@oh-my-pi/pi-ai 18.1.2 → 18.1.4

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [18.1.3] - 2026-09-02
+
+### Fixed
+
+- Fixed Gemini 3 sessions on Antigravity/Cloud Code Assist and Vertex AI getting permanently stuck on `400 INVALID_ARGUMENT` after a turn with parallel tool calls ([#9638](https://github.com/can1357/oh-my-pi/issues/9638)).
+- Preserved Anthropic thinking now survives side requests, tool-description drift, turn-scoped reminders, and recoverable prefix mismatches without corrupting the conversation prefix.
+- Fixed Anthropic-compatible endpoints backed by Amazon Bedrock permanently rejecting a session once an unsigned thinking block entered its history. The transport now recognizes Bedrock's `ValidationException … thinking.signature: Field required` as the same unsigned-thinking rejection it already heals for other signing proxies, so it demotes the unsigned block to text, retries once, and remembers the endpoint for the rest of the session instead of failing every turn and walking the model fallback chain.
+- Fixed the DeepSeek DSML markup healer leaking orphan `</｜DSML｜parameter>`/`</｜DSML｜invoke>` close tags into visible text, which poisoned long-session history and reinforced the model's XML-protocol mimicry until tool calls stopped dispatching ([#10556](https://github.com/can1357/oh-my-pi/issues/10556)).
+- Fixed repeated parallel tool-call batches bypassing the configured loop guard.
+- Fixed Cursor tool-schema composition failures by projecting unsupported keywords only for confirmed Fable models; Grok and other Cursor models retain canonical schemas.
+- Fixed API-key account rotation to honor provider-reported quota reset windows, including overlapping exhausted windows ([#10325](https://github.com/can1357/oh-my-pi/pull/10325) by [@usr-bin-roygbiv](https://github.com/usr-bin-roygbiv)).
+
 ## [18.1.2] - 2026-09-01
 
 ### Added

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

@@ -215,8 +215,8 @@ export declare function applyAnthropicUsageExtras(usage: Usage, source: Anthropi
 export declare function isThinkingPrefixBindingError(message: string): boolean;
 export declare function isInvalidThinkingSignatureError(message: string): boolean;
 /**
- * Prepend a pointed remediation to Anthropic's `Invalid signature in thinking
- * block` 400 when the model looks like an unmarked custom signing proxy
+ * Prepend a pointed remediation to a thinking-signature rejection 400 when the
+ * model looks like an unmarked custom signing proxy
  * (opaque baseUrl, `spec.reasoning: true`, no explicit
  * `compat.replayUnsignedThinking` override). The default is native replay for
  * the 3p reasoning majority (#2005); this hint turns the misconfigured-proxy

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

@@ -223,7 +223,7 @@ export declare function processInteractionUpdate(update: any, output: AssistantM
  * that reconstruction.
  */
 export declare function buildCursorRequestContextRules(systemPrompt: readonly string[] | undefined): CursorRule[];
-export declare function buildMcpToolDefinitions(tools: Tool[] | undefined): McpToolDefinition[];
+export declare function buildMcpToolDefinitions(tools: Tool[] | undefined, requiresCursorToolSchemaProjection?: boolean): McpToolDefinition[];
 /**
  * Build `ConversationStateStructure.rootPromptMessagesJson` blob IDs for the
  * system prompt plus prior conversation history, as JSON blobs matching

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.1.2",
+	"version": "18.1.4",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -37,10 +37,10 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.1.2",
-		"@oh-my-pi/pi-catalog": "18.1.2",
-		"@oh-my-pi/pi-utils": "18.1.2",
-		"@oh-my-pi/pi-wire": "18.1.2"
+		"@oh-my-pi/omptype": "18.1.4",
+		"@oh-my-pi/pi-catalog": "18.1.4",
+		"@oh-my-pi/pi-utils": "18.1.4",
+		"@oh-my-pi/pi-wire": "18.1.4"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/auth-storage.ts

@@ -3873,7 +3873,7 @@ export class AuthStorage {
 		return limits.some(limit => this.#isUsageLimitExhausted(limit));
 	}
 
-	/** Extracts the earliest reset timestamp from exhausted windows (in ms). */
+	/** Extracts when every currently exhausted window has reset (in ms). */
 	#getUsageResetAtMs(limits: UsageLimit[], nowMs: number): number | undefined {
 		const candidates: number[] = [];
 		for (const limit of limits) {
@@ -3884,7 +3884,7 @@ export class AuthStorage {
 			}
 		}
 		if (candidates.length === 0) return undefined;
-		return Math.min(...candidates);
+		return Math.max(...candidates);
 	}
 
 	async #getUsageReport(
@@ -4572,7 +4572,7 @@ export class AuthStorage {
 		const now = Date.now();
 		let blockedUntil = now + (options?.retryAfterMs ?? AuthStorage.#defaultBackoffMs);
 
-		if (credentialType === "oauth" && target.credential.type === "oauth" && routing.strategy) {
+		if (target && routing.strategy) {
 			const report = await raceUsageWithSignal(
 				this.#getUsageReport(provider, target.credential, options),
 				options?.signal,

package/src/dialect/deepseek.ts

@@ -34,6 +34,10 @@ const DSML_TOOL_CALLS_OPEN_FULLWIDTH = "<｜DSML｜tool_calls>";
 const DSML_TOOL_CALLS_CLOSE_FULLWIDTH = "</｜DSML｜tool_calls>";
 const DSML_TOOL_CALLS_OPEN_ASCII = "<|DSML|tool_calls>";
 const DSML_TOOL_CALLS_CLOSE_ASCII = "</|DSML|tool_calls>";
+const DSML_INVOKE_CLOSE_FULLWIDTH = "</｜DSML｜invoke>";
+const DSML_INVOKE_CLOSE_ASCII = "</|DSML|invoke>";
+const DSML_PARAMETER_CLOSE_FULLWIDTH = "</｜DSML｜parameter>";
+const DSML_PARAMETER_CLOSE_ASCII = "</|DSML|parameter>";
 
 const CONTROL_TOKENS = [
 	DEEPSEEK_BOS,
@@ -53,6 +57,18 @@ const CONTROL_TOKENS = [
 	DEEPSEEK_TOOL_OUTPUT_END,
 ] as const;
 
+// Bare DSML invoke/parameter close tags with no matching open — leaked into
+// visible text once a session's history is poisoned (issue #10556). Stripped in
+// the `outside` state so they never reach stored assistant content and reinforce
+// the model's XML-protocol mimicry. Inside a well-formed envelope these closers
+// are consumed by the `dsmlInvoke`/`dsmlParam` states and never reach `outside`.
+const DSML_ORPHAN_CLOSE_TOKENS = [
+	DSML_INVOKE_CLOSE_FULLWIDTH,
+	DSML_INVOKE_CLOSE_ASCII,
+	DSML_PARAMETER_CLOSE_FULLWIDTH,
+	DSML_PARAMETER_CLOSE_ASCII,
+] as const;
+
 const OUTSIDE_TOKENS = [
 	DEEPSEEK_TOOL_CALLS_BEGIN,
 	DEEPSEEK_TOOL_CALLS_END,
@@ -63,6 +79,7 @@ const OUTSIDE_TOKENS = [
 	DSML_TOOL_CALLS_OPEN_ASCII,
 	DSML_TOOL_CALLS_CLOSE_FULLWIDTH,
 	DSML_TOOL_CALLS_CLOSE_ASCII,
+	...DSML_ORPHAN_CLOSE_TOKENS,
 	...CONTROL_TOKENS,
 ] as const;
 
@@ -73,8 +90,13 @@ const DSML_SECTION_TOKENS = [
 	"<｜DSML｜invoke",
 	"<|DSML|invoke",
 ] as const;
-const DSML_INVOKE_TOKENS = ["</｜DSML｜invoke>", "</|DSML|invoke>", "<｜DSML｜parameter", "<|DSML|parameter"] as const;
-const DSML_PARAMETER_CLOSE_TOKENS = ["</｜DSML｜parameter>", "</|DSML|parameter>"] as const;
+const DSML_INVOKE_TOKENS = [
+	DSML_INVOKE_CLOSE_FULLWIDTH,
+	DSML_INVOKE_CLOSE_ASCII,
+	"<｜DSML｜parameter",
+	"<|DSML|parameter",
+] as const;
+const DSML_PARAMETER_CLOSE_TOKENS = [DSML_PARAMETER_CLOSE_FULLWIDTH, DSML_PARAMETER_CLOSE_ASCII] as const;
 
 type State =
 	| "outside"
@@ -216,6 +238,11 @@ export class DeepSeekInbandScanner implements InbandScanner {
 				this.#state = "dsmlSection";
 				return;
 			}
+			const orphanClose = this.#matchingOrphanDsmlClose();
+			if (orphanClose) {
+				this.#buffer = this.#buffer.slice(orphanClose.length);
+				continue;
+			}
 			const control = this.#matchingControlToken();
 			if (control) {
 				this.#buffer = this.#buffer.slice(control.length);
@@ -478,6 +505,13 @@ export class DeepSeekInbandScanner implements InbandScanner {
 		return "";
 	}
 
+	#matchingOrphanDsmlClose(): string | undefined {
+		for (const token of DSML_ORPHAN_CLOSE_TOKENS) {
+			if (this.#buffer.startsWith(token)) return token;
+		}
+		return undefined;
+	}
+
 	#matchingControlToken(): string | undefined {
 		if (this.#buffer.startsWith(DEEPSEEK_TOOL_CALLS_END)) return DEEPSEEK_TOOL_CALLS_END;
 		if (this.#buffer.startsWith(THINK_CLOSE)) return THINK_CLOSE;

package/src/providers/anthropic.ts

@@ -199,7 +199,6 @@ function resolveAnthropicControlBetas(
 ): string[] {
 	const betas: string[] = [];
 	if (prefixMismatchBehavior) betas.push(THINKING_BINDING_CONTROLS_BETA);
-	if (model.compat.supportsMidConversationSystem) betas.push(midConversationSystemBeta);
 	if (model.compat.supportsTurnScopedSystem) betas.push(midConversationSystemClearAtBeta);
 	if (model.compat.supportsMidConversationToolChanges) betas.push(midConversationToolChangesBeta);
 	if (model.compat.supportsPerMessageEffort) betas.push(midConversationOutputConfigBeta);
@@ -420,22 +419,7 @@ type AnthropicControlTransition = {
 	effort?: AnthropicOutputEffort;
 };
 
-type AnthropicProviderSessionState = ProviderSessionState & {
-	strictToolsDisabled: boolean;
-	fastModeDisabled: boolean;
-	/**
-	 * Runtime-learned: this endpoint returned `400 Invalid signature in
-	 * thinking block` for a replayed unsigned thinking block, so it must be
-	 * treated as a signing proxy from now on. All subsequent requests demote
-	 * unsigned thinking to text for this (baseUrl, modelId), same behavior as
-	 * an explicit `compat.replayUnsignedThinking: false`. Cleared on session
-	 * close.
-	 */
-	replayUnsignedThinkingDisabled: boolean;
-	/** Thinking blocks the API permanently dropped after a prefix mismatch. */
-	prefixDroppedThinkingBlocks: Set<string>;
-	/** Model the control baseline below was captured for; a switch re-baselines. */
-	controlModelId: string | undefined;
+type AnthropicControlState = {
 	/** `tools` declared at baseline plus later `defer_loading` additions, in wire order. */
 	declaredTools: AnthropicWireTool[] | undefined;
 	activeToolNames: Set<string>;
@@ -447,13 +431,25 @@ type AnthropicProviderSessionState = ProviderSessionState & {
 	currentEffort: AnthropicOutputEffort | undefined;
 };
 
-function createAnthropicProviderSessionState(): AnthropicProviderSessionState {
-	const state: AnthropicProviderSessionState = {
-		strictToolsDisabled: false,
-		fastModeDisabled: false,
-		replayUnsignedThinkingDisabled: false,
-		prefixDroppedThinkingBlocks: new Set(),
-		controlModelId: undefined,
+type AnthropicProviderSessionState = ProviderSessionState & {
+	strictToolsDisabled: boolean;
+	fastModeDisabled: boolean;
+	/**
+	 * Runtime-learned: this endpoint rejected a replayed unsigned thinking
+	 * block, so it must be treated as a signing proxy from now on. All
+	 * subsequent requests demote unsigned thinking to text for this (baseUrl,
+	 * modelId), same behavior as an explicit
+	 * `compat.replayUnsignedThinking: false`. Cleared on session close.
+	 */
+	replayUnsignedThinkingDisabled: boolean;
+	/** Thinking blocks the API permanently dropped after a prefix mismatch. */
+	prefixDroppedThinkingBlocks: Set<string>;
+	/** Conversation-scoped control baselines, isolated from side requests and advisors. */
+	controlStates: Map<string, AnthropicControlState>;
+};
+
+function createAnthropicControlState(): AnthropicControlState {
+	return {
 		declaredTools: undefined,
 		activeToolNames: new Set(),
 		stableSystemBlocks: undefined,
@@ -462,13 +458,22 @@ function createAnthropicProviderSessionState(): AnthropicProviderSessionState {
 		baseEffort: undefined,
 		baseEffortWire: undefined,
 		currentEffort: undefined,
+	};
+}
+
+function createAnthropicProviderSessionState(): AnthropicProviderSessionState {
+	const state: AnthropicProviderSessionState = {
+		strictToolsDisabled: false,
+		fastModeDisabled: false,
+		replayUnsignedThinkingDisabled: false,
+		prefixDroppedThinkingBlocks: new Set(),
+		controlStates: new Map(),
 		close: () => {
 			state.strictToolsDisabled = false;
 			state.fastModeDisabled = false;
 			state.replayUnsignedThinkingDisabled = false;
 			state.prefixDroppedThinkingBlocks.clear();
-			state.controlModelId = undefined;
-			resetAnthropicControlState(state);
+			state.controlStates.clear();
 		},
 	};
 	return state;
@@ -496,8 +501,7 @@ function getAnthropicProviderSessionState(
 	const existing = providerSessionState.get(key) as AnthropicProviderSessionState | undefined;
 	if (existing) {
 		existing.prefixDroppedThinkingBlocks ??= new Set();
-		existing.activeToolNames ??= new Set();
-		existing.controlTransitions ??= [];
+		existing.controlStates ??= new Map();
 		return existing;
 	}
 	const created = createAnthropicProviderSessionState();
@@ -1863,11 +1867,20 @@ function calculateFallbackTurnCost(
 }
 
 /**
- * Detects the Anthropic `400 Invalid `signature` in `thinking` block` failure
- * a signing proxy returns when a stripped/unsigned prior thinking block is
- * replayed as `signature: ""`. Exported for the compat tests.
+ * Detects the two shapes a signature-enforcing endpoint uses to reject a
+ * replayed unsigned thinking block (sent as `signature: ""`):
+ *
+ * - Anthropic and Anthropic-fronting proxies: `400 Invalid `signature` in
+ *   `thinking` block`.
+ * - Bedrock-backed proxies: the empty string fails schema validation before
+ *   signature checking, so it comes back as `ValidationException: The model
+ *   returned the following errors: messages.N.content.M.thinking.signature:
+ *   Field required`.
+ *
+ * Exported for the compat tests.
  */
 const INVALID_THINKING_SIGNATURE_PATTERN = /invalid\s+`?signature`?\s+in\s+`?thinking`?(?:\s+block)?/i;
+const MISSING_THINKING_SIGNATURE_PATTERN = /thinking\.signature\b[^"\n]{0,32}\brequired\b/i;
 const THINKING_PREFIX_BINDING_PATTERN =
 	/(?:bound to a different conversation|block_binding\.prefix_mismatch_behavior|prefix_mismatch_behavior)/i;
 
@@ -1877,10 +1890,11 @@ export function isThinkingPrefixBindingError(message: string): boolean {
 }
 
 export function isInvalidThinkingSignatureError(message: string): boolean {
-	return INVALID_THINKING_SIGNATURE_PATTERN.test(message);
+	return INVALID_THINKING_SIGNATURE_PATTERN.test(message) || MISSING_THINKING_SIGNATURE_PATTERN.test(message);
 }
 
 const INPUT_TRANSFORMATION_PATH_PATTERN = /^messages\.(\d+)\.content\.(\d+)$/;
+const PREFIX_BINDING_ERROR_PATH_PATTERN = /messages\.(\d+)\.content\.(\d+)/;
 
 function thinkingReplayKey(block: ContentBlockParam): string | undefined {
 	if (block.type === "thinking") return block.signature ? `thinking:${block.signature}` : undefined;
@@ -1923,6 +1937,31 @@ function rememberPrefixDroppedThinking(
 	}
 }
 
+function rememberPrefixBindingFailure(
+	params: MessageCreateParamsStreaming,
+	message: string,
+	state: AnthropicProviderSessionState | undefined,
+): boolean {
+	if (!state) return false;
+	const match = PREFIX_BINDING_ERROR_PATH_PATTERN.exec(message);
+	let path = match ? `messages.${match[1]}.content.${match[2]}` : undefined;
+	if (!path) {
+		for (let messageIndex = 0; messageIndex < params.messages.length && !path; messageIndex++) {
+			const candidate = params.messages[messageIndex];
+			if (!candidate || !Array.isArray(candidate.content)) continue;
+			const blockIndex = candidate.content.findIndex(block => thinkingReplayKey(block) !== undefined);
+			if (blockIndex >= 0) path = `messages.${messageIndex}.content.${blockIndex}`;
+		}
+	}
+	if (!path) return false;
+	rememberPrefixDroppedThinking(
+		params,
+		[{ type: "thinking_dropped", reason: "prefix_binding_mismatch", path }],
+		state,
+	);
+	return true;
+}
+
 function applyReportedInputTransformations(
 	output: AssistantMessage,
 	params: MessageCreateParamsStreaming,
@@ -1956,8 +1995,8 @@ function applyReportedInputTransformations(
 }
 
 /**
- * Prepend a pointed remediation to Anthropic's `Invalid signature in thinking
- * block` 400 when the model looks like an unmarked custom signing proxy
+ * Prepend a pointed remediation to a thinking-signature rejection 400 when the
+ * model looks like an unmarked custom signing proxy
  * (opaque baseUrl, `spec.reasoning: true`, no explicit
  * `compat.replayUnsignedThinking` override). The default is native replay for
  * the 3p reasoning majority (#2005); this hint turns the misconfigured-proxy
@@ -2028,6 +2067,7 @@ const streamAnthropicOnce = (
 			let dropFastMode = providerSessionState?.fastModeDisabled ?? false;
 			let forceDemoteUnsignedThinking = providerSessionState?.replayUnsignedThinkingDisabled ?? false;
 			let dropAllThinking = false;
+			let prefixBindingRetryAttempted = false;
 			let prefixMismatchBehavior =
 				model.thinking?.prefixBinding && model.compat.supportsThinkingBindingControls
 					? (options?.anthropicPrefixMismatchBehavior ?? "drop_block")
@@ -2935,7 +2975,8 @@ const streamAnthropicOnce = (
 					const streamFailureMessage =
 						streamFailure instanceof Error ? streamFailure.message : String(streamFailure);
 					if (
-						!dropAllThinking &&
+						!prefixBindingRetryAttempted &&
+						options?.anthropicPrefixMismatchBehavior !== "error" &&
 						firstTokenTime === undefined &&
 						!streamedReplayUnsafeContent &&
 						isThinkingPrefixBindingError(streamFailureMessage)
@@ -2945,8 +2986,9 @@ const streamAnthropicOnce = (
 							model: model.id,
 							baseUrl,
 						});
+						prefixBindingRetryAttempted = true;
 						prefixMismatchBehavior = undefined;
-						dropAllThinking = true;
+						dropAllThinking = !rememberPrefixBindingFailure(params, streamFailureMessage, providerSessionState);
 						params = await prepareParams();
 						providerRetryAttempt = 0;
 						output.content.length = 0;
@@ -2968,7 +3010,7 @@ const streamAnthropicOnce = (
 						isInvalidThinkingSignatureError(streamFailureMessage)
 					) {
 						logger.warn(
-							"anthropic: signing proxy detected (Invalid signature in thinking block), demoting unsigned thinking and retrying",
+							"anthropic: signing proxy detected (thinking signature rejected), demoting unsigned thinking and retrying",
 							{
 								provider: model.provider,
 								model: model.id,
@@ -3460,10 +3502,11 @@ function applyPromptCaching(params: MessageCreateParamsStreaming, cacheControl?:
 		trailingMessage.content === "Continue." &&
 		params.messages[trailingIndex - 1]?.role === "assistant";
 	const messageEnd = hasTrailingAssistantPad ? trailingIndex - 1 : trailingIndex;
-	const start = Math.max(0, messageEnd - 1);
-	for (let index = messageEnd; index >= start; index--) {
+	let eligibleMessages = 0;
+	for (let index = messageEnd; index >= 0 && eligibleMessages < 2; index--) {
 		const message = params.messages[index];
-		if (!message) continue;
+		if (!message || message.clear_at === "next_user_message") continue;
+		eligibleMessages++;
 		if (typeof message.content === "string") {
 			message.content = [
 				{ type: "text", text: message.content, cache_control: cloneAnthropicCacheControl(cacheControl) },
@@ -3525,7 +3568,9 @@ function extractClaudeCodeFirstUserMessageText(messages: readonly Message[]): st
 	return "";
 }
 
-function resetAnthropicControlState(state: AnthropicProviderSessionState): void {
+const MAX_ANTHROPIC_CONTROL_STATES = 16;
+
+function resetAnthropicControlState(state: AnthropicControlState): void {
 	state.declaredTools = undefined;
 	state.activeToolNames.clear();
 	state.stableSystemBlocks = undefined;
@@ -3536,10 +3581,51 @@ function resetAnthropicControlState(state: AnthropicProviderSessionState): void
 	state.currentEffort = undefined;
 }
 
+function anthropicControlMessageProjection(message: MessageParam): MessageParam {
+	if (message.role !== "assistant" || !Array.isArray(message.content)) return message;
+	return {
+		...message,
+		content: message.content.filter(block => block.type !== "thinking" && block.type !== "redacted_thinking"),
+	};
+}
+
+function getAnthropicControlState(
+	state: AnthropicProviderSessionState | undefined,
+	sessionId: string | undefined,
+	system: readonly AnthropicSystemBlock[] | undefined,
+	messages: readonly MessageParam[],
+): AnthropicControlState | undefined {
+	if (!state) return undefined;
+	const root = messages[0];
+	const fingerprint = String(
+		Bun.hash(
+			JSON.stringify([
+				sessionId ?? "",
+				system?.map(block => block.text) ?? null,
+				root ? anthropicControlMessageProjection(root) : null,
+			]),
+		),
+	);
+	const existing = state.controlStates.get(fingerprint);
+	if (existing) {
+		state.controlStates.delete(fingerprint);
+		state.controlStates.set(fingerprint, existing);
+		return existing;
+	}
+	const created = createAnthropicControlState();
+	state.controlStates.set(fingerprint, created);
+	if (state.controlStates.size > MAX_ANTHROPIC_CONTROL_STATES) {
+		const oldest = state.controlStates.keys().next().value;
+		if (oldest !== undefined) state.controlStates.delete(oldest);
+	}
+	return created;
+}
+
 /** Fingerprint of the wire message a control transition is attached after. */
 function anthropicControlAnchor(messages: readonly MessageParam[], messageCount: number): string {
 	if (messageCount === 0) return "";
-	return String(Bun.hash(JSON.stringify(messages[messageCount - 1])));
+	const message = messages[messageCount - 1];
+	return message ? String(Bun.hash(JSON.stringify(anthropicControlMessageProjection(message)))) : "";
 }
 
 /**
@@ -3548,16 +3634,7 @@ function anthropicControlAnchor(messages: readonly MessageParam[], messageCount:
  * shrank or was rewritten under a recorded transition (compaction, branch
  * switch, `/clear`). The next request re-baselines from its own payload.
  */
-function syncAnthropicControlState(
-	state: AnthropicProviderSessionState,
-	model: Model<"anthropic-messages">,
-	messages: readonly MessageParam[],
-): void {
-	if (state.controlModelId !== model.id) {
-		state.controlModelId = model.id;
-		resetAnthropicControlState(state);
-		return;
-	}
+function syncAnthropicControlState(state: AnthropicControlState, messages: readonly MessageParam[]): void {
 	for (const transition of state.controlTransitions) {
 		if (
 			transition.messageCount > messages.length ||
@@ -3581,7 +3658,7 @@ function syncAnthropicControlState(
  */
 function planStableAnthropicSystem(
 	current: AnthropicSystemBlock[] | undefined,
-	state: AnthropicProviderSessionState | undefined,
+	state: AnthropicControlState | undefined,
 	enabled: boolean,
 ): AnthropicSystemBlock[] | undefined {
 	if (!state || !enabled) return current;
@@ -3600,11 +3677,16 @@ function planStableAnthropicSystem(
 function anthropicToolDefinitionKey(tool: AnthropicWireTool): string {
 	const stable = { ...tool };
 	delete stable.defer_loading;
+	delete stable.description;
 	return JSON.stringify(stable);
 }
 
+function cloneAnthropicTools(tools: readonly AnthropicWireTool[]): AnthropicWireTool[] {
+	return tools.map(tool => ({ ...tool }));
+}
+
 function recordAnthropicControlTransition(
-	state: AnthropicProviderSessionState,
+	state: AnthropicControlState,
 	messages: readonly MessageParam[],
 	messageCount: number,
 	content: ContentBlockParam[],
@@ -3634,14 +3716,14 @@ function recordAnthropicControlTransition(
 function planStableAnthropicTools(
 	current: AnthropicWireTool[] | undefined,
 	messages: readonly MessageParam[],
-	state: AnthropicProviderSessionState | undefined,
+	state: AnthropicControlState | undefined,
 	enabled: boolean,
 ): AnthropicWireTool[] | undefined {
 	if (!state || !enabled || !current) return current;
 	if (!state.declaredTools) {
-		state.declaredTools = current.map(tool => ({ ...tool }));
+		state.declaredTools = cloneAnthropicTools(current);
 		state.activeToolNames = new Set(current.map(tool => tool.name));
-		return state.declaredTools;
+		return cloneAnthropicTools(state.declaredTools);
 	}
 
 	const declaredByName = new Map(state.declaredTools.map(tool => [tool.name, tool]));
@@ -3649,9 +3731,9 @@ function planStableAnthropicTools(
 		const declared = declaredByName.get(tool.name);
 		if (declared && anthropicToolDefinitionKey(declared) !== anthropicToolDefinitionKey(tool)) {
 			resetAnthropicControlState(state);
-			state.declaredTools = current.map(candidate => ({ ...candidate }));
+			state.declaredTools = cloneAnthropicTools(current);
 			state.activeToolNames = new Set(current.map(candidate => candidate.name));
-			return state.declaredTools;
+			return cloneAnthropicTools(state.declaredTools);
 		}
 	}
 
@@ -3678,7 +3760,7 @@ function planStableAnthropicTools(
 	}
 	if (changes.length > 0) recordAnthropicControlTransition(state, messages, messages.length, changes);
 	state.activeToolNames = nextActive;
-	return state.declaredTools;
+	return cloneAnthropicTools(state.declaredTools);
 }
 
 /**
@@ -3690,7 +3772,7 @@ function planStableAnthropicTools(
 function planStableAnthropicEffort(
 	current: AnthropicOutputEffort | undefined,
 	messages: readonly MessageParam[],
-	state: AnthropicProviderSessionState | undefined,
+	state: AnthropicControlState | undefined,
 	enabled: boolean,
 ): AnthropicOutputEffort | undefined {
 	if (!state || !enabled) return current;
@@ -3712,7 +3794,7 @@ function planStableAnthropicEffort(
 
 function materializeAnthropicControlTransitions(
 	messages: MessageParam[],
-	state: AnthropicProviderSessionState | undefined,
+	state: AnthropicControlState | undefined,
 ): MessageParam[] {
 	if (!state || state.controlTransitions.length === 0) return messages;
 	const result = messages.slice();
@@ -3736,7 +3818,7 @@ function materializeAnthropicControlTransitions(
 		}
 		result.splice(index, 0, {
 			role: "system",
-			content: transition.content,
+			content: transition.content.map(block => ({ ...block })),
 			...(transition.effort === undefined ? {} : { output_config: { effort: transition.effort } }),
 		});
 		offset++;
@@ -3906,25 +3988,17 @@ function buildParams(
 		dropAllThinking,
 		droppedThinkingBlocks,
 	});
-	if (providerSessionState) syncAnthropicControlState(providerSessionState, model, wireMessages);
-	systemBlocks = planStableAnthropicSystem(
-		systemBlocks,
-		providerSessionState,
-		model.compat.supportsMidConversationSystem,
-	);
-	tools = planStableAnthropicTools(
-		tools,
-		wireMessages,
-		providerSessionState,
-		model.compat.supportsMidConversationToolChanges,
-	);
+	const controlState = getAnthropicControlState(providerSessionState, options?.sessionId, systemBlocks, wireMessages);
+	if (controlState) syncAnthropicControlState(controlState, wireMessages);
+	systemBlocks = planStableAnthropicSystem(systemBlocks, controlState, model.compat.supportsMidConversationSystem);
+	tools = planStableAnthropicTools(tools, wireMessages, controlState, model.compat.supportsMidConversationToolChanges);
 	const topLevelEffort = planStableAnthropicEffort(
 		outputConfigEffort,
 		wireMessages,
-		providerSessionState,
+		controlState,
 		model.compat.supportsPerMessageEffort,
 	);
-	wireMessages = materializeAnthropicControlTransitions(wireMessages, providerSessionState);
+	wireMessages = materializeAnthropicControlTransitions(wireMessages, controlState);
 
 	const outputConfigEntries: AnthropicOutputConfig = {};
 	if (topLevelEffort && model.compat.supportsOutputEffort) outputConfigEntries.effort = topLevelEffort;
@@ -4303,7 +4377,7 @@ export function convertAnthropicMessages(
 			for (const block of blocks) {
 				if (block.type === "tool_use") {
 					sawToolUse = true;
-				} else if (sawToolUse) {
+				} else if (sawToolUse && block.type !== "thinking" && block.type !== "redacted_thinking") {
 					needsPartition = true;
 					break;
 				}
@@ -4366,7 +4440,7 @@ export function convertAnthropicMessages(
 	// covers both the "followed by assistant / last" and "no consecutive system"
 	// constraints. Anything that does not qualify stays a `user` message.
 	if (developerParams.length > 0 && model.compat.supportsMidConversationSystem) {
-		for (const developer of developerParams) {
+		for (const developer of developerParams.toReversed()) {
 			const idx = developer.index;
 			const followsUser = idx > 0 && params[idx - 1]?.role === "user";
 			const next = params[idx + 1];
@@ -4378,18 +4452,35 @@ export function convertAnthropicMessages(
 					block => block.type === "text" || block.type === "tool_addition" || block.type === "tool_removal",
 				);
 			const effortOnly = developer.payload?.effort !== undefined && Array.isArray(content) && content.length === 0;
-			if ((followsUser && lastOrBeforeAssistant && systemCompatible) || effortOnly) {
-				params[idx] = {
-					role: "system",
-					content,
-					...(developer.payload?.clearAt !== undefined && model.compat.supportsTurnScopedSystem
-						? { clear_at: developer.payload.clearAt }
-						: {}),
-					...(developer.payload?.effort !== undefined && model.compat.supportsPerMessageEffort
-						? { output_config: { effort: developer.payload.effort } }
-						: {}),
-				};
+			if (!((followsUser && lastOrBeforeAssistant && systemCompatible) || effortOnly)) continue;
+
+			const turnScoped = developer.payload?.clearAt === "next_user_message" && model.compat.supportsTurnScopedSystem;
+			const hasEffort = developer.payload?.effort !== undefined && model.compat.supportsPerMessageEffort;
+			const hasToolChanges = (developer.payload?.toolChanges?.length ?? 0) > 0;
+			if (turnScoped && (hasEffort || hasToolChanges) && Array.isArray(content)) {
+				const scopedContent = content.filter(block => block.type === "text");
+				const controlContent = content.filter(block => block.type !== "text");
+				if (scopedContent.length > 0) {
+					params[idx] = {
+						role: "system",
+						content: scopedContent,
+						clear_at: "next_user_message",
+					};
+					params.splice(idx + 1, 0, {
+						role: "system",
+						content: controlContent,
+						...(hasEffort ? { output_config: { effort: developer.payload?.effort } } : {}),
+					});
+					continue;
+				}
 			}
+
+			params[idx] = {
+				role: "system",
+				content,
+				...(turnScoped && !hasEffort && !hasToolChanges ? { clear_at: "next_user_message" } : {}),
+				...(hasEffort ? { output_config: { effort: developer.payload?.effort } } : {}),
+			};
 		}
 	}
 	// Dropped empty user/developer turns can leave two assistant params adjacent;

package/src/providers/cursor.ts

@@ -702,7 +702,10 @@ function streamCursorWithWireMode(
 			const { requestBytes, conversationState } = builtRequest;
 			serializedFallbackWireModelId = builtRequest.fallbackWireModelId;
 			conversationStateCache.set(conversationId, conversationState);
-			const requestContextTools = buildMcpToolDefinitions(context.tools);
+			const requestContextTools = buildMcpToolDefinitions(
+				context.tools,
+				model.requiresCursorToolSchemaProjection === true,
+			);
 			const requestContextRules = buildCursorRequestContextRules(context.systemPrompt);
 
 			const baseUrl = model.baseUrl || CURSOR_API_URL;
@@ -4612,7 +4615,10 @@ function isJsonValue(value: unknown): value is JsonValue {
 	return true;
 }
 
-export function buildMcpToolDefinitions(tools: Tool[] | undefined): McpToolDefinition[] {
+export function buildMcpToolDefinitions(
+	tools: Tool[] | undefined,
+	requiresCursorToolSchemaProjection = false,
+): McpToolDefinition[] {
 	if (!tools || tools.length === 0) {
 		return [];
 	}
@@ -4632,7 +4638,8 @@ export function buildMcpToolDefinitions(tools: Tool[] | undefined): McpToolDefin
 	const forwarded = writeTool ? [...advertisedTools, writeTool] : advertisedTools;
 
 	return forwarded.map(tool => {
-		const jsonSchema = sanitizeSchemaForCursor(toolWireSchema(tool));
+		const wireSchema = toolWireSchema(tool);
+		const jsonSchema = requiresCursorToolSchemaProjection ? sanitizeSchemaForCursor(wireSchema) : wireSchema;
 		const schemaValue: JsonValue =
 			jsonSchema !== null && !Array.isArray(jsonSchema) && isJsonValue(jsonSchema)
 				? jsonSchema

package/src/providers/google-shared.ts

@@ -244,6 +244,13 @@ export function convertMessages<T extends GoogleApiType>(model: Model<T>, contex
 					}
 				} else if (block.type === "toolCall") {
 					emittedToolCallNames.set(block.id, block.name);
+					// Gemini 3 requires a thought signature on function calls it makes. For
+					// calls we cannot sign (cross-model replay, secret-redacted args, or the
+					// secondary calls of a parallel turn), the public Gemini API accepts the
+					// `skip_thought_signature_validator` sentinel as a bypass. Cloud Code
+					// Assist / Antigravity and Vertex AI reject that sentinel with 400
+					// INVALID_ARGUMENT — permanently wedging any session whose history
+					// contains one — so for those transports we omit the field instead. (#9638)
 					const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thoughtSignature);
 					const effectiveSignature =
 						thoughtSignature || (model.compat.requiresSkipThoughtSignature ? SKIP_THOUGHT_SIGNATURE : undefined);

package/src/utils/tool-call-loop-guard.ts

@@ -79,29 +79,39 @@ export class ToolCallLoopGuard {
 	/** Records one completed turn and returns the threshold hit, if any. */
 	recordTurn(turn: ToolCallLoopTurn): RepeatedToolCallDetection | null {
 		const toolCalls = turn.message.content.filter((part): part is ToolCall => part.type === "toolCall");
-		if (toolCalls.length !== 1 || this.#exemptTools.has(toolCalls[0]!.name)) {
+		if (toolCalls.length === 0) {
+			this.#lastHash = undefined;
+			this.#count = 0;
+			return null;
+		}
+		if (toolCalls.every(tc => this.#exemptTools.has(tc.name))) {
 			this.#lastHash = undefined;
 			this.#count = 0;
 			return null;
 		}
 
-		const toolCall = toolCalls[0]!;
-		const canonicalArgs = JSON.stringify(canonicalizeToolCallValue(toolCall.arguments));
-		const hash = `${toolCall.name}:${canonicalArgs}`;
-		if (hash === this.#lastHash) {
+		const canonicalCalls = toolCalls
+			.map(tc => JSON.stringify([tc.name, canonicalizeToolCallValue(tc.arguments)]))
+			.sort();
+		const turnHash = JSON.stringify(canonicalCalls);
+		if (turnHash === this.#lastHash) {
 			this.#count++;
 		} else {
-			this.#lastHash = hash;
+			this.#lastHash = turnHash;
 			this.#count = 1;
 		}
 
 		if (this.#count !== this.#threshold) return null;
+		const reportCall = toolCalls.find(tc => !this.#exemptTools.has(tc.name)) ?? toolCalls[0]!;
 		return {
 			kind: "repeated_tool_call",
-			toolName: toolCall.name,
+			toolName: reportCall.name,
 			count: this.#count,
-			resultSummary: summarizeToolResult(turn.toolResults, toolCall.id),
-			argumentsSummary: summarizeText(canonicalArgs, ARGUMENT_SUMMARY_LIMIT),
+			resultSummary: summarizeToolResult(turn.toolResults, reportCall.id),
+			argumentsSummary: summarizeText(
+				JSON.stringify(canonicalizeToolCallValue(reportCall.arguments)),
+				ARGUMENT_SUMMARY_LIMIT,
+			),
 		};
 	}
 }