@astralyn/pi 1.1.0 → 1.2.0

package/dist/extensions/mcp/index.js

@@ -131,13 +131,14 @@ export function renderServersSection(servers) {
     return [intro, ...lines, ...omitted(listed.length - kept)].join("\n");
 }
 /**
- * Whether a codemode script needs the server: it names the server's namespace, or searches,
- * enumerates, or describes tools or namespaces, which may name the server in other forms.
+ * Whether a call that reaches `reach` (see `ToolDefinition.reachesTools`) needs the server: it
+ * reaches every tool, or one of its words contains the server's namespace.
  */
-function scriptNeedsServer(code, server) {
-    if (/\b(searchTools|describeNamespace|describeTool|ALL_TOOLS)\b/.test(code))
+function reachesServer(reach, server) {
+    if (reach === "all")
         return true;
-    return code.includes(mcpNamespace(server));
+    const namespace = mcpNamespace(server);
+    return reach.some((word) => word.includes(namespace));
 }
 /** Short state for lists and the startup report. `withError` appends the first line of a failure. */
 function describeState(server, withError = true) {
@@ -152,10 +153,8 @@ function describeState(server, withError = true) {
         case "failed":
             return withError ? `failed: ${firstLine(connection.error ?? "unknown error")}` : "failed";
         case "connected": {
-            const { tools, resources } = connection;
-            const count = resources.length;
-            const resourceCount = count > 0 ? ` · ${count} resource${count === 1 ? "" : "s"}` : "";
-            return `connected · ${tools.length} tool${tools.length === 1 ? "" : "s"}${resourceCount}`;
+            const { tools, hasResources } = connection;
+            return `connected · ${tools.length} tool${tools.length === 1 ? "" : "s"}${hasResources ? " · resources" : ""}`;
         }
         case "connecting":
             return "connecting…";
@@ -287,6 +286,8 @@ export function createMcpExtension(options = {}) {
             const description = entry.config.description?.trim();
             const namespace = {
                 name: mcpNamespace(server),
+                // `describeNamespace("docs")` finds `mcp__docs`.
+                aliases: [server],
                 ...(description ? { description } : {}),
                 ...(connection.instructions ? { instructions: connection.instructions } : {}),
             };
@@ -379,19 +380,6 @@ export function createMcpExtension(options = {}) {
                 pi.setActiveTools(pi.getActiveTools().filter((name) => !names.has(name)));
             }
         };
-        /**
-         * Which of the tools are the bundled codemode and tool_search tools. Other extensions' tools of
-         * the same names cannot reach MCP tools. The owning extensions identify their tools through the
-         * event bus, so this extension does not import their internals.
-         */
-        const discoverOrchestrators = (tools) => {
-            const candidates = new Map(tools.map((tool) => [tool.name, tool.parameters]));
-            pi.events.emit("pi:discover-tool-orchestrators", candidates);
-            return {
-                codemode: candidates.get(CODEMODE_TOOL_NAME) === true,
-                toolSearch: candidates.get(TOOL_SEARCH_TOOL_NAME) === true,
-            };
-        };
         /**
          * Tools that are not declared to the model are reached through the codemode tool (scripts call
          * them) or the tool_search tool (it declares them). Either reaches every such tool. Activate the
@@ -411,8 +399,12 @@ export function createMcpExtension(options = {}) {
             const needsToolSearch = exposures.has("deferred");
             if (!needsCodemode && !needsToolSearch)
                 return;
-            // Other extensions' tools of the same names cannot reach MCP tools, so never activate them.
-            const { codemode: hasCodemode, toolSearch: hasToolSearch } = discoverOrchestrators(pi.getAllTools());
+            // Only a tool of these names that declares `reachesTools` can reach MCP tools; another
+            // extension's tool of the same name without it is never activated.
+            const tools = pi.getAllTools();
+            const hasReachingTool = (name) => tools.some((tool) => tool.name === name && tool.reachesTools);
+            const hasCodemode = hasReachingTool(CODEMODE_TOOL_NAME);
+            const hasToolSearch = hasReachingTool(TOOL_SEARCH_TOOL_NAME);
             const active = pi.getActiveTools();
             const activate = [];
             if (needsCodemode && hasCodemode && autoEnableCodemode && !active.includes(CODEMODE_TOOL_NAME)) {
@@ -1049,10 +1041,11 @@ export function createMcpExtension(options = {}) {
             else
                 delete sections[MCP_SERVERS_SECTION];
         });
-        // A codemode script waits for the servers it names, or for every server when it searches or
-        // enumerates tools, so their tools are registered before the script runs. tool_search and the
-        // resource tools reach every server, so they wait for all of them. Direct MCP calls wait only
-        // for their own server, including a reconnect still closing its old transport.
+        // A tool that reaches other tools (`reachesTools`) waits for the servers it may reach, so their
+        // tools are registered before it runs: a codemode script for the servers it names, or for every
+        // server when it searches or enumerates tools, and tool_search for every server. The resource
+        // tools reach every server, so they wait for all of them. Direct MCP calls wait only for their
+        // own server, including a reconnect still closing its old transport.
         pi.on("tool_call", async (event, ctx) => {
             const tool = pi.getAllTools().find((candidate) => candidate.name === event.toolName);
             if (!tool)
@@ -1063,13 +1056,11 @@ export function createMcpExtension(options = {}) {
             if (readyServers.length === 0)
                 return;
             let waiting = [];
-            const orchestrator = discoverOrchestrators([tool]);
-            if (orchestrator.codemode) {
-                const { code } = event.input;
-                const source = typeof code === "string" ? code : "";
-                waiting = readyServers.filter((server) => scriptNeedsServer(source, server.entry.name));
+            const reach = tool.reachesTools?.(event.input);
+            if (reach !== undefined) {
+                waiting = readyServers.filter((server) => reachesServer(reach, server.entry.name));
             }
-            else if (orchestrator.toolSearch || RESOURCE_TOOL_NAMES.has(tool.name)) {
+            else if (RESOURCE_TOOL_NAMES.has(tool.name)) {
                 waiting = readyServers;
             }
             else {