pi-lean-ctx 3.2.1 → 3.3.5

package/extensions/index.ts

@@ -490,10 +490,22 @@ export default function (pi: ExtensionAPI) {
       const lines: string[] = [];
       lines.push(found ? `Binary: ${bin}` : "Binary: NOT FOUND — install: cargo install lean-ctx");
       lines.push(`MCP bridge: ${status.mode} (${status.connected ? "connected" : "disconnected"})`);
+      lines.push(`Reconnect attempts: ${status.reconnectAttempts}`);
       lines.push(`MCP tools: ${status.toolCount} registered`);
       if (status.toolNames.length > 0) {
         lines.push(`  ${status.toolNames.join(", ")}`);
       }
+      if (status.lastHungTool) {
+        lines.push(`Last hung tool: ${status.lastHungTool}`);
+      }
+      if (status.lastRetry) {
+        lines.push(
+          `Last retry: ${status.lastRetry.toolName} (${status.lastRetry.reason}) at ${status.lastRetry.timestamp}`,
+        );
+      }
+      if (status.lastError) {
+        lines.push(`Last bridge error: ${status.lastError}`);
+      }
 
       ctx.ui.notify(lines.join("\n"), found && status.connected ? "info" : "warning");
     },

package/extensions/mcp-bridge.ts

@@ -2,7 +2,7 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import type { McpBridgeStatus } from "./types.js";
+import type { McpBridgeRetryState, McpBridgeStatus } from "./types.js";
 
 const CLI_OVERRIDE_TOOLS = new Set([
   "ctx_read",
@@ -14,6 +14,7 @@ const CLI_OVERRIDE_TOOLS = new Set([
 
 const MAX_RECONNECT_ATTEMPTS = 3;
 const RECONNECT_DELAY_MS = 2000;
+const TOOL_CALL_TIMEOUT_MS = 120000;
 
 type McpTool = {
   name: string;
@@ -21,6 +22,32 @@ type McpTool = {
   inputSchema?: Record<string, unknown>;
 };
 
+function isAbortLikeError(error: unknown): boolean {
+  if (!(error instanceof Error)) return false;
+  const msg = error.message.toLowerCase();
+  return error.name === "AbortError"
+    || msg.includes("aborted")
+    || msg.includes("cancelled")
+    || msg.includes("canceled");
+}
+
+function isHostToolRejection(error: unknown): boolean {
+  if (!(error instanceof Error)) return false;
+  const msg = error.message.toLowerCase();
+  return msg.includes("the user doesn't want to proceed with this tool use")
+    || msg.includes("tool use was rejected")
+    || msg.includes("stop what you are doing and wait for the user to tell you how to proceed");
+}
+
+function isRetrySafeTool(name: string): boolean {
+  const lower = name.toLowerCase();
+  const mutatingHints = [
+    "edit", "fill", "cache", "workflow",
+    "execute", "session", "knowledge", "response",
+  ];
+  return !mutatingHints.some((hint) => lower.includes(hint));
+}
+
 export class McpBridge {
   private client: Client | null = null;
   private transport: StdioClientTransport | null = null;
@@ -28,6 +55,9 @@ export class McpBridge {
   private connected = false;
   private binary: string;
   private reconnectAttempts = 0;
+  private lastError: string | undefined;
+  private lastHungTool: string | undefined;
+  private lastRetry: McpBridgeRetryState | undefined;
 
   constructor(binary: string) {
     this.binary = binary;
@@ -39,6 +69,7 @@ export class McpBridge {
       await this.discoverAndRegisterTools(pi);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
+      this.lastError = msg;
       console.error(`[lean-ctx MCP bridge] Failed to start: ${msg}`);
     }
   }
@@ -57,20 +88,24 @@ export class McpBridge {
 
     this.transport.onclose = () => {
       this.connected = false;
+      this.lastError = "MCP transport closed";
       this.scheduleReconnect();
     };
 
     this.transport.onerror = (err) => {
+      this.lastError = err.message;
       console.error(`[lean-ctx MCP bridge] Transport error: ${err.message}`);
     };
 
     await this.client.connect(this.transport);
     this.connected = true;
     this.reconnectAttempts = 0;
+    this.lastError = undefined;
   }
 
   private scheduleReconnect(): void {
     if (this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+      this.lastError = `Max reconnect attempts (${MAX_RECONNECT_ATTEMPTS}) reached.`;
       console.error(
         `[lean-ctx MCP bridge] Max reconnect attempts (${MAX_RECONNECT_ATTEMPTS}) reached. MCP tools unavailable.`,
       );
@@ -84,12 +119,25 @@ export class McpBridge {
       try {
         await this.connect();
         console.error("[lean-ctx MCP bridge] Reconnected successfully");
-      } catch {
+      } catch (error) {
+        this.lastError = error instanceof Error ? error.message : String(error);
         this.scheduleReconnect();
       }
     }, delay);
   }
 
+  private async forceReconnect(): Promise<void> {
+    this.connected = false;
+    try {
+      await this.client?.close();
+    } catch {
+      // best-effort cleanup
+    }
+    this.client = null;
+    this.transport = null;
+    await this.connect();
+  }
+
   private async discoverAndRegisterTools(pi: ExtensionAPI): Promise<void> {
     if (!this.client) return;
 
@@ -112,8 +160,12 @@ export class McpBridge {
       description: tool.description ?? `lean-ctx MCP tool: ${tool.name}`,
       promptSnippet: tool.description ?? tool.name,
       parameters: schema,
-      async execute(_toolCallId, params, _signal) {
-        return bridge.callTool(tool.name, params as Record<string, unknown>);
+      async execute(_toolCallId, params, signal) {
+        return bridge.callTool(
+          tool.name,
+          params as Record<string, unknown>,
+          signal,
+        );
       },
     });
 
@@ -123,6 +175,7 @@ export class McpBridge {
   async callTool(
     name: string,
     args: Record<string, unknown>,
+    signal?: AbortSignal,
   ): Promise<{ content: Array<{ type: string; text: string }> }> {
     if (!this.client || !this.connected) {
       throw new Error(
@@ -130,8 +183,93 @@ export class McpBridge {
       );
     }
 
-    const result = await this.client.callTool({ name, arguments: args });
+    if (signal?.aborted) {
+      throw new Error(`lean-ctx MCP tool "${name}" interrupted by host.`);
+    }
+
+    try {
+      const result = await this.callToolWithTimeout(name, args, signal);
+      this.lastError = undefined;
+      return this.toTextBlocks(result);
+    } catch (error) {
+      if (isHostToolRejection(error) || isAbortLikeError(error)) {
+        throw new Error(`lean-ctx MCP tool "${name}" interrupted by host.`);
+      }
+
+      if (this.isTimeoutError(error) && isRetrySafeTool(name)) {
+        this.lastRetry = {
+          toolName: name,
+          reason: "timeout",
+          retried: true,
+          timestamp: new Date().toISOString(),
+        };
+        await this.forceReconnect();
+        const retried = await this.callToolWithTimeout(name, args, signal);
+        this.lastError = undefined;
+        return this.toTextBlocks(retried);
+      }
+
+      this.lastError = error instanceof Error ? error.message : String(error);
+      throw error;
+    }
+  }
+
+  private async callToolWithTimeout(
+    name: string,
+    args: Record<string, unknown>,
+    signal?: AbortSignal,
+  ) {
+    const call = this.client?.callTool({ name, arguments: args });
+    if (!call) {
+      throw new Error(`lean-ctx MCP bridge not connected. Tool "${name}" unavailable.`);
+    }
+
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const timeout = new Promise<never>((_, reject) => {
+      timer = setTimeout(() => {
+        this.lastHungTool = name;
+        reject(
+          new Error(
+            `lean-ctx MCP tool "${name}" timed out after ${Math.round(TOOL_CALL_TIMEOUT_MS / 1000)}s.`,
+          ),
+        );
+      }, TOOL_CALL_TIMEOUT_MS);
+    });
+
+    const promises: Promise<unknown>[] = [call, timeout];
+
+    if (signal) {
+      let onAbort: (() => void) | undefined;
+      const abortPromise = new Promise<never>((_, reject) => {
+        onAbort = () => {
+          reject(new Error(`lean-ctx MCP tool "${name}" interrupted by host.`));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+      });
+      promises.push(abortPromise);
+
+      try {
+        return await Promise.race(promises);
+      } finally {
+        if (timer) clearTimeout(timer);
+        if (onAbort) signal.removeEventListener("abort", onAbort);
+      }
+    }
+
+    try {
+      return await Promise.race(promises);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+
+  private isTimeoutError(error: unknown): boolean {
+    return error instanceof Error && error.message.includes("timed out after");
+  }
 
+  private toTextBlocks(
+    result: Awaited<ReturnType<Client["callTool"]>>,
+  ): { content: Array<{ type: string; text: string }> } {
     const content = (
       result.content as Array<{ type: string; text?: string }>
     ).map((block) => ({
@@ -198,6 +336,10 @@ export class McpBridge {
       connected: this.connected,
       toolCount: this.registeredTools.length,
       toolNames: [...this.registeredTools],
+      reconnectAttempts: this.reconnectAttempts,
+      lastError: this.lastError,
+      lastHungTool: this.lastHungTool,
+      lastRetry: this.lastRetry,
     };
   }
 

package/extensions/types.ts

@@ -4,10 +4,21 @@ export type CompressionStats = {
   percentSaved: number;
 };
 
+export type McpBridgeRetryState = {
+  toolName: string;
+  reason: "timeout";
+  retried: boolean;
+  timestamp: string;
+};
+
 export type McpBridgeStatus = {
   mode: "embedded" | "adapter" | "disabled";
   connected: boolean;
   toolCount: number;
   toolNames: string[];
+  reconnectAttempts: number;
+  lastError?: string;
+  lastHungTool?: string;
+  lastRetry?: McpBridgeRetryState;
   error?: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-lean-ctx",
-  "version": "3.2.1",
+  "version": "3.3.5",
   "description": "Pi Coding Agent extension with first-class MCP support — routes bash, read, grep, find, and ls through lean-ctx CLI, and exposes all 46 lean-ctx MCP tools (ctx_session, ctx_knowledge, ctx_semantic_search, ctx_impact, ctx_architecture, ctx_workflow, ctx_gain, etc.) natively in Pi",
   "keywords": ["pi-package", "lean-ctx", "token-optimization", "compression", "mcp"],
   "license": "Apache-2.0",