@xiaoso/dsh-tool-plus 0.1.6 → 0.1.7-beta.0

package/lib/{utils-Cp2Mxf_U.mjs → utils-CUPhpw9A.mjs}

@@ -1,9 +1,11 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
-import { I as $flag, P as $env, S as debug, g as parseStreamingJson, h as parseJsonWithRepair } from "./src-BcD0_rQR.mjs";
-import { r as ValidationError } from "./error-C-f_Wnw4.mjs";
-import { t as preferredDialect } from "./identity-HNO1Oe9B.mjs";
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/json.ts
+import { F as $flag, N as $env, _ as parseStreamingJson, b as debug, g as parseJsonWithRepair } from "./src-BwW51vA5.mjs";
+import { r as ValidationError } from "./error-CORgGg5a.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
 /**
 * Try to parse JSON, returning null on failure.
 */
@@ -27,10 +29,46 @@ function stringifyJson$1(value, space) {
 	return JSON.stringify(value, (_key, item) => typeof item === "bigint" ? item.toString() : item, space);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/anthropic.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.1.17/node_modules/@oh-my-pi/pi-catalog/src/identity/bundled.ts
+/**
+* Memoized proxy-reference index over the bundled model catalog.
+*
+* Lazy: walking every bundled model (~12K) triggers thinking enrichment, so the
+* walk is deferred off module load and performed once. Consumers that need
+* non-bundled reference data use the pure builder directly
+* ({@link buildModelReferenceIndex}).
+*/
+let bundledModels;
+function getBundledModelList() {
+	bundledModels ??= getBundledProviders().flatMap((provider) => getBundledModels(provider));
+	return bundledModels;
+}
+let referenceIndex;
+/** Proxy-reference index over the bundled catalog. */
+function getBundledModelReferenceIndex() {
+	referenceIndex ??= buildModelReferenceIndex(getBundledModelList());
+	return referenceIndex;
+}
+function preferredDialect(modelId) {
+	switch (classifyModel("", modelId, { lenient: true }).class) {
+		case "anthropic": return "anthropic";
+		case "glm": return "glm";
+		case "gemini": return "gemini";
+		case "gemma": return "gemma";
+		case "kimi": return "kimi";
+		case "qwen": return "qwen3";
+		case "deepseek": return "deepseek";
+		case "minimax": return "minimax";
+		case "openai":
+		case "gpt-oss": return "harmony";
+		default: return "xml";
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/schema/types.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/types.ts
 function isJsonObject(value) {
 	return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -39,7 +77,7 @@ function isJsonObjectEmpty(value) {
 	return Object.keys(value).length === 0;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/schema/equality.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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)) {
@@ -92,7 +130,7 @@ function mergePropertySchemas(existing, incoming) {
 	return mergedAnyOf.length === 1 ? mergedAnyOf[0] : { anyOf: mergedAnyOf };
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/schema/stamps.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/stamps.ts
 /**
 * Symbol-keyed lazy memoization stamped directly onto the host object.
 *
@@ -198,7 +236,7 @@ function exit(target) {
 	slot[kDepth] = cur - 1;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/schema/draft.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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 = {
@@ -467,7 +505,7 @@ function upgradeJsonSchemaTo202012(schema) {
 	return upgradeJsonSchemaTo202012Impl(schema, /* @__PURE__ */ new WeakMap());
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/schema/dereference.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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.
@@ -545,7 +583,7 @@ function dereferenceJsonSchema(schema) {
 	return dereferenceNode(schema, schema, /* @__PURE__ */ new Set());
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/schema/fields.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/fields.ts
 /**
 * Field classification sets for JSON Schema sanitization across providers.
 *
@@ -586,7 +624,12 @@ const UNSUPPORTED_SCHEMA_FIELDS = {
 	format: true,
 	dependencies: true,
 	dependentSchemas: true,
-	dependentRequired: true
+	dependentRequired: true,
+	"x-mcp-header": true,
+	deprecated: true,
+	readOnly: true,
+	writeOnly: true,
+	$comment: true
 };
 /**
 * Human-meaningful validation/decorative keywords that can be preserved in a
@@ -729,11 +772,7 @@ const CLOUD_CODE_ASSIST_SHARED_SCHEMA_KEYS = {
 	title: true,
 	description: true,
 	default: true,
-	examples: true,
-	deprecated: true,
-	readOnly: true,
-	writeOnly: true,
-	$comment: true
+	examples: true
 };
 /**
 * Combinator keys used across schema sanitization modules.
@@ -756,10 +795,14 @@ const CCA_UNSUPPORTED_SCHEMA_FIELDS = {
 	$defs: true,
 	$dynamicRef: true,
 	$dynamicAnchor: true,
-	propertyNames: true
+	propertyNames: true,
+	deprecated: true,
+	readOnly: true,
+	writeOnly: true,
+	$comment: true
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/schema/meta-validator.ts
+//#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);
 }
@@ -900,7 +943,7 @@ function isValidJsonSchema(schema) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/schema/spill.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/spill.ts
 function formatSpillValue(value) {
 	return JSON.stringify(value);
 }
@@ -931,7 +974,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@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/schema/normalize.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/normalize.ts
 /**
 * Provider-specific JSON Schema normalization used in the request path.
 *
@@ -947,11 +990,12 @@ const SNAKE_TO_CAMEL_RENAMES = /* @__PURE__ */ new Map([
 	["property_ordering", "propertyOrdering"]
 ]);
 const JSON_SCHEMA_COMBINERS = ["anyOf", "oneOf"];
-const CCA_FORBIDDEN_COMBINERS = /* @__PURE__ */ new Set([
+/** The three JSON Schema composition keywords: `anyOf`, `oneOf`, `allOf`. */
+const SCHEMA_COMPOSITION_COMBINERS = [
+	"allOf",
 	"anyOf",
-	"oneOf",
-	"allOf"
-]);
+	"oneOf"
+];
 /**
 * Keywords whose value is a single subschema (draft 2020-12). A bare `true` /
 * `false` in one of these slots is a boolean subschema to coerce (issue #5604).
@@ -1312,18 +1356,24 @@ function mergeObjectCombinerVariants(schema, combiner) {
 	const nextSchema = copySchemaWithout(schema, combiner);
 	nextSchema.type = "object";
 	nextSchema.properties = mergedProperties;
-	let requiredIntersection;
-	for (const variant of variants) {
-		const variantRequired = Array.isArray(variant.required) ? variant.required.filter((r) => typeof r === "string") : [];
-		if (requiredIntersection === void 0) requiredIntersection = [...variantRequired];
+	const branchRequired = variants.map((variant) => Array.isArray(variant.required) ? variant.required.filter((r) => typeof r === "string") : []);
+	let combinedRequired;
+	if (combiner === "allOf") {
+		const union = /* @__PURE__ */ new Set();
+		for (const required of branchRequired) for (const name of required) union.add(name);
+		combinedRequired = [...union];
+	} else {
+		let intersection;
+		for (const required of branchRequired) if (intersection === void 0) intersection = [...required];
 		else {
-			const reqSet = new Set(variantRequired);
-			requiredIntersection = requiredIntersection.filter((r) => reqSet.has(r));
+			const reqSet = new Set(required);
+			intersection = intersection.filter((r) => reqSet.has(r));
 		}
+		combinedRequired = intersection ?? [];
 	}
 	const parentRequired = Array.isArray(schema.required) ? schema.required.filter((r) => typeof r === "string") : [];
 	const safeRequired = /* @__PURE__ */ new Set();
-	for (const name of requiredIntersection ?? []) if (Object.hasOwn(mergedProperties, name)) safeRequired.add(name);
+	for (const name of combinedRequired) if (Object.hasOwn(mergedProperties, name)) safeRequired.add(name);
 	for (const name of parentRequired) if (Object.hasOwn(ownProperties, name) && Object.hasOwn(mergedProperties, name)) safeRequired.add(name);
 	const requiredInPropertyOrder = [];
 	for (const name in mergedProperties) if (Object.hasOwn(mergedProperties, name) && safeRequired.has(name)) requiredInPropertyOrder.push(name);
@@ -1611,7 +1661,7 @@ function hasResidualSchemaIncompatibilities(value, checks, epoch = epochNext(),
 		if (checks.nullable && Object.hasOwn(value, "nullable")) return true;
 		if (checks.not && Object.hasOwn(value, "not")) return true;
 		if (checks.combiners) {
-			for (const combiner of CCA_FORBIDDEN_COMBINERS) if (Array.isArray(value[combiner])) return true;
+			for (const combiner of SCHEMA_COMPOSITION_COMBINERS) if (Array.isArray(value[combiner])) return true;
 		}
 	}
 	for (const key in value) {
@@ -1622,6 +1672,120 @@ function hasResidualSchemaIncompatibilities(value, checks, epoch = epochNext(),
 	}
 	return false;
 }
+/**
+* True when a JSON Schema subtree carries any composition keyword (`anyOf`,
+* `oneOf`, `allOf`) in a schema position. Property *names* that happen to equal
+* a combiner keyword (living under `properties`/`patternProperties`) are not
+* combiners and do not count.
+*/
+function containsSchemaCombiner(value, insideSchemaMap, epoch) {
+	if (Array.isArray(value)) {
+		if (!once(value, epoch)) return false;
+		return value.some((entry) => containsSchemaCombiner(entry, false, epoch));
+	}
+	if (!isJsonObject(value)) return false;
+	if (!once(value, epoch)) return false;
+	if (!insideSchemaMap) {
+		for (const combiner of SCHEMA_COMPOSITION_COMBINERS) if (Array.isArray(value[combiner])) return true;
+	}
+	for (const key in value) {
+		if (!Object.hasOwn(value, key)) continue;
+		const childKind = classifySchemaChild(key, value[key], insideSchemaMap);
+		if (childKind && containsSchemaCombiner(value[key], childKind === "map", epoch)) return true;
+	}
+	return false;
+}
+/**
+* Fold every composition keyword out of one already child-projected node while
+* only ever widening acceptance. Object-shaped `anyOf`/`oneOf`/`allOf` branches
+* merge into the node's own `properties` via {@link mergeObjectCombinerVariants}
+* (union properties, combiner-appropriate `required`); any combiner whose
+* branches are not all object-shaped — scalar unions especially — is dropped so
+* the node widens to accept-all rather than narrowing to one branch. Merging can
+* itself synthesize a fresh `anyOf` inside a shared property (see
+* {@link mergePropertySchemas}), so property values are re-projected until the
+* node is combiner-free.
+*/
+function projectNodeCombinersForCursor(node) {
+	let current = node;
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const combiner of SCHEMA_COMPOSITION_COMBINERS) {
+			if (!Array.isArray(current[combiner])) continue;
+			const source = current;
+			const merged = mergeObjectCombinerVariants(current, combiner);
+			if (merged !== current) {
+				current = merged;
+				const properties = current.properties;
+				if (isJsonObject(properties)) {
+					if (combiner !== "allOf") {
+						const sourceProperties = isJsonObject(source.properties) ? source.properties : {};
+						const sourceVariants = source[combiner];
+						for (const name in properties) {
+							if (!Object.hasOwn(properties, name)) continue;
+							if (Object.hasOwn(sourceProperties, name)) {
+								properties[name] = sourceProperties[name];
+								continue;
+							}
+							let widenedProperty;
+							for (const variant of sourceVariants) {
+								const variantProperties = isJsonObject(variant.properties) ? variant.properties : {};
+								let constraint;
+								if (Object.hasOwn(variantProperties, name)) constraint = variantProperties[name];
+								else if (variant.additionalProperties === false) continue;
+								else if (isJsonObject(variant.additionalProperties)) constraint = variant.additionalProperties;
+								else constraint = {};
+								widenedProperty = widenedProperty === void 0 ? constraint : mergePropertySchemas(widenedProperty, constraint);
+							}
+							properties[name] = widenedProperty ?? {};
+						}
+					}
+					for (const name in properties) if (Object.hasOwn(properties, name)) properties[name] = projectSchemaForCursor(properties[name], false);
+				}
+			} else current = copySchemaWithout(current, combiner);
+			changed = true;
+		}
+	}
+	return current;
+}
+function projectSchemaForCursor(value, insideSchemaMap) {
+	if (Array.isArray(value)) {
+		if (!enter(value)) return [];
+		try {
+			return value.map((entry) => projectSchemaForCursor(entry, false));
+		} finally {
+			exit(value);
+		}
+	}
+	if (!isJsonObject(value)) return value;
+	if (!enter(value)) return {};
+	try {
+		const result = {};
+		for (const key in value) {
+			if (!Object.hasOwn(value, key)) continue;
+			const entry = value[key];
+			if (!insideSchemaMap && key === "not" && containsSchemaCombiner(entry, false, epochNext())) continue;
+			const childKind = classifySchemaChild(key, entry, insideSchemaMap);
+			result[key] = childKind ? projectSchemaForCursor(entry, childKind === "map") : entry;
+		}
+		return insideSchemaMap ? result : projectNodeCombinersForCursor(result);
+	} finally {
+		exit(value);
+	}
+}
+/**
+* Project a tool's wire schema onto the subset Cursor's MCP tool catalog
+* accepts. Cursor rejects the entire request with a provider 400 when any
+* advertised schema carries a composition keyword (issue #10432); this removes
+* `anyOf`/`oneOf`/`allOf` everywhere while preserving representable guidance and
+* only ever widening acceptance, so every input the canonical schema accepts is
+* still accepted by the advertised projection. The canonical schema (used for
+* execution-time argument validation) is never mutated.
+*/
+function sanitizeSchemaForCursor(schema) {
+	return projectSchemaForCursor(dereferenceJsonSchema(schema), false);
+}
 function normalizeSchema(value, options) {
 	let normalized = normalizeSchemaNode(dereferenceJsonSchema(upgradeJsonSchemaTo202012(value)), {
 		...options,
@@ -2524,7 +2688,7 @@ function resolveStrictRef(root, ref) {
 	return isJsonObject(cursor) ? cursor : void 0;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/schema/adapt.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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
@@ -2557,7 +2721,7 @@ function adaptSchemaForStrict(schema, strict) {
 ({ ...UNSUPPORTED_SCHEMA_FIELDS });
 ({ ...CCA_UNSUPPORTED_SCHEMA_FIELDS });
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/schema/wire.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/schema/wire.ts
 /**
 * True when `value` is a live ArkType schema instance.
 *
@@ -3053,7 +3217,7 @@ function toolWireSchema(tool) {
 	});
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/coercion.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/coercion.ts
 function buildArgShapes(tools = []) {
 	const shapes = /* @__PURE__ */ new Map();
 	for (const tool of tools) {
@@ -3152,7 +3316,7 @@ function asRecord(value) {
 	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/rendering.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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");
 }
@@ -3340,7 +3504,7 @@ function appendLegacySegment(out, segment) {
 	return `${out}\n\n${segment}`;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/anthropic.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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 = {
@@ -3859,10 +4023,10 @@ const definition$10 = {
 	renderTranscript: renderTranscript$10
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/deepseek.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/deepseek.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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｜>";
@@ -3883,6 +4047,10 @@ const DSML_TOOL_CALLS_OPEN_FULLWIDTH = "<｜DSML｜tool_calls>";
 const DSML_TOOL_CALLS_CLOSE_FULLWIDTH = "</｜DSML｜tool_calls>";
 const DSML_TOOL_CALLS_OPEN_ASCII = "<|DSML|tool_calls>";
 const DSML_TOOL_CALLS_CLOSE_ASCII = "</|DSML|tool_calls>";
+const DSML_INVOKE_CLOSE_FULLWIDTH = "</｜DSML｜invoke>";
+const DSML_INVOKE_CLOSE_ASCII = "</|DSML|invoke>";
+const DSML_PARAMETER_CLOSE_FULLWIDTH = "</｜DSML｜parameter>";
+const DSML_PARAMETER_CLOSE_ASCII = "</|DSML|parameter>";
 const CONTROL_TOKENS = [
 	DEEPSEEK_BOS,
 	DEEPSEEK_EOS,
@@ -3900,6 +4068,12 @@ const CONTROL_TOKENS = [
 	DEEPSEEK_TOOL_OUTPUT_BEGIN,
 	DEEPSEEK_TOOL_OUTPUT_END
 ];
+const DSML_ORPHAN_CLOSE_TOKENS = [
+	DSML_INVOKE_CLOSE_FULLWIDTH,
+	DSML_INVOKE_CLOSE_ASCII,
+	DSML_PARAMETER_CLOSE_FULLWIDTH,
+	DSML_PARAMETER_CLOSE_ASCII
+];
 const OUTSIDE_TOKENS = [
 	DEEPSEEK_TOOL_CALLS_BEGIN,
 	DEEPSEEK_TOOL_CALLS_END,
@@ -3910,6 +4084,7 @@ const OUTSIDE_TOKENS = [
 	DSML_TOOL_CALLS_OPEN_ASCII,
 	DSML_TOOL_CALLS_CLOSE_FULLWIDTH,
 	DSML_TOOL_CALLS_CLOSE_ASCII,
+	...DSML_ORPHAN_CLOSE_TOKENS,
 	...CONTROL_TOKENS
 ];
 const SECTION_TOKENS = [DEEPSEEK_TOOL_CALL_BEGIN, DEEPSEEK_TOOL_CALLS_END];
@@ -3920,12 +4095,12 @@ const DSML_SECTION_TOKENS = [
 	"<|DSML|invoke"
 ];
 const DSML_INVOKE_TOKENS = [
-	"</｜DSML｜invoke>",
-	"</|DSML|invoke>",
+	DSML_INVOKE_CLOSE_FULLWIDTH,
+	DSML_INVOKE_CLOSE_ASCII,
 	"<｜DSML｜parameter",
 	"<|DSML|parameter"
 ];
-const DSML_PARAMETER_CLOSE_TOKENS = ["</｜DSML｜parameter>", "</|DSML|parameter>"];
+const DSML_PARAMETER_CLOSE_TOKENS = [DSML_PARAMETER_CLOSE_FULLWIDTH, DSML_PARAMETER_CLOSE_ASCII];
 var DeepSeekInbandScanner = class {
 	#buffer = "";
 	#state = "outside";
@@ -4047,6 +4222,11 @@ var DeepSeekInbandScanner = class {
 				this.#state = "dsmlSection";
 				return;
 			}
+			const orphanClose = this.#matchingOrphanDsmlClose();
+			if (orphanClose) {
+				this.#buffer = this.#buffer.slice(orphanClose.length);
+				continue;
+			}
 			const control = this.#matchingControlToken();
 			if (control) {
 				this.#buffer = this.#buffer.slice(control.length);
@@ -4306,6 +4486,9 @@ 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;
@@ -4423,7 +4606,7 @@ const definition$9 = {
 	renderTranscript: renderTranscript$9
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/fenced-thinking.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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
@@ -4598,10 +4781,10 @@ var FencedThinkingScanner = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/gemini.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/gemini.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/gemini.ts
 const CODE_OPEN = "```tool_code";
 const OUTPUT_OPEN = "```tool_outputs";
 const FENCE = "```";
@@ -5129,10 +5312,10 @@ const definition$8 = {
 	renderTranscript: renderTranscript$8
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/gemma.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/gemma.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/gemma.ts
 const CALL_OPEN = "<|tool_call>";
 const CALL_CLOSE = "<tool_call|>";
 const STRING = "<|\"|>";
@@ -5477,10 +5660,10 @@ const definition$7 = {
 	renderTranscript: renderTranscript$7
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/glm.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/glm.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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>";
@@ -6005,10 +6188,10 @@ const definition$6 = {
 	renderTranscript: renderTranscript$6
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/harmony.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/harmony.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/harmony.ts
 const START = "<|start|>";
 const END = "<|end|>";
 const MESSAGE = "<|message|>";
@@ -6316,10 +6499,10 @@ const definition$5 = {
 	renderTranscript: renderTranscript$5
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/hermes.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/hermes.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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>";
@@ -6527,10 +6710,10 @@ const definition$4 = {
 	renderTranscript: renderTranscript$4
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/kimi.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/kimi.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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|>";
@@ -6826,10 +7009,10 @@ const definition$3 = {
 	renderTranscript: renderTranscript$3
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/minimax.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/minimax.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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",
@@ -6894,10 +7077,10 @@ const definition$2 = {
 	renderTranscript: renderTranscript$2
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/qwen3.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/qwen3.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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>";
@@ -7118,10 +7301,10 @@ const definition$1 = {
 	renderTranscript: renderTranscript$1
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/xml.md
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/xml.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/xml.ts
 var XmlInbandScanner = class {
 	#inner;
 	constructor(options = {}) {
@@ -7167,7 +7350,7 @@ function renderInvokes(calls, tools) {
 	return calls.map((call) => renderInvoke(call, shapes.get(call.name))).join("\n");
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/factory.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/factory.ts
 const DIALECT_DEFINITIONS = {
 	glm: definition$6,
 	hermes: definition$4,
@@ -7197,7 +7380,7 @@ function createInbandScanner(dialect, options = {}) {
 	return getDialectDefinition(dialect).createScanner(options);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/dialect/demotion.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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
@@ -7236,7 +7419,7 @@ function renderDemotedThinking(modelId, text) {
 	return getDialectDefinition(dialect).renderThinking(text);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/block-symbols.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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. */
@@ -7288,7 +7471,7 @@ function isDemotedThinking(block) {
 	return block?.[kDemotedThinking] === true;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/transform-messages.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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";
@@ -7306,6 +7489,79 @@ var ToolCallStatus = /* @__PURE__ */ function(ToolCallStatus) {
 * MUST not push a normalized id past this bound.
 */
 const MAX_TOOL_CALL_ID_LENGTH = 64;
+/**
+* OpenAI Responses-family APIs mint composite tool ids (`call_id|item_id`);
+* opaque Chat Completions ids do not (openai-completions preserves same-model
+* ids verbatim as provider correlation tokens), so ONLY these origins may be
+* canonicalized to their `call_` component for pairing.
+*/
+function isResponsesFamilyApi(api) {
+	return api === "openai-responses" || api === "openai-codex-responses" || api === "azure-openai-responses";
+}
+/**
+* The wire `call_id` component of a (possibly composite) Responses id: the
+* FIRST segment before `|`. A degenerate `|itemId` (empty call half, pipe at
+* index 0) keeps its full id so unrelated empty-half ids never collapse onto
+* one empty-string bucket.
+*/
+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);
+		}
+	}
+	return {
+		responsesComponents,
+		opaqueCompositeCallIds
+	};
+}
+/**
+* Canonical key for pairing a tool result with its assistant tool call.
+*
+* The OpenAI Codex/Responses APIs store a tool result's id as a composite
+* `<call_id>|<response_item_id>` (e.g. `call_ABC|fc_XYZ`), while the assistant
+* `toolCall` that produced it carries the plain `call_ABC` (or a composite with
+* a DIFFERENT item half). Keying both sides on the FIRST segment pairs them,
+* while NOT collapsing two distinct parallel calls whose results happen to
+* share a `response_item` (`fc_`) half.
+*
+* SCOPING (load-bearing, #10284): a pipe-bearing id is canonicalized to its
+* `call_` component ONLY when it is not itself a concrete opaque-origin call id
+* ({@link ToolCallOriginScope.opaqueCompositeCallIds}) and its component was
+* minted by a Responses-family turn ({@link ToolCallOriginScope.responsesComponents}).
+* A same-model Chat Completions id is an OPAQUE provider correlation token that
+* may itself contain `|` (openai-completions.ts preserves it verbatim);
+* splitting it would collapse two distinct opaque calls onto one bucket, so the
+* real result never pairs and the call is back-filled with a synthetic stub.
+* Opaque ids fall through to full-id keying, where the provider's own echoed
+* `tool_call_id` already pairs result to call by raw equality.
+*
+* Pairing keys are used only for lookup; the messages' own ids are left intact
+* so the provider encoder still receives the exact wire ids it expects.
+*
+* LOAD-BEARING INVARIANT: pairing correctness depends on the wire `call_id`
+* being unique per distinct tool call. The Codex Responses wire guarantees this
+* (distinct parallel calls carry distinct call_ids; only the `fc_` half varies),
+* and genuine cross-turn id reuse is `_dup`-suffixed on the call_ segment by
+* `deduplicateToolCallIds` (which this key preserves).
+*/
+function toolCallPairingKey(id, originScope) {
+	const pipe = id.indexOf("|");
+	if (pipe <= 0) return id;
+	if (originScope.opaqueCompositeCallIds.has(id)) return id;
+	const prefix = id.slice(0, pipe);
+	return originScope.responsesComponents.has(prefix) ? prefix : id;
+}
 function appendDuplicateSuffix(originalId, suffix, maxLength) {
 	if (originalId.includes("|")) return originalId.split("|").map((segment) => appendSegmentDuplicateSuffix(segment, suffix, maxLength)).join("|");
 	return appendSegmentDuplicateSuffix(originalId, suffix, maxLength);
@@ -7315,15 +7571,16 @@ function appendSegmentDuplicateSuffix(segment, suffix, maxLength) {
 	const prefixBudget = Math.max(0, maxLength - suffix.length);
 	return `${segment.slice(0, prefixBudget)}${suffix}`;
 }
-function deduplicateToolCallIds(messages, maxToolCallIdLength = MAX_TOOL_CALL_ID_LENGTH, duplicateSuffixPrefix = "_dup") {
+function deduplicateToolCallIds(messages, originScope, maxToolCallIdLength = MAX_TOOL_CALL_ID_LENGTH, duplicateSuffixPrefix = "_dup") {
 	const seenToolCallIds = /* @__PURE__ */ new Map();
 	const pendingToolResultRewrites = /* @__PURE__ */ new Map();
 	return messages.map((msg) => {
 		if (msg.role === "toolResult") {
-			const rewrites = pendingToolResultRewrites.get(msg.toolCallId);
+			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(msg.toolCallId);
+			if (rewrites.length === 0) pendingToolResultRewrites.delete(key);
 			if (rewrite) return {
 				...msg,
 				toolCallId: rewrite.replacementId
@@ -7343,25 +7600,26 @@ function deduplicateToolCallIds(messages, maxToolCallIdLength = MAX_TOOL_CALL_ID
 		let contentChanged = false;
 		const content = msg.content.map((block) => {
 			if (block.type !== "toolCall") return block;
-			if (!idsTouchedInTurn.has(block.id)) {
-				pendingToolResultRewrites.delete(block.id);
-				idsTouchedInTurn.add(block.id);
+			const blockKey = toolCallPairingKey(block.id, originScope);
+			if (!idsTouchedInTurn.has(blockKey)) {
+				pendingToolResultRewrites.delete(blockKey);
+				idsTouchedInTurn.add(blockKey);
 			}
-			const previousCount = seenToolCallIds.get(block.id) ?? 0;
+			const previousCount = seenToolCallIds.get(blockKey) ?? 0;
 			if (previousCount === 0) {
-				seenToolCallIds.set(block.id, 1);
-				enqueueToolResultRewrite(block.id, void 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(replacementId)) {
+			while (seenToolCallIds.has(toolCallPairingKey(replacementId, originScope))) {
 				duplicateIndex += 1;
 				replacementId = appendDuplicateSuffix(block.id, `${duplicateSuffixPrefix}${duplicateIndex}`, maxToolCallIdLength);
 			}
-			seenToolCallIds.set(block.id, duplicateIndex + 1);
-			seenToolCallIds.set(replacementId, 1);
-			enqueueToolResultRewrite(block.id, { replacementId });
+			seenToolCallIds.set(blockKey, duplicateIndex + 1);
+			seenToolCallIds.set(toolCallPairingKey(replacementId, originScope), 1);
+			enqueueToolResultRewrite(blockKey, { replacementId });
 			contentChanged = true;
 			return {
 				...block,
@@ -7508,11 +7766,22 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 	messages = redactSensitiveCredentialsInMessages(messages);
 	messages = sanitizeMalformedToolCalls(messages);
 	const toolCallIdMap = /* @__PURE__ */ new Map();
+	const responsesCompositeIdMap = /* @__PURE__ */ new Map();
 	const latestSurvivingAssistantIndex = getLatestSurvivingAssistantIndex(messages);
-	const transformed = deduplicateToolCallIds(messages.map((msg, index) => {
+	const invalidBoundThinkingAssistantIndexes = /* @__PURE__ */ new Set();
+	if (model.thinking?.prefixBinding) {
+		let latestRewriteAt;
+		for (let index = 0; index < messages.length; index++) {
+			const message = messages[index];
+			if (message.role === "user" && message.historyRewriteAt !== void 0) latestRewriteAt = latestRewriteAt === void 0 ? message.historyRewriteAt : Math.max(latestRewriteAt, message.historyRewriteAt);
+			else if (message.role === "toolResult" && message.prunedAt !== void 0) latestRewriteAt = latestRewriteAt === void 0 ? message.prunedAt : Math.max(latestRewriteAt, message.prunedAt);
+			else if (message.role === "assistant" && latestRewriteAt !== void 0 && message.timestamp <= latestRewriteAt) invalidBoundThinkingAssistantIndexes.add(index);
+		}
+	}
+	const normalizedMessages = messages.map((msg, index) => {
 		if (msg.role === "user" || msg.role === "developer") return msg;
 		if (msg.role === "toolResult") {
-			const normalizedId = toolCallIdMap.get(msg.toolCallId);
+			const normalizedId = toolCallIdMap.get(msg.toolCallId) ?? (msg.toolCallId.includes("|") ? responsesCompositeIdMap.get(responsesCallComponent(msg.toolCallId)) : void 0);
 			if (normalizedId && normalizedId !== msg.toolCallId) return {
 				...msg,
 				toolCallId: normalizedId
@@ -7524,6 +7793,7 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 			const isSameModel = assistantMsg.provider === model.provider && assistantMsg.api === model.api && assistantMsg.model === model.id;
 			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;
@@ -7544,6 +7814,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 (invalidBoundThinkingAssistantIndexes.has(index) && (block.type === "thinking" || block.type === "redactedThinking")) return [];
 				if (block.type === "thinking") {
 					let sanitized = (abandonedToolUse || invalidStopReason && blockIndex === lastBlockIndex) && block.thinkingSignature ? {
 						...block,
@@ -7552,7 +7823,7 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 					if (isAnthropicReplay) {
 						const crossProviderSource = assistantMsg.provider !== model.provider;
 						if (isLatestSurvivingAssistant && abandonedToolUse && !crossProviderSource) return block;
-						if ((isLatestSurvivingAssistant ? crossProviderSource : !isSameModel) && signingAnthropicInvolved && sanitized.thinkingSignature) sanitized = {
+						if (!sameAnthropicDeployment && (isLatestSurvivingAssistant ? crossProviderSource : !isSameModel) && signingAnthropicInvolved && sanitized.thinkingSignature) sanitized = {
 							...sanitized,
 							thinkingSignature: void 0
 						};
@@ -7576,7 +7847,7 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 				if (block.type === "redactedThinking") {
 					if (isAnthropicReplay) {
 						if (dropsAllSameModelVisibleThinking) return [];
-						if (isSameModel || isLatestSurvivingAssistant && assistantMsg.provider === model.provider || replaysUnsignedAnthropicThinking) return block;
+						if (isSameModel || sameAnthropicDeployment || isLatestSurvivingAssistant && assistantMsg.provider === model.provider || replaysUnsignedAnthropicThinking) return block;
 						return [];
 					}
 					if (isSameModel) return block;
@@ -7605,17 +7876,11 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 						...toolCall,
 						thoughtSignature: void 0
 					};
+					let normalizedId;
 					if (isAnthropicTarget) {
-						const normalizedId = normalizeAnthropicTargetToolCallId(toolCall.id, model, assistantMsg, normalizeToolCallId);
-						if (normalizedId !== toolCall.id) {
-							toolCallIdMap.set(toolCall.id, normalizedId);
-							normalizedToolCall = {
-								...normalizedToolCall,
-								id: normalizedId
-							};
-						}
-					} else if (!isSameModel && normalizeToolCallId) {
-						const normalizedId = normalizeToolCallId(toolCall.id, model, assistantMsg);
+						if (!isSameModel || model.compat.officialEndpoint) normalizedId = normalizeAnthropicTargetToolCallId(toolCall.id, model, assistantMsg, normalizeToolCallId);
+					} else if (!isSameModel && normalizeToolCallId) normalizedId = normalizeToolCallId(toolCall.id, model, assistantMsg);
+					if (normalizedId !== void 0) {
 						if (normalizedId !== toolCall.id) {
 							toolCallIdMap.set(toolCall.id, normalizedId);
 							normalizedToolCall = {
@@ -7623,6 +7888,7 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 								id: normalizedId
 							};
 						}
+						if (isResponsesFamilyApi(assistantMsg.api)) responsesCompositeIdMap.set(responsesCallComponent(toolCall.id), normalizedId);
 					}
 					return normalizedToolCall;
 				}
@@ -7639,7 +7905,9 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 			};
 		}
 		return msg;
-	}), maxNormalizedToolCallIdLength, duplicateToolCallIdSuffixPrefix);
+	});
+	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];
@@ -7649,13 +7917,14 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 				msg,
 				consumed: false
 			};
-			const entries = realToolResultsById.get(msg.toolCallId);
+			const key = toolCallPairingKey(msg.toolCallId, originScope);
+			const entries = realToolResultsById.get(key);
 			if (entries) entries.push(entry);
-			else realToolResultsById.set(msg.toolCallId, [entry]);
+			else realToolResultsById.set(key, [entry]);
 		}
 	}
 	const takeRealToolResult = (id, afterIndex) => {
-		const entries = realToolResultsById.get(id);
+		const entries = realToolResultsById.get(toolCallPairingKey(id, originScope));
 		if (!entries) return void 0;
 		for (const entry of entries) {
 			if (entry.consumed || entry.index <= afterIndex) continue;
@@ -7666,7 +7935,7 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 	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(block.id);
+		for (const block of msg.content) if (block.type === "toolCall") validToolUseIds.add(toolCallPairingKey(block.id, originScope));
 	}
 	const result = [];
 	let pendingToolCalls = [];
@@ -7678,11 +7947,12 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 	const flushPendingToolCalls = (timestamp) => {
 		if (pendingToolCalls.length === 0) return;
 		for (const tc of pendingToolCalls) {
-			if (toolCallStatus.has(tc.id)) continue;
+			const statusKey = toolCallPairingKey(tc.id, originScope);
+			if (toolCallStatus.has(statusKey)) continue;
 			const realToolResult = takeRealToolResult(tc.id, pendingToolCallsStartIndex);
 			if (realToolResult) {
 				result.push(realToolResult);
-				toolCallStatus.set(tc.id, 1);
+				toolCallStatus.set(statusKey, 1);
 				continue;
 			}
 			result.push({
@@ -7696,18 +7966,19 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 				isError: true,
 				timestamp
 			});
-			toolCallStatus.set(tc.id, 1);
+			toolCallStatus.set(statusKey, 1);
 		}
 		pendingToolCalls = [];
 	};
 	const flushPendingAbortedToolCalls = () => {
 		if (pendingAbortedTimestamp === void 0) return;
 		for (const tc of pendingAbortedToolCalls.values()) {
-			if (toolCallStatus.has(tc.id)) continue;
+			const statusKey = toolCallPairingKey(tc.id, originScope);
+			if (toolCallStatus.has(statusKey)) continue;
 			const realToolResult = takeRealToolResult(tc.id, pendingAbortedStartIndex);
 			if (realToolResult) {
 				result.push(realToolResult);
-				toolCallStatus.set(tc.id, 1);
+				toolCallStatus.set(statusKey, 1);
 				continue;
 			}
 			result.push({
@@ -7721,7 +7992,7 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 				isError: true,
 				timestamp: pendingAbortedTimestamp
 			});
-			toolCallStatus.set(tc.id, 2);
+			toolCallStatus.set(statusKey, 2);
 		}
 		pendingAbortedToolCalls = /* @__PURE__ */ new Map();
 		pendingAbortedTimestamp = void 0;
@@ -7738,7 +8009,7 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 			const toolCalls = assistantMsg.content.filter((b) => b.type === "toolCall");
 			if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
 				result.push(msg);
-				pendingAbortedToolCalls = new Map(toolCalls.map((toolCall) => [toolCall.id, toolCall]));
+				pendingAbortedToolCalls = new Map(toolCalls.map((toolCall) => [toolCallPairingKey(toolCall.id, originScope), toolCall]));
 				pendingAbortedTimestamp = assistantMsg.timestamp;
 				pendingAbortedStartIndex = i;
 				continue;
@@ -7749,20 +8020,21 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 			}
 			result.push(msg);
 		} else if (msg.role === "toolResult") {
-			if (toolCallStatus.has(msg.toolCallId)) continue;
-			if (pendingAbortedToolCalls.has(msg.toolCallId)) {
-				pendingAbortedToolCalls.delete(msg.toolCallId);
-				toolCallStatus.set(msg.toolCallId, 1);
+			const resultKey = toolCallPairingKey(msg.toolCallId, originScope);
+			if (toolCallStatus.has(resultKey)) continue;
+			if (pendingAbortedToolCalls.has(resultKey)) {
+				pendingAbortedToolCalls.delete(resultKey);
+				toolCallStatus.set(resultKey, 1);
 				result.push(msg);
 				continue;
 			}
-			if (pendingToolCalls.some((tc) => tc.id === msg.toolCallId)) {
-				toolCallStatus.set(msg.toolCallId, 1);
+			if (pendingToolCalls.some((tc) => toolCallPairingKey(tc.id, originScope) === resultKey)) {
+				toolCallStatus.set(resultKey, 1);
 				result.push(msg);
 				continue;
 			}
-			if (!validToolUseIds.has(msg.toolCallId)) {
-				if (pendingToolCalls.some((tc) => !toolCallStatus.has(tc.id)) || pendingAbortedToolCalls.size > 0) continue;
+			if (!validToolUseIds.has(resultKey)) {
+				if (pendingToolCalls.some((tc) => !toolCallStatus.has(toolCallPairingKey(tc.id, originScope))) || pendingAbortedToolCalls.size > 0) continue;
 				const textParts = [];
 				for (const part of msg.content) if (part.type === "text" && part.text.trim() !== "") textParts.push(part.text);
 				if (textParts.length > 0) {
@@ -7789,8 +8061,19 @@ function transformMessages(messages, model, normalizeToolCallId, maxNormalizedTo
 	return result;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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
+* case-insensitive, but `Record<string, string>` header bags are not, so a
+* config-authored `User-Agent` and a caller-authored `user-agent` are the same
+* header to every provider that lowercases before merging.
+*/
+function getHeaderCaseInsensitive(headers, headerName) {
+	if (!headers) return void 0;
+	const normalizedName = headerName.toLowerCase();
+	for (const [key, value] of Object.entries(headers)) if (key.toLowerCase() === normalizedName) return value;
+}
 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);
@@ -7799,21 +8082,18 @@ 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: truncateResponseItemId(callId, getIdPrefix(callId, "call")),
+		callId,
 		itemId: normalizeResponsesItemId(itemId, itemPrefix)
 	};
-	const hash = Bun.hash(id).toString(36);
 	return {
-		callId: id.startsWith("call_") ? truncateResponseItemId(id, "call") : `call_${hash}`,
-		itemId: `${itemPrefix}_${hash}`
+		callId: id,
+		itemId: `${itemPrefix}_${Bun.hash(id).toString(36)}`
 	};
 }
-function getIdPrefix(id, fallback) {
-	return id.match(/^([a-zA-Z][a-zA-Z0-9]*)_/)?.[1] || fallback;
-}
 function getExplicitIdPrefix(id) {
 	return id.match(/^([a-zA-Z][a-zA-Z0-9]*)_/)?.[1];
 }
@@ -7839,7 +8119,7 @@ function stripOpenAIResponsesOutputOnlyStatusesForReplay(items) {
 	let sanitized;
 	for (let index = 0; index < items.length; index++) {
 		const item = items[index];
-		if (!(item.type === "message" || item.type === "function_call" || item.type === "custom_tool_call") || !Object.hasOwn(item, "status")) {
+		if (!(item.type === "message" || item.type === "function_call" || item.type === "custom_tool_call" || item.type === "compaction" || item.type === "compaction_summary") || !Object.hasOwn(item, "status")) {
 			sanitized?.push(item);
 			continue;
 		}
@@ -7922,12 +8202,11 @@ function collectOpenAIResponsesComputerLinkedReasoningItems(items, requireLaterO
 }
 const provisionalOpenAIResponsesComputerReasoningItems = /* @__PURE__ */ new WeakSet();
 function sanitizeOpenAIResponsesHistoryItemsForReplay(items, options = {}) {
-	const normalizedCallIds = /* @__PURE__ */ new Map();
 	const supportsImageDetailOriginal = options.supportsImageDetailOriginal !== false;
 	const computerLinkedReasoningItems = options.supportsComputerUse === false ? void 0 : collectOpenAIResponsesComputerLinkedReasoningItems(items, false);
 	return stripOpenAIResponsesOutputOnlyStatusesForReplay(items.flatMap((item) => {
 		const preserveForComputer = computerLinkedReasoningItems?.has(item) === true;
-		const sanitizedItem = sanitizeOpenAIResponsesHistoryItemForReplay(item, normalizedCallIds, supportsImageDetailOriginal, preserveForComputer);
+		const sanitizedItem = sanitizeOpenAIResponsesHistoryItemForReplay(item, supportsImageDetailOriginal, preserveForComputer);
 		if (preserveForComputer && sanitizedItem?.type === "reasoning") provisionalOpenAIResponsesComputerReasoningItems.add(sanitizedItem);
 		return sanitizedItem ? [sanitizedItem] : [];
 	}));
@@ -8051,13 +8330,20 @@ function sanitizeOpenAIResponsesAssistantFallbackItemsForReplay(items) {
 	}
 	return sanitized;
 }
-function sanitizeOpenAIResponsesHistoryItemForReplay(item, normalizedCallIds, supportsImageDetailOriginal, preserveReasoningItemIds) {
+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;
+		}
+	}
 	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 (typeof item.call_id === "string") sanitizedItem.call_id = normalizeReplayedResponsesHistoryCallId(item.call_id, normalizedCallIds);
 	return clampReplayItemImageDetail(sanitizedItem, supportsImageDetailOriginal);
 }
 function sanitizeOpenAIResponsesReasoningItemForReplay(item, preserveItemId) {
@@ -8077,13 +8363,6 @@ function sanitizeOpenAIResponsesImageGenerationCallForReplay(item) {
 		result: item.result
 	};
 }
-function normalizeReplayedResponsesHistoryCallId(value, normalizedValues) {
-	const normalized = normalizedValues.get(value);
-	if (normalized) return normalized;
-	const next = truncateResponseItemId(value, getIdPrefix(value, "call"));
-	normalizedValues.set(value, next);
-	return next;
-}
 function createOpenAIResponsesHistoryPayload(provider, items, incremental = true) {
 	return {
 		type: "openaiResponsesHistory",
@@ -8116,4 +8395,4 @@ function resolveCacheRetention(cacheRetention, fallback = "short") {
 	return fallback;
 }
 //#endregion
-export { NO_STRICT as A, stringifyJson$1 as B, kStreamingPartialJson as C, partialSuffixOverlapAny as D, FencedThinkingScanner as E, sanitizeSchemaForGrammar as F, sanitizeSchemaForOllama as I, sanitizeSchemaForOpenAIResponses as L, normalizeSchemaForCCA as M, normalizeSchemaForGoogle as N, flattenExclusiveRequiredRootUnion as O, normalizeSchemaForMoonshot as P, spillToDescription as R, kStreamingLastParseLen as S, createInbandScanner as T, tryParseJson as V, kCursorExecResolved as _, normalizeSystemPrompts as a, kStreamingBlockKind as b, sanitizeOpenAIResponsesAssistantFallbackItemsForReplay as c, stripOpenAIResponsesComputerLinkedReasoningIdsForReplay as d, stripUnpairedOpenAIResponsesComputerReasoningIdsForReplay as f, isDemotedThinking as g, clearStreamingPartialJson as h, normalizeResponsesToolCallId as i, adaptSchemaForStrict as j, toolWireSchema as k, sanitizeOpenAIResponsesAssistantHistoryItemsForReplay as l, transformMessages as m, getOpenAIResponsesHistoryItems as n, normalizeToolCallId as o, redactSensitiveInObject as p, getOpenAIResponsesHistoryPayload as r, resolveCacheRetention as s, createOpenAIResponsesHistoryPayload as t, sanitizeOpenAIResponsesHistoryItemsForReplay as u, kStreamingArgumentsDone as v, renderDemotedThinking as w, kStreamingEnvelopeId as x, kStreamingBlockIndex as y, COMBINATOR_KEYS as z };
+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 };