zidane 6.5.0 → 6.5.2

package/dist/{openai-compat-B3c_hzwf.js → openai-compat-CnHeo4Lz.js}

@@ -1,10 +1,223 @@
-import { a as rewriteMessagesToWire, n as buildAliasMaps, o as toCanonicalName, r as buildSanitizedWireAliases, s as toWireName } from "./aliasing-lVFbm81n.js";
 import { i as documentBlockMarker, n as assertResolvedMediaBlock } from "./types-BIarq1qE.js";
 import { n as estimateTokens } from "./utils-ngQzYzZD.js";
 import { f as isRetryableHttpStatus, l as classifyErrorPrelude, m as matchesToolPairingError, p as matchesContextExceeded } from "./errors-BwBxu3zD.js";
 import { t as audioFormatFromMediaType } from "./media-sniff-UKijEaiQ.js";
 import { renderSystemForWire, splitSystemPrompt } from "./prompt.js";
 import { createHash } from "node:crypto";
+//#region src/hash.ts
+/**
+* FNV-1a (32-bit) rendered in base36 — a tiny, dependency-free, deterministic
+* hash.
+*
+* Used to disambiguate sanitized identifiers: distinct inputs that would
+* otherwise collapse to the same sanitized string (e.g. `a.b` and `a/b` both
+* → `a_b`, or two over-long names truncated to the same prefix) keep a stable,
+* unique suffix. Determinism matters because the suffix must be identical
+* across runs and across a `tool_use` / `tool_result` pair derived from the
+* same original value.
+*/
+function fnv1aBase36(value) {
+	let hash = 2166136261;
+	for (let i = 0; i < value.length; i++) {
+		hash ^= value.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+//#endregion
+//#region src/aliasing.ts
+/**
+* Build alias lookup maps from a `toolAliases` record.
+*
+* Validates:
+* - No two canonical names map to the same alias (collision).
+* - No alias collides with another canonical tool name (would shadow).
+*
+* Silently ignores alias entries whose canonical name isn't in `canonicalNames` —
+* preset/agent authors can declare aliases for tools that may be added later via MCP.
+*
+* @param aliases - The `toolAliases` map from the agent options.
+* @param canonicalNames - All tool canonical names currently in scope (agent + MCP).
+*/
+function buildAliasMaps(aliases, canonicalNames) {
+	const aliasByCanonical = /* @__PURE__ */ new Map();
+	const canonicalByAlias = /* @__PURE__ */ new Map();
+	if (!aliases) return {
+		aliasByCanonical,
+		canonicalByAlias
+	};
+	const canonicalSet = new Set(canonicalNames);
+	function isRemappedAway(canonical) {
+		const mapped = aliases[canonical];
+		return typeof mapped === "string" && mapped.length > 0 && mapped !== canonical;
+	}
+	for (const [canonical, alias] of Object.entries(aliases)) {
+		if (typeof alias !== "string" || alias.length === 0) throw new Error(`Tool alias for "${canonical}" must be a non-empty string`);
+		if (alias === canonical) continue;
+		if (!canonicalSet.has(canonical)) continue;
+		if (canonicalSet.has(alias) && !isRemappedAway(alias)) throw new Error(`Tool alias "${canonical}" -> "${alias}" collides with an existing canonical tool name`);
+		const existingCanonical = canonicalByAlias.get(alias);
+		if (existingCanonical && existingCanonical !== canonical) throw new Error(`Tool alias collision: both "${existingCanonical}" and "${canonical}" map to alias "${alias}"`);
+		aliasByCanonical.set(canonical, alias);
+		canonicalByAlias.set(alias, canonical);
+	}
+	return {
+		aliasByCanonical,
+		canonicalByAlias
+	};
+}
+/** Return the alias for a canonical name, falling back to the canonical name itself. */
+function toWireName(canonical, maps) {
+	return maps.aliasByCanonical.get(canonical) ?? canonical;
+}
+/** Return the canonical name for a wire name, falling back to the wire name itself. */
+function toCanonicalName(wire, maps) {
+	return maps.canonicalByAlias.get(wire) ?? wire;
+}
+/**
+* Tool names must match `^[a-zA-Z0-9_-]{1,N}$`. The charset is universal; the
+* length cap is taken as the STRICTEST across providers (OpenAI/-compat: 64;
+* Anthropic allows 128) so a sanitized name is valid on EVERY provider — and so
+* a mid-session model switch can never make the provider-level drop guard
+* (`sanitizeToolSpecs`) discard a tool we could have kept.
+*
+* MCP tool names are minted verbatim as `mcp_<server>_<tool>` (see
+* `connectMcpServers`), so a server configured as `SSH Ipseity` yields
+* `mcp_SSH Ipseity_exec` — the space (and `.`/`:`/`/`, unicode, or a >64-char
+* join) 400s the request the instant that tool lands in the `tools` array:
+* `tools.N.custom.name: String should match pattern ...`.
+*/
+const WIRE_NAME_MAX = 64;
+const WIRE_NAME_OK = /^[\w-]{1,64}$/;
+const WIRE_NAME_BAD_CHAR = /[^\w-]/g;
+/**
+* Build OUTBOUND wire aliases that coerce any tool name violating the provider
+* name constraint into a valid one. Only offenders get an entry; clean setups
+* return `undefined` (no alias map churn, prompt cache untouched).
+*
+* Returned as a `Record` so it merges into `effectiveToolAliases` upstream of
+* BOTH wire-name computations — the `tool_search` catalog and the `tools` array
+* — keeping them in lockstep. Canonical names (dispatch, hooks, persisted
+* turns) never change; only the bytes the model sees do.
+*
+* Scoped to MCP names (the only third-party-controlled, thus only realistically
+* invalid, source). The hash suffix keeps distinct originals distinct even when
+* they collapse to the same replacement; `taken` guards the residual collision.
+*/
+function buildSanitizedWireAliases(names, existing) {
+	const wireOf = (name) => {
+		const alias = existing?.[name];
+		return typeof alias === "string" && alias.length > 0 ? alias : name;
+	};
+	const taken = /* @__PURE__ */ new Set();
+	const offenders = [];
+	for (const name of names) {
+		const wire = wireOf(name);
+		if (WIRE_NAME_OK.test(wire)) taken.add(wire);
+		else offenders.push(name);
+	}
+	if (offenders.length === 0) return void 0;
+	const out = {};
+	for (const name of offenders) {
+		const sanitized = sanitizeWireName(wireOf(name), taken);
+		out[name] = sanitized;
+		taken.add(sanitized);
+	}
+	return out;
+}
+function sanitizeWireName(name, taken) {
+	let base = name.replace(WIRE_NAME_BAD_CHAR, "_");
+	if (base.length === 0) base = "tool";
+	const hash = fnv1aBase36(name);
+	const withSuffix = (suffix) => `${base.slice(0, Math.max(1, WIRE_NAME_MAX - suffix.length))}${suffix}`;
+	let candidate = withSuffix(`_${hash}`);
+	for (let n = 1; taken.has(candidate); n++) candidate = withSuffix(`_${hash}_${n}`);
+	return candidate;
+}
+/**
+* Augment {@link AliasMaps} with INBOUND-ONLY aliases for the Claude Code
+* `mcp__server__tool` double-underscore naming convention. For every MCP
+* tool registered with the canonical `mcp_<server>_<tool>` form, add a
+* `canonicalByAlias` entry mapping the double-underscore variant to the
+* same canonical name. Outbound (`aliasByCanonical`) is left untouched —
+* the model still sees the single-underscore canonical on the wire, so
+* the tools-array byte count (and the provider prompt cache) is
+* unaffected.
+*
+* Why: SDK consumers and tool descriptions across the ecosystem
+* inconsistently reference one form or the other (Anthropic's docs use
+* double, zidane uses single). A Claude-Code-trained model emitting
+* `mcp__acme__apply_migration` against a server zidane registered as
+* `mcp_acme_apply_migration` would otherwise trip the `tool:unknown`
+* path and waste a turn on the correction.
+*
+* Idempotent: a canonical that already has a double-underscore alias
+* mapped (host's explicit `toolAliases` got there first) is left alone.
+* Tools whose canonical name DOESN'T start with `mcp_` (or that contain
+* no inner separator) are skipped — we don't want to invent aliases for
+* non-MCP tools or malformed names.
+*
+* Mutates `maps.canonicalByAlias` in place and returns the same object
+* for chaining.
+*/
+function augmentMcpDoubleUnderscoreAliases(maps, canonicalNames) {
+	for (const canonical of canonicalNames) {
+		if (!canonical.startsWith("mcp_")) continue;
+		const tail = canonical.slice(4);
+		const sep = tail.indexOf("_");
+		if (sep <= 0 || sep >= tail.length - 1) continue;
+		const doubleForm = `mcp__${tail.slice(0, sep)}__${tail.slice(sep + 1)}`;
+		if (doubleForm === canonical) continue;
+		if (maps.canonicalByAlias.has(doubleForm)) continue;
+		maps.canonicalByAlias.set(doubleForm, canonical);
+	}
+	return maps;
+}
+/**
+* Rewrite `tool_call` block names in a content array from canonical → wire for outbound
+* messages sent to the provider. Mutation is non-destructive (returns a new array).
+*/
+function rewriteContentToWire(content, maps) {
+	if (maps.aliasByCanonical.size === 0) return content;
+	return content.map((block) => {
+		if (block.type !== "tool_call") return block;
+		const wire = maps.aliasByCanonical.get(block.name);
+		if (!wire || wire === block.name) return block;
+		return {
+			...block,
+			name: wire
+		};
+	});
+}
+/**
+* Rewrite `tool_call` block names in a content array from wire → canonical for inbound
+* messages received from the provider. Non-destructive.
+*/
+function rewriteContentToCanonical(content, maps) {
+	if (maps.canonicalByAlias.size === 0) return content;
+	return content.map((block) => {
+		if (block.type !== "tool_call") return block;
+		const canonical = maps.canonicalByAlias.get(block.name);
+		if (!canonical || canonical === block.name) return block;
+		return {
+			...block,
+			name: canonical
+		};
+	});
+}
+/**
+* Rewrite every `SessionMessage.content` in an array from canonical → wire.
+* Returns a new array of new message objects — input messages are not mutated.
+* When the alias map is empty, returns the input by reference (no allocation).
+*/
+function rewriteMessagesToWire(messages, maps) {
+	if (maps.aliasByCanonical.size === 0) return messages;
+	return messages.map((msg) => ({
+		...msg,
+		content: rewriteContentToWire(msg.content, maps)
+	}));
+}
+//#endregion
 //#region src/prompt.ts
 /**
 * Coerce the run-level prompt into a `PromptPart[]`.
@@ -2067,6 +2280,6 @@ function openaiCompat(params) {
 	};
 }
 //#endregion
-export { mergeCatalogEntry as A, estimateRebilledCostUsd as C, listModelOverlay as D, getModelCatalog as E, unsupportedMediaError as F, buildPromptMessage as M, canonicalizePrompt as N, listModels as O, defaultPromptMessage as P, resolvePromptCacheKey as S, aliasCatalogProviders as T, userMessage as _, applyOAICacheBreakpoints as a, sanitizeToolSpecs as b, buildAssistantContent as c, formatTools as d, mapOAIFinishReason as f, toolResultsMessage as g, toOAIMessages as h, TOOL_RESULTS_TAG as i, setModelCatalog as j, lookupModel as k, classifyOpenAICompatError as l, openaiCompat as m, OpenAICompatHttpError as n, applyOAIToolCacheBreakpoint as o, openAICompatPromptMessage as p, OpenAICompatStreamError as r, assistantMessage as s, ASSISTANT_TOOL_CALLS_TAG as t, consumeSSE as u, createToolNameBoundary as v, fillEstimatedCost as w, derivePromptCacheKey as x, sanitizeToolSchema as y };
+export { mergeCatalogEntry as A, rewriteMessagesToWire as B, estimateRebilledCostUsd as C, listModelOverlay as D, getModelCatalog as E, unsupportedMediaError as F, toWireName as H, augmentMcpDoubleUnderscoreAliases as I, buildAliasMaps as L, buildPromptMessage as M, canonicalizePrompt as N, listModels as O, defaultPromptMessage as P, buildSanitizedWireAliases as R, resolvePromptCacheKey as S, aliasCatalogProviders as T, fnv1aBase36 as U, toCanonicalName as V, userMessage as _, applyOAICacheBreakpoints as a, sanitizeToolSpecs as b, buildAssistantContent as c, formatTools as d, mapOAIFinishReason as f, toolResultsMessage as g, toOAIMessages as h, TOOL_RESULTS_TAG as i, setModelCatalog as j, lookupModel as k, classifyOpenAICompatError as l, openaiCompat as m, OpenAICompatHttpError as n, applyOAIToolCacheBreakpoint as o, openAICompatPromptMessage as p, OpenAICompatStreamError as r, assistantMessage as s, ASSISTANT_TOOL_CALLS_TAG as t, consumeSSE as u, createToolNameBoundary as v, fillEstimatedCost as w, derivePromptCacheKey as x, sanitizeToolSchema as y, rewriteContentToCanonical as z };
 
-//# sourceMappingURL=openai-compat-B3c_hzwf.js.map
+//# sourceMappingURL=openai-compat-CnHeo4Lz.js.map