@oh-my-pi/pi-ai 18.8.5 → 18.8.7

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [18.8.7] - 2026-10-09
+
+### Added
+
+- Added routing-session cleanup for OpenAI Responses and Codex while preserving shared provider fallbacks ([#14334](https://github.com/can1357/oh-my-pi/pull/14334) by [@iliaal](https://github.com/iliaal)).
+
+### Fixed
+
+- Fixed Claude Haiku 5.5 requests silently enabling adaptive thinking when reasoning is off, on native Bedrock (main and helper calls) and the Anthropic API; conversations whose earlier effort controls rule out disabled thinking fall back to lowest-effort adaptive thinking instead of failing ([#14996](https://github.com/can1357/oh-my-pi/pull/14996) by [@bse-ai](https://github.com/bse-ai)).
+- Fixed `/session pin` being ignored when every stored account is quota-blocked, which routed the next request to a different exhausted account instead of the pinned one ([#14997](https://github.com/can1357/oh-my-pi/issues/14997)).
+- Fixed `minimax-code-cn` sessions staying pinned to a key whose Token Plan quota is exhausted (`用量上限` 429) instead of rotating to a sibling credential ([#15053](https://github.com/can1357/oh-my-pi/issues/15053)).
+
+## [18.8.6] - 2026-10-08
+
+### Fixed
+
+- Fixed Google Gemini and Cloud Code Assist (Antigravity) requests failing when tool schemas contain unsupported JSON Schema keywords or fields that allow multiple types.
+- Fixed auth broker account selection and usage-limit enforcement to consistently use the selected account’s quota when multiple accounts are present.
+- Fixed Anthropic-family model streaming so encoded marker tokens are decoded correctly in text, tool-call updates, partial messages, and completed tool calls.
+
 ## [18.8.5] - 2026-10-08
 
 ### Added
@@ -2333,19 +2353,4 @@
 - Fixed OpenAI-compatible Ollama completions that return empty `finish_reason:length` after filling `num_ctx` so they surface an actionable context-window error instead of an empty length stop. ([#2774](https://github.com/can1357/oh-my-pi/issues/2774))
 - Fixed Codex browser login issuing credentials for the `opencode` OAuth originator while OMP requests identify as `pi`, which could make the first authenticated Codex request return 401 ([#2696](https://github.com/can1357/oh-my-pi/issues/2696)).
 
-## [16.0.1] - 2026-06-15
-
-### Added
-
-- Added Umans AI Coding Plan API-key login support and `UMANS_AI_CODING_PLAN_API_KEY` environment fallback ([#2636](https://github.com/can1357/oh-my-pi/pull/2636) by [@oldschoola](https://github.com/oldschoola)).
-
-### Fixed
-
-- Fixed OpenAI Responses, Azure OpenAI Responses, and Codex Responses providers ignoring async `onPayload` replacement bodies. Provider payload hooks can now transform the actual request body sent upstream, matching the Anthropic/Gemini replacement contract.
-- Fixed OpenAI-compatible chat-completions streams that send object-shaped tool arguments in fragments by deep-merging nested objects and task arrays instead of replacing earlier chunks. ([#2617](https://github.com/can1357/oh-my-pi/issues/2617))
-- Fixed OpenAI Responses strict-mode tool schema normalization for nullable enum MCP parameters so enum constraints are distributed to matching `anyOf` branches instead of being copied onto the `null` branch. ([#1835](https://github.com/can1357/oh-my-pi/issues/1835))
-- Fixed Cursor provider formatting tool errors with the same `[Tool Result]` prefix as successful results, causing Composer models to misinterpret error messages (e.g. "Pattern must not be empty") as directives over long conversations. Errors now use a `[Tool Error]` prefix so the model can distinguish failures from successes in the prompt history. ([#1853](https://github.com/can1357/oh-my-pi/pull/1853))
-- Fixed `validateToolArguments` silently accepting JSON-encoded array strings (e.g. `'["a","b"]'`) against `union(string, array<string>)` schemas — providers that double-serialize tool-call arguments (Z.AI / GLM) caused tools like `search` to receive the literal `["a","b"]` as a single path, producing zero matches (single element) or glob parse errors (multi-element). A new pre-validation pass parses JSON-array-shaped strings when the schema explicitly accepts both shapes. ([#1788](https://github.com/can1357/oh-my-pi/issues/1788))
-- Fixed Anthropic thinking summaries that arrive wrapped in literal `<thinking>` tags so advisor/raw transcript dumps do not render nested thinking tags ([#2695](https://github.com/can1357/oh-my-pi/issues/2695)).
-
-Older entries are archived in [packages/ai/CHANGELOG.md@d22e34333695](https://github.com/can1357/oh-my-pi/blob/d22e34333695d3dd9de7741ff45903681dba4606/packages/ai/CHANGELOG.md).
+Older entries are archived in [packages/ai/CHANGELOG.md@0dd6aff5f282](https://github.com/can1357/oh-my-pi/blob/0dd6aff5f2821aec1e5b54c6a458e323667a949b/packages/ai/CHANGELOG.md).

package/dist/types/auth/select.d.ts

@@ -71,9 +71,9 @@ export declare class CredentialSelector {
      * 1. strict: unblocked credentials only, usage limits respected, plan
      *    filter enforced (when any account is confirmed eligible);
      * 2. plan-fitting last resort: same plan filter, but blocked/exhausted
-     *    accounts are allowed (blocked candidates rank earliest-unblocking
-     *    first) so the caller gets real usage-limit semantics from the wire
-     *    instead of a missing key;
+     *    accounts are allowed (an explicit session pin first, then blocked
+     *    candidates earliest-unblocking first) so the caller gets real
+     *    usage-limit semantics from the wire instead of a missing key;
      * 3. unfiltered last resort: the plan filter matched nothing usable —
      *    skip it and try every account once; the server is the final arbiter
      *    of model access.

package/dist/types/providers/openai-configuration-update.d.ts

@@ -35,16 +35,19 @@ interface EffortTransition<TEffort extends string> {
 }
 /** Per-conversation effort baseline and recorded transitions. */
 export interface OpenAIEffortControlState<TEffort extends string = string> {
+    sessionId: string;
     baseEffort?: TEffort;
     currentEffort?: TEffort;
     transitions: EffortTransition<TEffort>[];
 }
-export declare function createOpenAIEffortControlState<TEffort extends string>(): OpenAIEffortControlState<TEffort>;
+export declare function createOpenAIEffortControlState<TEffort extends string>(sessionId: string): OpenAIEffortControlState<TEffort>;
 /**
  * Fetch (or create) the control state for one conversation from a provider's
  * bounded per-session map, refreshing its LRU slot.
  */
-export declare function getOpenAIEffortControlState<TEffort extends string>(states: Map<string, OpenAIEffortControlState<TEffort>>, key: string): OpenAIEffortControlState<TEffort>;
+export declare function getOpenAIEffortControlState<TEffort extends string>(states: Map<string, OpenAIEffortControlState<TEffort>>, key: string, sessionId: string): OpenAIEffortControlState<TEffort>;
+/** Release one conversation's effort state from the Responses and Codex `releaseSession` implementations. */
+export declare function releaseOpenAIEffortControlSession<TEffort extends string>(states: Map<string, OpenAIEffortControlState<TEffort>>, sessionId: string): void;
 interface AnchorableItem {
     type?: string | null;
     role?: string;

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

@@ -91,6 +91,7 @@ interface OpenAIResponsesProviderSessionState extends ProviderSessionState, Open
 /** Wire efforts a `configuration_update` can carry: every real tier, never `none`/null. */
 type ResponsesStableEffort = Exclude<ReasoningEffort, "none" | null>;
 interface OpenAIResponsesChainState {
+    sessionId: string;
     /**
      * Wire params of the last successful turn; never carries
      * `previous_response_id`.

package/dist/types/types.d.ts

@@ -191,6 +191,8 @@ export declare function parseServiceTier(value: unknown): ServiceTier | undefine
 export declare function coerceServiceTierByFamily(value: unknown): ServiceTierByFamily | undefined;
 export interface ProviderSessionState {
     close(): void;
+    /** Release one routing session after its final request, preserving shared provider fallbacks. */
+    releaseSession?(sessionId: string): void;
 }
 export interface ProviderResponseMetadata {
     status: number;

package/dist/types/utils/glyph-codec.d.ts

@@ -4,7 +4,7 @@ import { AssistantMessageEventStream } from "./event-stream.js";
 export interface GlyphCodec {
     /** Context with model-bound glyphs encoded and one conditional convention notice. */
     context: Context;
-    /** Decodes glyph tokens in the stream's terminal assistant message. */
+    /** Decodes glyph tokens live: text and tool-call deltas, partial snapshots, completed tool calls, and the terminal message. */
     wrap(inner: AssistantMessageEventStream): AssistantMessageEventStream;
     /** Decodes Cursor Pi calls and encodes their provider-bound results. */
     wrapCursorExecHandlers(handlers: CursorExecHandlers): CursorExecHandlers;

package/dist/types/utils/schema/normalize.d.ts

@@ -10,7 +10,11 @@ export interface NormalizeSchemaOptions {
     unsupportedFields: (key: string) => boolean;
     normalizeFieldNames: boolean;
     collapseNullFields: boolean;
-    normalizeTypeArrayToNullable: boolean;
+    /**
+     * Target takes a scalar `type` only: `["T", "null"]` becomes `T` (+ `nullable`)
+     * and a multi-type array becomes one `anyOf` branch per type.
+     */
+    scalarizeTypeArrays: boolean;
     stripNullableKeyword: boolean;
     autoPropertyOrdering: boolean;
     ensureObjectProperties: boolean;
@@ -66,8 +70,9 @@ export declare function normalizeSchemaForMCP(value: unknown): unknown;
  *    rejected; collapse to `enum` with an inferred scalar `type`.
  *  - `oneOf` is not an MFJS combinator (only `anyOf` is); residual `oneOf` is
  *    folded into `anyOf`.
- *  - `type` must be a scalar string; `type: [...]` arrays are reduced to a
- *    single scalar (the `null` branch is dropped — `nullable` is unsupported).
+ *  - `type` must be a scalar string; `["T", "null"]` reduces to `T` (the
+ *    `null` member is dropped — `nullable` is unsupported) and a multi-type
+ *    array becomes one typed `anyOf` branch per type.
  *  - Enum-bearing nodes get an inferred `type` (the idiomatic MFJS form; a bare
  *    `enum` is valid too) so `anyOf` branches always carry a `type`.
  *  - Validation/decorative keywords (`minItems`, `maxItems`, `maxLength`,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.8.5",
+	"version": "18.8.7",
 	"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.8.5",
-		"@oh-my-pi/pi-catalog": "18.8.5",
-		"@oh-my-pi/pi-natives": "18.8.5",
-		"@oh-my-pi/pi-utils": "18.8.5",
-		"@oh-my-pi/pi-wire": "18.8.5"
+		"@oh-my-pi/omptype": "18.8.7",
+		"@oh-my-pi/pi-catalog": "18.8.7",
+		"@oh-my-pi/pi-natives": "18.8.7",
+		"@oh-my-pi/pi-utils": "18.8.7",
+		"@oh-my-pi/pi-wire": "18.8.7"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/auth/select.ts

@@ -505,9 +505,9 @@ export class CredentialSelector {
 	 * 1. strict: unblocked credentials only, usage limits respected, plan
 	 *    filter enforced (when any account is confirmed eligible);
 	 * 2. plan-fitting last resort: same plan filter, but blocked/exhausted
-	 *    accounts are allowed (blocked candidates rank earliest-unblocking
-	 *    first) so the caller gets real usage-limit semantics from the wire
-	 *    instead of a missing key;
+	 *    accounts are allowed (an explicit session pin first, then blocked
+	 *    candidates earliest-unblocking first) so the caller gets real
+	 *    usage-limit semantics from the wire instead of a missing key;
 	 * 3. unfiltered last resort: the plan filter matched nothing usable —
 	 *    skip it and try every account once; the server is the final arbiter
 	 *    of model access.
@@ -535,6 +535,9 @@ export class CredentialSelector {
 		const credentials = stored.filter(entry => this.#deps.affinity.allows(provider, sessionId, entry.credential));
 
 		if (credentials.length === 0) return undefined;
+		// Ranking and preflight both await provider work; preserve the row each
+		// selection started with even if a peer reorders the live pool.
+		const credentialIds = this.#deps.pool.entries(provider).map(entry => entry.id);
 		this.#deps.policies.validateUsageCapability(provider, this.#deps.usage.canFetchOAuthUsage(provider));
 
 		const providerKey = providerTypeKey(provider, "oauth");
@@ -659,6 +662,11 @@ export class CredentialSelector {
 							? { selection, usage: sessionPreferredUsage, usageChecked: true }
 							: { selection, usage: null, usageChecked: false },
 					);
+		// Keep the candidate object: preflight may rebind its positional index
+		// after a peer changes the credential pool.
+		const explicitPin = sessionPinIsExplicit
+			? candidates.find(candidate => candidate.selection.index === sessionPreferredIndex)
+			: undefined;
 		const preflightFailures = new Set<OAuthCandidate>();
 		// The last retryable refresh error (network, timeout, 5xx) that removed a candidate.
 		// When no candidate resolves, it is rethrown so callers retry instead of reporting
@@ -714,21 +722,24 @@ export class CredentialSelector {
 		const forceRefreshIndex = options?.forceRefresh
 			? (sessionPreferredIndex ?? candidates[0]?.selection.index)
 			: undefined;
-		// Each candidate's synchronous prefix below runs back to back inside `map`,
-		// before any await, so one provider re-list serves every initial rebind.
-		// Resyncs after an await (refresh, disable) re-read the store.
+		// Candidate IDs were captured before ranking. Their synchronous rebinds
+		// share one provider re-list; resyncs after refresh await re-read the store.
 		let preflightRows: StoredAuthCredential[] | undefined;
 		await Promise.all(
 			candidates.map(async candidate => {
 				const force = forceRefreshIndex !== undefined && candidate.selection.index === forceRefreshIndex;
-				const initialCredentialId = this.#deps.pool.entries(provider)[candidate.selection.index]?.id;
-				let syncedPeerCredential = false;
-				if (initialCredentialId !== undefined) {
-					const beforeSync = candidate.selection.credential;
-					preflightRows ??= this.#reloadProviderRows(provider);
-					if (!this.#rebindOAuthSelection(preflightRows, candidate.selection, initialCredentialId)) return;
-					syncedPeerCredential = !authCredentialEquals(beforeSync, candidate.selection.credential);
+				const initialCredentialId = credentialIds[candidate.selection.index];
+				if (initialCredentialId === undefined) {
+					preflightFailures.add(candidate);
+					return;
+				}
+				const beforeSync = candidate.selection.credential;
+				preflightRows ??= this.#reloadProviderRows(provider);
+				if (!this.#rebindOAuthSelection(preflightRows, candidate.selection, initialCredentialId)) {
+					preflightFailures.add(candidate);
+					return;
 				}
+				const syncedPeerCredential = !authCredentialEquals(beforeSync, candidate.selection.credential);
 				const hasFreshAccess = Date.now() + OAUTH_REFRESH_SKEW_MS < candidate.selection.credential.expires;
 				if ((!force || syncedPeerCredential) && hasFreshAccess) return;
 				const latestCredential = this.#deps.pool.credentials(provider)[candidate.selection.index];
@@ -884,9 +895,15 @@ export class CredentialSelector {
 		];
 		if (enforcePlanRequirement) passes.push({ allowBlocked: true, enforcePlanRequirement: false, enforceAccounts });
 		if (enforceAccounts) passes.push({ allowBlocked: true, enforcePlanRequirement: false, enforceAccounts: false });
+		// Blocked candidates rank earliest-unblock first, which would route a
+		// blocked explicit pin to an equally blocked sibling. Once the strict
+		// pass finds no unblocked account, the user's pin goes first.
+		const lastResortCandidates = explicitPin
+			? [explicitPin, ...candidates.filter(candidate => candidate !== explicitPin)]
+			: candidates;
 
 		for (const pass of passes) {
-			for (const candidate of candidates) {
+			for (const candidate of pass.allowBlocked ? lastResortCandidates : candidates) {
 				if (preflightFailures.has(candidate)) continue;
 				const candidateAccountKey = oauthAccountKey(candidate.selection.credential);
 				if (pass.enforceAccounts && (candidateAccountKey === undefined || !accountIds?.has(candidateAccountKey)))

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

@@ -1582,9 +1582,10 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
  * pick the one whose identity (accountId / email / projectId) lines up with
  * the credential the caller is asking about.
  *
- * Falls back to the lone candidate when only one matches the provider; falls
- * through to `null` when nothing matches, which `AuthStorage` treats as "no
- * usage data" (ranking proceeds without a usage signal for this credential).
+ * Falls back to the provider's lone report when it shares no identity field
+ * with the credential; falls through to `null` when nothing matches, which
+ * `AuthStorage` treats as "no usage data" (ranking proceeds without a usage
+ * signal for this credential).
  */
 function matchUsageReport(reports: UsageReport[], provider: Provider, credential: OAuthCredential): UsageReport | null {
 	const all = reports.filter(report => report.provider === provider);
@@ -1635,7 +1636,17 @@ function matchUsageReport(reports: UsageReport[], provider: Provider, credential
 		report => !readMetadataString((report.metadata ?? {}) as Record<string, unknown>, "orgId"),
 	);
 	if (candidates.length === 0) return null;
-	if (all.length === 1 && candidates.length === 1) return candidates[0];
+	// The sole report stands in for a credential it shares no identity field
+	// with; otherwise identity decides, because a report naming another email,
+	// account or project is a sibling's pool whose fetch succeeded where this
+	// credential's failed.
+	if (
+		all.length === 1 &&
+		candidates.length === 1 &&
+		!reportHasComparableIdentity(candidates[0], accountId, email, projectId)
+	) {
+		return candidates[0];
+	}
 	for (const report of candidates) {
 		if (reportMatchesIdentity(report, accountId, email, projectId)) return report;
 	}
@@ -1699,7 +1710,13 @@ function findMatchingReportIndex(reports: UsageReport[], overlay: UsageReport):
 		candidate => !readMetadataString((candidate.report.metadata ?? {}) as Record<string, unknown>, "orgId"),
 	);
 	if (candidates.length === 0) return -1;
-	if (all.length === 1 && candidates.length === 1) return candidates[0]!.index;
+	if (
+		all.length === 1 &&
+		candidates.length === 1 &&
+		!reportHasComparableIdentity(candidates[0]!.report, accountId, email, projectId)
+	) {
+		return candidates[0]!.index;
+	}
 	for (const candidate of candidates) {
 		if (reportMatchesIdentity(candidate.report, accountId, email, projectId)) return candidate.index;
 	}
@@ -1721,19 +1738,39 @@ function reportMatchesIdentity(
 		const metaAccount = readMetadataString(metadata, "accountId") ?? readMetadataString(metadata, "account_id");
 		if (metaAccount && metaAccount.toLowerCase() === accountId) return true;
 		for (const limit of report.limits) {
-			if (limit.scope.accountId?.toLowerCase() === accountId) return true;
+			if (limit.scope.accountId?.trim().toLowerCase() === accountId) return true;
 		}
 	}
 	if (projectId) {
 		const metaProject = readMetadataString(metadata, "projectId") ?? readMetadataString(metadata, "project_id");
 		if (metaProject && metaProject.toLowerCase() === projectId) return true;
 		for (const limit of report.limits) {
-			if (limit.scope.projectId?.toLowerCase() === projectId) return true;
+			if (limit.scope.projectId?.trim().toLowerCase() === projectId) return true;
 		}
 	}
 	return false;
 }
 
+/** Whether the report names an email, account or project the caller can compare against. */
+function reportHasComparableIdentity(
+	report: UsageReport,
+	accountId: string | undefined,
+	email: string | undefined,
+	projectId: string | undefined,
+): boolean {
+	const metadata = report.metadata ?? {};
+	if (email && readMetadataString(metadata, "email")) return true;
+	if (accountId) {
+		if (readMetadataString(metadata, "accountId") ?? readMetadataString(metadata, "account_id")) return true;
+		if (report.limits.some(limit => limit.scope.accountId?.trim())) return true;
+	}
+	if (projectId) {
+		if (readMetadataString(metadata, "projectId") ?? readMetadataString(metadata, "project_id")) return true;
+		if (report.limits.some(limit => limit.scope.projectId?.trim())) return true;
+	}
+	return false;
+}
+
 function readMetadataString(metadata: Record<string, unknown>, key: string): string | undefined {
 	const value = metadata[key];
 	return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;

package/src/error/rate-limit.ts

@@ -78,15 +78,17 @@ const ACCOUNT_SCOPED_403_PATTERN =
 	/\b(?:overall|account|organization|team|workspace)\b[^\n]{0,40}\b(?:message |request )?rate.?limit\b|\byour\b[^\n]{0,30}\b(?:limit )?will reset\b/i;
 // Simplified Chinese account-quota exhaustion phrasing. Zhipu Coding Plan
 // returns e.g. "429 已达到 5 小时的使用上限。您的限额将在 2026-08-06 20:06:00 重置。"
-// (type=1308) when the 5h window is spent; other CN providers use 额度已用完 /
+// (type=1308) when the 5h window is spent; MiniMax CN returns
+// "当前已达到 Token Plan 用量上限。…" (2067); other CN providers use 额度已用完 /
 // 配额已耗尽 / 余额不足. These are persistent account-local caps that must
 // rotate to a sibling credential, not transient rate limits, so they are
 // matched before the RATE_LIMIT_EXCEEDED branch. The 上限 arm is anchored on
-// the 使用 token: a rate/concurrency cap phrased as 每分钟请求数已达上限 /
-// 并发请求数已达上限 / 速率达到上限 (no 使用) must NOT match, or it would burn a
-// healthy sibling credential as a false quota. "速率限制" is absent for the
-// same reason.
-const CN_QUOTA_EXHAUSTED_PATTERN = /使用.{0,30}?上限|(?:额度|配额)已?(?:用|耗)(?:完|尽)|限额.{0,30}重置|余额不足/;
+// the 使用 / 用量 tokens: a rate/concurrency cap phrased as 每分钟请求数已达上限 /
+// 并发请求数已达上限 / 速率达到上限 (neither token) must NOT match, or it would
+// burn a healthy sibling credential as a false quota. "速率限制" is absent for
+// the same reason.
+const CN_QUOTA_EXHAUSTED_PATTERN =
+	/(?:使用|用量).{0,30}?上限|(?:额度|配额)已?(?:用|耗)(?:完|尽)|限额.{0,30}重置|余额不足/;
 // Simplified Chinese rate/concurrency caps can contain both 使用 and 上限, but
 // remain transient rather than account quota exhaustion.
 const CN_TRANSIENT_CAP_PATTERN =

package/src/providers/amazon-bedrock.ts

@@ -450,16 +450,20 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 			let toolConfig = toolPlan.toolConfig;
 			const sentinelInjected = toolPlan.sentinelInjected;
 			let additionalModelRequestFields = buildAdditionalModelRequestFields(model, options);
-			const prefixMismatchBehavior = model.thinking?.prefixBinding
-				? (options.anthropicPrefixMismatchBehavior ?? "drop_block")
-				: undefined;
+			const thinkingDisabled =
+				isRecord(additionalModelRequestFields?.thinking) &&
+				additionalModelRequestFields.thinking.type === "disabled";
+			const prefixMismatchBehavior =
+				!thinkingDisabled && model.thinking?.prefixBinding
+					? (options.anthropicPrefixMismatchBehavior ?? "drop_block")
+					: undefined;
 
 			// Some models (Opus/Sonnet 5.5) reject forced tool use outright; keep the
 			// tools offered under `auto` and leave thinking intact.
 			const forcedChoice = toolConfig?.toolChoice?.any || toolConfig?.toolChoice?.tool;
 			if (toolConfig && forcedChoice && !model.compat.supportsForcedToolChoice) {
 				toolConfig = { ...toolConfig, toolChoice: { auto: {} } };
-			} else if (toolConfig && forcedChoice && additionalModelRequestFields) {
+			} else if (toolConfig && forcedChoice && additionalModelRequestFields && !thinkingDisabled) {
 				// Bedrock rejects thinking + forced tool_choice. Fable's adaptive
 				// thinking cannot be disabled, so downgrade its forced choice instead.
 				if (prefixMismatchBehavior) toolConfig = { ...toolConfig, toolChoice: { auto: {} } };
@@ -1335,7 +1339,13 @@ function buildAdditionalModelRequestFields(
 	options: BedrockOptions,
 ): Record<string, unknown> | undefined {
 	const reasoning = options.reasoning;
-	if (!reasoning || !model.reasoning) return undefined;
+	if (!model.reasoning) return undefined;
+	if (!reasoning) {
+		if (model.compat.disabledThinking === "disabled") {
+			return { thinking: { type: "disabled" }, output_config: { effort: "low" } };
+		}
+		return undefined;
+	}
 
 	const mode = model.thinking?.mode;
 	if (mode === "anthropic-adaptive") {

package/src/providers/anthropic.ts

@@ -4514,6 +4514,23 @@ export function resolveAnthropicCompactionEffort(
 	);
 }
 
+/**
+ * Whether effort controls earlier requests left in `messages` rule out
+ * `thinking: {type: "disabled"}`: Anthropic rejects a per-message effort
+ * control with thinking off, and `disabled` above `high` effort. Both stay in
+ * force across a thinking toggle, so such a request falls back to the
+ * adaptive-only off path (lowest effort) instead of a 400.
+ */
+function effortControlsBlockDisabledThinking(
+	model: Model<"anthropic-messages">,
+	messages: readonly Message[],
+	records: readonly AnthropicControlRecord[],
+): boolean {
+	if (model.compat.supportsPerMessageEffort !== true) return false;
+	const plan = planAnthropicEffortControls(undefined, messages, records, true, undefined, false);
+	return plan.inserts.length > 0 || plan.topLevel === "xhigh" || plan.topLevel === "max";
+}
+
 /**
  * Splice control markers into `messages`. Inserts sharing an index come from
  * one request and merge into one control: tool changes first, then the effort.
@@ -4732,7 +4749,11 @@ function buildParams(
 	let outputConfigEffort: AnthropicOutputEffort | undefined;
 	if (model.reasoning) {
 		const disabledThinking = model.compat.disabledThinking;
-		if (options?.thinkingEnabled === false && disabledThinking !== undefined) {
+		if (
+			options?.thinkingEnabled === false &&
+			disabledThinking !== undefined &&
+			!(disabledThinking === "disabled" && effortControlsBlockDisabledThinking(model, context.messages, records))
+		) {
 			if (disabledThinking !== "omit") {
 				thinking =
 					disabledThinking === "adaptive"

package/src/providers/openai-codex-responses.ts

@@ -102,6 +102,7 @@ export { setCodexAttestationProvider } from "./openai-codex-attestation";
 export type { CodexAttestationProvider } from "./openai-codex-attestation";
 import {
 	getOpenAIEffortControlState,
+	releaseOpenAIEffortControlSession,
 	type OpenAIEffortControlState,
 	planStableOpenAIEffort,
 } from "./openai-configuration-update";
@@ -434,6 +435,7 @@ export interface OpenAICodexWebSocketDebugStats {
  * is historical — SSE-only sessions use it too.
  */
 type CodexWebSocketSessionState = {
+	sessionId: string;
 	disableWebsocket: boolean;
 	lastRequest?: RequestBody;
 	/** Last completed response; an in-progress response cannot replace the retry baseline. */
@@ -1058,6 +1060,20 @@ function createCodexProviderSessionState(): CodexProviderSessionState {
 		webSocketPublicToPrivate: new Map(),
 		metadataSessions: new Map(),
 		effortControls: new Map(),
+		releaseSession: sessionId => {
+			const normalizedSessionId = normalizeOpenAIPromptCacheKey(sessionId);
+			if (!normalizedSessionId) return;
+			for (const [key, session] of state.webSocketSessions) {
+				if (session.sessionId !== normalizedSessionId) continue;
+				session.connection?.close("session_disposed");
+				state.webSocketSessions.delete(key);
+				for (const [publicKey, privateKey] of state.webSocketPublicToPrivate) {
+					if (privateKey === key) state.webSocketPublicToPrivate.delete(publicKey);
+				}
+			}
+			state.metadataSessions.delete(normalizedSessionId);
+			releaseOpenAIEffortControlSession(state.effortControls, normalizedSessionId);
+		},
 		close: () => {
 			for (const session of state.webSocketSessions.values()) {
 				session.connection?.close("session_disposed");
@@ -1472,14 +1488,14 @@ function createCodexRequestContext(
 		transportProviderSessionState?.webSocketPublicToPrivate.set(publicSessionKey, sessionKey);
 	}
 	const sharedWebsocketState =
-		sessionKey && providerSessionState
+		sessionKey && transportSessionId && providerSessionState
 			? isolatedTransportState
 				? providerSessionState.webSocketSessions.get(sessionKey)
-				: getCodexWebSocketSessionState(sessionKey, providerSessionState)
+				: getCodexWebSocketSessionState(sessionKey, transportSessionId, providerSessionState)
 			: undefined;
 	const websocketState =
-		sessionKey && isolatedTransportState
-			? getCodexWebSocketSessionState(sessionKey, isolatedTransportState)
+		sessionKey && transportSessionId && isolatedTransportState
+			? getCodexWebSocketSessionState(sessionKey, transportSessionId, isolatedTransportState)
 			: sharedWebsocketState;
 	if (isolatedTransportState && websocketState && sharedWebsocketState) {
 		websocketState.disableWebsocket = sharedWebsocketState.disableWebsocket;
@@ -1616,7 +1632,7 @@ function applyCodexStableEffort(
 	const providerState = getCodexProviderSessionState(options?.providerSessionState);
 	const sessionId = normalizeOpenAIPromptCacheKey(options?.sessionId);
 	if (!providerState || !sessionId) return;
-	const state = getOpenAIEffortControlState(providerState.effortControls, `${model.id}\u0000${sessionId}`);
+	const state = getOpenAIEffortControlState(providerState.effortControls, `${model.id}\u0000${sessionId}`, sessionId);
 	body.reasoning = { ...body.reasoning, effort: planStableOpenAIEffort(state, body.input, effort) };
 }
 
@@ -3361,13 +3377,10 @@ export async function prewarmOpenAICodexResponses(
 	if (publicSessionKey && sessionKey) {
 		providerSessionState?.webSocketPublicToPrivate.set(publicSessionKey, sessionKey);
 	}
-	if (!sessionKey || !providerSessionState) return;
-	const state = getCodexWebSocketSessionState(sessionKey, providerSessionState);
+	if (!sessionKey || !transportSessionId || !providerSessionState) return;
+	const state = getCodexWebSocketSessionState(sessionKey, transportSessionId, providerSessionState);
 	if (!shouldUseCodexWebSocket(model, state, options?.preferWebsockets)) return;
-	const metadataSession = getOrCreateCodexMetadataSessionState(
-		transportSessionId ?? crypto.randomUUID(),
-		providerSessionState,
-	);
+	const metadataSession = getOrCreateCodexMetadataSessionState(transportSessionId, providerSessionState);
 	const turnState = getOrCreateCodexTurnState(metadataSession, sessionKey);
 	const codexClientVersion = CODEX_CLIENT_VERSION;
 	const requestIdentity = createCodexCompatibilityIdentity(metadataSession);
@@ -3418,11 +3431,13 @@ function getCodexWebSocketSessionKey(
 
 function getCodexWebSocketSessionState(
 	sessionKey: string,
+	sessionId: string,
 	providerSessionState: CodexProviderSessionState,
 ): CodexWebSocketSessionState {
 	const existing = providerSessionState.webSocketSessions.get(sessionKey);
 	if (existing) return existing;
 	const created: CodexWebSocketSessionState = {
+		sessionId,
 		disableWebsocket: false,
 		canAppend: false,
 		fallbackCount: 0,

package/src/providers/openai-configuration-update.ts

@@ -36,13 +36,16 @@ interface EffortTransition<TEffort extends string> {
 
 /** Per-conversation effort baseline and recorded transitions. */
 export interface OpenAIEffortControlState<TEffort extends string = string> {
+	sessionId: string;
 	baseEffort?: TEffort;
 	currentEffort?: TEffort;
 	transitions: EffortTransition<TEffort>[];
 }
 
-export function createOpenAIEffortControlState<TEffort extends string>(): OpenAIEffortControlState<TEffort> {
-	return { transitions: [] };
+export function createOpenAIEffortControlState<TEffort extends string>(
+	sessionId: string,
+): OpenAIEffortControlState<TEffort> {
+	return { sessionId, transitions: [] };
 }
 
 const MAX_EFFORT_CONTROL_STATES = 16;
@@ -54,6 +57,7 @@ const MAX_EFFORT_CONTROL_STATES = 16;
 export function getOpenAIEffortControlState<TEffort extends string>(
 	states: Map<string, OpenAIEffortControlState<TEffort>>,
 	key: string,
+	sessionId: string,
 ): OpenAIEffortControlState<TEffort> {
 	const existing = states.get(key);
 	if (existing) {
@@ -61,7 +65,7 @@ export function getOpenAIEffortControlState<TEffort extends string>(
 		states.set(key, existing);
 		return existing;
 	}
-	const created = createOpenAIEffortControlState<TEffort>();
+	const created = createOpenAIEffortControlState<TEffort>(sessionId);
 	states.set(key, created);
 	if (states.size > MAX_EFFORT_CONTROL_STATES) {
 		const oldest = states.keys().next().value;
@@ -70,6 +74,16 @@ export function getOpenAIEffortControlState<TEffort extends string>(
 	return created;
 }
 
+/** Release one conversation's effort state from the Responses and Codex `releaseSession` implementations. */
+export function releaseOpenAIEffortControlSession<TEffort extends string>(
+	states: Map<string, OpenAIEffortControlState<TEffort>>,
+	sessionId: string,
+): void {
+	for (const [key, state] of states) {
+		if (state.sessionId === sessionId) states.delete(key);
+	}
+}
+
 interface AnchorableItem {
 	type?: string | null;
 	role?: string;

package/src/providers/openai-responses.ts

@@ -56,6 +56,7 @@ import {
 import { compactGrammarDefinition } from "./grammar";
 import {
 	getOpenAIEffortControlState,
+	releaseOpenAIEffortControlSession,
 	type OpenAIEffortControlState,
 	planStableOpenAIEffort,
 } from "./openai-configuration-update";
@@ -95,6 +96,7 @@ import {
 	getJuiceValue,
 	getOpenAIPromptCacheKey,
 	getOpenAIResponsesRoutingSessionId,
+	normalizeOpenAIPromptCacheKey,
 	getOpenAIStrictToolsScope,
 	getOpenRouterResponsesSessionId,
 	isCompiledGrammarTooLargeStrictError,
@@ -404,6 +406,7 @@ interface OpenAIResponsesProviderSessionState
 type ResponsesStableEffort = Exclude<ReasoningEffort, "none" | null>;
 
 interface OpenAIResponsesChainState {
+	sessionId: string;
 	/**
 	 * Wire params of the last successful turn; never carries
 	 * `previous_response_id`.
@@ -429,6 +432,14 @@ function createOpenAIResponsesProviderSessionState(): OpenAIResponsesProviderSes
 		nativeHistoryReplayWarmed: false,
 		chains: new Map(),
 		effortControls: new Map(),
+		releaseSession: sessionId => {
+			const normalizedSessionId = normalizeOpenAIPromptCacheKey(sessionId);
+			if (!normalizedSessionId) return;
+			for (const [key, chain] of state.chains) {
+				if (chain.sessionId === normalizedSessionId) state.chains.delete(key);
+			}
+			releaseOpenAIEffortControlSession(state.effortControls, normalizedSessionId);
+		},
 		close: () => {
 			state.nativeHistoryReplayWarmed = false;
 			state.chains.clear();
@@ -511,7 +522,7 @@ function getOpenAIResponsesChainState(
 	const key = `${resolvedBaseUrl ?? model.baseUrl ?? ""}\u0000${model.id}\u0000${sessionId}`;
 	const existing = providerSessionState.chains.get(key);
 	if (existing) return existing;
-	const created: OpenAIResponsesChainState = { canAppend: false, staleFailures: 0, disabled: false };
+	const created: OpenAIResponsesChainState = { sessionId, canAppend: false, staleFailures: 0, disabled: false };
 	providerSessionState.chains.set(key, created);
 	return created;
 }
@@ -1744,6 +1755,7 @@ function applyResponsesStableEffort(
 	const state = getOpenAIEffortControlState(
 		providerSessionState.effortControls,
 		`${model.baseUrl ?? ""}\u0000${model.id}\u0000${sessionId}`,
+		sessionId,
 	);
 	params.reasoning = { ...reasoning, effort: planStableOpenAIEffort(state, input, effort) };
 }

package/src/types.ts

@@ -405,6 +405,8 @@ export function coerceServiceTierByFamily(value: unknown): ServiceTierByFamily |
 
 export interface ProviderSessionState {
 	close(): void;
+	/** Release one routing session after its final request, preserving shared provider fallbacks. */
+	releaseSession?(sessionId: string): void;
 }
 
 export interface ProviderResponseMetadata {

package/src/utils/glyph-codec.ts

@@ -1,4 +1,13 @@
-import type { AssistantMessage, Context, CursorExecHandlers, ImageContent, Message, TextContent } from "../types";
+import type {
+	AssistantMessage,
+	AssistantMessageEvent,
+	Context,
+	CursorExecHandlers,
+	ImageContent,
+	Message,
+	TextContent,
+	ToolCall,
+} from "../types";
 import { getStreamingPartialJson, setStreamingPartialJson } from "./block-symbols";
 import { AssistantMessageEventStream } from "./event-stream";
 import glyphNotice from "./glyph-notice.md" with { type: "text" };
@@ -10,6 +19,9 @@ const GLYPH_ENCODE_PATTERN =
 	/([\uE000-\uF8FF\u{F0000}-\u{FFFFD}\u{100000}-\u{10FFFD}])|⟦(?=(?:U[0-9a-fA-F]{4,6}|E)⟧)/gu;
 const GLYPH_DECODE_PATTERN = /⟦E⟧|⟦U([0-9a-fA-F]{4,6})⟧/gu;
 
+/** A trailing token or escape prefix that a later delta may still complete; sticky, tested at the last opener. */
+const GLYPH_PENDING_TAIL = /⟦(?:U[0-9a-fA-F]{0,6}|E)?$/uy;
+
 const kGlyphEncoded = Symbol("provider.context.glyphEncoded");
 
 interface GlyphEncodedContext extends Context {
@@ -20,7 +32,7 @@ interface GlyphEncodedContext extends Context {
 export interface GlyphCodec {
 	/** Context with model-bound glyphs encoded and one conditional convention notice. */
 	context: Context;
-	/** Decodes glyph tokens in the stream's terminal assistant message. */
+	/** Decodes glyph tokens live: text and tool-call deltas, partial snapshots, completed tool calls, and the terminal message. */
 	wrap(inner: AssistantMessageEventStream): AssistantMessageEventStream;
 	/** Decodes Cursor Pi calls and encodes their provider-bound results. */
 	wrapCursorExecHandlers(handlers: CursorExecHandlers): CursorExecHandlers;
@@ -287,15 +299,196 @@ function decodeAssistantMessageInPlace(message: AssistantMessage): void {
 	}
 }
 
+/** Decoded copy of a tool call, or the block itself when it carries no tokens. */
+function decodeToolCall(block: ToolCall): ToolCall {
+	const args = transformRecord(block.arguments, decodeGlyphText);
+	const partialJson = getStreamingPartialJson(block);
+	const json = partialJson === undefined ? undefined : decodeGlyphText(partialJson);
+	if (args === block.arguments && json === partialJson) return block;
+	const decoded: ToolCall = { ...block, arguments: args };
+	if (json !== undefined) setStreamingPartialJson(decoded, json);
+	return decoded;
+}
+
+/** Decodes one streamed block incrementally, holding back a token split across deltas. */
+class GlyphDeltaDecoder {
+	#pending = "";
+
+	/** Decodes everything in the held-back tail plus `delta` that no later delta can still change. */
+	push(delta: string): string {
+		const text = this.#pending + delta;
+		const open = text.lastIndexOf(GLYPH_OPEN);
+		let cut = text.length;
+		if (open >= 0) {
+			GLYPH_PENDING_TAIL.lastIndex = open;
+			if (GLYPH_PENDING_TAIL.test(text)) cut = open;
+		}
+		this.#pending = text.slice(cut);
+		return decodeGlyphText(cut === text.length ? text : text.slice(0, cut));
+	}
+
+	/** Releases the held-back tail verbatim: an unfinished token is literal text. */
+	flush(): string {
+		const tail = this.#pending;
+		this.#pending = "";
+		return tail;
+	}
+}
+
+/** Decode state for one streamed text or tool-call block. */
+interface GlyphChannel {
+	kind: "text" | "toolCall";
+	decoder: GlyphDeltaDecoder;
+	/** Decoded text forwarded so far; text blocks only. */
+	text: string;
+	/** Whether a delta carried a token opener; tool-call stand-ins are only rebuilt then. */
+	tokens: boolean;
+	/** Decoded stand-in for the provider's block in forwarded partials. */
+	view?: AssistantMessage["content"][number];
+}
+
+/**
+ * Re-projects a provider stream with glyph tokens decoded as they arrive, so
+ * delta consumers (side-channel replies, argument streams) and partial
+ * snapshots (live rendering, speculation) never see wire tokens.
+ *
+ * Provider-owned blocks are never mutated mid-stream — the provider keeps
+ * appending to them — so decoded stand-ins are swapped into each forwarded
+ * partial instead. The terminal message is decoded in place once. Thinking
+ * stays encoded, matching {@link decodeAssistantMessageInPlace}.
+ */
+class GlyphStreamProjector {
+	readonly #out: AssistantMessageEventStream;
+	readonly #channels = new Map<number, GlyphChannel>();
+	/** Set once any block has a stand-in; until then events pass through untouched. */
+	#projected = false;
+
+	constructor(out: AssistantMessageEventStream) {
+		this.#out = out;
+	}
+
+	push(event: AssistantMessageEvent): void {
+		switch (event.type) {
+			case "start":
+				this.#channels.clear();
+				this.#projected = false;
+				this.#out.push(event);
+				return;
+			case "text_delta": {
+				const channel = this.#channel(event.contentIndex, "text");
+				const delta = channel.decoder.push(event.delta);
+				channel.text += delta;
+				const block = event.partial.content[event.contentIndex];
+				if (block?.type === "text" && (channel.view !== undefined || delta !== event.delta)) {
+					this.#setView(channel, { ...block, text: channel.text });
+				}
+				if (!delta) return;
+				this.#out.push(
+					delta === event.delta && !this.#projected
+						? event
+						: { ...event, delta, partial: this.#partial(event.partial) },
+				);
+				return;
+			}
+			case "text_end": {
+				const channel = this.#channel(event.contentIndex, "text");
+				this.#flush(event.contentIndex, channel, event.partial);
+				const content = decodeGlyphText(event.content);
+				const block = event.partial.content[event.contentIndex];
+				if (block?.type === "text" && (channel.view !== undefined || content !== event.content)) {
+					this.#setView(channel, { ...block, text: content });
+				}
+				this.#out.push(
+					content === event.content && !this.#projected
+						? event
+						: { ...event, content, partial: this.#partial(event.partial) },
+				);
+				return;
+			}
+			case "toolcall_delta": {
+				const channel = this.#channel(event.contentIndex, "toolCall");
+				const delta = channel.decoder.push(event.delta);
+				channel.tokens ||= event.delta.includes(GLYPH_OPEN);
+				const block = event.partial.content[event.contentIndex];
+				if (channel.tokens && block?.type === "toolCall") {
+					const view = decodeToolCall(block);
+					if (view === block) channel.view = undefined;
+					else this.#setView(channel, view);
+				}
+				if (!delta) return;
+				this.#out.push(
+					delta === event.delta && !this.#projected
+						? event
+						: { ...event, delta, partial: this.#partial(event.partial) },
+				);
+				return;
+			}
+			case "toolcall_end": {
+				const channel = this.#channel(event.contentIndex, "toolCall");
+				this.#flush(event.contentIndex, channel, event.partial);
+				const toolCall = decodeToolCall(event.toolCall);
+				if (toolCall === event.toolCall) channel.view = undefined;
+				else this.#setView(channel, toolCall);
+				this.#out.push(
+					toolCall === event.toolCall && !this.#projected
+						? event
+						: { ...event, toolCall, partial: this.#partial(event.partial) },
+				);
+				return;
+			}
+			case "done":
+			case "error": {
+				const message = event.type === "done" ? event.message : event.error;
+				for (const [index, channel] of this.#channels) this.#flush(index, channel, message);
+				decodeAssistantMessageInPlace(message);
+				this.#out.push(event);
+				return;
+			}
+			default:
+				this.#out.push(this.#projected ? { ...event, partial: this.#partial(event.partial) } : event);
+		}
+	}
+
+	#channel(index: number, kind: GlyphChannel["kind"]): GlyphChannel {
+		let channel = this.#channels.get(index);
+		if (channel === undefined) {
+			channel = { kind, decoder: new GlyphDeltaDecoder(), text: "", tokens: false };
+			this.#channels.set(index, channel);
+		}
+		return channel;
+	}
+
+	#setView(channel: GlyphChannel, view: AssistantMessage["content"][number]): void {
+		channel.view = view;
+		this.#projected = true;
+	}
+
+	/** Forwards a block's held-back tail before the block ends or the stream settles. */
+	#flush(index: number, channel: GlyphChannel, partial: AssistantMessage): void {
+		const tail = channel.decoder.flush();
+		if (!tail) return;
+		if (channel.kind === "toolCall") {
+			this.#out.push({ type: "toolcall_delta", contentIndex: index, delta: tail, partial: this.#partial(partial) });
+			return;
+		}
+		channel.text += tail;
+		const block = partial.content[index];
+		if (block?.type === "text") this.#setView(channel, { ...block, text: channel.text });
+		this.#out.push({ type: "text_delta", contentIndex: index, delta: tail, partial: this.#partial(partial) });
+	}
+
+	#partial(partial: AssistantMessage): AssistantMessage {
+		if (!this.#projected) return partial;
+		return { ...partial, content: partial.content.map((block, index) => this.#channels.get(index)?.view ?? block) };
+	}
+}
+
 function wrapGlyphStream(inner: AssistantMessageEventStream): AssistantMessageEventStream {
 	const out = new AssistantMessageEventStream();
+	const projector = new GlyphStreamProjector(out);
 	void (async () => {
 		try {
-			for await (const event of inner) {
-				if (event.type === "done") decodeAssistantMessageInPlace(event.message);
-				else if (event.type === "error") decodeAssistantMessageInPlace(event.error);
-				out.push(event);
-			}
+			for await (const event of inner) projector.push(event);
 			if (!out.done) {
 				const result = await inner.result();
 				decodeAssistantMessageInPlace(result);

package/src/utils/schema/CONSTRAINTS.md

@@ -64,19 +64,21 @@ Schemas sent on the Google JSON Schema path MUST follow:
 
 1. **Unsupported JSON Schema keywords are stripped (except property names under `properties`)**
    - Unsupported keys (`UNSUPPORTED_SCHEMA_FIELDS`):
-      - `$schema`, `$ref`, `$defs`, `$dynamicRef`, `$dynamicAnchor`
+      - `$schema`, `$id`, `$anchor`, `$ref`, `$defs`, `$dynamicRef`, `$dynamicAnchor`
       - `examples`, `prefixItems`, `unevaluatedProperties`, `unevaluatedItems`
-      - `patternProperties`, `additionalProperties`
-      - `minItems`, `maxItems`, `minLength`, `maxLength`
-      - `minimum`, `maximum`, `exclusiveMinimum`, `exclusiveMaximum`
-      - `pattern`, `format`
+      - `patternProperties`, `additionalProperties`, `propertyNames`
+      - `minItems`, `maxItems`, `uniqueItems`, `contains`, `minContains`, `maxContains`, `additionalItems`
+      - `minLength`, `maxLength`, `minimum`, `maximum`, `exclusiveMinimum`, `exclusiveMaximum`, `multipleOf`
+      - `pattern`, `format`, `contentEncoding`, `contentMediaType`, `contentSchema`
       - `dependencies`, `dependentSchemas`, `dependentRequired`
-      - `deprecated`, `readOnly`, `writeOnly`, `$comment`
+      - `x-mcp-header`, `deprecated`, `readOnly`, `writeOnly`, `$comment`
    - Important: keys inside a `properties` object are treated as property names and MUST NOT be stripped by keyword match.
    - Human-meaningful stripped keys (`pattern`, `format`, min/max constraints, `default`, `examples`, etc.) are appended to the sibling `description` as an Anthropic-style spill block: `{pattern: "^foo$", minimum: 0}`. Structural/meta keys such as `$ref`, `$defs`, and `additionalProperties` are not spilled.
 
 2. **`type` arrays are normalized to scalar type + nullable marker**
    - `type: ["T", "null"]` becomes `type: "T"` and `nullable: true`.
+   - `type: ["A", "B", …]` becomes `anyOf: [{ type: "A", …A keywords }, { type: "B", …B keywords }]`; type-specific keywords (`items`, `properties`, `minimum`, …) move into the branches whose type they constrain, and a `null` member becomes `nullable: true`.
+   - A node left with a scalar `type` MUST NOT keep another type's keywords: Gemini rejects `items` beside `type: "string"` with HTTP 400.
    - Google expects scalar type, not `type[]`.
 
 3. **`const` is converted to `enum`**
@@ -115,7 +117,7 @@ For Cloud Code Assist Claude tool declarations, schema MUST satisfy stricter con
 
 1. Start with Google unsupported-key stripping behavior.
 2. **`nullable` keyword MUST be stripped** in CCA Claude path.
-3. `type: ["T", "null"]` becomes `type: "T"` with no `nullable` marker.
+3. `type: ["T", "null"]` becomes `type: "T"` with no `nullable` marker; a multi-type array becomes `anyOf` branches that the combiner rules below collapse.
 4. Human-meaningful stripped keys are appended to `description` with the same spill format used by the Google dispatcher.
 
 ### 3.3 Combiner/union normalization contract

package/src/utils/schema/fields.ts

@@ -15,6 +15,8 @@
  */
 export const UNSUPPORTED_SCHEMA_FIELDS: Record<string, true> = {
 	$schema: true,
+	$id: true,
+	$anchor: true,
 	$ref: true,
 	$defs: true,
 	$dynamicRef: true,
@@ -28,6 +30,11 @@ export const UNSUPPORTED_SCHEMA_FIELDS: Record<string, true> = {
 	propertyNames: true,
 	minItems: true,
 	maxItems: true,
+	uniqueItems: true,
+	contains: true,
+	minContains: true,
+	maxContains: true,
+	additionalItems: true,
 	minLength: true,
 	maxLength: true,
 	minimum: true,
@@ -37,6 +44,9 @@ export const UNSUPPORTED_SCHEMA_FIELDS: Record<string, true> = {
 	multipleOf: true,
 	pattern: true,
 	format: true,
+	contentEncoding: true,
+	contentMediaType: true,
+	contentSchema: true,
 	dependencies: true,
 	dependentSchemas: true,
 	dependentRequired: true,
@@ -212,6 +222,8 @@ export const COMBINATOR_KEYS = ["anyOf", "allOf", "oneOf"] as const;
  */
 export const CCA_UNSUPPORTED_SCHEMA_FIELDS: Record<string, true> = {
 	$schema: true,
+	$id: true,
+	$anchor: true,
 	$ref: true,
 	$defs: true,
 	$dynamicRef: true,
@@ -223,4 +235,12 @@ export const CCA_UNSUPPORTED_SCHEMA_FIELDS: Record<string, true> = {
 	readOnly: true,
 	writeOnly: true,
 	$comment: true,
+	uniqueItems: true,
+	contains: true,
+	minContains: true,
+	maxContains: true,
+	additionalItems: true,
+	contentEncoding: true,
+	contentMediaType: true,
+	contentSchema: true,
 };

package/src/utils/schema/normalize.ts

@@ -36,7 +36,11 @@ export interface NormalizeSchemaOptions {
 	unsupportedFields: (key: string) => boolean;
 	normalizeFieldNames: boolean;
 	collapseNullFields: boolean;
-	normalizeTypeArrayToNullable: boolean;
+	/**
+	 * Target takes a scalar `type` only: `["T", "null"]` becomes `T` (+ `nullable`)
+	 * and a multi-type array becomes one `anyOf` branch per type.
+	 */
+	scalarizeTypeArrays: boolean;
 	stripNullableKeyword: boolean;
 	autoPropertyOrdering: boolean;
 	ensureObjectProperties: boolean;
@@ -290,6 +294,51 @@ function preHandleNullFields(obj: JsonObject): JsonObject {
 	return out;
 }
 
+/**
+ * Rewrites a multi-type `type` array (`["string", "array"]`) as one `anyOf`
+ * branch per non-null type, each carrying only the keywords that constrain its
+ * type. Collapsing to the first type instead narrows what the tool accepts and
+ * strands the other types' keywords: Gemini rejects `items` beside
+ * `type: "string"` with HTTP 400. A `null` member becomes `nullable: true`, as
+ * in the scalar collapse. Returns `obj` itself when it has fewer than two
+ * non-null types or already carries `anyOf`.
+ */
+function splitTypeArrayIntoAnyOf(obj: JsonObject): JsonObject {
+	if (!Array.isArray(obj.type) || Array.isArray(obj.anyOf)) return obj;
+	const types: string[] = [];
+	for (const type of obj.type) {
+		if (typeof type === "string" && type !== "null" && !types.includes(type)) types.push(type);
+	}
+	if (types.length < 2) return obj;
+	const branches = types.map(type => {
+		const schema: JsonObject = { type };
+		return { schema, keys: CLOUD_CODE_ASSIST_TYPE_SPECIFIC_KEYS[type] ?? {} };
+	});
+	const out: JsonObject = {};
+	for (const key in obj) {
+		if (!Object.hasOwn(obj, key) || key === "type") continue;
+		const value = obj[key];
+		if (!Object.hasOwn(ALL_CCA_TYPE_SPECIFIC_KEYS, key)) {
+			out[key] = value;
+			continue;
+		}
+		for (const branch of branches) {
+			if (Object.hasOwn(branch.keys, key)) branch.schema[key] = value;
+		}
+	}
+	if (obj.type.includes("null")) out.nullable = true;
+	out.anyOf = branches.map(branch => branch.schema);
+	return out;
+}
+
+/** Deletes keywords that constrain a JSON type other than `type`, e.g. `items` on a string node. */
+function dropForeignTypeKeywords(schema: JsonObject, type: string): void {
+	const allowed = CLOUD_CODE_ASSIST_TYPE_SPECIFIC_KEYS[type] ?? {};
+	for (const key in schema) {
+		if (Object.hasOwn(ALL_CCA_TYPE_SPECIFIC_KEYS, key) && !Object.hasOwn(allowed, key)) delete schema[key];
+	}
+}
+
 function outHasOwn(obj: JsonObject, key: string): boolean {
 	return Object.hasOwn(obj, key);
 }
@@ -375,6 +424,9 @@ function normalizeSchemaNode(value: unknown, options: NormalizeSchemaWalkOptions
 
 function normalizeSchemaObjectNode(value: JsonObject, options: NormalizeSchemaWalkOptions): unknown {
 	let obj = options.normalizeFieldNames && !options.insideSchemaMap ? applySnakeCaseRenames(value) : value;
+	if (options.scalarizeTypeArrays && !options.insideSchemaMap) {
+		obj = splitTypeArrayIntoAnyOf(obj);
+	}
 	if (options.collapseNullFields && !options.insideSchemaMap) {
 		obj = preHandleNullFields(obj);
 	}
@@ -479,13 +531,14 @@ function normalizeSchemaObjectNode(value: JsonObject, options: NormalizeSchemaWa
 			: entry;
 	}
 
-	if (options.normalizeTypeArrayToNullable && Array.isArray(result.type)) {
+	if (options.scalarizeTypeArrays && Array.isArray(result.type)) {
 		const types = (result.type as unknown[]).filter((t): t is string => typeof t === "string");
 		const nonNull = types.filter(t => t !== "null");
 		if (types.includes("null") && !options.stripNullableKeyword) {
 			result.nullable = true;
 		}
 		result.type = nonNull[0] ?? types[0];
+		if (typeof result.type === "string") dropForeignTypeKeywords(result, result.type);
 	}
 	if (constValue !== undefined) {
 		const existingEnum = Array.isArray(result.enum) ? result.enum : [];
@@ -738,20 +791,8 @@ function collapseMixedTypeCombinerVariants(schema: JsonObject, combiner: "anyOf"
 	const chosenType: string = nonNullTypes[0] ?? variantTypes[0];
 	nextSchema.type = chosenType;
 	const chosenTypeAllowedKeys = CLOUD_CODE_ASSIST_TYPE_SPECIFIC_KEYS[chosenType] ?? {};
-
-	// Strip sibling keys that were copied from the parent and belong to a
-	// different type (e.g. `items` sibling on a now-string-typed schema).
-	for (const key in nextSchema) {
-		if (!Object.hasOwn(nextSchema, key)) continue;
-		if (key === "type") continue;
-		if (
-			Object.hasOwn(ALL_CCA_TYPE_SPECIFIC_KEYS, key) &&
-			!Object.hasOwn(chosenTypeAllowedKeys, key) &&
-			!Object.hasOwn(CLOUD_CODE_ASSIST_SHARED_SCHEMA_KEYS, key)
-		) {
-			delete nextSchema[key];
-		}
-	}
+	// Sibling keys copied from the parent may belong to a different type.
+	dropForeignTypeKeywords(nextSchema, chosenType);
 
 	for (const key in mergedVariantFields) {
 		if (!Object.hasOwn(mergedVariantFields, key)) continue;
@@ -1256,7 +1297,7 @@ export function normalizeSchemaForGoogle(value: unknown): unknown {
 		unsupportedFields: isGoogleUnsupportedSchemaField,
 		normalizeFieldNames: true,
 		collapseNullFields: true,
-		normalizeTypeArrayToNullable: true,
+		scalarizeTypeArrays: true,
 		stripNullableKeyword: false,
 		autoPropertyOrdering: true,
 		ensureObjectProperties: true,
@@ -1279,7 +1320,7 @@ export function normalizeSchemaForCCA(value: unknown): unknown {
 		unsupportedFields: isGoogleUnsupportedSchemaField,
 		normalizeFieldNames: true,
 		collapseNullFields: false,
-		normalizeTypeArrayToNullable: true,
+		scalarizeTypeArrays: true,
 		stripNullableKeyword: true,
 		autoPropertyOrdering: false,
 		ensureObjectProperties: true,
@@ -1302,7 +1343,7 @@ export function normalizeSchemaForMCP(value: unknown): unknown {
 		unsupportedFields: isMcpUnsupportedSchemaField,
 		normalizeFieldNames: false,
 		collapseNullFields: false,
-		normalizeTypeArrayToNullable: false,
+		scalarizeTypeArrays: false,
 		foldOneOfIntoAnyOf: false,
 		stripNullableKeyword: true,
 		autoPropertyOrdering: false,
@@ -1330,8 +1371,9 @@ export function normalizeSchemaForMCP(value: unknown): unknown {
  *    rejected; collapse to `enum` with an inferred scalar `type`.
  *  - `oneOf` is not an MFJS combinator (only `anyOf` is); residual `oneOf` is
  *    folded into `anyOf`.
- *  - `type` must be a scalar string; `type: [...]` arrays are reduced to a
- *    single scalar (the `null` branch is dropped — `nullable` is unsupported).
+ *  - `type` must be a scalar string; `["T", "null"]` reduces to `T` (the
+ *    `null` member is dropped — `nullable` is unsupported) and a multi-type
+ *    array becomes one typed `anyOf` branch per type.
  *  - Enum-bearing nodes get an inferred `type` (the idiomatic MFJS form; a bare
  *    `enum` is valid too) so `anyOf` branches always carry a `type`.
  *  - Validation/decorative keywords (`minItems`, `maxItems`, `maxLength`,
@@ -1354,7 +1396,7 @@ export function normalizeSchemaForMoonshot(value: unknown): unknown {
 		unsupportedFields: isMoonshotUnsupportedSchemaField,
 		normalizeFieldNames: false,
 		collapseNullFields: false,
-		normalizeTypeArrayToNullable: true,
+		scalarizeTypeArrays: true,
 		stripNullableKeyword: true,
 		autoPropertyOrdering: false,
 		ensureObjectProperties: false,