@oh-my-pi/pi-ai 18.12.2 → 18.12.3

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [18.12.3] - 2026-10-19
+
+### Added
+
+- Added `validateToolArguments(tool, call, { keepUnknownRootKeys: true })` to keep unknown root keys that a closed schema would otherwise drop during argument repair ([#16317](https://github.com/can1357/oh-my-pi/issues/16317))
+
+### Fixed
+
+- Fixed Claude streams that a gateway cut off before `message_delta` failing the turn instead of being retried ([#16341](https://github.com/can1357/oh-my-pi/pull/16341) by [@lz-lunzi](https://github.com/lz-lunzi))
+- Fixed Gemini pairing parallel same-name tool results with the wrong call when history stores them out of call order (sessions from before 18.4.2, SDK-built contexts) ([#16259](https://github.com/can1357/oh-my-pi/pull/16259) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed Factory Droid Gemini dropping calls to tools with names over 64 characters (most MCP tools) and their results from later requests, so the model called the tool again; such names now shorten to 64 characters ([#16283](https://github.com/can1357/oh-my-pi/pull/16283) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed Factory Droid Gemini requests failing with 400 "For schema with items, schema type should be ARRAY" when a tool parameter accepts a string or a list, as the default `task` tool's `model` field does ([#16249](https://github.com/can1357/oh-my-pi/pull/16249) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed `PI_REQ_DEBUG=1` request dumps writing your API key, bearer token and response cookies to disk in plain text: credential headers now read `[redacted]`, as in rejected-request dumps ([#16293](https://github.com/can1357/oh-my-pi/pull/16293) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed finalized signed reasoning disappearing from displayed thinking when no deltas streamed ([#16227](https://github.com/can1357/oh-my-pi/issues/16227))
+
 ## [18.12.2] - 2026-10-18
 
 ### Added
@@ -2332,26 +2347,4 @@
 - Fixed OpenAI Responses native history replay leaking image generation provider-only fields into the next request, which made OpenAI-compatible proxies reject `pi` tool-calling sessions with `Unknown parameter: input[1].action`. ([#3201](https://github.com/can1357/oh-my-pi/issues/3201))
 - Fixed a stream thought-leakage issue for `gemini-3.5-flash` where the model's internal reasoning JSON could leak into the visible text stream. The stream parser now uses a brace-balanced counting algorithm to accurately slice and discard the leading thought JSON block, with a robust fallback for unescaped double quotes, dynamic tool-name derivation, and preservation of subsequent text deltas without triggering empty-response retries.
 
-## [16.1.10] - 2026-06-21
-
-### Changed
-
-- Improved JSON robustness by replacing external dependency with a custom, high-performance parser
-- Strengthened streaming JSON parsing to prevent non-finite numbers from surfacing as `undefined/NaN`
-- Configured JSON parser to reject JS-specific `NaN` and `Infinity` values for tool arguments
-- Replaced the JSON repair/parse helpers (`parseJsonWithRepair`, `parseStreamingJson`) with a single from-scratch tolerant parser (`RelaxedJson`) that accepts single-quoted strings, unquoted object keys, trailing/stray commas, `//` and `/* */` comments, Python `True`/`False`/`None`, raw control characters, invalid escapes, and unescaped apostrophes (`'it's'`). Final parsing still throws on truncated/garbage input (so a malformed tool call is skipped rather than executed with half-formed args) and rejects JS-only `NaN`/`Infinity`; streaming parsing stays non-throwing and rolls back incomplete trailing tokens instead of surfacing `undefined`/`NaN`. The Cursor provider's ad-hoc regex + JSON5 tool-argument parser now routes through the shared parser.
-
-### Fixed
-
-- Fixed tool call ID normalization for Anthropic-compatible models
-- Fixed Anthropic Messages replay sanitizing malformed tool-call IDs, including aborted native tool calls with empty IDs, so retries no longer send invalid `tool_use.id` / `tool_result.tool_use_id` pairs.
-- Fixed the Codex Responses WebSocket transport attributing a prior turn's output to the current one on a reused connection: a trailing/duplicate frame from a cleanly-completed previous response that slipped past the queue drain could be consumed as this request's terminal (ending the turn with empty output) or as a stale tool call. Frames are now keyed by `response.id` — a frame carrying the previous response's id is dropped, and one carrying a third id (or a regressed `sequence_number`) fails closed so the turn retries instead of mixing two responses' streams. Idless frames (deltas, the rate-limit/metadata preamble, `response.created`-less streams) still pass through, matching upstream codex-rs.
-- Fixed `transformMessages` pulling an earlier, orphaned tool result onto a later tool call that reused the same id (left behind when compaction folded the originating `tool_use` into a summary). The pending-call flush now pairs each call with a result positioned _after_ its assistant turn, so a reused id surfaces its own output rather than a prior turn's.
-- Fixed DashScope 429 rate-limit messages that mention authorization being classified as credential failures, preventing valid API keys from being invalidated after throttling. ([#3172](https://github.com/can1357/oh-my-pi/issues/3172))
-- Fixed OpenCode Go `401 Insufficient balance` quota errors being treated as unknown failures instead of usage-limit errors, restoring credential rotation and fallback chains. ([#3169](https://github.com/can1357/oh-my-pi/issues/3169))
-
-### Removed
-
-- Removed the `partial-json` dependency; streaming JSON parsing now uses the in-house `RelaxedJson` parser.
-
-Older entries are archived in [packages/ai/CHANGELOG.md@bb602d67c9b6](https://github.com/can1357/oh-my-pi/blob/bb602d67c9b685535bbf8ef1a1cc9de3c944ede4/packages/ai/CHANGELOG.md).
+Older entries are archived in [packages/ai/CHANGELOG.md@5eb78e90fa4e](https://github.com/can1357/oh-my-pi/blob/5eb78e90fa4ec4318b9520302f1977fa58c48745/packages/ai/CHANGELOG.md).

package/dist/types/providers/google-shared.d.ts

@@ -76,6 +76,23 @@ export declare function isThinkingPart(part: Pick<Part, "thought" | "thoughtSign
  */
 export declare function retainThoughtSignature(existing: string | undefined, incoming: string | undefined): string | undefined;
 export declare const SKIP_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
+/**
+ * Gemini pairs id-less function responses with calls by position. The agent loop stores
+ * parallel results in call order, but histories can still arrive out of call order (sessions
+ * saved by older versions, contexts built through the SDK), so the converters guard the wire:
+ * record each call as it is emitted and each response with its call, then {@link apply} sorts
+ * every turn's matched responses back into call order within the slots they already occupy.
+ */
+export declare class FunctionCallOrder {
+    #private;
+    call(id: string): void;
+    /** The call ordinal of `id`, if that call was recorded. */
+    ordinal(id: string): number | undefined;
+    response(part: Part, callId: string): void;
+    apply(contents: readonly {
+        parts?: Part[];
+    }[]): void;
+}
 /**
  * Convert internal messages to Gemini Content[] format.
  */

package/dist/types/utils/http-inspector.d.ts

@@ -85,3 +85,5 @@ export declare function rewriteCopilotError(errorMessage: string, error: unknown
  *        credential rotation (sibling keys fail identically).
  */
 export declare function rewriteClinePassError(errorMessage: string, provider: string): string;
+/** Copy of `headers` with every credential value replaced by `[redacted]`; shared by every persisted dump. */
+export declare function redactHeaders<T>(headers: Record<string, T> | undefined): Record<string, T | string> | undefined;

package/dist/types/utils/validation.d.ts

@@ -19,10 +19,20 @@ import type { Tool, ToolCall } from "../types.js";
  * @throws Error if tool is not found or validation fails
  */
 export declare function validateToolCall(tools: Tool[], toolCall: ToolCall): ToolCall["arguments"];
+/** Options for {@link validateToolArguments}. */
+export interface ValidateToolArgumentsOptions {
+    /**
+     * Keep unknown root keys on the validated value instead of letting the
+     * unrecognized-key repair delete them from a closed schema. Set for tools
+     * that own their refusal (`lenientArgValidation`), so execute() can reject
+     * fields the model sent rather than run without them.
+     */
+    keepUnknownRootKeys?: boolean;
+}
 /**
  * Validates tool call arguments against an ArkType or plain JSON Schema schema.
  * Applies conservative LLM-quirk normalization before declaring failure.
  *
  * @throws Error with a formatted message when validation cannot be reconciled.
  */
-export declare function validateToolArguments(tool: Tool, toolCall: ToolCall): ToolCall["arguments"];
+export declare function validateToolArguments(tool: Tool, toolCall: ToolCall, options?: ValidateToolArgumentsOptions): ToolCall["arguments"];

package/package.json

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

package/src/error/flags.ts

@@ -167,7 +167,7 @@ function matchesPayloadRejectionText(text: string): boolean {
 
 const TIMEOUT_PATTERN = /\b(?:operation\s+)?timed?\s*out\b|\btimeout\b|\bstream stall\b/i;
 const TRANSIENT_ENVELOPE_PATTERN = /anthropic stream envelope error:/i;
-const TRANSIENT_ENVELOPE_TRUNCATION_PATTERN = /before message_(?:start|stop)/i;
+const TRANSIENT_ENVELOPE_TRUNCATION_PATTERN = /before message_(?:start|delta|stop)/i;
 export const STREAM_READ_ERROR_PATTERN = /stream[_ -]?read[_ -]?error/i;
 /** Python h2/httpx diagnostics forwarded through provider or proxy error events. */
 export const PYTHON_HTTP2_STREAM_RESET_PATTERN = /<StreamReset stream_id:\d+, error_code:(?:2|7), remote_reset:True>/;
@@ -1103,7 +1103,7 @@ export function isTransientStreamParseError(error: unknown): boolean {
  * non-terminal status treat it as transient (#11805).
  */
 const STREAM_DROP_PATTERN =
-	/stream disconnected before completion|(?:stream|websocket) closed before response\.completed|stream was interrupted|stream ended before terminal (?:chunk|completion event)|socket disconnected before secure tls connection/i;
+	/stream disconnected before completion|(?:stream|websocket) closed before response\.completed|stream was interrupted|stream ended before (?:terminal (?:chunk|completion event)|message_(?:start|delta|stop))|socket disconnected before secure tls connection/i;
 
 /**
  * Transport stream-drop diagnostic (see {@link STREAM_DROP_PATTERN}). Unlike

package/src/providers/factory-droid/gemini.ts

@@ -15,6 +15,7 @@ import { notifyProviderResponse } from "../../utils/provider-response";
 import { dereferenceJsonSchema, normalizeSchemaForFactoryDroid, toolWireSchema } from "../../utils/schema";
 import {
 	extractGoogleErrorMessage,
+	FunctionCallOrder,
 	googleStreamChunkError,
 	GoogleTextBlocks,
 	mapGoogleUsage,
@@ -41,14 +42,15 @@ function geminiThinkingLevel(effort: string | undefined, supportsMedium: boolean
 }
 
 /**
- * The CLI sanitizes tool names to `[a-zA-Z0-9_-]`; names longer than 64 chars
- * are truncated and suffixed with `_` + an 8-char sha256. Applied to
- * declarations and replayed functionCall/functionResponse names.
+ * The CLI sanitizes tool names to `[a-zA-Z0-9_-]`; a name longer than 64
+ * chars keeps its first 55 and ends `_` + an 8-char sha256, 64 in all, which
+ * stays inside the route's tool-name bound. Applied to declarations and
+ * replayed functionCall/functionResponse names.
  */
 function sanitizeFactoryDroidToolName(name: string): string {
 	const sanitized = name.replace(/[^a-zA-Z0-9_-]/g, "_");
 	if (sanitized.length <= 64) return sanitized;
-	return `${sanitized.slice(0, 64)}_${Bun.SHA256.hash(sanitized, "hex").slice(0, 8)}`;
+	return `${sanitized.slice(0, 55)}_${Bun.SHA256.hash(sanitized, "hex").slice(0, 8)}`;
 }
 
 /**
@@ -167,7 +169,9 @@ function adoptFactoryReplay(message: Message, model: Model<"factory-droid-agent"
  *   text carries the signature Gemini put on it.
  * - Tool calls replay as `functionCall` parts carrying their
  *   `thoughtSignature`; consecutive tool results group into ONE user content,
- *   because the proxy 400s when a call turn's response part count mismatches.
+ *   because the proxy 400s when a call turn's response part count mismatches,
+ *   and sort back into call order, because Gemini pairs id-less responses by
+ *   position.
  * - Tool names are sanitized to the CLI's `[a-zA-Z0-9_-]` shape on
  *   declarations and on replayed call/response names.
  * - After the latest user turn containing a non-response part, function calls
@@ -182,6 +186,7 @@ function toGeminiContents(
 	systemInstruction?: { parts: Part[] };
 } {
 	const contents: Array<{ role: "user" | "model"; parts: Part[] }> = [];
+	const callOrder = new FunctionCallOrder();
 	const messages = transformMessages(
 		context.messages.map(message => adoptFactoryReplay(message, model)),
 		model,
@@ -209,6 +214,7 @@ function toGeminiContents(
 				} else if (block.type === "thinking" && block.thinkingSignature) {
 					parts.push({ text: block.thinking, thoughtSignature: block.thinkingSignature });
 				} else if (block.type === "toolCall") {
+					callOrder.call(block.id);
 					parts.push({
 						functionCall: { name: block.name, args: block.arguments },
 						...(block.thoughtSignature ? { thoughtSignature: block.thoughtSignature } : {}),
@@ -239,6 +245,7 @@ function toGeminiContents(
 				...(binaryParts.length > 0 ? { parts: binaryParts } : {}),
 			},
 		};
+		callOrder.response(part, message.toolCallId);
 		const last = contents[contents.length - 1];
 		if (last && last.role === "user" && last.parts.every(p => p.functionResponse)) {
 			last.parts.push(part);
@@ -246,6 +253,7 @@ function toGeminiContents(
 			contents.push({ role: "user", parts: [part] });
 		}
 	}
+	callOrder.apply(contents);
 	// Sentinel injection: scope to model turns at/after the latest user turn
 	// with a non-response part (the validator only checks the current tail).
 	let lastUserText = 0;

package/src/providers/google-shared.ts

@@ -155,24 +155,73 @@ function resolveThoughtSignature(isSameProviderAndModel: boolean, signature: str
 	return isSameProviderAndModel && isValidThoughtSignature(signature) ? signature : undefined;
 }
 
+/** Sort the items whose key is known into key order within the slots they occupy; others stay put. */
+function sortKnownInPlace<T>(items: T[], keyOf: (item: T) => number | undefined): void {
+	const known: Array<{ position: number; key: number; item: T }> = [];
+	items.forEach((item, position) => {
+		const key = keyOf(item);
+		if (key !== undefined) known.push({ position, key, item });
+	});
+	if (known.length < 2) return;
+	const inOrder = [...known].sort((a, b) => a.key - b.key);
+	known.forEach(({ position }, index) => {
+		items[position] = inOrder[index].item;
+	});
+}
+
+/**
+ * Gemini pairs id-less function responses with calls by position. The agent loop stores
+ * parallel results in call order, but histories can still arrive out of call order (sessions
+ * saved by older versions, contexts built through the SDK), so the converters guard the wire:
+ * record each call as it is emitted and each response with its call, then {@link apply} sorts
+ * every turn's matched responses back into call order within the slots they already occupy.
+ */
+export class FunctionCallOrder {
+	#ordinals = new Map<string, number>();
+	#responses = new Map<Part, number>();
+	#next = 0;
+
+	call(id: string): void {
+		this.#ordinals.set(id, this.#next++);
+	}
+
+	/** The call ordinal of `id`, if that call was recorded. */
+	ordinal(id: string): number | undefined {
+		return this.#ordinals.get(id);
+	}
+
+	response(part: Part, callId: string): void {
+		const ordinal = this.#ordinals.get(callId);
+		if (ordinal !== undefined) this.#responses.set(part, ordinal);
+	}
+
+	apply(contents: readonly { parts?: Part[] }[]): void {
+		for (const content of contents) {
+			if (content.parts) sortKnownInPlace(content.parts, part => this.#responses.get(part));
+		}
+	}
+}
+
 /**
  * Convert internal messages to Gemini Content[] format.
  */
 export function convertMessages<T extends GoogleApiType>(model: Model<T>, context: Context): Content[] {
 	const contents: Content[] = [];
 	const emittedToolCallNames = new Map<string, string>();
+	const callOrder = new FunctionCallOrder();
 
 	const transformedMessages = transformMessages(context.messages, model, id => normalizeToolCallId(id));
 
 	// Gemini < 3 image tool results go in a separate user turn, but parallel tool results must
 	// stay a single contiguous functionResponse turn ("number of function response parts is not
 	// equal to number of function call parts"). Buffer image turns and flush them only after the
-	// merged functionResponse turn is complete.
-	let pendingToolImageParts: Part[] = [];
+	// merged functionResponse turn is complete, each result's images in its call's order.
+	let pendingToolImages: Array<{ ordinal: number | undefined; parts: Part[] }> = [];
 	const flushPendingToolImages = () => {
-		if (pendingToolImageParts.length === 0) return;
-		contents.push({ role: "user", parts: pendingToolImageParts });
-		pendingToolImageParts = [];
+		if (pendingToolImages.length === 0) return;
+		sortKnownInPlace(pendingToolImages, group => group.ordinal);
+		contents.push({ role: "user", parts: pendingToolImages.flatMap(group => group.parts) });
+		pendingToolImages = [];
 	};
 
 	for (const msg of transformedMessages) {
@@ -246,6 +295,7 @@ export function convertMessages<T extends GoogleApiType>(model: Model<T>, contex
 					}
 				} else if (block.type === "toolCall") {
 					emittedToolCallNames.set(block.id, block.name);
+					callOrder.call(block.id);
 					// Gemini 3 requires a thought signature on function calls it makes. The
 					// public API requires the bypass sentinel on every unsigned call. Cloud
 					// Code Assist requires it only when the first call itself is unsigned;
@@ -314,6 +364,7 @@ export function convertMessages<T extends GoogleApiType>(model: Model<T>, contex
 					...(includeId ? { id: msg.toolCallId } : {}),
 				},
 			};
+			callOrder.response(functionResponsePart, msg.toolCallId);
 
 			// Cloud Code Assist API requires all function responses to be in a single user turn.
 			// Check if the last content is already a user turn with function responses and merge.
@@ -329,11 +380,15 @@ export function convertMessages<T extends GoogleApiType>(model: Model<T>, contex
 
 			// For Gemini < 3, buffer images for a separate user message after the functionResponse turn
 			if (hasImages && !modelSupportsMultimodalFunctionResponse) {
-				pendingToolImageParts.push({ text: "Tool result image:" }, ...imageParts);
+				pendingToolImages.push({
+					ordinal: callOrder.ordinal(msg.toolCallId),
+					parts: [{ text: "Tool result image:" }, ...imageParts],
+				});
 			}
 		}
 	}
 	flushPendingToolImages();
+	callOrder.apply(contents);
 
 	return contents;
 }

package/src/utils/http-inspector.ts

@@ -268,12 +268,13 @@ function redactUrlQuery(url: string | undefined): string | undefined {
 	}
 }
 
-function redactHeaders(headers: Record<string, string> | undefined): Record<string, string> | undefined {
+/** Copy of `headers` with every credential value replaced by `[redacted]`; shared by every persisted dump. */
+export function redactHeaders<T>(headers: Record<string, T> | undefined): Record<string, T | string> | undefined {
 	if (!headers) {
 		return undefined;
 	}
 
-	const redacted: Record<string, string> = {};
+	const redacted: Record<string, T | string> = {};
 	for (const [key, value] of Object.entries(headers)) {
 		if (SENSITIVE_HEADER_PATTERN.test(key)) {
 			redacted[key] = "[redacted]";

package/src/utils/leaked-thinking-stream.ts

@@ -256,9 +256,10 @@ class LeakedThinkingProjector {
 	thinkingEnd(srcIndex: number, source: ThinkingContent | undefined): void {
 		const index = this.#thinkingBlocks.get(srcIndex);
 		if (index === undefined) {
-			if (source?.thinkingSignature) this.#projectSignedThinking(srcIndex, "", source);
+			if (source?.thinkingSignature) this.#projectSignedThinking(srcIndex, source);
 			return;
 		}
+		this.#appendThinkingTail(index, source);
 		adoptThinkingState(this.#partial.content[index] as ThinkingContent, source);
 		if (!this.#pendingThinkingEnds.delete(index)) return;
 		if (this.#thinking?.index === index) this.#thinking = undefined;
@@ -271,20 +272,31 @@ class LeakedThinkingProjector {
 	 * semantics as {@link toolStart}) so block order survives for replay —
 	 * the signature item must precede the function call it signs.
 	 */
-	#projectSignedThinking(srcIndex: number, thinking: string, source: ThinkingContent): void {
+	#projectSignedThinking(srcIndex: number, source: ThinkingContent): void {
 		this.#flushHealer();
 		this.#closeText();
 		this.#closeThinking();
-		const block: ThinkingContent = { type: "thinking", thinking };
+		const block: ThinkingContent = { type: "thinking", thinking: "" };
 		adoptThinkingState(block, source);
 		this.#partial.content.push(block);
 		const index = this.#partial.content.length - 1;
 		this.#anchor(index, srcIndex);
 		this.#thinkingBlocks.set(srcIndex, index);
 		this.#out.push({ type: "thinking_start", contentIndex: index, partial: this.#partial });
+		this.#appendThinkingTail(index, source);
 		this.#emitThinkingEnd(index);
 	}
 
+	/** Emit only finalized native thinking that did not arrive as deltas. */
+	#appendThinkingTail(index: number, source: ThinkingContent | undefined): void {
+		const block = this.#partial.content[index] as ThinkingContent;
+		if (!source || source.thinking.length <= block.thinking.length || !source.thinking.startsWith(block.thinking))
+			return;
+		const delta = source.thinking.slice(block.thinking.length);
+		block.thinking += delta;
+		this.#out.push({ type: "thinking_delta", contentIndex: index, delta, partial: this.#partial });
+	}
+
 	/** Forward a completed native image after releasing held text. */
 	image(srcIndex: number, content: ImageContent): void {
 		this.#flushHealer();
@@ -380,7 +392,7 @@ class LeakedThinkingProjector {
 			const block = message.content[srcIndex];
 			if (block?.type !== "thinking" || !block.thinkingSignature) continue;
 			if (this.#thinkingBlocks.has(srcIndex)) continue;
-			this.#projectSignedThinking(srcIndex, block.thinking, block);
+			this.#projectSignedThinking(srcIndex, block);
 		}
 		for (let srcIndex = 0; srcIndex < message.content.length; srcIndex++) {
 			const block = message.content[srcIndex];

package/src/utils/request-debug.ts

@@ -1,5 +1,6 @@
 import { Buffer } from "node:buffer";
 import * as fs from "node:fs/promises";
+import { redactHeaders } from "./http-inspector";
 import { decodeRequestBodyBytes } from "./request-body";
 
 const REQUEST_DEBUG_ENV = "PI_REQ_DEBUG";
@@ -62,7 +63,7 @@ export async function createRequestDebugSession(payload: RequestDebugPayload): P
 		method: payload.method,
 		url: payload.url,
 	};
-	const headers = headersToRecord(payload.headers);
+	const headers = redactHeaders(headersToRecord(payload.headers));
 	if (headers) requestDump.headers = headers;
 	if (payload.body !== undefined) requestDump.body = payload.body;
 	if (payload.bodyText !== undefined) requestDump.bodyText = payload.bodyText;
@@ -303,7 +304,7 @@ function looksLikeJson(text: string): boolean {
 
 function formatResponseHeaderBlock(statusLine: string, headers?: RequestDebugHeaders): string {
 	const lines = [statusLine];
-	const record = headersToRecord(headers);
+	const record = redactHeaders(headersToRecord(headers));
 	if (record) {
 		for (const name in record) {
 			const value = record[name];

package/src/utils/schema/CONSTRAINTS.md

@@ -93,11 +93,18 @@ The droid CLI's gemini wire (`factory-droid/google-generate`) uses an
 ALLOWLIST copier instead of the shared denylist normalizer — it preserves
 `type`/`title`/`description`/`required`/`format`/`minimum`/`maximum`/
 `minLength`/`maxLength`/`pattern`/`minItems`/`maxItems`/`default`/`example`,
-converts `const` to a stringified single-entry `enum`, merges `allOf`
-(branch `required` lists union), collapses `anyOf`/`oneOf` into the parent
-(parent `properties`/`required` kept, branch properties merged in, a branch
-field required only when every non-null branch requires it, a `null` branch
-becomes `nullable: true`), and silently drops
+converts `const` to a stringified single-entry `enum`, merges `allOf` first
+(branch `required` lists union), then handles `anyOf`/`oneOf` by branch types:
+typed non-null branches of different types stay an `anyOf` (a `null` branch
+becomes `nullable: true`; branch `required` names missing from the branch's
+own `properties` are dropped) when the node has only `title`/`description`/
+`default`/`example` beside it, since the proxy 400s on other fields alongside
+`anyOf` and on a `string` carrying `items`. Otherwise the union collapses into
+the parent (parent `properties`/`required` kept, branch properties merged in, a
+branch field required only when every non-null branch requires it, a `null`
+branch becomes `nullable: true`); for different-type branches only those of
+the node's own type merge (none when no branch has it), or those of the first
+branch's type when the node declares none. It silently drops
 everything else. It never adds `propertyOrdering`, never edits descriptions,
 and does not spill stripped keywords. Use `normalizeSchemaForFactoryDroid`
 only in `packages/ai/src/providers/factory-droid/gemini.ts`; the shared

package/src/utils/schema/allowlist.ts

@@ -45,6 +45,16 @@ function dedupe(values: unknown[]): unknown[] {
 	return values.filter((entry, index, array) => array.indexOf(entry) === index);
 }
 
+/** Bound keywords whose conjunction keeps the stricter value. */
+const STRICTER_BOUND: Record<string, (a: number, b: number) => number> = {
+	minimum: Math.max,
+	minLength: Math.max,
+	minItems: Math.max,
+	maximum: Math.min,
+	maxLength: Math.min,
+	maxItems: Math.min,
+};
+
 function mergeFactoryDroidSchemas(left: JsonObject, right: JsonObject, requiredMerge: RequiredMerge): JsonObject {
 	const merged: JsonObject = { ...left };
 	for (const [key, value] of Object.entries(right)) {
@@ -62,8 +72,17 @@ function mergeFactoryDroidSchemas(left: JsonObject, right: JsonObject, requiredM
 			merged.properties = properties;
 		} else if (key === "required") {
 			// Combined below: intersection must also see a missing right-hand `required`.
+		} else if (requiredMerge === "union" && key in STRICTER_BOUND && typeof value === "number") {
+			// Conjunctions keep the tighter of two bounds.
+			const current = merged[key];
+			merged[key] = typeof current === "number" ? STRICTER_BOUND[key](current, value) : value;
 		} else if (key === "enum" && Array.isArray(left.enum) && Array.isArray(value)) {
 			merged.enum = dedupe([...(left.enum as unknown[]), ...(value as unknown[])]);
+		} else if (requiredMerge === "union" && key === "anyOf" && Array.isArray(merged.anyOf) && Array.isArray(value)) {
+			// Two retained unions in one conjunction: keep every pairing of compatible
+			// branches instead of dropping the right-hand constraint.
+			const pairs = intersectUnionBranches(merged.anyOf as JsonObject[], value as JsonObject[]);
+			if (pairs.length > 0) merged.anyOf = pairs;
 		} else if (!(key in merged)) {
 			merged[key] = value;
 		}
@@ -83,6 +102,88 @@ function mergeFactoryDroidSchemas(left: JsonObject, right: JsonObject, requiredM
 	return merged;
 }
 
+/** Branch-wise conjunction of two unions: each same-typed (or untyped) pair merged, enums intersected. */
+function intersectUnionBranches(left: JsonObject[], right: JsonObject[]): JsonObject[] {
+	const pairs: JsonObject[] = [];
+	for (const a of left) {
+		for (const b of right) {
+			if (a.type !== undefined && b.type !== undefined && a.type !== b.type) continue;
+			const pair = mergeFactoryDroidSchemas(a, b, "union");
+			if (Array.isArray(a.enum) && Array.isArray(b.enum)) {
+				// The merge unions enums; a conjunction admits only values both allow.
+				const allowed = (a.enum as unknown[]).filter(value => (b.enum as unknown[]).includes(value));
+				if (allowed.length === 0) continue;
+				pair.enum = allowed;
+			}
+			pairs.push(pair);
+		}
+	}
+	return pairs;
+}
+
+/** Fields the proxy accepts beside `anyOf`; anything else there is a 400. */
+const ANY_OF_SIBLING_KEYS: Record<string, true> = {
+	title: true,
+	description: true,
+	default: true,
+	example: true,
+};
+
+/** The proxy 400s on `required` names a schema's own `properties` lacks. */
+function withoutUndefinedRequired(branch: JsonObject): JsonObject {
+	if (!Array.isArray(branch.required)) return branch;
+	const properties = isJsonObject(branch.properties) ? branch.properties : {};
+	const required = (branch.required as unknown[]).filter(
+		name => typeof name === "string" && Object.hasOwn(properties, name),
+	);
+	const { required: _dropped, ...rest } = branch;
+	return required.length > 0 ? { ...rest, required } : rest;
+}
+
+function settleUnion(out: JsonObject, branches: JsonObject[], nullable: boolean): void {
+	let nonNull = branches;
+	const mixedTypes =
+		nonNull.every(branch => typeof branch.type === "string") && new Set(nonNull.map(branch => branch.type)).size > 1;
+	if (mixedTypes && Object.keys(out).every(key => key in ANY_OF_SIBLING_KEYS)) {
+		out.anyOf = nonNull.map(withoutUndefinedRequired);
+		if (nullable) out.nullable = true;
+		return;
+	}
+	if (mixedTypes) {
+		// `anyOf` must be the only structural field, and branches of
+		// different types never merge into one Schema: keep only the
+		// branches of the node's own type (none if no branch has it),
+		// else of the first branch's type.
+		const ownType = Array.isArray(out.type)
+			? (out.type as unknown[]).find(t => typeof t === "string" && t !== "null")
+			: (out.type ?? (isJsonObject(out.properties) ? "object" : undefined));
+		const kept = ownType ?? nonNull[0].type;
+		nonNull = nonNull.filter(branch => branch.type === kept);
+	} else if (typeof out.type === "string") {
+		// An untyped branch keeps the union from counting as mixed, but a typed branch of another type
+		// still must not lend its fields (`items` on a string) to this node.
+		const compatible = nonNull.filter(branch => branch.type === undefined || branch.type === out.type);
+		if (compatible.length > 0) nonNull = compatible;
+	}
+	let collapsed: JsonObject | undefined;
+	for (const branch of nonNull) {
+		collapsed = collapsed ? mergeFactoryDroidSchemas(collapsed, branch, "intersection") : { ...branch };
+	}
+	if (collapsed) {
+		collapsed.nullable = nullable;
+		Object.assign(out, mergeFactoryDroidSchemas(out, collapsed, "union"));
+		// A pattern cannot be conjoined into one regex the proxy accepts; the union's own,
+		// narrower one wins over one an `allOf` merged in first.
+		if (typeof collapsed.pattern === "string") out.pattern = collapsed.pattern;
+		// Narrowing can drop the branch that defined a required property.
+		if (mixedTypes && Array.isArray(out.required)) {
+			const kept = withoutUndefinedRequired(out);
+			if (kept.required) out.required = kept.required;
+			else delete out.required;
+		}
+	}
+}
+
 function copyFactoryDroidSchema(node: unknown): JsonObject | undefined {
 	if (!isJsonObject(node)) return undefined;
 
@@ -106,32 +207,28 @@ function copyFactoryDroidSchema(node: unknown): JsonObject | undefined {
 		if (copied !== undefined) out.items = copied;
 	}
 
+	// allOf: merge every branch into this node's own copy first, so the union
+	// handling below sees every field that will sit beside it.
+	if (Array.isArray(node.allOf)) {
+		for (const branch of node.allOf) {
+			const copied = copyFactoryDroidSchema(branch);
+			if (copied) Object.assign(out, mergeFactoryDroidSchemas(out, copied, "union"));
+		}
+	}
+
 	// anyOf/oneOf unions: merge the non-null branches (a field stays required
 	// only when every branch requires it), marking the result nullable when a
 	// `type: "null"` branch is present, then fold that into this node so its
-	// own properties/required survive.
+	// own properties/required survive. Typed branches of different types cannot
+	// merge into one Schema (`string` gaining `items` is a 400), so they stay an
+	// `anyOf` when the node has nothing else the proxy forbids beside it.
 	const unionKey = Array.isArray(node.anyOf) ? "anyOf" : Array.isArray(node.oneOf) ? "oneOf" : undefined;
 	if (unionKey) {
 		const branches = (node[unionKey] as unknown[])
 			.map(copyFactoryDroidSchema)
 			.filter((branch): branch is JsonObject => branch !== undefined);
 		const nonNull = branches.filter(branch => !typeIncludesNull(branch));
-		let collapsed: JsonObject | undefined;
-		for (const branch of nonNull) {
-			collapsed = collapsed ? mergeFactoryDroidSchemas(collapsed, branch, "intersection") : { ...branch };
-		}
-		if (collapsed) {
-			collapsed.nullable = nonNull.length < branches.length;
-			Object.assign(out, mergeFactoryDroidSchemas(out, collapsed, "union"));
-		}
-	}
-
-	// allOf: merge every branch into this node's own copy.
-	if (Array.isArray(node.allOf)) {
-		for (const branch of node.allOf) {
-			const copied = copyFactoryDroidSchema(branch);
-			if (copied) Object.assign(out, mergeFactoryDroidSchemas(out, copied, "union"));
-		}
+		settleUnion(out, nonNull, nonNull.length < branches.length);
 	}
 
 	// The Schema proto takes a single string `type`: collapse draft-2020-12
@@ -153,8 +250,37 @@ function copyFactoryDroidSchema(node: unknown): JsonObject | undefined {
 	return out;
 }
 
+/**
+ * A kept `anyOf` can gain structural siblings when an enclosing `allOf`
+ * merges into it (at any depth); settle those against the merged node.
+ */
+function settleMergedUnions(node: JsonObject): void {
+	if (isJsonObject(node.properties)) {
+		for (const schema of Object.values(node.properties)) {
+			if (isJsonObject(schema)) settleMergedUnions(schema);
+		}
+	}
+	if (isJsonObject(node.items)) settleMergedUnions(node.items);
+	if (!Array.isArray(node.anyOf)) return;
+	for (const branch of node.anyOf) {
+		if (isJsonObject(branch)) settleMergedUnions(branch);
+	}
+	// A union left with one branch (an allOf intersection) is that branch.
+	const single = node.anyOf.length === 1;
+	const { anyOf, nullable, ...rest } = node;
+	if (!single && Object.keys(rest).every(key => key in ANY_OF_SIBLING_KEYS)) return;
+	delete node.anyOf;
+	delete node.nullable;
+	settleUnion(node, anyOf as JsonObject[], nullable === true);
+	if (!("type" in node) && isJsonObject(node.properties)) node.type = "object";
+	// The collapse merges branches, which can leave new unions beside fields.
+	settleMergedUnions(node);
+}
+
 /** Project a dereferenced JSON Schema onto Factory Gemini's allowed fields. */
 export function normalizeSchemaForFactoryDroid(value: unknown): unknown {
 	if (!isJsonObject(value)) return value;
-	return copyFactoryDroidSchema(value) ?? {};
+	const out = copyFactoryDroidSchema(value) ?? {};
+	settleMergedUnions(out);
+	return out;
 }

package/src/utils/validation.ts

@@ -1647,6 +1647,7 @@ interface FlatIssue {
  *  - **unrecognized**: when a closed object received an extra key
  *    (`additionalProperties: false`), drop that key so re-validation succeeds.
  *    This effectively coerces object schemas to loose semantics recursively.
+ *    Dropped root keys are recorded in `droppedRootKeys` when one is supplied.
  *
  * The function is safe and conservative:
  *   - Only processes "type" and "unrecognized" issues
@@ -1654,7 +1655,11 @@ interface FlatIssue {
  *   - Only wraps singleton array values for non-union type expectations
  *   - Clones the args object before mutation (copy-on-write)
  */
-function coerceArgsFromIssues(args: unknown, issues: FlatIssue[]): { value: unknown; changed: boolean } {
+function coerceArgsFromIssues(
+	args: unknown,
+	issues: FlatIssue[],
+	droppedRootKeys?: Map<string, unknown>,
+): { value: unknown; changed: boolean } {
 	if (issues.length === 0) return { value: args, changed: false };
 
 	let changed = false;
@@ -1669,6 +1674,11 @@ function coerceArgsFromIssues(args: unknown, issues: FlatIssue[]): { value: unkn
 		// Container-to-string conversion remains enabled for string branches.
 		if (issue.keyword === "unrecognized") {
 			if (issue.unionBranch) continue;
+			if (droppedRootKeys) {
+				const segments = decodeJsonPointer(issue.instancePath);
+				const dropped = segments.length === 1 ? getValueAtPointer(nextArgs, issue.instancePath) : undefined;
+				if (dropped !== undefined) droppedRootKeys.set(segments[0]!, dropped);
+			}
 			const previous = nextArgs;
 			nextArgs = deleteValueAtPointer(nextArgs, issue.instancePath);
 			if (nextArgs !== previous) changed = true;
@@ -1755,6 +1765,19 @@ function preserveUnknownRootFields(input: unknown, parsed: unknown): unknown {
 	return { ...input, ...parsed };
 }
 
+/** Put root keys the unrecognized-key repair deleted back onto a validated value, never overwriting a key it kept. */
+function restoreDroppedRootKeys(value: unknown, dropped: ReadonlyMap<string, unknown> | undefined): unknown {
+	if (!dropped || dropped.size === 0 || !isPlainRecord(value)) return value;
+	const out: Record<string, unknown> = { ...value };
+	for (const [key, entry] of dropped) {
+		// Own-property check and define: `constructor`/`__proto__` must restore as plain fields.
+		if (!Object.hasOwn(out, key)) {
+			Object.defineProperty(out, key, { value: entry, enumerable: true, writable: true, configurable: true });
+		}
+	}
+	return out;
+}
+
 function flattenJsonSchemaIssues(
 	issues: ReadonlyArray<JsonSchemaValidationIssue>,
 	speculativeUnion = false,
@@ -1999,13 +2022,28 @@ function truncateArgsForError(value: unknown): unknown {
 	return value;
 }
 
+/** Options for {@link validateToolArguments}. */
+export interface ValidateToolArgumentsOptions {
+	/**
+	 * Keep unknown root keys on the validated value instead of letting the
+	 * unrecognized-key repair delete them from a closed schema. Set for tools
+	 * that own their refusal (`lenientArgValidation`), so execute() can reject
+	 * fields the model sent rather than run without them.
+	 */
+	keepUnknownRootKeys?: boolean;
+}
+
 /**
  * Validates tool call arguments against an ArkType or plain JSON Schema schema.
  * Applies conservative LLM-quirk normalization before declaring failure.
  *
  * @throws Error with a formatted message when validation cannot be reconciled.
  */
-export function validateToolArguments(tool: Tool, toolCall: ToolCall): ToolCall["arguments"] {
+export function validateToolArguments(
+	tool: Tool,
+	toolCall: ToolCall,
+	options: ValidateToolArgumentsOptions = {},
+): ToolCall["arguments"] {
 	const originalArgs = toolCall.arguments;
 	if (originalArgs && typeof originalArgs === "object" && "__parseError" in originalArgs) {
 		const parseError = originalArgs.__parseError;
@@ -2095,11 +2133,12 @@ export function validateToolArguments(tool: Tool, toolCall: ToolCall): ToolCall[
 	let result = validateContext(ctx, normalizedArgs);
 	if (result.success) return result.value as ToolCall["arguments"];
 
-	const coercionOutcome = runCoercionPasses(ctx, normalizedArgs, result);
+	const droppedRootKeys = options.keepUnknownRootKeys ? new Map<string, unknown>() : undefined;
+	const coercionOutcome = runCoercionPasses(ctx, normalizedArgs, result, true, false, droppedRootKeys);
 	normalizedArgs = coercionOutcome.args;
 	changed ||= coercionOutcome.changed;
 	result = coercionOutcome.result;
-	if (result.success) return result.value as ToolCall["arguments"];
+	if (result.success) return restoreDroppedRootKeys(result.value, droppedRootKeys) as ToolCall["arguments"];
 
 	// Last resort: some providers parse in-band tool-call syntax server-side,
 	// and a mistyped/missing `</arg_value>` closer inlines the remaining pairs
@@ -2111,11 +2150,11 @@ export function validateToolArguments(tool: Tool, toolCall: ToolCall): ToolCall[
 		changed = true;
 		result = validateContext(ctx, normalizedArgs);
 		if (!result.success) {
-			const healedOutcome = runCoercionPasses(ctx, normalizedArgs, result);
+			const healedOutcome = runCoercionPasses(ctx, normalizedArgs, result, true, false, droppedRootKeys);
 			normalizedArgs = healedOutcome.args;
 			result = healedOutcome.result;
 		}
-		if (result.success) return result.value as ToolCall["arguments"];
+		if (result.success) return restoreDroppedRootKeys(result.value, droppedRootKeys) as ToolCall["arguments"];
 	}
 
 	// Format validation errors nicely. The header phrase is asserted by
@@ -2151,6 +2190,7 @@ function runCoercionPasses(
 	initial: ContextValidationResult,
 	isRoot = true,
 	insideContent = false,
+	droppedRootKeys?: Map<string, unknown>,
 ): { args: unknown; result: ContextValidationResult; changed: boolean } {
 	const { json } = ctx;
 	const root = ctx.kind === "json" ? (ctx.root ?? json) : json;
@@ -2159,7 +2199,7 @@ function runCoercionPasses(
 	let changed = false;
 	for (let pass = 0; pass < MAX_COERCION_PASSES; pass += 1) {
 		if (result.success) break;
-		const coercion = coerceArgsFromIssues(normalizedArgs, result.flatIssues);
+		const coercion = coerceArgsFromIssues(normalizedArgs, result.flatIssues, droppedRootKeys);
 		let passChanged = coercion.changed;
 		normalizedArgs = coercion.value;