jeopi-ai 16.2.26 → 16.2.28

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [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
+
+- Leaked reasoning healing (`ThinkingInbandScanner`, and the owned `AnthropicInbandScanner`/`xml` dialect scanner) required an exact `<think>`/`<thinking>`/`<scratchpad>` tag name, so a model that consistently hallucinates a one-character-off spelling for both its open and close tag (e.g. `<thinke>...</thinke>`) leaked the entire block — tag and body — into the visible reply verbatim instead of collapsing into a thinking section. Both scanners now recognize any bare `<name>` whose name is within one character edit of a canonical thinking tag name and shares its prefix (`thinke`, `thinkin`, `scratchpaid`, …), while unrelated short words (`thing`, `thin`, `<div>`, …) are unaffected.
+- Cloud Code Assist (`google-gemini-cli`/`google-antigravity`) buffers a leaked raw tool-planning JSON object (`{"thought": "…", "call": "read", "paths": […]}`, mirroring jeopi's own tool-argument shapes) out of the visible text stream instead of a structured `functionCall` — but the buffer was gated to `model.id.includes("flash")`, so every non-flash id was unprotected. That includes the `google-antigravity` default model (`gemini-3.1-pro`), other Gemini-3 pro/agent tiers, and Claude-on-antigravity ids: the identical leak rendered straight into the TUI as raw JSON on every occurrence instead of being intercepted. The buffer now applies unconditionally across the whole Cloud Code Assist surface; the underlying `isPlanningLeakPrefix`/`isPlanningLeakObject` heuristics only fire on a leading `{"thought"…}`-shaped object, so this carries no additional false-positive risk for other model families.
+- `getOpenRouterHeaders()` identified every OpenRouter-routed request (chat completions and, via a duplicated inline copy in the coding-agent `image-gen` tool, image generation) as `User-Agent: Oh-My-Pi/…`, `HTTP-Referer: https://omp.sh/`, `X-OpenRouter-Title: Oh-My-Pi` — a leftover from before the fork went npm-independent, misattributing every jeopi user's OpenRouter traffic, analytics, and app rankings to the upstream project. Now sends `jeopi/<version>`, the fork's GitHub homepage, and `X-OpenRouter-Title: jeopi`; `image-gen.ts`'s duplicated header block was replaced with a call to the shared helper.
+- `RemoteAuthCredentialStore`'s three mutation-refusal error messages (`replaceAuthCredentialsForProvider`, `upsertAuthCredentialForProvider`, `deleteAuthCredentialsForProvider`) told users to run `omp auth-broker login`/`omp auth-broker logout` — a command that doesn't exist; the real CLI is `jeopi auth-broker login <provider>`/`jeopi auth-broker logout <provider>`. Doc comments across `stream.ts`, `auth-broker/client.ts`, `auth-broker/discover.ts`, `auth-gateway/server.ts`, `auth-gateway/types.ts`, and `providers/pi-native-client.ts` carried the same stale `omp auth-broker`/`omp auth-gateway` command examples and product references. Fixed all to `jeopi`.
+
 ## [16.2.26] - 2026-07-05
 
 ### Fixed

package/README.md

@@ -970,7 +970,7 @@ and optional mTLS material (`CLAUDE_CODE_CLIENT_CERT`, `CLAUDE_CODE_CLIENT_KEY`)
 `NODE_EXTRA_CA_CERTS` (PEM file path or inline PEM, mirroring Node's contract)
 is honoured on every provider fetch — OpenAI-compatible, Codex, Ollama, Azure
 Responses, Google, and Anthropic alike — for corporate relays or private CA
-bundles. Bun's `fetch` does not consume the env var natively, so omp injects
+bundles. Bun's `fetch` does not consume the env var natively, so jeopi injects
 the bundle into `RequestInit.tls.ca` and seeds the system root store
 alongside it.
 
@@ -1068,14 +1068,14 @@ Official docs: [Application Default Credentials](https://cloud.google.com/docs/a
 
 ### CLI Login
 
-Authenticate via the [`omp`](https://omp.sh) coding-agent CLI, which drives this library's OAuth/API-key flows in-process and persists into `agent.db`:
+Authenticate via the [`jeopi`](https://github.com/akillness/jeopi) coding-agent CLI, which drives this library's OAuth/API-key flows in-process and persists into `agent.db`:
 
 ```bash
-omp auth-broker login              # interactive provider selection
-omp auth-broker login anthropic    # login to a specific provider
-omp auth-broker login vllm         # store vLLM API key (or placeholder for local no-auth)
-omp auth-broker list               # list supported providers
-omp auth-broker logout             # interactive — pick a stored credential to remove
+jeopi auth-broker login              # interactive provider selection
+jeopi auth-broker login anthropic    # login to a specific provider
+jeopi auth-broker login vllm         # store vLLM API key (or placeholder for local no-auth)
+jeopi auth-broker list               # list supported providers
+jeopi auth-broker logout             # interactive — pick a stored credential to remove
 ```
 
 Credentials are saved to `agent.db` in the agent directory. `/login qianfan` opens the Qianfan console and stores the pasted API key.

package/dist/types/auth-broker/client.d.ts

@@ -1,8 +1,8 @@
 /**
- * HTTP client for the omp auth-broker server.
+ * HTTP client for the jeopi auth-broker server.
  *
  * Used by {@link RemoteAuthCredentialStore} (snapshot pulls) and by
- * `omp auth-broker status` (liveness checks). All endpoints except
+ * `jeopi auth-broker status` (liveness checks). All endpoints except
  * `/v1/healthz` require a bearer token.
  */
 import type { AuthCredential } from "../auth-storage";

package/dist/types/auth-broker/discover.d.ts

@@ -13,7 +13,7 @@ export interface DiscoverAuthStorageOptions {
     cachePath?: string;
     sourceLabel?: string;
 }
-/** Path to the local bearer token file. Created by `omp auth-broker token`. */
+/** Path to the local bearer token file. Created by `jeopi auth-broker token`. */
 export declare function getAuthBrokerTokenFilePath(): string;
 /**
  * Resolve broker connection configuration using the same precedence as the TUI:

package/dist/types/auth-gateway/server.d.ts

@@ -1,12 +1,12 @@
 /**
- * omp auth-gateway HTTP server.
+ * jeopi auth-gateway HTTP server.
  *
  * Accepts any provider-format request (OpenAI chat-completions, Anthropic
  * messages, OpenAI Responses) and dispatches through pi-ai's `streamSimple()`
  * — which handles credential injection, anthropic-beta headers, codex
  * websocket transport, and all the per-provider intricacies. The gateway is
- * pure protocol translation: foreign wire → omp Context → pi-ai stream() →
- * omp events → foreign wire.
+ * pure protocol translation: foreign wire → jeopi Context → pi-ai stream() →
+ * jeopi events → foreign wire.
  *
  * Endpoints:
  *   GET  /healthz                          → unauth; ok + version

package/dist/types/auth-gateway/types.d.ts

@@ -1,9 +1,9 @@
 import type { Effort } from "jeopi-catalog/effort";
 import type { AssistantMessage, AssistantMessageEventStream, CacheRetention, Context, ServiceTier, TokenTaskBudget } from "../types";
 /**
- * Wire types for the omp auth-gateway.
+ * Wire types for the jeopi auth-gateway.
  *
- * The gateway sits between unauthenticated clients (containerized omp,
+ * The gateway sits between unauthenticated clients (containerized jeopi,
  * llm-git, …) and the broker. It accepts provider-format HTTP requests
  * (OpenAI chat-completions / Anthropic messages / OpenAI Responses),
  * dispatches them through pi-ai's `streamSimple()`, and translates the

package/dist/types/dialect/thinking.d.ts

@@ -1,4 +1,12 @@
 import type { InbandScanEvent, InbandScanner } from "./types";
+/**
+ * True for the canonical thinking tag names, plus names within one character
+ * edit of `think`/`thinking`/`scratchpad` that also share that name's prefix —
+ * the shape of a real hallucinated typo (`thinke`, `thinkin`, `scratchpaid`),
+ * not an unrelated short word (`thing`, `thin`, `chink` all fail the prefix
+ * guard despite being edit-distance 1 from `think`).
+ */
+export declare function isThinkingTagName(name: string): boolean;
 export declare class ThinkingInbandScanner implements InbandScanner {
     #private;
     feed(text: string): InbandScanEvent[];

package/dist/types/providers/pi-native-client.d.ts

@@ -1,6 +1,6 @@
 import type { Api, AssistantMessageEventStream as AssistantMessageEventStreamType, Context, Model, SimpleStreamOptions } from "../types";
 /**
- * Stream a turn through an `omp auth-gateway` over the pi-native protocol.
+ * Stream a turn through a `jeopi auth-gateway` over the pi-native protocol.
  *
  * The returned {@link AssistantMessageEventStream} receives each parsed
  * `AssistantMessageEvent` verbatim from the gateway; the terminal `done` /

package/dist/types/stream.d.ts

@@ -30,7 +30,7 @@ export declare function getEnvApiKey(provider: string): string | undefined;
 export declare function getEnvApiKeyName(provider: string): string | undefined;
 /**
  * Enumerate every provider that has an env-var fallback for `getEnvApiKey`.
- * Used by `omp auth-broker migrate --include-env` to discover env-sourced keys
+ * Used by `jeopi auth-broker migrate --include-env` to discover env-sourced keys
  * that should be uploaded to the broker.
  */
 export declare function listProvidersWithEnvKey(): string[];

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "jeopi-ai",
-	"version": "16.2.26",
+	"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.26",
-		"jeopi-utils": "16.2.26",
-		"jeopi-wire": "16.2.26",
+		"jeopi-catalog": "16.2.28",
+		"jeopi-utils": "16.2.28",
+		"jeopi-wire": "16.2.28",
 		"arktype": "^2.2.0",
 		"zod": "^4"
 	},

package/src/auth-broker/client.ts

@@ -1,8 +1,8 @@
 /**
- * HTTP client for the omp auth-broker server.
+ * HTTP client for the jeopi auth-broker server.
  *
  * Used by {@link RemoteAuthCredentialStore} (snapshot pulls) and by
- * `omp auth-broker status` (liveness checks). All endpoints except
+ * `jeopi auth-broker status` (liveness checks). All endpoints except
  * `/v1/healthz` require a bearer token.
  */
 

package/src/auth-broker/discover.ts

@@ -38,7 +38,7 @@ export interface DiscoverAuthStorageOptions {
 	sourceLabel?: string;
 }
 
-/** Path to the local bearer token file. Created by `omp auth-broker token`. */
+/** Path to the local bearer token file. Created by `jeopi auth-broker token`. */
 export function getAuthBrokerTokenFilePath(): string {
 	return path.join(getConfigRootDir(), "auth-broker.token");
 }

package/src/auth-broker/remote-store.ts

@@ -328,19 +328,19 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 
 	replaceAuthCredentialsForProvider(_provider: string, _credentials: AuthCredential[]): StoredAuthCredential[] {
 		throw new AIError.AuthBrokerError(
-			"RemoteAuthCredentialStore is read-only on the client. Use `omp auth-broker login <provider>` to mutate credentials.",
+			"RemoteAuthCredentialStore is read-only on the client. Use `jeopi auth-broker login <provider>` to mutate credentials.",
 		);
 	}
 
 	upsertAuthCredentialForProvider(_provider: string, _credential: AuthCredential): StoredAuthCredential[] {
 		throw new AIError.AuthBrokerError(
-			"RemoteAuthCredentialStore is read-only on the client. Use `omp auth-broker login <provider>` to mutate credentials.",
+			"RemoteAuthCredentialStore is read-only on the client. Use `jeopi auth-broker login <provider>` to mutate credentials.",
 		);
 	}
 
 	deleteAuthCredentialsForProvider(_provider: string, _disabledCause: string): void {
 		throw new AIError.AuthBrokerError(
-			"RemoteAuthCredentialStore is read-only on the client. Use `omp auth-broker logout <provider>` to mutate credentials.",
+			"RemoteAuthCredentialStore is read-only on the client. Use `jeopi auth-broker logout <provider>` to mutate credentials.",
 		);
 	}
 

package/src/auth-gateway/server.ts

@@ -1,12 +1,12 @@
 /**
- * omp auth-gateway HTTP server.
+ * jeopi auth-gateway HTTP server.
  *
  * Accepts any provider-format request (OpenAI chat-completions, Anthropic
  * messages, OpenAI Responses) and dispatches through pi-ai's `streamSimple()`
  * — which handles credential injection, anthropic-beta headers, codex
  * websocket transport, and all the per-provider intricacies. The gateway is
- * pure protocol translation: foreign wire → omp Context → pi-ai stream() →
- * omp events → foreign wire.
+ * pure protocol translation: foreign wire → jeopi Context → pi-ai stream() →
+ * jeopi events → foreign wire.
  *
  * Endpoints:
  *   GET  /healthz                          → unauth; ok + version

package/src/auth-gateway/types.ts

@@ -9,9 +9,9 @@ import type {
 } from "../types";
 
 /**
- * Wire types for the omp auth-gateway.
+ * Wire types for the jeopi auth-gateway.
  *
- * The gateway sits between unauthenticated clients (containerized omp,
+ * The gateway sits between unauthenticated clients (containerized jeopi,
  * llm-git, …) and the broker. It accepts provider-format HTTP requests
  * (OpenAI chat-completions / Anthropic messages / OpenAI Responses),
  * dispatches them through pi-ai's `streamSimple()`, and translates the

package/src/dialect/anthropic.ts

@@ -9,6 +9,7 @@ import {
 	renderLegacyTextTranscript,
 	stringifyJson,
 } from "./rendering";
+import { isThinkingTagName } from "./thinking";
 import type {
 	DialectDefinition,
 	DialectRenderOptions,
@@ -22,7 +23,6 @@ const MAX_PARTIAL_TAG_LENGTH = 256;
 const MAX_PARAMETER_VALUE_LENGTH = 1_000_000;
 
 const WRAPPER_TAGS: Readonly<Record<string, true>> = { function_calls: true, tool_calls: true };
-const THINKING_TAGS: Record<string, true> = { thinking: true, think: true, scratchpad: true };
 const BASE_TAG_PREFIXES = [
 	"<function_calls",
 	"</function_calls",
@@ -217,7 +217,7 @@ export class AnthropicInbandScanner implements InbandScanner {
 			this.#startInvoke(tag, "section", events);
 			return true;
 		}
-		if (this.#parseThinking && !tag.closing && THINKING_TAGS[tag.localName] === true) {
+		if (this.#parseThinking && !tag.closing && isThinkingTagName(tag.localName)) {
 			this.#startThinking(tag, "section", events);
 		}
 		return true;
@@ -480,7 +480,7 @@ export class AnthropicInbandScanner implements InbandScanner {
 
 	#isThinkingOpen(tag: ParsedTag): boolean {
 		if (!this.#parseThinking || tag.closing) return false;
-		return THINKING_TAGS[tag.localName] === true;
+		return isThinkingTagName(tag.localName);
 	}
 
 	#relevantPrefixes(): readonly string[] {
@@ -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`
@@ -14,21 +19,154 @@ type Tag = { readonly open: string; readonly close: string; readonly fenced?: bo
  * emits and what models leak in practice. Attributed or namespaced XML thinking
  * tags (`<thinking signature="…">`, `antml:thinking`) are recovered by the owned
  * anthropic-dialect parser, not this text-channel healing fallback.
+ *
+ * `<think>`/`<thinking>`/`<scratchpad>` are additionally matched with one-typo
+ * tolerance ({@link isThinkingTagName}) — weaker models occasionally hallucinate
+ * a near-miss spelling (`<thinke>`, `<thinkin>`) consistently for both the open
+ * and close tag on long turns; without this the whole malformed pair leaks
+ * verbatim into the visible channel instead of collapsing into a thinking block.
  */
 const TAGS: readonly Tag[] = [
-	{ open: "<think>", close: "</think>" }, // deepseek, glm, hermes, kimi, qwen3 (and anthropic/minimax/xml)
-	{ open: "<thinking>", close: "</thinking>" }, // anthropic, minimax, xml
-	{ open: "<scratchpad>", close: "</scratchpad>" }, // anthropic
 	{ open: "```thinking\n", close: "```", fenced: true }, // gemini fenced thinking
 	{ open: "<|channel>thought\n", close: "<channel|>" }, // gemma reasoning channel
 	{ open: "<|start|>assistant<|channel|>analysis<|message|>", close: "<|end|>" }, // harmony analysis (rendered)
 	{ open: "<|channel|>analysis<|message|>", close: "<|end|>" }, // harmony analysis (bare leak)
 ];
 const OPENS = TAGS.map(tag => tag.open);
+/** Longest bare `<name>` this scanner ever recognizes; bounds partial-tag holding. */
+const MAX_BARE_TAG_NAME_LENGTH = 20;
+const BARE_TAG_OPEN_PATTERN = /<([A-Za-z][A-Za-z0-9]{0,19})>/g;
+const BARE_TAG_PARTIAL_PATTERN = /<(?:[A-Za-z][A-Za-z0-9]{0,19})?$/;
+
+/**
+ * True for the canonical thinking tag names, plus names within one character
+ * edit of `think`/`thinking`/`scratchpad` that also share that name's prefix —
+ * the shape of a real hallucinated typo (`thinke`, `thinkin`, `scratchpaid`),
+ * not an unrelated short word (`thing`, `thin`, `chink` all fail the prefix
+ * guard despite being edit-distance 1 from `think`).
+ */
+export function isThinkingTagName(name: string): boolean {
+	const lower = name.toLowerCase();
+	if (lower === "thinking" || lower === "think" || lower === "scratchpad") return true;
+	if (lower.startsWith("think") && levenshteinAtMost(lower, "think", 1)) return true;
+	if (lower.startsWith("thinking") && levenshteinAtMost(lower, "thinking", 1)) return true;
+	if (lower.startsWith("scratchpad") && levenshteinAtMost(lower, "scratchpad", 1)) return true;
+	return false;
+}
+
+/** Bounded Levenshtein distance check; avoids the full DP once `max` is exceeded. */
+function levenshteinAtMost(a: string, b: string, max: number): boolean {
+	if (Math.abs(a.length - b.length) > max) return false;
+	const prev = new Array<number>(b.length + 1);
+	const curr = new Array<number>(b.length + 1);
+	for (let j = 0; j <= b.length; j++) prev[j] = j;
+	for (let i = 1; i <= a.length; i++) {
+		curr[0] = i;
+		let rowMin = curr[0]!;
+		for (let j = 1; j <= b.length; j++) {
+			const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+			curr[j] = Math.min(prev[j]! + 1, curr[j - 1]! + 1, prev[j - 1]! + cost);
+			rowMin = Math.min(rowMin, curr[j]!);
+		}
+		if (rowMin > max) return false;
+		for (let j = 0; j <= b.length; j++) prev[j] = curr[j]!;
+	}
+	return prev[b.length]! <= max;
+}
+
+/**
+ * Earliest bare `<name>` tag (no attributes) whose name passes
+ * {@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;
+		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;
+}
+
+/**
+ * Holds back a buffer tail shaped like an unterminated bare tag (`<`,
+ * optionally followed by letters/digits, no `>` yet) so a diverging spelling
+ * isn't flushed as visible text one character before its typo would have
+ * 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; 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("<");
+	if (openIndex === -1) return 0;
+	const tail = buffer.slice(openIndex);
+	if (tail.length > MAX_BARE_TAG_NAME_LENGTH + 1) return 0;
+	return BARE_TAG_PARTIAL_PATTERN.test(tail) ? tail.length : 0;
+}
 
 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;
@@ -50,6 +188,7 @@ export class ThinkingInbandScanner implements InbandScanner {
 		}
 		this.#buffer = "";
 		this.#closeTag = "";
+		this.#closeFallback = "";
 		return events;
 	}
 
@@ -65,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;
@@ -72,24 +212,28 @@ 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;
 			}
 
 			const tag = findEarliestOpen(this.#buffer);
 			if (!tag) {
-				const hold = final ? 0 : partialSuffixOverlapAny(this.#buffer, OPENS);
+				const hold = final
+					? 0
+					: Math.max(partialSuffixOverlapAny(this.#buffer, OPENS), bareTagPartialHold(this.#buffer));
 				const emit = this.#buffer.slice(0, this.#buffer.length - hold);
 				if (emit.length > 0) events.push({ type: "text", text: emit });
 				this.#buffer = this.#buffer.slice(this.#buffer.length - hold);
@@ -98,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" });
@@ -112,11 +257,25 @@ 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) {
 		const index = buffer.indexOf(tag.open);
 		if (index !== -1 && (!best || index < best.index)) best = { ...tag, index };
 	}
+	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;
 }

package/src/providers/google-gemini-cli.ts

@@ -715,7 +715,21 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 				options?.streamFirstEventTimeoutMs ?? getStreamFirstEventTimeoutMs(undefined, 300_000);
 			const callerSignal = options?.signal;
 			const toolNames = new Set(context.tools?.map(t => t.name) ?? []);
-			const isFlashLeakModel = model.id.includes("flash");
+			// Cloud Code Assist (both `google-gemini-cli` and `google-antigravity`,
+			// covering Gemini and Claude-on-antigravity ids alike) can leak its raw
+			// tool-planning JSON (`{"thought": "…", "call": "read", "paths": […]}`,
+			// mirroring jeopi's own tool-argument shapes) into the visible text
+			// channel instead of emitting a structured `functionCall`. This was
+			// first captured and fixed for `gemini-3.5-flash`, but the gate on
+			// `model.id.includes("flash")` left every non-flash id (including the
+			// `google-antigravity` default model `gemini-3.1-pro`, other Gemini-3
+			// pro/flash-agent tiers, and Claude-on-antigravity ids) unprotected —
+			// so the same leak still renders straight into the TUI as raw JSON
+			// text on every occurrence for those models. `isPlanningLeakPrefix`/
+			// `isPlanningLeakObject` are narrow, shape-specific heuristics (they
+			// only fire on a leading `{"thought"…}`-style object), so buffering is
+			// safe to apply unconditionally across this whole provider surface
+			// rather than gating it to one model family.
 
 			let started = false;
 			let sawFinishReason = false;
@@ -899,7 +913,7 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 											bufferedTextSignature,
 											part.thoughtSignature,
 										);
-									} else if (isFlashLeakModel && part.text.trimStart().startsWith("{")) {
+									} else if (part.text.trimStart().startsWith("{")) {
 										isBuffering = true;
 										textBuffer = part.text;
 										bufferedTextSignature = part.thoughtSignature;

package/src/providers/pi-native-client.ts

@@ -1,7 +1,7 @@
 /**
  * Client half of the pi-native auth-gateway protocol.
  *
- * Dispatches a {@link streamSimple}-shaped request to an `omp auth-gateway`
+ * Dispatches a {@link streamSimple}-shaped request to a `jeopi auth-gateway`
  * via `POST /v1/pi/stream`, reads the SSE event stream back, and pushes the
  * parsed events into a local {@link AssistantMessageEventStream} — the same
  * stream type every other provider client produces. Callers downstream of
@@ -125,7 +125,7 @@ function buildHeaders(model: Model<Api>, apiKey: string | undefined): Record<str
 }
 
 /**
- * Stream a turn through an `omp auth-gateway` over the pi-native protocol.
+ * Stream a turn through a `jeopi auth-gateway` over the pi-native protocol.
  *
  * The returned {@link AssistantMessageEventStream} receives each parsed
  * `AssistantMessageEvent` verbatim from the gateway; the terminal `done` /

package/src/stream.ts

@@ -686,7 +686,7 @@ export function getEnvApiKeyName(provider: string): string | undefined {
 
 /**
  * Enumerate every provider that has an env-var fallback for `getEnvApiKey`.
- * Used by `omp auth-broker migrate --include-env` to discover env-sourced keys
+ * Used by `jeopi auth-broker migrate --include-env` to discover env-sourced keys
  * that should be uploaded to the broker.
  */
 export function listProvidersWithEnvKey(): string[] {

package/src/utils/openrouter-headers.ts

@@ -2,9 +2,9 @@ import packageJson from "../../package.json" with { type: "json" };
 
 export function getOpenRouterHeaders(): Record<string, string> {
 	return {
-		"User-Agent": `Oh-My-Pi/${packageJson.version}`,
-		"HTTP-Referer": "https://omp.sh/",
-		"X-OpenRouter-Title": "Oh-My-Pi",
+		"User-Agent": `jeopi/${packageJson.version}`,
+		"HTTP-Referer": packageJson.homepage,
+		"X-OpenRouter-Title": "jeopi",
 		"X-OpenRouter-Categories": "cli-agent",
 		"X-OpenRouter-Cache": "true",
 		"X-OpenRouter-Cache-TTL": "3600",