jeopi-ai 16.2.27 → 16.2.28

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [16.2.28] - 2026-07-08
+
+### Fixed
+
+- `ThinkingInbandScanner` (leaked-reasoning healer for OpenAI-compatible/Ollama providers) only recognized a bare thinking tag once its closing `>` arrived — a model that drops the `>` entirely (`<thinke\n<reasoning text>`, going straight into its reasoning instead of finishing the tag) never resolved as an open at all: `bareTagPartialHold` holds the unterminated run only while the buffer stays within `MAX_BARE_TAG_NAME_LENGTH`, then gives up and flushes it as visible text once the reasoning that follows pushes the buffer past that bound. A well-formed close tag emitted later (`</thinking>`) then had no open to pair with either, so it also leaked verbatim — both the malformed open and the clean close ended up in the visible channel, sandwiching the reasoning they were meant to hide. Added `findUnterminatedBareThinkingOpen`: once a `<name` run is proven complete (immediately followed by anything other than `>`) and the name passes the existing one-typo thinking-name check, it's treated as an open with a `</thinking>` fallback close accepted alongside its own derived close — covering opens and closes that diverge independently within the same turn, matching the pattern actually observed in practice.
+- `AnthropicInbandScanner`'s (native Claude/`xml` dialect) tag tokenizer (`parseTag`) parsed a `<...>` span by taking everything between `<` and the *first* `>` anywhere ahead in the buffer as that one tag's attributes, with no check that the span was a coherent single-line attribute list. An unterminated/malformed open (the same dropped-`>` shape above) therefore did not just leak as text: it silently swallowed every character up to and including the *next* legitimate `>` in the stream — including a real `</thinking>` close — as bogus "attributes", discarding the actual reasoning between them and misclassifying whatever text followed the close as hidden thinking instead of a visible reply. `parseTag` now rejects a match whose captured attrs span contains a newline or an embedded `<` (real single-line attribute lists here, e.g. `signature="…"`, never contain either), falling through to the existing malformed-tag handling that leaks the lone `<` as one visible character and rescans — trading a cosmetic leak for what was previously silent data loss and mislabeling.
+
 ## [16.2.27] - 2026-07-07
 
 ### Fixed

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "jeopi-ai",
-	"version": "16.2.27",
+	"version": "16.2.28",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://github.com/akillness/jeopi",
 	"author": "Can Boluk",
@@ -38,9 +38,9 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"jeopi-catalog": "16.2.27",
-		"jeopi-utils": "16.2.27",
-		"jeopi-wire": "16.2.27",
+		"jeopi-catalog": "16.2.28",
+		"jeopi-utils": "16.2.28",
+		"jeopi-wire": "16.2.28",
 		"arktype": "^2.2.0",
 		"zod": "^4"
 	},

package/src/dialect/anthropic.ts

@@ -494,6 +494,23 @@ export class AnthropicInbandScanner implements InbandScanner {
 
 const ALL_TAG_PREFIXES = [...BASE_TAG_PREFIXES, ...ANTHROPIC_THINKING_TAG_PREFIXES] as const;
 
+/**
+ * Parse one `<...>` span already isolated by `#peekTag` (buffer up to and
+ * including its first `>`).
+ *
+ * The `attrs` capture (`[^>]*` with `/s`, so it also matches newlines) has no
+ * bound on its own past "not another `>`" — an unterminated open tag whose
+ * name/spelling never resolves before the *next* legitimate `>` elsewhere in
+ * the buffer (e.g. a later `</thinking>`) would otherwise parse as one tag
+ * whose bogus "attributes" span silently swallows everything in between,
+ * including real content and that legitimate close tag. Reject the match
+ * when the attrs span contains a newline or an embedded `<`: real attribute
+ * lists here (e.g. `signature="…"`) are always single-line with no nested
+ * tags, so either is conclusive proof `raw` isn't one coherent tag. The
+ * caller (`#peekTag` returning `undefined`) then falls through to emitting
+ * the leading `<` as one visible character and rescanning — malformed input
+ * leaks as text instead of corrupting parser state.
+ */
 function parseTag(raw: string): ParsedTag | undefined {
 	const match = /^<\s*(\/?)\s*(?:(?<prefix>[A-Za-z_][\w.-]*):)?(?<localName>[A-Za-z_][\w.-]*)(?<attrs>[^>]*)>$/s.exec(
 		raw,
@@ -501,6 +518,7 @@ function parseTag(raw: string): ParsedTag | undefined {
 	const localName = match?.groups?.localName;
 	if (!match || !localName) return undefined;
 	const attrsText = match.groups?.attrs ?? "";
+	if (attrsText.includes("\n") || attrsText.includes("<")) return undefined;
 	return {
 		raw,
 		localName: localName.toLowerCase(),

package/src/dialect/thinking.ts

@@ -2,7 +2,12 @@ import { partialSuffixOverlapAny } from "./coercion";
 import { FencedThinkingScanner } from "./fenced-thinking";
 import type { InbandScanEvent, InbandScanner } from "./types";
 
-type Tag = { readonly open: string; readonly close: string; readonly fenced?: boolean };
+type Tag = {
+	readonly open: string;
+	readonly close: string;
+	readonly fenced?: boolean;
+	readonly closeFallback?: string;
+};
 
 /**
  * Every dialect's in-band thinking section in its canonical `renderThinking`
@@ -74,12 +79,60 @@ function levenshteinAtMost(a: string, b: string, max: number): boolean {
  * {@link isThinkingTagName}, paired with its matching `</name>` close. Runs
  * alongside the literal {@link TAGS} idioms so `<think>`/`<thinking>`/
  * `<scratchpad>` and their one-typo variants share a single fuzzy path.
+ * `closeFallback` additionally accepts a clean `</thinking>` close even when
+ * the open itself was a typo'd variant — evidence shows a model's open and
+ * close spellings can diverge independently within the same turn.
  */
 function findBareThinkingOpen(buffer: string): (Tag & { index: number }) | undefined {
 	for (const match of buffer.matchAll(BARE_TAG_OPEN_PATTERN)) {
 		const name = match[1]!;
 		if (!isThinkingTagName(name)) continue;
-		return { open: match[0], close: `</${name}>`, index: match.index };
+		const close = `</${name}>`;
+		return {
+			open: match[0],
+			close,
+			closeFallback: close === "</thinking>" ? undefined : "</thinking>",
+			index: match.index,
+		};
+	}
+	return undefined;
+}
+
+/**
+ * Detect a bare thinking-tag open that can never close validly: `<` followed
+ * by a name-shaped run (passing {@link isThinkingTagName}) that is itself
+ * immediately followed by something other than `>` — whitespace, a newline,
+ * or any other character. A model that drops the closing `>` (or garbles
+ * `<thinking>` into `<thinke` before moving straight into its actual
+ * reasoning) leaves exactly this shape: `<thinke\n<reasoning text>`. Unlike
+ * {@link bareTagPartialHold}, which holds a run that could *still* grow into
+ * a valid `<name>`, this fires only once the buffer proves the run is over
+ * and no `>` arrived — so it never races with, or preempts, the
+ * well-formed/one-typo match above (that one requires `>` immediately after
+ * the name; this one requires the opposite).
+ *
+ * `closeFallback` is always `</thinking>`: the malformed open carries no
+ * reliable spelling to expect back, so any well-formed thinking close ends
+ * the block. This is the exact failure mode reported in practice: a broken
+ * open (`<thinke`, no `>`) paired with a clean `</thinking>` close — without
+ * this, neither tag is ever recognized and both leak verbatim into the
+ * visible channel around the reasoning text they were meant to wrap.
+ */
+function findUnterminatedBareThinkingOpen(buffer: string): (Tag & { index: number }) | undefined {
+	for (let i = 0; i < buffer.length; i++) {
+		if (buffer[i] !== "<") continue;
+		const nameStart = i + 1;
+		if (!/[A-Za-z]/.test(buffer[nameStart] ?? "")) continue;
+		let end = nameStart + 1;
+		while (end < buffer.length && end - nameStart < MAX_BARE_TAG_NAME_LENGTH && /[A-Za-z0-9]/.test(buffer[end]!)) {
+			end++;
+		}
+		// Still growable (name run hit the end of the buffer with no terminator
+		// yet), or a valid `>`-closed tag — not this function's job either way.
+		if (end >= buffer.length || buffer[end] === ">") continue;
+		const name = buffer.slice(nameStart, end);
+		if (!isThinkingTagName(name)) continue;
+		return { open: buffer.slice(i, end), close: `</${name}>`, closeFallback: "</thinking>", index: i };
 	}
 	return undefined;
 }
@@ -91,7 +144,12 @@ function findBareThinkingOpen(buffer: string): (Tag & { index: number }) | undef
  * matched {@link isThinkingTagName} — e.g. `<thinke` must survive until the
  * closing `>` arrives and resolves it. Bounded by
  * {@link MAX_BARE_TAG_NAME_LENGTH} so an angle bracket in ordinary prose
- * can't stall the stream indefinitely.
+ * can't stall the stream indefinitely; once that bound is exceeded without a
+ * `>`, {@link findUnterminatedBareThinkingOpen} has already had — and taken —
+ * its chance to recognize a conclusively-broken thinking-tag attempt on the
+ * same buffer, so anything still unresolved here is either not
+ * thinking-tag-shaped or a `<` in ordinary prose, and is safe to release as
+ * visible text.
  */
 function bareTagPartialHold(buffer: string): number {
 	const openIndex = buffer.lastIndexOf("<");
@@ -104,6 +162,11 @@ function bareTagPartialHold(buffer: string): number {
 export class ThinkingInbandScanner implements InbandScanner {
 	#buffer = "";
 	#closeTag = "";
+	/** Alternate close accepted alongside {@link #closeTag} — set when the open
+	 *  tag's own spelling can't be trusted as a predictor of the close spelling
+	 *  (see {@link findUnterminatedBareThinkingOpen}). Empty when there is no
+	 *  fallback, in which case only `#closeTag` is checked. */
+	#closeFallback = "";
 	#thinking = "";
 	/** Fence-aware close-matcher while inside a ` ```thinking ` block; undefined otherwise. */
 	#fenced: FencedThinkingScanner | undefined;
@@ -125,6 +188,7 @@ export class ThinkingInbandScanner implements InbandScanner {
 		}
 		this.#buffer = "";
 		this.#closeTag = "";
+		this.#closeFallback = "";
 		return events;
 	}
 
@@ -140,6 +204,7 @@ export class ThinkingInbandScanner implements InbandScanner {
 					events.push({ type: "thinkingEnd", thinking: this.#thinking });
 					this.#thinking = "";
 					this.#closeTag = "";
+					this.#closeFallback = "";
 					this.#fenced = undefined;
 				}
 				if (this.#fenced) break;
@@ -147,18 +212,20 @@ export class ThinkingInbandScanner implements InbandScanner {
 			}
 			if (this.#buffer.length === 0) break;
 			if (this.#closeTag) {
-				const close = this.#buffer.indexOf(this.#closeTag);
-				if (close === -1) {
-					const hold = final ? 0 : partialSuffixOverlapAny(this.#buffer, [this.#closeTag]);
+				const candidates = this.#closeFallback ? [this.#closeTag, this.#closeFallback] : [this.#closeTag];
+				const found = earliestIndexOf(this.#buffer, candidates);
+				if (!found) {
+					const hold = final ? 0 : partialSuffixOverlapAny(this.#buffer, candidates);
 					this.#emitThinking(this.#buffer.slice(0, this.#buffer.length - hold), events);
 					this.#buffer = this.#buffer.slice(this.#buffer.length - hold);
 					break;
 				}
-				this.#emitThinking(this.#buffer.slice(0, close), events);
-				this.#buffer = this.#buffer.slice(close + this.#closeTag.length);
+				this.#emitThinking(this.#buffer.slice(0, found.index), events);
+				this.#buffer = this.#buffer.slice(found.index + found.tag.length);
 				events.push({ type: "thinkingEnd", thinking: this.#thinking });
 				this.#thinking = "";
 				this.#closeTag = "";
+				this.#closeFallback = "";
 				continue;
 			}
 
@@ -175,6 +242,7 @@ export class ThinkingInbandScanner implements InbandScanner {
 			if (tag.index > 0) events.push({ type: "text", text: this.#buffer.slice(0, tag.index) });
 			this.#buffer = this.#buffer.slice(tag.index + tag.open.length);
 			this.#closeTag = tag.close;
+			this.#closeFallback = tag.closeFallback ?? "";
 			this.#thinking = "";
 			if (tag.fenced) this.#fenced = new FencedThinkingScanner();
 			events.push({ type: "thinkingStart" });
@@ -189,6 +257,16 @@ export class ThinkingInbandScanner implements InbandScanner {
 	}
 }
 
+/** Earliest match among several candidate substrings, or `undefined` if none occur. */
+function earliestIndexOf(buffer: string, candidates: readonly string[]): { index: number; tag: string } | undefined {
+	let best: { index: number; tag: string } | undefined;
+	for (const tag of candidates) {
+		const index = buffer.indexOf(tag);
+		if (index !== -1 && (!best || index < best.index)) best = { index, tag };
+	}
+	return best;
+}
+
 function findEarliestOpen(buffer: string): (Tag & { index: number }) | undefined {
 	let best: (Tag & { index: number }) | undefined;
 	for (const tag of TAGS) {
@@ -197,5 +275,7 @@ function findEarliestOpen(buffer: string): (Tag & { index: number }) | undefined
 	}
 	const bare = findBareThinkingOpen(buffer);
 	if (bare && (!best || bare.index < best.index)) best = bare;
+	const unterminated = findUnterminatedBareThinkingOpen(buffer);
+	if (unterminated && (!best || unterminated.index < best.index)) best = unterminated;
 	return best;
 }