@justanothermldude/mcp-exec 1.3.6 → 1.4.0

package/dist/index.js

@@ -11,6 +11,10 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprot
 
 // dist/tools/list-servers.js
 import { listServers } from "@justanothermldude/meta-mcp-core";
+function escapeMarkdownCell(text) {
+  return text.replace(/\|/g, "\\|");
+}
+__name(escapeMarkdownCell, "escapeMarkdownCell");
 var listAvailableMcpServersTool = {
   name: "list_available_mcp_servers",
   description: "List available MCP servers with their names, descriptions, and tags. Optionally filter by name or tag.",
@@ -45,8 +49,37 @@ function createListServersHandler() {
           return false;
         });
       }
+      if (servers.length === 0) {
+        const noMatchMsg = filter ? `No servers matched filter: '${filter}'. Try list_available_mcp_servers without a filter.` : "No servers are configured. Check that servers.json is properly set up.";
+        return {
+          content: [{ type: "text", text: noMatchMsg }],
+          isError: false
+        };
+      }
+      const rows = servers.map((server) => {
+        const desc = (() => {
+          if (!server.description)
+            return "";
+          if (server.description.length <= 80)
+            return server.description;
+          let truncated = server.description.substring(0, 77);
+          truncated = truncated.replace(/[\uD800-\uDBFF]$/, "");
+          return truncated + "...";
+        })();
+        let tagsStr = "";
+        if (server.tags && server.tags.length > 0) {
+          const displayTags = server.tags.slice(0, 5);
+          const hasMore = server.tags.length > 5;
+          tagsStr = displayTags.join(", ") + (hasMore ? ` +${server.tags.length - 5} more` : "");
+        }
+        const escapedName = escapeMarkdownCell(server.name);
+        const escapedDesc = escapeMarkdownCell(desc);
+        const escapedTags = escapeMarkdownCell(tagsStr);
+        return `| \`${escapedName}\` | ${escapedDesc} | ${escapedTags} |`;
+      });
+      const table = "## Available MCP Servers\n\n| Name | Description | Tags |\n|------|-------------|------|\n" + rows.join("\n") + '\n\nTo use a server, pass its exact name in the `wrappers` array of `execute_code_with_wrappers`.\nExample: `wrappers: ["adobe-mcp-gateway"]`\n\nTo see tools on a server: `get_mcp_tool_schema({ server: "adobe-mcp-gateway" })`';
       return {
-        content: [{ type: "text", text: JSON.stringify(servers, null, 2) }],
+        content: [{ type: "text", text: table }],
         isError: false
       };
     } catch (error) {
@@ -164,12 +197,29 @@ function isGetToolSchemaInput(args2) {
 }
 __name(isGetToolSchemaInput, "isGetToolSchemaInput");
 
+// dist/tools/execute-with-wrappers.js
+import { listServers as listServers3 } from "@justanothermldude/meta-mcp-core";
+
 // dist/codegen/wrapper-generator.js
 var BRIDGE_ENDPOINT = "http://127.0.0.1:3000/call";
-function jsonSchemaToTs(prop, _required = true) {
+function jsonSchemaToTs(prop, _required = true, definitions, visited = /* @__PURE__ */ new Set()) {
   if (!prop) {
     return "unknown";
   }
+  if (prop.$ref) {
+    const refKey = prop.$ref.replace(/^#\/(definitions|\$defs)\//, "");
+    if (definitions && refKey in definitions) {
+      if (visited.has(refKey))
+        return "unknown";
+      const nextVisited = new Set(visited);
+      nextVisited.add(refKey);
+      return jsonSchemaToTs(definitions[refKey], _required, definitions, nextVisited);
+    }
+    return "unknown";
+  }
+  if ("const" in prop && prop.const !== void 0) {
+    return JSON.stringify(prop.const);
+  }
   if (Array.isArray(prop.type)) {
     const types = prop.type.map((t) => primitiveToTs(t));
     return types.join(" | ");
@@ -177,20 +227,60 @@ function jsonSchemaToTs(prop, _required = true) {
   if (prop.enum) {
     return prop.enum.map((v) => JSON.stringify(v)).join(" | ");
   }
+  if (prop.oneOf) {
+    const types = prop.oneOf.map((s) => jsonSchemaToTs(s, _required, definitions, visited)).filter((t) => t !== "unknown");
+    if (types.length > 0) {
+      return types.join(" | ");
+    }
+  }
+  if (prop.anyOf) {
+    const types = prop.anyOf.map((s) => jsonSchemaToTs(s, _required, definitions, visited)).filter((t) => t !== "unknown");
+    if (types.length > 0) {
+      return types.join(" | ");
+    }
+  }
+  if (prop.allOf) {
+    const types = prop.allOf.map((s) => jsonSchemaToTs(s, _required, definitions, visited)).filter((t) => t !== "unknown");
+    if (types.length > 0) {
+      const primitives = ["string", "number", "boolean", "null"];
+      const incompatible = types.filter((t) => primitives.includes(t)).length > 1;
+      if (incompatible)
+        return "unknown";
+      return types.join(" & ");
+    }
+  }
   if (prop.type === "object" && prop.properties) {
     const propLines = Object.entries(prop.properties).map(([key, value]) => {
       const isRequired = prop.required?.includes(key) ?? false;
-      const tsType = jsonSchemaToTs(value, isRequired);
+      const tsType = jsonSchemaToTs(value, isRequired, definitions, visited);
       const optionalMark = isRequired ? "" : "?";
       return `${key}${optionalMark}: ${tsType}`;
     });
+    if (prop.additionalProperties === true) {
+      propLines.push("[key: string]: unknown");
+    } else if (typeof prop.additionalProperties === "object" && prop.additionalProperties !== null) {
+      propLines.push("[key: string]: unknown");
+    } else if (Object.keys(prop.properties).length === 0 && !prop.additionalProperties) {
+      return "Record<string, unknown>";
+    }
     return `{ ${propLines.join("; ")} }`;
   }
+  if (prop.type === "object") {
+    if (prop.additionalProperties === true || typeof prop.additionalProperties === "object" && prop.additionalProperties !== null) {
+      return "Record<string, unknown>";
+    }
+  }
   if (prop.type === "array") {
-    const itemType = prop.items ? jsonSchemaToTs(prop.items, true) : "unknown";
+    const itemType = prop.items ? jsonSchemaToTs(prop.items, true, definitions, visited) : "unknown";
     return `${itemType}[]`;
   }
-  return primitiveToTs(prop.type ?? "unknown");
+  let result = primitiveToTs(prop.type ?? "unknown");
+  if (prop.nullable === true) {
+    if (result !== "unknown" && !result.includes("| null") && !result.includes("null |")) {
+      result = `${result} | null`;
+    }
+  }
+  return result;
 }
 __name(jsonSchemaToTs, "jsonSchemaToTs");
 function primitiveToTs(type) {
@@ -213,7 +303,8 @@ function primitiveToTs(type) {
   }
 }
 __name(primitiveToTs, "primitiveToTs");
-function generateInterface(name, schema) {
+function generateInterface(name, schema, definitions) {
+  const defs = definitions || schema.definitions;
   if (!schema.properties || Object.keys(schema.properties).length === 0) {
     return `interface ${name} {}`;
   }
@@ -223,7 +314,7 @@ function generateInterface(name, schema) {
     const prop = propValue;
     const isRequired = schema.required?.includes(propName) ?? false;
     const optionalMark = isRequired ? "" : "?";
-    const tsType = jsonSchemaToTs(prop, isRequired);
+    const tsType = jsonSchemaToTs(prop, isRequired, defs);
     if (prop.description) {
       lines.push(`  /** ${sanitizeJsDoc(prop.description)} */`);
     }
@@ -318,10 +409,10 @@ function toPascalCase(name) {
   return name.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
 }
 __name(toPascalCase, "toPascalCase");
-function generateToolInterface(tool) {
+function generateToolInterface(tool, rootDefinitions) {
   const interfaceName = `${toPascalCase(tool.name)}Input`;
   if (tool.inputSchema?.properties && Object.keys(tool.inputSchema.properties).length > 0) {
-    return generateInterface(interfaceName, tool.inputSchema);
+    return generateInterface(interfaceName, tool.inputSchema, rootDefinitions);
   }
   return "";
 }
@@ -333,17 +424,41 @@ function generateMethodDefinition(tool, serverName, bridgePort) {
   const inputParam = hasInput ? `input: ${interfaceName}` : "";
   const inputArg = hasInput ? "input" : "{}";
   const lines = [];
+  const requiredParams = [];
+  const optionalParams = [];
+  if (tool.inputSchema?.properties) {
+    for (const propName of Object.keys(tool.inputSchema.properties)) {
+      if (tool.inputSchema.required?.includes(propName)) {
+        requiredParams.push(propName);
+      } else {
+        optionalParams.push(propName);
+      }
+    }
+  }
   if (tool.description) {
     lines.push("  /**");
     lines.push(`   * ${sanitizeJsDoc(tool.description)}`);
     if (tool.inputSchema?.properties) {
       for (const [propName, propValue] of Object.entries(tool.inputSchema.properties)) {
         const prop = propValue;
+        const isRequired = tool.inputSchema.required?.includes(propName) ?? false;
+        const marker = isRequired ? "[required]" : "[optional]";
         if (prop.description) {
-          lines.push(`   * @param input.${propName} - ${sanitizeJsDoc(prop.description)}`);
+          lines.push(`   * @param input.${propName} ${marker} - ${sanitizeJsDoc(prop.description)}`);
+        } else {
+          lines.push(`   * @param input.${propName} ${marker}`);
         }
       }
     }
+    if (requiredParams.length > 0 || optionalParams.length > 0) {
+      lines.push(`   * Required: ${requiredParams.length > 0 ? requiredParams.join(", ") : "none"}`);
+      if (optionalParams.length > 0) {
+        lines.push(`   * Optional: ${optionalParams.join(", ")}`);
+      }
+    }
+    const safeServerName2 = JSON.stringify(serverName);
+    const safeToolName2 = JSON.stringify(tool.name);
+    lines.push(`   * @returns Promise<unknown>. To inspect response shape: get_mcp_tool_schema({ server: ${safeServerName2}, tool: ${safeToolName2} })`);
     lines.push("   */");
   }
   const safeServerName = JSON.stringify(serverName);
@@ -359,15 +474,15 @@ function generateMethodDefinition(tool, serverName, bridgePort) {
   lines.push(`      }),`);
   lines.push(`    });`);
   lines.push(`    if (!response.ok) {`);
-  lines.push("      throw new Error(`Tool call failed: ${response.statusText}`);");
+  lines.push(`      throw new Error(\`[${safeServerName}.${safeToolName}] HTTP \${response.status}: \${response.statusText}\`);`);
   lines.push(`    }`);
   lines.push(`    const data = await response.json() as { success: boolean; content?: unknown; error?: string; isError?: boolean };`);
   lines.push(`    if (!data.success) {`);
-  lines.push(`      throw new Error(data.error || 'Tool call failed');`);
+  lines.push(`      throw new Error(\`[${safeServerName}.${safeToolName}] \${data.error || 'Tool call failed'}\`);`);
   lines.push(`    }`);
   lines.push(`    if (data.isError) {`);
   lines.push(`      const errText = Array.isArray(data.content) && data.content[0]?.text ? data.content[0].text : 'Tool returned isError';`);
-  lines.push(`      throw new Error(errText);`);
+  lines.push(`      throw new Error(\`[${safeServerName}.${safeToolName}] \${errText}\`);`);
   lines.push(`    }`);
   lines.push(`    // Auto-parse JSON from MCP text content blocks for convenience`);
   lines.push(`    const content = data.content;`);
@@ -435,9 +550,9 @@ function generateToolWrapper(tool, serverName) {
   return lines.join("\n");
 }
 __name(generateToolWrapper, "generateToolWrapper");
-function generateServerModule(tools, serverName, bridgePort = 3e3) {
+function generateServerModule(tools, serverName, bridgePort = 3e3, variableNameOverride) {
   const lines = [];
-  const namespaceName = sanitizeIdentifier(serverName);
+  const namespaceName = variableNameOverride ?? sanitizeIdentifier(serverName);
   lines.push("/**");
   lines.push(` * Auto-generated TypeScript wrappers for ${serverName} MCP server tools.`);
   lines.push(` * Case-insensitive: methodName, method_name, and method-name all work.`);
@@ -446,7 +561,8 @@ function generateServerModule(tools, serverName, bridgePort = 3e3) {
   lines.push("");
   lines.push(generateFieldGuard());
   for (const tool of tools) {
-    const interfaceCode = generateToolInterface(tool);
+    const rootDefs = tool.inputSchema?.definitions ?? tool.inputSchema?.$defs;
+    const interfaceCode = generateToolInterface(tool, rootDefs);
     if (interfaceCode) {
       lines.push(interfaceCode);
       lines.push("");
@@ -464,8 +580,51 @@ function generateServerModule(tools, serverName, bridgePort = 3e3) {
   return lines.join("\n");
 }
 __name(generateServerModule, "generateServerModule");
+function generateMcpDictionaryFromMap(serverNames, nameMap) {
+  const lines = [];
+  lines.push("/**");
+  lines.push(" * MCP Server Dictionary - Access all MCP servers via case-agnostic lookup.");
+  lines.push(` * Available: ${serverNames.map((n) => `mcp['${n}']`).join(", ")}`);
+  lines.push(" */");
+  lines.push("");
+  lines.push("const mcp_servers_raw: Record<string, unknown> = {");
+  for (const serverName of serverNames) {
+    const varName = nameMap.get(serverName) ?? sanitizeIdentifier(serverName);
+    lines.push(`  ${JSON.stringify(serverName)}: ${varName},`);
+  }
+  lines.push("};");
+  lines.push("");
+  lines.push(`const mcp = ${generateFuzzyProxy("mcp_servers_raw", "mcp")};`);
+  lines.push("");
+  return lines.join("\n");
+}
+__name(generateMcpDictionaryFromMap, "generateMcpDictionaryFromMap");
 function generateMcpDictionary(serverNames) {
   const lines = [];
+  const sanitizedToOriginal = /* @__PURE__ */ new Map();
+  const uniqueNames = /* @__PURE__ */ new Map();
+  for (let i = 0; i < serverNames.length; i++) {
+    const originalName = serverNames[i];
+    const sanitized = sanitizeIdentifier(originalName);
+    if (!sanitizedToOriginal.has(sanitized)) {
+      sanitizedToOriginal.set(sanitized, []);
+    }
+    sanitizedToOriginal.get(sanitized).push(originalName);
+  }
+  let collisionIndex = 0;
+  for (const originalName of serverNames) {
+    const sanitized = sanitizeIdentifier(originalName);
+    const conflictingNames = sanitizedToOriginal.get(sanitized);
+    if (conflictingNames.length > 1) {
+      const uniqueName = `${sanitized}_${collisionIndex}`;
+      uniqueNames.set(originalName, uniqueName);
+      lines.push(`// WARNING: Server name collision: '${originalName}' and previous server both sanitize to '${sanitized}'. Using '${uniqueName}'.`);
+      collisionIndex++;
+    } else {
+      uniqueNames.set(originalName, sanitized);
+    }
+  }
+  lines.push("");
   const sanitizedNames = serverNames.map(sanitizeIdentifier);
   lines.push("/**");
   lines.push(" * MCP Server Dictionary - Access all MCP servers via case-agnostic lookup.");
@@ -475,8 +634,8 @@ function generateMcpDictionary(serverNames) {
   lines.push("");
   lines.push("const mcp_servers_raw: Record<string, unknown> = {");
   for (const serverName of serverNames) {
-    const sanitized = sanitizeIdentifier(serverName);
-    lines.push(`  ${JSON.stringify(serverName)}: ${sanitized},`);
+    const uniqueName = uniqueNames.get(serverName);
+    lines.push(`  ${JSON.stringify(serverName)}: ${uniqueName},`);
   }
   lines.push("};");
   lines.push("");
@@ -1128,45 +1287,70 @@ var MCPBridge = class {
   handleCallRequest(req, res) {
     let body = "";
     let bodySize = 0;
+    let responseSent = false;
     req.on("data", (chunk) => {
       bodySize += chunk.length;
       if (bodySize > MAX_REQUEST_BODY_SIZE) {
         req.destroy();
-        this.sendError(res, 413, `Request body too large. Maximum size is ${MAX_REQUEST_BODY_SIZE / 1024 / 1024}MB`);
+        if (!responseSent) {
+          responseSent = true;
+          this.sendError(res, 413, `Request body too large. Maximum size is ${MAX_REQUEST_BODY_SIZE / 1024 / 1024}MB`);
+        }
         return;
       }
       body += chunk.toString();
     });
     req.on("end", async () => {
+      if (responseSent)
+        return;
       try {
         let request;
         try {
           request = JSON.parse(body);
         } catch {
-          this.sendError(res, 400, "Invalid JSON body");
+          if (!responseSent) {
+            responseSent = true;
+            this.sendError(res, 400, "Invalid JSON body");
+          }
           return;
         }
         if (!request.server || typeof request.server !== "string") {
-          this.sendError(res, 400, 'Missing or invalid "server" field');
+          if (!responseSent) {
+            responseSent = true;
+            this.sendError(res, 400, 'Missing or invalid "server" field');
+          }
           return;
         }
         if (!request.tool || typeof request.tool !== "string") {
-          this.sendError(res, 400, 'Missing or invalid "tool" field');
+          if (!responseSent) {
+            responseSent = true;
+            this.sendError(res, 400, 'Missing or invalid "tool" field');
+          }
           return;
         }
         if (request.args !== void 0 && (typeof request.args !== "object" || request.args === null || Array.isArray(request.args))) {
-          this.sendError(res, 400, '"args" must be an object');
+          if (!responseSent) {
+            responseSent = true;
+            this.sendError(res, 400, '"args" must be an object');
+          }
           return;
         }
         let connection;
         try {
           connection = await this.pool.getConnection(request.server);
         } catch (err) {
-          const errorMsg = err instanceof Error ? err.message : String(err);
-          if (errorMsg.includes("not found") || errorMsg.includes("No server configured") || errorMsg.includes("Unknown server")) {
-            this.sendError(res, 404, buildServerNotFoundError(request.server));
-          } else {
-            this.sendError(res, 502, buildConnectionError(request.server, errorMsg));
+          if (!responseSent) {
+            responseSent = true;
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            if (errorMsg.includes("not found") || errorMsg.includes("No server configured") || errorMsg.includes("Unknown server")) {
+              this.sendError(res, 404, buildServerNotFoundError(request.server));
+            } else if (errorMsg.includes("403") || errorMsg.includes("Forbidden") || errorMsg.includes("PermissionError") || errorMsg.includes("Unauthorized")) {
+              this.sendError(res, 403, `Authentication failed for server '${request.server}'. Check X-MCP-Client header and backend auth config.`);
+            } else if (errorMsg.includes("503") || errorMsg.includes("Service Unavailable")) {
+              this.sendError(res, 503, `Server '${request.server}' is unavailable. It may be starting up \u2014 retry in a few seconds.`);
+            } else {
+              this.sendError(res, 502, buildConnectionError(request.server, errorMsg));
+            }
           }
           return;
         }
@@ -1183,36 +1367,52 @@ var MCPBridge = class {
             // resultSchema
             timeout ? { timeout } : void 0
           );
-          const response = {
-            success: true,
-            content: result.content,
-            isError: result.isError
-          };
-          res.writeHead(200);
-          res.end(JSON.stringify(response));
+          if (!responseSent) {
+            responseSent = true;
+            const response = {
+              success: true,
+              content: result.content,
+              isError: result.isError
+            };
+            res.writeHead(200);
+            res.end(JSON.stringify(response));
+          }
         } catch (err) {
-          const errorMsg = err instanceof Error ? err.message : String(err);
-          if (errorMsg.includes("not found") || errorMsg.includes("Unknown tool") || errorMsg.includes("no such tool")) {
-            try {
-              const tools = await connection.getTools();
-              const toolNames = tools.map((t) => t.name);
-              this.sendError(res, 404, buildToolNotFoundError(request.server, request.tool, toolNames));
-            } catch {
-              this.sendError(res, 500, `Tool '${request.tool}' not found on server '${request.server}'. Unable to fetch available tools.`);
+          if (!responseSent) {
+            responseSent = true;
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            if (errorMsg.includes("not found") || errorMsg.includes("Unknown tool") || errorMsg.includes("no such tool")) {
+              try {
+                const tools = await connection.getTools();
+                const toolNames = tools.map((t) => t.name);
+                this.sendError(res, 404, buildToolNotFoundError(request.server, request.tool, toolNames));
+              } catch {
+                this.sendError(res, 500, `Tool '${request.tool}' not found on server '${request.server}'. Unable to fetch available tools.`);
+              }
+            } else if (errorMsg.includes("403") || errorMsg.includes("Forbidden") || errorMsg.includes("PermissionError") || errorMsg.includes("Unauthorized")) {
+              this.sendError(res, 403, `Authorization failed calling '${request.tool}' on '${request.server}': ${errorMsg}. Ensure X-MCP-Client header is being sent.`);
+            } else if (errorMsg.includes("503") || errorMsg.includes("504") || errorMsg.includes("Gateway")) {
+              this.sendError(res, 503, `Server '${request.server}' temporarily unavailable during tool '${request.tool}'. Retry after a short delay.`);
+            } else {
+              this.sendError(res, 500, `[${request.server}.${request.tool}] Tool execution failed: ${errorMsg}`);
             }
-          } else {
-            this.sendError(res, 500, `Tool execution failed: ${errorMsg}`);
           }
         } finally {
           this.pool.releaseConnection(request.server);
         }
       } catch (err) {
-        const errorMsg = err instanceof Error ? err.message : String(err);
-        this.sendError(res, 500, `Internal error: ${errorMsg}`);
+        if (!responseSent) {
+          responseSent = true;
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          this.sendError(res, 500, `Internal error: ${errorMsg}`);
+        }
       }
     });
     req.on("error", (err) => {
-      this.sendError(res, 400, `Request error: ${err.message}`);
+      if (!responseSent) {
+        responseSent = true;
+        this.sendError(res, 400, `Request error: ${err.message}`);
+      }
     });
   }
   /**
@@ -1266,6 +1466,89 @@ var executeCodeWithWrappersTool = {
     required: ["code", "wrappers"]
   }
 };
+function buildServerListString() {
+  try {
+    const servers = listServers3();
+    if (!servers || servers.length === 0) {
+      return "";
+    }
+    const serverLines = servers.slice(0, 7).map((s) => {
+      const desc = s.description || "No description";
+      return `  \u2022 ${s.name} \u2014 ${desc}`;
+    });
+    const moreCount = Math.max(0, servers.length - 7);
+    const moreStr = moreCount > 0 ? `
+  [+${moreCount} more]` : "";
+    return `
+Available MCP servers (use exact names in wrappers array):
+${serverLines.join("\n")}${moreStr}
+
+Use list_available_mcp_servers to discover tools on each server before calling execute_code_with_wrappers.`;
+  } catch {
+    return "";
+  }
+}
+__name(buildServerListString, "buildServerListString");
+function createExecuteCodeWithWrappersToolDefinition() {
+  const baseDescription = 'Execute TypeScript/JavaScript code with auto-generated typed wrappers for specified MCP servers. Provides a typed API like github.createIssue({ title: "..." }) instead of raw mcp.callTool(). Multi-line code is supported - format naturally for readability.';
+  const serverList = buildServerListString();
+  const environmentNote = '\n\nExecution environment: Node.js (not browser). Top-level await is supported.\n- Use ES modules syntax (import/export NOT supported \u2014 modules are pre-injected as namespace vars)\n- DO NOT use require(), __dirname, __filename, or browser APIs (window, document, localStorage)\n- Available globals: fetch (Node 18+), console, process, Buffer, setTimeout, clearTimeout\n- Server namespaces are pre-injected: use serverName.toolName(args) directly\n- mcp is the server dictionary: mcp["server-name"].toolName(args) for dynamic lookup\n- Low-level fallback (avoid if typed wrapper exists): globalThis.mcp.callTool(serverName, toolName, args)';
+  return {
+    name: "execute_code_with_wrappers",
+    description: baseDescription + serverList + environmentNote,
+    inputSchema: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: "The TypeScript/JavaScript code to execute. Multi-line supported - format for readability."
+        },
+        wrappers: {
+          type: "array",
+          items: { type: "string" },
+          description: "Array of MCP server names to generate typed wrappers for"
+        },
+        timeout_ms: {
+          type: "number",
+          description: `Maximum execution time in milliseconds (default: ${DEFAULT_TIMEOUT_MS})`
+        }
+      },
+      required: ["code", "wrappers"]
+    }
+  };
+}
+__name(createExecuteCodeWithWrappersToolDefinition, "createExecuteCodeWithWrappersToolDefinition");
+function sanitizeIdentifier2(name) {
+  let s = name.replace(/[^a-zA-Z0-9_]/g, "_");
+  if (/^[0-9]/.test(s)) {
+    s = "_" + s;
+  }
+  return s;
+}
+__name(sanitizeIdentifier2, "sanitizeIdentifier");
+function buildUniqueNameMap(names) {
+  const sanitizedToOriginals = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const s = sanitizeIdentifier2(name);
+    if (!sanitizedToOriginals.has(s)) {
+      sanitizedToOriginals.set(s, []);
+    }
+    sanitizedToOriginals.get(s).push(name);
+  }
+  const nameMap = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const s = sanitizeIdentifier2(name);
+    const group = sanitizedToOriginals.get(s);
+    if (group.length === 1) {
+      nameMap.set(name, s);
+    } else {
+      const idx = group.indexOf(name);
+      nameMap.set(name, `${s}_${idx}`);
+    }
+  }
+  return nameMap;
+}
+__name(buildUniqueNameMap, "buildUniqueNameMap");
 function isExecuteWithWrappersInput(args2) {
   return typeof args2 === "object" && args2 !== null && "code" in args2 && typeof args2.code === "string" && "wrappers" in args2 && Array.isArray(args2.wrappers) && args2.wrappers.every((w) => typeof w === "string");
 }
@@ -1300,33 +1583,6 @@ ${indent}}`;
   return lines.join("\n");
 }
 __name(wrapUserCodeForReturnCapture, "wrapUserCodeForReturnCapture");
-function getMcpPreamble(bridgePort) {
-  return `
-// MCP helper for calling tools via HTTP bridge
-declare global {
-  var mcp: {
-    callTool: (server: string, tool: string, args?: Record<string, unknown>) => Promise<unknown[]>;
-  };
-}
-
-globalThis.mcp = {
-  callTool: async (server: string, tool: string, args: Record<string, unknown> = {}) => {
-    const response = await fetch('http://127.0.0.1:${bridgePort}/call', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ server, tool, args }),
-    });
-    const data = await response.json() as { success: boolean; content?: unknown[]; error?: string };
-    if (!data.success) {
-      throw new Error(data.error || 'MCP tool call failed');
-    }
-    return data.content || [];
-  },
-};
-
-`;
-}
-__name(getMcpPreamble, "getMcpPreamble");
 function createExecuteWithWrappersHandler(pool, config = {}) {
   const preferredPort = config.bridgeConfig?.port ?? 3e3;
   let activeBridge = null;
@@ -1341,6 +1597,7 @@ function createExecuteWithWrappersHandler(pool, config = {}) {
   }
   __name(stopActiveBridge, "stopActiveBridge");
   async function executeWithWrappersHandler(args2) {
+    const TOOLS_FETCH_TIMEOUT_MS = 15e3;
     const { code, wrappers, timeout_ms = DEFAULT_TIMEOUT_MS } = args2;
     if (!code || typeof code !== "string") {
       return {
@@ -1375,17 +1632,36 @@ function createExecuteWithWrappersHandler(pool, config = {}) {
     try {
       await bridge.start();
       const actualPort = bridge.getPort();
+      const uniqueNameMap = buildUniqueNameMap(wrappers);
       const wrapperModules = [];
       for (const serverName of wrappers) {
+        let connection;
         try {
-          const connection = await pool.getConnection(serverName);
-          const tools = await connection.getTools();
-          const moduleCode = generateServerModule(tools, serverName, actualPort);
+          connection = await pool.getConnection(serverName);
+          const conn = connection;
+          const tools = await new Promise((resolve, reject) => {
+            const timeoutHandle = setTimeout(() => {
+              reject(new Error(`Timed out fetching tools from server '${serverName}' after ${TOOLS_FETCH_TIMEOUT_MS}ms`));
+            }, TOOLS_FETCH_TIMEOUT_MS);
+            conn.getTools().then((result2) => {
+              clearTimeout(timeoutHandle);
+              resolve(result2);
+            }, (err) => {
+              clearTimeout(timeoutHandle);
+              reject(err);
+            });
+          });
+          const uniqueName = uniqueNameMap.get(serverName) ?? sanitizeIdentifier2(serverName);
+          const moduleCode = generateServerModule(tools, serverName, actualPort, uniqueName);
           wrapperModules.push(moduleCode);
           pool.releaseConnection(serverName);
         } catch (serverError) {
           const errorMessage = serverError instanceof Error ? serverError.message : String(serverError);
+          if (connection !== void 0) {
+            pool.releaseConnection(serverName);
+          }
           await bridge.stop();
+          activeBridge = null;
           return {
             content: [{ type: "text", text: `Error generating wrapper for server '${serverName}': ${errorMessage}` }],
             isError: true
@@ -1393,14 +1669,12 @@ function createExecuteWithWrappersHandler(pool, config = {}) {
         }
       }
       const generatedWrappers = wrapperModules.join("\n\n");
-      const mcpDictionary = generateMcpDictionary(wrappers);
-      const mcpPreamble = getMcpPreamble(actualPort);
+      const mcpDictionary = generateMcpDictionaryFromMap(wrappers, uniqueNameMap);
       const instrumentedCode = wrapUserCodeForReturnCapture(code);
       const fullCode = `${generatedWrappers}
 
 ${mcpDictionary}
 
-${mcpPreamble}
 ${instrumentedCode}`;
       const sandboxConfig = {
         ...config.sandboxConfig,
@@ -1478,7 +1752,7 @@ function createMcpExecServer(pool, config = {}) {
   const tools = [
     listAvailableMcpServersTool,
     getMcpToolSchemaTool,
-    executeCodeWithWrappersTool
+    createExecuteCodeWithWrappersToolDefinition()
   ];
   const listToolsHandler = /* @__PURE__ */ __name(async () => ({ tools }), "listToolsHandler");
   const callToolRequestHandler = /* @__PURE__ */ __name(async (params) => {
@@ -1549,7 +1823,7 @@ __name(createMcpExecServer, "createMcpExecServer");
 // dist/index.js
 import { ServerPool, createConnection, getServerConfig as getServerConfig2, loadServerManifest as loadServerManifest2, cleanupOrphanedProcesses } from "@justanothermldude/meta-mcp-core";
 var APP_NAME = "mcp-exec";
-var VERSION2 = "1.3.6";
+var VERSION2 = "1.3.5";
 var defaultExecutor = null;
 function getDefaultExecutor() {
   if (!defaultExecutor) {
@@ -1651,6 +1925,7 @@ export {
   cleanupStaleProcess,
   createDefaultFilesystemConfig,
   createDefaultNetworkConfig,
+  createExecuteCodeWithWrappersToolDefinition,
   createExecuteWithWrappersHandler,
   createExecutor,
   createGetToolSchemaHandler,
@@ -1662,6 +1937,7 @@ export {
   executeCodeWithWrappersTool,
   generateFromManifest,
   generateMcpDictionary,
+  generateMcpDictionaryFromMap,
   generateServerModule,
   generateToolWrapper,
   getMcpToolSchemaTool,