@context-engine-bridge/context-engine-mcp-bridge 0.0.3 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-engine-bridge/context-engine-mcp-bridge",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Context Engine MCP bridge (http/stdio proxy combining indexer + memory servers)",
   "bin": {
     "ctxce": "bin/ctxce.js",

package/src/mcpServer.js

@@ -94,6 +94,22 @@ function withTimeout(promise, ms, label) {
   });
 }
 
+function getBridgeToolTimeoutMs() {
+  try {
+    const raw = process.env.CTXCE_TOOL_TIMEOUT_MSEC;
+    if (!raw) {
+      return 300000;
+    }
+    const parsed = Number.parseInt(String(raw), 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+      return 300000;
+    }
+    return parsed;
+  } catch {
+    return 300000;
+  }
+}
+
 function selectClientForTool(name, indexerClient, memoryClient) {
   if (!name) {
     return indexerClient;
@@ -104,6 +120,118 @@ function selectClientForTool(name, indexerClient, memoryClient) {
   }
   return indexerClient;
 }
+
+function isSessionError(error) {
+  try {
+    const msg =
+      (error && typeof error.message === "string" && error.message) ||
+      (typeof error === "string" ? error : String(error || ""));
+    if (!msg) {
+      return false;
+    }
+    return (
+      msg.includes("No valid session ID") ||
+      msg.includes("Mcp-Session-Id header is required") ||
+      msg.includes("Server not initialized") ||
+      msg.includes("Session not found")
+    );
+  } catch {
+    return false;
+  }
+}
+
+function getBridgeRetryAttempts() {
+  try {
+    const raw = process.env.CTXCE_TOOL_RETRY_ATTEMPTS;
+    if (!raw) {
+      return 2;
+    }
+    const parsed = Number.parseInt(String(raw), 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+      return 1;
+    }
+    return parsed;
+  } catch {
+    return 2;
+  }
+}
+
+function getBridgeRetryDelayMs() {
+  try {
+    const raw = process.env.CTXCE_TOOL_RETRY_DELAY_MSEC;
+    if (!raw) {
+      return 200;
+    }
+    const parsed = Number.parseInt(String(raw), 10);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+      return 0;
+    }
+    return parsed;
+  } catch {
+    return 200;
+  }
+}
+
+function isTransientToolError(error) {
+  try {
+    const msg =
+      (error && typeof error.message === "string" && error.message) ||
+      (typeof error === "string" ? error : String(error || ""));
+    if (!msg) {
+      return false;
+    }
+    const lower = msg.toLowerCase();
+
+    if (
+      lower.includes("timed out") ||
+      lower.includes("timeout") ||
+      lower.includes("time-out")
+    ) {
+      return true;
+    }
+
+    if (
+      lower.includes("econnreset") ||
+      lower.includes("econnrefused") ||
+      lower.includes("etimedout") ||
+      lower.includes("enotfound") ||
+      lower.includes("ehostunreach") ||
+      lower.includes("enetunreach")
+    ) {
+      return true;
+    }
+
+    if (
+      lower.includes("bad gateway") ||
+      lower.includes("gateway timeout") ||
+      lower.includes("service unavailable") ||
+      lower.includes(" 502 ") ||
+      lower.includes(" 503 ") ||
+      lower.includes(" 504 ")
+    ) {
+      return true;
+    }
+
+    if (lower.includes("network error")) {
+      return true;
+    }
+
+    if (typeof error.code === "number" && error.code === -32001 && !isSessionError(error)) {
+      return true;
+    }
+    if (
+      typeof error.code === "string" &&
+      error.code.toLowerCase &&
+      error.code.toLowerCase().includes("timeout")
+    ) {
+      return true;
+    }
+
+    return false;
+  } catch {
+    return false;
+  }
+}
 // MCP stdio server implemented using the official MCP TypeScript SDK.
 // Acts as a low-level proxy for tools, forwarding tools/list and tools/call
 // to the remote qdrant-indexer MCP server while adding a local `ping` tool.
@@ -146,52 +274,8 @@ async function createBridgeServer(options) {
     );
   }
 
-  // High-level MCP client for the remote HTTP /mcp indexer
-  const indexerTransport = new StreamableHTTPClientTransport(indexerUrl);
-  const indexerClient = new Client(
-    {
-      name: "ctx-context-engine-bridge-http-client",
-      version: "0.0.1",
-    },
-    {
-      capabilities: {
-        tools: {},
-        resources: {},
-        prompts: {},
-      },
-    },
-  );
-
-  try {
-    await indexerClient.connect(indexerTransport);
-  } catch (err) {
-    debugLog("[ctxce] Failed to connect MCP HTTP client to indexer: " + String(err));
-  }
-
+  let indexerClient = null;
   let memoryClient = null;
-  if (memoryUrl) {
-    try {
-      const memoryTransport = new StreamableHTTPClientTransport(memoryUrl);
-      memoryClient = new Client(
-        {
-          name: "ctx-context-engine-bridge-memory-client",
-          version: "0.0.1",
-        },
-        {
-          capabilities: {
-            tools: {},
-            resources: {},
-            prompts: {},
-          },
-        },
-      );
-      await memoryClient.connect(memoryTransport);
-      debugLog(`[ctxce] Connected memory MCP client: ${memoryUrl}`);
-    } catch (err) {
-      debugLog("[ctxce] Failed to connect memory MCP client: " + String(err));
-      memoryClient = null;
-    }
-  }
 
   // Derive a simple session identifier for this bridge process. In the
   // future this can be made user-aware (e.g. from auth), but for now we
@@ -213,13 +297,81 @@ async function createBridgeServer(options) {
     defaultsPayload.under = defaultUnder;
   }
 
-  if (Object.keys(defaultsPayload).length > 1) {
-    await sendSessionDefaults(indexerClient, defaultsPayload, "indexer");
-    if (memoryClient) {
-      await sendSessionDefaults(memoryClient, defaultsPayload, "memory");
+  async function initializeRemoteClients(forceRecreate = false) {
+    if (!forceRecreate && indexerClient) {
+      return;
+    }
+
+    if (forceRecreate) {
+      try {
+        debugLog("[ctxce] Reinitializing remote MCP clients after session error.");
+      } catch {
+        // ignore logging failures
+      }
+    }
+
+    let nextIndexerClient = null;
+    try {
+      const indexerTransport = new StreamableHTTPClientTransport(indexerUrl);
+      const client = new Client(
+        {
+          name: "ctx-context-engine-bridge-http-client",
+          version: "0.0.1",
+        },
+        {
+          capabilities: {
+            tools: {},
+            resources: {},
+            prompts: {},
+          },
+        },
+      );
+      await client.connect(indexerTransport);
+      nextIndexerClient = client;
+    } catch (err) {
+      debugLog("[ctxce] Failed to connect MCP HTTP client to indexer: " + String(err));
+      nextIndexerClient = null;
+    }
+
+    let nextMemoryClient = null;
+    if (memoryUrl) {
+      try {
+        const memoryTransport = new StreamableHTTPClientTransport(memoryUrl);
+        const client = new Client(
+          {
+            name: "ctx-context-engine-bridge-memory-client",
+            version: "0.0.1",
+          },
+          {
+            capabilities: {
+              tools: {},
+              resources: {},
+              prompts: {},
+            },
+          },
+        );
+        await client.connect(memoryTransport);
+        debugLog(`[ctxce] Connected memory MCP client: ${memoryUrl}`);
+        nextMemoryClient = client;
+      } catch (err) {
+        debugLog("[ctxce] Failed to connect memory MCP client: " + String(err));
+        nextMemoryClient = null;
+      }
+    }
+
+    indexerClient = nextIndexerClient;
+    memoryClient = nextMemoryClient;
+
+    if (Object.keys(defaultsPayload).length > 1 && indexerClient) {
+      await sendSessionDefaults(indexerClient, defaultsPayload, "indexer");
+      if (memoryClient) {
+        await sendSessionDefaults(memoryClient, defaultsPayload, "memory");
+      }
     }
   }
 
+  await initializeRemoteClients(false);
+
   const server = new Server( // TODO: marked as depreciated
     {
       name: "ctx-context-engine-bridge",
@@ -237,6 +389,10 @@ async function createBridgeServer(options) {
     let remote;
     try {
       debugLog("[ctxce] tools/list: fetching tools from indexer");
+      await initializeRemoteClients(false);
+      if (!indexerClient) {
+        throw new Error("Indexer MCP client not initialized");
+      }
       remote = await withTimeout(
         indexerClient.listTools(),
         10000,
@@ -295,16 +451,60 @@ async function createBridgeServer(options) {
       return indexerResult;
     }
 
-    const targetClient = selectClientForTool(name, indexerClient, memoryClient);
-    if (!targetClient) {
-      throw new Error(`Tool ${name} not available on any configured MCP server`);
+    await initializeRemoteClients(false);
+
+    const timeoutMs = getBridgeToolTimeoutMs();
+    const maxAttempts = getBridgeRetryAttempts();
+    const retryDelayMs = getBridgeRetryDelayMs();
+    let sessionRetried = false;
+    let lastError;
+
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+      if (attempt > 0 && retryDelayMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+      }
+
+      const targetClient = selectClientForTool(name, indexerClient, memoryClient);
+      if (!targetClient) {
+        throw new Error(`Tool ${name} not available on any configured MCP server`);
+      }
+
+      try {
+        const result = await targetClient.callTool(
+          {
+            name,
+            arguments: args,
+          },
+          undefined,
+          { timeout: timeoutMs },
+        );
+        return result;
+      } catch (err) {
+        lastError = err;
+
+        if (isSessionError(err) && !sessionRetried) {
+          debugLog(
+            "[ctxce] tools/call: detected remote MCP session error; reinitializing clients and retrying once: " +
+              String(err),
+          );
+          await initializeRemoteClients(true);
+          sessionRetried = true;
+          continue;
+        }
+
+        if (!isTransientToolError(err) || attempt === maxAttempts - 1) {
+          throw err;
+        }
+
+        debugLog(
+          `[ctxce] tools/call: transient error (attempt ${attempt + 1}/${maxAttempts}), retrying: ` +
+            String(err),
+        );
+        // Loop will retry
+      }
     }
 
-    const result = await targetClient.callTool({
-      name,
-      arguments: args,
-    });
-    return result;
+    throw lastError || new Error("Unknown MCP tools/call error");
   });
 
   return server;
@@ -314,6 +514,27 @@ export async function runMcpServer(options) {
   const server = await createBridgeServer(options);
   const transport = new StdioServerTransport();
   await server.connect(transport);
+
+  const exitOnStdinClose = process.env.CTXCE_EXIT_ON_STDIN_CLOSE !== "0";
+  if (exitOnStdinClose) {
+    const handleStdioClosed = () => {
+      try {
+        debugLog("[ctxce] Stdio transport closed; exiting MCP bridge process.");
+      } catch {
+        // ignore
+      }
+      // Allow any in-flight logs to flush, then exit.
+      setTimeout(() => {
+        process.exit(0);
+      }, 10).unref();
+    };
+
+    if (process.stdin && typeof process.stdin.on === "function") {
+      process.stdin.on("end", handleStdioClosed);
+      process.stdin.on("close", handleStdioClosed);
+      process.stdin.on("error", handleStdioClosed);
+    }
+  }
 }
 
 export async function runHttpMcpServer(options) {