Detach schemas without provider value limits

internal/usecase/prepared_execution.go

@@ -249,16 +249,8 @@ func clonePreparedRun(source *domain.PreparedRun) (*domain.PreparedRun, error) {
 		if source.StructuredOutput.JSONSchema != nil {
 			jsonSchema := *source.StructuredOutput.JSONSchema
 			copied.StructuredOutput.JSONSchema = &jsonSchema
-			schema, copyErr := cloneJSONValue(source.StructuredOutput.JSONSchema.Schema)
-			if copyErr != nil {
-				return nil, copyErr
-			}
-			copied.StructuredOutput.JSONSchema.Schema = schema
+			copied.StructuredOutput.JSONSchema.Schema = jsonvalue.CloneTrusted(source.StructuredOutput.JSONSchema.Schema)
 		}
 	}
 	return &copied, nil
 }
-
-func cloneJSONValue(source any) (any, error) {
-	return jsonvalue.Copy(source)
-}

internal/usecase/prepared_execution_test.go

@@ -171,75 +171,32 @@ func TestRunnerPrepareExecutionCompletesWithoutAdmissionOrGeneration(t *testing.
 	}
 }
 
-func TestRunnerPreparationRejectsExcessivelyDeepPreparedSchema(t *testing.T) {
-	operations := []struct {
-		name string
-		run  func(*Runner, domain.RunRequest) error
-	}{
-		{
-			name: "Prepare",
-			run: func(runner *Runner, request domain.RunRequest) error {
-				_, err := runner.Prepare(context.Background(), request)
-				return err
-			},
-		},
-		{
-			name: "Run",
-			run: func(runner *Runner, request domain.RunRequest) error {
-				_, err := runner.Run(context.Background(), request)
-				return err
-			},
-		},
-		{
-			name: "PrepareExecution",
-			run: func(runner *Runner, request domain.RunRequest) error {
-				_, err := runner.PrepareExecution(context.Background(), request)
-				return err
-			},
-		},
+func TestRunnerPreparationDetachesDeepPreparedSchema(t *testing.T) {
+	var nested any = "original"
+	for range 150 {
+		nested = map[string]any{"child": nested}
 	}
-
-	for _, operation := range operations {
-		t.Run(operation.name, func(t *testing.T) {
-			def := promptDef(domain.FormatJSON, domain.ValidationJSONSchema, 0)
-			def.Validation.SchemaPath = "schema.json"
-			llmClient := &fakeLLM{forbid: true}
-			validator := &recordingValidationPreparer{
-				plan: &recordingPreparedValidation{schemaDocument: excessivelyDeepPreparedJSONValue()},
-			}
-			runner := NewRunner(
-				&fakePromptRepo{def: def},
-				&fakeExecutionProfileRepo{profiles: map[string]*domain.ExecutionProfile{"exec": defaultExecutionProfile()}},
-
-				defaultArtifactReader(),
-				defaultRenderer(),
-				llmClient,
-				validator,
-				nil,
-			)
-
-			err := operation.run(runner, domain.RunRequest{
-				PromptID:  "p",
-				ProfileID: "exec",
-				Inputs:    singleInputRef(),
-			})
-			if !errors.Is(err, ErrValidation) {
-				t.Fatalf("expected ErrValidation, got %v", err)
-			}
-			if llmClient.calls != 0 {
-				t.Fatalf("invalid prepared schema reached generation: %d calls", llmClient.calls)
-			}
-		})
+	schema := map[string]any{"annotation": nested}
+	def := promptDef(domain.FormatJSON, domain.ValidationJSONSchema, 0)
+	def.Validation.SchemaPath = "schema.json"
+	validator := &recordingValidationPreparer{plan: &recordingPreparedValidation{schemaDocument: schema}}
+	runner := NewRunner(&fakePromptRepo{def: def},
+		&fakeExecutionProfileRepo{profiles: map[string]*domain.ExecutionProfile{"exec": defaultExecutionProfile()}},
+		defaultArtifactReader(), defaultRenderer(), &fakeLLM{forbid: true}, validator, nil)
+	prepared, err := runner.PrepareExecution(context.Background(), domain.RunRequest{PromptID: "p", ProfileID: "exec", Inputs: singleInputRef()})
+	if err != nil {
+		t.Fatalf("prepare execution: %v", err)
 	}
-}
-
-func excessivelyDeepPreparedJSONValue() any {
-	const clearlyUnsafeContainerDepth = 1_000
-	var value any = true
-	for level := 0; level < clearlyUnsafeContainerDepth; level++ {
-		value = map[string]any{"child": value}
+	schema["annotation"].(map[string]any)["child"] = "source mutation"
+	first := prepared.Details().StructuredOutput.JSONSchema.Schema.(map[string]any)
+	if _, ok := first["annotation"].(map[string]any)["child"].(map[string]any); !ok {
+		t.Fatal("prepared schema aliases the validator document")
+	}
+	first["annotation"].(map[string]any)["child"] = "caller mutation"
+	second := prepared.Details().StructuredOutput.JSONSchema.Schema.(map[string]any)
+	if _, ok := second["annotation"].(map[string]any)["child"].(map[string]any); !ok {
+		t.Fatal("prepared schema details share mutable storage")
 	}
-	return value
 }
 
 func TestRunnerRunPreparedCredentialAvailabilityBeforeAdmission(t *testing.T) {

internal/usecase/runner.go

@@ -435,11 +435,7 @@ func (r *Runner) structuredOutputFromValidationPlan(
 		}
 		return nil, fmt.Errorf("%w: prepared json_schema validation has no schema document", ErrValidation)
 	}
-	schemaDocument, err := jsonvalue.Copy(schemaDocument)
-	if err != nil {
-		return nil, fmt.Errorf("%w: invalid prepared json_schema schema document: %v", ErrValidation, err)
-	}
-	return structuredOutputSpec(def, schemaDocument), nil
+	return structuredOutputSpec(def, jsonvalue.CloneTrusted(schemaDocument)), nil
 }
 
 func (r *Runner) completePreparationWithStructuredOutput(