2 Commits

Author	SHA1	Message	Date
Patrick Buckley	70165807c7	fix(reasoning): close the unmarked chain-of-thought leak, gate the tag scan by backend (#940) (#978) ... Some serving setups emit model reasoning inline with no think tags and no reasoning_content at all — nothing any parser can segregate (measured live on the dev vLLM: 20/20 sampled completions, streamed and not, proxied and direct). The drain seam correctly passes unmarked prose through, so it became the artifact on every bounded-artifact lane: workstream titles ("Thinking Process:"), compaction summaries that were ~90% chain-of- thought, and the web-fetch tool results #940 reports — which then ride every following turn as context. Three coordinated changes: * Utility lanes ask for no reasoning. _utility_completion (title, compaction, web-fetch extraction) pins the alias's declared thinking toggle off and withholds every reasoning-effort channel — the relayed session knob, the lane rung, the definition default, and the graded template key — via lane_without_thinking / lane_thinking_suppressed, the same suppression omni transcription already used (now shared as thinking_off_template_kwargs). Measured end-to-end: the extraction that returned 3.7k chars of reasoning returns a 258-char answer. * server_parses_reasoning capability. A backend that segregates reasoning into its own channel declares it, and the inline tag scan turns off on every lane: the drain seam, the interactive splitter (which now reads the ACTIVE stream's capabilities via the creation- time handoff register, never the primary alias's), and the title lane's cosmetic peel — so prose that merely quotes a tag can no longer be misrouted, and the utility suppression stands down where reasoning costs the artifact nothing. The built-in commercial capability tables declare it wholesale (known models and table-miss defaults); local compat lanes keep the passthrough default the scan exists for. Bool-typed capability overrides coerce string spellings instead of truthiness-flipping on hand-edited JSON. * Title selection follows the prompt's contract, not line position: the last line within the word cap that ends in a word character — rejecting explanation sentences, sign-offs, parentheticals, and reasoning headings in any script (terminal punctuation carries unspaced scripts where whitespace word counts are meaningless) — else the last non-empty line. 20/20 captured live responses title correctly (9/20 before, unchanged since well before the seam unification: the old and new pipelines scored identically on every sample, so the regression source was the backend's output shape, not #965). Also folded in from the review round: a think tag split across a reasoning-delta boundary reassembles in the drain (partial-tag tail carry; tool boundaries still flush), Turn.text joins text blocks with a newline so multi-block answers stop fusing words in notification bodies and every flattened read, the notify hook reads final_assistant_text directly instead of through a one-line shim, web-fetch extraction uses the shared _non_blank_or fallback, and the judge/output-guard suites use real ModelCapabilities instead of truthy mock attributes. Closes #940.	2026-08-05 12:58:55 -07:00
Patrick Buckley	bc3fa60011	fix(providers): segregate inline reasoning at the drain seam ... Passthrough servers (parserless vLLM/llama.cpp, LM Studio, bare gateways) emit reasoning as literal <think>/<reasoning> blocks inside content, and only three of nine drained lanes stripped them: web_fetch tool results persisted raw think blocks into every following turn (#940), judge verdicts parsed through tag noise, and a draft verdict inside a think block could shadow the real one at the output guard. One rule at the seam now. drain_stream accumulates content in RUNS bounded by interleaving signals (provider-parsed reasoning deltas, tool-call deltas) with the interactive consumer's within-chunk ordering — reasoning, then content, then the tool-call close — and splits each run through split_inline_reasoning, the one-shot form of the interactive lane's ThinkTagSplitter: a pure raw split, exactly equivalent to the streaming form on every catalog case. One trim policy exists and the drain owns it: blank edge lines are trimmed once over the joined runs when a tag was consumed, so tag residue dies at the edges while genuine inter-run paragraph separators survive. Extracted text is appended to result.reasoning after any server-parsed reasoning with a blank-line boundary and rides the native lane as the reasoning_text synth block. Orphan CLOSE tags deliberately pass through byte-identical: a close whose open never arrived is indistinguishable from prose QUOTING the tag, and drained lanes routinely quote third-party text — reclassifying would let a malicious page containing the literal tag destroy the extraction that cites it. The title lane keeps a local rfind peel as display-string formatting. The citations footer folds only onto non-blank content — sourcing for an answer that does not exist is dropped rather than handed to emptiness checks as a footer-only "answer". Every private strip is deleted: the title lane's strip, the summarizer strip, _strip_reasoning itself, and the optimizer's five regexes (_strip_markdown_fence is now the one fence rule, applied to normalized model output only, never to or-fallback values). Think-only and whitespace-only responses drain to blank content, and every lane's no-answer fallback gates on blankness: web_fetch returns an honest extraction-error card, the intent judge takes the empty-retry ladder, the task-agent synthesis reports "(no output)", and the optimizer keeps the current observer system and prompt verbatim on no-answer passes. Final-say reads (optimizer analyst, eval final_content, the notify hook) use trajectory.final_assistant_text — the last assistant turn only, never an earlier narration presented as the conclusion — while last_assistant_text is the salvage walk (task_agent partial-work recovery), skipping tool-call-only, all-reasoning, and whitespace-only turns. Perception memoizes every completed description immediately, including an empty one — one perceive per key, ever — under a commit-lock guard so an empty result never overwrites a concurrently memoized real description; an all-reasoning perception model pins the placeholder until restart, and the remediation is server-side (a reasoning parser or the template thinking toggle on the perception alias). A true double-reasoning shape (inline-extracted text alongside a native reasoning block) logs chars-only at the drain, where it is distinguishable from the routine reasoning_delta mirror. The dialect's semantics are pinned as one table (tests/_reasoning_dialect.py) driven through shared fixtures (think_tag_stream, seam_provider): one-shot conformance, the exact one-shot/streaming equivalence property, the drain seam rules including quoted-tag safety, run-boundary and separator-preservation pins, per-lane pins for all nine lanes, and the empty-content assistant wire shape. Closes #965. Closes #940.	2026-08-05 00:23:11 -07:00