notarius/internal/modules/dnd/extract/locationoccurrences/extractor.go

// Package locationoccurrences extracts source-grounded D&D location occurrences.
package locationoccurrences

import (
	"context"
	"fmt"
	"sort"

	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
	locationregistry "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/locations/registry"
	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared"
)

const (
	Key           = "dnd/location-occurrences"
	mappingPolicy = "dnd.location_occurrences.extract_mapping.v2"
)

const (
	LocationRegistryReferenceSlot = locationregistry.ReferenceSlot
	LocationRegistryMaxBytes      = locationregistry.MaxBytes
)

var requiredCapabilities = []string{"chunks", "source.transcript"}
var providedCapabilities = []string{"dnd.location_occurrences"}

var referenceSlotDescriptions = shared.ReferenceSlotDescriptions{
	Glossary: "Optional campaign glossary reference material used only for location-occurrence disambiguation.",
	Party:    "Optional party roster reference material used only for location-occurrence disambiguation.",
	Players:  "Optional player list reference material used only for location-occurrence disambiguation.",
	Roster:   "Deprecated alias for party roster reference material used only for location-occurrence disambiguation.",
}

func referenceSlots() []contracts.ReferenceSlot {
	slots := shared.ReferenceSlots(referenceSlotDescriptions)
	slots = append(slots, contracts.ReferenceSlot{
		Name:                  LocationRegistryReferenceSlot,
		Description:           "Required normalized location registry used only for location identity grounding, never as occurrence evidence.",
		Required:              true,
		AcceptedMediaTypes:    []string{"application/json"},
		AcceptedArtifactKinds: []contracts.ArtifactKind{dnd.LocationRegistryKind},
		MaxBytes:              LocationRegistryMaxBytes,
	})
	sort.Slice(slots, func(left, right int) bool { return slots[left].Name < slots[right].Name })
	return slots
}

var _ contracts.Extractor[dnd.LocationOccurrenceList] = (*Extractor)(nil)
var _ contracts.ManifestMetadataProvider = (*Extractor)(nil)
var _ pipeline.CheckpointFingerprintProvider = (*Extractor)(nil)

type Options struct{}

type Extractor struct {
	llm               contracts.StructuredLLMClient
	locationResolver  *locationregistry.Resolver
	promptSHA         string
	responseSchemaSHA string
}

func New(llmClient contracts.StructuredLLMClient, _ Options, references ...contracts.ReferenceSet) (*Extractor, error) {
	if llmClient == nil {
		return nil, extractorErrorf("LLM client must not be nil")
	}
	if len(references) > 1 {
		return nil, extractorErrorf("at most one reference set may be supplied")
	}
	var referenceSet contracts.ReferenceSet
	if len(references) == 1 {
		referenceSet = references[0]
	}
	locationResolver, err := locationregistry.NewResolver(referenceSet)
	if err != nil {
		return nil, extractorErrorf("prepare location registry prompt input: %w", err)
	}
	promptSHA, err := promptAssetMetadata()
	if err != nil {
		return nil, extractorErrorf("load prompt metadata: %w", err)
	}
	responseSchema, err := loadResponseSchema()
	if err != nil {
		return nil, extractorErrorf("load response schema: %w", err)
	}
	return &Extractor{llm: llmClient, locationResolver: locationResolver, promptSHA: promptSHA, responseSchemaSHA: responseSchema.SHA256}, nil
}

func (e *Extractor) Key() string { return Key }

func (e *Extractor) ReferenceSlots() []contracts.ReferenceSlot { return referenceSlots() }

func (e *Extractor) ManifestMetadata() map[string]any {
	if e == nil {
		return nil
	}
	metadata := map[string]any{
		"prompt_id":               PromptID,
		"prompt_version":          SchemaVersion,
		"prompt_sha256":           e.promptSHA,
		"mapping_policy":          mappingPolicy,
		"response_schema_key":     string(ResponseSchemaKey),
		"response_schema_id":      ResponseSchemaID,
		"response_schema_name":    ResponseSchemaName,
		"response_schema_version": SchemaVersion,
		"response_schema_sha256":  e.responseSchemaSHA,
	}
	seeded := e.locationResolver.Seeded()
	if seeded.Bound() {
		metadata["location_registry_digest"] = seeded.Digest()
		metadata["location_count"] = seeded.Count()
	}
	return metadata
}

func (e *Extractor) CheckpointFingerprints() []pipeline.CheckpointFingerprint {
	if e == nil {
		return nil
	}
	return []pipeline.CheckpointFingerprint{
		{Name: "prompt", Value: e.promptSHA},
		{Name: "response_schema", Value: e.responseSchemaSHA},
		{Name: "mapping_policy", Value: mappingPolicy},
		{Name: "location_registry", Value: e.locationResolver.Seeded().IdentityDigest()},
	}
}

func (e *Extractor) Extract(ctx context.Context, req contracts.TypedExtractionRequest) (contracts.TypedExtractionResult[dnd.LocationOccurrenceList], error) {
	if e == nil {
		return contracts.TypedExtractionResult[dnd.LocationOccurrenceList]{}, extractorErrorf("extractor must not be nil")
	}
	if e.llm == nil {
		return contracts.TypedExtractionResult[dnd.LocationOccurrenceList]{}, extractorErrorf("LLM client must not be nil")
	}
	sourceInput, err := shared.PrepareChunkExtraction(ctx, req)
	if err != nil {
		return contracts.TypedExtractionResult[dnd.LocationOccurrenceList]{}, extractorErrorf("%w", err)
	}
	registry, err := e.locationResolver.Resolve(req.References)
	if err != nil {
		return contracts.TypedExtractionResult[dnd.LocationOccurrenceList]{}, extractorErrorf("resolve location registry: %w", err)
	}
	if !registry.Bound() {
		return contracts.TypedExtractionResult[dnd.LocationOccurrenceList]{}, extractorErrorf("location registry reference is required")
	}
	grounding, err := locationregistry.NewGrounding(registry, req.Source)
	if err != nil {
		return contracts.TypedExtractionResult[dnd.LocationOccurrenceList]{}, extractorErrorf("prepare location grounding: %w", err)
	}

	var response extractionResponse
	inputs := shared.PromptInputs(sourceInput, req.References)
	inputs[LocationRegistryReferenceSlot] = grounding.PromptInput()
	if _, err := e.llm.CompleteStructured(ctx, contracts.StructuredCompletionRequest{
		StageName: Key, PromptID: PromptID, PromptVersion: SchemaVersion,
		ProfileID: req.LLMProfile, SessionID: req.SessionID, Inputs: inputs,
	}, &response); err != nil {
		return contracts.TypedExtractionResult[dnd.LocationOccurrenceList]{}, extractorErrorf("complete structured output: %w", err)
	}
	occurrences, err := canonicalOccurrenceList(response, shared.NewSourceRefOrder(req.Source), req.Source.ID, grounding)
	if err != nil {
		return contracts.TypedExtractionResult[dnd.LocationOccurrenceList]{}, extractorErrorf("resolve location grounding: %w", err)
	}
	return contracts.TypedExtractionResult[dnd.LocationOccurrenceList]{Value: occurrences}, nil
}

func ModuleSpec() pipeline.ModuleSpec {
	return pipeline.ModuleSpec{
		Key: Key, Stage: pipeline.StageExtract, ExecutionClass: contracts.ExecutionClassLLMBacked,
		Requires: append([]string(nil), requiredCapabilities...), Provides: append([]string(nil), providedCapabilities...),
		ArtifactKind: dnd.LocationOccurrenceListKind, ReferenceSlots: referenceSlots(),
	}
}

func Register(registry *pipeline.ExtractorRegistry) error {
	return pipeline.RegisterExtractorBuilder(registry, ModuleSpec(), validateOptions, func(request pipeline.BuildRequest) (contracts.Extractor[dnd.LocationOccurrenceList], error) {
		options, err := DecodeOptions(request.Options)
		if err != nil {
			return nil, err
		}
		return New(request.Dependencies.LLM, options, request.References)
	})
}

func validateOptions(options map[string]any) error { _, err := DecodeOptions(options); return err }

func DecodeOptions(options map[string]any) (Options, error) {
	if err := pipeline.RejectUnknownOptions(options); err != nil {
		return Options{}, extractorErrorf("%w", err)
	}
	return Options{}, nil
}

func extractorErrorf(format string, args ...any) error {
	return fmt.Errorf("dnd location occurrences extractor: "+format, args...)
}