package promptkit_test import ( "context" "encoding/json" "errors" "fmt" "io" "net/http" "os" "path/filepath" "strings" "testing" "github.com/santhosh-tekuri/jsonschema/v6" "go.maximumdirect.net/configkit" "go.maximumdirect.net/promptkit" ) type rejectWireSchemaLoad struct{} func (rejectWireSchemaLoad) Load(uri string) (any, error) { return nil, fmt.Errorf("unexpected external resource %s", uri) } func TestSchemaFilePreparationAndNativeSubmission(t *testing.T) { secondDir := t.TempDir() second := filepath.Join(secondDir, "schema.json") if err := os.WriteFile(second, []byte(`{"$defs":{"value":{"type":"integer"}},"$ref":"#/$defs/value"}`), 0600); err != nil { t.Fatal(err) } input := configkit.Input{Source: configkit.Mapping("schema test", map[string]any{ "profiles": []any{map[string]any{"id": "profile", "endpoint": "https://example.invalid/v1", "model": "model"}}, "prompts": []any{map[string]any{"id": "prompt", "default_profile": "profile", "messages": []any{map[string]any{"role": "user", "content": "hello"}}, "output": map[string]any{"format": "json", "validation_mode": "json_schema", "schema_file": "schema.json"}}}, })} filesystem := configkit.NewFilesystem("schema", os.DirFS(secondDir)) input.Filesystem = &configkit.FilesystemContext{FS: &filesystem, Root: ".", BaseDir: "."} var payload map[string]any client := &http.Client{Transport: roundTripFunc(func(request *http.Request) (*http.Response, error) { if err := json.NewDecoder(request.Body).Decode(&payload); err != nil { t.Fatal(err) } return &http.Response{StatusCode: 200, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(`{"choices":[{"message":{"content":"3"}}]}`))}, nil })} engine, err := promptkit.NewEngine(promptkit.Config{HTTPClient: client, Sources: promptkit.ConfigurationSources{Main: &input}}) if err != nil { t.Fatal(err) } if err := engine.ValidateRequest(context.Background(), promptkit.RunRequest{PromptID: "prompt"}); err != nil { t.Fatalf("validate request: %v", err) } inspected, err := engine.InspectPrompt(context.Background(), "prompt") if err != nil || inspected.OutputContract.SchemaFile == nil || *inspected.OutputContract.SchemaFile != "schema.json" { t.Fatalf("schema reference inspection = %+v, %v", inspected, err) } prepared, err := engine.PrepareExecution(context.Background(), promptkit.RunRequest{PromptID: "prompt"}) if err != nil || prepared.Details().StructuredOutput == nil { t.Fatalf("prepared = %+v, %v", prepared, err) } if contract := prepared.Details().OutputContract; contract.Schema != nil || contract.SchemaPath != "" { t.Fatalf("source-relative public contract = %+v", contract) } if err := os.Remove(second); err != nil { t.Fatal(err) } result, err := engine.RunPrepared(context.Background(), prepared) if err != nil || result.Validation.Status != promptkit.ValidationPassed || result.Validation.SchemaPath != "" { t.Fatalf("run = %+v, %v", result, err) } encoded, err := json.Marshal(payload["response_format"]) if err != nil || !strings.Contains(string(encoded), `"$defs"`) || !strings.Contains(string(encoded), `#/$defs/value`) { t.Fatalf("wire schema = %s, %v", encoded, err) } compiler := jsonschema.NewCompiler() compiler.UseLoader(rejectWireSchemaLoad{}) const submission = "https://provider.invalid/request-schema" document := payload["response_format"].(map[string]any)["json_schema"].(map[string]any)["schema"] if err := compiler.AddResource(submission, document); err != nil { t.Fatal(err) } if _, err := compiler.Compile(submission); err != nil { t.Fatalf("outbound schema needs local source context: %v", err) } if _, err := engine.PrepareExecution(context.Background(), promptkit.RunRequest{PromptID: "prompt"}); !errors.Is(err, promptkit.ErrValidation) { t.Fatalf("missing root error = %v", err) } } func TestSchemaFilePreparationDetachesLargeAnnotation(t *testing.T) { // Annotation values are not constraints; this array exceeds the former // provider-value copier node limit without requiring a large fixture file. const entries = 100_001 path := filepath.Join(t.TempDir(), "schema.json") schema := `{"type":"string","examples":[` + strings.Repeat(`0,`, entries-1) + `0]}` if err := os.WriteFile(path, []byte(schema), 0o600); err != nil { t.Fatal(err) } input := configkit.Input{Source: configkit.Mapping("schema test", map[string]any{ "profiles": []any{map[string]any{"id": "profile", "endpoint": "https://example.invalid/v1", "model": "model"}}, "prompts": []any{map[string]any{"id": "prompt", "default_profile": "profile", "messages": []any{map[string]any{"role": "user", "content": "hello"}}, "output": map[string]any{"format": "json", "validation_mode": "json_schema", "schema_file": "schema.json"}}}, })} filesystem := configkit.NewFilesystem("schema", os.DirFS(filepath.Dir(path))) input.Filesystem = &configkit.FilesystemContext{FS: &filesystem, Root: ".", BaseDir: "."} engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{Main: &input}}) if err != nil { t.Fatal(err) } prepared, err := engine.PrepareExecution(context.Background(), promptkit.RunRequest{PromptID: "prompt"}) if err != nil { t.Fatalf("prepare large schema: %v", err) } first := prepared.Details().StructuredOutput.JSONSchema.Schema.(map[string]any) examples := first["examples"].([]any) if len(examples) != entries { t.Fatalf("examples = %d, want %d", len(examples), entries) } examples[0] = "changed" second := prepared.Details().StructuredOutput.JSONSchema.Schema.(map[string]any) if _, ok := second["examples"].([]any)[0].(json.Number); !ok { t.Fatal("schema details share mutable annotation values") } } func TestSchemaFileRejectsInvalidSourcesAndExternalReferences(t *testing.T) { dir := t.TempDir() root := filepath.Join(dir, "schema.json") if err := os.WriteFile(root, []byte(`{"$defs":{"unused":{"$ref":"other.json"}}}`), 0600); err != nil { t.Fatal(err) } input := configkit.Input{Source: configkit.Mapping("schema test", map[string]any{ "profiles": []any{map[string]any{"id": "profile", "endpoint": "https://example.invalid/v1", "model": "model"}}, "prompts": []any{map[string]any{"id": "prompt", "default_profile": "profile", "messages": []any{map[string]any{"role": "user", "content": "hello"}}, "output": map[string]any{"format": "json", "validation_mode": "json_schema", "schema_file": "schema.json"}}}, })} filesystem := configkit.NewFilesystem("schema", os.DirFS(dir)) input.Filesystem = &configkit.FilesystemContext{FS: &filesystem, Root: ".", BaseDir: "."} calls := 0 client := &http.Client{Transport: roundTripFunc(func(*http.Request) (*http.Response, error) { calls++; return nil, errors.New("unexpected dispatch") })} engine, err := promptkit.NewEngine(promptkit.Config{HTTPClient: client, Sources: promptkit.ConfigurationSources{Main: &input}}) if err != nil { t.Fatal(err) } _, err = engine.Run(context.Background(), promptkit.RunRequest{PromptID: "prompt"}) if !errors.Is(err, promptkit.ErrValidation) || calls != 0 { t.Fatalf("external reference = %v, calls = %d", err, calls) } }