diff --git a/agent/finalize.go b/agent/finalize.go index b9207e7..6753b10 100644 --- a/agent/finalize.go +++ b/agent/finalize.go @@ -1 +1,184 @@ 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 \ No newline at end of file +package agent + +import ( + "regexp" + "strings" + + "gitea.stevedudenhoeffer.com/steve/majordomo/llm" +) + +// finalOutput selects the user-facing answer when the loop reaches a clean +// terminal turn (one with no tool calls). +// +// Normally that terminal turn's text IS the answer: well-behaved models defer +// their answer to the final, tool-free turn. But some models — notably several +// open-weight ones — "front-load" their full answer into an earlier turn that +// ALSO calls a tool (e.g. answer text alongside a citation call), then close +// with a degenerate terminal turn that is not itself the answer. Two shapes are +// recovered from the transcript (zero extra model calls): +// +// - a trivial back-reference ("(Already answered above.)", "see above", …): +// the real answer sits earlier, so recover it and DISCARD the worthless +// closer. +// - a sources/citations-only addendum ("Sources: [x](…), [y](…)"): the model +// front-loaded the prose answer and closed with just its citations (the +// glm-5.2 "cite" pattern behind mort issue #1418). The citations are real, +// useful content — unlike a back-reference — so recover the prior answer and +// KEEP the citations, appended below it. +// +// A citations addendum is tested first and wins over the back-reference test (a +// short terminal can be both), so its links are never discarded. When the +// terminal text stands on its own it is returned unchanged; when it is +// degenerate but nothing better can be recovered, it is returned as-is (a bare +// sources list still beats nothing). +// +// msgs must already include the terminal assistant message as its last element +// (the loop appends it before calling this); terminal is that message's text. +func finalOutput(msgs []llm.Message, terminal string) string { + citations := isCitationsOnly(terminal) + if !citations && !isWeakFinal(terminal) { + return terminal + } + rec, ok := lastSubstantiveAssistantText(msgs, terminal, citations) + if !ok { + return terminal + } + if citations { + // Preserve the citations addendum below the recovered answer, unless the + // recovered turn already carries it verbatim (guards against a duplicate + // sources block when the front-loaded turn included its own citations). + if tail := strings.TrimSpace(terminal); !strings.Contains(rec, tail) { + return rec + "\n\n" + tail + } + } + return rec +} + +// backRefRe matches a terminal turn that merely points back to an earlier +// message instead of stating the answer ("(Already answered above.)", +// "see above", "as I said", ...). +var backRefRe = regexp.MustCompile(`(?i)(already answered|see above|as (i )?(said|mentioned|stated|noted)|answered (that )?above|per my (previous|earlier))`) + +// preambleRe matches intent-announcing prefixes ("Let me search...", "I'll +// check...") so a preamble is never mistaken for the answer during recovery. +var preambleRe = regexp.MustCompile(`(?i)^(let me|let'?s|i'?ll|i will|first[, ]|sure[,. ]|okay[,. ]|on it|checking)`) + +// citationLabelRe matches a terminal turn that OPENS with a sources/citations +// heading — the shape a model produces when it front-loads its answer into an +// earlier tool-call turn and closes with only its sources. Leading markdown +// emphasis / list / block-quote / ATX-heading markers (with their whitespace, +// via \s in the class) are tolerated before the label, and closing emphasis +// (** / __) plus whitespace between the label and the colon/dash separator. +// Anchored at ^ so a normal answer that merely mentions "sources" mid-sentence, +// or ends with a "Sources:" section AFTER its prose, is never matched. +var citationLabelRe = regexp.MustCompile(`(?i)^[\s>#*_+-]*(sources?|references?|citations?|works cited|further reading)\b[\s*_]*[:：\-—]`) + +// linkRe matches a whole markdown link "[label](url)" or a bare URL. Used both +// to require that a citations terminal carries at least one link and to strip +// links out when measuring how citation-dominated the terminal is. +var linkRe = regexp.MustCompile(`\[[^\]]*\]\([^)]*\)|https?://\S+`) + +// citationResidueCutset is trimmed from the ends of a citations terminal's +// non-link remainder before measuring it — list bullets, separators, and the +// short per-source annotations models add in parentheses. +const citationResidueCutset = " \t\r\n,;.:|·•*_()[]—-" + +const ( + // weakFinalMaxChars bounds how long a back-reference closer can be. A + // genuine final answer that merely contains "as I said" mid-sentence is + // longer than this, so it is never treated as weak. + weakFinalMaxChars = 120 + // recoverMinChars: a prior assistant turn this long is treated as a real + // answer regardless of how it opens (still gated by the preamble check). + recoverMinChars = 200 + // recoverFloorChars / recoverRatio gate the borderline band: a shorter + // prior turn must clear the floor and — unless the terminal is a citations + // addendum, which is not a rival answer — also clearly dwarf the (very + // short) terminal. See isSubstantiveAnswer. + recoverFloorChars = 80 + recoverRatio = 3 + // citationDominatedDivisor: a citations terminal's non-link remainder must + // be at most len/N of the whole, so a prose answer that merely opens with + // "Source:" and cites a URL mid-sentence is not mistaken for a bare list. + citationDominatedDivisor = 3 +) + +// isWeakFinal reports whether a terminal turn's text fails to stand on its own +// as the answer: empty/whitespace, or a short pure back-reference. +func isWeakFinal(s string) bool { + t := strings.TrimSpace(s) + if t == "" { + return true + } + return len(t) <= weakFinalMaxChars && backRefRe.MatchString(t) +} + +// isCitationsOnly reports whether a terminal turn is essentially just a +// sources/citations addendum: it OPENS with a citations heading, carries at +// least one link, and — once the heading and links are removed — is dominated +// by that citation structure (only list punctuation and short per-source +// annotations remain). The dominance check is what separates a bare sources +// list (recover the front-loaded answer, keep the links) from a real prose +// answer that merely opens with "Source:" and references a URL mid-sentence +// (leave it as the answer). Unlike a back-reference closer the links are worth +// keeping, so finalOutput appends them to the recovered answer. +// +// A citations terminal whose sources are bare domains (no scheme, no markdown +// link) is intentionally out of scope — there is no reliable link signal, so it +// is left as-is rather than risk misclassifying prose. +func isCitationsOnly(s string) bool { + t := strings.TrimSpace(s) + if !citationLabelRe.MatchString(t) { + return false + } + body := citationLabelRe.ReplaceAllString(t, "") + if !linkRe.MatchString(body) { + return false + } + residue := strings.Trim(linkRe.ReplaceAllString(body, ""), citationResidueCutset) + return len(residue) <= len(t)/citationDominatedDivisor +} + +// lastSubstantiveAssistantText scans msgs newest→oldest (skipping the terminal +// turn and empty tool-only turns) for the most recent assistant turn whose text +// reads like a real answer. citations selects the recovery bar (see +// isSubstantiveAnswer). Returns ("", false) when nothing qualifies. +func lastSubstantiveAssistantText(msgs []llm.Message, terminal string, citations bool) (string, bool) { + tt := strings.TrimSpace(terminal) + for i := len(msgs) - 1; i >= 0; i-- { + m := msgs[i] + if m.Role != llm.RoleAssistant { + continue + } + txt := strings.TrimSpace(m.Text()) + if txt == "" || txt == tt { + continue // the terminal turn itself, or an empty tool-only turn + } + if isSubstantiveAnswer(txt, tt, citations) { + return txt, true + } + } + return "", false +} + +// isSubstantiveAnswer reports whether txt (a prior assistant turn) reads like a +// real answer rather than a preamble, relative to the terminal text. +// +// A preamble ("Let me look that up…") is never the answer regardless of length, +// so that check applies BEFORE the length shortcut — otherwise a long planning +// narration would be recovered. A sufficiently long non-preamble turn is +// accepted; a shorter one must clear a floor and, unless the terminal is a +// citations addendum (not a rival answer, so its length is irrelevant), also +// clearly dwarf the terminal. +func isSubstantiveAnswer(txt, terminal string, citations bool) bool { + if preambleRe.MatchString(txt) { + return false + } + if len(txt) >= recoverMinChars { + return true + } + if len(txt) < recoverFloorChars { + return false + } + return citations || len(txt) >= recoverRatio*len(terminal) +}