pi-mcp-adapter 1.2.2 → 1.4.0

package/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.4.0] - 2026-01-19
+
+### Changed
+
+- **Non-blocking startup** - Pi starts immediately, MCP servers connect in background. First MCP call waits only if init isn't done yet.
+
+### Fixed
+
+- Tool metadata now includes `inputSchema` after `/mcp reconnect` (was missing, breaking describe and error hints)
+
+## [1.3.0] - 2026-01-19
+
+### Changed
+
+- **Parallel server connections** - All MCP servers now connect in parallel on startup instead of sequentially, significantly faster with many servers
+
 ## [1.2.2] - 2026-01-19
 
 ### Fixed

package/README.md

@@ -129,4 +129,3 @@ See [ARCHITECTURE.md](./ARCHITECTURE.md) for details. Short version:
 
 - OAuth tokens obtained externally (no browser flow)
 - No automatic token refresh
-- Servers connect sequentially on startup

package/index.ts

@@ -24,6 +24,27 @@ interface McpExtensionState {
   config: McpConfig;
 }
 
+/** Run async tasks with concurrency limit */
+async function parallelLimit<T, R>(
+  items: T[],
+  limit: number,
+  fn: (item: T) => Promise<R>
+): Promise<R[]> {
+  const results: R[] = [];
+  let index = 0;
+  
+  async function worker() {
+    while (index < items.length) {
+      const i = index++;
+      results[i] = await fn(items[i]);
+    }
+  }
+  
+  const workers = Array(Math.min(limit, items.length)).fill(null).map(() => worker());
+  await Promise.all(workers);
+  return results;
+}
+
 export default function mcpAdapter(pi: ExtensionAPI) {
   let state: McpExtensionState | null = null;
   let initPromise: Promise<McpExtensionState> | null = null;
@@ -34,25 +55,33 @@ export default function mcpAdapter(pi: ExtensionAPI) {
   });
   
   pi.on("session_start", async (_event, ctx) => {
+    // Non-blocking init - Pi starts immediately, MCP connects in background
     initPromise = initializeMcp(pi, ctx);
-    state = await initPromise;
-    initPromise = null;
     
-    // Set up callback for auto-reconnect to update metadata
-    state.lifecycle.setReconnectCallback((serverName) => {
-      if (state) {
-        updateServerMetadata(state, serverName);
+    initPromise.then(s => {
+      state = s;
+      initPromise = null;
+      
+      // Set up callback for auto-reconnect to update metadata
+      s.lifecycle.setReconnectCallback((serverName) => {
+        if (state) {
+          updateServerMetadata(state, serverName);
+        }
+      });
+      
+      // Update status bar when ready
+      if (ctx.hasUI) {
+        const totalTools = [...s.registeredTools.values()].flat().length;
+        if (totalTools > 0) {
+          ctx.ui.setStatus("mcp", ctx.ui.theme.fg("accent", `MCP: ${totalTools} tools`));
+        } else {
+          ctx.ui.setStatus("mcp", "");
+        }
       }
+    }).catch(err => {
+      console.error("MCP initialization failed:", err);
+      initPromise = null;
     });
-    
-    if (ctx.hasUI) {
-      const totalTools = [...state.registeredTools.values()].flat().length;
-      if (totalTools > 0) {
-        ctx.ui.setStatus("mcp", ctx.ui.theme.fg("accent", `MCP: ${totalTools} tools`));
-      } else {
-        ctx.ui.setStatus("mcp", "");
-      }
-    }
   });
   
   pi.on("session_shutdown", async () => {
@@ -74,6 +103,15 @@ export default function mcpAdapter(pi: ExtensionAPI) {
   pi.registerCommand("mcp", {
     description: "Show MCP server status",
     handler: async (args, ctx) => {
+      // Wait for init if still in progress
+      if (!state && initPromise) {
+        try {
+          state = await initPromise;
+        } catch {
+          if (ctx.hasUI) ctx.ui.notify("MCP initialization failed", "error");
+          return;
+        }
+      }
       if (!state) {
         if (ctx.hasUI) ctx.ui.notify("MCP not initialized", "error");
         return;
@@ -107,6 +145,15 @@ export default function mcpAdapter(pi: ExtensionAPI) {
         return;
       }
       
+      // Wait for init if still in progress
+      if (!state && initPromise) {
+        try {
+          state = await initPromise;
+        } catch {
+          if (ctx.hasUI) ctx.ui.notify("MCP initialization failed", "error");
+          return;
+        }
+      }
       if (!state) {
         if (ctx.hasUI) ctx.ui.notify("MCP not initialized", "error");
         return;
@@ -152,6 +199,17 @@ Mode: tool (call) > describe > search > server (list) > nothing (status)`,
       includeSchemas?: boolean;
       server?: string;
     }) {
+      // Wait for init if still in progress
+      if (!state && initPromise) {
+        try {
+          state = await initPromise;
+        } catch {
+          return {
+            content: [{ type: "text", text: "MCP initialization failed" }],
+            details: { error: "init_failed" },
+          };
+        }
+      }
       if (!state) {
         return {
           content: [{ type: "text", text: "MCP not initialized" }],
@@ -586,80 +644,94 @@ async function initializeMcp(
     return { manager, lifecycle, registeredTools, toolMetadata, config };
   }
   
-  for (const [name, definition] of serverEntries) {
+  if (ctx.hasUI) {
+    ctx.ui.setStatus("mcp", `Connecting to ${serverEntries.length} servers...`);
+  }
+  
+  // Connect to all servers in parallel (max 10 concurrent)
+  const results = await parallelLimit(serverEntries, 10, async ([name, definition]) => {
     try {
-      if (ctx.hasUI) {
-        ctx.ui.setStatus("mcp", `Connecting to ${name}...`);
-      }
-      
       const connection = await manager.connect(name, definition);
-      const prefix = config.settings?.toolPrefix ?? "server";
-      
-      // Collect tool names (NOT registered with Pi - only mcp proxy is registered)
-      const { collected: toolNames, failed: failedTools } = collectToolNames(
-        connection.tools,
-        { serverName: name, prefix }
-      );
-      
-      // Collect resource tool names (if enabled)
-      if (definition.exposeResources !== false && connection.resources.length > 0) {
-        const resourceToolNames = collectResourceToolNames(
-          connection.resources,
-          { serverName: name, prefix }
-        );
-        toolNames.push(...resourceToolNames);
-      }
-      
-      registeredTools.set(name, toolNames);
-      
-      // Build tool metadata for searching (include inputSchema for describe/errors)
-      const metadata: ToolMetadata[] = connection.tools.map(tool => ({
-        name: formatToolName(tool.name, name, prefix),
-        originalName: tool.name,
-        description: tool.description ?? "",
-        inputSchema: tool.inputSchema,
-      }));
-      // Add resource tools to metadata
-      for (const resource of connection.resources) {
-        if (definition.exposeResources !== false) {
-          const baseName = `get_${resourceNameToToolName(resource.name)}`;
-          metadata.push({
-            name: formatToolName(baseName, name, prefix),
-            originalName: baseName,
-            description: resource.description ?? `Read resource: ${resource.uri}`,
-            resourceUri: resource.uri,
-          });
-        }
-      }
-      toolMetadata.set(name, metadata);
-      
-      // Mark keep-alive servers
-      if (definition.lifecycle === "keep-alive") {
-        lifecycle.markKeepAlive(name, definition);
-      }
-      
-      if (failedTools.length > 0 && ctx.hasUI) {
-        ctx.ui.notify(
-          `MCP: ${name} - ${failedTools.length} tools skipped`,
-          "warning"
-        );
-      }
-      
-      if (ctx.hasUI) {
-        ctx.ui.notify(
-          `MCP: ${name} connected (${connection.tools.length} tools, ${connection.resources.length} resources)`,
-          "info"
-        );
-      }
+      return { name, definition, connection, error: null };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
+      return { name, definition, connection: null, error: message };
+    }
+  });
+  const prefix = config.settings?.toolPrefix ?? "server";
+  
+  // Process results
+  for (const { name, definition, connection, error } of results) {
+    if (error || !connection) {
       if (ctx.hasUI) {
-        ctx.ui.notify(`MCP: Failed to connect to ${name}: ${message}`, "error");
+        ctx.ui.notify(`MCP: Failed to connect to ${name}: ${error}`, "error");
       }
-      console.error(`MCP: Failed to connect to ${name}: ${message}`);
+      console.error(`MCP: Failed to connect to ${name}: ${error}`);
+      continue;
+    }
+    
+    // Collect tool names (NOT registered with Pi - only mcp proxy is registered)
+    const { collected: toolNames, failed: failedTools } = collectToolNames(
+      connection.tools,
+      { serverName: name, prefix }
+    );
+    
+    // Collect resource tool names (if enabled)
+    if (definition.exposeResources !== false && connection.resources.length > 0) {
+      const resourceToolNames = collectResourceToolNames(
+        connection.resources,
+        { serverName: name, prefix }
+      );
+      toolNames.push(...resourceToolNames);
+    }
+    
+    registeredTools.set(name, toolNames);
+    
+    // Build tool metadata for searching (include inputSchema for describe/errors)
+    const metadata: ToolMetadata[] = connection.tools.map(tool => ({
+      name: formatToolName(tool.name, name, prefix),
+      originalName: tool.name,
+      description: tool.description ?? "",
+      inputSchema: tool.inputSchema,
+    }));
+    // Add resource tools to metadata
+    for (const resource of connection.resources) {
+      if (definition.exposeResources !== false) {
+        const baseName = `get_${resourceNameToToolName(resource.name)}`;
+        metadata.push({
+          name: formatToolName(baseName, name, prefix),
+          originalName: baseName,
+          description: resource.description ?? `Read resource: ${resource.uri}`,
+          resourceUri: resource.uri,
+        });
+      }
+    }
+    toolMetadata.set(name, metadata);
+    
+    // Mark keep-alive servers
+    if (definition.lifecycle === "keep-alive") {
+      lifecycle.markKeepAlive(name, definition);
+    }
+    
+    if (failedTools.length > 0 && ctx.hasUI) {
+      ctx.ui.notify(
+        `MCP: ${name} - ${failedTools.length} tools skipped`,
+        "warning"
+      );
     }
   }
   
+  // Summary notification
+  const connectedCount = results.filter(r => r.connection).length;
+  const failedCount = results.filter(r => r.error).length;
+  if (ctx.hasUI && connectedCount > 0) {
+    const totalTools = [...registeredTools.values()].flat().length;
+    const msg = failedCount > 0 
+      ? `MCP: ${connectedCount}/${serverEntries.length} servers connected (${totalTools} tools)`
+      : `MCP: ${connectedCount} servers connected (${totalTools} tools)`;
+    ctx.ui.notify(msg, "info");
+  }
+  
   // Start health checks for keep-alive servers
   lifecycle.startHealthChecks();
   
@@ -792,11 +864,12 @@ async function reconnectServers(
       
       state.registeredTools.set(name, toolNames);
       
-      // Update tool metadata for searching
+      // Update tool metadata for searching (include inputSchema for describe/errors)
       const metadata: ToolMetadata[] = connection.tools.map(tool => ({
         name: formatToolName(tool.name, name, prefix),
         originalName: tool.name,
         description: tool.description ?? "",
+        inputSchema: tool.inputSchema,
       }));
       for (const resource of connection.resources) {
         if (definition.exposeResources !== false) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mcp-adapter",
-  "version": "1.2.2",
+  "version": "1.4.0",
   "description": "MCP (Model Context Protocol) adapter extension for Pi coding agent",
   "type": "module",
   "license": "MIT",