@oh-my-pi/pi-ai 16.1.8 → 16.1.9

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [16.1.9] - 2026-06-21
+
+### Added
+
+- Added `llama.cpp` to the interactive `/login` provider list, accepting an optional API key while defaulting to local no-auth mode.
+
+### Changed
+
+- Optimized generated AI tool schemas by collapsing verbose `anyOf` unions into standard `enum` types
+
+### Fixed
+
+- Fixed tool-call argument validation dropping nested keys that were accidentally double-encoded
+- Fixed the `moonshot` provider being locked to the international Kimi host (`api.moonshot.ai`): OpenAI-completions requests now honor a `MOONSHOT_BASE_URL` override so users can reach the Kimi China platform (`api.moonshot.cn`), which rejects keys issued for the international endpoint. ([#2883](https://github.com/can1357/oh-my-pi/issues/2883))
+- Fixed tool-call argument validation dropping fields whose object keys were accidentally JSON-encoded a second time (e.g. `{ "\"op\"": "done" }`), which surfaced as spurious missing-required errors. A schema-agnostic pre-validation pass now recursively unwraps such double-encoded keys — through arrays and nested objects, and again after a JSON-string container is parsed — before the unrecognized-key repair can delete them.
+
+### Removed
+
+- Removed the `setNextRequestDebugPath`, `clearNextRequestDebugPath`, and `getNextRequestDebugPath` utility functions for request debugging, as request/response recording now relies exclusively on the `PI_REQ_DEBUG` environment variable.
+- Removed Wafer Pass (`wafer-pass`) login support; Wafer Serverless remains available as `wafer-serverless`.
+
 ## [16.1.8] - 2026-06-20
 
 ### Changed

package/README.md

@@ -62,7 +62,6 @@ Unified LLM API with automatic model discovery, provider configuration, token an
 - **Hugging Face Inference**
 - **xAI**
 - **Venice** (requires `VENICE_API_KEY`)
-- **Wafer Pass** (requires `WAFER_PASS_API_KEY`; flat-rate subscription, includes GLM-5.1 and Qwen3.5-397B-A17B)
 - **Wafer Serverless** (requires `WAFER_SERVERLESS_API_KEY`; pay-as-you-go)
 - **OpenRouter**
 - **Kilo Gateway** (supports OAuth `/login kilo` or `KILO_API_KEY`)

package/dist/types/registry/llama-cpp.d.ts

@@ -0,0 +1,8 @@
+import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types";
+export declare function loginLlamaCpp(options: OAuthController): Promise<string>;
+export declare const llamaCppProvider: {
+    readonly id: "llama.cpp";
+    readonly name: "llama.cpp (Local OpenAI-compatible)";
+    readonly envKeys: "LLAMA_CPP_API_KEY";
+    readonly login: (cb: OAuthLoginCallbacks) => Promise<string>;
+};

package/dist/types/registry/oauth/wafer.d.ts

@@ -1,2 +1 @@
-export declare const loginWaferPass: (options: import("./types").OAuthController) => Promise<string>;
 export declare const loginWaferServerless: (options: import("./types").OAuthController) => Promise<string>;

package/dist/types/registry/registry.d.ts

@@ -112,6 +112,11 @@ declare const ALL: ({
     readonly id: "litellm";
     readonly name: "LiteLLM";
     readonly login: (cb: import("./oauth").OAuthLoginCallbacks) => Promise<string>;
+} | {
+    readonly id: "llama.cpp";
+    readonly name: "llama.cpp (Local OpenAI-compatible)";
+    readonly envKeys: "LLAMA_CPP_API_KEY";
+    readonly login: (cb: import("./oauth").OAuthLoginCallbacks) => Promise<string>;
 } | {
     readonly id: "lm-studio";
     readonly name: "LM Studio (Local OpenAI-compatible)";
@@ -226,10 +231,6 @@ declare const ALL: ({
     readonly id: "vllm";
     readonly name: "vLLM (Local OpenAI-compatible)";
     readonly login: (cb: import("./oauth").OAuthLoginCallbacks) => Promise<string>;
-} | {
-    readonly id: "wafer-pass";
-    readonly name: "Wafer Pass (flat-rate subscription)";
-    readonly login: (cb: import("./oauth").OAuthLoginCallbacks) => Promise<string>;
 } | {
     readonly id: "wafer-serverless";
     readonly name: "Wafer Serverless (pay-as-you-go)";

package/dist/types/utils/request-debug.d.ts

@@ -22,9 +22,6 @@ export interface RequestDebugSession {
     wrapResponse(response: Response): Promise<Response>;
 }
 export declare function isRequestDebugEnabled(): boolean;
-export declare function setNextRequestDebugPath(requestPath: string): void;
-export declare function clearNextRequestDebugPath(): void;
-export declare function getNextRequestDebugPath(): string | undefined;
 export declare function wrapFetchForRequestDebug(fetchImpl: FetchImpl): FetchImpl;
 export declare function withRequestDebugFetch<T extends {
     fetch?: FetchImpl;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.1.8",
+	"version": "16.1.9",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,9 +38,9 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-catalog": "16.1.8",
-		"@oh-my-pi/pi-utils": "16.1.8",
-		"@oh-my-pi/pi-wire": "16.1.8",
+		"@oh-my-pi/pi-catalog": "16.1.9",
+		"@oh-my-pi/pi-utils": "16.1.9",
+		"@oh-my-pi/pi-wire": "16.1.9",
 		"arktype": "^2.2.0",
 		"partial-json": "^0.1.7",
 		"zod": "^4"

package/src/providers/openai-shared.ts

@@ -155,6 +155,16 @@ export function resolveOpenAIRequestSetup(
 
 	let copilotPremiumRequests: number | undefined;
 	let baseUrl = model.baseUrl;
+	if (model.provider === "moonshot") {
+		// Bundled `moonshot` catalog models hardcode the international endpoint
+		// (`api.moonshot.ai`). MOONSHOT_BASE_URL lets users redirect the provider
+		// at the China platform (`api.moonshot.cn`), which only accepts China keys
+		// and rejects the international host. (#2883)
+		const moonshotBaseUrl = $env.MOONSHOT_BASE_URL?.trim();
+		if (moonshotBaseUrl) {
+			baseUrl = moonshotBaseUrl;
+		}
+	}
 	if (model.provider === "github-copilot") {
 		apiKey = parseGitHubCopilotApiKey(rawApiKey).accessToken;
 		const copilot = buildCopilotDynamicHeaders({

package/src/registry/llama-cpp.ts

@@ -0,0 +1,34 @@
+import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+const PROVIDER_ID = "llama.cpp";
+const AUTH_URL = "https://github.com/ggml-org/llama.cpp#quick-start";
+const DEFAULT_LOCAL_BASE_URL = "http://127.0.0.1:8080";
+const DEFAULT_LOCAL_TOKEN = "llama-cpp-local";
+
+export async function loginLlamaCpp(options: OAuthController): Promise<string> {
+	if (!options.onPrompt) {
+		throw new Error(`${PROVIDER_ID} login requires onPrompt callback`);
+	}
+	options.onAuth?.({
+		url: AUTH_URL,
+		instructions: `Paste your llama.cpp API key if your server requires auth. Leave empty for local no-auth mode (default base URL: ${DEFAULT_LOCAL_BASE_URL}; set LLAMA_CPP_BASE_URL to customize).`,
+	});
+	const apiKey = await options.onPrompt({
+		message: "Paste your llama.cpp API key (optional for local no-auth)",
+		placeholder: DEFAULT_LOCAL_TOKEN,
+		allowEmpty: true,
+	});
+	if (options.signal?.aborted) {
+		throw new Error("Login cancelled");
+	}
+	const trimmed = apiKey.trim();
+	return trimmed || DEFAULT_LOCAL_TOKEN;
+}
+
+export const llamaCppProvider = {
+	id: PROVIDER_ID,
+	name: "llama.cpp (Local OpenAI-compatible)",
+	envKeys: "LLAMA_CPP_API_KEY",
+	login: (cb: OAuthLoginCallbacks) => loginLlamaCpp(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/oauth/wafer.ts

@@ -1,41 +1,15 @@
 /**
- * Wafer login flows.
+ * Wafer Serverless login flow.
  *
- * Wafer (https://wafer.ai) exposes a single OpenAI-compatible base URL
- * (`https://pass.wafer.ai/v1`) for two SKUs:
- *
- *  - **Wafer Pass** — flat-rate subscription. The key authorizes models whose
- *    catalog entries carry `wafer.tier = "pass_included"`.
- *  - **Wafer Serverless** — pay-as-you-go. Superset of Pass; the same `/v1/models`
- *    endpoint returns the full per-account model list.
- *
- * Both SKUs issue `wfr_…` keys. The key prefix alone does not distinguish
- * tiers — the entitlement is per-account on the server side — so we expose
- * two parallel logins / env vars (`WAFER_PASS_API_KEY`, `WAFER_SERVERLESS_API_KEY`)
- * mirroring the firepass/fireworks split, letting users with both
- * subscriptions switch between them without re-pasting.
- *
- * Validation uses the shared `/v1/models` endpoint, which works for both
- * tiers and is cheap (no token spend).
+ * Wafer (https://wafer.ai) exposes a pay-as-you-go OpenAI-compatible SKU at
+ * `https://pass.wafer.ai/v1`. Keys use the `wfr_…` prefix and are validated
+ * against `/v1/models`, which is cheap (no token spend).
  */
 import { createApiKeyLogin } from "../api-key-login";
 
 const WAFER_AUTH_URL = "https://wafer.ai/dashboard";
 const WAFER_MODELS_URL = "https://pass.wafer.ai/v1/models";
 
-export const loginWaferPass = createApiKeyLogin({
-	providerLabel: "Wafer Pass",
-	authUrl: WAFER_AUTH_URL,
-	instructions: "Create or copy your Wafer Pass API key from the Wafer dashboard",
-	promptMessage: "Paste your Wafer Pass API key",
-	placeholder: "wfr_...",
-	validation: {
-		kind: "models-endpoint",
-		provider: "Wafer Pass",
-		modelsUrl: WAFER_MODELS_URL,
-	},
-});
-
 export const loginWaferServerless = createApiKeyLogin({
 	providerLabel: "Wafer Serverless",
 	authUrl: WAFER_AUTH_URL,

package/src/registry/registry.ts

@@ -22,6 +22,7 @@ import { kagiProvider } from "./kagi";
 import { kiloProvider } from "./kilo";
 import { kimiCodeProvider } from "./kimi-code";
 import { litellmProvider } from "./litellm";
+import { llamaCppProvider } from "./llama-cpp";
 import { lmStudioProvider } from "./lm-studio";
 import { minimaxProvider } from "./minimax";
 import { minimaxCodeProvider } from "./minimax-code";
@@ -50,7 +51,6 @@ import { umansProvider } from "./umans";
 import { veniceProvider } from "./venice";
 import { vercelAiGatewayProvider } from "./vercel-ai-gateway";
 import { vllmProvider } from "./vllm";
-import { waferPassProvider } from "./wafer-pass";
 import { waferServerlessProvider } from "./wafer-serverless";
 import { xaiProvider } from "./xai";
 import { xaiOauthProvider } from "./xai-oauth";
@@ -95,7 +95,6 @@ const ALL = [
 	xiaomiTokenPlanAmsProvider,
 	xiaomiTokenPlanCnProvider,
 	firepassProvider,
-	waferPassProvider,
 	deepseekProvider,
 	moonshotProvider,
 	cerebrasProvider,
@@ -122,6 +121,7 @@ const ALL = [
 	ollamaProvider,
 	ollamaCloudProvider,
 	lmStudioProvider,
+	llamaCppProvider,
 	vllmProvider,
 	openaiProvider,
 	googleProvider,

package/src/stream.ts

@@ -160,7 +160,6 @@ type KeyResolver = string | (() => string | undefined);
 const LEGACY_ENV_KEYS: Record<string, KeyResolver> = {
 	// Non-provider / search-tool keys and API-name keys not modeled as registry provider defs.
 	"azure-openai-responses": "AZURE_OPENAI_API_KEY",
-	"llama.cpp": "LLAMA_CPP_API_KEY",
 	exa: "EXA_API_KEY",
 	jina: "JINA_API_KEY",
 	brave: "BRAVE_API_KEY",

package/src/utils/request-debug.ts

@@ -1,6 +1,5 @@
 import { Buffer } from "node:buffer";
 import * as fs from "node:fs/promises";
-import * as path from "node:path";
 import type { FetchImpl } from "../types";
 
 const REQUEST_DEBUG_ENV = "PI_REQ_DEBUG";
@@ -9,7 +8,6 @@ const textEncoder = new TextEncoder();
 const utf8Decoder = new TextDecoder("utf-8", { fatal: true });
 
 let nextSessionId = 1;
-let nextRequestDebugPath: string | undefined;
 
 type DebugFetch = FetchImpl & { [DEBUG_FETCH_MARKER]?: true };
 type RequestBodyInit = NonNullable<RequestInit["body"]>;
@@ -55,25 +53,7 @@ function isRequestDebugEnvEnabled(): boolean {
 }
 
 export function isRequestDebugEnabled(): boolean {
-	return isRequestDebugEnvEnabled() || nextRequestDebugPath !== undefined;
-}
-
-export function setNextRequestDebugPath(requestPath: string): void {
-	nextRequestDebugPath = requestPath;
-}
-
-export function clearNextRequestDebugPath(): void {
-	nextRequestDebugPath = undefined;
-}
-
-export function getNextRequestDebugPath(): string | undefined {
-	return nextRequestDebugPath;
-}
-
-function consumeNextRequestDebugPath(): string | undefined {
-	const requestPath = nextRequestDebugPath;
-	nextRequestDebugPath = undefined;
-	return requestPath;
+	return isRequestDebugEnvEnabled();
 }
 
 export function wrapFetchForRequestDebug(fetchImpl: FetchImpl): FetchImpl {
@@ -249,19 +229,6 @@ function copyResponseMetadata(target: Response, source: Response): void {
 }
 
 async function reserveRequestDebugFile(): Promise<ReservedRequestDebugFile> {
-	const explicitPath = consumeNextRequestDebugPath();
-	if (explicitPath) {
-		await fs.mkdir(path.dirname(explicitPath), { recursive: true });
-		const handle = await fs.open(explicitPath, "w");
-		return {
-			id: nextSessionId++,
-			requestPath: explicitPath,
-			responsePath: `${explicitPath}.res.log`,
-			handle,
-			overwrite: true,
-		};
-	}
-
 	for (;;) {
 		const id = nextSessionId++;
 		const requestPath = `rr-session-${id}.json`;

package/src/utils/schema/wire.ts

@@ -388,6 +388,73 @@ function inferBareEnumScalarType(obj: Record<string, unknown>): void {
 	if (inferred !== undefined) obj.type = inferred;
 }
 
+/**
+ * ArkType serializes a *described* literal union — `type.enumerated(...).describe(d)`
+ * or a `"a" | "b"` union carrying a description — as an `anyOf` of
+ * `{ const, description }` branches that repeat the description on every branch
+ * *and* the union root. The meta is distributed across the union's constituents
+ * at the type level (each `unit` node inherits it), so the duplication is baked
+ * in before serialization rather than added by this pipeline.
+ *
+ * Collapse such a homogeneous all-`const` union into one typed
+ * `{ type, enum, description }` node: a shorter wire and a single description in
+ * the place providers expect it. The collapse is conservative — applied only
+ * when it is lossless:
+ *   - every branch is a bare `{ const }` (optionally `{ const, description }`),
+ *   - all branch values share one scalar JSON type (so `enum` gets a `type`,
+ *     which Gemini/Vertex require),
+ *   - branch descriptions are either all absent or all identical,
+ * so a union whose branches carry *distinct* per-variant descriptions is left
+ * untouched (a flat `enum` has nowhere to keep them). The union root's own
+ * description wins when present; otherwise the shared branch description is kept.
+ */
+function collapseConstUnionAnyOf(obj: Record<string, unknown>): void {
+	// `hasSchemaDefiningSibling` already rejects a sibling `enum`/`const`/etc.; it
+	// does not list `type`, so guard it here — collapsing would overwrite a
+	// wrapper `type` constraint paired with the `anyOf`.
+	if (hasSchemaDefiningSibling(obj) || "type" in obj) return;
+	const variants = obj.anyOf;
+	if (!Array.isArray(variants) || variants.length < 2) return;
+
+	const values: unknown[] = [];
+	let branchDescription: string | undefined;
+	let describedCount = 0;
+	for (const variant of variants) {
+		if (!isSchemaRecord(variant) || !Object.hasOwn(variant, "const")) return;
+		for (const key in variant) {
+			if (key !== "const" && key !== "description") return; // extra constraints — not a bare const
+		}
+		const desc = variant.description;
+		if (typeof desc === "string") {
+			if (describedCount === 0) branchDescription = desc;
+			else if (desc !== branchDescription) return; // distinct per-variant descriptions — preserve them
+			describedCount++;
+		}
+		values.push(variant.const);
+	}
+	if (describedCount !== 0 && describedCount !== variants.length) return; // mixed described/undescribed
+	// A shared branch description that disagrees with the union root's own
+	// description would be silently dropped by the collapse — keep the anyOf so
+	// neither annotation is lost. (Equal descriptions, the ArkType case, collapse.)
+	if (
+		describedCount === variants.length &&
+		typeof obj.description === "string" &&
+		obj.description !== branchDescription
+	) {
+		return;
+	}
+
+	const scalarType = homogeneousEnumScalarType(values);
+	if (scalarType === undefined) return; // mixed / non-scalar (incl. null) — leave as anyOf
+
+	delete obj.anyOf;
+	obj.type = scalarType;
+	obj.enum = values;
+	if (typeof obj.description !== "string" && branchDescription !== undefined) {
+		obj.description = branchDescription;
+	}
+}
+
 function walk(node: unknown, zodCleanup: boolean): void {
 	if (Array.isArray(node)) {
 		for (const child of node) walk(child, zodCleanup);
@@ -397,6 +464,7 @@ function walk(node: unknown, zodCleanup: boolean): void {
 	const obj = node as Record<string, unknown>;
 	rewriteNullableScalarAnyOf(obj);
 	inferBareEnumScalarType(obj);
+	collapseConstUnionAnyOf(obj);
 
 	if (zodCleanup) {
 		// Drop noise injected for `z.number().int()`.

package/src/utils/validation.ts

@@ -834,6 +834,105 @@ function normalizeOptionalNullsForSchema(
 	return { value: changed ? nextValue : value, changed };
 }
 
+// ============================================================================
+// Double-encoded object-key normalization (LLM quirk).
+// ============================================================================
+//
+// LLMs occasionally serialize an object key one time too many, so the property
+// NAME arrives as the JSON encoding of the real name — literal quote characters
+// and all (e.g. `{ "\"op\"": "done" }` decodes to the JS key `"op"`). The
+// schema never matches such a key, so it reads as an unrecognized extra and is
+// dropped by the unrecognized-key repair, later surfacing as a spurious
+// missing-required error. We walk the whole value (arrays + nested objects)
+// and rename any key that is itself the JSON encoding of a plain string back to
+// that string.
+// ============================================================================
+
+/** Max layers of accidental JSON-encoding to peel off a single object key. */
+const MAX_KEY_DECODE_DEPTH = 3;
+
+/**
+ * If `key` is the JSON encoding of a plain string (quote-wrapped and
+ * `JSON.parse`s to a string), return the decoded string; otherwise null. Peels
+ * up to {@link MAX_KEY_DECODE_DEPTH} nested encodings so multiply-encoded keys
+ * collapse in one pass. Conservative: any key that is not a quote-wrapped JSON
+ * string literal is left untouched.
+ */
+function decodeDoubleEncodedKey(key: string): string | null {
+	let current = key;
+	let decoded: string | null = null;
+	for (let depth = 0; depth < MAX_KEY_DECODE_DEPTH; depth += 1) {
+		if (current.length < 2 || current[0] !== '"' || current[current.length - 1] !== '"') break;
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(current);
+		} catch {
+			break;
+		}
+		if (typeof parsed !== "string") break;
+		current = parsed;
+		decoded = current;
+	}
+	return decoded;
+}
+
+/**
+ * Recursively unwrap object keys that were accidentally JSON-encoded an extra
+ * time. Schema-agnostic by design: such keys are dropped before any schema pass
+ * can map them, so this runs first. A key is only renamed when the decoded name
+ * differs and does not already exist on the same object — renaming would
+ * otherwise clobber a sibling and silently lose data.
+ */
+function normalizeDoubleEncodedKeys(value: unknown): { value: unknown; changed: boolean } {
+	if (Array.isArray(value)) {
+		let changed = false;
+		let next = value;
+		for (let i = 0; i < value.length; i += 1) {
+			const normalized = normalizeDoubleEncodedKeys(value[i]);
+			if (!normalized.changed) continue;
+			if (!changed) {
+				next = [...value];
+				changed = true;
+			}
+			next[i] = normalized.value;
+		}
+		return { value: changed ? next : value, changed };
+	}
+
+	if (value === null || typeof value !== "object") return { value, changed: false };
+
+	const source = value as Record<string, unknown>;
+	let changed = false;
+	const out: Record<string, unknown> = {};
+	for (const [key, entry] of Object.entries(source)) {
+		const normalizedChild = normalizeDoubleEncodedKeys(entry);
+		const nextChild = normalizedChild.changed ? normalizedChild.value : entry;
+
+		const decodedKey = decodeDoubleEncodedKey(key);
+		// `Object.hasOwn` (not `in`) so a decoded `constructor`/`toString` is not
+		// mistaken for a collision via the prototype chain.
+		const targetKey =
+			decodedKey !== null &&
+			decodedKey !== key &&
+			!Object.hasOwn(source, decodedKey) &&
+			!Object.hasOwn(out, decodedKey)
+				? decodedKey
+				: key;
+
+		if (targetKey !== key || normalizedChild.changed) changed = true;
+		// `defineProperty` so a decoded `__proto__` key becomes an own property
+		// instead of mutating the result object's prototype.
+		Object.defineProperty(out, targetKey, {
+			value: nextChild,
+			writable: true,
+			enumerable: true,
+			configurable: true,
+		});
+	}
+
+	return { value: changed ? out : value, changed };
+}
+
 // ============================================================================
 // String-encoded array coercion for union(string, array) schemas.
 // ============================================================================
@@ -922,8 +1021,15 @@ function normalizeStringEncodedArrayUnions(schema: unknown, value: unknown): { v
 		if (!trimmed.startsWith("[")) return { value, changed: false };
 		try {
 			const parsed = JSON.parse(trimmed) as unknown;
-			if (Array.isArray(parsed) && parsedArrayMatchesArrayBranch(schemaObject, parsed)) {
-				return { value: parsed, changed: true };
+			if (Array.isArray(parsed)) {
+				// Unwrap any double-encoded object keys inside the parsed array
+				// before the branch-match check; otherwise an `array<object>`
+				// branch fails to validate and the value silently stays on the
+				// string branch.
+				const candidate = normalizeDoubleEncodedKeys(parsed).value as unknown[];
+				if (parsedArrayMatchesArrayBranch(schemaObject, candidate)) {
+					return { value: candidate, changed: true };
+				}
 			}
 		} catch {
 			// Not valid JSON — leave the string alone for the validator to handle.
@@ -1312,6 +1418,18 @@ export function validateToolArguments(tool: Tool, toolCall: ToolCall): ToolCall[
 	// placeholders for "no value" even when validation would otherwise pass.
 	let normalizedArgs: unknown = originalArgs;
 	let changed = false;
+
+	// Unwrap accidentally double-JSON-encoded object keys before any schema
+	// pass. LLMs sometimes emit `{ "\"op\"": "done" }`, so the property name
+	// arrives quote-wrapped; left alone it reads as an unrecognized key, gets
+	// dropped by the coercion repair, and re-surfaces as a missing-required
+	// error. Running first means every later pass sees the corrected names.
+	const keyNormalization = normalizeDoubleEncodedKeys(normalizedArgs);
+	if (keyNormalization.changed) {
+		normalizedArgs = keyNormalization.value;
+		changed = true;
+	}
+
 	const initialNormalization = normalizeOptionalNullsForSchema(json, normalizedArgs);
 	if (initialNormalization.changed) {
 		normalizedArgs = initialNormalization.value;
@@ -1338,6 +1456,15 @@ export function validateToolArguments(tool: Tool, toolCall: ToolCall): ToolCall[
 		normalizedArgs = coercion.value;
 		changed = true;
 
+		// `coerceArgsFromIssues` may have just parsed a JSON-string container at
+		// the root or a nested field, exposing double-encoded keys the initial
+		// pass could not reach. Re-unwrap before the unrecognized-key repair on
+		// the next validation pass would delete them.
+		const keyNormalizationPass = normalizeDoubleEncodedKeys(normalizedArgs);
+		if (keyNormalizationPass.changed) {
+			normalizedArgs = keyNormalizationPass.value;
+		}
+
 		const nullNormalization = normalizeOptionalNullsForSchema(json, normalizedArgs);
 		if (nullNormalization.changed) {
 			normalizedArgs = nullNormalization.value;

package/dist/types/registry/wafer-pass.d.ts

@@ -1,6 +0,0 @@
-import type { OAuthLoginCallbacks } from "./oauth/types";
-export declare const waferPassProvider: {
-    readonly id: "wafer-pass";
-    readonly name: "Wafer Pass (flat-rate subscription)";
-    readonly login: (cb: OAuthLoginCallbacks) => Promise<string>;
-};

package/src/registry/wafer-pass.ts

@@ -1,12 +0,0 @@
-import type { OAuthLoginCallbacks } from "./oauth/types";
-import type { ProviderDefinition } from "./types";
-
-export const waferPassProvider = {
-	id: "wafer-pass",
-	name: "Wafer Pass (flat-rate subscription)",
-	login: async (cb: OAuthLoginCallbacks) => {
-		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
-		const { loginWaferPass } = await import("./oauth/wafer");
-		return loginWaferPass(cb);
-	},
-} as const satisfies ProviderDefinition;