@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

package/lib/{utils-cZX3f_Ls.mjs → utils-C_Ncya1r.mjs}

@@ -1,11 +1,16 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
-import { F as $flag, N as $env, _ as parseStreamingJson, b as debug, g as parseJsonWithRepair } from "./src-AELUUb5U.mjs";
-import { r as ValidationError } from "./error-O63pC8zg.mjs";
-import { n as classifyModel } from "./taxonomy-DSIM99rS.mjs";
-import { i as getBundledProviders, r as getBundledModels } from "./models-DnXMYGcJ.mjs";
-import { t as buildModelReferenceIndex } from "./reference-CtvM4zLU.mjs";
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/json.ts
+import { E as debug, H as $env, S as parseJsonWithRepair, W as $flag, n as structuredCloneJSON, x as classifyJsonPrefix } from "./src-BhinCSpi.mjs";
+import { r as ValidationError } from "./error-8LVo7tug.mjs";
+import { h as isRecord, r as resolveCascade } from "./cascade-BWjRTD1q.mjs";
+import { i as isBareIdReferenceProvider } from "./behavior-BwvTUtag.mjs";
+import { o as resolveCatalogAxes } from "./id-EJwVLDHE.mjs";
+import { l as classifyModel } from "./pricing-DusBEhwm.mjs";
+import { i as buildModelReferenceIndex, r as toModelSpec } from "./bundled-references-CrQ4dQcT.mjs";
+import { i as getBundledProviders, r as getBundledModels } from "./models-DCpDT_im.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { formatLocalRefPointer, parseLocalRefPointer } from "@oh-my-pi/omptype";
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/json.ts
 /**
 * Try to parse JSON, returning null on failure.
 */
@@ -26,10 +31,139 @@ function tryParseJson(content) {
 * only lossless JSON representation.
 */
 function stringifyJson$1(value, space) {
-	return JSON.stringify(value, (_key, item) => typeof item === "bigint" ? item.toString() : item, space);
+	try {
+		return JSON.stringify(value, void 0, space);
+	} catch (error) {
+		if (!(error instanceof TypeError)) throw error;
+		return JSON.stringify(value, (_key, item) => typeof item === "bigint" ? item.toString() : item, space);
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/sanitize-text.ts
+const ESC_CHAR = "\x1B";
+const CONTROL_RE = /[\x00-\x08\x0B-\x1F\x7F-\x9F]/g;
+const REPLACEMENT_CHAR = "�";
+function sanitizeText(text) {
+	const wellFormed = text.toWellFormed();
+	if (wellFormed !== text) return sanitizeWellFormedText(wellFormed.replaceAll(REPLACEMENT_CHAR, ""));
+	return sanitizeWellFormedText(text);
+}
+function sanitizeWellFormedText(text) {
+	CONTROL_RE.lastIndex = 0;
+	if (CONTROL_RE.exec(text) === null) return text;
+	const stripped = text.indexOf(ESC_CHAR) === -1 ? text : Bun.stripANSI(text);
+	CONTROL_RE.lastIndex = 0;
+	return stripped.replace(CONTROL_RE, "");
+}
+/**
+* Escape the three XML-significant characters (`&`, `<`, `>`) in text destined
+* for an XML/markup element body. Allocation-conscious: returns the input
+* unchanged (same reference) when nothing needs escaping. Quotes are left as-is
+* — use it for element text, not attribute values.
+*/
+function escapeXmlText(input) {
+	let firstEscapable = -1;
+	for (let index = 0; index < input.length; index++) {
+		const char = input.charCodeAt(index);
+		if (char === 38 || char === 60 || char === 62) {
+			firstEscapable = index;
+			break;
+		}
+	}
+	if (firstEscapable === -1) return input;
+	let output = input.slice(0, firstEscapable);
+	for (let index = firstEscapable; index < input.length; index++) {
+		const char = input[index];
+		if (char === "&") output += "&amp;";
+		else if (char === "<") output += "&lt;";
+		else if (char === ">") output += "&gt;";
+		else output += char;
+	}
+	return output;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/compat/catalog-policy.ts
+/**
+* Rule-owned catalog-axis policy by model. Resolve once per process rather
+* than walking the static policy cascade on every accessor call. The key
+* mirrors the cascade target inputs — `providerType ?? provider`, api, model
+* id, and the reasoning flag; identity-derived class/family/revision facts are
+* a pure function of provider + id. Bounded: one entry per distinct model.
+*/
+const catalogPolicyCache = /* @__PURE__ */ new Map();
+const CATALOG_POLICY_CACHE_MAX = 8192;
+/**
+* The `catalog` axis bag authored in the KDL cascade rules for a model,
+* memoized per distinct model. Frozen: the bag is shared across callers, so it
+* must stay read-only — extract the value you need rather than handing it on.
+*/
+function resolveCatalogPolicy(model) {
+	const key = `${model.provider}\u0000${model.providerType ?? ""}\u0000${model.api}\u0000${model.id}\u0000${model.reasoning ? 1 : 0}`;
+	const cached = catalogPolicyCache.get(key);
+	if (cached !== void 0) return cached;
+	const policy = Object.freeze({ ...resolveCatalogAxes(toModelSpec(model)) });
+	if (catalogPolicyCache.size >= CATALOG_POLICY_CACHE_MAX) catalogPolicyCache.clear();
+	catalogPolicyCache.set(key, policy);
+	return policy;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/compat/reasoning-carry.ts
+/**
+* Reasoning carry: whether reasoning a model produced on one host may replay
+* natively on another host serving the same model.
+*
+* The model-side half is declared with the `portable-reasoning` catalog axis
+* per family in `rules/classes/*.kdl`: the family's stored reasoning is its own
+* full plaintext trace, and its identity pins one set of weights. A host whose
+* reasoning must neither be carried in nor out overrides it to `#false` in its
+* `rules/providers/*.kdl`. Whether the target host has a native slot for
+* earlier reasoning is derived by the request encoders in `@oh-my-pi/pi-ai`,
+* not declared here.
+*
+* Resolved through the cascade on demand (like delegation bias) because
+* bundled rows are frozen by the generator; results are memoized per
+* deployment.
+*/
+/** `null` records a deployment that does not carry reasoning. */
+const portableIdentityMemo = /* @__PURE__ */ new Map();
+/**
+* The identity a deployment's reasoning is carried under, or `undefined` when
+* the deployment's model family is not declared portable there. Class-only
+* identities never qualify: they name a lineage, not a set of weights.
+*/
+function portableReasoningIdentity(provider, api, modelId) {
+	const key = `${provider}\0${api}\0${modelId}`;
+	const memo = portableIdentityMemo.get(key);
+	if (memo !== void 0) return memo ?? void 0;
+	const identity = classifyModel(provider, modelId, { lenient: true });
+	let portable = null;
+	if (identity.family !== void 0 || identity.revision !== void 0) {
+		if (resolveCascade({
+			provider,
+			api,
+			class: identity.class,
+			model: modelId,
+			reasoning: true,
+			...identity.family !== void 0 && { family: identity.family },
+			...identity.revision !== void 0 && { revision: identity.revision }
+		}).catalog.portableReasoning === true) portable = identity;
+	}
+	portableIdentityMemo.set(key, portable);
+	return portable ?? void 0;
+}
+/**
+* Whether reasoning recorded on `source` may replay natively on `target`:
+* both deployments declare the family portable and classify to the same
+* class, family, and revision.
+*/
+function carriesReasoning(source, target) {
+	const to = portableReasoningIdentity(target.provider, target.api, target.id);
+	if (!to) return false;
+	const from = portableReasoningIdentity(source.provider, source.api, source.model);
+	return from !== void 0 && from.class === to.class && from.family === to.family && from.revision === to.revision;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.1.17/node_modules/@oh-my-pi/pi-catalog/src/identity/bundled.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/identity/bundled.ts
 /**
 * Memoized proxy-reference index over the bundled model catalog.
 *
@@ -40,7 +174,7 @@ function stringifyJson$1(value, space) {
 */
 let bundledModels;
 function getBundledModelList() {
-	bundledModels ??= getBundledProviders().flatMap((provider) => getBundledModels(provider));
+	bundledModels ??= getBundledProviders().filter(isBareIdReferenceProvider).flatMap((provider) => getBundledModels(provider));
 	return bundledModels;
 }
 let referenceIndex;
@@ -65,10 +199,10 @@ function preferredDialect(modelId) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/anthropic.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/anthropic.md
 var anthropic_default = "## Format guide\n\nA call is a `<function_calls>` block wrapping one or more `<invoke>` blocks, each holding `<parameter>` children:\n\n```text\n<function_calls>\n<invoke name=\"tool_name\"><parameter name=\"arg_name\">arg value</parameter></invoke>\n</function_calls>\n```\n\nResults arrive later in a `<function_results>` block, one `<result>` per call (failures use `<error>` with `<stderr>` in place of `<result>` with `<stdout>`):\n\n```text\n<function_results>\n<result>\n<tool_name>tool_name</tool_name>\n<stdout>verbatim tool result</stdout>\n</result>\n</function_results>\n```\n\n## Rules\n\n- `name` MUST match a listed function.\n- String/scalar parameters: exact text, spaces preserved — bodies are read by regex (delimiter matching), NOT a real XML parser, so never HTML-escape them (emit `a & b`, not `a &amp; b`; `<`/`>` stay literal); only the body's own `</parameter>` closing tag is reserved. Lists/objects: JSON.\n- Multiple calls: multiple `<invoke>` blocks in one `<function_calls>`.\n- You MAY write visible text before the calls.\n- NEVER emit `tool_calls` JSON.\n- NEVER use the legacy `<tool_name>`/`<parameters>` call syntax.\n- Read each `<result>`/`<error>` in call order. NEVER emit `<function_results>` yourself.\n- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at \"Let's run `cargo clippy`\" with no `<invoke>` emitted). Write the complete call, THEN the stop sequence, THEN halt.\n";
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/types.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils/schema/types.ts
 function isJsonObject(value) {
 	return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -77,7 +211,7 @@ function isJsonObjectEmpty(value) {
 	return Object.keys(value).length === 0;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/equality.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils/schema/equality.ts
 function areJsonValuesEqual(left, right) {
 	if (Object.is(left, right)) return true;
 	if (Array.isArray(left) || Array.isArray(right)) {
@@ -130,43 +264,41 @@ function mergePropertySchemas(existing, incoming) {
 	return mergedAnyOf.length === 1 ? mergedAnyOf[0] : { anyOf: mergedAnyOf };
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/stamps.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils/schema/stamps.ts
 /**
-* Symbol-keyed lazy memoization stamped directly onto the host object.
+* Lazy memoization keyed by host object identity, held in a module-level
+* weak side table.
 *
-* Faster than a module-level `WeakMap` in V8/JSC because the symbol slot is
-* resolved through the object's hidden class instead of a side-table hash
-* lookup. The slot is defined as a non-enumerable property so the stamp
-* does not leak through `{...spread}`, `Object.keys`, `JSON.stringify`, or
-* `toEqual`-style deep equality.
+* The bookkeeping deliberately lives outside the host rather than in a
+* non-enumerable symbol property: schema objects are caller-owned and may be
+* sealed, frozen, or deep-frozen after their first traversal. A recursive
+* freeze that enumerates with `Reflect.ownKeys` reaches symbol slots, so an
+* on-host slot would be frozen along with the schema and every later write
+* would throw. A side table is also invisible to `{...spread}`,
+* `Object.keys`, `JSON.stringify`, and `toEqual`-style deep equality.
 *
-* Caveats: the stamp lives as long as the host object, even after callers
+* Caveats: an entry lives as long as the host object, even after callers
 * release their references to the cached value — only use this for caches
-* whose lifetime should match the host. Frozen hosts cannot be stamped;
-* `define` silently skips them, so memoization/visit-tracking degrades to
-* best-effort (recompute on every call, no cycle protection) instead of
-* throwing.
+* whose lifetime should match the host.
 */
-function define(target, key, value) {
-	if (Object.isFrozen(target)) return;
-	Object.defineProperty(target, key, {
-		value,
-		writable: true,
-		configurable: true
-	});
-}
+const memos = /* @__PURE__ */ new WeakMap();
 function stamp(target, key, compute) {
-	const existing = target[key];
+	let slots = memos.get(target);
+	if (!slots) {
+		slots = /* @__PURE__ */ new Map();
+		memos.set(target, slots);
+	}
+	const existing = slots.get(key);
 	if (existing !== void 0) return existing;
 	const value = compute(target);
-	define(target, key, value);
+	slots.set(key, value);
 	return value;
 }
 /**
-* Epoch-keyed cycle guard. Cheaper than `WeakSet` for recursive traversal
-* because the marker is a single property slot on the host object, written
-* once and overwritten in place on every subsequent traversal — the hidden
-* class transitions once per object lifetime, not per traversal.
+* Epoch-keyed cycle guard. Cheaper than a per-call `WeakSet` for recursive
+* traversal because the marker is a single side-table entry per host object,
+* written once and overwritten in place on every subsequent traversal — no
+* per-walk allocation.
 *
 * Usage:
 *   function walk(node, epoch = epochNext()) {
@@ -174,7 +306,7 @@ function stamp(target, key, compute) {
 *     for (const child of node.children) walk(child, epoch);
 *   }
 */
-const kEpoch = Symbol("pi.schema.epoch");
+const epochs = /* @__PURE__ */ new WeakMap();
 let __epoch = 0;
 function epochNext() {
 	return ++__epoch;
@@ -185,24 +317,18 @@ function epochNext() {
 * subsequent call within the same epoch.
 */
 function once(target, epoch) {
-	const slot = target;
-	const cur = slot[kEpoch];
+	const cur = epochs.get(target);
 	if (cur !== void 0 && cur >= epoch) return false;
-	if (cur === void 0) define(target, kEpoch, epoch);
-	else slot[kEpoch] = epoch;
+	epochs.set(target, epoch);
 	return true;
 }
 /**
 * Counter-based path tracker. Use when a traversal needs to distinguish
 * "currently on the recursion path" from "previously visited" — i.e. cycle
 * detection that throws while still allowing DAG sharing. Increment on
-* entry, decrement on exit; the slot returns to 0 after a balanced walk so
+* entry, decrement on exit; the counter returns to 0 after a balanced walk so
 * subsequent top-level calls see a fresh state without any reset.
 *
-* Unlike a `WeakSet` with `seen.delete(...)`, the property is never deleted
-* — only incremented and decremented — so the host object's hidden class
-* is never invalidated.
-*
 * Usage:
 *   function walk(node) {
 *     if (!enter(node)) throw new Error("cycle");
@@ -210,7 +336,7 @@ function once(target, epoch) {
 *     finally { exit(node); }
 *   }
 */
-const kDepth = Symbol("pi.schema.depth");
+const depths = /* @__PURE__ */ new WeakMap();
 /**
 * Returns `true` on first entry, `false` if `target` is already on the
 * current path. A `false` return does NOT deepen the counter — callers pair
@@ -219,24 +345,18 @@ const kDepth = Symbol("pi.schema.depth");
 * make every later top-level walk of the same object misreport a cycle.
 */
 function enter(target) {
-	const slot = target;
-	const cur = slot[kDepth];
-	if (cur === void 0) {
-		define(target, kDepth, 1);
-		return true;
-	}
-	if (cur !== 0) return false;
-	slot[kDepth] = 1;
+	const cur = depths.get(target);
+	if (cur !== void 0 && cur !== 0) return false;
+	depths.set(target, 1);
 	return true;
 }
 function exit(target) {
-	const slot = target;
-	const cur = slot[kDepth];
+	const cur = depths.get(target);
 	if (cur === void 0) return;
-	slot[kDepth] = cur - 1;
+	depths.set(target, cur - 1);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/draft.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils/schema/draft.ts
 const JSON_SCHEMA_DRAFT_2020_12_URI = "https://json-schema.org/draft/2020-12/schema";
 /** Draft-07 schema URIs we recognise as needing an upgrade. The trailing `#` is the canonical form in the JSON Schema spec, but providers (and Zod) emit both. */
 const DRAFT_07_SCHEMA_URIS = {
@@ -250,7 +370,7 @@ const DRAFT_07_SCHEMA_URIS = {
 * entry rather than the map object itself so legacy `definitions`-style refs
 * inside property schemas get rewritten.
 */
-const SCHEMA_MAP_KEYS$1 = {
+const SCHEMA_MAP_KEYS$2 = {
 	properties: true,
 	patternProperties: true,
 	dependentSchemas: true
@@ -270,9 +390,16 @@ const NON_SCHEMA_VALUE_KEYS = {
 	dependentRequired: true,
 	type: true
 };
-/** Rewrite draft-07's `#/definitions/Foo` ref form to draft 2020-12's `#/$defs/Foo`. External refs (`http://…`) pass through. */
+/**
+* Rewrite draft-07's `#/definitions/Foo` ref form to draft 2020-12's
+* `#/$defs/Foo`, decoding URI-fragment spellings such as
+* `#%2Fdefinitions%2Ffoo` with the shared pointer parser first. External
+* refs (`http://…`) pass through.
+*/
 function convertRef(value) {
-	return value.startsWith("#/definitions/") ? `#/$defs/${value.slice(14)}` : value;
+	const pointer = parseLocalRefPointer(value);
+	if (pointer === void 0 || pointer[0] !== "definitions") return value;
+	return formatLocalRefPointer(["$defs", ...pointer.slice(1)]);
 }
 /** Get-or-create a child object map on `target[key]`. Used to lazily build up `$defs`/`dependentRequired`/`dependentSchemas` during conversion. */
 function getObjectMap(target, key) {
@@ -421,7 +548,7 @@ function schemaNeedsDraft202012UpgradeImpl(value, epoch) {
 			continue;
 		}
 		if (key === "items" && Array.isArray(entry)) return true;
-		if (key === "$defs" || key in SCHEMA_MAP_KEYS$1) {
+		if (key === "$defs" || key in SCHEMA_MAP_KEYS$2) {
 			if (schemaMapNeedsDraft202012Upgrade(entry, epoch)) return true;
 			continue;
 		}
@@ -456,7 +583,7 @@ function upgradeJsonSchemaTo202012Impl(value, cache) {
 			if (isJsonObject(entry)) mergeSchemaMap(result, "$defs", entry, cache);
 			continue;
 		}
-		if (key in SCHEMA_MAP_KEYS$1) {
+		if (key in SCHEMA_MAP_KEYS$2) {
 			copySchemaMap(result, key, entry, cache);
 			continue;
 		}
@@ -505,7 +632,7 @@ function upgradeJsonSchemaTo202012(schema) {
 	return upgradeJsonSchemaTo202012Impl(schema, /* @__PURE__ */ new WeakMap());
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/dereference.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils/schema/dereference.ts
 /**
 * Inline `$ref` / `$defs` in a JSON Schema so every consumer sees
 * the full definition without needing a resolver.
@@ -517,17 +644,54 @@ function upgradeJsonSchemaTo202012(schema) {
 *
 * After dereferencing, `$defs` and `definitions` are stripped from the root.
 */
+const SCHEMA_MAP_KEYS$1 = {
+	properties: true,
+	patternProperties: true,
+	dependencies: true,
+	dependentSchemas: true
+};
+const SCHEMA_ARRAY_KEYS$1 = {
+	anyOf: true,
+	oneOf: true,
+	allOf: true,
+	prefixItems: true
+};
+const SCHEMA_VALUE_KEYS$1 = {
+	items: true,
+	additionalItems: true,
+	contains: true,
+	contentSchema: true,
+	propertyNames: true,
+	if: true,
+	then: true,
+	else: true,
+	not: true,
+	additionalProperties: true,
+	unevaluatedItems: true,
+	unevaluatedProperties: true
+};
+function dereferenceKeyword(key, value, root, visiting) {
+	if (Object.hasOwn(SCHEMA_MAP_KEYS$1, key) && isJsonObject(value)) {
+		const result = {};
+		for (const name in value) result[name] = dereferenceNode(value[name], root, visiting);
+		return result;
+	}
+	if ((Object.hasOwn(SCHEMA_ARRAY_KEYS$1, key) || key === "items") && Array.isArray(value)) return value.map((item) => dereferenceNode(item, root, visiting));
+	if (Object.hasOwn(SCHEMA_VALUE_KEYS$1, key)) return dereferenceNode(value, root, visiting);
+	return value;
+}
 /**
 * Resolve a JSON-pointer-style `$ref` against the root schema's `$defs`
 * or `definitions` block. Returns `undefined` for external or unresolvable refs.
 */
 function resolveLocalRef(ref, root) {
-	const match = /^#\/(\$defs|definitions)\/(.+)$/.exec(ref);
-	if (!match) return void 0;
-	const [, defsKey, name] = match;
+	const pointer = parseLocalRefPointer(ref);
+	if (pointer === void 0 || pointer.length !== 2) return void 0;
+	const defsKey = pointer[0];
+	if (defsKey !== "$defs" && defsKey !== "definitions") return void 0;
 	const defs = root[defsKey];
 	if (!isJsonObject(defs)) return void 0;
-	const resolved = defs[name];
+	const resolved = defs[pointer[1]];
 	return isJsonObject(resolved) ? resolved : void 0;
 }
 /**
@@ -535,7 +699,6 @@ function resolveLocalRef(ref, root) {
 */
 function dereferenceNode(node, root, visiting) {
 	if (!isJsonObject(node)) return node;
-	if (Array.isArray(node)) return node.map((item) => dereferenceNode(item, root, visiting));
 	const ref = node.$ref;
 	if (typeof ref === "string") {
 		if (visiting.has(ref)) return {};
@@ -545,25 +708,23 @@ function dereferenceNode(node, root, visiting) {
 		const inlined = dereferenceNode(resolved, root, visiting);
 		visiting.delete(ref);
 		let hasSiblings = false;
-		for (const k in node) if (k !== "$ref") {
+		for (const k in node) if (k !== "$ref" && k !== "$defs" && k !== "definitions") {
 			hasSiblings = true;
 			break;
 		}
 		if (!hasSiblings || !isJsonObject(inlined)) return inlined;
-		const merged = {
-			...inlined,
-			...node
-		};
-		delete merged.$ref;
+		const merged = { ...inlined };
+		for (const key in node) {
+			if (key === "$ref" || key === "$defs" || key === "definitions") continue;
+			merged[key] = dereferenceKeyword(key, node[key], root, visiting);
+		}
 		return merged;
 	}
 	const result = {};
 	for (const key in node) {
 		const value = node[key];
 		if (key === "$defs" || key === "definitions") continue;
-		if (Array.isArray(value)) result[key] = value.map((item) => dereferenceNode(item, root, visiting));
-		else if (isJsonObject(value)) result[key] = dereferenceNode(value, root, visiting);
-		else result[key] = value;
+		result[key] = dereferenceKeyword(key, value, root, visiting);
 	}
 	return result;
 }
@@ -583,7 +744,7 @@ function dereferenceJsonSchema(schema) {
 	return dereferenceNode(schema, schema, /* @__PURE__ */ new Set());
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/fields.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils/schema/fields.ts
 /**
 * Field classification sets for JSON Schema sanitization across providers.
 *
@@ -600,6 +761,8 @@ function dereferenceJsonSchema(schema) {
 */
 const UNSUPPORTED_SCHEMA_FIELDS = {
 	$schema: true,
+	$id: true,
+	$anchor: true,
 	$ref: true,
 	$defs: true,
 	$dynamicRef: true,
@@ -613,6 +776,11 @@ const UNSUPPORTED_SCHEMA_FIELDS = {
 	propertyNames: true,
 	minItems: true,
 	maxItems: true,
+	uniqueItems: true,
+	contains: true,
+	minContains: true,
+	maxContains: true,
+	additionalItems: true,
 	minLength: true,
 	maxLength: true,
 	minimum: true,
@@ -622,6 +790,9 @@ const UNSUPPORTED_SCHEMA_FIELDS = {
 	multipleOf: true,
 	pattern: true,
 	format: true,
+	contentEncoding: true,
+	contentMediaType: true,
+	contentSchema: true,
 	dependencies: true,
 	dependentSchemas: true,
 	dependentRequired: true,
@@ -791,6 +962,8 @@ const COMBINATOR_KEYS = [
 */
 const CCA_UNSUPPORTED_SCHEMA_FIELDS = {
 	$schema: true,
+	$id: true,
+	$anchor: true,
 	$ref: true,
 	$defs: true,
 	$dynamicRef: true,
@@ -799,13 +972,18 @@ const CCA_UNSUPPORTED_SCHEMA_FIELDS = {
 	deprecated: true,
 	readOnly: true,
 	writeOnly: true,
-	$comment: true
+	$comment: true,
+	uniqueItems: true,
+	contains: true,
+	minContains: true,
+	maxContains: true,
+	additionalItems: true,
+	contentEncoding: true,
+	contentMediaType: true,
+	contentSchema: true
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/meta-validator.ts
-function isPlainObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils/schema/meta-validator.ts
 const TYPE_NAMES = {
 	string: true,
 	number: true,
@@ -836,14 +1014,14 @@ function checkSchemaArray(value, epoch) {
 	return Array.isArray(value) && value.every((entry) => checkNode(entry, epoch));
 }
 function checkSchemaMap(value, epoch) {
-	if (!isPlainObject(value)) return false;
+	if (!isRecord(value)) return false;
 	for (const k in value) if (!checkNode(value[k], epoch)) return false;
 	return true;
 }
 /** Validate a single sub-schema node. */
 function checkNode(node, epoch) {
 	if (node === true || node === false) return true;
-	if (!isPlainObject(node)) return false;
+	if (!isRecord(node)) return false;
 	if (!once(node, epoch)) return true;
 	if ("type" in node && !checkTypeKeyword(node.type)) return false;
 	for (const key of [
@@ -893,7 +1071,7 @@ function checkNode(node, epoch) {
 	if ("dependentSchemas" in node && !checkSchemaMap(node.dependentSchemas, epoch)) return false;
 	if ("dependentRequired" in node) {
 		const value = node.dependentRequired;
-		if (!isPlainObject(value)) return false;
+		if (!isRecord(value)) return false;
 		for (const k in value) {
 			const entry = value[k];
 			if (!Array.isArray(entry) || !entry.every((item) => typeof item === "string")) return false;
@@ -943,7 +1121,7 @@ function isValidJsonSchema(schema) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/spill.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils/schema/spill.ts
 function formatSpillValue(value) {
 	return JSON.stringify(value);
 }
@@ -974,7 +1152,7 @@ function spillToDescription(node, entries, format = "spill") {
 	node.description = existing ? `${existing}\n\n${formatted}` : formatted;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/normalize.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils/schema/normalize.ts
 /**
 * Provider-specific JSON Schema normalization used in the request path.
 *
@@ -1144,6 +1322,45 @@ function preHandleNullFields(obj) {
 	} else out.anyOf = kept;
 	return out;
 }
+/**
+* Rewrites a multi-type `type` array (`["string", "array"]`) as one `anyOf`
+* branch per non-null type, each carrying only the keywords that constrain its
+* type. Collapsing to the first type instead narrows what the tool accepts and
+* strands the other types' keywords: Gemini rejects `items` beside
+* `type: "string"` with HTTP 400. A `null` member becomes `nullable: true`, as
+* in the scalar collapse. Returns `obj` itself when it has fewer than two
+* non-null types or already carries `anyOf`.
+*/
+function splitTypeArrayIntoAnyOf(obj) {
+	if (!Array.isArray(obj.type) || Array.isArray(obj.anyOf)) return obj;
+	const types = [];
+	for (const type of obj.type) if (typeof type === "string" && type !== "null" && !types.includes(type)) types.push(type);
+	if (types.length < 2) return obj;
+	const branches = types.map((type) => {
+		return {
+			schema: { type },
+			keys: CLOUD_CODE_ASSIST_TYPE_SPECIFIC_KEYS[type] ?? {}
+		};
+	});
+	const out = {};
+	for (const key in obj) {
+		if (!Object.hasOwn(obj, key) || key === "type") continue;
+		const value = obj[key];
+		if (!Object.hasOwn(ALL_CCA_TYPE_SPECIFIC_KEYS, key)) {
+			out[key] = value;
+			continue;
+		}
+		for (const branch of branches) if (Object.hasOwn(branch.keys, key)) branch.schema[key] = value;
+	}
+	if (obj.type.includes("null")) out.nullable = true;
+	out.anyOf = branches.map((branch) => branch.schema);
+	return out;
+}
+/** Deletes keywords that constrain a JSON type other than `type`, e.g. `items` on a string node. */
+function dropForeignTypeKeywords(schema, type) {
+	const allowed = CLOUD_CODE_ASSIST_TYPE_SPECIFIC_KEYS[type] ?? {};
+	for (const key in schema) if (Object.hasOwn(ALL_CCA_TYPE_SPECIFIC_KEYS, key) && !Object.hasOwn(allowed, key)) delete schema[key];
+}
 function outHasOwn(obj, key) {
 	return Object.hasOwn(obj, key);
 }
@@ -1198,6 +1415,7 @@ function normalizeSchemaNode(value, options) {
 }
 function normalizeSchemaObjectNode(value, options) {
 	let obj = options.normalizeFieldNames && !options.insideSchemaMap ? applySnakeCaseRenames(value) : value;
+	if (options.scalarizeTypeArrays && !options.insideSchemaMap) obj = splitTypeArrayIntoAnyOf(obj);
 	if (options.collapseNullFields && !options.insideSchemaMap) obj = preHandleNullFields(obj);
 	const result = {};
 	let spill;
@@ -1262,11 +1480,12 @@ function normalizeSchemaObjectNode(value, options) {
 			booleanIsSubschema: childKind === "schema"
 		}) : entry;
 	}
-	if (options.normalizeTypeArrayToNullable && Array.isArray(result.type)) {
+	if (options.scalarizeTypeArrays && Array.isArray(result.type)) {
 		const types = result.type.filter((t) => typeof t === "string");
 		const nonNull = types.filter((t) => t !== "null");
 		if (types.includes("null") && !options.stripNullableKeyword) result.nullable = true;
 		result.type = nonNull[0] ?? types[0];
+		if (typeof result.type === "string") dropForeignTypeKeywords(result, result.type);
 	}
 	if (constValue !== void 0) {
 		const existingEnum = Array.isArray(result.enum) ? result.enum : [];
@@ -1414,11 +1633,7 @@ function collapseMixedTypeCombinerVariants(schema, combiner) {
 	const chosenType = variantTypes.filter((t) => t !== "null")[0] ?? variantTypes[0];
 	nextSchema.type = chosenType;
 	const chosenTypeAllowedKeys = CLOUD_CODE_ASSIST_TYPE_SPECIFIC_KEYS[chosenType] ?? {};
-	for (const key in nextSchema) {
-		if (!Object.hasOwn(nextSchema, key)) continue;
-		if (key === "type") continue;
-		if (Object.hasOwn(ALL_CCA_TYPE_SPECIFIC_KEYS, key) && !Object.hasOwn(chosenTypeAllowedKeys, key) && !Object.hasOwn(CLOUD_CODE_ASSIST_SHARED_SCHEMA_KEYS, key)) delete nextSchema[key];
-	}
+	dropForeignTypeKeywords(nextSchema, chosenType);
 	for (const key in mergedVariantFields) {
 		if (!Object.hasOwn(mergedVariantFields, key)) continue;
 		if (!Object.hasOwn(chosenTypeAllowedKeys, key) && !Object.hasOwn(CLOUD_CODE_ASSIST_SHARED_SCHEMA_KEYS, key)) continue;
@@ -1811,7 +2026,7 @@ function normalizeSchemaForGoogle(value) {
 		unsupportedFields: isGoogleUnsupportedSchemaField,
 		normalizeFieldNames: true,
 		collapseNullFields: true,
-		normalizeTypeArrayToNullable: true,
+		scalarizeTypeArrays: true,
 		stripNullableKeyword: false,
 		autoPropertyOrdering: true,
 		ensureObjectProperties: true,
@@ -1833,7 +2048,7 @@ function normalizeSchemaForCCA(value) {
 		unsupportedFields: isGoogleUnsupportedSchemaField,
 		normalizeFieldNames: true,
 		collapseNullFields: false,
-		normalizeTypeArrayToNullable: true,
+		scalarizeTypeArrays: true,
 		stripNullableKeyword: true,
 		autoPropertyOrdering: false,
 		ensureObjectProperties: true,
@@ -1868,8 +2083,9 @@ function normalizeSchemaForCCA(value) {
 *    rejected; collapse to `enum` with an inferred scalar `type`.
 *  - `oneOf` is not an MFJS combinator (only `anyOf` is); residual `oneOf` is
 *    folded into `anyOf`.
-*  - `type` must be a scalar string; `type: [...]` arrays are reduced to a
-*    single scalar (the `null` branch is dropped — `nullable` is unsupported).
+*  - `type` must be a scalar string; `["T", "null"]` reduces to `T` (the
+*    `null` member is dropped — `nullable` is unsupported) and a multi-type
+*    array becomes one typed `anyOf` branch per type.
 *  - Enum-bearing nodes get an inferred `type` (the idiomatic MFJS form; a bare
 *    `enum` is valid too) so `anyOf` branches always carry a `type`.
 *  - Validation/decorative keywords (`minItems`, `maxItems`, `maxLength`,
@@ -1892,7 +2108,7 @@ function normalizeSchemaForMoonshot(value) {
 		unsupportedFields: isMoonshotUnsupportedSchemaField,
 		normalizeFieldNames: false,
 		collapseNullFields: false,
-		normalizeTypeArrayToNullable: true,
+		scalarizeTypeArrays: true,
 		stripNullableKeyword: true,
 		autoPropertyOrdering: false,
 		ensureObjectProperties: false,
@@ -2295,12 +2511,12 @@ function inferStrictPrimitiveTypeFromEnumOrConst(node) {
 	return inferred;
 }
 /**
-* Per-schema-object memoization slot. The result of `tryEnforceStrictSchema`
-* is stamped directly onto the input via `stamp(target, kStrictSchema, …)`
-* so repeated calls (different providers, retries, batching) reuse the same
+* Per-schema-object memoization key. The result of `tryEnforceStrictSchema`
+* is memoized against the input via `stamp(target, kStrictSchema, …)` so
+* repeated calls (different providers, retries, batching) reuse the same
 * computed pair without re-walking the tree.
 */
-const kStrictSchema = Symbol("pi.schema.strict");
+const kStrictSchema = Symbol("omp.schema.strict");
 /**
 * A boolean schema (`true`/`false`) or the empty object schema `{}`: an
 * unconstrained branch with no declared type. Strict providers (OpenAI/Codex)
@@ -2671,24 +2887,21 @@ function tryEnforceStrictSchema(schema) {
 	});
 }
 /**
-* Resolve a JSON-pointer-style `$ref` against the root schema. Mirrors the
-* OpenAI SDK's `resolve_ref` helper: only local refs starting with `#/` are
-* supported, and each segment must dereference to a dictionary.
-* Cite: openai-python/src/openai/lib/_pydantic.py:118-129
+* Resolve a URI-fragment JSON Pointer against the root schema. Each segment
+* must dereference to a dictionary, as in the OpenAI SDK's `resolve_ref` helper.
 */
 function resolveStrictRef(root, ref) {
-	if (!ref.startsWith("#/")) return void 0;
-	const segments = ref.slice(2).split("/");
+	const pointer = parseLocalRefPointer(ref);
+	if (pointer === void 0 || pointer.length === 0) return void 0;
 	let cursor = root;
-	for (const raw of segments) {
+	for (const segment of pointer) {
 		if (!isJsonObject(cursor)) return void 0;
-		const segment = raw.replace(/~1/g, "/").replace(/~0/g, "~");
 		cursor = cursor[segment];
 	}
 	return isJsonObject(cursor) ? cursor : void 0;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/adapt.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils/schema/adapt.ts
 /**
 * Set when callers want to globally bypass OpenAI strict-mode enforcement
 * (e.g. for debugging a provider that misreports strict support, or when
@@ -2721,7 +2934,212 @@ function adaptSchemaForStrict(schema, strict) {
 ({ ...UNSUPPORTED_SCHEMA_FIELDS });
 ({ ...CCA_UNSUPPORTED_SCHEMA_FIELDS });
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/wire.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils/schema/foundation-models.ts
+/**
+* Lowers tool JSON Schemas into the dialect Apple's `GenerationSchema` Codable
+* decoder accepts (Foundation Models, `apple-fm` provider).
+*
+* The decoder is strict: every object needs `title`, `x-order` (which also
+* selects the generated properties), `required`, and
+* `additionalProperties: false`; `anyOf` needs a `title`; a node must carry
+* `type`, `const`, `$ref`, or `anyOf`. Constructs it cannot express — free-form
+* maps, open `{}` subschemas, tuples, mixed-type enums, `allOf` — are generated
+* as JSON-encoded strings instead, and {@link decodeFoundationModelsArguments}
+* parses those back so tools receive the arguments their schema describes.
+*
+* @example
+* const { schema, encodedPaths } = toFoundationModelsSchema(toolWireSchema(tool), tool.name);
+* // …model responds with arguments…
+* const args = decodeFoundationModelsArguments(rawArgs, encodedPaths);
+*/
+const ENCODED_SUFFIX = "(JSON-encoded value)";
+/** Converts a tool's wire JSON Schema into Foundation Models' dialect. */
+function toFoundationModelsSchema(schema, name) {
+	const encodedPaths = [];
+	const root = dereferenceJsonSchema(schema);
+	const lowered = lower(root, titleOf(name), [], encodedPaths);
+	if (lowered?.type === "object") return {
+		schema: lowered,
+		encodedPaths
+	};
+	return {
+		schema: object(titleOf(name), {}, [], describe(root)),
+		encodedPaths: []
+	};
+}
+/** Parses the JSON-encoded argument values produced for {@link FoundationModelsSchema.encodedPaths}. */
+function decodeFoundationModelsArguments(args, encodedPaths) {
+	for (const path of encodedPaths) decodeAt(args, path, 0);
+	return args;
+}
+function decodeAt(container, path, index) {
+	const key = path[index];
+	const last = index === path.length - 1;
+	if (key === "*") {
+		if (!Array.isArray(container)) return;
+		for (let i = 0; i < container.length; i++) if (last) container[i] = parseEncoded(container[i]);
+		else decodeAt(container[i], path, index + 1);
+		return;
+	}
+	if (!isJsonObject(container) || !Object.hasOwn(container, key)) return;
+	if (last) container[key] = parseEncoded(container[key]);
+	else decodeAt(container[key], path, index + 1);
+}
+function parseEncoded(value) {
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+/**
+* Lowers one subschema. Returns `undefined` when the node is not expressible;
+* the caller then encodes it as a JSON string when `encoded` is non-null, or
+* propagates the failure (inside `anyOf`, where an encoded branch would make
+* decoding ambiguous).
+*/
+function lower(node, title, path, encoded) {
+	if (!isJsonObject(node)) return void 0;
+	const description = describe(node);
+	const lowered = lowerShape(node, title, path, encoded);
+	if (lowered && description !== void 0 && lowered.description === void 0) lowered.description = description;
+	return lowered;
+}
+function lowerShape(node, title, path, encoded) {
+	if (Object.hasOwn(node, "const")) return typeof node.const === "string" ? { const: node.const } : void 0;
+	if (Array.isArray(node.enum)) return node.enum.length > 0 && node.enum.every((value) => typeof value === "string") ? {
+		type: "string",
+		enum: node.enum
+	} : void 0;
+	const branches = [...Array.isArray(node.anyOf) ? node.anyOf : [], ...Array.isArray(node.oneOf) ? node.oneOf : []];
+	if (branches.length > 0) return lowerUnion(node, branches, title, path, encoded);
+	if (Array.isArray(node.allOf)) {
+		if (node.allOf.length !== 1 || !isJsonObject(node.allOf[0])) return void 0;
+		const { allOf: _, ...rest } = node;
+		return lower({
+			...rest,
+			...node.allOf[0]
+		}, title, path, encoded);
+	}
+	if (Array.isArray(node.type)) {
+		const types = [...new Set(node.type.filter((type) => type !== "null"))];
+		if (types.length === 0) return { type: "null" };
+		if (types.length === 1) return lowerShape({
+			...node,
+			type: types[0]
+		}, title, path, encoded);
+		return lowerUnion(node, types.map((type) => ({
+			...node,
+			type
+		})), title, path, encoded);
+	}
+	const type = node.type ?? (isJsonObject(node.properties) ? "object" : void 0);
+	switch (type) {
+		case "string":
+		case "boolean":
+		case "null": return { type };
+		case "integer":
+		case "number": {
+			const out = { type };
+			if (typeof node.minimum === "number") out.minimum = node.minimum;
+			if (typeof node.maximum === "number") out.maximum = node.maximum;
+			return out;
+		}
+		case "array": return lowerArray(node, title, path, encoded);
+		case "object": return lowerObject(node, title, path, encoded);
+		default: return;
+	}
+}
+function lowerUnion(node, branches, title, path, encoded) {
+	const { anyOf: _a, oneOf: _o, type: _t, ...shared } = node;
+	const options = branches.filter((branch) => !(isJsonObject(branch) && branch.type === "null"));
+	if (options.length === 0) return { type: "null" };
+	if (options.length === 1) return isJsonObject(options[0]) ? lower({
+		...shared,
+		...options[0]
+	}, title, path, encoded) : void 0;
+	const literals = options.flatMap((option) => stringLiterals(option) ?? [null]);
+	if (!literals.includes(null)) return {
+		type: "string",
+		enum: [...new Set(literals)]
+	};
+	const anyOf = [];
+	for (let i = 0; i < options.length; i++) {
+		const option = options[i];
+		const lowered = lower(isJsonObject(option) ? {
+			...shared,
+			...option
+		} : option, `${title}_${i}`, path, null);
+		if (!lowered) return void 0;
+		delete lowered.description;
+		anyOf.push(lowered);
+	}
+	return {
+		title,
+		anyOf
+	};
+}
+function stringLiterals(node) {
+	if (!isJsonObject(node)) return void 0;
+	if (typeof node.const === "string") return [node.const];
+	if (Array.isArray(node.enum) && node.enum.every((value) => typeof value === "string")) return node.enum;
+}
+function lowerArray(node, title, path, encoded) {
+	if (Array.isArray(node.items) || Array.isArray(node.prefixItems)) return void 0;
+	const items = child(node.items ?? true, `${title}_item`, [...path, "*"], encoded);
+	if (!items) return void 0;
+	const out = {
+		type: "array",
+		items
+	};
+	if (typeof node.minItems === "number") out.minItems = node.minItems;
+	if (typeof node.maxItems === "number") out.maxItems = node.maxItems;
+	return out;
+}
+function lowerObject(node, title, path, encoded) {
+	const properties = isJsonObject(node.properties) ? node.properties : {};
+	const keys = Object.keys(properties);
+	if (keys.length === 0 && node.additionalProperties !== false) return void 0;
+	const lowered = {};
+	for (const key of keys) {
+		const property = child(properties[key], `${title}_${titleOf(key)}`, [...path, key], encoded);
+		if (!property) return void 0;
+		lowered[key] = property;
+	}
+	return object(title, lowered, Array.isArray(node.required) ? node.required.filter((key) => typeof key === "string" && Object.hasOwn(lowered, key)) : [], void 0);
+}
+/** Lowers a nested subschema, falling back to a JSON-encoded string when allowed. */
+function child(node, title, path, encoded) {
+	const lowered = lower(node, title, path, encoded);
+	if (lowered || !encoded) return lowered;
+	encoded.push(path);
+	const description = isJsonObject(node) ? describe(node) : void 0;
+	return {
+		type: "string",
+		description: description ? `${description} ${ENCODED_SUFFIX}` : ENCODED_SUFFIX
+	};
+}
+function object(title, properties, required, description) {
+	const out = {
+		type: "object",
+		title,
+		properties,
+		required,
+		"x-order": Object.keys(properties),
+		additionalProperties: false
+	};
+	if (description !== void 0) out.description = description;
+	return out;
+}
+function describe(node) {
+	return isJsonObject(node) && typeof node.description === "string" ? node.description : void 0;
+}
+function titleOf(name) {
+	return name.replace(/[^A-Za-z0-9_]/g, "_");
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils/schema/wire.ts
 /**
 * True when `value` is a live ArkType schema instance.
 *
@@ -2733,11 +3151,11 @@ function isArkSchema(value) {
 }
 function isArkJsonAst(value) {
 	if (Array.isArray(value)) return value.some(isArkJsonAst);
-	if (!isSchemaRecord(value)) return false;
+	if (!isRecord(value)) return false;
 	if (typeof value.domain === "string" || Object.hasOwn(value, "unit")) return true;
 	if (value.proto === "Array" && Object.hasOwn(value, "sequence")) return true;
 	const required = value.required;
-	return Array.isArray(required) && required.some((entry) => isSchemaRecord(entry) && typeof entry.key === "string" && "value" in entry);
+	return Array.isArray(required) && required.some((entry) => isRecord(entry) && typeof entry.key === "string" && "value" in entry);
 }
 function parseArkObjectKey(key) {
 	const match = /^(.*?)\s*\/\*\*\s*([\s\S]*?)\s*\*\/\s*$/.exec(key);
@@ -2749,7 +3167,7 @@ function parseArkObjectKey(key) {
 }
 function withArkKeyDescription(schema, description) {
 	if (!description) return schema;
-	if (isSchemaRecord(schema)) {
+	if (isRecord(schema)) {
 		if (typeof schema.description !== "string") schema.description = description;
 		return schema;
 	}
@@ -2769,10 +3187,10 @@ function arkJsonAstToWire(value) {
 		default: return {};
 	}
 	if (Array.isArray(value)) {
-		if (value.every((item) => isSchemaRecord(item) && Object.hasOwn(item, "unit"))) return { enum: value.map((item) => item.unit) };
+		if (value.every((item) => isRecord(item) && Object.hasOwn(item, "unit"))) return { enum: value.map((item) => item.unit) };
 		return { anyOf: value.map(arkJsonAstToWire) };
 	}
-	if (!isSchemaRecord(value)) return {};
+	if (!isRecord(value)) return {};
 	if (Object.hasOwn(value, "unit")) return { const: value.unit };
 	if (value.proto === "Array" && Object.hasOwn(value, "sequence")) return {
 		type: "array",
@@ -2782,7 +3200,7 @@ function arkJsonAstToWire(value) {
 		const properties = {};
 		const required = [];
 		const addEntry = (entry, isRequired) => {
-			if (!isSchemaRecord(entry) || typeof entry.key !== "string" || !("value" in entry)) return;
+			if (!isRecord(entry) || typeof entry.key !== "string" || !("value" in entry)) return;
 			const key = parseArkObjectKey(entry.key);
 			properties[key.name] = withArkKeyDescription(arkJsonAstToWire(entry.value), key.description);
 			if (isRequired) required.push(key.name);
@@ -2799,9 +3217,9 @@ function arkJsonAstToWire(value) {
 	if (typeof value.domain === "string") return { type: value.domain };
 	return {};
 }
-/** Symbol-stamped caches keyed by schema object identity. */
-const kJsonWireSchema = Symbol("pi.schema.json.wire");
-const kArkWireSchema = Symbol("pi.schema.ark.wire");
+/** `stamp` cache keys; the entries themselves live in a weak side table keyed by schema identity. */
+const kJsonWireSchema = Symbol("omp.schema.json.wire");
+const kArkWireSchema = Symbol("omp.schema.ark.wire");
 function postProcessJsonSchema(schema) {
 	walk(schema);
 	normalizeArkPropertyComments(schema);
@@ -2835,9 +3253,6 @@ const SCHEMA_DEFINING_SIBLING_KEYS = /* @__PURE__ */ new Set([
 	"unevaluatedItems",
 	"unevaluatedProperties"
 ]);
-function isSchemaRecord(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
 function hasSchemaDefiningSibling(schema) {
 	for (const key in schema) if (key !== "anyOf" && SCHEMA_DEFINING_SIBLING_KEYS.has(key)) return true;
 	return false;
@@ -2868,7 +3283,7 @@ function rewriteNullableScalarAnyOf(schema) {
 	let scalarType;
 	let sawNull = false;
 	for (const variant of variants) {
-		if (!isSchemaRecord(variant)) return;
+		if (!isRecord(variant)) return;
 		if (isNullVariant(variant)) {
 			if (sawNull) return;
 			sawNull = true;
@@ -2884,7 +3299,7 @@ function rewriteNullableScalarAnyOf(schema) {
 	schema.type = [scalarType, "null"];
 }
 function isExclusiveRequiredBranch(branch) {
-	if (!isSchemaRecord(branch)) return false;
+	if (!isRecord(branch)) return false;
 	if (Object.hasOwn(branch, "type")) return false;
 	if (!Array.isArray(branch.required) || branch.required.length === 0) return false;
 	if (!branch.required.every((name) => typeof name === "string" && name.length > 0)) return false;
@@ -2905,7 +3320,7 @@ function flattenExclusiveRequiredRootUnion(schema) {
 	if (!unionKey) return schema;
 	const union = schema[unionKey];
 	if (!Array.isArray(union) || union.length === 0) return schema;
-	if (!(schema.type === "object" || Array.isArray(schema.type) && schema.type.includes("object")) && !isSchemaRecord(schema.properties)) return schema;
+	if (!(schema.type === "object" || Array.isArray(schema.type) && schema.type.includes("object")) && !isRecord(schema.properties)) return schema;
 	if (!union.every(isExclusiveRequiredBranch)) return schema;
 	const flattened = { ...schema };
 	delete flattened[unionKey];
@@ -2943,10 +3358,10 @@ function normalizeArkPropertyComments(node) {
 		for (const child of node) normalizeArkPropertyComments(child);
 		return;
 	}
-	if (!isSchemaRecord(node)) return;
+	if (!isRecord(node)) return;
 	const obj = node;
 	const properties = obj.properties;
-	if (isSchemaRecord(properties)) {
+	if (isRecord(properties)) {
 		const required = Array.isArray(obj.required) ? obj.required : void 0;
 		if (required) obj.required = required.map((key) => typeof key === "string" ? parseArkObjectKey(key).name : key);
 		for (const key of Object.keys(properties)) {
@@ -2965,7 +3380,7 @@ function normalizeArkPropertyComments(node) {
 	for (const mapKey of SCHEMA_MAP_KEYS) {
 		if (mapKey === "properties") continue;
 		const map = obj[mapKey];
-		if (isSchemaRecord(map)) for (const key in map) normalizeArkPropertyComments(map[key]);
+		if (isRecord(map)) for (const key in map) normalizeArkPropertyComments(map[key]);
 	}
 	for (const arrayKey of SCHEMA_ARRAY_KEYS) {
 		const array = obj[arrayKey];
@@ -3045,7 +3460,7 @@ function collapseConstUnionAnyOf(obj) {
 	let branchDescription;
 	let describedCount = 0;
 	for (const variant of variants) {
-		if (!isSchemaRecord(variant) || !Object.hasOwn(variant, "const")) return;
+		if (!isRecord(variant) || !Object.hasOwn(variant, "const")) return;
 		for (const key in variant) if (key !== "const" && key !== "description") return;
 		const desc = variant.description;
 		if (typeof desc === "string") {
@@ -3173,7 +3588,7 @@ function pruneArkUndefinedUnionBranches(node) {
 		const concrete = branches.filter((branch) => !isUnconstrainedSchema(branch));
 		if (concrete.length === branches.length || concrete.length === 0) continue;
 		const only = concrete.length === 1 ? concrete[0] : void 0;
-		if (only !== void 0 && isSchemaRecord(only)) {
+		if (only !== void 0 && isRecord(only)) {
 			delete obj[unionKey];
 			for (const key in only) if (!(key in obj)) obj[key] = only[key];
 		} else obj[unionKey] = concrete;
@@ -3213,11 +3628,11 @@ function toolWireSchema(tool) {
 	const params = tool.parameters;
 	if (isArkSchema(params)) return arkToWireSchema(params);
 	return stamp(params, kJsonWireSchema, (p) => {
-		return postProcessJsonSchema(upgradeJsonSchemaTo202012(isArkJsonAst(p) ? arkJsonAstToWire(p) : p));
+		return postProcessJsonSchema(upgradeJsonSchemaTo202012(isArkJsonAst(p) ? arkJsonAstToWire(p) : structuredCloneJSON(p)));
 	});
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/coercion.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/coercion.ts
 function buildArgShapes(tools = []) {
 	const shapes = /* @__PURE__ */ new Map();
 	for (const tool of tools) {
@@ -3315,8 +3730,23 @@ function normalizeKimiFunctionName(rawId) {
 function asRecord(value) {
 	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
+/**
+* Extract a COMPLETE tool name from a partial in-band JSON body.
+* Returns undefined until the name string is fully closed, so streaming
+* scanners never start a tool call under a truncated name.
+*/
+function parseCompleteToolName(body) {
+	const match = /^\s*\{\s*"name"\s*:\s*("(?:\\.|[^"\\])*")/.exec(body);
+	if (!match) return void 0;
+	try {
+		const name = JSON.parse(match[1]);
+		return typeof name === "string" && name.length > 0 ? name : void 0;
+	} catch {
+		return;
+	}
+}
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/rendering.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/rendering.ts
 function renderToolResponseResults(results) {
 	return results.map((result) => `<tool_response>\n${result.text}\n</tool_response>`).join("\n");
 }
@@ -3347,8 +3777,19 @@ function pyString(value) {
 function escapeXmlAttr(value) {
 	return value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
-function escapeXmlText(value) {
-	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+/** Render one Anthropic-style `<invoke>`; declared string args stay raw, everything else is JSON. */
+function renderInvoke(call, shape) {
+	let body = `<invoke name="${escapeXmlAttr(call.name)}">`;
+	for (const key in call.arguments) {
+		const value = call.arguments[key];
+		const rendered = shape?.stringArgs.has(key) === true && typeof value === "string" ? value : stringifyJson(value);
+		body += `<parameter name="${escapeXmlAttr(key)}">${rendered}</parameter>`;
+	}
+	return `${body}</invoke>`;
+}
+function renderInvokes(calls, tools) {
+	const shapes = buildArgShapes(tools);
+	return calls.map((call) => renderInvoke(call, shapes.get(call.name))).join("\n");
 }
 function renderChatMlTranscript(messages, options, config) {
 	if (messages.length === 0) return "";
@@ -3504,7 +3945,7 @@ function appendLegacySegment(out, segment) {
 	return `${out}\n\n${segment}`;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/anthropic.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/anthropic.ts
 const MAX_PARTIAL_TAG_LENGTH = 256;
 const MAX_PARAMETER_VALUE_LENGTH = 1e6;
 const WRAPPER_TAGS = {
@@ -3976,11 +4417,11 @@ function couldBeTagPrefix(buffer, prefixes) {
 	return false;
 }
 function renderToolCall$10(call, options = {}) {
-	return renderInvoke$2(call, buildArgShapes(options.tools).get(call.name));
+	return renderInvoke(call, buildArgShapes(options.tools).get(call.name));
 }
 function renderAssistantToolCalls$10(calls, options = {}) {
 	if (calls.length === 0) return "";
-	return `<function_calls>\n${renderInvokes$2(calls, options.tools ?? [])}\n</function_calls>`;
+	return `<function_calls>\n${renderInvokes(calls, options.tools ?? [])}\n</function_calls>`;
 }
 function renderToolResults$10(results) {
 	return `<function_results>\n${results.map((result) => {
@@ -3999,19 +4440,6 @@ function renderTranscript$10(messages, options = {}) {
 		renderResults: renderToolResults$10
 	});
 }
-function renderInvoke$2(call, shape) {
-	let body = `<invoke name="${escapeXmlAttr(call.name)}">`;
-	for (const key in call.arguments) {
-		const value = call.arguments[key];
-		const rendered = shape?.stringArgs.has(key) === true && typeof value === "string" ? value : stringifyJson(value);
-		body += `<parameter name="${escapeXmlAttr(key)}">${rendered}</parameter>`;
-	}
-	return `${body}</invoke>`;
-}
-function renderInvokes$2(calls, tools) {
-	const shapes = buildArgShapes(tools);
-	return calls.map((call) => renderInvoke$2(call, shapes.get(call.name))).join("\n");
-}
 const definition$10 = {
 	dialect: "anthropic",
 	prompt: anthropic_default,
@@ -4023,10 +4451,92 @@ const definition$10 = {
 	renderTranscript: renderTranscript$10
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/deepseek.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils/tool-call-arguments.ts
+/** Final arguments must not reuse the streaming parser's auto-closed preview. */
+function parseToolCallArguments(json) {
+	if (!json?.trim()) return {};
+	try {
+		return parseJsonWithRepair(json);
+	} catch (error) {
+		return invalidToolCallArguments(json, error);
+	}
+}
+/**
+* Native Responses `function_call.arguments` to persist for replay.
+*
+* {@link parseToolCallArguments} repairs some invalid JSON (e.g. `"name": ,`) and the tool runs with the
+* repaired value; replay must carry what was executed (#14155), not the {@link invalidToolCallArguments}
+* diagnostic it substitutes for stored arguments that do not parse (#15568).
+* Returns `raw` when it already parses or the arguments were unrepairable, else the executed arguments.
+*/
+function replayableToolCallArguments(raw, executed) {
+	try {
+		JSON.parse(raw);
+		return raw;
+	} catch {
+		return executed && typeof executed === "object" && "__parseError" in executed ? raw : JSON.stringify(executed);
+	}
+}
+const TRUNCATED_SUFFIX = /… \[truncated \d+ chars\]$/;
+/** Bound raw argument text for a diagnostic. Text this function already bounded is returned unchanged. */
+function boundRawToolArguments(raw) {
+	if (raw.length <= 512) return raw;
+	if (TRUNCATED_SUFFIX.exec(raw)?.index === 512) return raw;
+	return `${raw.slice(0, 512)}… [truncated ${raw.length - 512} chars]`;
+}
+/** Preserve a bounded diagnostic, never any partially recovered executable keys. */
+function invalidToolCallArguments(raw, error) {
+	return {
+		__parseError: error instanceof Error ? error.message : String(error),
+		__rawJson: boundRawToolArguments(raw)
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/deepseek.md
 var deepseek_default = "## Format guide\n\nA tool call wraps the function name, a separator, and one JSON object of arguments in fixed tokens. Emit them exactly:\n\n```text\n<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>tool_name<｜tool▁sep｜>{\"arg\":\"value\"}<｜tool▁call▁end｜><｜tool▁calls▁end｜>\n```\n\nResults arrive as output tokens:\n\n```text\n<｜tool▁output▁begin｜>verbatim tool result<｜tool▁output▁end｜>\n```\n\n## Rules\n\n- Use `｜` (U+FF5C) and `▁` (U+2581) exactly.\n- Tool name MUST match an available function; arguments are one valid JSON object.\n- Argument string values use only normal JSON string escaping (`\\\"`, `\\\\`, `\\n`); never HTML-escape their contents — write `a & b`, not `a &amp; b`.\n- NEVER wrap arguments in Markdown fences; NEVER emit a `type` field or `function` prefix.\n- Multiple calls chain `<｜tool▁call▁begin｜>...<｜tool▁call▁end｜>` directly — no separators, spaces, or newlines between them.\n- Private reasoning, when needed, goes in `<think>...</think>` before the tokens.\n- Read each output token in call order. NEVER emit output tokens yourself.\n- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at \"Let's run `cargo clippy`\" with no `<｜tool▁call▁begin｜>` emitted). Write the complete call, THEN the stop sequence, THEN halt.\n";
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/deepseek.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/terminator-wait.ts
+/**
+* Fast path for in-band scanners that sit inside a body waiting for one fixed
+* terminator (a tool-call close tag) and emit nothing until it arrives.
+*
+* Appending each delta to the scanner's string buffer and calling `indexOf` on
+* it flattens the growing rope on every delta, so a long in-band tool call cost
+* O(n²) copying and scanning. While armed, deltas are set aside and only the new
+* text plus the terminator-length overlap with what came before is searched;
+* the buffer is rebuilt once, when the terminator shows up or the stream ends.
+*/
+var TerminatorWait = class {
+	#terminator = "";
+	#tail = "";
+	#parts = [];
+	/** Start deferring; `buffered` is the scanner's pending body, known not to contain `terminator`. */
+	arm(terminator, buffered) {
+		this.#terminator = terminator;
+		this.#tail = buffered.slice(Math.max(0, buffered.length - (terminator.length - 1)));
+		this.#parts.length = 0;
+	}
+	/** Take `text` while the terminator is still absent; false means the caller must {@link release} and scan. */
+	absorb(text) {
+		if (this.#terminator.length === 0) return false;
+		const window = this.#tail + text;
+		if (window.includes(this.#terminator)) return false;
+		this.#parts.push(text);
+		this.#tail = window.slice(Math.max(0, window.length - (this.#terminator.length - 1)));
+		return true;
+	}
+	/** Stop deferring and return `buffered` with every absorbed delta appended. */
+	release(buffered) {
+		this.#terminator = "";
+		this.#tail = "";
+		if (this.#parts.length === 0) return buffered;
+		const joined = buffered + this.#parts.join("");
+		this.#parts.length = 0;
+		return joined;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/deepseek.ts
 const DEEPSEEK_TOOL_CALLS_BEGIN = "<｜tool▁calls▁begin｜>";
 const DEEPSEEK_TOOL_CALLS_END = "<｜tool▁calls▁end｜>";
 const DEEPSEEK_TOOL_CALL_BEGIN = "<｜tool▁call▁begin｜>";
@@ -4087,7 +4597,90 @@ const OUTSIDE_TOKENS = [
 	...DSML_ORPHAN_CLOSE_TOKENS,
 	...CONTROL_TOKENS
 ];
-const SECTION_TOKENS = [DEEPSEEK_TOOL_CALL_BEGIN, DEEPSEEK_TOOL_CALLS_END];
+/** Outside-state tokens dropped from visible text (closers with nothing open, template control tokens). */
+const OUTSIDE_DROPPED_TOKENS = Object.fromEntries([
+	DEEPSEEK_TOOL_CALLS_END,
+	THINK_CLOSE$4,
+	DSML_TOOL_CALLS_CLOSE_FULLWIDTH,
+	DSML_TOOL_CALLS_CLOSE_ASCII,
+	...CONTROL_TOKENS
+].map((token) => [token, true]));
+const TEMPLATE_TOKEN_SPELLING = /<(｜?)([A-Za-z]+(?:[▁_][A-Za-z]+)*)(｜?)>/gu;
+const TEMPLATE_TOKEN_SPELLING_AT_START = new RegExp(TEMPLATE_TOKEN_SPELLING.source, "uy");
+const TEMPLATE_TOKEN_PARTIAL = /^<｜?([A-Za-z▁_]*)(｜?)$/u;
+const TEMPLATE_TOKEN_BAR = "｜";
+/**
+* Canonical template token by spelling-independent key (`tool_calls_begin`).
+* A Map, not a Record: keys come from model output, so `constructor` and friends
+* must not resolve through the prototype.
+*/
+const TEMPLATE_TOKEN_BY_KEY = new Map([
+	DEEPSEEK_TOOL_CALLS_BEGIN,
+	DEEPSEEK_TOOL_CALLS_END,
+	DEEPSEEK_TOOL_CALL_BEGIN,
+	DEEPSEEK_TOOL_CALL_END,
+	DEEPSEEK_TOOL_SEPARATOR,
+	...CONTROL_TOKENS
+].flatMap((token) => {
+	const name = /^<｜([A-Za-z]+(?:▁[A-Za-z]+)*)｜>$/u.exec(token)?.[1];
+	return name === void 0 ? [] : [[templateTokenKey(name), token]];
+}));
+const TEMPLATE_TOKEN_KEYS = [...TEMPLATE_TOKEN_BY_KEY.keys()];
+const TEMPLATE_TOKEN_MAX_SPELLING = Math.max(...TEMPLATE_TOKEN_KEYS.map((key) => key.length)) + 4;
+const OUTSIDE_TEMPLATE_TOKENS = Object.fromEntries([
+	DEEPSEEK_TOOL_CALLS_BEGIN,
+	DEEPSEEK_TOOL_CALLS_END,
+	DEEPSEEK_TOOL_CALL_BEGIN,
+	...CONTROL_TOKENS
+].map((token) => [token, true]));
+const SEPARATOR_TOKENS = { [DEEPSEEK_TOOL_SEPARATOR]: true };
+const ARGS_TERMINATOR_TOKENS = {
+	[DEEPSEEK_TOOL_CALL_END]: true,
+	[DEEPSEEK_TOOL_CALLS_END]: true,
+	[DEEPSEEK_TOOL_CALL_BEGIN]: true
+};
+function templateTokenKey(name) {
+	return name.replaceAll("▁", "_");
+}
+function resolveTemplateSpelling(match) {
+	if (match[1].length === 0 && match[3].length === 0) return void 0;
+	return TEMPLATE_TOKEN_BY_KEY.get(templateTokenKey(match[2]));
+}
+/**
+* Find the earliest of `tokens` in `text` at or after `from`, in its canonical
+* spelling or any re-spelling described at {@link TEMPLATE_TOKEN_SPELLING}.
+*/
+function findDeepSeekTemplateToken(text, tokens, from = 0) {
+	TEMPLATE_TOKEN_SPELLING.lastIndex = from;
+	for (let match = TEMPLATE_TOKEN_SPELLING.exec(text); match; match = TEMPLATE_TOKEN_SPELLING.exec(text)) {
+		const token = resolveTemplateSpelling(match);
+		if (token !== void 0 && tokens[token]) return {
+			token,
+			raw: match[0],
+			index: match.index
+		};
+	}
+}
+function templateTokenAtStart(text) {
+	TEMPLATE_TOKEN_SPELLING_AT_START.lastIndex = 0;
+	const match = TEMPLATE_TOKEN_SPELLING_AT_START.exec(text);
+	if (!match) return void 0;
+	const token = resolveTemplateSpelling(match);
+	return token === void 0 ? void 0 : {
+		token,
+		raw: match[0],
+		index: 0
+	};
+}
+/** Length of a trailing fragment of `text` that could still complete into a template token spelling. */
+function templateTokenPartialLength(text) {
+	const start = text.lastIndexOf("<");
+	if (start === -1 || text.length - start >= TEMPLATE_TOKEN_MAX_SPELLING) return 0;
+	const match = TEMPLATE_TOKEN_PARTIAL.exec(text.slice(start));
+	if (!match) return 0;
+	const key = templateTokenKey(match[1]);
+	return (match[2].length > 0 ? TEMPLATE_TOKEN_BY_KEY.has(key) : TEMPLATE_TOKEN_KEYS.some((known) => known.startsWith(key))) ? text.length - start : 0;
+}
 const DSML_SECTION_TOKENS = [
 	DSML_TOOL_CALLS_CLOSE_FULLWIDTH,
 	DSML_TOOL_CALLS_CLOSE_ASCII,
@@ -4101,6 +4694,67 @@ const DSML_INVOKE_TOKENS = [
 	"<|DSML|parameter"
 ];
 const DSML_PARAMETER_CLOSE_TOKENS = [DSML_PARAMETER_CLOSE_FULLWIDTH, DSML_PARAMETER_CLOSE_ASCII];
+const BARE_DSML_OPEN = /<[｜|]DSML[｜|](?:invoke|parameter)\b/u;
+const OUTSIDE_CODE = {
+	fence: 0,
+	run: 0,
+	newline: false
+};
+const BACKTICK = 96;
+const LINE_FEED = 10;
+/** A finished backtick run opens code, or closes it when it matches the opening run. */
+function settleBacktickRun(fence, run) {
+	if (run === 0) return fence;
+	if (fence === 0) return run;
+	return run === fence ? 0 : fence;
+}
+function advanceCodeState(state, text) {
+	let { fence, run, newline } = state;
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c === BACKTICK) {
+			run++;
+			newline = false;
+			continue;
+		}
+		fence = settleBacktickRun(fence, run);
+		run = 0;
+		if (c === LINE_FEED) {
+			if (newline && fence < 3) fence = 0;
+			newline = true;
+		} else if (!/\s/.test(text[i])) newline = false;
+	}
+	return {
+		fence,
+		run,
+		newline
+	};
+}
+/**
+* Whether an inline span opened by a `fence`-long backtick run closes in
+* `text` before its paragraph ends. Markdown renders an unmatched run as plain
+* text, so only a closed span is code. `undefined` until the stream decides.
+*/
+function inlineSpanCloses(text, fence, final) {
+	let run = 0;
+	let newline = false;
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c === BACKTICK) {
+			run++;
+			newline = false;
+			continue;
+		}
+		if (run === fence) return true;
+		run = 0;
+		if (c === LINE_FEED) {
+			if (newline) return false;
+			newline = true;
+		} else if (!/\s/.test(text[i])) newline = false;
+	}
+	if (!final) return void 0;
+	return run === fence;
+}
 var DeepSeekInbandScanner = class {
 	#buffer = "";
 	#state = "outside";
@@ -4113,17 +4767,35 @@ var DeepSeekInbandScanner = class {
 	#dsmlParamName = "";
 	#dsmlParamIsString = true;
 	#dsmlParamRaw = "";
+	/** Unclassified wrapper text is kept until an invoke proves it is a tool call. */
+	#pendingDsmlSection;
 	#rawBlock = "";
 	#stripLeadingWhitespace = false;
+	/**
+	* Visible text already carries a bare DSML `invoke`/`parameter` opener (a
+	* malformed call missing its `tool_calls` wrapper). Its closers are then kept
+	* verbatim instead of stripped as orphans, so the agent loop can find where
+	* the broken call ends and remove exactly that span, keeping prose after it.
+	*/
+	#bareDsmlOpenVisible = false;
+	/** Last few visible characters, so a bare opener split across chunks is still seen. */
+	#visibleTail = "";
+	/** Markdown code state of the visible text emitted so far. */
+	#code = OUTSIDE_CODE;
+	#closeWait = new TerminatorWait();
 	constructor(options = {}) {
 		this.#parseThinking = options.parseThinking ?? true;
 	}
 	feed(text) {
 		if (text.length === 0) return [];
-		this.#buffer += text;
-		return this.#consume(false);
+		if (this.#closeWait.absorb(text)) return [];
+		this.#buffer = this.#closeWait.release(this.#buffer) + text;
+		const events = this.#consume(false);
+		if ((this.#state === "args" || this.#state === "legacyArgs") && templateTokenPartialLength(this.#buffer) === 0) this.#closeWait.arm(TEMPLATE_TOKEN_BAR, this.#buffer);
+		return events;
 	}
 	flush() {
+		this.#buffer = this.#closeWait.release(this.#buffer);
 		return this.#consume(true);
 	}
 	#consume(final) {
@@ -4140,7 +4812,7 @@ var DeepSeekInbandScanner = class {
 				continue;
 			}
 			if (this.#state === "section") {
-				if (!this.#consumeSection(final)) break;
+				if (!this.#consumeSection(final, events)) break;
 				continue;
 			}
 			if (this.#state === "header") {
@@ -4166,6 +4838,12 @@ var DeepSeekInbandScanner = class {
 			if (!this.#consumeDsmlParam(final, events)) break;
 		}
 		if (final && this.#state === "thinking") this.#endThinking(events);
+		if (final && this.#pendingDsmlSection !== void 0) {
+			this.#emitText(this.#pendingDsmlSection + this.#buffer, events);
+			this.#pendingDsmlSection = void 0;
+			this.#buffer = "";
+			this.#state = "outside";
+		}
 		if (final && this.#buffer.length === 0 && this.#rawBlock.length > 0) this.#rawBlock = "";
 		return events;
 	}
@@ -4180,62 +4858,68 @@ var DeepSeekInbandScanner = class {
 				this.#buffer = trimmed;
 				this.#stripLeadingWhitespace = false;
 			}
-			const match = findEarliestToken(this.#buffer, OUTSIDE_TOKENS);
+			const match = this.#findOutsideToken(final);
+			if (typeof match === "number") {
+				this.#emitText(this.#buffer.slice(0, match), events);
+				this.#buffer = this.#buffer.slice(match);
+				return;
+			}
 			if (!match) {
-				const hold = final ? 0 : partialSuffixOverlapAny(this.#buffer, OUTSIDE_TOKENS);
-				const emit = this.#buffer.slice(0, this.#buffer.length - hold);
-				if (emit.length > 0) events.push({
-					type: "text",
-					text: emit
-				});
+				const hold = final ? 0 : Math.max(partialSuffixOverlapAny(this.#buffer, OUTSIDE_TOKENS), templateTokenPartialLength(this.#buffer));
+				this.#emitText(this.#buffer.slice(0, this.#buffer.length - hold), events);
 				this.#buffer = this.#buffer.slice(this.#buffer.length - hold);
 				return;
 			}
-			if (match.index > 0) events.push({
-				type: "text",
-				text: this.#buffer.slice(0, match.index)
-			});
-			this.#buffer = this.#buffer.slice(match.index);
-			if (this.#buffer.startsWith("<｜tool▁calls▁begin｜>")) {
-				this.#buffer = this.#buffer.slice(20);
+			this.#emitText(this.#buffer.slice(0, match.index), events);
+			this.#buffer = this.#buffer.slice(match.index + match.raw.length);
+			if (match.raw !== match.token) {
+				const fence = settleBacktickRun(this.#code.fence, this.#code.run);
+				if (fence > 0 && fence < 3) this.#code = OUTSIDE_CODE;
+			}
+			if (match.token === "<｜tool▁calls▁begin｜>") {
 				this.#inToolSection = true;
 				this.#state = "section";
 				return;
 			}
-			if (this.#buffer.startsWith("<｜tool▁call▁begin｜>")) {
-				this.#buffer = this.#buffer.slice(19);
-				this.#rawBlock = DEEPSEEK_TOOL_CALL_BEGIN;
+			if (match.token === "<｜tool▁call▁begin｜>") {
+				this.#rawBlock = match.raw;
 				this.#inToolSection = false;
 				this.#state = "header";
 				return;
 			}
-			if (this.#buffer.startsWith(THINK_OPEN$5)) {
-				this.#buffer = this.#buffer.slice(7);
+			if (match.token === THINK_OPEN$5) {
 				this.#state = "thinking";
 				this.#thinking = "";
 				if (this.#parseThinking) events.push({ type: "thinkingStart" });
 				return;
 			}
-			if (this.#buffer.startsWith(DSML_TOOL_CALLS_OPEN_FULLWIDTH) || this.#buffer.startsWith(DSML_TOOL_CALLS_OPEN_ASCII)) {
-				const openToken = this.#buffer.startsWith(DSML_TOOL_CALLS_OPEN_FULLWIDTH) ? DSML_TOOL_CALLS_OPEN_FULLWIDTH : DSML_TOOL_CALLS_OPEN_ASCII;
-				this.#buffer = this.#buffer.slice(openToken.length);
+			if (match.token === DSML_TOOL_CALLS_OPEN_FULLWIDTH || match.token === DSML_TOOL_CALLS_OPEN_ASCII) {
+				this.#pendingDsmlSection = match.raw;
 				this.#state = "dsmlSection";
 				return;
 			}
-			const orphanClose = this.#matchingOrphanDsmlClose();
-			if (orphanClose) {
-				this.#buffer = this.#buffer.slice(orphanClose.length);
+			if (DSML_ORPHAN_CLOSE_TOKENS.includes(match.token)) {
+				if (this.#bareDsmlOpenVisible) this.#emitText(match.raw, events);
 				continue;
 			}
-			const control = this.#matchingControlToken();
-			if (control) {
-				this.#buffer = this.#buffer.slice(control.length);
-				this.#stripLeadingWhitespace = true;
+			if (this.#bareDsmlOpenVisible && (match.token === DSML_TOOL_CALLS_CLOSE_FULLWIDTH || match.token === DSML_TOOL_CALLS_CLOSE_ASCII)) {
+				this.#emitText(match.raw, events);
+				this.#bareDsmlOpenVisible = false;
 				continue;
 			}
-			this.#buffer = this.#buffer.slice(match.token.length);
+			if (OUTSIDE_DROPPED_TOKENS[match.token]) this.#stripLeadingWhitespace = true;
 		}
 	}
+	#emitText(text, events) {
+		if (text.length === 0) return;
+		events.push({
+			type: "text",
+			text
+		});
+		this.#visibleTail = (this.#visibleTail + text).slice(-48);
+		this.#code = advanceCodeState(this.#code, text);
+		if (!this.#bareDsmlOpenVisible && BARE_DSML_OPEN.test(this.#visibleTail)) this.#bareDsmlOpenVisible = true;
+	}
 	#consumeThinking(final, events) {
 		const close = this.#buffer.indexOf(THINK_CLOSE$4);
 		if (close === -1) {
@@ -4249,35 +4933,47 @@ var DeepSeekInbandScanner = class {
 		this.#buffer = this.#buffer.slice(close + 8);
 		this.#endThinking(events);
 	}
-	#consumeSection(final) {
+	#consumeSection(final, events) {
 		while (this.#buffer.length > 0) {
-			this.#skipWhitespace();
-			if (this.#buffer.startsWith("<｜tool▁calls▁end｜>")) {
-				this.#buffer = this.#buffer.slice(18);
+			const indent = this.#buffer.length - this.#buffer.trimStart().length;
+			const rest = this.#buffer.slice(indent);
+			const lead = templateTokenAtStart(rest);
+			if (lead?.token === "<｜tool▁calls▁end｜>") {
+				this.#buffer = rest.slice(lead.raw.length);
 				this.#inToolSection = false;
 				this.#state = "outside";
 				return true;
 			}
-			if (this.#buffer.startsWith("<｜tool▁call▁begin｜>")) {
-				this.#buffer = this.#buffer.slice(19);
-				this.#rawBlock = DEEPSEEK_TOOL_CALL_BEGIN;
+			if (lead?.token === "<｜tool▁call▁begin｜>") {
+				this.#buffer = rest.slice(lead.raw.length);
+				this.#rawBlock = lead.raw;
 				this.#state = "header";
 				return true;
 			}
-			if (!final && partialSuffixOverlapAny(this.#buffer, SECTION_TOKENS) === this.#buffer.length) return false;
-			if (this.#buffer.length === 0) return false;
-			this.#buffer = this.#buffer.slice(1);
+			if (lead) {
+				this.#buffer = rest.slice(lead.raw.length);
+				continue;
+			}
+			if (rest.length === 0 || templateTokenPartialLength(rest) === rest.length) {
+				if (!final) return false;
+				this.#buffer = "";
+				return true;
+			}
+			const next = rest.indexOf("<", 1);
+			const prose = this.#buffer.slice(0, next === -1 ? this.#buffer.length : indent + next).trimEnd();
+			this.#emitText(prose, events);
+			this.#buffer = this.#buffer.slice(prose.length);
 		}
 		return final;
 	}
 	#consumeHeader(final, events) {
-		const sep = this.#buffer.indexOf(DEEPSEEK_TOOL_SEPARATOR);
-		if (sep === -1) {
+		const sep = findDeepSeekTemplateToken(this.#buffer, SEPARATOR_TOKENS);
+		if (!sep) {
 			if (final) this.#resetTool();
 			return false;
 		}
-		const rawHead = this.#buffer.slice(0, sep + 12);
-		const head = this.#buffer.slice(0, sep).trim();
+		const rawHead = this.#buffer.slice(0, sep.index + sep.raw.length);
+		const head = this.#buffer.slice(0, sep.index).trim();
 		this.#rawBlock += rawHead;
 		this.#buffer = this.#buffer.slice(rawHead.length);
 		if (head === LEGACY_TOOL_TYPE) {
@@ -4304,18 +5000,26 @@ var DeepSeekInbandScanner = class {
 		return true;
 	}
 	#consumeArgs(final, events) {
-		const end = this.#buffer.indexOf(DEEPSEEK_TOOL_CALL_END);
-		if (end === -1) {
+		let end;
+		let rawArgs = "";
+		for (let candidate = findDeepSeekTemplateToken(this.#buffer, ARGS_TERMINATOR_TOKENS); candidate; candidate = findDeepSeekTemplateToken(this.#buffer, ARGS_TERMINATOR_TOKENS, candidate.index + candidate.raw.length)) {
+			rawArgs = this.#buffer.slice(0, candidate.index);
+			if (this.#state === "legacyArgs") {
+				const fence = rawArgs.lastIndexOf(CODE_FENCE);
+				if (fence !== -1) rawArgs = rawArgs.slice(0, fence);
+			}
+			const trimmed = rawArgs.trim();
+			if (candidate.raw === "<｜tool▁call▁end｜>" || trimmed.length === 0 || classifyJsonPrefix(trimmed) !== "prefix") {
+				end = candidate;
+				break;
+			}
+		}
+		if (!end) {
 			if (final) this.#resetTool();
 			return false;
 		}
-		let rawArgs = this.#buffer.slice(0, end);
-		if (this.#state === "legacyArgs") {
-			const fence = rawArgs.lastIndexOf(CODE_FENCE);
-			if (fence !== -1) rawArgs = rawArgs.slice(0, fence);
-		}
-		const rawTail = this.#buffer.slice(0, end + 17);
-		this.#rawBlock += rawTail;
+		const consumed = end.index + (end.token === "<｜tool▁call▁end｜>" ? end.raw.length : 0);
+		this.#rawBlock += this.#buffer.slice(0, consumed);
 		events.push({
 			type: "toolEnd",
 			id: this.#id,
@@ -4323,21 +5027,27 @@ var DeepSeekInbandScanner = class {
 			arguments: this.#parseArgs(rawArgs),
 			rawBlock: this.#rawBlock
 		});
-		this.#buffer = this.#buffer.slice(rawTail.length);
+		this.#buffer = this.#buffer.slice(consumed);
 		this.#resetTool(this.#inToolSection ? "section" : "outside");
 		return true;
 	}
 	#consumeDsmlSection(final, events) {
+		const initial = this.#buffer;
 		while (this.#buffer.length > 0) {
 			this.#skipWhitespace();
 			const close = this.#matchingDsmlClose(DSML_TOOL_CALLS_CLOSE_FULLWIDTH, DSML_TOOL_CALLS_CLOSE_ASCII);
 			if (close) {
+				if (this.#pendingDsmlSection !== void 0) {
+					this.#emitText(this.#pendingDsmlSection + initial.slice(0, initial.length - this.#buffer.length) + close, events);
+					this.#pendingDsmlSection = void 0;
+				}
 				this.#buffer = this.#buffer.slice(close.length);
 				this.#state = "outside";
 				return true;
 			}
 			const invoke = this.#matchDsmlOpen("invoke");
 			if (invoke) {
+				this.#pendingDsmlSection = void 0;
 				this.#rawBlock = invoke.raw;
 				this.#name = invoke.name;
 				this.#id = mintToolCallId();
@@ -4351,12 +5061,13 @@ var DeepSeekInbandScanner = class {
 				return true;
 			}
 			if (!final) {
-				if ((this.#buffer.startsWith("<｜DSML｜invoke") || this.#buffer.startsWith("<|DSML|invoke")) && !this.#buffer.includes(">")) return false;
-				if (partialSuffixOverlapAny(this.#buffer, DSML_SECTION_TOKENS) === this.#buffer.length) return false;
+				if ((this.#buffer.startsWith("<｜DSML｜invoke") || this.#buffer.startsWith("<|DSML|invoke")) && !this.#buffer.includes(">")) break;
+				if (partialSuffixOverlapAny(this.#buffer, DSML_SECTION_TOKENS) === this.#buffer.length) break;
 			}
-			if (this.#buffer.length === 0) return false;
+			if (this.#buffer.length === 0) break;
 			this.#buffer = this.#buffer.slice(1);
 		}
+		if (this.#pendingDsmlSection !== void 0) this.#pendingDsmlSection += initial.slice(0, initial.length - this.#buffer.length);
 		return final;
 	}
 	#consumeDsmlInvoke(final, events) {
@@ -4461,11 +5172,7 @@ var DeepSeekInbandScanner = class {
 	#parseArgs(rawArgs) {
 		const trimmed = rawArgs.trim();
 		if (trimmed.length === 0) return {};
-		try {
-			return asRecord(parseJsonWithRepair(trimmed));
-		} catch {
-			return {};
-		}
+		return asRecord(parseToolCallArguments(trimmed));
 	}
 	#skipWhitespace() {
 		let i = 0;
@@ -4486,15 +5193,34 @@ var DeepSeekInbandScanner = class {
 		}
 		return "";
 	}
-	#matchingOrphanDsmlClose() {
-		for (const token of DSML_ORPHAN_CLOSE_TOKENS) if (this.#buffer.startsWith(token)) return token;
-	}
-	#matchingControlToken() {
-		if (this.#buffer.startsWith("<｜tool▁calls▁end｜>")) return DEEPSEEK_TOOL_CALLS_END;
-		if (this.#buffer.startsWith(THINK_CLOSE$4)) return THINK_CLOSE$4;
-		if (this.#buffer.startsWith(DSML_TOOL_CALLS_CLOSE_FULLWIDTH)) return DSML_TOOL_CALLS_CLOSE_FULLWIDTH;
-		if (this.#buffer.startsWith(DSML_TOOL_CALLS_CLOSE_ASCII)) return DSML_TOOL_CALLS_CLOSE_ASCII;
-		for (const token of CONTROL_TOKENS) if (this.#buffer.startsWith(token)) return token;
+	/**
+	* Earliest outside-state token: a literal (`<think>`, DSML tags, canonical
+	* template tokens) or a re-spelled template token. Ties keep the literal.
+	* A re-spelled token inside code the model quoted is prose about the token,
+	* not markup; canonical spellings keep their long-standing handling. An
+	* inline span is code only once its closing run arrives, so a token after an
+	* unclosed run returns its index to hold from until the paragraph decides.
+	*/
+	#findOutsideToken(final) {
+		const literal = findEarliestToken(this.#buffer, OUTSIDE_TOKENS);
+		let template = findDeepSeekTemplateToken(this.#buffer, OUTSIDE_TEMPLATE_TOKENS);
+		while (template && template.raw !== template.token && (!literal || template.index < literal.index)) {
+			const code = advanceCodeState(this.#code, this.#buffer.slice(0, template.index));
+			const fence = settleBacktickRun(code.fence, code.run);
+			if (fence === 0) break;
+			if (fence < 3) {
+				const closes = inlineSpanCloses(this.#buffer.slice(template.index + template.raw.length), fence, final);
+				if (closes === void 0) return template.index;
+				if (!closes) break;
+			}
+			template = findDeepSeekTemplateToken(this.#buffer, OUTSIDE_TEMPLATE_TOKENS, template.index + template.raw.length);
+		}
+		if (template && (!literal || template.index < literal.index)) return template;
+		return literal && {
+			token: literal.token,
+			raw: literal.token,
+			index: literal.index
+		};
 	}
 	#matchingDsmlClose(fullwidth, ascii) {
 		if (this.#buffer.startsWith(fullwidth)) return fullwidth;
@@ -4606,7 +5332,7 @@ const definition$9 = {
 	renderTranscript: renderTranscript$9
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/fenced-thinking.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/fenced-thinking.ts
 /**
 * Close-matcher for a ` ```thinking ` block that respects nested Markdown code
 * fences. A naive `indexOf("```")` closes the thinking section at the FIRST
@@ -4781,10 +5507,10 @@ var FencedThinkingScanner = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/gemini.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/gemini.md
 var gemini_default = "## Format guide\n\nEmit tool calls as Python inside a fenced ` ```tool_code ` block. Call each function as a method on `default_api`:\n\n````text\n```tool_code\ndefault_api.function_name(arg=\"value\", count=2)\n```\n````\n\nArgument values are Python literals: `\"strings\"`, numbers, `True`/`False`, `None`, `[lists]`, `{\"dicts\": 1}`.\n\nCall several functions in parallel as a Python list:\n\n````text\n```tool_code\n[default_api.first(x=\"a\"), default_api.second(y=\"b\")]\n```\n````\n\nTool results arrive later in a ` ```tool_outputs ` block:\n\n````text\n```tool_outputs\nverbatim tool result\n```\n````\n\nPut any private reasoning in a fenced ` ```thinking ` block before the ` ```tool_code ` block:\n\n````text\n```thinking\nbrief reasoning\n```\n````\n\n## Rules\n\n- The function name MUST match a listed function; arguments are keyword form (`name=value`).\n- Argument string values use only normal Python string escaping; never HTML-escape their contents — write `\"a & b\"`, not `\"a &amp; b\"`.\n- Multiple calls = a single `[...]` list (or one `default_api...` call per line) inside one ` ```tool_code ` block.\n- Put private reasoning in a ` ```thinking ` block before the ` ```tool_code ` block, never inside ` ```tool_code `.\n- Read each ` ```tool_outputs ` block in call order. NEVER write a ` ```tool_outputs ` block yourself.\n- Emit the ` ```tool_code ` block in full, THEN stop and halt — NEVER announce a tool then stop (e.g. halting at \"Let's run `cargo clippy`\" with no ` ```tool_code ` block emitted).\n";
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/gemini.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/gemini.ts
 const CODE_OPEN = "```tool_code";
 const OUTPUT_OPEN = "```tool_outputs";
 const FENCE = "```";
@@ -4806,15 +5532,20 @@ var GeminiInbandScanner = class {
 	/** Fence-aware close-matcher while {@link #state} is "thinking"; undefined otherwise. */
 	#fenced;
 	#parseThinking;
+	#closeWait = new TerminatorWait();
 	constructor(options = {}) {
 		this.#parseThinking = options.parseThinking !== false;
 	}
 	feed(text) {
 		if (text.length === 0) return [];
-		this.#buffer += text;
-		return this.#consume(false);
+		if (this.#closeWait.absorb(text)) return [];
+		this.#buffer = this.#closeWait.release(this.#buffer) + text;
+		const events = this.#consume(false);
+		if (this.#state === "tool") this.#closeWait.arm(FENCE, this.#buffer);
+		return events;
 	}
 	flush() {
+		this.#buffer = this.#closeWait.release(this.#buffer);
 		return this.#consume(true);
 	}
 	#consume(final) {
@@ -5312,10 +6043,10 @@ const definition$8 = {
 	renderTranscript: renderTranscript$8
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/gemma.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/gemma.md
 var gemma_default = "## Format guide\n\nEmit each tool call as one `<|tool_call>` block. The body is `call:NAME{key:value,...}`; wrap every string value in the `<|\"|>` token:\n\n```text\n<|tool_call>call:function_name{path:<|\"|>src/a.ts<|\"|>,count:2}<tool_call|>\n```\n\nNon-string values are bare: numbers (`2`), `true`/`false`, `null`, lists `[<|\"|>a<|\"|>,<|\"|>b<|\"|>]`, and nested objects `{k:<|\"|>v<|\"|>}`.\n\nTool results arrive later in matching `<|tool_response>` blocks:\n\n```text\n<|tool_response>response:function_name{output:<|\"|>verbatim result<|\"|>}<tool_response|>\n```\n\nOptionally precede tool calls with private reasoning in a `<|channel>thought` block, closed by `<channel|>`:\n\n```text\n<|channel>thought\nbrief reasoning\n<channel|>\n```\n\n## Rules\n\n- `NAME` MUST match a listed function; arguments are `key:value` pairs separated by commas.\n- String values between `<|\"|>` tokens are raw literal text (no escaping); never HTML-escape them — write `a & b`, not `a &amp; b`.\n- Multiple calls = consecutive `<|tool_call>...<tool_call|>` blocks; keep prose outside them.\n- The closer is `<tool_call|>` (pipe on the right), not `</tool_call>` or `<|tool_call>`.\n- Private reasoning goes in a `<|channel>thought…<channel|>` block before any call; NEVER put tool calls inside it.\n- Read each `<|tool_response>` block in call order. NEVER write a `<|tool_response>` block yourself.\n- Write each call in full, THEN stop and halt — NEVER announce a tool then stop (e.g. halting at \"Let's run `cargo clippy`\" with no `<|tool_call>` block emitted).\n";
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/gemma.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/gemma.ts
 const CALL_OPEN = "<|tool_call>";
 const CALL_CLOSE = "<tool_call|>";
 const STRING = "<|\"|>";
@@ -5660,10 +6391,10 @@ const definition$7 = {
 	renderTranscript: renderTranscript$7
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/glm.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/glm.md
 var glm_default = "## Format guide\n\nEmit each call as a `<tool_call>` block. The function name goes on the same line as the opening tag, followed by one `<arg_key>`/`<arg_value>` pair per argument, closed by `</tool_call>`:\n\n```text\n<tool_call>get_weather\n<arg_key>location</arg_key>\n<arg_value>Beijing</arg_value>\n<arg_key>days</arg_key>\n<arg_value>3</arg_value>\n</tool_call>\n```\n\nTool results return in an observation block:\n\n```text\n<observation>\n<tool_response>\nverbatim tool result\n</tool_response>\n</observation>\n```\n\n## Rules\n\n- The name after `<tool_call>` must match a listed function and sit on the same line.\n- Emit one `<arg_key>name</arg_key>` + `<arg_value>value</arg_value>` pair per argument; omit unset optional args.\n- `<arg_value>` bodies are read by regex (delimiter matching), NOT a real XML parser: write string values as raw literal text and never HTML-escape them (emit `a & b`, not `a &amp; b`; `<`/`>` stay literal); only the body's own `</arg_value>` closing tag is reserved. Non-string values are valid JSON.\n- Multiple calls are consecutive `<tool_call>…</tool_call>` blocks.\n- Private reasoning goes in `<think>…</think>`; NEVER put tool calls inside `<think>`.\n- Read each `<tool_response>` in call order. NEVER emit `<tool_response>` yourself.\n- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at \"Let's run `cargo clippy`\" with no `<tool_call>` emitted). Write the complete call, THEN the stop sequence, THEN halt.\n";
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/glm.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/glm.ts
 const TOOL_OPEN$2 = "<tool_call>";
 const TOOL_CLOSE$2 = "</tool_call>";
 const ARG_KEY_OPEN = "<arg_key>";
@@ -6188,10 +6919,10 @@ const definition$6 = {
 	renderTranscript: renderTranscript$6
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/harmony.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/harmony.md
 var harmony_default = "## Format guide\n\nEach function call is one assistant message on the `commentary` channel addressed to the function, emitted as text:\n\n```text\n<|start|>assistant<|channel|>commentary to=functions.function_name<|message|>{\"arg\":\"value\"}<|call|>\n```\n\nPut private reasoning in an `analysis` message:\n\n```text\n<|start|>assistant<|channel|>analysis<|message|>private reasoning<|end|>\n```\n\nTool results arrive as messages authored by the function, addressed back to the assistant:\n\n```text\n<|start|>functions.function_name to=assistant<|channel|>commentary<|message|>verbatim tool result<|end|>\n```\n\n## Rules\n\n- Recipient is `functions.` + a listed function name.\n- Body is one JSON object matching the schema; omit optional arguments you are not setting.\n- Argument string values use only normal JSON string escaping (`\\\"`, `\\\\`, `\\n`); never HTML-escape their contents — write `a & b`, not `a &amp; b`.\n- Multiple calls = consecutive call messages.\n- An optional visible preamble is a `commentary` message ending `<|end|>`.\n- NEVER put tool calls in `analysis`.\n- NEVER wrap calls in Markdown/code fences.\n- Read each tool-result message in call order. NEVER emit tool-result messages yourself.\n- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at \"Let's run `cargo clippy`\" with no `<|call|>` message emitted). Write the complete call, THEN the stop sequence, THEN halt.\n";
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/harmony.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/harmony.ts
 const START = "<|start|>";
 const END = "<|end|>";
 const MESSAGE = "<|message|>";
@@ -6393,11 +7124,7 @@ var HarmonyInbandScanner = class {
 	#parseArgs() {
 		const raw = this.#toolArgs.trim();
 		if (raw.length === 0) return {};
-		try {
-			return asRecord(parseJsonWithRepair(raw));
-		} catch {
-			return {};
-		}
+		return asRecord(parseToolCallArguments(raw));
 	}
 	#clearBody(resetRawBlock = true) {
 		this.#mode = "skip";
@@ -6499,10 +7226,10 @@ const definition$5 = {
 	renderTranscript: renderTranscript$5
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/hermes.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/hermes.md
 var hermes_default = "## Format guide\n\nEmit each call as a `<tool_call>` block wrapping a single-line JSON object with `name` and `arguments`:\n\n```text\n<tool_call>\n{\"name\":\"function_name\",\"arguments\":{\"arg\":\"value\"}}\n</tool_call>\n```\n\nResults arrive later as `<tool_response>` blocks:\n\n```text\n<tool_response>\nverbatim tool result\n</tool_response>\n```\n\n## Rules\n\n- `name` MUST match a listed function; `arguments` is a JSON object, never a stringified JSON.\n- Argument string values use only normal JSON string escaping (`\\\"`, `\\\\`, `\\n`); never HTML-escape their contents — write `a & b`, not `a &amp; b`.\n- Emit multiple calls as consecutive `<tool_call>` blocks; keep any prose outside them.\n- Read each `<tool_response>` in call order. NEVER emit `<tool_response>` yourself.\n- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at \"Let's run `cargo clippy`\" with no `<tool_call>` emitted). Write the complete call, THEN the stop sequence, THEN halt.\n";
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/hermes.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/hermes.ts
 const TOOL_OPEN$1 = "<tool_call>";
 const TOOL_CLOSE$1 = "</tool_call>";
 const THINK_OPEN$2 = "<think>";
@@ -6522,15 +7249,20 @@ var HermesInbandScanner = class {
 	#parseThinking;
 	#inThinking = false;
 	#thinking = "";
+	#closeWait = new TerminatorWait();
 	constructor(options = {}) {
 		this.#parseThinking = options.parseThinking === true;
 	}
 	feed(text) {
 		if (text.length === 0) return [];
-		this.#buffer += text;
-		return this.#consume(false);
+		if (this.#closeWait.absorb(text)) return [];
+		this.#buffer = this.#closeWait.release(this.#buffer) + text;
+		const events = this.#consume(false);
+		if (this.#inside && this.#started && !this.#inThinking) this.#closeWait.arm(TOOL_CLOSE$1, this.#buffer);
+		return events;
 	}
 	flush() {
+		this.#buffer = this.#closeWait.release(this.#buffer);
 		return this.#consume(true);
 	}
 	#consume(final) {
@@ -6639,28 +7371,22 @@ var HermesInbandScanner = class {
 		return events;
 	}
 	#tryStart(body, events) {
-		try {
-			const partial = parseStreamingJson(body);
-			if (typeof partial.name !== "string" || partial.name.length === 0) return;
-			this.#name = partial.name;
-			this.#started = true;
-			events.push({
-				type: "toolStart",
-				id: this.#id,
-				name: this.#name
-			});
-		} catch {}
+		const name = parseCompleteToolName(body);
+		if (!name) return;
+		this.#name = name;
+		this.#started = true;
+		events.push({
+			type: "toolStart",
+			id: this.#id,
+			name: this.#name
+		});
 	}
 	#parseCall(body) {
 		try {
 			const parsed = parseJsonWithRepair(body.trim());
 			if (typeof parsed.name !== "string" || parsed.name.length === 0) return void 0;
 			let args = parsed.arguments;
-			if (typeof args === "string") try {
-				args = parseJsonWithRepair(args);
-			} catch {
-				args = {};
-			}
+			if (typeof args === "string") args = parseToolCallArguments(args);
 			return {
 				name: parsed.name,
 				arguments: asRecord(args)
@@ -6710,10 +7436,10 @@ const definition$4 = {
 	renderTranscript: renderTranscript$4
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/kimi.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/kimi.md
 var kimi_default = "## Format guide\n\nEmit every call of a turn inside one section. Each call is an id of the fixed form `functions.NAME:INDEX` followed by one JSON arguments object:\n\n```text\n<|tool_calls_section_begin|><|tool_call_begin|>functions.NAME:INDEX<|tool_call_argument_begin|>{\"arg\":\"value\"}<|tool_call_end|><|tool_calls_section_end|>\n```\n\nTool results arrive later as turns whose body is a `## Return of functions.NAME:INDEX` header then the verbatim result:\n\n```text\n<|im_system|>NAME<|im_middle|>## Return of functions.NAME:INDEX\nverbatim tool result<|im_end|>\n```\n\n## Rules\n\n- `NAME` MUST match a listed function exactly.\n- Arguments MUST be one JSON object with double-quoted keys.\n- Argument string values use only normal JSON string escaping (`\\\"`, `\\\\`, `\\n`); never HTML-escape their contents — write `a & b`, not `a &amp; b`.\n- Multiple calls = consecutive `<|tool_call_begin|>…<|tool_call_end|>` blocks in the same section; `INDEX` increments from `0`.\n- Private reasoning, when supported, goes in `<think>…</think>` before the tool-call section; NEVER put tool calls inside `<think>`.\n- Read each result turn in call order. NEVER emit result turns yourself.\n- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at \"Let's run `cargo clippy`\" with no `<|tool_call_begin|>` emitted). Write the complete call, THEN the stop sequence, THEN halt.\n";
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/kimi.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/kimi.ts
 const KIMI_SECTION_BEGIN = "<|tool_calls_section_begin|>";
 const KIMI_SECTION_END = "<|tool_calls_section_end|>";
 const KIMI_CALL_BEGIN = "<|tool_call_begin|>";
@@ -6743,16 +7469,21 @@ var KimiInbandScanner = class {
 	#name = "";
 	#rawBlock = "";
 	#thinking = "";
+	#closeWait = new TerminatorWait();
 	#parseThinking;
 	constructor(options = {}) {
 		this.#parseThinking = options.parseThinking !== false;
 	}
 	feed(text) {
 		if (text.length === 0) return [];
-		this.#buffer += text;
-		return this.#consume(false);
+		if (this.#closeWait.absorb(text)) return [];
+		this.#buffer = this.#closeWait.release(this.#buffer) + text;
+		const events = this.#consume(false);
+		if (this.#state === "args") this.#closeWait.arm(KIMI_CALL_END, this.#buffer);
+		return events;
 	}
 	flush() {
+		this.#buffer = this.#closeWait.release(this.#buffer);
 		return this.#consume(true);
 	}
 	#consume(final) {
@@ -6914,11 +7645,7 @@ var KimiInbandScanner = class {
 	}
 	#parseArgs(rawArgs) {
 		if (rawArgs.length === 0) return {};
-		try {
-			return asRecord(parseJsonWithRepair(rawArgs));
-		} catch {
-			return {};
-		}
+		return asRecord(parseToolCallArguments(rawArgs));
 	}
 	#nextTokenIndex() {
 		let best = -1;
@@ -7009,10 +7736,10 @@ const definition$3 = {
 	renderTranscript: renderTranscript$3
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/minimax.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/minimax.md
 var minimax_default = "## Format guide\n\nA call is a `<minimax:tool_call>` block wrapping one or more `<invoke>` blocks, each holding `<parameter>` children:\n\n```text\n<minimax:tool_call>\n<invoke name=\"tool_name\"><parameter name=\"arg_name\">arg value</parameter></invoke>\n</minimax:tool_call>\n```\n\nResults arrive later in a `<function_results>` block, one `<result>` per call (failures use `<error>` with `<stderr>` in place of `<result>` with `<stdout>`):\n\n```text\n<function_results>\n<result>\n<tool_name>tool_name</tool_name>\n<stdout>verbatim tool result</stdout>\n</result>\n</function_results>\n```\n\n## Rules\n\n- `name` MUST match a listed function.\n- String/scalar parameters: exact text, spaces preserved — bodies are read by regex (delimiter matching), NOT a real XML parser, so never HTML-escape them (emit `a & b`, not `a &amp; b`; `<`/`>` stay literal); only the body's own `</parameter>` closing tag is reserved. Lists/objects: JSON.\n- Multiple calls: multiple `<invoke>` blocks in one `<minimax:tool_call>`.\n- You MAY write visible text before the calls.\n- NEVER emit `tool_calls` JSON.\n- NEVER use `<function_calls>` or the legacy `<tool_name>`/`<parameters>` call syntax.\n- Read each `<result>`/`<error>` in call order. NEVER emit `<function_results>` yourself.\n- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at \"Let's run `cargo clippy`\" with no `<invoke>` emitted). Write the complete call, THEN the stop sequence, THEN halt.\n";
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/minimax.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/minimax.ts
 const MINIMAX_WRAPPER_TAGS = { tool_call: true };
 const MINIMAX_BASE_TAG_PREFIXES = [
 	"<minimax:tool_call",
@@ -7030,11 +7757,11 @@ const MINIMAX_SCANNER_CONFIG = {
 	allTagPrefixes: [...MINIMAX_BASE_TAG_PREFIXES, ...ANTHROPIC_THINKING_TAG_PREFIXES]
 };
 function renderToolCall$2(call, options = {}) {
-	return renderInvoke$1(call, buildArgShapes(options.tools).get(call.name));
+	return renderInvoke(call, buildArgShapes(options.tools).get(call.name));
 }
 function renderAssistantToolCalls$2(calls, options = {}) {
 	if (calls.length === 0) return "";
-	return `<minimax:tool_call>\n${renderInvokes$1(calls, options.tools ?? [])}\n</minimax:tool_call>`;
+	return `<minimax:tool_call>\n${renderInvokes(calls, options.tools ?? [])}\n</minimax:tool_call>`;
 }
 function renderToolResults$2(results) {
 	return `<function_results>\n${results.map((result) => {
@@ -7053,19 +7780,6 @@ function renderTranscript$2(messages, options = {}) {
 		renderResults: renderToolResults$2
 	});
 }
-function renderInvoke$1(call, shape) {
-	let body = `<invoke name="${escapeXmlAttr(call.name)}">`;
-	for (const key in call.arguments) {
-		const value = call.arguments[key];
-		const rendered = shape?.stringArgs.has(key) === true && typeof value === "string" ? value : stringifyJson(value);
-		body += `<parameter name="${escapeXmlAttr(key)}">${rendered}</parameter>`;
-	}
-	return `${body}</invoke>`;
-}
-function renderInvokes$1(calls, tools) {
-	const shapes = buildArgShapes(tools);
-	return calls.map((call) => renderInvoke$1(call, shapes.get(call.name))).join("\n");
-}
 const definition$2 = {
 	dialect: "minimax",
 	prompt: minimax_default,
@@ -7077,10 +7791,10 @@ const definition$2 = {
 	renderTranscript: renderTranscript$2
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/qwen3.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/qwen3.md
 var qwen3_default = "## Format guide\n\nEmit each tool call as one `<tool_call>` block wrapping a single-line JSON object with `name` and a nested `arguments` object:\n\n```text\n<tool_call>\n{\"name\":\"function_name\",\"arguments\":{\"arg\":\"value\"}}\n</tool_call>\n```\n\nDo any private reasoning in `<think>...</think>` before your tool calls.\n\nTool results arrive later in a user turn:\n\n```text\n<tool_response>\nverbatim tool result\n</tool_response>\n```\n\n## Rules\n\n- `name` MUST match a listed function; `arguments` is a JSON object, never a JSON string.\n- Argument string values use only normal JSON string escaping (`\\\"`, `\\\\`, `\\n`); never HTML-escape their contents — write `a & b`, not `a &amp; b`.\n- Multiple calls = consecutive `<tool_call>...</tool_call>` blocks; keep prose outside them.\n- NEVER put tool calls inside `<think>`.\n- Read each `<tool_response>` in call order. NEVER emit `<tool_response>` yourself.\n- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at \"Let's run `cargo clippy`\" with no `<tool_call>` emitted). Write the complete call, THEN the stop sequence, THEN halt.\n";
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/qwen3.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/qwen3.ts
 const TOOL_OPEN = "<tool_call>";
 const TOOL_CLOSE = "</tool_call>";
 const THINK_OPEN = "<think>";
@@ -7088,7 +7802,6 @@ const THINK_CLOSE = "</think>";
 const TOOL_START_TAGS = [TOOL_OPEN];
 const START_TAGS = [TOOL_OPEN, THINK_OPEN];
 const THINK_CLOSE_TAGS = [THINK_CLOSE];
-const COMPLETE_NAME = /^\s*\{\s*"name"\s*:\s*("(?:\\.|[^"\\])*")/;
 var Qwen3InbandScanner = class {
 	#buffer = "";
 	#state = "outside";
@@ -7096,16 +7809,21 @@ var Qwen3InbandScanner = class {
 	#name = "";
 	#started = false;
 	#thinking = "";
+	#closeWait = new TerminatorWait();
 	#parseThinking;
 	constructor(options = {}) {
 		this.#parseThinking = options.parseThinking !== false;
 	}
 	feed(text) {
 		if (text.length === 0) return [];
-		this.#buffer += text;
-		return this.#consume(false);
+		if (this.#closeWait.absorb(text)) return [];
+		this.#buffer = this.#closeWait.release(this.#buffer) + text;
+		const events = this.#consume(false);
+		if (this.#state === "tool" && this.#started) this.#closeWait.arm(TOOL_CLOSE, this.#buffer);
+		return events;
 	}
 	flush() {
+		this.#buffer = this.#closeWait.release(this.#buffer);
 		return this.#consume(true);
 	}
 	#consume(final) {
@@ -7224,15 +7942,8 @@ var Qwen3InbandScanner = class {
 		this.#state = "outside";
 	}
 	#tryStart(body, events) {
-		const nameMatch = COMPLETE_NAME.exec(body);
-		if (!nameMatch) return;
-		let name;
-		try {
-			name = JSON.parse(nameMatch[1]);
-		} catch {
-			return;
-		}
-		if (typeof name !== "string" || name.length === 0) return;
+		const name = parseCompleteToolName(body);
+		if (!name) return;
 		this.#name = name;
 		this.#started = true;
 		events.push({
@@ -7246,11 +7957,7 @@ var Qwen3InbandScanner = class {
 			const parsed = parseJsonWithRepair(body.trim());
 			if (typeof parsed.name !== "string" || parsed.name.length === 0) return void 0;
 			let args = parsed.arguments;
-			if (typeof args === "string") try {
-				args = parseJsonWithRepair(args);
-			} catch {
-				args = {};
-			}
+			if (typeof args === "string") args = parseToolCallArguments(args);
 			return {
 				name: parsed.name,
 				arguments: asRecord(args)
@@ -7301,10 +8008,10 @@ const definition$1 = {
 	renderTranscript: renderTranscript$1
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/xml.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/xml.md
 var xml_default = "## Format guide\n\nA call is one `<invoke>` element whose `<parameter>` children carry its arguments:\n\n```text\n<invoke name=\"fn\"><parameter name=\"arg\">value</parameter></invoke>\n```\n\nEmit consecutive `<invoke>…</invoke>` blocks for multiple calls; you MAY wrap them in `<tool_calls>…</tool_calls>`. Each call's result arrives as a response block:\n\n```text\n<tool_response>\nverbatim tool result\n</tool_response>\n```\n\n## Rules\n\n- `name` MUST match a listed function.\n- Parameter values are read literally by regex (delimiter matching), NOT a real XML parser: write them verbatim and never HTML-escape (emit `a & b`, never `a &amp; b`; `<`/`>` stay literal too). Only the body's own `</parameter>` closing tag is reserved. Non-string values are JSON; add `string=\"false\"` to a parameter only to force JSON parsing of a value the schema treats as a string.\n- Read each `<tool_response>` in call order. NEVER emit `<tool_response>` yourself.\n- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at \"Let's run `cargo clippy`\" with no `<invoke>` emitted). Write the complete call, THEN the stop sequence, THEN halt.\n";
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/xml.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/xml.ts
 var XmlInbandScanner = class {
 	#inner;
 	constructor(options = {}) {
@@ -7336,21 +8043,8 @@ function renderTranscript(messages, options = {}) {
 		renderResults: renderToolResults
 	});
 }
-function renderInvoke(call, shape) {
-	let body = `<invoke name="${escapeXmlAttr(call.name)}">`;
-	for (const key in call.arguments) {
-		const value = call.arguments[key];
-		const rendered = shape?.stringArgs.has(key) === true && typeof value === "string" ? value : stringifyJson(value);
-		body += `<parameter name="${escapeXmlAttr(key)}">${rendered}</parameter>`;
-	}
-	return `${body}</invoke>`;
-}
-function renderInvokes(calls, tools) {
-	const shapes = buildArgShapes(tools);
-	return calls.map((call) => renderInvoke(call, shapes.get(call.name))).join("\n");
-}
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/factory.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/factory.ts
 const DIALECT_DEFINITIONS = {
 	glm: definition$6,
 	hermes: definition$4,
@@ -7380,7 +8074,7 @@ function createInbandScanner(dialect, options = {}) {
 	return getDialectDefinition(dialect).createScanner(options);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/demotion.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/dialect/demotion.ts
 /**
 * Wrap a prior-turn reasoning string for demotion into native conversation
 * history — the cross-provider / cross-model case where the target cannot
@@ -7419,7 +8113,7 @@ function renderDemotedThinking(modelId, text) {
 	return getDialectDefinition(dialect).renderThinking(text);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/block-symbols.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils/block-symbols.ts
 /** Stores streamed tool-call argument JSON for live renderers and parser recovery. */
 const kStreamingPartialJson = Symbol("provider.block.partialJson");
 /** Clears streamed tool-call argument JSON without deleting or changing object shape. */
@@ -7470,8 +8164,74 @@ const kDemotedThinking = Symbol("provider.block.demotedThinking");
 function isDemotedThinking(block) {
 	return block?.[kDemotedThinking] === true;
 }
+/**
+* Marks a thinking block that `transformMessages` carried natively from
+* another host serving the same model (see `compat/reasoning-carry` in the
+* catalog). Its host-bound signature and item id are gone, so encoders that
+* replay reasoning from stored payloads (Responses) emit a plaintext item for
+* it instead. Symbol-keyed so the marker never persists or reaches the wire.
+*/
+const kCarriedReasoning = Symbol("provider.block.carriedReasoning");
+/** True for thinking blocks carried natively from another host of the same model. */
+function isCarriedReasoning(block) {
+	return block?.[kCarriedReasoning] === true;
+}
+/**
+* Marks an Anthropic wire message that was serialized from a source
+* `role: "user"` message.
+*
+* The wire role alone cannot answer this. `convertAnthropicMessages` emits
+* `role: "user"` for several things that are not a conversational turn:
+* `developer` messages on models without mid-conversation `system` support,
+* `tool_result` runs, and the synthetic `Continue.` pads inserted between
+* adjacent assistants. Prompt-cache decimation counts conversational turns,
+* so it reads this marker instead of guessing from wire content.
+*
+* Symbol-keyed so the marker never persists across the JSONL round-trip and
+* never reaches the wire.
+*/
+const kConversationalUser = Symbol("provider.message.conversationalUser");
+/** True for wire messages serialized from a source `role: "user"` message. */
+function isConversationalUser(message) {
+	return message?.[kConversationalUser] === true;
+}
+/**
+* Marks a `role: "user"` message that `transformMessages` synthesized rather
+* than one the user sent.
+*
+* The stale-tool-result note is deliberately emitted as `user` so no provider
+* elevates untrusted tool output to instruction priority, which leaves it
+* indistinguishable from a real turn by role alone. Prompt-cache decimation
+* must not count it, or an orphan result appearing or disappearing in a
+* compacted history shifts every later checkpoint.
+*
+* Symbol-keyed so the marker never persists across the JSONL round-trip and
+* never reaches the wire.
+*/
+const kSyntheticUser = Symbol("provider.message.syntheticUser");
+/** True for `user` messages synthesized by message transformation. */
+function isSyntheticUser(message) {
+	return message?.[kSyntheticUser] === true;
+}
+/**
+* Marks a message synthesized by a per-call context transform rather than
+* loaded from persisted conversation history.
+*
+* Prompt-cache boundaries must skip these messages: their content is rebuilt
+* for each request and cannot anchor a prefix reused by the next turn.
+* Symbol-keyed so the marker never persists or reaches the provider wire.
+*/
+const kPerCallContextMessage = Symbol("agent.message.perCallContext");
+/** Copies per-call context provenance to a converted or projected message. */
+function copyPerCallContextMessage(target, source) {
+	if (source[kPerCallContextMessage] === true) target[kPerCallContextMessage] = true;
+}
+/** True when a message was synthesized for the current provider call. */
+function isPerCallContextMessage(message) {
+	return message?.[kPerCallContextMessage] === true;
+}
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/providers/transform-messages.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/providers/transform-messages.ts
 var ToolCallStatus = /* @__PURE__ */ function(ToolCallStatus) {
 	/** A tool result has already been emitted for this tool call; later duplicates must be skipped. */
 	ToolCallStatus[ToolCallStatus["Resolved"] = 1] = "Resolved";
@@ -7479,16 +8239,15 @@ var ToolCallStatus = /* @__PURE__ */ function(ToolCallStatus) {
 	ToolCallStatus[ToolCallStatus["Aborted"] = 2] = "Aborted";
 	return ToolCallStatus;
 }(ToolCallStatus || {});
-/**
-* Maximum tool-call id length the strictest replay provider accepts.
-*
-* Anthropic requires `^[a-zA-Z0-9_-]+$` with a 64-char cap; Google and Codex
-* `normalizeToolCallId` implementations cap individual id segments to the same
-* 64-char ceiling. Replacement ids minted here flow back through
-* `convertAnthropicMessages` (and friends) unchanged, so the `_dupN` suffix
-* MUST not push a normalized id past this bound.
-*/
-const MAX_TOOL_CALL_ID_LENGTH = 64;
+/** Replace unsupported tool-call ID characters and cap the result for strict replay providers. */
+function normalizeToolCallId(id, maxLength = 64) {
+	return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, maxLength);
+}
+const TOOL_CALL_ID_PATTERN = new RegExp(`^[a-zA-Z0-9_-]{1,64}$`);
+/** Whether `id` already satisfies the strict 1–64 `[a-zA-Z0-9_-]` tool-call ID contract. */
+function isValidToolCallId(id) {
+	return TOOL_CALL_ID_PATTERN.test(id);
+}
 /**
 * OpenAI Responses-family APIs mint composite tool ids (`call_id|item_id`);
 * opaque Chat Completions ids do not (openai-completions preserves same-model
@@ -7508,22 +8267,22 @@ function responsesCallComponent(id) {
 	const pipe = id.indexOf("|");
 	return pipe <= 0 ? id : id.slice(0, pipe);
 }
-function collectToolCallOriginScope(messages) {
-	const responsesComponents = /* @__PURE__ */ new Set();
-	const opaqueCompositeCallIds = /* @__PURE__ */ new Set();
-	for (const msg of messages) {
-		if (msg.role !== "assistant") continue;
-		const responsesOrigin = isResponsesFamilyApi(msg.api);
-		for (const block of msg.content) {
-			if (block.type !== "toolCall") continue;
-			if (responsesOrigin) responsesComponents.add(responsesCallComponent(block.id));
-			else if (block.id.includes("|")) opaqueCompositeCallIds.add(block.id);
-		}
+/**
+* Record one assistant turn's tool-call ids into the origin-scope sets.
+*
+* Called from the normalization map (`transformMessages`) in document order, on
+* the SAME post-transform content that message emits, so the two sets cover
+* every assistant turn exactly once and hold its post-normalization, pre-dedup
+* ids (`_dupN` replacements minted later by dedup are never scope members).
+* Both sets are only read via `.has`, so ordering is inert.
+*/
+function recordToolCallOriginScope(msg, content, responsesComponents, opaqueCompositeCallIds) {
+	const responsesOrigin = isResponsesFamilyApi(msg.api);
+	for (const block of content) {
+		if (block.type !== "toolCall") continue;
+		if (responsesOrigin) responsesComponents.add(responsesCallComponent(block.id));
+		else if (block.id.includes("|")) opaqueCompositeCallIds.add(block.id);
 	}
-	return {
-		responsesComponents,
-		opaqueCompositeCallIds
-	};
 }
 /**
 * Canonical key for pairing a tool result with its assistant tool call.
@@ -7571,70 +8330,146 @@ function appendSegmentDuplicateSuffix(segment, suffix, maxLength) {
 	const prefixBudget = Math.max(0, maxLength - suffix.length);
 	return `${segment.slice(0, prefixBudget)}${suffix}`;
 }
-function deduplicateToolCallIds(messages, originScope, maxToolCallIdLength = MAX_TOOL_CALL_ID_LENGTH, duplicateSuffixPrefix = "_dup") {
+/**
+* File a SURVIVING (post-dedup) tool result into the request-wide index.
+*
+* Called from the dedup pass, once per tool result message, at the position the
+* message occupies in that pass's output array — so the entries and their order
+* describe the transcript the request will actually carry.
+* The caller passes the pairing key for the id that survived the pass (a `_dup`
+* rewrite changes it), which is what the consumers downstream must pair against.
+*/
+function indexToolResult(msg, index, key, realToolResultsById) {
+	const entry = {
+		index,
+		msg,
+		consumed: false
+	};
+	const entries = realToolResultsById.get(key);
+	if (entries) entries.push(entry);
+	else realToolResultsById.set(key, [entry]);
+}
+function deduplicateToolCallIds(messages, originScope, maxToolCallIdLength, duplicateSuffixPrefix) {
 	const seenToolCallIds = /* @__PURE__ */ new Map();
 	const pendingToolResultRewrites = /* @__PURE__ */ new Map();
-	return messages.map((msg) => {
-		if (msg.role === "toolResult") {
-			const key = toolCallPairingKey(msg.toolCallId, originScope);
-			const rewrites = pendingToolResultRewrites.get(key);
-			if (!rewrites || rewrites.length === 0) return msg;
-			const rewrite = rewrites.shift();
-			if (rewrites.length === 0) pendingToolResultRewrites.delete(key);
-			if (rewrite) return {
-				...msg,
-				toolCallId: rewrite.replacementId
-			};
-			return msg;
+	const realToolResultsById = /* @__PURE__ */ new Map();
+	const validToolUseIds = /* @__PURE__ */ new Set();
+	const enqueueToolResultRewrite = (id, rewrite) => {
+		const rewrites = pendingToolResultRewrites.get(id);
+		if (rewrites) {
+			rewrites.push(rewrite);
+			return;
 		}
-		if (msg.role !== "assistant") return msg;
-		const enqueueToolResultRewrite = (id, rewrite) => {
-			const rewrites = pendingToolResultRewrites.get(id);
-			if (rewrites) {
-				rewrites.push(rewrite);
-				return;
-			}
-			pendingToolResultRewrites.set(id, [rewrite]);
-		};
-		const idsTouchedInTurn = /* @__PURE__ */ new Set();
-		let contentChanged = false;
-		const content = msg.content.map((block) => {
-			if (block.type !== "toolCall") return block;
-			const blockKey = toolCallPairingKey(block.id, originScope);
-			if (!idsTouchedInTurn.has(blockKey)) {
-				pendingToolResultRewrites.delete(blockKey);
-				idsTouchedInTurn.add(blockKey);
-			}
-			const previousCount = seenToolCallIds.get(blockKey) ?? 0;
-			if (previousCount === 0) {
-				seenToolCallIds.set(blockKey, 1);
-				enqueueToolResultRewrite(blockKey, void 0);
-				return block;
+		pendingToolResultRewrites.set(id, [rewrite]);
+	};
+	return {
+		messages: messages.map((msg, index) => {
+			if (msg.role === "toolResult") {
+				const key = toolCallPairingKey(msg.toolCallId, originScope);
+				const rewrites = pendingToolResultRewrites.get(key);
+				if (!rewrites || rewrites.length === 0) {
+					indexToolResult(msg, index, key, realToolResultsById);
+					return msg;
+				}
+				const rewrite = rewrites.shift();
+				if (rewrites.length === 0) pendingToolResultRewrites.delete(key);
+				if (rewrite) {
+					const rewritten = {
+						...msg,
+						toolCallId: rewrite.replacementId
+					};
+					indexToolResult(rewritten, index, toolCallPairingKey(rewritten.toolCallId, originScope), realToolResultsById);
+					return rewritten;
+				}
+				indexToolResult(msg, index, key, realToolResultsById);
+				return msg;
 			}
-			let duplicateIndex = previousCount;
-			let replacementId = appendDuplicateSuffix(block.id, `${duplicateSuffixPrefix}${duplicateIndex}`, maxToolCallIdLength);
-			while (seenToolCallIds.has(toolCallPairingKey(replacementId, originScope))) {
-				duplicateIndex += 1;
-				replacementId = appendDuplicateSuffix(block.id, `${duplicateSuffixPrefix}${duplicateIndex}`, maxToolCallIdLength);
+			if (msg.role !== "assistant") return msg;
+			let idsTouchedInTurn;
+			let contentChanged = false;
+			const content = msg.content.map((block) => {
+				if (block.type !== "toolCall") return block;
+				const blockKey = toolCallPairingKey(block.id, originScope);
+				if (!idsTouchedInTurn?.has(blockKey)) {
+					(idsTouchedInTurn ??= /* @__PURE__ */ new Set()).add(blockKey);
+					pendingToolResultRewrites.delete(blockKey);
+				}
+				const previousCount = seenToolCallIds.get(blockKey) ?? 0;
+				if (previousCount === 0) {
+					seenToolCallIds.set(blockKey, 1);
+					enqueueToolResultRewrite(blockKey, void 0);
+					return block;
+				}
+				let duplicateIndex = previousCount;
+				let replacementId = appendDuplicateSuffix(block.id, `${duplicateSuffixPrefix}${duplicateIndex}`, maxToolCallIdLength);
+				while (seenToolCallIds.has(toolCallPairingKey(replacementId, originScope))) {
+					duplicateIndex += 1;
+					replacementId = appendDuplicateSuffix(block.id, `${duplicateSuffixPrefix}${duplicateIndex}`, maxToolCallIdLength);
+				}
+				seenToolCallIds.set(blockKey, duplicateIndex + 1);
+				seenToolCallIds.set(toolCallPairingKey(replacementId, originScope), 1);
+				enqueueToolResultRewrite(blockKey, { replacementId });
+				contentChanged = true;
+				return {
+					...block,
+					id: replacementId
+				};
+			});
+			for (const block of content) {
+				if (block.type !== "toolCall") continue;
+				validToolUseIds.add(toolCallPairingKey(block.id, originScope));
 			}
-			seenToolCallIds.set(blockKey, duplicateIndex + 1);
-			seenToolCallIds.set(toolCallPairingKey(replacementId, originScope), 1);
-			enqueueToolResultRewrite(blockKey, { replacementId });
-			contentChanged = true;
+			if (!contentChanged) return msg;
 			return {
-				...block,
-				id: replacementId
+				...msg,
+				content
 			};
-		});
-		if (!contentChanged) return msg;
-		return {
-			...msg,
-			content
-		};
-	});
+		}),
+		realToolResultsById,
+		validToolUseIds
+	};
 }
+/** Default for providers without an authored tool-name policy and native OpenAI Responses history. */
+const MAX_TOOL_CALL_NAME_LENGTH = 128;
+const STRICT_TOOL_CALL_NAME_RE = /^[a-zA-Z0-9_-]+$/;
+const GOOGLE_TOOL_CALL_NAME_RE = /^[a-zA-Z_][a-zA-Z0-9_.:-]*$/;
+/** Any character some provider accepts in a declared tool name, for checks with no target. */
+const ANY_PROVIDER_TOOL_CALL_NAME_RE = /^[a-zA-Z0-9_.:-]+$/;
 /**
-* Drop assistant `toolCall` blocks whose `id` or `name` is empty / whitespace-only,
+* Charset and length a tool-call name must meet to replay to `model`. Without a
+* target, a name passes when any provider could declare it.
+*/
+function toolCallNameLimits(model) {
+	if (!model) return {
+		allowedName: ANY_PROVIDER_TOOL_CALL_NAME_RE,
+		maxLength: MAX_TOOL_CALL_NAME_LENGTH
+	};
+	const policy = resolveCatalogPolicy(model);
+	return {
+		allowedName: policy.toolCallNameCharset === "google" ? GOOGLE_TOOL_CALL_NAME_RE : STRICT_TOOL_CALL_NAME_RE,
+		maxLength: typeof policy.toolCallNameMaxLength === "number" ? policy.toolCallNameMaxLength : MAX_TOOL_CALL_NAME_LENGTH
+	};
+}
+/**
+* Whether a tool-call name cannot be replayed to the target: missing, empty,
+* longer than its declaration limit, or containing a character outside its
+* declaration charset. Models emit such names when the name slot carries
+* invocation text (whitespace, NULs) or an invented internal URL (`proc://*`).
+*
+* Without a target, use the OpenAI Responses native-history constraints.
+*/
+function isMalformedToolCallName(name, allowedName = STRICT_TOOL_CALL_NAME_RE, maxLength = MAX_TOOL_CALL_NAME_LENGTH) {
+	return typeof name !== "string" || name.length > maxLength || !allowedName.test(name);
+}
+function isMalformedToolCallId(id) {
+	return !id || id.trim().length === 0;
+}
+function isMalformedToolCall(block, allowedName, maxLength) {
+	return isMalformedToolCallId(block.id) || isMalformedToolCallName(block.name, allowedName, maxLength);
+}
+/**
+* Drop assistant `toolCall` blocks with an empty / whitespace-only `id` or a `name`
+* the target provider cannot declare (see {@link isMalformedToolCallName}),
 * the `toolResult` messages they point at, and any assistant turn that has no
 * replayable content left.
 *
@@ -7647,26 +8482,21 @@ function deduplicateToolCallIds(messages, originScope, maxToolCallIdLength = MAX
 * Anthropic 400s on `tool_use.name` / `tool_use.id` (alongside an orphan
 * `tool_result`), OpenAI Chat Completions 400s on malformed
 * `tool_calls[i].function.*` — wedging the session in a 400 loop until manual
-* `/clear`.
+* `/clear`. Gateways also hand back the model's whole invocation text as the
+* name (observed: a 9654-char script and a NUL-separated `bash\0arg\0…` string
+* from GLM-5.3); OpenAI Responses rejects any replayed `input[N].name` over
+* 128 characters with `string_above_max_length`.
 *
 * Run before any other transform so the rest of the pipeline never sees a
-* malformed call. Idempotent: a re-run on an already-sanitized list returns
-* the input untouched. Provider-agnostic — any wire model could surface this.
+* malformed call. Idempotent for the same target: a re-run on an already-sanitized
+* list returns the input untouched.
 */
-function isMalformedToolCallName(name) {
-	return !name || name.trim().length === 0;
-}
-function isMalformedToolCallId(id) {
-	return !id || id.trim().length === 0;
-}
-function isMalformedToolCall(block) {
-	return isMalformedToolCallId(block.id) || isMalformedToolCallName(block.name);
-}
-function sanitizeMalformedToolCalls(messages) {
+function sanitizeMalformedToolCalls(messages, model) {
+	const { allowedName, maxLength } = toolCallNameLimits(model);
 	let hasMalformed = false;
 	outer: for (const msg of messages) {
 		if (msg.role !== "assistant") continue;
-		for (const block of msg.content) if (block.type === "toolCall" && isMalformedToolCall(block)) {
+		for (const block of msg.content) if (block.type === "toolCall" && isMalformedToolCall(block, allowedName, maxLength)) {
 			hasMalformed = true;
 			break outer;
 		}
@@ -7680,7 +8510,7 @@ function sanitizeMalformedToolCalls(messages) {
 			const filtered = [];
 			for (const block of msg.content) {
 				if (block.type === "toolCall") {
-					const malformed = isMalformedToolCall(block);
+					const malformed = isMalformedToolCall(block, allowedName, maxLength);
 					const queue = dropQueues.get(block.id);
 					if (queue) queue.push(malformed);
 					else dropQueues.set(block.id, [malformed]);
@@ -7710,19 +8540,41 @@ function sanitizeMalformedToolCalls(messages) {
 	}
 	return result;
 }
+/**
+* Whether {@link transformMessages} drops `msg` from every replay: a turn cut
+* off by `length` / `error` / `aborted` that carries no text and no tool call.
+*/
 function shouldDropTruncatedThinkingOnlyAssistant(msg) {
 	return (msg.stopReason === "length" || msg.stopReason === "error" || msg.stopReason === "aborted") && !msg.content.some((block) => block.type === "toolCall" || block.type === "text");
 }
-function getLatestSurvivingAssistantIndex(messages) {
+/**
+* Whether `msg` reaches a replay as an assistant turn, so it can be the latest
+* surviving one: {@link sanitizeMalformedToolCalls} drops its malformed tool
+* calls, then {@link shouldDropTruncatedThinkingOnlyAssistant} a truncated
+* turn left with no text and no tool call. On an already sanitized list this
+* is `!shouldDropTruncatedThinkingOnlyAssistant(msg)`. Pass the target `model`
+* to apply its tool-name limits; without one, any provider-declarable name survives.
+*/
+function isSurvivingAssistant(msg, model) {
+	const isTruncatedStop = msg.stopReason === "length" || msg.stopReason === "error" || msg.stopReason === "aborted";
+	if (msg.content.length === 0) return !isTruncatedStop;
+	const { allowedName, maxLength } = toolCallNameLimits(model);
+	return msg.content.some((block) => block.type === "toolCall" ? !isMalformedToolCall(block, allowedName, maxLength) : !isTruncatedStop || block.type === "text");
+}
+function getLatestSurvivingAssistantIndex(messages, model) {
 	for (let index = messages.length - 1; index >= 0; index -= 1) {
 		const msg = messages[index];
-		if (msg.role === "assistant" && !shouldDropTruncatedThinkingOnlyAssistant(msg)) return index;
+		if (msg.role === "assistant" && isSurvivingAssistant(msg, model)) return index;
 	}
 	return -1;
 }
 function isAnthropicMessagesModel(model) {
 	return model.api === "anthropic-messages";
 }
+/** Whether `turn` came from `model` itself: its own turns replay their native reasoning unchanged. */
+function isSameModelTurn(turn, model) {
+	return turn.provider === model.provider && turn.api === model.api && turn.model === model.id;
+}
 /**
 * Targets that have proven they read unsigned foreign thinking when replayed
 * natively. This is a semantic-carry allowlist only: OpenAI-compatible
@@ -7737,37 +8589,253 @@ function targetReadsForeignThinking(model, compat) {
 	if (compat.requiresThinkingAsText) return false;
 	return model.reasoning && compat.thinkingFormat === "zai";
 }
-const ANTHROPIC_TOOL_CALL_ID_PATTERN = /^[a-zA-Z0-9_-]{1,64}$/;
-function isValidAnthropicToolCallId(id) {
-	return ANTHROPIC_TOOL_CALL_ID_PATTERN.test(id);
+/**
+* Whether the target's encoder already replays the target's own plaintext
+* reasoning in a native slot. Reasoning carried from another host of the same
+* model (`carriesReasoning`) takes exactly that path, so this is derived from
+* the flags the encoders branch on rather than declared per host:
+* - chat completions writes a reasoning field or content part for thinking
+*   blocks only under these flags; otherwise it drops them.
+* - the Responses wire replays reasoning items unless history is filtered, and
+*   hosts that require reasoning replay already receive id-less plaintext
+*   items from omp (the `requiresReasoningContent*` safety net). OpenRouter's
+*   chat fallback shares the tool-call flag.
+* - Devin sends every turn's thinking in the prompt's `thinking` field.
+* Anthropic-format targets that accept unsigned thinking already read it via
+* `targetReadsForeignThinking`; Bedrock and Google reject or ignore unsigned
+* reasoning, and Codex hosts no portable family.
+*/
+function targetReplaysPlaintextReasoning(model, compat) {
+	if (!model.reasoning || compat === void 0) return false;
+	if (model.api === "devin-agent") return true;
+	if (!("requiresReasoningContentForToolCalls" in compat)) return false;
+	switch (model.api) {
+		case "openai-completions": return !compat.requiresThinkingAsText && (compat.mistralReasoningContentParts === true || compat.requiresReasoningContentForToolCalls || compat.thinkingFormat === "zai" || compat.replayReasoningContent);
+		case "openrouter": return !compat.filterReasoningHistory && compat.requiresReasoningContentForToolCalls;
+		case "openai-responses": return !compat.filterReasoningHistory && (compat.requiresReasoningContentForToolCalls || compat.requiresReasoningContentForAllAssistantTurns);
+		default: return false;
+	}
 }
 function fallbackAnthropicToolCallId(originalId) {
 	return `toolu_${Bun.hash(originalId).toString(36)}`;
 }
-function normalizeAnthropicTargetToolCallId(id, model, source, normalizeToolCallId) {
-	if (isValidAnthropicToolCallId(id)) return id;
-	const normalized = normalizeToolCallId?.(id, model, source) ?? id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, MAX_TOOL_CALL_ID_LENGTH);
-	if (isValidAnthropicToolCallId(normalized)) return normalized;
+function normalizeAnthropicTargetToolCallId(id, model, source, normalizeId) {
+	if (isValidToolCallId(id)) return id;
+	const normalized = normalizeId?.(id, model, source) ?? normalizeToolCallId(id);
+	if (isValidToolCallId(normalized)) return normalized;
 	return fallbackAnthropicToolCallId(id);
 }
+/**
+* Normalize tool call ID for cross-provider compatibility.
+* OpenAI Responses API generates IDs that are 450+ chars with special characters like `|`.
+* Anthropic APIs require IDs matching ^[a-zA-Z0-9_-]+$ (max 64 chars).
+*
+* For aborted/errored turns, this function:
+* - Preserves tool call structure (unlike converting to text summaries)
+* - Injects synthetic "aborted" tool results
+*/
+/**
+* Credential-shaped token patterns scrubbed from outbound provider traffic when
+* credential redaction is enabled. Exported so hosts can route the same shapes
+* through reversible obfuscation (keyed placeholders restored before local tool
+* execution) instead of the irreversible `[*_token_redacted]` rewrite below —
+* an irreversible placeholder echoed back in edit-tool `old_string` can never
+* match the real bytes on disk.
+*/
+const SENSITIVE_TOKEN_RE = /(?<![a-zA-Z0-9_*-])(gh[opusr]_[a-zA-Z0-9_*]{36,}|github_pat_[a-zA-Z0-9_*]{36,}|glpat-[a-zA-Z0-9_*-]{20,}|sk-proj-[a-zA-Z0-9_*-]{36,}|sk-ant-[a-zA-Z0-9_*-]{36,}|sk-[a-zA-Z0-9_*-]{48,})(?![a-zA-Z0-9_*-])/gi;
+function hasPlausibleCredentialEntropy(token) {
+	const lower = token.toLowerCase();
+	const prefixLength = lower.startsWith("github_pat_") ? 11 : lower.startsWith("glpat-") ? 6 : lower.startsWith("sk-proj-") ? 8 : lower.startsWith("sk-ant-") ? 7 : lower.startsWith("gh") ? 4 : 3;
+	const secret = token.slice(prefixLength);
+	if (/^\*+$/.test(secret)) return true;
+	return [
+		/[a-z]/,
+		/[A-Z]/,
+		/\d/,
+		/[_-]/
+	].filter((pattern) => pattern.test(secret)).length >= 2;
+}
+/**
+* Whether outbound credential-pattern redaction is active outside any
+* {@link withCredentialRedaction} scope. Off by default; hosts opt in
+* explicitly (the coding agent wires this to the `secrets.enabled` setting).
+*/
+let credentialRedactionEnabled = false;
+/** Per-request override of {@link credentialRedactionEnabled}; see {@link withCredentialRedaction}. */
+const credentialRedactionScope = new AsyncLocalStorage();
+/** Redaction policy for the request being built: its scope's, else the process-wide switch. */
+function isCredentialRedactionActive() {
+	return credentialRedactionScope.getStore() ?? credentialRedactionEnabled;
+}
 function redactSensitiveCredentials(text) {
-	return text;
+	if (!isCredentialRedactionActive()) return text;
+	return text.replace(SENSITIVE_TOKEN_RE, (match) => {
+		if (!hasPlausibleCredentialEntropy(match)) return match;
+		const lower = match.toLowerCase();
+		if (lower.startsWith("gh")) return "[github_token_redacted]";
+		if (lower.startsWith("gl")) return "[gitlab_token_redacted]";
+		if (lower.startsWith("sk-ant-")) return "[anthropic_token_redacted]";
+		if (lower.startsWith("sk")) return "[openai_token_redacted]";
+		return "[token_redacted]";
+	});
 }
 function redactSensitiveInObject(val) {
+	if (!isCredentialRedactionActive()) return {
+		result: val,
+		changed: false
+	};
+	if (typeof val === "string") {
+		const redacted = redactSensitiveCredentials(val);
+		return {
+			result: redacted,
+			changed: redacted !== val
+		};
+	}
+	if (Array.isArray(val)) {
+		let result;
+		for (let i = 0; i < val.length; i++) {
+			const sub = redactSensitiveInObject(val[i]);
+			if (!sub.changed) continue;
+			result ??= val.slice();
+			result[i] = sub.result;
+		}
+		return result ? {
+			result,
+			changed: true
+		} : {
+			result: val,
+			changed: false
+		};
+	}
+	if (val !== null && typeof val === "object") {
+		const entries = Object.entries(val);
+		let result;
+		for (const [k, v] of entries) {
+			const sub = redactSensitiveInObject(v);
+			if (!sub.changed) continue;
+			result ??= Object.fromEntries(entries);
+			result[k] = sub.result;
+		}
+		return result ? {
+			result,
+			changed: true
+		} : {
+			result: val,
+			changed: false
+		};
+	}
 	return {
 		result: val,
 		changed: false
 	};
 }
 function redactSensitiveCredentialsInMessages(messages) {
-	return messages;
+	if (!isCredentialRedactionActive()) return messages;
+	return messages.map((msg) => {
+		if (msg.role === "user" || msg.role === "developer") {
+			const userMsg = msg;
+			if (typeof userMsg.content === "string") {
+				const redacted = redactSensitiveCredentials(userMsg.content);
+				if (redacted === userMsg.content) return msg;
+				return {
+					...userMsg,
+					content: redacted
+				};
+			}
+			const contentArray = userMsg.content;
+			let changed = false;
+			const content = contentArray.map((block) => {
+				if (block.type === "text") {
+					const redacted = redactSensitiveCredentials(block.text);
+					if (redacted !== block.text) {
+						changed = true;
+						return {
+							...block,
+							text: redacted
+						};
+					}
+				}
+				return block;
+			});
+			return changed ? {
+				...userMsg,
+				content
+			} : userMsg;
+		}
+		if (msg.role === "toolResult") {
+			const toolResultMsg = msg;
+			let changed = false;
+			const content = toolResultMsg.content.map((block) => {
+				if (block.type === "text") {
+					const redacted = redactSensitiveCredentials(block.text);
+					if (redacted !== block.text) {
+						changed = true;
+						return {
+							...block,
+							text: redacted
+						};
+					}
+				}
+				return block;
+			});
+			return changed ? {
+				...toolResultMsg,
+				content
+			} : toolResultMsg;
+		}
+		if (msg.role === "assistant") {
+			const assistantMsg = msg;
+			let changed = false;
+			const content = assistantMsg.content.map((block) => {
+				if (block.type === "text") {
+					const redacted = redactSensitiveCredentials(block.text);
+					if (redacted !== block.text) {
+						changed = true;
+						return {
+							...block,
+							text: redacted
+						};
+					}
+				} else if (block.type === "thinking") {
+					const redacted = redactSensitiveCredentials(block.thinking);
+					if (redacted !== block.thinking) {
+						changed = true;
+						return {
+							...block,
+							thinking: redacted,
+							thinkingSignature: void 0
+						};
+					}
+				} else if (block.type === "toolCall") {
+					if (block.arguments) {
+						const { result: redactedArgs, changed: argsChanged } = redactSensitiveInObject(block.arguments);
+						if (argsChanged) {
+							changed = true;
+							const castArgs = redactedArgs && typeof redactedArgs === "object" && !Array.isArray(redactedArgs) ? redactedArgs : void 0;
+							return {
+								...block,
+								arguments: castArgs,
+								thoughtSignature: void 0
+							};
+						}
+					}
+				}
+				return block;
+			});
+			return changed ? {
+				...assistantMsg,
+				content
+			} : assistantMsg;
+		}
+		return msg;
+	});
 }
-function transformMessages(messages, model, normalizeToolCallId, maxNormalizedToolCallIdLength = MAX_TOOL_CALL_ID_LENGTH, duplicateToolCallIdSuffixPrefix = "_dup", targetCompat = model.compat) {
+function transformMessages(messages, model, normalizeToolCallId, maxNormalizedToolCallIdLength = 64, duplicateToolCallIdSuffixPrefix = "_dup", targetCompat = model.compat, targetCredentialId) {
 	messages = redactSensitiveCredentialsInMessages(messages);
-	messages = sanitizeMalformedToolCalls(messages);
+	messages = sanitizeMalformedToolCalls(messages, model);
 	const toolCallIdMap = /* @__PURE__ */ new Map();
 	const responsesCompositeIdMap = /* @__PURE__ */ new Map();
-	const latestSurvivingAssistantIndex = getLatestSurvivingAssistantIndex(messages);
+	const latestSurvivingAssistantIndex = getLatestSurvivingAssistantIndex(messages, model);
 	const invalidBoundThinkingAssistantIndexes = /* @__PURE__ */ new Set();
 	if (model.thinking?.prefixBinding) {
 		let latestRewriteAt;
@@ -7778,6 +8846,9 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 			else if (message.role === "assistant" && latestRewriteAt !== void 0 && message.timestamp <= latestRewriteAt) invalidBoundThinkingAssistantIndexes.add(index);
 		}
 	}
+	const targetHasReasoningSlot = targetReplaysPlaintextReasoning(model, targetCompat);
+	const responsesComponents = /* @__PURE__ */ new Set();
+	const opaqueCompositeCallIds = /* @__PURE__ */ new Set();
 	const normalizedMessages = messages.map((msg, index) => {
 		if (msg.role === "user" || msg.role === "developer") return msg;
 		if (msg.role === "toolResult") {
@@ -7790,13 +8861,19 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 		}
 		if (msg.role === "assistant") {
 			const assistantMsg = msg;
-			const isSameModel = assistantMsg.provider === model.provider && assistantMsg.api === model.api && assistantMsg.model === model.id;
+			const isSameModel = isSameModelTurn(assistantMsg, model);
+			const carriesSameModelReasoning = !isSameModel && assistantMsg.stopReason !== "error" && targetHasReasoningSlot && carriesReasoning({
+				provider: assistantMsg.provider,
+				api: assistantMsg.api,
+				model: assistantMsg.upstreamModel ?? assistantMsg.model
+			}, model);
 			const isAnthropicTarget = isAnthropicMessagesModel(model);
 			const isAnthropicReplay = isAnthropicTarget && assistantMsg.api === "anthropic-messages";
 			const sameAnthropicDeployment = isAnthropicReplay && assistantMsg.provider === model.provider && (model.compat.officialEndpoint || model.thinking?.prefixBinding === true);
 			const isLatestSurvivingAssistant = index === latestSurvivingAssistantIndex;
 			const isOfficialAnthropicSource = isAnthropicReplay && assistantMsg.provider === "anthropic";
 			const isSigningAnthropicTarget = isAnthropicTarget && model.compat.signingEndpoint;
+			const foreignCredential = isSigningAnthropicTarget && assistantMsg.credentialId !== void 0 && targetCredentialId !== void 0 && assistantMsg.credentialId !== targetCredentialId;
 			const signingAnthropicInvolved = isOfficialAnthropicSource || isSigningAnthropicTarget;
 			const replaysUnsignedAnthropicThinking = isAnthropicTarget && model.compat.replayUnsignedThinking;
 			const invalidStopReason = assistantMsg.stopReason === "aborted" || assistantMsg.stopReason === "error";
@@ -7814,6 +8891,7 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 			const hasVisibleAnthropicThinking = assistantMsg.content.some((candidate) => candidate.type === "thinking");
 			const dropsAllSameModelVisibleThinking = isAnthropicReplay && isSameModel && isSigningAnthropicTarget && hasVisibleAnthropicThinking && !assistantMsg.content.some(anthropicVisibleThinkingSurvivesReplay);
 			const transformedContent = assistantMsg.content.flatMap((block, blockIndex) => {
+				if (foreignCredential && (block.type === "thinking" || block.type === "redactedThinking")) return [];
 				if (invalidBoundThinkingAssistantIndexes.has(index) && (block.type === "thinking" || block.type === "redactedThinking")) return [];
 				if (block.type === "thinking") {
 					let sanitized = (abandonedToolUse || invalidStopReason && blockIndex === lastBlockIndex) && block.thinkingSignature ? {
@@ -7838,6 +8916,11 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 						...sanitized,
 						thinkingSignature: void 0
 					} : sanitized;
+					if (carriesSameModelReasoning && sanitized.summary === false) return {
+						type: "thinking",
+						thinking: sanitized.thinking,
+						[kCarriedReasoning]: true
+					};
 					return {
 						type: "text",
 						text: renderDemotedThinking(model.id, sanitized.thinking),
@@ -7858,7 +8941,7 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 					return [];
 				}
 				if (block.type === "fallback") {
-					if (isAnthropicTarget && model.compat.officialEndpoint) return block;
+					if (isAnthropicTarget) return block;
 					return [];
 				}
 				if (block.type === "image") return [];
@@ -7899,6 +8982,7 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 				...finalBlock,
 				text: finalBlock.text.trimEnd()
 			};
+			recordToolCallOriginScope(assistantMsg, transformedContent, responsesComponents, opaqueCompositeCallIds);
 			return {
 				...assistantMsg,
 				content: transformedContent
@@ -7906,23 +8990,11 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 		}
 		return msg;
 	});
-	const originScope = collectToolCallOriginScope(normalizedMessages);
-	const transformed = deduplicateToolCallIds(normalizedMessages, originScope, maxNormalizedToolCallIdLength, duplicateToolCallIdSuffixPrefix);
-	const realToolResultsById = /* @__PURE__ */ new Map();
-	for (let index = 0; index < transformed.length; index++) {
-		const msg = transformed[index];
-		if (msg.role === "toolResult") {
-			const entry = {
-				index,
-				msg,
-				consumed: false
-			};
-			const key = toolCallPairingKey(msg.toolCallId, originScope);
-			const entries = realToolResultsById.get(key);
-			if (entries) entries.push(entry);
-			else realToolResultsById.set(key, [entry]);
-		}
-	}
+	const originScope = {
+		responsesComponents,
+		opaqueCompositeCallIds
+	};
+	const { messages: transformed, realToolResultsById, validToolUseIds } = deduplicateToolCallIds(normalizedMessages, originScope, maxNormalizedToolCallIdLength, duplicateToolCallIdSuffixPrefix);
 	const takeRealToolResult = (id, afterIndex) => {
 		const entries = realToolResultsById.get(toolCallPairingKey(id, originScope));
 		if (!entries) return void 0;
@@ -7932,11 +9004,6 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 			return entry.msg;
 		}
 	};
-	const validToolUseIds = /* @__PURE__ */ new Set();
-	for (const msg of transformed) {
-		if (msg.role !== "assistant") continue;
-		for (const block of msg.content) if (block.type === "toolCall") validToolUseIds.add(toolCallPairingKey(block.id, originScope));
-	}
 	const result = [];
 	let pendingToolCalls = [];
 	let pendingToolCallsStartIndex = -1;
@@ -8039,11 +9106,13 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 				for (const part of msg.content) if (part.type === "text" && part.text.trim() !== "") textParts.push(part.text);
 				if (textParts.length > 0) {
 					const errorAttr = msg.isError ? " is-error=\"true\"" : "";
-					result.push({
+					const note = {
 						role: "user",
 						content: `<stale-tool-result tool="${msg.toolName}" id="${msg.toolCallId}"${errorAttr}>\n${textParts.join("\n")}\n</stale-tool-result>`,
 						timestamp: messageTimestamp
-					});
+					};
+					note[kSyntheticUser] = true;
+					result.push(note);
 				}
 			}
 		} else if (msg.role === "user" || msg.role === "developer") {
@@ -8061,7 +9130,7 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 	return result;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils.ts
 const NON_WHITESPACE_RE = /\S/;
 /**
 * Read a header value ignoring key casing. HTTP header names are
@@ -8078,16 +9147,12 @@ function normalizeSystemPrompts(systemPrompt) {
 	if (systemPrompt === void 0 || systemPrompt === null) return [];
 	return (Array.isArray(systemPrompt) ? systemPrompt : typeof systemPrompt === "string" ? [systemPrompt] : []).map((prompt) => redactSensitiveCredentials(prompt.toWellFormed())).filter((prompt) => prompt.trim().length > 0);
 }
-function normalizeToolCallId(id) {
-	const sanitized = id.replace(/[^a-zA-Z0-9_-]/g, "_");
-	return sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
-}
 /** Preserve opaque call IDs for Responses replay while normalizing or generating the separate item ID. */
 function normalizeResponsesToolCallId(id, itemPrefix = "fc") {
-	const [callId, itemId] = id.split("|");
-	if (callId && itemId) return {
-		callId,
-		itemId: normalizeResponsesItemId(itemId, itemPrefix)
+	const sep = id.search(/[\n|]/);
+	if (sep > 0) return {
+		callId: id.slice(0, sep),
+		itemId: normalizeResponsesItemId(id.slice(sep + 1), itemPrefix)
 	};
 	return {
 		callId: id,
@@ -8158,6 +9223,18 @@ function clampReplayItemImageDetail(item, supportsImageDetailOriginal) {
 		content
 	} : item;
 }
+/** Clamp replayed images without changing item identities or other native replay fields. */
+function clampOpenAIResponsesImageDetailForReplay(items, supportsImageDetailOriginal) {
+	if (supportsImageDetailOriginal) return items;
+	let clamped;
+	for (let index = 0; index < items.length; index++) {
+		const item = items[index];
+		const clampedItem = clampReplayItemImageDetail(item, supportsImageDetailOriginal);
+		if (clampedItem !== item && !clamped) clamped = items.slice(0, index);
+		clamped?.push(clampedItem);
+	}
+	return clamped ?? items;
+}
 function isOpenAIResponsesClientInputBoundary(item) {
 	if (item.type === "message") return item.role !== "assistant";
 	if (item.type === void 0 && typeof item.role === "string") return item.role !== "assistant";
@@ -8202,9 +9279,10 @@ function collectOpenAIResponsesComputerLinkedReasoningItems(items, requireLaterO
 }
 const provisionalOpenAIResponsesComputerReasoningItems = /* @__PURE__ */ new WeakSet();
 function sanitizeOpenAIResponsesHistoryItemsForReplay(items, options = {}) {
-	const supportsImageDetailOriginal = options.supportsImageDetailOriginal !== false;
-	const computerLinkedReasoningItems = options.supportsComputerUse === false ? void 0 : collectOpenAIResponsesComputerLinkedReasoningItems(items, false);
-	return stripOpenAIResponsesOutputOnlyStatusesForReplay(items.flatMap((item) => {
+	const replayItems = dropMalformedOpenAIResponsesToolCalls(items);
+	const supportsImageDetailOriginal = options.supportsImageDetailOriginal === true;
+	const computerLinkedReasoningItems = options.supportsComputerUse === false ? void 0 : collectOpenAIResponsesComputerLinkedReasoningItems(replayItems, false);
+	return stripOpenAIResponsesOutputOnlyStatusesForReplay(replayItems.flatMap((item) => {
 		const preserveForComputer = computerLinkedReasoningItems?.has(item) === true;
 		const sanitizedItem = sanitizeOpenAIResponsesHistoryItemForReplay(item, supportsImageDetailOriginal, preserveForComputer);
 		if (preserveForComputer && sanitizedItem?.type === "reasoning") provisionalOpenAIResponsesComputerReasoningItems.add(sanitizedItem);
@@ -8272,36 +9350,77 @@ function stripUnpairedOpenAIResponsesComputerReasoningIdsForReplay(items) {
 * Returns `undefined` for hidden-empty turns that only contain reasoning and an
 * empty assistant message, allowing callers to rebuild visible transcript
 * history instead of replaying stale native state.
+*
+* When the turn does carry replayable output, whitespace-only assistant
+* messages are dropped rather than replayed. gpt-5.6 Codex ends a turn whose
+* text all landed in the `commentary` phase with an empty `final_answer`
+* message; replaying that item verbatim seeds the next turn with an empty slot
+* the model then fills - `""` → `"\n\n"` → stray words → non-Latin residue -
+* and each contaminated item is replayed in turn, so the drift compounds until
+* the visible answer collapses. Codex CLI replays the empty item too
+* (openai/codex#32389); this is the layer where omp can refuse to.
 */
 function sanitizeOpenAIResponsesAssistantHistoryItemsForReplay(items, options = {}) {
 	const sanitized = sanitizeOpenAIResponsesHistoryItemsForReplay(items, options);
 	let hasReplayableAssistantOutput = false;
+	let hasEmptyAssistantMessage = false;
 	for (const item of sanitized) {
 		if (item.type === "reasoning") continue;
-		if (item.type !== "message" || item.role !== "assistant") {
-			hasReplayableAssistantOutput = true;
-			break;
+		if (isEmptyAssistantMessage(item)) {
+			hasEmptyAssistantMessage = true;
+			continue;
 		}
-		if (typeof item.content === "string") {
-			if (NON_WHITESPACE_RE.test(item.content)) {
-				hasReplayableAssistantOutput = true;
-				break;
-			}
+		hasReplayableAssistantOutput = true;
+	}
+	if (!hasReplayableAssistantOutput) return void 0;
+	if (!hasEmptyAssistantMessage) return sanitized;
+	return dropEmptyAssistantMessagesForReplay(sanitized);
+}
+function isEmptyAssistantMessage(item) {
+	if (item.type !== "message" || item.role !== "assistant") return false;
+	if (typeof item.content === "string") return !NON_WHITESPACE_RE.test(item.content);
+	for (const part of item.content) {
+		if (part.type === "output_text" && NON_WHITESPACE_RE.test(part.text)) return false;
+		if (part.type === "refusal" && NON_WHITESPACE_RE.test(part.refusal)) return false;
+	}
+	return true;
+}
+/**
+* Remove whitespace-only assistant messages plus any reasoning item left with
+* no output to introduce: a reasoning item is only meaningful ahead of the
+* output it produced, and a dangling one is rejected by the Responses API when
+* it carries an id.
+*/
+function dropEmptyAssistantMessagesForReplay(items) {
+	const kept = [];
+	let pendingReasoning = [];
+	let removedAssistantMessage = false;
+	const flushReasoning = () => {
+		kept.push(...pendingReasoning);
+		pendingReasoning = [];
+	};
+	for (const item of items) {
+		if (isOpenAIResponsesClientInputBoundary(item)) {
+			pendingReasoning = [];
+			removedAssistantMessage = false;
+			kept.push(item);
 			continue;
 		}
-		for (const part of item.content) {
-			if (part.type === "output_text" && NON_WHITESPACE_RE.test(part.text)) {
-				hasReplayableAssistantOutput = true;
-				break;
-			}
-			if (part.type === "refusal" && NON_WHITESPACE_RE.test(part.refusal)) {
-				hasReplayableAssistantOutput = true;
-				break;
-			}
+		if (item.type === "reasoning") {
+			if (removedAssistantMessage) pendingReasoning = [];
+			removedAssistantMessage = false;
+			pendingReasoning.push(item);
+			continue;
 		}
-		if (hasReplayableAssistantOutput) break;
+		if (isEmptyAssistantMessage(item)) {
+			removedAssistantMessage = true;
+			continue;
+		}
+		flushReasoning();
+		removedAssistantMessage = false;
+		kept.push(item);
 	}
-	return hasReplayableAssistantOutput ? sanitized : void 0;
+	return kept;
 }
 /**
 * Drop hidden-only fallback assistant replay after a native Responses snapshot is rejected.
@@ -8330,20 +9449,129 @@ function sanitizeOpenAIResponsesAssistantFallbackItemsForReplay(items) {
 	}
 	return sanitized;
 }
-function sanitizeOpenAIResponsesHistoryItemForReplay(item, supportsImageDetailOriginal, preserveReasoningItemIds) {
-	if (item.type === "function_call") {
-		if (typeof item.arguments !== "string" || item.arguments.trim().length === 0) return void 0;
-		try {
-			JSON.parse(item.arguments);
-		} catch {
-			return;
+/** Native tool call whose name {@link isMalformedToolCallName} rejects. */
+function isMalformedOpenAIResponsesToolCall(item) {
+	return (item.type === "function_call" || item.type === "custom_tool_call") && isMalformedToolCallName(item.name);
+}
+function malformedResponsesCallKind(type) {
+	if (type === "function_call") return "function";
+	if (type === "custom_tool_call") return "custom";
+}
+function malformedResponsesOutputKind(type) {
+	if (type === "function_call_output") return "function";
+	if (type === "custom_tool_call_output") return "custom";
+}
+/** Tool results stay inside the pairing window; other client input starts a new one. */
+function isResponsesToolResultItem(type) {
+	return type === "function_call_output" || type === "custom_tool_call_output" || type === "computer_call_output" || type === "local_shell_call_output" || type === "shell_call_output" || type === "apply_patch_call_output";
+}
+/**
+* User/developer messages and other non-result client input end the current
+* call/output window. A malformed call whose output never arrived must not
+* consume a later valid call that reuses the same `call_id`.
+*/
+function breaksMalformedResponsesPairingWindow(item) {
+	if (isResponsesToolResultItem(item.type)) return false;
+	return isOpenAIResponsesClientInputBoundary(item);
+}
+/**
+* Drop each native tool call with a malformed name and only the matching
+* `function_call_output` / `custom_tool_call_output` in the same window.
+*
+* `call_id` is not unique across a snapshot. Pair the same way
+* `sanitizeMalformedToolCalls` does for transcript messages: a per-id FIFO of
+* malformed-ness, keyed by function vs custom, cleared at user/developer and
+* other non-result client boundaries so a missing result cannot eat the next
+* window's output. Returns `items` itself when nothing is malformed.
+*/
+function dropMalformedOpenAIResponsesToolCalls(items) {
+	let hasMalformed = false;
+	for (const item of items) if (isMalformedOpenAIResponsesToolCall(item)) {
+		hasMalformed = true;
+		break;
+	}
+	if (!hasMalformed) return items;
+	const dropQueues = /* @__PURE__ */ new Map();
+	const kept = [];
+	for (const item of items) {
+		const callKind = malformedResponsesCallKind(item.type);
+		if (callKind) {
+			const malformed = isMalformedOpenAIResponsesToolCall(item);
+			const callId = typeof item.call_id === "string" ? item.call_id : void 0;
+			if (callId !== void 0) {
+				const key = `${callKind}\0${callId}`;
+				const queue = dropQueues.get(key);
+				if (queue) queue.push(malformed);
+				else dropQueues.set(key, [malformed]);
+			}
+			if (malformed) continue;
+			kept.push(item);
+			continue;
 		}
+		const outputKind = malformedResponsesOutputKind(item.type);
+		if (outputKind) {
+			const callId = typeof item.call_id === "string" ? item.call_id : void 0;
+			if (callId !== void 0) {
+				const key = `${outputKind}\0${callId}`;
+				const queue = dropQueues.get(key);
+				if (queue && queue.length > 0) {
+					const drop = queue.shift() === true;
+					if (queue.length === 0) dropQueues.delete(key);
+					if (drop) continue;
+				}
+			}
+			kept.push(item);
+			continue;
+		}
+		if (breaksMalformedResponsesPairingWindow(item)) dropQueues.clear();
+		kept.push(item);
 	}
+	return kept;
+}
+/**
+* Replay history is immutable and re-sanitized on every request, so each item
+* remembers the replay `arguments` derived from its stored value instead of
+* re-parsing every historical call (large write/edit payloads) per request.
+* Frozen/sealed caller-owned items are never mutated; they re-parse instead.
+*/
+const kReplayArguments = Symbol("openaiResponses.replayArguments");
+/**
+* `arguments` to replay for a native `function_call`: the stored string when it
+* parses, `{}` when absent/blank, else the bounded `{__parseError, __rawJson}`
+* diagnostic the transcript (and the cold replay path) already carries.
+*
+* Unparsable text (stream cut off mid-JSON) 400s the whole request, but dropping
+* the call orphans its recorded tool result into an assistant note that can end
+* the request and 400 it again (#15568).
+*/
+function replayFunctionCallArguments(item) {
+	const raw = item.arguments;
+	const cached = item[kReplayArguments];
+	if (cached && cached.raw === raw) return cached.replay;
+	let replay = "{}";
+	if (typeof raw === "string" && raw.trim().length > 0) try {
+		JSON.parse(raw);
+		replay = raw;
+	} catch (error) {
+		replay = JSON.stringify(invalidToolCallArguments(raw, error));
+	}
+	if (Object.isExtensible(item)) Object.defineProperty(item, kReplayArguments, {
+		value: {
+			raw,
+			replay
+		},
+		writable: true
+	});
+	return replay;
+}
+function sanitizeOpenAIResponsesHistoryItemForReplay(item, supportsImageDetailOriginal, preserveReasoningItemIds) {
+	if (isMalformedOpenAIResponsesToolCall(item)) return;
 	if (item.type === "item_reference") return void 0;
 	if (item.type === "image_generation_call") return sanitizeOpenAIResponsesImageGenerationCallForReplay(item);
 	if (item.type === "reasoning") return sanitizeOpenAIResponsesReasoningItemForReplay(item, preserveReasoningItemIds);
 	const { id: _id, ...sanitizedItem } = item;
 	if (item.type === "computer_call" && typeof item.id === "string") sanitizedItem.id = item.id;
+	if (item.type === "function_call") sanitizedItem.arguments = replayFunctionCallArguments(item);
 	return clampReplayItemImageDetail(sanitizedItem, supportsImageDetailOriginal);
 }
 function sanitizeOpenAIResponsesReasoningItemForReplay(item, preserveItemId) {
@@ -8395,4 +9623,4 @@ function resolveCacheRetention(cacheRetention, fallback = "short") {
 	return fallback;
 }
 //#endregion
-export { toolWireSchema as A, spillToDescription as B, kStreamingLastParseLen as C, FencedThinkingScanner as D, createInbandScanner as E, normalizeSchemaForMoonshot as F, getBundledModelReferenceIndex as H, sanitizeSchemaForCursor as I, sanitizeSchemaForGrammar as L, adaptSchemaForStrict as M, normalizeSchemaForCCA as N, partialSuffixOverlapAny as O, normalizeSchemaForGoogle as P, sanitizeSchemaForOllama as R, kStreamingEnvelopeId as S, renderDemotedThinking as T, stringifyJson$1 as U, COMBINATOR_KEYS as V, tryParseJson as W, isDemotedThinking as _, normalizeResponsesToolCallId as a, kStreamingBlockIndex as b, resolveCacheRetention as c, sanitizeOpenAIResponsesHistoryItemsForReplay as d, stripOpenAIResponsesComputerLinkedReasoningIdsForReplay as f, clearStreamingPartialJson as g, transformMessages as h, getOpenAIResponsesHistoryPayload as i, NO_STRICT as j, flattenExclusiveRequiredRootUnion as k, sanitizeOpenAIResponsesAssistantFallbackItemsForReplay as l, redactSensitiveInObject as m, getHeaderCaseInsensitive as n, normalizeSystemPrompts as o, stripUnpairedOpenAIResponsesComputerReasoningIdsForReplay as p, getOpenAIResponsesHistoryItems as r, normalizeToolCallId as s, createOpenAIResponsesHistoryPayload as t, sanitizeOpenAIResponsesAssistantHistoryItemsForReplay as u, kCursorExecResolved as v, kStreamingPartialJson as w, kStreamingBlockKind as x, kStreamingArgumentsDone as y, sanitizeSchemaForOpenAIResponses as z };
+export { normalizeSchemaForMoonshot as $, kConversationalUser as A, FencedThinkingScanner as B, clearStreamingPartialJson as C, isDemotedThinking as D, isConversationalUser as E, kStreamingEnvelopeId as F, flattenExclusiveRequiredRootUnion as G, parseToolCallArguments as H, kStreamingLastParseLen as I, toFoundationModelsSchema as J, toolWireSchema as K, kStreamingPartialJson as L, kStreamingArgumentsDone as M, kStreamingBlockIndex as N, isPerCallContextMessage as O, kStreamingBlockKind as P, normalizeSchemaForGoogle as Q, renderDemotedThinking as R, transformMessages as S, isCarriedReasoning as T, replayableToolCallArguments as U, TerminatorWait as V, partialSuffixOverlapAny as W, adaptSchemaForStrict as X, NO_STRICT as Y, normalizeSchemaForCCA as Z, isValidToolCallId as _, getOpenAIResponsesHistoryItems as a, COMBINATOR_KEYS as at, redactSensitiveInObject as b, normalizeSystemPrompts as c, sanitizeText as ct, sanitizeOpenAIResponsesAssistantHistoryItemsForReplay as d, sanitizeSchemaForCursor as et, sanitizeOpenAIResponsesHistoryItemsForReplay as f, isResponsesFamilyApi as g, truncateResponseItemId as h, getHeaderCaseInsensitive as i, spillToDescription as it, kCursorExecResolved as j, isSyntheticUser as k, resolveCacheRetention as l, stringifyJson$1 as lt, stripUnpairedOpenAIResponsesComputerReasoningIdsForReplay as m, createOpenAIResponsesHistoryPayload as n, sanitizeSchemaForOllama as nt, getOpenAIResponsesHistoryPayload as o, getBundledModelReferenceIndex as ot, stripOpenAIResponsesComputerLinkedReasoningIdsForReplay as p, decodeFoundationModelsArguments as q, dropMalformedOpenAIResponsesToolCalls as r, sanitizeSchemaForOpenAIResponses as rt, normalizeResponsesToolCallId as s, resolveCatalogPolicy as st, clampOpenAIResponsesImageDetailForReplay as t, sanitizeSchemaForGrammar as tt, sanitizeOpenAIResponsesAssistantFallbackItemsForReplay as u, tryParseJson as ut, normalizeToolCallId as v, copyPerCallContextMessage as w, responsesCallComponent as x, redactSensitiveCredentials as y, createInbandScanner as z };