@skydiveai/pi-extensions 0.1.253-beta.7 → 0.1.253

package/dist/index.mjs

@@ -1169,7 +1169,58 @@ function estimateToolTokens(tool) {
 	return Math.ceil(chars / 4);
 }
 //#endregion
-//#region src/extensions/mcp/tool-name.ts
+//#region src/extensions/mcp/legacy-names.ts
+/**
+* Rewrites `mcp_<server>_<tool>` names in replayed history to the current
+* `mcp__<server>__<tool>` registration. Runs on pi's `context` hook, which
+* hands us a per-call clone that is never written back to the session file,
+* so the stored history keeps the names the model actually emitted while the
+* model only ever sees the live shape (and so does not mimic the old one).
+*
+* Returns the input array untouched when nothing matched. `renamed` lists
+* the legacy names that were mapped, for one-shot logging by the caller.
+*/
+function rewriteLegacyMcpToolNames({ messages, legacyNames }) {
+	const renamed = /* @__PURE__ */ new Set();
+	if (legacyNames.size === 0) return {
+		messages,
+		renamed
+	};
+	const out = messages.map((message) => {
+		if (message.role === "assistant") {
+			let changed = false;
+			const content = message.content.map((block) => {
+				if (block.type !== "toolCall") return block;
+				const current = legacyNames.get(block.name);
+				if (current === void 0) return block;
+				renamed.add(block.name);
+				changed = true;
+				return {
+					...block,
+					name: current
+				};
+			});
+			return changed ? {
+				...message,
+				content
+			} : message;
+		}
+		if (message.role === "toolResult") {
+			const current = legacyNames.get(message.toolName);
+			if (current === void 0) return message;
+			renamed.add(message.toolName);
+			return {
+				...message,
+				toolName: current
+			};
+		}
+		return message;
+	});
+	return {
+		messages: renamed.size > 0 ? out : messages,
+		renamed
+	};
+}
 const MAX_LENGTH = 128;
 /**
 * Deterministically coerce `raw` into the Anthropic tool-name alphabet.
@@ -1185,17 +1236,46 @@ function sanitizeToolName(raw) {
 	return stripped === "" ? "tool" : stripped;
 }
 /**
-* First free `name`, `name_2`, `name_3`, ... within the 128-char budget.
-* Suffixes come out of the kept base so the whole string stays <= 128.
+* First free `name`, `name_2`, `name_3`, ... within `maxLength`. Suffixes
+* come out of the kept base so the whole string stays <= `maxLength`; the
+* caller passes the budget its names were built to (64 for MCP names, 128
+* for the Anthropic-wide limit) so a collision cannot push a name past it.
 */
-function uniqueSanitizedToolName(base, used) {
+function uniqueSanitizedToolName({ base, used, maxLength }) {
 	if (!used.has(base)) return base;
 	for (let n = 2;; n++) {
 		const suffix = `_${n}`;
-		const candidate = base.slice(0, MAX_LENGTH - suffix.length) + suffix;
+		const candidate = base.slice(0, maxLength - suffix.length) + suffix;
 		if (!used.has(candidate)) return candidate;
 	}
 }
+/**
+* MCP tools register under Claude Code's `mcp__<server>__<tool>` shape: the
+* double-underscore separators are what Anthropic's models were trained on,
+* and they make the name splittable again (`mcp_stripe_stripe_planner` cannot
+* be split; `mcp__stripe__stripe_planner` can). Cap is 64, not Anthropic's
+* 128: `tool-history.ts` hashes replayed names over 64 and OpenAI-compatible
+* providers enforce 64, so a longer name would be unusable on replay anyway.
+*/
+const MCP_TOOL_PREFIX = "mcp__";
+const MCP_SEPARATOR = "__";
+const MCP_SERVER_SEGMENT_MAX_LENGTH = 32;
+function sanitizeServerSegment(serverName) {
+	return sanitizeToolName(serverName).replace(/_{2,}/g, "_").slice(0, MCP_SERVER_SEGMENT_MAX_LENGTH).replace(/_+$/, "");
+}
+function buildMcpToolName({ serverName, toolName }) {
+	const head = `${MCP_TOOL_PREFIX}${sanitizeServerSegment(serverName)}${MCP_SEPARATOR}`;
+	const tool = sanitizeToolName(toolName).slice(0, 64 - head.length).replace(/_+$/, "");
+	return `${head}${tool === "" ? "tool" : tool}`;
+}
+/**
+* The pre-2026-10 registered shape (`mcp_<server>_<tool>`, sanitized, no
+* collision suffix). Only used to map names in replayed history onto the
+* current registration; delete with the compat window.
+*/
+function legacyMcpToolName({ serverName, toolName }) {
+	return sanitizeToolName(`mcp_${serverName}_${toolName}`);
+}
 //#endregion
 //#region src/extensions/mcp/mcp-config.ts
 /**
@@ -1296,16 +1376,23 @@ async function readConfigMtimeMs(configPath) {
 	}
 }
 /**
-* The registered tool name must satisfy Anthropic's tools[].name pattern
-* (`^[a-zA-Z0-9_-]{1,128}$`) or the WHOLE Messages request hard-400s — real
-* servers emit names that fail it (e.g. granola's `granola.meetings.list
-* (v2)`). Sanitize here at registration time; execution still calls the
-* server with the ORIGINAL name, and model tool_use round-trips on the
-* sanitized one, so no reverse mapping is needed. `used` dedupes collisions
-* (two distinct raw names can sanitize to the same string).
+* Registered as Claude Code's `mcp__<server>__<tool>` (see tool-name.ts), in
+* the Anthropic tools[].name alphabet or the WHOLE Messages request hard-400s
+* — real servers emit names that fail it (e.g. granola's
+* `granola.meetings.list (v2)`). Execution still calls the server with the
+* ORIGINAL name, and model tool_use round-trips on the registered one, so no
+* reverse mapping is needed. `used` dedupes collisions (two distinct raw
+* names can sanitize to the same string).
 */
 function makeToolName(serverId, toolName, used) {
-	return uniqueSanitizedToolName(sanitizeToolName(`mcp_${serverId}_${toolName}`), used);
+	return uniqueSanitizedToolName({
+		base: buildMcpToolName({
+			serverName: serverId,
+			toolName
+		}),
+		used,
+		maxLength: 64
+	});
 }
 function toMcpArguments(params) {
 	const out = {};
@@ -1410,6 +1497,9 @@ var McpExtension = class {
 	mcpClients = /* @__PURE__ */ new Map();
 	registeredMcpToolNames = /* @__PURE__ */ new Set();
 	usedSanitizedToolNames = /* @__PURE__ */ new Set();
+	legacyToolNames = /* @__PURE__ */ new Map();
+	usedLegacyToolNames = /* @__PURE__ */ new Set();
+	loggedLegacyToolNames = /* @__PURE__ */ new Set();
 	lastConfigMtimeMs = 0;
 	pendingMcpUpdate = null;
 	/** Non-consuming peek used by `shouldStopAfterTurn`. */
@@ -1468,6 +1558,23 @@ var McpExtension = class {
 		}));
 		this.registeredMcpToolNames.add(name);
 		this.usedSanitizedToolNames.add(name);
+		this.recordLegacyToolName({
+			serverId,
+			toolName: tool.name,
+			name
+		});
+	}
+	recordLegacyToolName({ serverId, toolName, name }) {
+		const legacy = uniqueSanitizedToolName({
+			base: legacyMcpToolName({
+				serverName: serverId,
+				toolName
+			}),
+			used: this.usedLegacyToolNames,
+			maxLength: 128
+		});
+		this.usedLegacyToolNames.add(legacy);
+		this.legacyToolNames.set(legacy, name);
 	}
 	async reconcile({ pi, configPath, connectTimeoutMs, contextWindow }) {
 		let config;
@@ -1494,6 +1601,8 @@ var McpExtension = class {
 		const desiredIds = new Set(Object.keys(config.servers));
 		this.registeredMcpToolNames.clear();
 		this.usedSanitizedToolNames.clear();
+		this.legacyToolNames.clear();
+		this.usedLegacyToolNames.clear();
 		for (const [id, existing] of [...this.mcpClients.entries()]) if (!desiredIds.has(id)) {
 			await closeConnected(existing);
 			this.mcpClients.delete(id);
@@ -1852,6 +1961,22 @@ var McpExtension = class {
 					}, "MCP reconcile failed");
 				}
 			});
+			pi.on("context", (event) => {
+				const { messages, renamed } = rewriteLegacyMcpToolNames({
+					messages: event.messages,
+					legacyNames: this.legacyToolNames
+				});
+				for (const legacy of renamed) {
+					if (this.loggedLegacyToolNames.has(legacy)) continue;
+					this.loggedLegacyToolNames.add(legacy);
+					log$13.info({
+						event: "mcp_tool_legacy_name",
+						legacy_name: legacy,
+						tool_name: this.legacyToolNames.get(legacy)
+					}, "rewrote legacy MCP tool name in replayed history");
+				}
+				return { messages };
+			});
 			pi.on("tool_result", async (_event, ctx) => {
 				const configPath = join(ctx.cwd, MCP_CONFIG_FILENAME);
 				let mtime;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skydiveai/pi-extensions",
-  "version": "0.1.253-beta.7",
+  "version": "0.1.253",
   "homepage": "https://skydive.com",
   "license": "MIT",
   "author": "Create, Inc.",