Files
audita/internal/framework/validators/llm_context.go

93 lines
3.2 KiB
Go

package validators
import (
"slices"
"gitea.maximumdirect.net/eric/audita/v3/internal/core/glossary"
"gitea.maximumdirect.net/eric/audita/v3/internal/core/schema"
)
// GlossaryView holds the read-only matching data shared by a stage's validators
// and apply-time checks.
type GlossaryView struct {
Protection glossary.ProtectedVocabulary
context glossaryContext
}
func PrepareGlossaryView(entries []glossary.Entry, protected []glossary.Term) *GlossaryView {
return &GlossaryView{Protection: glossary.NewProtectedVocabulary(protected), context: prepareGlossaryContext(entries)}
}
type glossaryContext struct {
entries []glossary.Entry
positions map[glossary.Identity][]int
vocabulary glossary.ProtectedVocabulary
}
func prepareGlossaryContext(entries []glossary.Entry) glossaryContext {
positions := make(map[glossary.Identity][]int, len(entries))
for i, entry := range entries {
identity := glossary.Identity{Collection: entry.Collection, ID: entry.ID}
positions[identity] = append(positions[identity], i)
}
return glossaryContext{entries: entries, positions: positions, vocabulary: glossary.NewProtectedVocabulary(glossary.Vocabulary(entries, nil))}
}
type optionalValidationContext func(LLMValidationItem) ([]NeighboringSegment, []glossary.Entry)
// validationContextFor builds optional context on demand. Unchanged segment
// matches are shared within the request. Corrected text is candidate-specific.
func validationContextFor(req Request) optionalValidationContext {
segments := req.sectionLookup().segments
var view *glossaryContext
if req.GlossaryView != nil {
view = &req.GlossaryView.context
}
var sourceMentions map[int]map[glossary.Identity]struct{}
return func(item LLMValidationItem) ([]NeighboringSegment, []glossary.Entry) {
position := item.segmentPosition
var neighbors []NeighboringSegment
if position > 0 {
neighbors = append(neighbors, neighboringSegment("preceding", segments[position-1]))
}
if position+1 < len(segments) {
neighbors = append(neighbors, neighboringSegment("following", segments[position+1]))
}
if view == nil {
prepared := prepareGlossaryContext(req.Glossary)
view = &prepared
}
if view.vocabulary.Empty() {
return neighbors, nil
}
if sourceMentions == nil {
sourceMentions = make(map[int]map[glossary.Identity]struct{})
}
mentioned := view.vocabulary.MentionedIdentities(item.CorrectedSegmentText)
for i := max(0, position-1); i < min(len(segments), position+2); i++ {
identities, ok := sourceMentions[i]
if !ok {
identities = view.vocabulary.MentionedIdentities(segments[i].Text)
sourceMentions[i] = identities
}
for id := range identities {
mentioned[id] = struct{}{}
}
}
var matched []int
for identity := range mentioned {
matched = append(matched, view.positions[identity]...)
}
slices.Sort(matched)
var entries []glossary.Entry
for _, index := range matched {
entries = append(entries, view.entries[index])
}
return neighbors, entries
}
}
func neighboringSegment(position string, segment schema.Segment) NeighboringSegment {
return NeighboringSegment{Position: position, Speaker: segment.Speaker, Text: segment.Text, Categories: segment.Categories}
}