package combat_semantics import ( "context" "encoding/json" "errors" "strings" "go.maximumdirect.net/promptkit" "gitea.maximumdirect.net/eric/notarius/internal/core/source" "gitea.maximumdirect.net/eric/notarius/internal/framework/contracts" "gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline" "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd" "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared" "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/scenedescriptions/shape" ) const Key = "extract/dnd/scene-descriptions/combat_semantics" const PromptID = "notarius/dnd.scene_descriptions.validate_combat" type Options struct{} type Validator struct{ engine *promptkit.Engine } var _ contracts.TypedValidator[dnd.SceneDescriptionList] = (*Validator)(nil) func New(engine *promptkit.Engine, _ Options) (*Validator, error) { if engine == nil { return nil, validatorErrorf("native engine must not be nil") } return &Validator{engine: engine}, nil } func (v *Validator) Name() string { return Key } func (v *Validator) ExecutionClass() contracts.ExecutionClass { return contracts.ExecutionClassLLMBacked } func (v *Validator) Validate(ctx context.Context, req contracts.TypedValidationRequest[dnd.SceneDescriptionList]) (contracts.ValidationResult, error) { if v == nil { return contracts.ValidationResult{}, validatorErrorf("validator must not be nil") } if v.engine == nil { return contracts.ValidationResult{}, validatorErrorf("native engine must not be nil") } sourceInput, scene, err := validateRequest(ctx, req) if err != nil { return contracts.ValidationResult{}, err } material := shared.TranscriptPromptMaterial(sourceInput) request, capture := pipeline.CaptureNativeRequest(promptkit.RunRequest{ PromptID: PromptID, ProfileID: req.LLMProfile, SessionID: req.SessionID, Inputs: map[string]promptkit.ArtifactRef{"transcript": promptkit.InlineWithURI(material.OriginURI, string(material.Content))}, Execution: req.Execution.Execution, TransientRetries: req.Execution.TransientRetries, Observer: req.Execution.Observer, OnPrepared: req.Execution.OnPrepared, }, req.Execution.Capture) if err := capture.Err(); err != nil { return contracts.ValidationResult{}, err } result, err := v.engine.Run(ctx, request) if captureErr := capture.Finish(result, err, ctx.Err() != nil, false); captureErr != nil { return contracts.ValidationResult{}, errors.Join(ctx.Err(), err, captureErr) } if canceled := ctx.Err(); canceled != nil { return contracts.ValidationResult{}, canceled } if err != nil { return contracts.ValidationResult{}, unavailable(err) } if result == nil || result.Validation.Status == promptkit.ValidationFailed || !result.Validation.IsValid { return contracts.ValidationResult{}, unavailable(validatorErrorf("native output contract failed: %w", promptkit.ErrValidation)) } var response classificationResponse if err := json.Unmarshal([]byte(result.RawOutput), &response); err != nil { return contracts.ValidationResult{}, unavailable(validatorErrorf("decode native output: %w", err)) } assessment, err := interpretResponse(response, scene.Kind) if canceled := ctx.Err(); canceled != nil { return contracts.ValidationResult{}, canceled } if err != nil { return contracts.ValidationResult{}, unavailable(err) } return assessment, nil } func validateRequest(ctx context.Context, req contracts.TypedValidationRequest[dnd.SceneDescriptionList]) (contracts.LLMInputMaterial, dnd.SceneDescription, error) { if ctx == nil { return contracts.LLMInputMaterial{}, dnd.SceneDescription{}, validatorErrorf("context must not be nil") } if err := ctx.Err(); err != nil { return contracts.LLMInputMaterial{}, dnd.SceneDescription{}, validatorErrorf("context error before validation: %w", err) } if req.Stage != string(pipeline.StageExtract) { return contracts.LLMInputMaterial{}, dnd.SceneDescription{}, validatorErrorf("validation stage must be extract, got %q", req.Stage) } sourceInput, err := shared.PrepareChunkExtraction(ctx, contracts.TypedExtractionRequest[dnd.SceneDescriptionList]{Source: req.Source, Chunk: req.Chunk, SourceInput: req.SourceInput}) if err != nil { return contracts.LLMInputMaterial{}, dnd.SceneDescription{}, validatorErrorf("prepare chunk source input: %w", err) } if strings.TrimSpace(req.Chunk.ID) == "" || req.Chunk.ID != strings.TrimSpace(req.Chunk.ID) { return contracts.LLMInputMaterial{}, dnd.SceneDescription{}, validatorErrorf("current chunk ID must be nonblank and trimmed") } if req.Chunk.SourceID != req.Source.ID { return contracts.LLMInputMaterial{}, dnd.SceneDescription{}, validatorErrorf("current chunk source ID %q does not match source %q", req.Chunk.SourceID, req.Source.ID) } if err := source.NewDocumentIndex(req.Source).ValidateRef(req.Chunk.Ref); err != nil { return contracts.LLMInputMaterial{}, dnd.SceneDescription{}, validatorErrorf("validate current chunk source range: %w", err) } if err := shape.ValidateForStage(req.Value, req.Stage); err != nil { return contracts.LLMInputMaterial{}, dnd.SceneDescription{}, validatorErrorf("validate scene description shape: %w", err) } scene := req.Value.Scenes[0] if scene.ID != req.Chunk.ID { return contracts.LLMInputMaterial{}, dnd.SceneDescription{}, validatorErrorf("scene ID must equal current chunk ID") } if scene.SourceRef != req.Chunk.Ref { return contracts.LLMInputMaterial{}, dnd.SceneDescription{}, validatorErrorf("scene source range must equal current chunk range") } return sourceInput, scene, nil } func unavailable(cause error) error { return &contracts.ValidationUnavailableError{Cause: validatorErrorf("native assessment unavailable: %w", cause)} } func Spec() pipeline.ValidatorSpec { return pipeline.ValidatorSpec{Key: Key, ExecutionClass: contracts.ExecutionClassLLMBacked, Prompts: []string{PromptID}} } func Register(registry *pipeline.ValidatorRegistry) error { return pipeline.RegisterTypedValidatorBuilder(registry, dnd.SceneDescriptionListKind, Spec(), validateOptions, func(request pipeline.BuildRequest) (contracts.TypedValidator[dnd.SceneDescriptionList], error) { options, err := DecodeOptions(request.Options) if err != nil { return nil, err } return New(request.Dependencies.Engine, options) }) } func DecodeOptions(options map[string]any) (Options, error) { if err := pipeline.RejectUnknownOptions(options); err != nil { return Options{}, err } return Options{}, nil } func validateOptions(options map[string]any) error { _, err := DecodeOptions(options); return err }