@oh-my-pi/pi-ai 18.10.3 → 18.11.0

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [18.11.0] - 2026-10-14
+
+### Fixed
+
+- Fixed parallel tool calls failing with "Tool call arguments are not valid JSON" on some OpenAI-compatible gateways, such as Gemini ([#15682](https://github.com/can1357/oh-my-pi/pull/15682) by [@Zzz141592653](https://github.com/Zzz141592653))
+- Fixed Anthropic fallback-credit redemption losing its credit on errors that only mention `400` in their text, such as an overload message ([#15702](https://github.com/can1357/oh-my-pi/pull/15702) by [@H4vC](https://github.com/H4vC))
+- Fixed Anthropic fallback-credit redemption sending an extra `fallback-credit-2026-06-01` beta when the refused request used a newer one ([#15702](https://github.com/can1357/oh-my-pi/pull/15702) by [@H4vC](https://github.com/H4vC))
+- Fixed Anthropic fallback-credit redemptions failing when the refused turn included unsigned thinking ([#15702](https://github.com/can1357/oh-my-pi/pull/15702) by [@H4vC](https://github.com/H4vC))
+- Fixed turns ending without automatic retry when a gateway forwards Go's `use of closed network connection` transport error; it now retries like other dropped connections ([#15385](https://github.com/can1357/oh-my-pi/issues/15385))
+- Fixed Codex SSE streams failing with an abort instead of retrying when the first event stalls ([#15542](https://github.com/can1357/oh-my-pi/issues/15542))
+- Fixed Codex (ChatGPT subscription) requests with reasoning disabled, such as judges, titles, commit messages, and thinking `off`, leaving effort to the server default; they now send the lowest supported effort, or `none` where the model accepts it ([#15514](https://github.com/can1357/oh-my-pi/issues/15514))
+- Fixed a Codex account whose token OpenAI rejects (401/403) continuing to show its last quota as healthy; `omp usage` now drops the stale report and `omp auth-gateway check` reports the credential as failing ([#15439](https://github.com/can1357/oh-my-pi/issues/15439))
+- Fixed usage reports being served indefinitely while their provider keeps failing; the last successful report is now shown for at most 24 hours after it was fetched ([#15439](https://github.com/can1357/oh-my-pi/issues/15439))
+- Fixed Responses requests 400ing (DeepSeek: "The `reasoning_text` in the thinking mode must be passed back to the API") after a tool call whose arguments were invalid JSON: the call is now replayed with its parse diagnostic instead of being dropped and leaving a trailing `[Orphan tool result]` note ([#15568](https://github.com/can1357/oh-my-pi/issues/15568))
+- Fixed DeepSeek on OpenAI-compatible gateways leaving doubled-pipe DSML markup (`</｜｜DSML｜｜parameter>`) in assistant text and reasoning ([#15485](https://github.com/can1357/oh-my-pi/issues/15485))
+- Fixed sessions failing every request with `400 … thinking or redacted_thinking blocks in the latest assistant message cannot be modified` after a response fell back to another model mid-turn (e.g. through a gateway that opts into Anthropic server-side fallback); the turn now replays one model's reasoning, and a session already stuck on such a turn recovers by dropping that turn's reasoning and retrying ([#15654](https://github.com/can1357/oh-my-pi/pull/15654) by [@abilliontokens](https://github.com/abilliontokens))
+- Fixed `omp auth-gateway`'s Anthropic `/v1/messages` stream misnumbering content blocks after a redacted reasoning block, which misrouted every later delta in index-addressed clients ([#15654](https://github.com/can1357/oh-my-pi/pull/15654) by [@abilliontokens](https://github.com/abilliontokens))
+
+## [18.10.4] - 2026-10-13
+
+### Fixed
+
+- Fixed Codex cybersecurity policy errors incorrectly retrying without Daybreak and disabling it for subsequent requests, while preserving retries without Daybreak when access is rejected ([#15472](https://github.com/can1357/oh-my-pi/pull/15472) by [@taibenvenuti](https://github.com/taibenvenuti))
+
+### Removed
+
+- Removed the `toolNamespacesInfo` stream option; Codex requests no longer send `tool_namespaces_info` turn metadata, and `code_mode_tool_names`/`tool_namespaces_info` are no longer reserved client metadata keys.
+
 ## [18.10.3] - 2026-10-12
 
 ### Breaking Changes

package/dist/types/auth/usage-cache.d.ts

@@ -2,7 +2,7 @@ import type { AuthCredentialStore } from "./store.js";
 import type { AuthCredential, OAuthCredential } from "./types.js";
 import type { CredentialPool } from "./pool.js";
 import type { Provider } from "../types.js";
-import type { UsageCredential, UsageProvider } from "../usage.js";
+import type { UsageCredential, UsageProvider, UsageReport } from "../usage.js";
 /** Minimum interval between non-exhausted header snapshots; used by UsageService. */
 export declare const USAGE_HEADER_INGEST_INTERVAL_MS = 60000;
 /**
@@ -56,6 +56,8 @@ export declare class UsageCache {
     failureKey(reportKey: string): string;
     get<T>(key: string): UsageCacheEntry<T> | undefined;
     getStale<T>(key: string): UsageCacheEntry<T> | undefined;
+    /** Last successful report under `key` while inside its retention window; the failure-path fallback. */
+    lastGood(key: string): UsageReport | null;
     set<T>(key: string, entry: UsageCacheEntry<T>): void;
     deletePrefix(prefix: string): boolean;
     markForceRefresh(provider?: Provider): void;

package/dist/types/error/flags.d.ts

@@ -68,10 +68,22 @@ export declare function isCodexSteerRejection(message: {
     api?: Api;
     errorMessage?: string;
 }): boolean;
+/**
+ * Transport-failure wording that marks an error transient. Covers
+ * diagnostics forwarded verbatim by gateways/proxies in other runtimes, e.g.
+ * undici's "other side closed" and Go's `net.ErrClosed` ("use of closed
+ * network connection", #15385).
+ */
 export declare const TRANSIENT_TRANSPORT_PATTERN: RegExp;
 export declare const ANTHROPIC_ACCOUNT_POLICY_PATTERN: RegExp;
 /** Whether an error message represents an Anthropic account-scoped permission/policy denial. */
 export declare function isAnthropicAccountPolicyText(text: string, provider?: string, statusArg?: number): boolean;
+/**
+ * Anthropic's rejection of a replayed latest assistant turn whose `thinking` or
+ * `redacted_thinking` blocks no longer verify. Resending the same turn fails the
+ * same way; only a request that changes that turn's reasoning can succeed.
+ */
+export declare function isImmutableLatestThinkingText(text: string): boolean;
 /**
  * Local llama.cpp / Ollama deterministic tool-call argument JSON parse failure.
  * The model emitted invalid JSON in a tool call and the server returned HTTP 500

package/dist/types/provider-session-state.d.ts

@@ -18,8 +18,8 @@
  *   siblings are endpoint-scoped and stay: `strictToolsDisabled`
  *   (grammar-too-large 400 for the model's tool schema),
  *   `replayUnsignedThinkingDisabled` / `thinkingReplayDisabled` (the endpoint
- *   is a signing proxy), `prefixDroppedThinkingBlocks` (blocks a prefix-binding
- *   400 made the client strip).
+ *   is a signing proxy), `prefixDroppedThinkingBlocks` (blocks a rejected
+ *   replay made the client strip).
  * - **OpenAI Responses** — the `previous_response_id` chain baselines are
  *   account-scoped: a stored response belongs to the account that created it.
  *   Strict-tools / reasoning-effort fallbacks, replay warmup and the chaining

package/dist/types/providers/anthropic.d.ts

@@ -118,7 +118,8 @@ export interface AnthropicOptions extends StreamOptions {
      * header is auto-attached; the response parser then honors mid-stream
      * `fallback` content blocks and `usage.iterations` for served-model
      * promotion and per-attempt pricing. Opt-in ONLY — leaving this
-     * undefined preserves the pre-fallback behavior on every code path.
+     * undefined sends neither and keeps both off; a `fallback` block in the
+     * response (a gateway opted in) is still persisted as a replay boundary.
      */
     fallbacks?: FallbackParam[];
 }
@@ -283,10 +284,11 @@ export type AnthropicMessageParam = MessageParam;
  * Serialize omp {@link Message}s to Anthropic wire messages.
  *
  * `opts.serverSideFallbackEnabled` — when the CURRENT request itself
- * opts into the server-side-fallback beta chain. Only then may a persisted
- * `fallback` content block from a prior turn be replayed on the wire;
- * otherwise the block is dropped to avoid a 400 on non-fallback requests
- * that don't send the beta.
+ * opts into the server-side-fallback beta chain. Only then, and only on the
+ * official endpoint, may a persisted `fallback` content block from a prior
+ * turn be replayed on the wire; otherwise the block is dropped to avoid a 400
+ * on requests that don't send the beta, and its turn keeps one model's
+ * reasoning (see {@link collapseFallbackSegments}).
  *
  * `opts.replayCompaction` — replay a user-role compaction summary that
  * carries an {@link AnthropicCompactionPayload} from this provider as a

package/dist/types/providers/openai-codex-responses.d.ts

@@ -6,6 +6,12 @@ export type { CodexAttestationProvider } from "./openai-codex-attestation.js";
 import type { ResponseInput } from "./openai-responses-wire.js";
 export interface OpenAICodexResponsesOptions extends StreamOptions {
     reasoning?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+    /**
+     * Run with the least reasoning the model allows; takes precedence over
+     * `reasoning`. Sends the `none` tier where the catalog's disable mode is
+     * `none-effort`, else the model's lowest supported effort.
+     */
+    disableReasoning?: boolean;
     reasoningSummary?: "auto" | "concise" | "detailed" | null;
     /** Explicit `reasoning.context` replay scope. Omitted by default so Codex applies its native request policy. */
     reasoningContext?: CodexReasoningContext;

package/dist/types/types.d.ts

@@ -9,7 +9,7 @@ import type { ApiKey } from "./auth-retry.js";
 import type { OAuthRequestIdentity } from "./auth/types.js";
 import type { BedrockOptions } from "./providers/amazon-bedrock.js";
 import type { AnthropicOptions } from "./providers/anthropic.js";
-import type { FallbackParam, StopDetails } from "./providers/anthropic-wire.js";
+import type { FallbackParam, MessageCreateParamsStreaming, StopDetails } from "./providers/anthropic-wire.js";
 import type { AzureOpenAIResponsesOptions } from "./providers/azure-openai-responses.js";
 import type { CursorOptions } from "./providers/cursor.js";
 import type { AppleFoundationModelsOptions } from "./providers/apple-foundation-models.js";
@@ -398,8 +398,6 @@ export interface StreamOptions {
     liveSteering?: LiveSteering;
     /** Canonical Codex compaction classification; ignored by other providers. */
     codexCompaction?: CodexCompactionRequestContext;
-    /** Codex Code Mode tool exposure snapshot emitted as `tool_namespaces_info` turn metadata; ignored by other providers. */
-    toolNamespacesInfo?: unknown;
     /**
      * Optional per-provider concurrent request cap for LLM stream calls. Keys are
      * provider ids (`model.provider`); positive numeric values cap in-flight
@@ -652,11 +650,12 @@ export interface RedactedThinkingContent {
 }
 /**
  * Anthropic server-side-fallback boundary marker persisted on assistant
- * turns whose provider request opted into
- * `AnthropicOptions.fallbacks`. Consumers other than the Anthropic
- * provider MUST ignore it — `transformMessages` strips the block on any
- * cross-provider hop and on non-official Anthropic replays, so downstream
- * converters never see it.
+ * turns whose response switched models mid-stream, whether the request
+ * opted into `AnthropicOptions.fallbacks` or a gateway opted in on its
+ * behalf. Consumers other than the Anthropic provider MUST ignore it —
+ * `transformMessages` strips the block on any non-Anthropic hop, and
+ * `convertAnthropicMessages` only puts it on the wire for an opted-in
+ * request to the official endpoint.
  */
 export interface AnthropicFallbackContent {
     type: "fallback";
@@ -1424,7 +1423,8 @@ export type AssistantMessageEvent = {
 export interface AnthropicFallbackCreditHandle {
     token: string;
     prefillClaim?: boolean | null;
-    params: unknown;
+    /** The refused request's body, replayed with the credit token on the fallback model. */
+    params: MessageCreateParamsStreaming;
     betas?: readonly string[];
     betaHeader?: string;
     expiresAt: number;

package/dist/types/utils/dsml-leak.d.ts

@@ -23,7 +23,9 @@ export declare function isDsmlLeakRecoveryTarget(model: Model): boolean;
  */
 export declare function stripDsmlToolMarkup(text: string): string | undefined;
 /**
- * Remove leaked DSML tool-call markup from `message`'s text blocks in place,
- * dropping blocks left empty. Returns true when anything was removed.
+ * Remove leaked DSML tool-call markup from an assistant message before commit,
+ * including reasoning blocks and turns with valid structured calls. Rewritten
+ * thinking with an opaque signature is discarded; OpenAI-compatible reasoning
+ * field names are replay markers, not signatures, and survive cleanup.
  */
 export declare function removeDsmlToolMarkupLeak(message: AssistantMessage): boolean;

package/dist/types/utils/tool-call-arguments.d.ts

@@ -5,7 +5,8 @@ export declare function parseToolCallArguments(json: string | undefined): ToolCa
  * Native Responses `function_call.arguments` to persist for replay.
  *
  * {@link parseToolCallArguments} repairs some invalid JSON (e.g. `"name": ,`) and the tool runs with the
- * repaired value; replay drops a call whose stored arguments do not parse, orphaning its output (#14155).
+ * repaired value; replay must carry what was executed (#14155), not the {@link invalidToolCallArguments}
+ * diagnostic it substitutes for stored arguments that do not parse (#15568).
  * Returns `raw` when it already parses or the arguments were unrepairable, else the executed arguments.
  */
 export declare function replayableToolCallArguments(raw: string, executed: ToolCall["arguments"]): string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.10.3",
+	"version": "18.11.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"keywords": [
 		"ai",
@@ -155,11 +155,11 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.10.3",
-		"@oh-my-pi/pi-catalog": "18.10.3",
-		"@oh-my-pi/pi-natives": "18.10.3",
-		"@oh-my-pi/pi-utils": "18.10.3",
-		"@oh-my-pi/pi-wire": "18.10.3"
+		"@oh-my-pi/omptype": "18.11.0",
+		"@oh-my-pi/pi-catalog": "18.11.0",
+		"@oh-my-pi/pi-natives": "18.11.0",
+		"@oh-my-pi/pi-utils": "18.11.0",
+		"@oh-my-pi/pi-wire": "18.11.0"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/auth/usage-cache.ts

@@ -3,6 +3,7 @@ import type { AuthCredential, OAuthCredential } from "./types";
 import type { CredentialPool } from "./pool";
 import type { Provider } from "../types";
 import type { UsageCredential, UsageProvider, UsageReport } from "../usage";
+import { isRecord } from "../utils";
 
 const USAGE_CACHE_PREFIX = "usage_cache:";
 const USAGE_FORCE_REFRESH_CACHE_PREFIX = "force-refresh:";
@@ -53,6 +54,17 @@ function withoutRawPayload(value: unknown): unknown {
 	return rest;
 }
 
+/**
+ * End of a cached value's durable retention. A report is retained for 24h past
+ * its last successful fetch, so re-storing it as a failure fallback never
+ * extends that window; other values are retained for 24h from now.
+ */
+function retentionDeadline(value: unknown): number {
+	const fetchedAt = isRecord(value) ? value.fetchedAt : undefined;
+	const start = typeof fetchedAt === "number" && Number.isFinite(fetchedAt) && fetchedAt > 0 ? fetchedAt : Date.now();
+	return start + USAGE_LAST_GOOD_RETENTION_MS;
+}
+
 /** Convert a stored credential for usage providers; used by usage and health services. */
 export function buildUsageCredential(credential: AuthCredential): UsageCredential {
 	if (credential.type === "api_key") {
@@ -203,15 +215,19 @@ export class UsageCache {
 		return parseUsageCacheEntry<T>(raw);
 	}
 
+	/** Last successful report under `key` while inside its retention window; the failure-path fallback. */
+	lastGood(key: string): UsageReport | null {
+		const report = this.getStale<UsageReport | null>(key)?.value;
+		return report && Date.now() < retentionDeadline(report) ? report : null;
+	}
+
 	set<T>(key: string, entry: UsageCacheEntry<T>): void {
 		const value = withoutRawPayload(entry.value);
-		const payload = JSON.stringify({
-			value,
-			expiresAt: entry.expiresAt,
-		});
-		const durableExpiresAt =
-			value === null ? entry.expiresAt : Math.max(entry.expiresAt, Date.now() + USAGE_LAST_GOOD_RETENTION_MS);
-		this.#store.setCache(`${USAGE_CACHE_PREFIX}${key}`, payload, Math.floor(durableExpiresAt / 1000));
+		const deadline = value === null ? undefined : retentionDeadline(value);
+		// Failure cooldowns must not make a last-good report fresh beyond retention.
+		const expiresAt = deadline === undefined ? entry.expiresAt : Math.min(entry.expiresAt, deadline);
+		const payload = JSON.stringify({ value, expiresAt });
+		this.#store.setCache(`${USAGE_CACHE_PREFIX}${key}`, payload, Math.floor((deadline ?? expiresAt) / 1000));
 	}
 
 	deletePrefix(prefix: string): boolean {

package/src/auth/usage.ts

@@ -334,7 +334,7 @@ export class UsageService implements UsageApi {
 
 		const failure = this.#deps.cache.get<null>(failureKey);
 		if (failure && failure.expiresAt > now) {
-			return this.#deps.cache.getStale<UsageReport | null>(cacheKey)?.value ?? null;
+			return this.#deps.cache.lastGood(cacheKey);
 		}
 
 		// Invalidation must not fork an already-running credential probe. Share it;
@@ -378,9 +378,7 @@ export class UsageService implements UsageApi {
 			// so an expired login does not display stale quota indefinitely.
 			const providerImpl = this.providerFor(request.provider);
 			const retainLastGood = !invalidated && providerImpl?.retainLastGoodOnFailure !== false;
-			const lastGood = retainLastGood
-				? (this.#deps.cache.getStale<UsageReport | null>(cacheKey)?.value ?? null)
-				: null;
+			const lastGood = retainLastGood ? this.#deps.cache.lastGood(cacheKey) : null;
 			const failureBackoffMs = providerImpl?.failureBackoffMs ?? USAGE_FAILURE_BACKOFF_MS;
 			const backoffJitter = failureBackoffMs * (Math.random() * 0.5 - 0.25);
 			const coolDown = Date.now() + failureBackoffMs + backoffJitter;

package/src/error/flags.ts

@@ -217,8 +217,14 @@ export function isCodexSteerRejection(message: { api?: Api; errorMessage?: strin
 	);
 }
 
+/**
+ * Transport-failure wording that marks an error transient. Covers
+ * diagnostics forwarded verbatim by gateways/proxies in other runtimes, e.g.
+ * undici's "other side closed" and Go's `net.ErrClosed` ("use of closed
+ * network connection", #15385).
+ */
 export const TRANSIENT_TRANSPORT_PATTERN =
-	/\b(?:no[_ -]?capacity|(?:high|peak)[ _-]?demand|(?:at|over|insufficient)[ _-]?capacity|capacity[ _-]?(?:exceeded|exhausted)|peak[ _-]?load)\b|overloaded|provider.?returned.?error|rate.?limit|too many requests|auth-gateway\s+5\d{2}(?=[:\s]|$)|\b(?:429|500|502|503|504)\b|service.?unavailable|server.?error|internal.?error|retry your request|network.?error|connection.?error|connection.?refused|unable.?to.?connect\.\s*is the computer able to access the url\?|other side closed|fetch failed|upstream.?connect|upstream.?request.?failed|reset before headers|socket hang up|timed? out|timeout|terminated|retry delay|stream stall|no error details in response|HTTP2(?:StreamReset|RefusedStream|EnhanceYourCalm)|nghttp2_(?:internal_error|refused_stream)|stream closed with error code nghttp2_(?:internal_error|refused_stream)|malformed.?function.?call/i;
+	/\b(?:no[_ -]?capacity|(?:high|peak)[ _-]?demand|(?:at|over|insufficient)[ _-]?capacity|capacity[ _-]?(?:exceeded|exhausted)|peak[ _-]?load)\b|overloaded|provider.?returned.?error|rate.?limit|too many requests|auth-gateway\s+5\d{2}(?=[:\s]|$)|\b(?:429|500|502|503|504)\b|service.?unavailable|server.?error|internal.?error|retry your request|network.?error|connection.?error|connection.?refused|unable.?to.?connect\.\s*is the computer able to access the url\?|other side closed|use of closed network connection|fetch failed|upstream.?connect|upstream.?request.?failed|reset before headers|socket hang up|timed? out|timeout|terminated|retry delay|stream stall|no error details in response|HTTP2(?:StreamReset|RefusedStream|EnhanceYourCalm)|nghttp2_(?:internal_error|refused_stream)|stream closed with error code nghttp2_(?:internal_error|refused_stream)|malformed.?function.?call/i;
 const AUTH_FAILURE_PATTERN =
 	/\b(?:401|403|unauthorized|forbidden|authentication|auth[_ ]?unavailable|no auth available|(?:invalid|no)[_ ]?api[_ ]?key)\b/i;
 const MALFORMED_FUNCTION_CALL_PATTERN = /\bmalformed.?function.?call\b/i;
@@ -237,6 +243,18 @@ export function isAnthropicAccountPolicyText(text: string, provider?: string, st
 	return ANTHROPIC_ACCOUNT_POLICY_PATTERN.test(text);
 }
 
+const IMMUTABLE_LATEST_THINKING_PATTERN =
+	/messages\.\d+\.content\.\d+.*\b(?:thinking|redacted_thinking)\b.*\blatest assistant message cannot be modified\b/is;
+
+/**
+ * Anthropic's rejection of a replayed latest assistant turn whose `thinking` or
+ * `redacted_thinking` blocks no longer verify. Resending the same turn fails the
+ * same way; only a request that changes that turn's reasoning can succeed.
+ */
+export function isImmutableLatestThinkingText(text: string): boolean {
+	return IMMUTABLE_LATEST_THINKING_PATTERN.test(text);
+}
+
 const CODEX_CHATGPT_ACCOUNT_MODEL_POLICY_PATTERN =
 	/\bThe ['"]([^'"\r\n]+)['"] model is not supported when using Codex with a ChatGPT account\./i;
 const CODEX_CHATGPT_ACCOUNT_MODEL_MAX_LENGTH = 256;

package/src/provider-session-state.ts

@@ -18,8 +18,8 @@
  *   siblings are endpoint-scoped and stay: `strictToolsDisabled`
  *   (grammar-too-large 400 for the model's tool schema),
  *   `replayUnsignedThinkingDisabled` / `thinkingReplayDisabled` (the endpoint
- *   is a signing proxy), `prefixDroppedThinkingBlocks` (blocks a prefix-binding
- *   400 made the client strip).
+ *   is a signing proxy), `prefixDroppedThinkingBlocks` (blocks a rejected
+ *   replay made the client strip).
  * - **OpenAI Responses** — the `previous_response_id` chain baselines are
  *   account-scoped: a stored response belongs to the account that created it.
  *   Strict-tools / reasoning-effort fallbacks, replay warmup and the chaining

package/src/providers/anthropic-messages-server.ts

@@ -538,9 +538,53 @@ function mapStopReasonOut(reason: StopReason, hasToolUse: boolean): "end_turn" |
 	}
 }
 
+/**
+ * Collapse a server-side-fallback turn for a bridge client that never opted
+ * into the beta: drop the `fallback` markers and keep reasoning from one
+ * model only. The downstream client never accepted a `fallbacks` request
+ * param and the bridge does not forward one, so the marker cannot go on the
+ * wire; without it, two models' signed reasoning replayed back-to-back reads
+ * as one modified chain and is the shape Anthropic rejects.
+ *
+ * The segment kept is the first that has any reasoning, not the last. The
+ * streaming encoder has already sent the first segment's blocks when the
+ * boundary arrives and cannot retract them, so first-segment is the only
+ * rule it can decide online; this path uses the same rule so streamed and
+ * non-streamed turns present the same reasoning. The offline converter
+ * (`collapseFallbackSegments` in `anthropic.ts`) can see the whole turn and
+ * keeps the last segment instead — both guarantee a single chain survives.
+ */
+function collapseFallbackSegmentsKeepFirst(content: AssistantMessage["content"]): AssistantMessage["content"] {
+	let firstReasoningSegment = -1;
+	let segment = 0;
+	for (const block of content) {
+		if (block.type === "fallback") segment++;
+		else if (block.type === "thinking" || block.type === "redactedThinking") {
+			firstReasoningSegment = segment;
+			break;
+		}
+	}
+	if (firstReasoningSegment === -1) {
+		return content.filter(block => block.type !== "fallback");
+	}
+	const collapsed: AssistantMessage["content"] = [];
+	segment = 0;
+	for (const block of content) {
+		if (block.type === "fallback") {
+			segment++;
+			continue;
+		}
+		if ((block.type === "thinking" || block.type === "redactedThinking") && segment !== firstReasoningSegment) {
+			continue;
+		}
+		collapsed.push(block);
+	}
+	return collapsed;
+}
+
 function encodeContentBlocks(message: AssistantMessage): Record<string, unknown>[] {
 	const blocks: Record<string, unknown>[] = [];
-	for (const c of message.content) {
+	for (const c of collapseFallbackSegmentsKeepFirst(message.content)) {
 		switch (c.type) {
 			case "text":
 				blocks.push({ type: "text", text: c.text });
@@ -668,6 +712,20 @@ export function encodeStream(
 			// preceding text/thinking block before it opens, so no block that is
 			// still open is ever renumbered.
 			const suppressed = new Set<number>();
+			// A persisted `fallback` marker occupies a content index but is
+			// never emitted — the bridge client never opted into the beta, so
+			// the marker cannot go on the wire. The walk below records each
+			// marker (and every other block this encoder cannot emit) in
+			// `suppressed` so `wireIndex` stays dense. Once a boundary has been
+			// passed with reasoning already sent, every later segment's
+			// reasoning is a second signed chain the client must not receive;
+			// the first chain is already on the wire and cannot be retracted,
+			// so it is the one that survives (see
+			// `collapseFallbackSegmentsKeepFirst`). `reasoningSeen` tracks what
+			// the client actually received, which is why redacted reasoning —
+			// which this encoder has no event for — does not set it.
+			let reasoningSeen = false;
+			let suppressLaterReasoning = false;
 			const wireIndex = (contentIndex: number): number => {
 				let shift = 0;
 				for (const index of suppressed) {
@@ -707,6 +765,20 @@ export function encodeStream(
 				while (nextContentIndexToInspect < limit) {
 					const contentIndex = nextContentIndexToInspect++;
 					const content = message.content[contentIndex];
+					if (content?.type === "fallback") {
+						// Never on the wire, so keep the numbering dense. Latch the
+						// collapse only when the client already has this turn's first
+						// chain: what follows would be a second one.
+						suppressed.add(contentIndex);
+						if (reasoningSeen) suppressLaterReasoning = true;
+						continue;
+					}
+					if (content?.type === "redactedThinking") {
+						// Redacted reasoning has no stream event, so it never reaches
+						// the client; account for its index like any other hole.
+						suppressed.add(contentIndex);
+						continue;
+					}
 					if (content?.type !== "anthropicServerTool") continue;
 					ensureStart(message);
 					const index = wireIndex(contentIndex);
@@ -781,6 +853,15 @@ export function encodeStream(
 						case "thinking_start": {
 							emitServerToolBlocksBefore(ev.partial, ev.contentIndex);
 							ensureStart(ev.partial);
+							if (suppressLaterReasoning) {
+								// A later segment's reasoning is a second signed
+								// chain; drop the whole block — start, deltas,
+								// signature and stop — and account for its index
+								// so later blocks stay densely numbered.
+								suppressed.add(ev.contentIndex);
+								break;
+							}
+							reasoningSeen = true;
 							const index = wireIndex(ev.contentIndex);
 							open.set(ev.contentIndex, { index, kind: "thinking" });
 							controller.enqueue(
@@ -793,6 +874,7 @@ export function encodeStream(
 							break;
 						}
 						case "thinking_delta":
+							if (suppressed.has(ev.contentIndex)) break;
 							controller.enqueue(
 								sseFrame("content_block_delta", {
 									type: "content_block_delta",
@@ -802,6 +884,7 @@ export function encodeStream(
 							);
 							break;
 						case "thinking_end": {
+							if (suppressed.has(ev.contentIndex)) break;
 							const c = ev.partial.content[ev.contentIndex];
 							if (c?.type === "thinking" && c.thinkingSignature) {
 								controller.enqueue(