188 lines
6.9 KiB
Go
188 lines
6.9 KiB
Go
package combatturns
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"strings"
|
|
"testing"
|
|
|
|
"gitea.maximumdirect.net/eric/notarius/assets"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/core/source"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
|
|
npccodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/npcregistry"
|
|
scenecodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/scenedescriptions"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/identity"
|
|
"go.maximumdirect.net/configkit"
|
|
"go.maximumdirect.net/promptkit"
|
|
)
|
|
|
|
func extractionRequest(t *testing.T) contracts.TypedExtractionRequest[dnd.CombatTurnList] {
|
|
t.Helper()
|
|
doc := combatSourceDocument()
|
|
chunk := &source.Chunk{
|
|
ID: "session-alpha:chunk:0",
|
|
SourceID: doc.ID,
|
|
Index: 0,
|
|
Ref: source.SourceRef{SourceID: doc.ID, StartUnitID: 2, EndUnitID: 10},
|
|
Content: []byte(`{"units":[10,2]}`),
|
|
MediaType: "application/json",
|
|
Units: append([]source.SourceUnit(nil), doc.Units...),
|
|
}
|
|
request := contracts.TypedExtractionRequest[dnd.CombatTurnList]{
|
|
Source: doc,
|
|
Chunk: chunk,
|
|
SourceInput: contracts.NewLLMInputMaterial("source", chunk.MediaType, chunk.Content, "sha256:chunk", "file:///session-alpha.json"),
|
|
SessionID: "session-123",
|
|
LLMProfile: "profile-combat",
|
|
Operation: contracts.ProducerOperation[dnd.CombatTurnList]{Controls: contracts.ProducerControls{Mode: contracts.ModeStrict, Cache: contracts.CacheBypass}, ReuseEligible: true, Assess: func(context.Context, dnd.CombatTurnList) (contracts.CandidateAssessment, error) {
|
|
return contracts.CandidateAssessment{}, nil
|
|
}},
|
|
}
|
|
request.References = sceneReferences(t, chunk, dnd.SceneKindCombat)
|
|
return request
|
|
}
|
|
|
|
func combatSourceDocument() *source.SourceDocument {
|
|
return &source.SourceDocument{
|
|
ID: "session-alpha", Kind: "transcript", Format: "application/vnd.seriatim.minimal+json", Digest: "sha256:source",
|
|
Units: []source.SourceUnit{
|
|
{ID: 10, Kind: "transcript_segment", Text: "Aria reacts and strikes the ogre.", Ref: source.SourceRef{SourceID: "session-alpha", StartUnitID: 10, EndUnitID: 10}},
|
|
{ID: 2, Kind: "transcript_segment", Text: "Borin retreats from the ogre.", Ref: source.SourceRef{SourceID: "session-alpha", StartUnitID: 2, EndUnitID: 2}},
|
|
},
|
|
}
|
|
}
|
|
|
|
func mismatchedSourceInputRequest(req contracts.TypedExtractionRequest[dnd.CombatTurnList]) contracts.TypedExtractionRequest[dnd.CombatTurnList] {
|
|
req.SourceInput = contracts.NewLLMInputMaterial("source", "application/json", []byte(`{"other":true}`), "sha256:other", "")
|
|
return req
|
|
}
|
|
|
|
func newExtractor(t *testing.T, client promptkit.LLMClient, references ...contracts.ReferenceSet) *Extractor {
|
|
t.Helper()
|
|
type settings struct {
|
|
PromptKit promptkit.Settings `yaml:"promptkit"`
|
|
}
|
|
definition := promptkit.Configure(configkit.Definition[settings]{}, func(value *settings) *promptkit.Settings { return &value.PromptKit })
|
|
filesystem := configkit.NewFilesystem("Notarius assets", assets.FS())
|
|
result, err := configkit.LoadLayered(configkit.Input{Source: configkit.Bytes("occurrence fixture", []byte(`promptkit:
|
|
profiles:
|
|
- id: profile-combat
|
|
endpoint: https://example.invalid/v1
|
|
model: occurrence-test-model
|
|
api_key_required: false
|
|
`))}, configkit.LayeredOptions[settings]{Definition: definition, Underlays: []configkit.Underlay{
|
|
promptkit.BundledOpenRouterUnderlay(),
|
|
{Inputs: []configkit.Input{{Source: filesystem.File("notarius.yml"), Imports: true, Filesystem: &configkit.FilesystemContext{FS: &filesystem, Root: "."}}}},
|
|
}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
engine, err := promptkit.NewFromConfig(result, promptkit.RuntimeConfig{}, promptkit.WithLLMClient(client))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
extractor, err := New(engine, Options{}, references...)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return extractor
|
|
}
|
|
|
|
func renderedInput(t *testing.T, request promptkit.GenerateRequest, name string) []byte {
|
|
t.Helper()
|
|
key := map[string]string{"transcript": "units", "npc_registry": "npcs", "location_registry": "locations"}[name]
|
|
for _, message := range request.Prompt.Messages {
|
|
start := strings.Index(message.Content, "{")
|
|
if start < 0 {
|
|
continue
|
|
}
|
|
content := []byte(message.Content[start:])
|
|
var fields map[string]json.RawMessage
|
|
if json.Unmarshal(content, &fields) == nil && fields[key] != nil {
|
|
return bytes.TrimSpace(content)
|
|
}
|
|
}
|
|
t.Fatalf("missing rendered %s input", name)
|
|
return nil
|
|
}
|
|
|
|
type fakeCombatTurnsLLMClient struct {
|
|
response extractionResponse
|
|
responses []string
|
|
raw string
|
|
err error
|
|
errors []error
|
|
requests []promptkit.GenerateRequest
|
|
onGenerate func(context.Context, promptkit.GenerateRequest)
|
|
}
|
|
|
|
func (client *fakeCombatTurnsLLMClient) Generate(ctx context.Context, request promptkit.GenerateRequest) (*promptkit.GenerateResponse, error) {
|
|
index := len(client.requests)
|
|
client.requests = append(client.requests, request)
|
|
if client.onGenerate != nil {
|
|
client.onGenerate(ctx, request)
|
|
}
|
|
if err := ctx.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
if client.err != nil {
|
|
return nil, client.err
|
|
}
|
|
if index < len(client.errors) && client.errors[index] != nil {
|
|
return nil, client.errors[index]
|
|
}
|
|
content := client.raw
|
|
if index < len(client.responses) {
|
|
content = client.responses[index]
|
|
}
|
|
if content == "" {
|
|
encoded, err := json.Marshal(client.response)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
content = string(encoded)
|
|
}
|
|
return &promptkit.GenerateResponse{Content: content}, nil
|
|
}
|
|
|
|
func npcRegistryJSON(t *testing.T) []byte {
|
|
t.Helper()
|
|
value := dnd.NPCRegistry{NPCs: []dnd.NPC{{ID: identity.DeriveID("Mira Thorn"), Name: "Mira Thorn", SourceRefs: []source.SourceRef{{SourceID: "other-session", StartUnitID: 1, EndUnitID: 1}}}}}
|
|
content, err := npccodec.New().Encode(value)
|
|
if err != nil {
|
|
t.Fatalf("encode NPC registry: %v", err)
|
|
}
|
|
return content
|
|
}
|
|
|
|
func sceneReferences(t *testing.T, chunk *source.Chunk, kind dnd.SceneKind) contracts.ReferenceSet {
|
|
t.Helper()
|
|
return sceneListReferences(t, sceneDescription(chunk, kind))
|
|
}
|
|
|
|
func sceneListReferences(t *testing.T, scenes ...dnd.SceneDescription) contracts.ReferenceSet {
|
|
t.Helper()
|
|
content, err := scenecodec.New().Encode(dnd.SceneDescriptionList{Scenes: scenes})
|
|
if err != nil {
|
|
t.Fatalf("encode scene descriptions: %v", err)
|
|
}
|
|
return contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{
|
|
SceneDescriptionReferenceSlot: {
|
|
Slot: contracts.ReferenceSlot{Name: SceneDescriptionReferenceSlot},
|
|
Items: []contracts.ReferenceItem{{SlotName: SceneDescriptionReferenceSlot, MediaType: scenecodec.MediaType, Content: content}},
|
|
},
|
|
}}
|
|
}
|
|
|
|
func sceneDescription(chunk *source.Chunk, kind dnd.SceneKind) dnd.SceneDescription {
|
|
return dnd.SceneDescription{
|
|
ID: chunk.ID,
|
|
SourceRef: chunk.Ref,
|
|
Kind: kind,
|
|
Title: "Combat eligibility",
|
|
Summary: "A valid scene description for combat extraction.",
|
|
}
|
|
}
|