@gajae-code/agent-core 0.12.19 → 0.12.21

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## [Unreleased]
 
+## [0.12.21] - 2026-08-09
+
+## [0.12.20] - 2026-08-09
+
 ## [0.12.19] - 2026-08-08
 
 ## [0.12.18] - 2026-08-08

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/agent-core",
-	"version": "0.12.19",
+	"version": "0.12.21",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -32,9 +32,9 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@gajae-code/ai": "0.12.19",
-		"@gajae-code/natives": "0.12.19",
-		"@gajae-code/utils": "0.12.19",
+		"@gajae-code/ai": "0.12.21",
+		"@gajae-code/natives": "0.12.21",
+		"@gajae-code/utils": "0.12.21",
 		"@opentelemetry/api": "^1.9.0"
 	},
 	"devDependencies": {

package/src/agent-loop.ts

@@ -2507,66 +2507,35 @@ function toolCallNames(tool: { name: string; customWireName?: string }): string[
 
 /**
  * Wire name of the tool-discovery tool. Sessions that hide discoverable
- * built-ins expose it under this name, or under a bridge alias of it.
+ * built-ins expose it under exactly that name.
  */
 const TOOL_DISCOVERY_NAME = "search_tool_bm25";
 
 /**
- * Split an MCP bridge namespace off a call name so it can be compared against
- * the tool it actually denotes. Bridges expose tools as `mcp__<server>_<tool>`,
- * and proxied bridges add a per-session instance segment
- * (`mcp__<server>__<instance>_<tool>`). A name the model replayed from earlier
- * context therefore differs from the live registry only in that segment.
+ * Active tool a call name dispatches to. Tools emitted via OpenAI's custom-tool
+ * path (e.g. `apply_patch` on GPT-5) come back under their wire-level name,
+ * which may differ from the harness-internal `name`. Match on either, preferring
+ * `name` for determinism if both somehow collide.
  */
-function parseToolCallName(name: string): { server?: string; base: string } {
-	const namespace = /^mcp__([^_]+)(?:__[^_]+)?_/.exec(name);
-	if (!namespace) return { base: name };
-	return { server: namespace[1], base: name.slice(namespace[0].length) };
-}
-
-/**
- * Call names of active tools that denote the same tool as an unresolved call
- * name. Two servers can expose the same tool name, so a namespaced call is only
- * matched against its own server or against an unnamespaced tool.
- */
-function findToolCallNameAliases(
+function findActiveTool<T extends { name: string; customWireName?: string }>(
+	tools: ReadonlyArray<T> | undefined,
 	callName: string,
-	tools: ReadonlyArray<{ name: string; customWireName?: string }> | undefined,
-	limit = 3,
-): string[] {
-	const target = parseToolCallName(callName);
-	if (target.base.length === 0) return [];
-	const aliases: string[] = [];
-	for (const tool of tools ?? []) {
-		for (const candidate of toolCallNames(tool)) {
-			if (candidate === callName) continue;
-			const parsed = parseToolCallName(candidate);
-			if (parsed.base !== target.base) continue;
-			if (parsed.server !== undefined && target.server !== undefined && parsed.server !== target.server) continue;
-			if (aliases.includes(candidate)) continue;
-			aliases.push(candidate);
-			if (aliases.length === limit) return aliases;
-		}
-	}
-	return aliases;
+): T | undefined {
+	return (
+		tools?.find(tool => tool.name === callName) ??
+		tools?.find(tool => tool.customWireName !== undefined && tool.customWireName === callName)
+	);
 }
 
 /**
- * Resolve how tool discovery is actually callable in this session. Assuming the
- * bare `search_tool_bm25` literal both drops the hint when the discovery tool is
- * bridged and, worse, would name a second non-callable tool if emitted anyway.
+ * Whether tool discovery is callable in this session. A namespaced lookalike
+ * proves nothing: `mcp__srv__x_search_tool_bm25` reads equally well as a bridged
+ * discovery tool and as that server's own `x_search_tool_bm25`, and the registry
+ * cannot tell the two apart. Naming the wrong one sends the model at a tool it
+ * never asked for, so only the literal call name counts.
  */
-function findToolDiscoveryCallName(
-	tools: ReadonlyArray<{ name: string; customWireName?: string }> | undefined,
-): string | undefined {
-	let bridged: string | undefined;
-	for (const tool of tools ?? []) {
-		for (const candidate of toolCallNames(tool)) {
-			if (candidate === TOOL_DISCOVERY_NAME) return candidate;
-			if (bridged === undefined && parseToolCallName(candidate).base === TOOL_DISCOVERY_NAME) bridged = candidate;
-		}
-	}
-	return bridged;
+function isToolDiscoveryCallable(tools: ReadonlyArray<{ name: string; customWireName?: string }> | undefined): boolean {
+	return (tools ?? []).some(tool => toolCallNames(tool).includes(TOOL_DISCOVERY_NAME));
 }
 
 /**
@@ -2615,13 +2584,7 @@ async function executeToolCalls(
 
 	const records = toolCalls.map(toolCall => ({
 		toolCall,
-		// Tools emitted via OpenAI's custom-tool path (e.g. `apply_patch` on GPT-5)
-		// come back under their wire-level name, which may differ from the
-		// harness-internal `name`. Match on either, preferring `name` for
-		// determinism if both somehow collide.
-		tool:
-			tools?.find(t => t.name === toolCall.name) ??
-			tools?.find(t => t.customWireName !== undefined && t.customWireName === toolCall.name),
+		tool: findActiveTool(tools, toolCall.name),
 		args: toolCall.arguments as Record<string, unknown>,
 		started: false,
 		result: undefined as AgentToolResult<any> | undefined,
@@ -2769,21 +2732,19 @@ async function executeToolCalls(
 					// the tool and retry instead of giving up on the capability. The
 					// base wording stays byte-for-byte stable for downstream consumers;
 					// the period and hint are appended only when discovery is callable.
+					// The call name is echoed verbatim and no other tool is named or
+					// dispatched to: `mcp__<server>__<x>_<base>` reads equally well as a
+					// stale bridge instance segment in front of `base` and as that
+					// server's own two-segment `<x>_<base>`, and the registry only ever
+					// proves the live name, never the one the model sent. Running or
+					// naming that guess hits a tool the model never asked for, which is
+					// worse than the dead end it would replace.
 					const base = `Tool ${toolCall.name} not found`;
-					const hints: string[] = [];
-					const aliases = findToolCallNameAliases(toolCall.name, tools);
-					if (aliases.length > 0) {
-						hints.push(
-							`It is active as ${aliases.map(name => `\`${name}\``).join(" or ")} — call that name instead.`,
-						);
-					}
-					const discoveryCallName = findToolDiscoveryCallName(tools);
-					if (discoveryCallName !== undefined) {
-						hints.push(
-							`If you are unsure whether this tool exists or how to use it, call \`${discoveryCallName}\` to discover and activate the matching tool, then retry.`,
-						);
-					}
-					throw new Error(hints.length > 0 ? `${base}. ${hints.join(" ")}` : base);
+					throw new Error(
+						isToolDiscoveryCallable(tools)
+							? `${base}. If you are unsure whether this tool exists or how to use it, call \`${TOOL_DISCOVERY_NAME}\` to discover and activate the matching tool, then retry.`
+							: base,
+					);
 				}
 
 				let effectiveArgs: Record<string, unknown>;