package integration_test import ( "context" "encoding/json" "fmt" "reflect" "sync" "testing" "gitea.maximumdirect.net/eric/notarius/internal/core/config" "gitea.maximumdirect.net/eric/notarius/internal/core/source" "gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline" occurrencecodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/npcoccurrences" npccodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/npcregistry" "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/identity" "go.maximumdirect.net/promptkit" ) func TestNPCOccurrencePipelineUsesAcceptedRegistryAndCurrentEvidence(t *testing.T) { registries := productionNPCRegistries(t) resolved := resolveNPCOccurrencePipeline(t, registries) client := &npcOccurrenceLLMClient{} output, err := runPreparedPipeline(t, registries, resolved, client, pipeline.RunInput{RawInput: readNPCFixture(t)}) if err != nil { t.Fatalf("Run() error = %v", err) } if len(output.OutputFiles) != 2 { t.Fatalf("output files = %#v, want registry and occurrences", output.OutputFiles) } request := client.requestFor(t, "occurrences") wantRegistry := `{"npcs":[{"name":"Mira Thorn"},{"name":"Hooded Guard"}]}` registryInput, err := nativeJSONInput(request, "npcs") if err != nil { t.Fatal(err) } if string(registryInput) != wantRegistry { t.Fatalf("occurrence registry = %s, want names-only projection %s", registryInput, wantRegistry) } serialized := publishedLane(t, output, "occurrences") occurrences, err := occurrencecodec.New().Decode(serialized.Bytes) if err != nil { t.Fatalf("Decode(occurrence output) error = %v", err) } if len(occurrences.Occurrences) != 2 { t.Fatalf("occurrences = %#v, want two occurrences", occurrences) } first, second := occurrences.Occurrences[0], occurrences.Occurrences[1] if first.Name != "Mira Thorn" || string(first.Kind) != "dialogue" || second.Name != "Hooded Guard" || string(second.Kind) != "noncombat_presence" { t.Fatalf("occurrences = %#v, want canonical names, kinds, and source chronology", occurrences) } if first.NPCID != identity.DeriveID("Mira Thorn") || second.NPCID != identity.DeriveID("Hooded Guard") { t.Fatalf("occurrences = %#v, want durable registry IDs", occurrences) } assertOccurrenceEvidence(t, first.SourceRefs) assertOccurrenceEvidence(t, second.SourceRefs) if first.SourceRefs[0].StartUnitID >= second.SourceRefs[0].StartUnitID { t.Fatalf("occurrence chronology = %#v, want source order", occurrences.Occurrences) } var durable map[string]json.RawMessage if err := json.Unmarshal(serialized.Bytes, &durable); err != nil { t.Fatalf("unmarshal durable occurrence payload: %v", err) } if len(durable) != 1 || durable["occurrences"] == nil { t.Fatalf("durable occurrence payload = %#v, want only occurrences", durable) } } func TestSemanticNPCNormalizationCrossesOrderedRegistryHandoff(t *testing.T) { registries := productionNPCRegistries(t) cfg := loadNPCOccurrencePipelineConfig(t) profile := cfg.Pipelines["dnd-npc-occurrences-fixture"] profile.Chunk = pipeline.ModuleBinding{Module: "generic", Options: map[string]any{"max_units": 1}} cfg.Pipelines["dnd-npc-occurrences-fixture"] = profile effective, err := cfg.Resolve(config.ResolveInput{PipelineID: "dnd-npc-occurrences-fixture", Catalog: moduleCatalog(registries)}) if err != nil { t.Fatal(err) } resolved, warnings, err := pipeline.MaterializeReferences(effective.ResolvedPipeline, moduleCatalog(registries), pipeline.ReferenceMaterializationOptions{}) if err != nil || len(warnings) != 0 { t.Fatalf("MaterializeReferences() error = %v warnings = %#v", err, warnings) } client := &semanticNPCOccurrenceClient{} raw := []byte(`{"metadata":{"id":"semantic-session","title":"Semantic NPC session"},"segments":[{"id":1,"start":0,"end":1,"speaker":"DM","text":"Mira Thorn enters."},{"id":2,"start":1,"end":2,"speaker":"DM","text":"Mira Thorn, the Greencloak, waves."}]}`) output, err := runPreparedPipeline(t, registries, resolved, client, pipeline.RunInput{RawInput: raw}) if err != nil { t.Fatalf("Run() error = %v", err) } if client.requestCount("npcs") != 2 || client.requestCount("duplicate_groups") != 1 { t.Fatalf("prompt requests = %#v, want two extraction calls and one document normalization call", client.requests) } npcOutput := publishedLane(t, output, "npc_registry") npcsValue, err := npccodec.New().Decode(npcOutput.Bytes) if err != nil { t.Fatal(err) } if len(npcsValue.NPCs) != 1 || npcsValue.NPCs[0].Name != "Mira Thorn" || npcsValue.NPCs[0].ID != identity.DeriveID("Mira Thorn") { t.Fatalf("NPC output = %#v / %#v, want canonical ordered producer artifact", npcOutput, npcsValue) } if refs := npcsValue.NPCs[0].SourceRefs; !reflect.DeepEqual(refs, []source.SourceRef{{SourceID: "semantic-session", StartUnitID: 1, EndUnitID: 1}, {SourceID: "semantic-session", StartUnitID: 2, EndUnitID: 2}}) { t.Fatalf("NPC evidence = %#v, want original extraction evidence union", refs) } registryRequest := client.requestFor(t, "occurrences") registryInput, err := nativeJSONInput(registryRequest, "npcs") if err != nil || string(registryInput) != `{"npcs":[{"name":"Mira Thorn"}]}` { t.Fatalf("downstream registry = %s, error=%v", registryInput, err) } occurrences, err := occurrencecodec.New().Decode(publishedLane(t, output, "occurrences").Bytes) if err != nil || len(occurrences.Occurrences) != 2 { t.Fatalf("downstream occurrences=%#v error=%v, want both chunks", occurrences, err) } for index, occurrence := range occurrences.Occurrences { wantRef := source.SourceRef{SourceID: "semantic-session", StartUnitID: index + 1, EndUnitID: index + 1} if occurrence.Name != "Mira Thorn" || occurrence.NPCID != npcsValue.NPCs[0].ID || !reflect.DeepEqual(occurrence.SourceRefs, []source.SourceRef{wantRef}) { t.Fatalf("occurrence=%#v, want canonical identity and current chunk evidence %#v", occurrence, wantRef) } } } func TestNPCOccurrencePipelineSkipsConsumerWhenNPCProducerIsRejected(t *testing.T) { registries := productionNPCRegistries(t) resolved := resolveNPCOccurrencePipeline(t, registries) client := &npcOccurrenceLLMClient{rejectNPCs: true} resolved.Steps[0].ArtifactLanes[0].ExtractControls.MaxAdditionalTurns = 0 output, err := runPreparedPipeline(t, registries, resolved, client, pipeline.RunInput{RawInput: readNPCFixture(t)}) if err == nil { t.Fatalf("Run() output = %#v, want missing generated NPC producer error", output) } if client.requestCount("npcs") != 1 { t.Fatalf("NPC requests = %d, want rejected producer", client.requestCount("npcs")) } if client.requestCount("occurrences") != 0 { t.Fatalf("occurrence requests = %d, want none after rejected producer", client.requestCount("occurrences")) } } func resolveNPCOccurrencePipeline(t *testing.T, registries pipeline.Registries) pipeline.ResolvedPipeline { t.Helper() configValue := loadNPCOccurrencePipelineConfig(t) effective, err := configValue.Resolve(config.ResolveInput{PipelineID: "dnd-npc-occurrences-fixture", Catalog: moduleCatalog(registries)}) if err != nil { t.Fatalf("Resolve() error = %v", err) } resolved, warnings, err := pipeline.MaterializeReferences(effective.ResolvedPipeline, moduleCatalog(registries), pipeline.ReferenceMaterializationOptions{}) if err != nil || len(warnings) != 0 { t.Fatalf("MaterializeReferences() error = %v warnings = %#v", err, warnings) } return resolved } func loadNPCOccurrencePipelineConfig(t *testing.T) config.Config { t.Helper() return loadIntegrationConfig(t, "testdata/dnd_npc_occurrences_pipeline.yml") } func assertOccurrenceEvidence(t *testing.T, references []source.SourceRef) { t.Helper() if len(references) == 0 { t.Fatal("occurrence has no current-source evidence") } for _, reference := range references { if reference.SourceID != "npc-session" { t.Fatalf("occurrence evidence = %#v, want current source only", reference) } } } type npcOccurrenceLLMClient struct { mu sync.Mutex requests []promptkit.GenerateRequest rejectNPCs bool } func (client *npcOccurrenceLLMClient) Generate(ctx context.Context, request promptkit.GenerateRequest) (*promptkit.GenerateResponse, error) { if err := ctx.Err(); err != nil { return nil, err } client.mu.Lock() client.requests = append(client.requests, request) client.mu.Unlock() var payload any switch { case nativeSchemaHasProperty(request, "npcs"): if client.rejectNPCs { payload = map[string]any{"npcs": []any{map[string]any{ "name": "", "source_refs": []any{map[string]int{"start_unit_id": 1, "end_unit_id": 1}}, }}} } else { payload = map[string]any{"npcs": []any{ map[string]any{"name": "Mira Thorn", "source_refs": []any{map[string]int{"start_unit_id": 1, "end_unit_id": 1}}}, map[string]any{"name": "Hooded Guard", "source_refs": []any{map[string]int{"start_unit_id": 3, "end_unit_id": 3}}}, }} } case nativeSchemaHasProperty(request, "duplicate_groups"): payload = map[string]any{"duplicate_groups": []any{}} case nativeSchemaHasProperty(request, "occurrences"): payload = map[string]any{"occurrences": []any{ map[string]any{"name": "Hooded Guard", "kind": "noncombat_presence", "source_refs": []any{map[string]int{"start_unit_id": 3, "end_unit_id": 3}}}, map[string]any{"name": "Mira Thorn", "kind": "dialogue", "source_refs": []any{map[string]int{"start_unit_id": 2, "end_unit_id": 2}}}, }} default: return nil, fmt.Errorf("unexpected native occurrence response contract") } content, err := json.Marshal(payload) if err != nil { return nil, err } return &promptkit.GenerateResponse{Content: string(content)}, nil } func (client *npcOccurrenceLLMClient) requestFor(t *testing.T, property string) promptkit.GenerateRequest { t.Helper() client.mu.Lock() defer client.mu.Unlock() for _, request := range client.requests { if nativeSchemaHasProperty(request, property) { return request } } t.Fatalf("requests = %#v, missing prompt %q", client.requests, property) return promptkit.GenerateRequest{} } func (client *npcOccurrenceLLMClient) requestCount(property string) int { client.mu.Lock() defer client.mu.Unlock() count := 0 for _, request := range client.requests { if nativeSchemaHasProperty(request, property) { count++ } } return count } var _ promptkit.LLMClient = (*npcOccurrenceLLMClient)(nil) type semanticNPCOccurrenceClient struct { mu sync.Mutex requests []promptkit.GenerateRequest } func (client *semanticNPCOccurrenceClient) Generate(ctx context.Context, request promptkit.GenerateRequest) (*promptkit.GenerateResponse, error) { client.mu.Lock() defer client.mu.Unlock() if err := ctx.Err(); err != nil { return nil, err } client.requests = append(client.requests, request) var payload any var unitID int if nativeSchemaHasProperty(request, "npcs") || nativeSchemaHasProperty(request, "occurrences") { content, err := nativeJSONInput(request, "units") if err != nil { return nil, err } var document struct { Units []struct { ID int `json:"id"` } `json:"units"` } if err := json.Unmarshal(content, &document); err != nil { return nil, err } if len(document.Units) != 1 || document.Units[0].ID <= 0 { return nil, fmt.Errorf("semantic fixture requires one source-addressed unit: %s", content) } unitID = document.Units[0].ID } switch { case nativeSchemaHasProperty(request, "npcs"): name := "Mira Thorn" if unitID == 2 { name = "Mira Thorn, the Greencloak" } payload = map[string]any{"npcs": []any{map[string]any{"name": name, "source_refs": []any{map[string]int{"start_unit_id": unitID, "end_unit_id": unitID}}}}} case nativeSchemaHasProperty(request, "duplicate_groups"): content := []byte(`{"duplicate_groups":[{"candidate_numbers":[1,2],"canonical_candidate_number":1}]}`) return &promptkit.GenerateResponse{Content: string(content)}, nil case nativeSchemaHasProperty(request, "occurrences"): payload = map[string]any{"occurrences": []any{map[string]any{"name": "Mira Thorn", "kind": "dialogue", "source_refs": []any{map[string]int{"start_unit_id": unitID, "end_unit_id": unitID}}}}} default: return nil, fmt.Errorf("unexpected native occurrence response contract") } content, err := json.Marshal(payload) if err != nil { return nil, err } return &promptkit.GenerateResponse{Content: string(content)}, nil } func (client *semanticNPCOccurrenceClient) requestCount(property string) int { count := 0 for _, request := range client.requests { if nativeSchemaHasProperty(request, property) { count++ } } return count } func (client *semanticNPCOccurrenceClient) requestFor(t *testing.T, property string) promptkit.GenerateRequest { t.Helper() for _, request := range client.requests { if nativeSchemaHasProperty(request, property) { return request } } t.Fatalf("requests = %#v, missing %q", client.requests, property) return promptkit.GenerateRequest{} } var _ promptkit.LLMClient = (*semanticNPCOccurrenceClient)(nil)