Separate reconciliation preparation and proposal assessment from native execution

This commit is contained in:
2026-11-22 00:07:05 +00:00
parent 92c2382806
commit 2348730820
17 changed files with 327 additions and 1138 deletions

View File

@@ -1,111 +0,0 @@
package semanticreconcile
import (
"errors"
"fmt"
"io/fs"
"gitea.maximumdirect.net/eric/notarius/internal/framework/llm"
"gitea.maximumdirect.net/eric/notarius/internal/framework/promptfs"
)
const (
PromptID = "generic.semantic_reconciliation"
PromptVersion = "v1"
promptRoot = "assets/prompts"
)
var promptFiles = []promptfs.ModulePromptFile{
{Name: "prompt.yaml", Path: "prompts/prompt.yaml"},
{Name: "system.md", Path: "prompts/system.md"},
{Name: "protocol.md", Path: "prompts/protocol.md"},
{Name: "instructions.md", Path: "prompts/instructions.md"},
{Name: "candidates.md", Path: "prompts/candidates.md"},
{Name: "transcript-windows.md", Path: "prompts/transcript-windows.md"},
}
// RegisterAssets registers the generic reconciliation prompt and response
// schema as one production-owned asset set.
func RegisterAssets(registry *llm.AssetRegistry) error {
if registry == nil {
return fmt.Errorf("semantic reconciliation asset registry must not be nil")
}
if err := ensureAssetsAbsent(registry); err != nil {
return err
}
assets, err := assetFS()
if err != nil {
return err
}
prompts, err := promptfs.ModulePromptFS(PromptID, assets, append([]promptfs.ModulePromptFile(nil), promptFiles...))
if err != nil {
return fmt.Errorf("prepare semantic reconciliation prompt assets: %w", err)
}
if err := registry.RegisterPromptFS(prompts, promptRoot); err != nil {
return fmt.Errorf("register semantic reconciliation prompt assets: %w", err)
}
if err := registry.RegisterSchemaFS(assets, "schemas"); err != nil {
return fmt.Errorf("register semantic reconciliation schema assets: %w", err)
}
return nil
}
// PromptHash returns the deterministic identity of the complete generic prompt.
func PromptHash() (string, error) {
assets, err := assetFS()
if err != nil {
return "", err
}
parts := make([]llm.AssetHashPart, 0, len(promptFiles))
for _, file := range promptFiles {
parts = append(parts, llm.AssetHashPart{FS: assets, Path: file.Path})
}
return llm.HashAssets(parts)
}
// SchemaHash returns the deterministic identity of the response schema.
func SchemaHash() (string, error) {
schema, err := LoadResponseSchema()
if err != nil {
return "", err
}
return schema.SHA256, nil
}
// SharedPromptFiles returns fresh descriptors for the mandatory protocol and
// variable-input presentation assets that domain prompts may reuse.
func SharedPromptFiles() ([]promptfs.SharedPromptFile, error) {
assets, err := assetFS()
if err != nil {
return nil, err
}
return []promptfs.SharedPromptFile{
{Name: "protocol.md", FS: assets, Path: "prompts/protocol.md"},
{Name: "candidates.md", FS: assets, Path: "prompts/candidates.md"},
{Name: "transcript-windows.md", FS: assets, Path: "prompts/transcript-windows.md"},
}, nil
}
func ensureAssetsAbsent(registry *llm.AssetRegistry) error {
prompts, err := registry.PromptFS()
if err != nil {
return fmt.Errorf("inspect registered prompt assets: %w", err)
}
if _, err := fs.Stat(prompts, PromptID+"/prompt.yaml"); err == nil {
return fmt.Errorf("semantic reconciliation prompt assets already registered")
} else if !errors.Is(err, fs.ErrNotExist) {
return fmt.Errorf("inspect semantic reconciliation prompt assets: %w", err)
}
schemas, err := registry.SchemaFS()
if err != nil {
return fmt.Errorf("inspect registered schema assets: %w", err)
}
if _, err := fs.Stat(schemas, "semantic_reconciliation_llm.v1.json"); err == nil {
return fmt.Errorf("semantic reconciliation schema assets already registered")
} else if !errors.Is(err, fs.ErrNotExist) {
return fmt.Errorf("inspect semantic reconciliation schema assets: %w", err)
}
return nil
}

View File

@@ -2,110 +2,68 @@ package semanticreconcile
import (
"context"
"io/fs"
"reflect"
"strings"
"testing"
"time"
"gitea.maximumdirect.net/eric/notarius/internal/framework/llm"
"gitea.maximumdirect.net/eric/notarius/internal/testsupport/promptkitfixture"
"gitea.maximumdirect.net/eric/promptkit"
"go.maximumdirect.net/promptkit"
)
func TestRegisterAssetsPreparesGenericPromptOffline(t *testing.T) {
registry := llm.NewAssetRegistry()
if err := RegisterAssets(registry); err != nil {
t.Fatalf("RegisterAssets() error = %v, want nil", err)
}
engine := promptkitfixture.NewEngine(t, registry, promptkit.Config{Timeout: time.Second}, map[string]promptkit.ProfileConfig{
"semantic-reconciliation-test": promptkitfixture.Profile("http://127.0.0.1:1/v1", "offline-test-model"),
})
prepared, err := engine.Prepare(context.Background(), promptkit.RunRequest{
PromptID: PromptID, PromptVersion: PromptVersion, ProfileID: "semantic-reconciliation-test",
Inputs: map[string]promptkit.ArtifactRef{
"candidates": promptkit.Inline(`{"candidate_number_range":{"first":1,"last":2},"candidates":[{"candidate_number":1,"label":"Mira"},{"candidate_number":2,"label":"Captain Mira"}]}`),
"transcript": promptkit.Inline(`{"windows":[{"units":[{"unit_id":7,"text":"Mira arrived."}]}]}`),
},
})
func TestNativeReconciliationPromptPairPreparesOffline(t *testing.T) {
client := &nativeReconciliationClient{}
engine := newReconciliationEngine(t, client)
preparation := proposalPreparation(t)
initial, err := InitialRequest(preparation, PromptID, "test-profile", "session-1")
if err != nil {
t.Fatalf("Prepare() error = %v, want nil", err)
t.Fatal(err)
}
if prepared.PromptID != PromptID || prepared.PromptVersion != PromptVersion {
t.Fatalf("prepared prompt identity = %q %q, want %q %q", prepared.PromptID, prepared.PromptVersion, PromptID, PromptVersion)
correction := CorrectionRequest(CorrectionPromptID, "test-profile", "session-1", []string{"Use only candidate numbers in the supplied range.", "Preserve distinct entities."})
if len(correction.Inputs) != 1 {
t.Fatal("correction regenerated fixed evidence")
}
if prepared.SelectedProfileID != "semantic-reconciliation-test" {
t.Fatalf("selected profile = %q, want explicit test profile", prepared.SelectedProfileID)
}
if contract := prepared.OutputContract; contract.SchemaPath != "semantic_reconciliation_llm.v1.json" || contract.RepairAttempts != 1 {
t.Fatalf("output contract = %#v, want generic schema with one repair", contract)
}
if len(prepared.Messages) != 5 || prepared.Messages[0].Role != "system" {
t.Fatalf("prepared messages = %#v, want five ordered messages beginning with system", prepared.Messages)
}
if cache := prepared.Messages[2].CacheControl; cache == nil || cache.Type != promptkit.CacheControlEphemeral {
t.Fatalf("semantic policy cache control = %#v, want ephemeral", cache)
}
for _, index := range []int{0, 1, 3, 4} {
if prepared.Messages[index].CacheControl != nil {
t.Fatalf("message %d cache control = %#v, want nil", index, prepared.Messages[index].CacheControl)
var first promptkit.PreparedRun
for i, request := range []promptkit.RunRequest{initial, correction} {
handle, err := engine.PrepareExecution(context.Background(), request)
if err != nil {
t.Fatal(err)
}
prepared := handle.Details()
handle.Discard()
if prepared.SelectedProfileID != "test-profile" || prepared.SessionID != "session-1" {
t.Fatal("request selection lost")
}
if prepared.OutputContract.ValidationMode != promptkit.ValidationJSONSchema || prepared.StructuredOutput == nil {
t.Fatal("native response schema missing")
}
if i == 0 {
first = prepared
var system string
for _, message := range prepared.Messages {
if message.Role == "system" {
system += message.Content
}
}
for _, rule := range []string{"candidate_number_range", "not candidate numbers", "do not copy candidate names", "Preserve distinct entities"} {
if !strings.Contains(system, rule) {
t.Fatalf("missing enduring system principle %q", rule)
}
}
} else {
if !reflect.DeepEqual(first.OutputContract, prepared.OutputContract) || len(prepared.Messages) != 1 || prepared.Messages[0].Role != "user" {
t.Fatal("correction changed native contract or supplied more than a follow-up assignment")
}
text := prepared.Messages[0].Content
if !strings.Contains(text, "Use only candidate numbers") || !strings.Contains(text, "complete replacement proposal") {
t.Fatal("correction lost findings or assignment")
}
for _, material := range preparation.Materials() {
if strings.Contains(text, string(material)) {
t.Fatal("correction contains regenerated input material")
}
}
}
}
protocol := prepared.Messages[1].Content
for _, requirement := range []string{"candidate_number_range", "Return candidate numbers only", "do not copy candidate names", "start_unit_id", "not candidate numbers"} {
if !strings.Contains(protocol, requirement) {
t.Fatalf("protocol message = %q, want requirement %q", protocol, requirement)
}
}
if !strings.Contains(prepared.Messages[3].Content, `"candidate_number":1`) || strings.Contains(prepared.Messages[3].Content, `"windows"`) {
t.Fatalf("candidate message = %q, want only integer candidate material", prepared.Messages[3].Content)
}
if !strings.Contains(prepared.Messages[4].Content, `"windows"`) || strings.Contains(prepared.Messages[4].Content, `"candidate_number"`) {
t.Fatalf("transcript message = %q, want only transcript windows", prepared.Messages[4].Content)
}
}
func TestAssetHashesAreDeterministicAndComplete(t *testing.T) {
firstPrompt, err := PromptHash()
if err != nil {
t.Fatal(err)
}
secondPrompt, err := PromptHash()
if err != nil {
t.Fatal(err)
}
schemaHash, err := SchemaHash()
if err != nil {
t.Fatal(err)
}
if firstPrompt == "" || firstPrompt != secondPrompt || schemaHash == "" || firstPrompt == schemaHash {
t.Fatalf("asset hashes = prompt %q/%q schema %q, want stable distinct hashes", firstPrompt, secondPrompt, schemaHash)
}
}
func TestSharedPromptFilesExposeOnlyReusableCoreAssets(t *testing.T) {
first, err := SharedPromptFiles()
if err != nil {
t.Fatal(err)
}
second, err := SharedPromptFiles()
if err != nil {
t.Fatal(err)
}
wantNames := []string{"protocol.md", "candidates.md", "transcript-windows.md"}
gotNames := make([]string, len(first))
for index, file := range first {
gotNames[index] = file.Name
if content, err := fs.ReadFile(file.FS, file.Path); err != nil || len(content) == 0 {
t.Fatalf("shared file %q = %q, %v; want readable content", file.Name, content, err)
}
}
if !reflect.DeepEqual(gotNames, wantNames) {
t.Fatalf("shared files = %#v, want narrow allowlist %#v", gotNames, wantNames)
}
first[0].Name = "changed.md"
if second[0].Name != "protocol.md" {
t.Fatalf("SharedPromptFiles() reused mutable descriptors: %#v", second)
if len(client.requests) != 0 {
t.Fatal("offline preparation called a provider")
}
}

View File

@@ -1,3 +1,4 @@
// Package semanticreconcile prepares, executes, and validates bounded
// domain-neutral semantic reconciliation requests.
// Package semanticreconcile prepares fixed source-backed candidate material,
// builds native requests, and assesses and applies domain-neutral duplicate
// proposals. Typed owners execute through the pipeline producer helper.
package semanticreconcile

View File

@@ -1,254 +0,0 @@
package semanticreconcile
import (
"context"
"errors"
"fmt"
"strings"
"gitea.maximumdirect.net/eric/notarius/internal/core/source"
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
"gitea.maximumdirect.net/eric/notarius/internal/framework/llm"
)
// PromptSpec identifies the exact prompt selected by a reconciliation owner.
type PromptSpec struct {
ID string
Version string
SHA256 string
}
// Validate rejects incomplete prompt identity and non-canonical digests.
func (spec PromptSpec) Validate() error {
if strings.TrimSpace(spec.ID) == "" {
return fmt.Errorf("semantic reconciliation prompt ID must not be empty")
}
if strings.TrimSpace(spec.Version) == "" {
return fmt.Errorf("semantic reconciliation prompt version must not be empty")
}
if err := validateSHA256(spec.SHA256); err != nil {
return fmt.Errorf("semantic reconciliation prompt digest: %w", err)
}
return nil
}
// DefaultPromptSpec returns the identity of the core-owned generic prompt.
func DefaultPromptSpec() (PromptSpec, error) {
digest, err := PromptHash()
if err != nil {
return PromptSpec{}, err
}
return PromptSpec{ID: PromptID, Version: PromptVersion, SHA256: digest}, nil
}
// Request contains one typed owner's source-backed reconciliation input.
type Request struct {
StageName string
Source *source.SourceDocument
Candidates []Candidate
ProfileID string
StructuredOutputRepairAttempts *int
SessionID string
Correction *contracts.SemanticCorrection
}
// ResultDisposition classifies a provider-neutral reconciliation outcome.
type ResultDisposition uint8
const (
Complete ResultDisposition = iota + 1
RetryableInvalidStructuredOutput
RetryableDiscardedProposalGroups
SkippedInsufficientCandidates
SkippedLimitExceeded
)
// Result owns the safe plan and neutral diagnostics from one call.
type Result struct {
disposition ResultDisposition
plan Plan
issues []Issue
discardedGroupCount int
candidateNumberRange CandidateNumberRange
candidateMappings []CandidateMapping
modelCandidate *contracts.ModelCandidate
}
// Disposition returns the classified outcome.
func (result Result) Disposition() ResultDisposition { return result.disposition }
// Plan returns an independently owned safe plan.
func (result Result) Plan() Plan { return result.planCopy() }
// Issues returns an owned copy of stable proposal issues.
func (result Result) Issues() []Issue { return append([]Issue(nil), result.issues...) }
// DiscardedGroupCount returns the number of excluded proposal groups.
func (result Result) DiscardedGroupCount() int { return result.discardedGroupCount }
// CandidateNumberRange returns the exact request-local range used for this call.
func (result Result) CandidateNumberRange() CandidateNumberRange {
return result.candidateNumberRange
}
// CandidateMappings returns the request-local number mapping used for this call.
func (result Result) CandidateMappings() []CandidateMapping {
return append([]CandidateMapping(nil), result.candidateMappings...)
}
// CorrectionDetails returns bounded model-facing descriptions of the result's
// proposal issues using the exact candidate-number range for this call.
func (result Result) CorrectionDetails() ([]string, error) {
return CorrectionDetails(result.Issues(), result.candidateNumberRange)
}
// CorrectionGuidance returns one bounded replacement request for this result.
func (result Result) CorrectionGuidance(additionalDetails ...string) (string, error) {
return CorrectionGuidance(result.Issues(), result.candidateNumberRange, additionalDetails...)
}
// ModelCandidate returns an owned copy of the proposal response when a model
// completion produced this result.
func (result Result) ModelCandidate() *contracts.ModelCandidate {
candidate, err := contracts.CloneModelCandidate(result.modelCandidate)
if err != nil {
return nil
}
return candidate
}
func (result Result) planCopy() Plan {
return Plan{groups: result.plan.Groups()}
}
// Engine prepares bounded material, performs one structured completion, and
// classifies the deterministic assessment without applying it to typed values.
type Engine struct {
client contracts.StructuredLLMClient
prompt PromptSpec
schema llm.ResponseSchema
limits Limits
}
// NewEngine constructs a reconciliation engine using the core response schema.
func NewEngine(client contracts.StructuredLLMClient, prompt PromptSpec, limits Limits) (*Engine, error) {
if client == nil {
return nil, fmt.Errorf("construct semantic reconciliation engine: LLM client must not be nil")
}
if err := prompt.Validate(); err != nil {
return nil, fmt.Errorf("construct semantic reconciliation engine: %w", err)
}
if err := limits.Validate(); err != nil {
return nil, fmt.Errorf("construct semantic reconciliation engine: %w", err)
}
schema, err := LoadResponseSchema()
if err != nil {
return nil, fmt.Errorf("construct semantic reconciliation engine: load response schema: %w", err)
}
return newEngine(client, prompt, schema, limits), nil
}
func newEngine(client contracts.StructuredLLMClient, prompt PromptSpec, schema llm.ResponseSchema, limits Limits) *Engine {
return &Engine{client: client, prompt: prompt, schema: schema, limits: limits}
}
// Reconcile prepares and assesses one request. Retryable semantic outcomes are
// returned as results; provider and transport failures remain errors.
func (engine *Engine) Reconcile(ctx context.Context, request Request) (Result, error) {
if err := engine.validate(); err != nil {
return Result{}, err
}
if ctx == nil {
return Result{}, fmt.Errorf("semantic reconciliation %q: context must not be nil", request.StageName)
}
if strings.TrimSpace(request.StageName) == "" {
return Result{}, fmt.Errorf("semantic reconciliation stage name must not be empty")
}
if request.Source == nil {
return Result{}, fmt.Errorf("semantic reconciliation %q: source document must not be nil", request.StageName)
}
if err := ctx.Err(); err != nil {
return Result{}, fmt.Errorf("semantic reconciliation %q: context error before preparation: %w", request.StageName, err)
}
preparation, err := Prepare(request.Source, request.Candidates, engine.limits)
if err != nil {
return Result{}, fmt.Errorf("semantic reconciliation %q: prepare materials: %w", request.StageName, err)
}
result := Result{
candidateNumberRange: preparation.CandidateNumberRange(),
candidateMappings: preparation.CandidateMappings(),
}
switch preparation.Disposition() {
case InsufficientCandidates:
result.disposition = SkippedInsufficientCandidates
return result, nil
case LimitExceeded:
result.disposition = SkippedLimitExceeded
return result, nil
case Ready:
default:
return Result{}, fmt.Errorf("semantic reconciliation %q: unknown preparation disposition %d", request.StageName, preparation.Disposition())
}
if err := ctx.Err(); err != nil {
return Result{}, fmt.Errorf("semantic reconciliation %q: context error before completion: %w", request.StageName, err)
}
correction, err := contracts.CloneSemanticCorrection(request.Correction)
if err != nil {
return Result{}, fmt.Errorf("semantic reconciliation %q: clone correction: %w", request.StageName, err)
}
var response ProposalResponse
completion, err := engine.client.CompleteStructured(ctx, contracts.StructuredCompletionRequest{
StageName: request.StageName,
PromptID: engine.prompt.ID,
PromptVersion: engine.prompt.Version,
ProfileID: request.ProfileID,
SessionID: request.SessionID,
StructuredOutputRepairAttempts: request.StructuredOutputRepairAttempts,
Inputs: preparation.Materials(),
Correction: correction,
}, &response)
if err != nil {
if errors.Is(err, contracts.ErrInvalidStructuredOutput) {
result.disposition = RetryableInvalidStructuredOutput
return result, nil
}
return Result{}, fmt.Errorf("semantic reconciliation %q: complete structured output: %w", request.StageName, err)
}
candidate, err := contracts.NewModelCandidate(completion.Content, contracts.CorrectionProtocolSingleResponseV1)
if err != nil {
return Result{}, fmt.Errorf("semantic reconciliation %q: own model candidate: %w", request.StageName, err)
}
result.modelCandidate = candidate
assessment := preparation.Assess(response)
result.plan = assessment.Plan()
result.issues = assessment.Issues()
result.discardedGroupCount = assessment.DiscardedGroupCount()
if result.discardedGroupCount > 0 {
result.disposition = RetryableDiscardedProposalGroups
} else {
result.disposition = Complete
}
return result, nil
}
func (engine *Engine) validate() error {
if engine == nil {
return fmt.Errorf("semantic reconciliation engine must not be nil")
}
if engine.client == nil {
return fmt.Errorf("semantic reconciliation engine: LLM client must not be nil")
}
if err := engine.prompt.Validate(); err != nil {
return fmt.Errorf("semantic reconciliation engine: invalid construction state: %w", err)
}
if err := engine.limits.Validate(); err != nil {
return fmt.Errorf("semantic reconciliation engine: invalid construction state: %w", err)
}
if err := validateResponseSchemaIdentity(engine.schema); err != nil {
return fmt.Errorf("semantic reconciliation engine: invalid construction state: %w", err)
}
return nil
}

View File

@@ -2,335 +2,162 @@ package semanticreconcile
import (
"context"
"errors"
"fmt"
"reflect"
"strings"
"testing"
"time"
"gitea.maximumdirect.net/eric/notarius/internal/core/source"
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
"gitea.maximumdirect.net/eric/notarius/internal/framework/llm"
"gitea.maximumdirect.net/eric/notarius/assets"
"go.maximumdirect.net/configkit"
"go.maximumdirect.net/promptkit"
)
func TestNewEngineValidatesConstruction(t *testing.T) {
prompt := testPromptSpec("a")
tests := []struct {
name string
client contracts.StructuredLLMClient
prompt PromptSpec
limits Limits
want string
}{
{name: "nil client", prompt: prompt, limits: DefaultLimits(), want: "client"},
{name: "empty prompt ID", client: &recordingReconciliationClient{}, prompt: PromptSpec{Version: "v1", SHA256: testDigest("a")}, limits: DefaultLimits(), want: "prompt ID"},
{name: "empty prompt version", client: &recordingReconciliationClient{}, prompt: PromptSpec{ID: "prompt", SHA256: testDigest("a")}, limits: DefaultLimits(), want: "prompt version"},
{name: "missing digest", client: &recordingReconciliationClient{}, prompt: PromptSpec{ID: "prompt", Version: "v1"}, limits: DefaultLimits(), want: "digest"},
{name: "wrong digest algorithm", client: &recordingReconciliationClient{}, prompt: PromptSpec{ID: "prompt", Version: "v1", SHA256: "md5:" + strings.Repeat("a", 32)}, limits: DefaultLimits(), want: "sha256:"},
{name: "non canonical digest", client: &recordingReconciliationClient{}, prompt: PromptSpec{ID: "prompt", Version: "v1", SHA256: "sha256:" + strings.Repeat("A", 64)}, limits: DefaultLimits(), want: "lowercase"},
{name: "invalid limits", client: &recordingReconciliationClient{}, prompt: prompt, limits: Limits{}, want: "limits"},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if _, err := NewEngine(test.client, test.prompt, test.limits); err == nil || !strings.Contains(err.Error(), test.want) {
t.Fatalf("NewEngine() error = %v, want %q", err, test.want)
}
})
}
defaultPrompt, err := DefaultPromptSpec()
if err != nil {
t.Fatal(err)
}
if defaultPrompt.ID != PromptID || defaultPrompt.Version != PromptVersion || defaultPrompt.SHA256 == "" {
t.Fatalf("DefaultPromptSpec() = %#v, want complete generic prompt identity", defaultPrompt)
}
type nativeReconciliationClient struct {
requests []promptkit.GenerateRequest
output string
}
func TestEnginePropagatesRequestAndAssessesResponse(t *testing.T) {
client := &recordingReconciliationClient{responses: []ProposalResponse{{DuplicateGroups: []DuplicateGroup{{
CandidateNumbers: []int{1, 2}, CanonicalCandidateNumber: 2,
}}}}}
engine := newTestEngine(t, client, DefaultLimits())
request := readyEngineRequest()
request.ProfileID = " profile-as-resolved "
request.SessionID = " session-as-supplied "
correction, err := contracts.NewSemanticCorrection([]byte(`{"duplicate_groups":[]}`), "retain distinct candidates")
if err != nil {
t.Fatal(err)
}
request.Correction = correction
result, err := engine.Reconcile(context.Background(), request)
if err != nil {
t.Fatalf("Reconcile() error = %v, want nil", err)
}
if result.Disposition() != Complete || result.DiscardedGroupCount() != 0 || len(result.Issues()) != 0 {
t.Fatalf("result = disposition %v discarded %d issues %#v", result.Disposition(), result.DiscardedGroupCount(), result.Issues())
}
if got, want := result.CandidateNumberRange(), (CandidateNumberRange{First: 1, Last: 2}); got != want {
t.Fatalf("candidate number range = %#v, want %#v", got, want)
}
groups := result.Plan().Groups()
if len(groups) != 1 || !reflect.DeepEqual(groups[0].MemberPositions(), []int{0, 1}) || groups[0].CanonicalPosition() != 1 {
t.Fatalf("safe plan = %#v", groups)
}
if len(client.requests) != 1 {
t.Fatalf("completion calls = %d, want exactly one", len(client.requests))
}
got := client.requests[0]
if got.StageName != request.StageName || got.PromptID != engine.prompt.ID || got.PromptVersion != engine.prompt.Version || got.ProfileID != request.ProfileID || got.SessionID != request.SessionID {
t.Fatalf("structured request = %#v, want exact routing values", got)
}
if !reflect.DeepEqual(got.Correction, correction) {
t.Fatalf("structured request correction = %#v, want %#v", got.Correction, correction)
}
if len(got.Inputs) != 2 || got.Inputs["candidates"].Name != "candidates" || got.Inputs["transcript"].Name != "transcript" || len(got.Vars) != 0 {
t.Fatalf("structured request inputs = %#v vars = %#v, want only candidate and transcript materials", got.Inputs, got.Vars)
}
candidate := result.ModelCandidate()
if candidate == nil || candidate.Protocol != contracts.CorrectionProtocolSingleResponseV1 || string(candidate.Response) != `{"duplicate_groups":[]}` {
t.Fatalf("model candidate = %#v, want exact owned completion response", candidate)
}
func (client *nativeReconciliationClient) Generate(_ context.Context, request promptkit.GenerateRequest) (*promptkit.GenerateResponse, error) {
client.requests = append(client.requests, request)
return &promptkit.GenerateResponse{Content: client.output}, nil
}
func TestEngineClassifiesSemanticAndTransportOutcomes(t *testing.T) {
transportErr := errors.New("provider unavailable")
tests := []struct {
name string
response ProposalResponse
completion error
want ResultDisposition
wantDiscard int
wantIssues bool
wantCandidate bool
wantError error
}{
{name: "empty groups complete", response: ProposalResponse{DuplicateGroups: []DuplicateGroup{}}, want: Complete, wantCandidate: true},
{name: "discarded proposal retryable", response: ProposalResponse{DuplicateGroups: []DuplicateGroup{{CandidateNumbers: []int{1, 99}, CanonicalCandidateNumber: 1}}}, want: RetryableDiscardedProposalGroups, wantDiscard: 1, wantIssues: true, wantCandidate: true},
{name: "invalid structured output retryable", completion: fmt.Errorf("decode response: %w", contracts.ErrInvalidStructuredOutput), want: RetryableInvalidStructuredOutput},
{name: "transport failure", completion: transportErr, wantError: transportErr},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
client := &recordingReconciliationClient{responses: []ProposalResponse{test.response}, errors: []error{test.completion}}
result, err := newTestEngine(t, client, DefaultLimits()).Reconcile(context.Background(), readyEngineRequest())
if test.wantError != nil {
if !errors.Is(err, test.wantError) || !strings.Contains(err.Error(), readyEngineRequest().StageName) {
t.Fatalf("Reconcile() error = %v, want contextual %v", err, test.wantError)
}
return
}
if err != nil {
t.Fatalf("Reconcile() error = %v, want nil", err)
}
if result.Disposition() != test.want || result.DiscardedGroupCount() != test.wantDiscard || (len(result.Issues()) > 0) != test.wantIssues {
t.Fatalf("result = disposition %v discarded %d issues %#v", result.Disposition(), result.DiscardedGroupCount(), result.Issues())
}
if (result.ModelCandidate() != nil) != test.wantCandidate {
t.Fatalf("model candidate = %#v, want presence %t", result.ModelCandidate(), test.wantCandidate)
}
if len(client.requests) != 1 {
t.Fatalf("completion calls = %d, want one", len(client.requests))
}
})
}
}
func TestEngineSkipsDeterministicOutcomesWithoutCompletion(t *testing.T) {
tests := []struct {
name string
request Request
limits Limits
want ResultDisposition
mappingLen int
}{
{name: "insufficient candidates", request: engineRequestWithCandidateCount(1), limits: DefaultLimits(), want: SkippedInsufficientCandidates, mappingLen: 1},
{name: "candidate limit", request: engineRequestWithCandidateCount(2), limits: Limits{ContextRadius: 0, MaximumCandidates: 1, MaximumMaterialBytes: 10000}, want: SkippedLimitExceeded, mappingLen: 2},
{name: "material limit", request: engineRequestWithCandidateCount(2), limits: Limits{ContextRadius: 0, MaximumCandidates: 2, MaximumMaterialBytes: 1}, want: SkippedLimitExceeded, mappingLen: 2},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
client := &recordingReconciliationClient{}
result, err := newTestEngine(t, client, test.limits).Reconcile(context.Background(), test.request)
if err != nil {
t.Fatalf("Reconcile() error = %v, want nil", err)
}
if result.Disposition() != test.want || len(result.CandidateMappings()) != test.mappingLen {
t.Fatalf("result disposition = %v mappings = %#v", result.Disposition(), result.CandidateMappings())
}
if result.ModelCandidate() != nil {
t.Fatalf("model candidate = %#v, want nil for no-call outcome", result.ModelCandidate())
}
if len(client.requests) != 0 {
t.Fatalf("completion calls = %d, want zero", len(client.requests))
}
})
}
}
func TestEngineRejectsInvalidInvocationAndHonorsCancellation(t *testing.T) {
request := readyEngineRequest()
client := &recordingReconciliationClient{}
engine := newTestEngine(t, client, DefaultLimits())
var nilEngine *Engine
if _, err := nilEngine.Reconcile(context.Background(), request); err == nil || !strings.Contains(err.Error(), "engine must not be nil") {
t.Fatalf("nil engine error = %v", err)
}
if _, err := (&Engine{}).Reconcile(context.Background(), request); err == nil || !strings.Contains(err.Error(), "client") {
t.Fatalf("zero engine error = %v", err)
}
invalid := newEngine(&recordingReconciliationClient{}, testPromptSpec("a"), llm.ResponseSchema{}, DefaultLimits())
if _, err := invalid.Reconcile(context.Background(), request); err == nil || !strings.Contains(err.Error(), "invalid construction state") {
t.Fatalf("invalid construction error = %v", err)
}
if _, err := engine.Reconcile(nil, request); err == nil || !strings.Contains(err.Error(), "context") {
t.Fatalf("nil context error = %v", err)
}
withoutStage := request
withoutStage.StageName = " "
if _, err := engine.Reconcile(context.Background(), withoutStage); err == nil || !strings.Contains(err.Error(), "stage name") {
t.Fatalf("empty stage error = %v", err)
}
withoutSource := request
withoutSource.Source = nil
if _, err := engine.Reconcile(context.Background(), withoutSource); err == nil || !strings.Contains(err.Error(), "source document") {
t.Fatalf("nil source error = %v", err)
}
canceled, cancel := context.WithCancel(context.Background())
cancel()
if _, err := engine.Reconcile(canceled, request); !errors.Is(err, context.Canceled) || !strings.Contains(err.Error(), "before preparation") {
t.Fatalf("preparation cancellation error = %v", err)
}
if _, err := engine.Reconcile(&cancelBeforeCompletionContext{}, request); !errors.Is(err, context.Canceled) || !strings.Contains(err.Error(), "before completion") {
t.Fatalf("completion cancellation error = %v", err)
}
if len(client.requests) != 0 {
t.Fatalf("completion calls = %d, want zero for invalid and canceled invocations", len(client.requests))
}
}
func TestEngineCallsAreIndependentAndResultsAreOwned(t *testing.T) {
client := &recordingReconciliationClient{responses: []ProposalResponse{
{DuplicateGroups: []DuplicateGroup{
{CandidateNumbers: []int{1, 2}, CanonicalCandidateNumber: 1},
{CandidateNumbers: []int{2, 99}, CanonicalCandidateNumber: 2},
}},
{DuplicateGroups: []DuplicateGroup{}},
}}
engine := newTestEngine(t, client, DefaultLimits())
first, err := engine.Reconcile(context.Background(), readyEngineRequest())
if err != nil {
t.Fatal(err)
}
first.Plan().Groups()[0].memberPositions[0] = 99
firstIssues := first.Issues()
firstIssues[0].Category = "changed"
firstMappings := first.CandidateMappings()
firstMappings[0].CandidatePosition = 99
firstCandidate := first.ModelCandidate()
firstCandidate.Response[0] = 'x'
if first.Plan().Groups()[0].MemberPositions()[0] != 0 || first.Issues()[0].Category == "changed" || first.CandidateMappings()[0].CandidatePosition != 0 || string(first.ModelCandidate().Response) != `{"duplicate_groups":[]}` {
t.Fatal("result accessors exposed retained state")
}
second, err := engine.Reconcile(context.Background(), readyEngineRequest())
if err != nil {
t.Fatal(err)
}
if second.Disposition() != Complete || len(second.Plan().Groups()) != 0 || len(second.Issues()) != 0 || second.DiscardedGroupCount() != 0 || len(second.CandidateMappings()) != 2 || second.ModelCandidate() == nil {
t.Fatalf("second result retained prior call state: disposition %v plan %#v issues %#v discarded %d mappings %#v", second.Disposition(), second.Plan().Groups(), second.Issues(), second.DiscardedGroupCount(), second.CandidateMappings())
}
}
type recordingReconciliationClient struct {
requests []contracts.StructuredCompletionRequest
responses []ProposalResponse
errors []error
content []byte
}
func (client *recordingReconciliationClient) CompleteStructured(_ context.Context, request contracts.StructuredCompletionRequest, output any) (contracts.StructuredCompletionResponse, error) {
snapshot, err := contracts.CloneStructuredCompletionRequest(request)
if err != nil {
return contracts.StructuredCompletionResponse{}, fmt.Errorf("clone recording request: %w", err)
}
client.requests = append(client.requests, snapshot)
index := len(client.requests) - 1
if index < len(client.errors) && client.errors[index] != nil {
return contracts.StructuredCompletionResponse{}, client.errors[index]
}
response := ProposalResponse{DuplicateGroups: []DuplicateGroup{}}
if index < len(client.responses) {
response = cloneProposalResponse(client.responses[index])
}
target, ok := output.(*ProposalResponse)
if !ok {
return contracts.StructuredCompletionResponse{}, fmt.Errorf("output type = %T", output)
}
*target = response
content := append([]byte(nil), client.content...)
if len(content) == 0 {
content = []byte(`{"duplicate_groups":[]}`)
}
return contracts.StructuredCompletionResponse{Content: content}, nil
}
func cloneProposalResponse(response ProposalResponse) ProposalResponse {
cloned := ProposalResponse{DuplicateGroups: make([]DuplicateGroup, len(response.DuplicateGroups))}
for index, group := range response.DuplicateGroups {
cloned.DuplicateGroups[index] = DuplicateGroup{
CandidateNumbers: append([]int(nil), group.CandidateNumbers...), CanonicalCandidateNumber: group.CanonicalCandidateNumber,
}
}
return cloned
}
func newTestEngine(t *testing.T, client contracts.StructuredLLMClient, limits Limits) *Engine {
func newReconciliationEngine(t *testing.T, client promptkit.LLMClient) *promptkit.Engine {
t.Helper()
engine, err := NewEngine(client, testPromptSpec("a"), limits)
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("reconciliation fixture", []byte(`promptkit:
profiles:
- id: test-profile
endpoint: https://example.invalid/v1
model: reconciliation-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.Fatalf("NewEngine() error = %v", err)
t.Fatal(err)
}
engine, err := promptkit.NewFromConfig(result, promptkit.RuntimeConfig{}, promptkit.WithLLMClient(client))
if err != nil {
t.Fatal(err)
}
return engine
}
func testPromptSpec(digestCharacter string) PromptSpec {
return PromptSpec{ID: "test.semantic_reconciliation", Version: "v1", SHA256: testDigest(digestCharacter)}
}
func testDigest(character string) string { return "sha256:" + strings.Repeat(character, 64) }
func readyEngineRequest() Request { return engineRequestWithCandidateCount(2) }
func engineRequestWithCandidateCount(count int) Request {
document := &source.SourceDocument{ID: "source", Units: []source.SourceUnit{
{ID: 1, Kind: "speech", Text: "Mira arrived."},
{ID: 2, Kind: "speech", Text: "The captain spoke."},
}}
candidates := make([]Candidate, count)
for index := range candidates {
unitID := index%len(document.Units) + 1
candidates[index] = Candidate{
Label: fmt.Sprintf("candidate-%d", index+1),
SourceRefs: []source.SourceRef{{SourceID: document.ID, StartUnitID: unitID, EndUnitID: unitID}},
func TestNativeRequestUsesFixedPreparedEvidenceAndRouting(t *testing.T) {
preparation := proposalPreparation(t)
before := preparation.Materials()
request, err := InitialRequest(preparation, PromptID, "test-profile", "session-1")
if err != nil {
t.Fatal(err)
}
if request.PromptID != PromptID || request.ProfileID != "test-profile" || request.SessionID != "session-1" {
t.Fatalf("routing = %#v", request)
}
client := &nativeReconciliationClient{output: `{"duplicate_groups":[{"candidate_numbers":[1,2],"canonical_candidate_number":2}]}`}
engine := newReconciliationEngine(t, client)
result, err := engine.Run(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if result == nil || !result.Validation.IsValid {
t.Fatalf("invalid native result: %#v", result)
}
response, err := DecodeProposal(result.RawOutput)
if err != nil {
t.Fatal(err)
}
assessment := preparation.Assess(response)
if got, want := snapshotPlan(assessment.Plan()), []planGroupSnapshot{{members: []int{0, 2}, canonical: 2}}; !reflect.DeepEqual(got, want) {
t.Fatalf("plan = %#v, want %#v", got, want)
}
if len(client.requests) != 1 || client.requests[0].Prompt.SessionID != "session-1" || client.requests[0].Target.Model != "reconciliation-test-model" {
t.Fatal("native provider routing was not preserved")
}
var text string
for _, message := range client.requests[0].Prompt.Messages {
text += message.Content
}
for _, content := range before {
if !strings.Contains(text, string(content)) {
t.Fatal("request changed prepared evidence")
}
}
return Request{StageName: "test/normalize", Source: document, Candidates: candidates, ProfileID: "profile", SessionID: "session"}
}
type cancelBeforeCompletionContext struct{ calls int }
func (ctx *cancelBeforeCompletionContext) Deadline() (time.Time, bool) { return time.Time{}, false }
func (ctx *cancelBeforeCompletionContext) Done() <-chan struct{} { return nil }
func (ctx *cancelBeforeCompletionContext) Value(any) any { return nil }
func (ctx *cancelBeforeCompletionContext) Err() error {
ctx.calls++
if ctx.calls > 1 {
return context.Canceled
returned := preparation.Materials()
returned[candidateInputName][0] = 'x'
request.Inputs[candidateInputName] = promptkit.Inline("caller mutation")
if !reflect.DeepEqual(preparation.Materials(), before) {
t.Fatal("request exposed retained preparation")
}
}
func TestRequestConstructionRejectsUnreadyPreparation(t *testing.T) {
for _, preparation := range []Preparation{{}, {disposition: InsufficientCandidates}, {disposition: LimitExceeded}} {
request, err := InitialRequest(preparation, PromptID, "test-profile", "")
if err == nil || request.PromptID != "" {
t.Fatal("unready material produced a model request")
}
}
}
func TestNativeStructuralFailureIsNotAReconciliationRetry(t *testing.T) {
client := &nativeReconciliationClient{output: `{"duplicate_groups":null}`}
engine := newReconciliationEngine(t, client)
request, err := InitialRequest(proposalPreparation(t), PromptID, "test-profile", "")
if err != nil {
t.Fatal(err)
}
// A test-selected native budget gives a terminal result without depending on
// the upstream default number of structural repair calls.
zero := 0
request.Validation = &promptkit.OutputContractInput{
Format: promptkit.FormatJSON, ValidationMode: promptkit.ValidationJSONSchema,
SchemaPath: "generic/normalize/deduplication/schemas/semantic_reconciliation_llm.v1.json", RepairAttempts: &zero,
}
result, err := engine.Run(context.Background(), request)
if err == nil && (result == nil || result.Validation.Status != promptkit.ValidationFailed || result.Validation.IsValid) {
t.Fatalf("native structural failure lost: %#v %v", result, err)
}
if len(client.requests) != 1 {
t.Fatalf("native test budget not respected: %d", len(client.requests))
}
}
func TestDecodeProposalReportsMalformedOutput(t *testing.T) {
if _, err := DecodeProposal("{"); err == nil {
t.Fatal("malformed JSON decoded")
}
}
func TestRepeatedProposalsUseTheSameMappingWithoutPlanUnion(t *testing.T) {
preparation := proposalPreparation(t)
before := preparation.CandidateMappings()
first, err := DecodeProposal(`{"duplicate_groups":[{"candidate_numbers":[1,2],"canonical_candidate_number":1},{"candidate_numbers":[4,99],"canonical_candidate_number":4}]}`)
if err != nil {
t.Fatal(err)
}
earlier := preparation.Assess(first)
if earlier.DiscardedGroupCount() != 1 || len(earlier.Plan().Groups()) != 1 {
t.Fatalf("first assessment = %#v", earlier)
}
second, err := DecodeProposal(`{"duplicate_groups":[{"candidate_numbers":[4,5],"canonical_candidate_number":5}]}`)
if err != nil {
t.Fatal(err)
}
current := preparation.Assess(second)
if got, want := snapshotPlan(current.Plan()), []planGroupSnapshot{{members: []int{5, 6}, canonical: 6}}; !reflect.DeepEqual(got, want) {
t.Fatalf("current plan retained or remapped earlier groups: %#v", got)
}
if !reflect.DeepEqual(preparation.CandidateMappings(), before) {
t.Fatal("proposal assessment changed fixed handles")
}
if len(earlier.Plan().Groups()) != 1 || earlier.DiscardedGroupCount() != 1 {
t.Fatal("later proposal mutated earlier assessment")
}
return nil
}

View File

@@ -1,101 +0,0 @@
package semanticreconcile
import (
"crypto/sha256"
"encoding/hex"
"fmt"
"strconv"
"strings"
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
"gitea.maximumdirect.net/eric/notarius/internal/framework/llm"
"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
)
// Policy identifies the framework-owned reconciliation and assessment rules.
const Policy = "semantic_reconciliation.v3"
var _ contracts.ManifestMetadataProvider = (*Engine)(nil)
var _ pipeline.CheckpointFingerprintProvider = (*Engine)(nil)
// ManifestMetadata returns fresh, content-free identity for the complete core
// reconciliation mechanism.
func (engine *Engine) ManifestMetadata() map[string]any {
if engine == nil || engine.validate() != nil {
return nil
}
return map[string]any{
"prompt_id": engine.prompt.ID,
"prompt_version": engine.prompt.Version,
"prompt_sha256": engine.prompt.SHA256,
"response_schema_key": string(engine.schema.Key),
"response_schema_id": engine.schema.ID,
"response_schema_name": engine.schema.Name,
"response_schema_version": engine.schema.Version,
"response_schema_sha256": engine.schema.SHA256,
"semantic_reconciliation_policy": Policy,
"semantic_reconciliation_limits": map[string]any{
"context_radius": engine.limits.ContextRadius,
"maximum_candidates": engine.limits.MaximumCandidates,
"maximum_material_bytes": engine.limits.MaximumMaterialBytes,
},
}
}
// CheckpointFingerprints returns fresh canonical identities for prompt,
// schema, reconciliation policy, and the complete limit policy.
func (engine *Engine) CheckpointFingerprints() []pipeline.CheckpointFingerprint {
if engine == nil || engine.validate() != nil {
return nil
}
return []pipeline.CheckpointFingerprint{
{Name: "prompt", Value: identityDigest(engine.prompt.ID, engine.prompt.Version, engine.prompt.SHA256)},
{Name: "response_schema", Value: identityDigest(string(engine.schema.Key), engine.schema.ID, engine.schema.Version, engine.schema.Name, engine.schema.SHA256)},
{Name: "semantic_reconciliation_policy", Value: Policy},
{Name: "semantic_reconciliation_limits", Value: limitPolicyDigest(engine.limits)},
}
}
func limitPolicyDigest(limits Limits) string {
return identityDigest(
strconv.Itoa(limits.ContextRadius),
strconv.Itoa(limits.MaximumCandidates),
strconv.Itoa(limits.MaximumMaterialBytes),
)
}
func identityDigest(parts ...string) string {
hash := sha256.New()
for _, part := range parts {
_, _ = hash.Write([]byte(strconv.Itoa(len(part))))
_, _ = hash.Write([]byte{':'})
_, _ = hash.Write([]byte(part))
}
return "sha256:" + hex.EncodeToString(hash.Sum(nil))
}
func validateResponseSchemaIdentity(schema llm.ResponseSchema) error {
if strings.TrimSpace(string(schema.Key)) == "" || strings.TrimSpace(schema.ID) == "" || strings.TrimSpace(schema.Version) == "" || strings.TrimSpace(schema.Name) == "" {
return fmt.Errorf("response schema identity must be complete")
}
if err := validateSHA256(schema.SHA256); err != nil {
return fmt.Errorf("response schema digest: %w", err)
}
return nil
}
func validateSHA256(value string) error {
const prefix = "sha256:"
if !strings.HasPrefix(value, prefix) {
return fmt.Errorf("must use sha256: prefix")
}
hexValue := strings.TrimPrefix(value, prefix)
if len(hexValue) != sha256.Size*2 || hexValue != strings.ToLower(hexValue) {
return fmt.Errorf("must contain 64 lowercase hexadecimal characters")
}
decoded, err := hex.DecodeString(hexValue)
if err != nil || len(decoded) != sha256.Size {
return fmt.Errorf("must contain 64 lowercase hexadecimal characters")
}
return nil
}

View File

@@ -1,93 +0,0 @@
package semanticreconcile
import (
"testing"
"gitea.maximumdirect.net/eric/notarius/internal/framework/llm"
"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
)
func TestEngineMetadataAndFingerprintsCoverCoreIdentity(t *testing.T) {
base := newTestEngine(t, &recordingReconciliationClient{}, DefaultLimits())
metadata := base.ManifestMetadata()
for _, key := range []string{
"prompt_id", "prompt_version", "prompt_sha256",
"response_schema_key", "response_schema_id", "response_schema_name", "response_schema_version", "response_schema_sha256",
"semantic_reconciliation_policy", "semantic_reconciliation_limits",
} {
if metadata[key] == nil || metadata[key] == "" {
t.Fatalf("metadata[%q] = %#v, want populated core identity", key, metadata[key])
}
}
limits, ok := metadata["semantic_reconciliation_limits"].(map[string]any)
if !ok || len(limits) != 3 || limits["context_radius"] == nil || limits["maximum_candidates"] == nil || limits["maximum_material_bytes"] == nil {
t.Fatalf("limit metadata = %#v, want complete limits", metadata["semantic_reconciliation_limits"])
}
fingerprints := base.CheckpointFingerprints()
wantNames := []string{"prompt", "response_schema", "semantic_reconciliation_policy", "semantic_reconciliation_limits"}
if len(fingerprints) != len(wantNames) {
t.Fatalf("fingerprints = %#v, want required categories", fingerprints)
}
for index, want := range wantNames {
if fingerprints[index].Name != want || fingerprints[index].Value == "" {
t.Fatalf("fingerprint %d = %#v, want %q with value", index, fingerprints[index], want)
}
}
metadata["prompt_id"] = "changed"
limits["context_radius"] = -1
fingerprints[0].Name = "changed"
if got := base.ManifestMetadata(); got["prompt_id"] == "changed" || got["semantic_reconciliation_limits"].(map[string]any)["context_radius"] == -1 {
t.Fatalf("ManifestMetadata() exposed retained state: %#v", got)
}
if got := base.CheckpointFingerprints(); got[0].Name == "changed" {
t.Fatalf("CheckpointFingerprints() exposed retained state: %#v", got)
}
}
func TestCoreFingerprintsChangeWithBehavioralIdentity(t *testing.T) {
base := newTestEngine(t, &recordingReconciliationClient{}, DefaultLimits())
baseFingerprints := base.CheckpointFingerprints()
promptChanged, err := NewEngine(&recordingReconciliationClient{}, testPromptSpec("b"), DefaultLimits())
if err != nil {
t.Fatal(err)
}
assertOnlyFingerprintChanged(t, baseFingerprints, promptChanged.CheckpointFingerprints(), "prompt")
schema, err := LoadResponseSchema()
if err != nil {
t.Fatal(err)
}
schema.SHA256 = testDigest("b")
schemaChanged := newEngine(&recordingReconciliationClient{}, base.prompt, schema, DefaultLimits())
assertOnlyFingerprintChanged(t, baseFingerprints, schemaChanged.CheckpointFingerprints(), "response_schema")
limits := DefaultLimits()
limits.ContextRadius++
limitsChanged, err := NewEngine(&recordingReconciliationClient{}, base.prompt, limits)
if err != nil {
t.Fatal(err)
}
assertOnlyFingerprintChanged(t, baseFingerprints, limitsChanged.CheckpointFingerprints(), "semantic_reconciliation_limits")
}
func TestInvalidEngineIdentityHasNoMetadataOrFingerprints(t *testing.T) {
invalid := newEngine(&recordingReconciliationClient{}, testPromptSpec("a"), llm.ResponseSchema{}, DefaultLimits())
if invalid.ManifestMetadata() != nil || invalid.CheckpointFingerprints() != nil {
t.Fatalf("invalid engine exposed identity: metadata %#v fingerprints %#v", invalid.ManifestMetadata(), invalid.CheckpointFingerprints())
}
}
func assertOnlyFingerprintChanged(t *testing.T, before, after []pipeline.CheckpointFingerprint, changedName string) {
t.Helper()
if len(before) != len(after) {
t.Fatalf("fingerprint counts differ: %#v %#v", before, after)
}
for index := range before {
changed := before[index] != after[index]
if changed != (before[index].Name == changedName) {
t.Fatalf("fingerprint %q change = %t, want only %q changed\nbefore: %#v\nafter: %#v", before[index].Name, changed, changedName, before, after)
}
}
}

View File

@@ -1,20 +1,16 @@
package semanticreconcile
import (
"crypto/sha256"
"encoding/hex"
"encoding/json"
"fmt"
"sort"
"gitea.maximumdirect.net/eric/notarius/internal/core/source"
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
)
const (
candidateInputName = "candidates"
transcriptInputName = "transcript"
jsonMediaType = "application/json"
)
var defaultLimits = Limits{
@@ -89,7 +85,7 @@ type Preparation struct {
disposition Disposition
candidateNumberRange CandidateNumberRange
mappings []CandidateMapping
materials contracts.LLMInputSet
materials map[string][]byte
}
// Disposition returns the preparation outcome.
@@ -110,8 +106,15 @@ func (preparation Preparation) CandidateNumberRange() CandidateNumberRange {
// Materials returns independently owned candidate and transcript materials.
// It is empty unless Disposition returns Ready.
func (preparation Preparation) Materials() contracts.LLMInputSet {
return preparation.materials.Clone()
func (preparation Preparation) Materials() map[string][]byte {
if preparation.materials == nil {
return nil
}
materials := make(map[string][]byte, len(preparation.materials))
for name, content := range preparation.materials {
materials[name] = append([]byte(nil), content...)
}
return materials
}
type sourceRange struct {
@@ -242,9 +245,9 @@ func Prepare(document *source.SourceDocument, candidates []Candidate, limits Lim
}
result.disposition = Ready
result.materials = contracts.LLMInputSet{
candidateInputName: newInputMaterial(candidateInputName, candidateContent),
transcriptInputName: newInputMaterial(transcriptInputName, transcriptContent),
result.materials = map[string][]byte{
candidateInputName: candidateContent,
transcriptInputName: transcriptContent,
}
return result, nil
}
@@ -412,14 +415,3 @@ func appendWithinLimit(content []byte, maximumBytes int, parts ...[]byte) ([]byt
}
return content, true
}
func newInputMaterial(name string, content []byte) contracts.LLMInputMaterial {
digest := sha256.Sum256(content)
return contracts.NewLLMInputMaterial(
name,
jsonMediaType,
content,
"sha256:"+hex.EncodeToString(digest[:]),
"",
)
}

View File

@@ -1,8 +1,6 @@
package semanticreconcile
import (
"crypto/sha256"
"encoding/hex"
"encoding/json"
"math"
"reflect"
@@ -67,16 +65,12 @@ func TestPrepareBuildsContiguousCandidatesAndOwnedSourceContext(t *testing.T) {
t.Fatal("transcript material is missing")
}
for name, material := range materials {
if material.Name != name || material.MediaType != "application/json" || material.OriginURI != "" || material.SizeBytes != int64(len(material.Content)) {
t.Fatalf("material %q metadata = %#v", name, material)
}
digest := sha256.Sum256(material.Content)
if want := "sha256:" + hex.EncodeToString(digest[:]); material.Digest != want {
t.Fatalf("material %q digest = %q, want %q", name, material.Digest, want)
if !json.Valid(material) {
t.Fatalf("material %q is not valid JSON", name)
}
}
candidateContent := append([]byte(nil), materials[candidateInputName].Content...)
candidateContent := append([]byte(nil), materials[candidateInputName]...)
var candidatePayload candidateInput
if err := json.Unmarshal(candidateContent, &candidatePayload); err != nil {
t.Fatal(err)
@@ -102,7 +96,7 @@ func TestPrepareBuildsContiguousCandidatesAndOwnedSourceContext(t *testing.T) {
t.Fatalf("model-facing candidate fields = %#v", candidate)
}
}
combined := string(materials[candidateInputName].Content) + string(materials[transcriptInputName].Content)
combined := string(materials[candidateInputName]) + string(materials[transcriptInputName])
for _, forbidden := range []string{document.ID, "application_entity_id", "private-entity-id", `"candidate_id"`, `"candidate_ids"`, `"canonical_candidate_id"`} {
if strings.Contains(combined, forbidden) {
t.Fatalf("model material leaked %q: %s", forbidden, combined)
@@ -110,7 +104,7 @@ func TestPrepareBuildsContiguousCandidatesAndOwnedSourceContext(t *testing.T) {
}
var transcript transcriptInput
if err := json.Unmarshal(materials[transcriptInputName].Content, &transcript); err != nil {
if err := json.Unmarshal(materials[transcriptInputName], &transcript); err != nil {
t.Fatal(err)
}
if len(transcript.Windows) != 1 || len(transcript.Windows[0].Units) != len(document.Units) {
@@ -132,11 +126,11 @@ func TestPrepareBuildsContiguousCandidatesAndOwnedSourceContext(t *testing.T) {
candidates[0].SourceRefs[0].StartUnitID = 40
document.Units[1].Metadata["speaker"].(map[string]any)["name"] = "changed"
if got := preparation.Materials()[candidateInputName].Content; !reflect.DeepEqual(got, candidateContent) {
if got := preparation.Materials()[candidateInputName]; !reflect.DeepEqual(got, candidateContent) {
t.Fatalf("candidate material changed through caller input: %s", got)
}
var retained transcriptInput
if err := json.Unmarshal(preparation.Materials()[transcriptInputName].Content, &retained); err != nil {
if err := json.Unmarshal(preparation.Materials()[transcriptInputName], &retained); err != nil {
t.Fatal(err)
}
if got := retained.Windows[0].Units[1].Metadata["speaker"].(map[string]any)["name"]; got != "Mira" {
@@ -147,10 +141,10 @@ func TestPrepareBuildsContiguousCandidatesAndOwnedSourceContext(t *testing.T) {
returnedMappings[0].CandidatePosition = 99
returnedMaterials := preparation.Materials()
candidateMaterial := returnedMaterials[candidateInputName]
candidateMaterial.Content[0] = '['
candidateMaterial[0] = '['
returnedMaterials[candidateInputName] = candidateMaterial
delete(returnedMaterials, transcriptInputName)
if preparation.CandidateMappings()[0].CandidatePosition != 0 || !json.Valid(preparation.Materials()[candidateInputName].Content) || len(preparation.Materials()) != 2 {
if preparation.CandidateMappings()[0].CandidatePosition != 0 || !json.Valid(preparation.Materials()[candidateInputName]) || len(preparation.Materials()) != 2 {
t.Fatal("preparation accessors exposed retained data")
}
}
@@ -207,7 +201,7 @@ func TestPrepareFiltersUnsafeCandidatesAndCoalescesAdjacentWindows(t *testing.T)
t.Fatalf("CandidateNumberRange() after filtering = %#v, want %#v", got, want)
}
var transcript transcriptInput
if err := json.Unmarshal(preparation.Materials()[transcriptInputName].Content, &transcript); err != nil {
if err := json.Unmarshal(preparation.Materials()[transcriptInputName], &transcript); err != nil {
t.Fatal(err)
}
if len(transcript.Windows) != 1 || len(transcript.Windows[0].Units) != 2 || transcript.Windows[0].Units[0].ID != 3 || transcript.Windows[0].Units[1].ID != 8 {
@@ -302,7 +296,7 @@ func TestPrepareStopsRenderingContextWhenMaterialLimitIsExceeded(t *testing.T) {
if err != nil || base.Disposition() != Ready {
t.Fatalf("Prepare(base) = disposition %v, error %v", base.Disposition(), err)
}
candidateBytes := len(base.Materials()[candidateInputName].Content)
candidateBytes := len(base.Materials()[candidateInputName])
document.Units[1].Metadata = cycle
limited, err := Prepare(document, candidates, Limits{
@@ -330,7 +324,7 @@ func TestPrepareAcceptsExactCombinedByteLimitAndSkipsOneOver(t *testing.T) {
t.Fatalf("Prepare(base) = disposition %v, error %v", base.Disposition(), err)
}
materials := base.Materials()
totalBytes := len(materials[candidateInputName].Content) + len(materials[transcriptInputName].Content)
totalBytes := len(materials[candidateInputName]) + len(materials[transcriptInputName])
exactLimits := baseLimits
exactLimits.MaximumMaterialBytes = totalBytes

View File

@@ -1,12 +1,10 @@
package semanticreconcile
import (
"encoding/json"
"fmt"
"sort"
"strings"
"unicode/utf8"
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
)
// ProposalResponse is the complete private structured response contract.
@@ -14,6 +12,17 @@ type ProposalResponse struct {
DuplicateGroups []DuplicateGroup `json:"duplicate_groups"`
}
// DecodeProposal reads an already structurally validated native response.
// Native execution errors and failed validation must be handled before this
// function; decoding never requests another structural repair or execution.
func DecodeProposal(output string) (ProposalResponse, error) {
var response ProposalResponse
if err := json.Unmarshal([]byte(output), &response); err != nil {
return ProposalResponse{}, fmt.Errorf("decode semantic reconciliation proposal: %w", err)
}
return response, nil
}
// DuplicateGroup proposes supplied request-local candidate numbers that may
// denote one entity and identifies one supplied member as canonical.
type DuplicateGroup struct {
@@ -121,39 +130,6 @@ func CorrectionDetails(issues []Issue, numberRange CandidateNumberRange) ([]stri
return details, nil
}
// CorrectionGuidance builds one bounded request for a complete corrected
// proposal. Additional details let a typed owner append a domain rule without
// weakening or duplicating the shared protocol guidance.
func CorrectionGuidance(issues []Issue, numberRange CandidateNumberRange, additionalDetails ...string) (string, error) {
details, err := CorrectionDetails(issues, numberRange)
if err != nil {
return "", err
}
for _, detail := range additionalDetails {
if !utf8.ValidString(detail) {
return "", fmt.Errorf("semantic reconciliation additional correction detail has invalid UTF-8")
}
detail = strings.TrimSpace(detail)
if detail == "" {
return "", fmt.Errorf("semantic reconciliation additional correction detail must not be blank")
}
details = append(details, detail)
}
if len(details) == 0 {
return "", fmt.Errorf("semantic reconciliation correction guidance requires at least one detail")
}
parts := make([]string, 0, len(details)+2)
parts = append(parts, "The previous semantic-duplicate proposal was invalid.")
parts = append(parts, details...)
parts = append(parts, "Return one complete corrected JSON response that follows the original instructions; do not return a patch or commentary.")
guidance := strings.Join(parts, " ")
if len(guidance) > contracts.MaxNormalizeRetryCorrectionGuidanceBytes {
return "", fmt.Errorf("semantic reconciliation correction guidance exceeds maximum length")
}
return guidance, nil
}
func validateCorrectionRange(numberRange CandidateNumberRange) error {
if numberRange.First != 1 || numberRange.Last < 2 {
return fmt.Errorf("semantic reconciliation correction candidate-number range must start at 1 and include at least two candidates")
@@ -251,8 +227,8 @@ func (assessment Assessment) DiscardedGroupCount() int {
return assessment.discardedGroupCount
}
// RetryRequired reports whether any response group was discarded.
func (assessment Assessment) RetryRequired() bool {
// HasDiscardedGroups reports whether the proposal contains unsafe groups.
func (assessment Assessment) HasDiscardedGroups() bool {
return assessment.discardedGroupCount > 0
}

View File

@@ -6,7 +6,6 @@ import (
"testing"
"gitea.maximumdirect.net/eric/notarius/internal/core/source"
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
)
func TestAssessProducesAStableOriginalPositionPlan(t *testing.T) {
@@ -23,8 +22,8 @@ func TestAssessProducesAStableOriginalPositionPlan(t *testing.T) {
if got := snapshotPlan(assessment.Plan()); !reflect.DeepEqual(got, want) {
t.Fatalf("plan = %#v, want %#v", got, want)
}
if assessment.DiscardedGroupCount() != 0 || assessment.RetryRequired() || len(assessment.Issues()) != 0 {
t.Fatalf("assessment diagnostics = discarded %d, retry %t, issues %#v", assessment.DiscardedGroupCount(), assessment.RetryRequired(), assessment.Issues())
if assessment.DiscardedGroupCount() != 0 || assessment.HasDiscardedGroups() || len(assessment.Issues()) != 0 {
t.Fatalf("assessment diagnostics = discarded count %d, has unsafe groups %t, issues %#v", assessment.DiscardedGroupCount(), assessment.HasDiscardedGroups(), assessment.Issues())
}
reordered := preparation.Assess(ProposalResponse{DuplicateGroups: []DuplicateGroup{
@@ -36,8 +35,8 @@ func TestAssessProducesAStableOriginalPositionPlan(t *testing.T) {
}
empty := preparation.Assess(ProposalResponse{})
if len(empty.Plan().Groups()) != 0 || len(empty.Issues()) != 0 || empty.DiscardedGroupCount() != 0 || empty.RetryRequired() {
t.Fatalf("empty assessment = plan %#v, issues %#v, discarded %d, retry %t", empty.Plan().Groups(), empty.Issues(), empty.DiscardedGroupCount(), empty.RetryRequired())
if len(empty.Plan().Groups()) != 0 || len(empty.Issues()) != 0 || empty.DiscardedGroupCount() != 0 || empty.HasDiscardedGroups() {
t.Fatalf("empty assessment = plan %#v, issues %#v, discarded count %d, has unsafe groups %t", empty.Plan().Groups(), empty.Issues(), empty.DiscardedGroupCount(), empty.HasDiscardedGroups())
}
}
@@ -52,7 +51,7 @@ func TestIssueDetailsPreservesIssueOrder(t *testing.T) {
}
}
func TestCorrectionGuidanceCoversEveryIssueCategoryWithoutExposingInternalLabels(t *testing.T) {
func TestCorrectionDetailsCoverEveryIssueCategoryWithoutExposingInternalLabels(t *testing.T) {
numberRange := CandidateNumberRange{First: 1, Last: 8}
if len(issueCorrectionProse) != len(allIssueCategories) {
t.Fatalf("correction prose entries = %d, categories = %d", len(issueCorrectionProse), len(allIssueCategories))
@@ -74,12 +73,9 @@ func TestCorrectionGuidanceCoversEveryIssueCategoryWithoutExposingInternalLabels
if err != nil {
t.Fatalf("CorrectionDetails() error = %v", err)
}
guidance, err := CorrectionGuidance(issues, numberRange)
if err != nil {
t.Fatalf("CorrectionGuidance() error = %v", err)
}
if len(details) != len(allIssueCategories)+1 || !strings.Contains(guidance, "Duplicate group 1") || !strings.Contains(guidance, "candidate-number range 1 through 8") || !strings.Contains(guidance, "start_unit_id") || !strings.Contains(guidance, "complete corrected JSON response") || len(guidance) > contracts.MaxNormalizeRetryCorrectionGuidanceBytes {
t.Fatalf("correction details = %#v guidance = %q", details, guidance)
guidance := strings.Join(details, " ")
if len(details) != len(allIssueCategories)+1 || !strings.Contains(guidance, "Duplicate group 1") || !strings.Contains(guidance, "candidate-number range 1 through 8") || !strings.Contains(guidance, "start_unit_id") {
t.Fatalf("correction details = %#v", details)
}
for _, category := range allIssueCategories {
if strings.Contains(guidance, string(category)) {
@@ -103,10 +99,6 @@ func TestCorrectionDetailsDeduplicatesAndBoundsAffectedGroupLists(t *testing.T)
if len(details) != 2 || !strings.Contains(details[0], "additional affected group") || strings.Count(details[0], "Duplicate groups") != 1 || !strings.Contains(details[1], "source positions") {
t.Fatalf("CorrectionDetails() = %#v, want one bounded grouped detail and one namespace reminder", details)
}
guidance, err := CorrectionGuidance(issues, numberRange)
if err != nil || len(guidance) > contracts.MaxNormalizeRetryCorrectionGuidanceBytes {
t.Fatalf("CorrectionGuidance() = %q, %v", guidance, err)
}
}
func TestCorrectionDetailsRejectsUnknownOrInvalidIssues(t *testing.T) {
@@ -145,8 +137,8 @@ func TestAssessRejectsEveryUnsafeLocalGroupShape(t *testing.T) {
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
assessment := preparation.Assess(ProposalResponse{DuplicateGroups: []DuplicateGroup{test.group}})
if len(assessment.Plan().Groups()) != 0 || assessment.DiscardedGroupCount() != 1 || !assessment.RetryRequired() {
t.Fatalf("assessment = plan %#v, discarded %d, retry %t", assessment.Plan().Groups(), assessment.DiscardedGroupCount(), assessment.RetryRequired())
if len(assessment.Plan().Groups()) != 0 || assessment.DiscardedGroupCount() != 1 || !assessment.HasDiscardedGroups() {
t.Fatalf("assessment = plan %#v, discarded count %d, has unsafe groups %t", assessment.Plan().Groups(), assessment.DiscardedGroupCount(), assessment.HasDiscardedGroups())
}
if !hasIssue(assessment.Issues(), 0, test.category) {
t.Fatalf("issues = %#v, want category %q", assessment.Issues(), test.category)
@@ -166,8 +158,8 @@ func TestAssessDiscardsEveryOverlappingGroupAndRetainsIndependentGroups(t *testi
if got := snapshotPlan(assessment.Plan()); !reflect.DeepEqual(got, wantPlan) {
t.Fatalf("plan = %#v, want %#v", got, wantPlan)
}
if assessment.DiscardedGroupCount() != 2 || !assessment.RetryRequired() {
t.Fatalf("discarded = %d, retry = %t", assessment.DiscardedGroupCount(), assessment.RetryRequired())
if assessment.DiscardedGroupCount() != 2 || !assessment.HasDiscardedGroups() {
t.Fatalf("discarded count = %d, has unsafe groups = %t", assessment.DiscardedGroupCount(), assessment.HasDiscardedGroups())
}
issues := assessment.Issues()
if len(issues) != 2 || !hasIssue(issues, 0, IssueOverlappingMember) || !hasIssue(issues, 1, IssueOverlappingMember) {
@@ -182,8 +174,8 @@ func TestAssessDiscardsEveryOverlappingGroupAndRetainsIndependentGroups(t *testi
if got := snapshotPlan(invalidAndSafe.Plan()); !reflect.DeepEqual(got, wantPlan) {
t.Fatalf("plan with independent invalid group = %#v, want %#v", got, wantPlan)
}
if invalidAndSafe.DiscardedGroupCount() != 1 || !invalidAndSafe.RetryRequired() || !hasIssue(invalidAndSafe.Issues(), 0, IssueMemberUnknown) {
t.Fatalf("invalid-and-safe assessment = discarded %d, retry %t, issues %#v", invalidAndSafe.DiscardedGroupCount(), invalidAndSafe.RetryRequired(), invalidAndSafe.Issues())
if invalidAndSafe.DiscardedGroupCount() != 1 || !invalidAndSafe.HasDiscardedGroups() || !hasIssue(invalidAndSafe.Issues(), 0, IssueMemberUnknown) {
t.Fatalf("invalid-and-safe assessment = discarded count %d, has unsafe groups %t, issues %#v", invalidAndSafe.DiscardedGroupCount(), invalidAndSafe.HasDiscardedGroups(), invalidAndSafe.Issues())
}
}

View File

@@ -0,0 +1,34 @@
package semanticreconcile
import (
"fmt"
"strings"
"go.maximumdirect.net/promptkit"
)
const PromptID = "notarius/generic.semantic_reconciliation"
const CorrectionPromptID = "notarius/generic.semantic_reconciliation.repair"
// InitialRequest selects a native prompt and copies already prepared evidence.
// The owner prepares once and retains the same Preparation for every proposal.
// Deterministic skips and preparation limits do not create synthetic requests.
func InitialRequest(preparation Preparation, promptID, profileID, sessionID string) (promptkit.RunRequest, error) {
if preparation.Disposition() != Ready {
return promptkit.RunRequest{}, fmt.Errorf("semantic reconciliation materials are not ready for execution")
}
inputs := make(map[string]promptkit.ArtifactRef, len(preparation.materials))
for name, content := range preparation.materials {
inputs[name] = promptkit.Inline(string(content))
}
return promptkit.RunRequest{PromptID: promptID, ProfileID: profileID, SessionID: sessionID, Inputs: inputs}, nil
}
// CorrectionRequest supplies only findings. Native coordination retains source
// windows, candidate handles, and prior proposals from the original exchange.
func CorrectionRequest(promptID, profileID, sessionID string, guidance []string) promptkit.RunRequest {
return promptkit.RunRequest{
PromptID: promptID, ProfileID: profileID, SessionID: sessionID,
Inputs: map[string]promptkit.ArtifactRef{"guidance": promptkit.Inline(strings.Join(guidance, "\n\n"))},
}
}

View File

@@ -1,41 +0,0 @@
package semanticreconcile
import (
"fmt"
"io/fs"
rootassets "gitea.maximumdirect.net/eric/notarius/assets"
"gitea.maximumdirect.net/eric/notarius/internal/framework/llm"
)
const (
ResponseSchemaKey = llm.ResponseSchemaKey("semantic_reconciliation_llm")
ResponseSchemaID = "notarius.generic.semantic_reconciliation.llm"
ResponseSchemaName = "notarius_semantic_reconciliation_llm_v1"
SchemaVersion = "v1"
SchemaAssetPath = "schemas/semantic_reconciliation_llm.v1.json"
)
func assetFS() (fs.FS, error) {
assets, err := fs.Sub(rootassets.FS(), "generic/normalize/deduplication")
if err != nil {
return nil, fmt.Errorf("scope semantic reconciliation assets: %w", err)
}
return assets, nil
}
// LoadResponseSchema returns the private request-local integer proposal
// contract. It is separate from every durable artifact schema.
func LoadResponseSchema() (llm.ResponseSchema, error) {
assets, err := assetFS()
if err != nil {
return llm.ResponseSchema{}, err
}
return llm.LoadResponseSchema(assets, llm.ResponseSchemaDefinition{
Key: ResponseSchemaKey,
ID: ResponseSchemaID,
Version: SchemaVersion,
Name: ResponseSchemaName,
AssetPath: SchemaAssetPath,
})
}

View File

@@ -3,38 +3,17 @@ package semanticreconcile
import (
"bytes"
"encoding/json"
"io/fs"
"reflect"
"strings"
"testing"
"gitea.maximumdirect.net/eric/notarius/assets"
"github.com/santhosh-tekuri/jsonschema/v6"
)
func TestResponseSchemaMetadataAndOwnership(t *testing.T) {
schema, err := LoadResponseSchema()
if err != nil {
t.Fatal(err)
}
if schema.Key != ResponseSchemaKey || schema.ID != ResponseSchemaID || schema.Version != SchemaVersion || schema.Name != ResponseSchemaName {
t.Fatalf("schema metadata = %#v", schema)
}
if !json.Valid(schema.JSONSchema) || !strings.HasPrefix(schema.SHA256, "sha256:") {
t.Fatalf("schema content metadata = %#v", schema)
}
first := append([]byte(nil), schema.JSONSchema...)
schema.JSONSchema[0] = '['
loadedAgain, err := LoadResponseSchema()
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(loadedAgain.JSONSchema, first) || !json.Valid(loadedAgain.JSONSchema) {
t.Fatal("LoadResponseSchema() exposed shared schema content")
}
}
func TestResponseSchemaAcceptsOnlyTheIntegerProposalShape(t *testing.T) {
schema, err := LoadResponseSchema()
schema, err := fs.ReadFile(assets.FS(), "generic/normalize/deduplication/schemas/semantic_reconciliation_llm.v1.json")
if err != nil {
t.Fatal(err)
}
@@ -66,7 +45,7 @@ func TestResponseSchemaAcceptsOnlyTheIntegerProposalShape(t *testing.T) {
if err != nil {
t.Fatal(err)
}
err = validateAgainstSchema(content, schema.JSONSchema)
err = validateAgainstSchema(content, schema)
if (err == nil) != test.valid {
t.Fatalf("schema validation error = %v, want valid=%t", err, test.valid)
}
@@ -74,11 +53,11 @@ func TestResponseSchemaAcceptsOnlyTheIntegerProposalShape(t *testing.T) {
}
content := []byte(`{"duplicate_groups":[{"candidate_numbers":[1,2],"canonical_candidate_number":2}]}`)
if err := validateAgainstSchema(content, schema.JSONSchema); err != nil {
if err := validateAgainstSchema(content, schema); err != nil {
t.Fatal(err)
}
var response ProposalResponse
if err := json.Unmarshal(content, &response); err != nil {
response, err := DecodeProposal(string(content))
if err != nil {
t.Fatal(err)
}
want := ProposalResponse{DuplicateGroups: []DuplicateGroup{{CandidateNumbers: []int{1, 2}, CanonicalCandidateNumber: 2}}}