Files
notarius/internal/framework/pipeline/runner_chunk_plan.go

113 lines
4.9 KiB
Go
Raw Normal View History

package pipeline
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"gitea.maximumdirect.net/eric/notarius/internal/core/source"
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
)
type chunkPlanExecution struct {
outcome contracts.ProducerOutcome
accepted bool
chunks []source.Chunk
plan *source.ChunkPlan
diagnostics []contracts.DiagnosticGroup
}
// Chunk planning remains serial before lane workers. Only a native chunk
// producer uses the accepted-artifact cache; deterministic plans run directly.
func (r *Runner) runChunkPlan(ctx context.Context, input RunInput, doc *source.SourceDocument, sourceInput contracts.LLMInputMaterial, sessionID string) (result chunkPlanExecution, err error) {
chunker := input.Prepared.chunker
origin := contracts.DiagnosticOrigin{Stage: contracts.DiagnosticOriginStageChunk, ModuleKey: chunker.Key()}
execution := operationExecution(input, origin, nil)
defer func() {
errorText := ""
if err != nil {
errorText = err.Error()
}
err = captureFailure(err, execution.RecordEvidence("outcome.json", map[string]any{"outcome": result.outcome, "plan": result.plan, "chunks": debugSourceChunkEnvelopes(result.chunks), "error": errorText}))
}()
target := typedValidationTarget{stage: StageChunk, moduleKey: chunker.Key(), source: doc, sourceID: doc.ID, sourceInput: sourceInput.Clone(), sessionID: sessionID, references: input.pipeline.ChunkReferences.ReferenceSet, metadata: input.Metadata, execution: execution}
if err := captureOperationInputs(execution, target, input.pipeline.Chunk, nil); err != nil {
return result, err
}
assessChunks := chunkCandidateAssessor(target, input.Prepared.chunkValidators)
var assessment contracts.CandidateAssessment
candidateNumber := 0
operation := contracts.ProducerOperation[source.ChunkPlan]{Controls: input.pipeline.ChunkControls, Execution: execution, ReuseEligible: !input.reuseIneligible,
Assess: func(ctx context.Context, plan source.ChunkPlan) (contracts.CandidateAssessment, error) {
if execution.Capture != nil {
candidateNumber++
if err := execution.RecordEvidence(fmt.Sprintf("plans/candidate-%d.json", candidateNumber), plan); err != nil {
return contracts.CandidateAssessment{}, err
}
}
_, chunks, err := validateAndMaterializeChunkPlan(doc, plan)
if err != nil {
if input.pipeline.ChunkExecutionClass == contracts.ExecutionClassDeterministic {
return contracts.CandidateAssessment{}, err
}
assessment = contracts.CandidateAssessment{Validators: []contracts.ValidatorAssessment{{ValidatorName: "chunk materialization", Decision: contracts.AssessmentFailed, Failure: err}}}
return assessment, nil
}
assessment, err = assessChunks(ctx, chunks)
return assessment, err
},
}
var cacheDiagnostics []contracts.ProducerDiagnostic
if input.Cache != nil && input.pipeline.ChunkExecutionClass == contracts.ExecutionClassLLMBacked {
operation.Cache = &contracts.ProducerCache[source.ChunkPlan]{
Store: input.Cache,
Encode: func(plan source.ChunkPlan) ([]byte, error) {
canonical, _, err := validateAndMaterializeChunkPlan(doc, plan)
2026-08-27 00:35:37 +00:00
if err != nil {
return nil, err
}
return json.Marshal(canonical)
},
Decode: func(content []byte) (source.ChunkPlan, error) {
var plan source.ChunkPlan
decoder := json.NewDecoder(bytes.NewReader(content))
decoder.DisallowUnknownFields()
if err := decoder.Decode(&plan); err != nil {
return source.ChunkPlan{}, err
}
var trailing any
if err := decoder.Decode(&trailing); err != io.EOF {
return source.ChunkPlan{}, fmt.Errorf("cached chunk plan must contain one JSON value")
}
canonical, _, err := validateAndMaterializeChunkPlan(doc, plan)
return canonical, err
},
Observe: producerCacheObserver(input, origin, nil, &cacheDiagnostics),
}
}
metadata, err := cloneMetadata(input.Metadata)
if err != nil {
return result, err
}
if err := ctx.Err(); err != nil {
return result, err
2026-08-27 01:27:25 +00:00
}
produced, err := chunker.Plan(ctx, contracts.ChunkRequest{Operation: operation, Source: doc, SourceInput: sourceInput.Clone(), SessionID: sessionID, References: CloneReferenceSet(target.references), LLMProfile: input.pipeline.Chunk.LLMProfile, Metadata: metadata})
if err != nil {
return result, fmt.Errorf("chunk source with %q: %w", chunker.Key(), err)
}
plan, outcome, err := completeProducerOperation(ctx, input.pipeline.ChunkExecutionClass, operation, produced.Plan, produced.Outcome, produced.Fallback)
if err != nil {
return result, fmt.Errorf("accept chunk plan with %q: %w", chunker.Key(), err)
}
plan, chunks, err := validateAndMaterializeChunkPlan(doc, plan)
if err != nil {
return result, fmt.Errorf("materialize final chunk plan: %w", err)
}
result.plan, result.chunks, result.accepted, result.outcome = &plan, chunks, true, outcome
result.diagnostics, err = operationDiagnosticGroups(produced.Diagnostics, cacheDiagnostics, assessment, outcome, origin, nil)
return result, err
}