@mcpc-tech/cli 0.1.16 → 0.1.19

package/bin/mcpc.mjs

@@ -56,686 +56,1114 @@ var ServerSentEventStream = class extends TransformStream {
 // __mcpc__cli_latest/node_modules/@mcpc/cli/src/controllers/sse.controller.js
 import { createRoute as createRoute2, z as z2 } from "@hono/zod-openapi";
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/compose.js
-import { CallToolRequestSchema, ListToolsRequestSchema, SetLevelRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+// __mcpc__cli_latest/node_modules/@mcpc/cli/src/controllers/streamable-http.controller.js
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/schema.js
-var schemaSymbol = Symbol.for("mcpc.schema");
-var vercelSchemaSymbol = Symbol.for("vercel.ai.schema");
-var validatorSymbol = Symbol.for("mcpc.validator");
-function jsonSchema(schema, options = {}) {
-  if (isWrappedSchema(schema)) {
-    return schema;
+// __mcpc__cli_latest/node_modules/@mcpc/cli/src/config/loader.js
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import process2 from "node:process";
+function extractServerName(command, commandArgs) {
+  for (const arg of commandArgs) {
+    if (!arg.startsWith("-")) {
+      const name2 = arg.replace(/[@.,/\\:;!?#$%^&*()[\]{}]/g, "_").substring(0, 64);
+      if (name2) return name2;
+    }
   }
-  return {
-    [schemaSymbol]: true,
-    [validatorSymbol]: true,
-    _type: void 0,
-    jsonSchema: schema,
-    validate: options.validate
-  };
-}
-function isWrappedSchema(value) {
-  return typeof value === "object" && value !== null && (schemaSymbol in value && value[schemaSymbol] === true || vercelSchemaSymbol in value && value[vercelSchemaSymbol] === true);
+  const name = command.replace(/[@.,/\\:;!?#$%^&*()[\]{}]/g, "_").substring(0, 64);
+  return name || "agentic-tool";
 }
-function extractJsonSchema(schema) {
-  if (isWrappedSchema(schema)) {
-    return schema.jsonSchema;
-  }
-  return schema;
+function getUserConfigDir() {
+  return join(homedir(), ".mcpc");
 }
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/compose.js
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/json.js
-import { jsonrepair } from "jsonrepair";
-function stripMarkdownAndText(text) {
-  text = text.trim();
-  text = text.replace(/^```(?:json)?\s*\n?/i, "");
-  text = text.replace(/\n?```\s*$/, "");
-  text = text.replace(/^(?:here is|here's|response|result|output|json):\s*/i, "");
-  const firstJsonIndex = text.search(/[\{\[]/);
-  if (firstJsonIndex >= 0) {
-    text = text.slice(firstJsonIndex);
-    let depth = 0;
-    let inString = false;
-    let escapeNext = false;
-    const startChar = text[0];
-    const endChar = startChar === "{" ? "}" : "]";
-    for (let i = 0; i < text.length; i++) {
-      const char = text[i];
-      if (escapeNext) {
-        escapeNext = false;
-        continue;
-      }
-      if (char === "\\") {
-        escapeNext = true;
-        continue;
-      }
-      if (char === '"' && !inString) {
-        inString = true;
-        continue;
-      }
-      if (char === '"' && inString) {
-        inString = false;
-        continue;
-      }
-      if (inString) continue;
-      if (char === startChar) {
-        depth++;
-      } else if (char === endChar) {
-        depth--;
-        if (depth === 0) {
-          return text.slice(0, i + 1);
-        }
-      }
-    }
-  }
-  return text.trim();
+function getUserConfigPath() {
+  return join(getUserConfigDir(), "config.json");
 }
-function parseJSON(text, throwError) {
+async function saveUserConfig(config2, newAgentName) {
+  const configPath = getUserConfigPath();
+  const configDir = dirname(configPath);
   try {
-    return JSON.parse(text);
-  } catch (_error) {
+    let existingConfig = null;
     try {
-      const cleanedText = stripMarkdownAndText(text);
-      try {
-        return JSON.parse(cleanedText);
-      } catch {
-        const repairedText = jsonrepair(cleanedText);
-        console.warn(`Failed to parse JSON, cleaned and repaired. Original: ${text.slice(0, 100)}...`);
-        return JSON.parse(repairedText);
-      }
-    } catch (_repairError) {
-      if (throwError) {
-        throw new Error(`Failed to parse JSON after cleanup and repair. Original error: ${_error instanceof Error ? _error.message : String(_error)}`);
+      const content = await readFile(configPath, "utf-8");
+      existingConfig = JSON.parse(content);
+    } catch {
+    }
+    if (existingConfig) {
+      const hasConflict = existingConfig.agents.some((agent) => agent.name === newAgentName);
+      if (hasConflict) {
+        console.error(`
+\u26A0 Agent "${newAgentName}" already exists in ${configPath}
+  Use --name to choose a different name, or delete the existing agent first.
+`);
+        return;
       }
-      return null;
+      existingConfig.agents.push(...config2.agents);
+      await writeFile(configPath, JSON.stringify(existingConfig, null, 2), "utf-8");
+      console.error(`
+\u2713 Added agent "${newAgentName}" (total: ${existingConfig.agents.length})
+  Config: ${configPath}
+  Run: mcpc
+`);
+      return;
     }
+    await mkdir(configDir, {
+      recursive: true
+    });
+    await writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+    console.error(`
+\u2713 Configuration saved to: ${configPath}
+  Run: mcpc
+`);
+  } catch (error) {
+    console.error(`Failed to save config to ${configPath}:`, error);
   }
 }
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/ai.js
-var p = (template, options = {}) => {
-  const { missingVariableHandling = "warn" } = options;
-  const names = /* @__PURE__ */ new Set();
-  const regex = /\{((\w|\.)+)\}/g;
-  let match;
-  while ((match = regex.exec(template)) !== null) {
-    names.add(match[1]);
+async function createWrapConfig(args) {
+  if (!args.mcpServers || args.mcpServers.length === 0) {
+    console.error("Error: --wrap/--add requires at least one MCP server\nExample: mcpc --wrap --mcp-stdio 'npx -y @wonderwhy-er/desktop-commander'\nMultiple: mcpc --add --mcp-stdio 'npx -y server1' --mcp-http 'https://api.example.com'");
+    process2.exit(1);
+  }
+  const mcpServers = {};
+  const serverNames = [];
+  const refs = [];
+  for (const spec of args.mcpServers) {
+    const serverName = extractServerName(spec.command, spec.args);
+    mcpServers[serverName] = {
+      command: spec.command,
+      args: spec.args,
+      transportType: spec.transportType
+    };
+    serverNames.push(serverName);
+    refs.push(`<tool name="${serverName}.__ALL__"/>`);
+    console.error(`Added MCP server: ${serverName}
+  Transport: ${spec.transportType}
+  Command: ${spec.command} ${spec.args.join(" ")}`);
   }
-  const required = Array.from(names);
-  return (input) => {
-    let result = template;
-    for (const name of required) {
-      const key = name;
-      const value = input[key];
-      const re = new RegExp(`\\{${String(name)}\\}`, "g");
-      if (value !== void 0 && value !== null) {
-        result = result.replace(re, String(value));
-      } else {
-        switch (missingVariableHandling) {
-          case "error":
-            throw new Error(`Missing variable "${String(name)}" in input for template.`);
-          case "empty":
-            result = result.replace(re, "");
-            break;
-          case "warn":
-          case "ignore":
-          default:
-            break;
+  const agentName = args.name || `${serverNames.join("__")}--orchestrator`;
+  const config2 = {
+    name: "mcpc-wrap-config",
+    version: "0.1.0",
+    capabilities: {
+      tools: {},
+      sampling: {}
+    },
+    agents: [
+      {
+        name: agentName,
+        description: `Orchestrate ${serverNames.length === 1 ? serverNames[0] : serverNames.join(", ")} MCP server tools`,
+        deps: {
+          mcpServers
+        },
+        options: {
+          mode: args.mode || "agentic",
+          refs
         }
       }
-    }
-    return result;
+    ]
   };
-};
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/tool-tags.js
-import { load } from "cheerio";
-function parseTags(htmlString, tags) {
-  const $ = load(htmlString, {
-    xml: {
-      decodeEntities: false
-    }
-  });
-  const tagToResults = {};
-  for (const tag of tags) {
-    const elements = $(tag);
-    tagToResults[tag] = elements.toArray();
+  const modeInfo = args.mode ? `
+Mode: ${args.mode}` : "";
+  console.error(`
+Created configuration for ${serverNames.length} MCP server(s)${modeInfo}`);
+  if (args.saveConfig) {
+    await saveUserConfig(config2, agentName);
   }
-  return {
-    tagToResults,
-    $
-  };
+  return config2;
 }
+function printHelp() {
+  console.log(`
+MCPC CLI - Model Context Protocol Composer
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+USAGE:
+    mcpc [OPTIONS]
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/registory.js
-function connectToSmitheryServer(smitheryConfig) {
-  const serverUrl = new URL(smitheryConfig.deploymentUrl);
-  serverUrl.searchParams.set("config", btoa(JSON.stringify(smitheryConfig.config)));
-  serverUrl.searchParams.set("api_key", smitheryConfig?.smitheryApiKey ?? smitheryConfig?.config?.smitheryApiKey);
-  return {
-    url: serverUrl.toString()
-  };
-}
-function smitheryToolNameCompatibale(name, scope) {
-  if (!name.startsWith("toolbox_")) {
-    return {
-      toolNameWithScope: `${scope}.${name}`,
-      toolName: name
-    };
-  }
-  const [, ...toolNames] = name.split("_");
-  const toolName = toolNames.join("_");
-  const toolNameWithScope = `${scope}.${toolName}`;
-  return {
-    toolNameWithScope,
-    toolName
-  };
-}
+OPTIONS:
+    --help, -h              Show this help message
+    --config <json>         Inline JSON configuration string
+    --config-url <url>      Fetch configuration from URL
+    --config-file <path>    Load configuration from file path
+    --request-headers <header>, -H <header>
+                           Add custom HTTP header for URL fetching
+                           Format: "Key: Value" or "Key=Value"
+                           Can be used multiple times
+    --mode <mode>           Set execution mode for all agents
+                           Supported modes:
+                           - agentic: Fully autonomous agent mode (default)
+                           - agentic_workflow: Agent workflow mode with dynamic or predefined steps
+                           - agentic_sampling: Autonomous sampling mode for agentic execution
+                           - agentic_workflow_sampling: Autonomous sampling mode for workflow execution
+                           - code_execution: Code execution mode for most efficient token usage
+    --add                   Add MCP servers to ~/.mcpc/config.json and exit
+                           Then run 'mcpc' to start the server with saved config
+                           Use --mcp-stdio, --mcp-http, or --mcp-sse to specify servers
+    --wrap                  Wrap and run MCP servers immediately without saving config
+                           Use --mcp-stdio, --mcp-http, or --mcp-sse to specify servers
+    --mcp-stdio <cmd>       Add an MCP server with stdio transport
+                           Example: --mcp-stdio "npx -y @wonderwhy-er/desktop-commander"
+    --mcp-http <url>        Add an MCP server with streamable-http transport
+                           Example: --mcp-http "https://api.github.com/mcp"
+    --mcp-sse <url>         Add an MCP server with SSE transport
+                           Example: --mcp-sse "https://api.example.com/sse"
+    --name <name>           Custom agent name for wrap mode (overrides auto-detection)
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/config.js
-import process2 from "node:process";
-var GEMINI_PREFERRED_FORMAT = process2.env.GEMINI_PREFERRED_FORMAT === "0" ? false : true;
+ENVIRONMENT VARIABLES:
+    MCPC_CONFIG            Inline JSON configuration (same as --config)
+    MCPC_CONFIG_URL        URL to fetch config from (same as --config-url)
+    MCPC_CONFIG_FILE       Path to config file (same as --config-file)
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/json.js
-import { jsonrepair as jsonrepair2 } from "jsonrepair";
+EXAMPLES:
+    # Show help
+    mcpc --help
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/provider.js
-function sanitizePropertyKey(name) {
-  return name.replace(/[@.,/\\:;!?#$%^&*()[\]{}]/g, "_").substring(0, 64);
-}
-var createGoogleCompatibleJSONSchema = (schema) => {
-  if (!GEMINI_PREFERRED_FORMAT) {
-    return schema;
-  }
-  const { oneOf: _oneOf, allOf: _allOf, anyOf: _anyOf, ...cleanSchema } = schema;
-  const removeAdditionalProperties = (obj) => {
-    if (Array.isArray(obj)) {
-      return obj.map(removeAdditionalProperties);
-    }
-    if (obj && typeof obj === "object") {
-      const result = {};
-      for (const [key, value] of Object.entries(obj)) {
-        if (key !== "additionalProperties") {
-          result[key] = removeAdditionalProperties(value);
-        }
-      }
-      return result;
-    }
-    return obj;
-  };
-  return removeAdditionalProperties(cleanSchema);
-};
+    # Add MCP servers to config and save to ~/.mcpc/config.json
+    mcpc --add --mcp-stdio "npx -y @wonderwhy-er/desktop-commander"
+    # Edit ~/.mcpc/config.json if needed (add headers, etc.)
+    mcpc  # Loads config from ~/.mcpc/config.json automatically
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
-import { cwd } from "node:process";
-import process3 from "node:process";
-import { createHash } from "node:crypto";
-var mcpClientPool = /* @__PURE__ */ new Map();
-var mcpClientConnecting = /* @__PURE__ */ new Map();
-var shortHash = (s) => createHash("sha256").update(s).digest("hex").slice(0, 8);
-function defSignature(def) {
-  const defCopy = {
-    ...def
-  };
-  if (defCopy.transportType === "memory" || defCopy.transport) {
-    return `memory:${Date.now()}:${Math.random()}`;
-  }
-  return JSON.stringify(defCopy);
+    # Wrap and run immediately (one-time use, no config saved)
+    mcpc --wrap --mcp-stdio "npx -y @wonderwhy-er/desktop-commander"
+
+    # Multiple servers with different transports
+    mcpc --add       --mcp-stdio "npx -y @wonderwhy-er/desktop-commander"       --mcp-http "https://api.github.com/mcp"       --mcp-sse "https://api.example.com/sse"
+
+    # Custom agent name
+    mcpc --add --name my-agent --mcp-stdio "npx shadcn@latest mcp"
+    mcpc --wrap --name my-agent --mcp-stdio "npx shadcn@latest mcp"
+
+    # Load from URL
+    mcpc --config-url \\
+      "https://raw.githubusercontent.com/mcpc-tech/mcpc/main/packages/cli/examples/configs/codex-fork.json"
+
+    # Load from URL with custom headers
+    mcpc \\
+      --config-url "https://api.example.com/config.json" \\
+      -H "Authorization: Bearer token123" \\
+      -H "X-Custom-Header: value"
+
+    # Load from file
+    mcpc --config-file ./my-config.json
+
+    # Override execution mode for all agents
+    mcpc --config-file ./my-config.json --mode agentic_workflow
+
+    # Using environment variable
+    export MCPC_CONFIG='[{"name":"agent","description":"..."}]'
+    mcpc
+
+    # Use default configuration (./mcpc.config.json)
+    mcpc
+
+CONFIGURATION:
+    Configuration files support environment variable substitution using $VAR_NAME syntax.
+    
+    Priority order:
+    1. --config (inline JSON)
+    2. MCPC_CONFIG environment variable
+    3. --config-url or MCPC_CONFIG_URL
+    4. --config-file or MCPC_CONFIG_FILE
+    5. ./mcpc.config.json (default)
+
+For more information, visit: https://github.com/mcpc-tech/mcpc
+`);
 }
-function createTransport(def) {
-  const defAny = def;
-  const explicitType = defAny.transportType || defAny.type;
-  if (explicitType === "memory") {
-    if (!defAny.server) {
-      throw new Error("In-memory transport requires a 'server' field with a Server instance");
-    }
-    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-    defAny.server.connect(serverTransport).catch((err) => {
-      console.error("Error connecting in-memory server:", err);
-    });
-    return clientTransport;
-  }
-  if (explicitType === "sse") {
-    const options = {};
-    if (defAny.headers) {
-      options.requestInit = {
-        headers: defAny.headers
-      };
-      options.eventSourceInit = {
-        headers: defAny.headers
-      };
-    }
-    return new SSEClientTransport(new URL(defAny.url), options);
-  }
-  if (defAny.url && typeof defAny.url === "string") {
-    const options = {};
-    if (defAny.headers) {
-      options.requestInit = {
-        headers: defAny.headers
-      };
+function parseArgs() {
+  const args = process2.argv.slice(2);
+  const result = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--config" && i + 1 < args.length) {
+      result.config = args[++i];
+    } else if (arg === "--config-url" && i + 1 < args.length) {
+      result.configUrl = args[++i];
+    } else if (arg === "--config-file" && i + 1 < args.length) {
+      result.configFile = args[++i];
+    } else if ((arg === "--request-headers" || arg === "-H") && i + 1 < args.length) {
+      const headerStr = args[++i];
+      const colonIdx = headerStr.indexOf(":");
+      const equalIdx = headerStr.indexOf("=");
+      const separatorIdx = colonIdx !== -1 ? equalIdx !== -1 ? Math.min(colonIdx, equalIdx) : colonIdx : equalIdx;
+      if (separatorIdx !== -1) {
+        const key = headerStr.substring(0, separatorIdx).trim();
+        const value = headerStr.substring(separatorIdx + 1).trim();
+        if (!result.requestHeaders) {
+          result.requestHeaders = {};
+        }
+        result.requestHeaders[key] = value;
+      }
+    } else if (arg === "--help" || arg === "-h") {
+      result.help = true;
+    } else if (arg === "--add") {
+      result.add = true;
+    } else if (arg === "--wrap") {
+      result.wrap = true;
+    } else if ((arg === "--mcp-stdio" || arg === "--mcp-http" || arg === "--mcp-sse") && i + 1 < args.length) {
+      const cmdString = args[++i];
+      const cmdParts = cmdString.split(/\s+/);
+      const command = cmdParts[0];
+      const cmdArgs = cmdParts.slice(1);
+      let transportType;
+      if (arg === "--mcp-stdio") {
+        transportType = "stdio";
+      } else if (arg === "--mcp-http") {
+        transportType = "streamable-http";
+      } else {
+        transportType = "sse";
+      }
+      if (!result.mcpServers) {
+        result.mcpServers = [];
+      }
+      result.mcpServers.push({
+        command,
+        args: cmdArgs,
+        transportType
+      });
+    } else if (arg === "--mode" && i + 1 < args.length) {
+      result.mode = args[++i];
+    } else if (arg === "--name" && i + 1 < args.length) {
+      result.name = args[++i];
     }
-    return new StreamableHTTPClientTransport(new URL(defAny.url), options);
-  }
-  if (explicitType === "stdio" || defAny.command) {
-    return new StdioClientTransport({
-      command: defAny.command,
-      args: defAny.args,
-      env: {
-        ...process3.env,
-        ...defAny.env ?? {}
-      },
-      cwd: cwd()
-    });
   }
-  throw new Error(`Unsupported transport configuration: ${JSON.stringify(def)}`);
+  return result;
 }
-async function getOrCreateMcpClient(defKey, def) {
-  const pooled = mcpClientPool.get(defKey);
-  if (pooled) {
-    pooled.refCount += 1;
-    return pooled.client;
-  }
-  const existingConnecting = mcpClientConnecting.get(defKey);
-  if (existingConnecting) {
-    const client = await existingConnecting;
-    const entry = mcpClientPool.get(defKey);
-    if (entry) entry.refCount += 1;
-    return client;
+async function loadConfig() {
+  const args = parseArgs();
+  if (args.help) {
+    printHelp();
+    process2.exit(0);
   }
-  const transport2 = createTransport(def);
-  const connecting = (async () => {
-    const client = new Client({
-      name: `mcp_${shortHash(defSignature(def))}`,
-      version: "1.0.0"
-    });
-    await client.connect(transport2, {
-      timeout: 6e4 * 10
+  if (args.add) {
+    await createWrapConfig({
+      ...args,
+      saveConfig: true
     });
-    return client;
-  })();
-  mcpClientConnecting.set(defKey, connecting);
-  try {
-    const client = await connecting;
-    mcpClientPool.set(defKey, {
-      client,
-      refCount: 1
+    process2.exit(0);
+  }
+  if (args.wrap) {
+    return await createWrapConfig({
+      ...args,
+      saveConfig: false
     });
-    return client;
-  } finally {
-    mcpClientConnecting.delete(defKey);
   }
-}
-async function releaseMcpClient(defKey) {
-  const entry = mcpClientPool.get(defKey);
-  if (!entry) return;
-  entry.refCount -= 1;
-  if (entry.refCount <= 0) {
-    mcpClientPool.delete(defKey);
+  if (args.config) {
     try {
-      await entry.client.close();
-    } catch (err) {
-      console.error("Error closing MCP client:", err);
+      const parsed = JSON.parse(args.config);
+      return applyModeOverride(normalizeConfig(parsed), args.mode);
+    } catch (error) {
+      console.error("Failed to parse --config argument:", error);
+      throw error;
     }
   }
-}
-var cleanupAllPooledClients = async () => {
-  const entries = Array.from(mcpClientPool.entries());
-  mcpClientPool.clear();
-  await Promise.all(entries.map(async ([, { client }]) => {
+  if (process2.env.MCPC_CONFIG) {
     try {
-      await client.close();
-    } catch (err) {
-      console.error("Error closing MCP client:", err);
+      const parsed = JSON.parse(process2.env.MCPC_CONFIG);
+      return applyModeOverride(normalizeConfig(parsed), args.mode);
+    } catch (error) {
+      console.error("Failed to parse MCPC_CONFIG environment variable:", error);
+      throw error;
     }
-  }));
-};
-process3.once?.("exit", () => {
-  cleanupAllPooledClients();
-});
-process3.once?.("SIGINT", () => {
-  cleanupAllPooledClients().finally(() => process3.exit(0));
-});
-async function composeMcpDepTools(mcpConfig, filterIn) {
-  const allTools = {};
-  const allClients = {};
-  const acquiredKeys = [];
-  for (const [name, definition] of Object.entries(mcpConfig.mcpServers)) {
-    const def = definition;
-    if (def.disabled) continue;
-    const defKey = shortHash(defSignature(def));
-    const serverId = name;
+  }
+  const configUrl = args.configUrl || process2.env.MCPC_CONFIG_URL;
+  if (configUrl) {
     try {
-      const client = await getOrCreateMcpClient(defKey, def);
-      acquiredKeys.push(defKey);
-      allClients[serverId] = client;
-      const { tools } = await client.listTools();
-      tools.forEach((tool) => {
-        const { toolNameWithScope, toolName: internalToolName } = smitheryToolNameCompatibale(tool.name, name);
-        const rawToolId = `${serverId}_${internalToolName}`;
-        const toolId = sanitizePropertyKey(rawToolId);
-        if (filterIn && !filterIn({
-          action: internalToolName,
-          tool,
-          mcpName: name,
-          toolNameWithScope,
-          internalToolName,
-          toolId
-        })) {
-          return;
-        }
-        const execute = (args) => allClients[serverId].callTool({
-          name: internalToolName,
-          arguments: args
-        }, void 0, {
-          timeout: def.toolCallTimeout
-        });
-        allTools[toolId] = {
-          ...tool,
-          execute,
-          _originalName: toolNameWithScope
-        };
+      const headers = {
+        "User-Agent": "MCPC-CLI/0.1.0",
+        ...args.requestHeaders
+      };
+      const response = await fetch(configUrl, {
+        headers
       });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const content = await response.text();
+      const parsed = JSON.parse(content);
+      return applyModeOverride(normalizeConfig(parsed), args.mode);
     } catch (error) {
-      console.error(`Error creating MCP client for ${name}:`, error);
+      console.error(`Failed to fetch config from ${configUrl}:`, error);
+      throw error;
     }
   }
-  const cleanupClients = async () => {
-    await Promise.all(acquiredKeys.map((k) => releaseMcpClient(k)));
-    acquiredKeys.length = 0;
-    Object.keys(allTools).forEach((key) => delete allTools[key]);
-    Object.keys(allClients).forEach((key) => delete allClients[key]);
-  };
-  return {
-    tools: allTools,
-    clients: allClients,
-    cleanupClients
-  };
-}
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/tool-tag-processor.js
-var ALL_TOOLS_PLACEHOLDER = "__ALL__";
-function findToolId(toolName, tools, toolNameMapping) {
-  const mappedId = toolNameMapping?.get(toolName);
-  if (mappedId) {
-    return mappedId;
-  }
-  return Object.keys(tools).find((id) => {
-    const dotNotation = id.replace(/_/g, ".");
-    return toolName === id || toolName === dotNotation;
-  });
-}
-function processToolTags({ description, tagToResults, $, tools, toolOverrides, toolNameMapping }) {
-  tagToResults.tool.forEach((toolEl) => {
-    const toolName = toolEl.attribs.name;
-    if (!toolName || toolName.includes(ALL_TOOLS_PLACEHOLDER)) {
-      $(toolEl).remove();
-      return;
-    }
-    const override = toolOverrides.get(toolName);
-    if (override?.visibility?.hidden) {
-      $(toolEl).remove();
-    } else if (override?.visibility?.public) {
-      $(toolEl).replaceWith(`<tool name="${toolName}"/>`);
-    } else {
-      const toolId = findToolId(toolName, tools, toolNameMapping);
-      if (toolId) {
-        $(toolEl).replaceWith(`<tool name="${toolId}"/>`);
+  const configFile = args.configFile || process2.env.MCPC_CONFIG_FILE;
+  if (configFile) {
+    try {
+      const content = await readFile(configFile, "utf-8");
+      const parsed = JSON.parse(content);
+      return applyModeOverride(normalizeConfig(parsed), args.mode);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        console.error(`Config file not found: ${configFile}`);
+        throw error;
       } else {
-        $(toolEl).remove();
+        console.error(`Failed to load config from ${configFile}:`, error);
+        throw error;
       }
     }
-  });
-  return $.root().html() ?? description;
-}
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/config-plugin.js
-var createConfigPlugin = () => ({
-  name: "built-in-config",
-  version: "1.0.0",
-  enforce: "pre",
-  transformTool: (tool, context2) => {
-    const server2 = context2.server;
-    const config2 = server2.findToolConfig?.(context2.toolName);
-    if (config2?.description) {
-      tool.description = config2.description;
-    }
-    return tool;
   }
-});
-var config_plugin_default = createConfigPlugin();
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/tool-name-mapping-plugin.js
-var createToolNameMappingPlugin = () => ({
-  name: "built-in-tool-name-mapping",
-  version: "1.0.0",
-  enforce: "pre",
-  transformTool: (tool, context2) => {
-    const server2 = context2.server;
-    const toolName = context2.toolName;
-    const originalName = tool._originalName || toolName;
-    const dotNotation = originalName.replace(/_/g, ".");
-    const underscoreNotation = originalName.replace(/\./g, "_");
-    if (dotNotation !== originalName && server2.toolNameMapping) {
-      server2.toolNameMapping.set(dotNotation, toolName);
-    }
-    if (underscoreNotation !== originalName && server2.toolNameMapping) {
-      server2.toolNameMapping.set(underscoreNotation, toolName);
-    }
-    if (originalName !== toolName && server2.toolNameMapping) {
-      server2.toolNameMapping.set(originalName, toolName);
+  const userConfigPath = getUserConfigPath();
+  try {
+    const content = await readFile(userConfigPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return applyModeOverride(normalizeConfig(parsed), args.mode);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      console.error(`Failed to load config from ${userConfigPath}:`, error);
+      throw error;
     }
-    return tool;
-  }
-});
-var tool_name_mapping_plugin_default = createToolNameMappingPlugin();
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/logger.js
-var LOG_LEVELS = {
-  debug: 0,
-  info: 1,
-  notice: 2,
-  warning: 3,
-  error: 4,
-  critical: 5,
-  alert: 6,
-  emergency: 7
-};
-var MCPLogger = class _MCPLogger {
-  server;
-  loggerName;
-  minLevel = "debug";
-  constructor(loggerName = "mcpc", server2) {
-    this.loggerName = loggerName;
-    this.server = server2;
-  }
-  setServer(server2) {
-    this.server = server2;
-  }
-  setLevel(level) {
-    this.minLevel = level;
   }
-  async log(level, data) {
-    if (LOG_LEVELS[level] < LOG_LEVELS[this.minLevel]) {
-      return;
-    }
-    this.logToConsole(level, data);
-    if (this.server) {
-      try {
-        await this.server.sendLoggingMessage({
-          level,
-          logger: this.loggerName,
-          data
-        });
-      } catch {
-      }
+  const defaultConfigPath = resolve(process2.cwd(), "mcpc.config.json");
+  try {
+    const content = await readFile(defaultConfigPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return applyModeOverride(normalizeConfig(parsed), args.mode);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    } else {
+      console.error(`Failed to load config from ${defaultConfigPath}:`, error);
+      throw error;
     }
   }
-  logToConsole(level, data) {
-    const message = typeof data === "string" ? data : JSON.stringify(data);
-    const prefix = `[${this.loggerName}:${level}]`;
-    console.error(prefix, message);
-  }
-  debug(data) {
-    return this.log("debug", data);
-  }
-  info(data) {
-    return this.log("info", data);
-  }
-  notice(data) {
-    return this.log("notice", data);
-  }
-  warning(data) {
-    return this.log("warning", data);
-  }
-  error(data) {
-    return this.log("error", data);
+}
+function replaceEnvVars(str) {
+  return str.replace(/\$([A-Z_][A-Z0-9_]*)/g, (_match, varName) => {
+    return process2.env[varName] || "";
+  });
+}
+function replaceEnvVarsInConfig(obj) {
+  if (typeof obj === "string") {
+    return replaceEnvVars(obj);
   }
-  critical(data) {
-    return this.log("critical", data);
+  if (Array.isArray(obj)) {
+    return obj.map((item) => replaceEnvVarsInConfig(item));
   }
-  alert(data) {
-    return this.log("alert", data);
+  if (obj && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = replaceEnvVarsInConfig(value);
+    }
+    return result;
   }
-  emergency(data) {
-    return this.log("emergency", data);
+  return obj;
+}
+function applyModeOverride(config2, mode) {
+  if (!mode) return config2;
+  config2.agents.forEach((agent) => {
+    if (!agent.options) agent.options = {};
+    agent.options.mode = mode;
+  });
+  return config2;
+}
+function normalizeConfig(config2) {
+  config2 = replaceEnvVarsInConfig(config2);
+  if (Array.isArray(config2)) {
+    return {
+      name: "mcpc-server",
+      version: "0.1.0",
+      agents: normalizeAgents(config2)
+    };
   }
-  child(name) {
-    const child = new _MCPLogger(`${this.loggerName}.${name}`, this.server);
-    child.setLevel(this.minLevel);
-    return child;
+  if (config2 && typeof config2 === "object") {
+    const cfg = config2;
+    return {
+      name: cfg.name || "mcpc-server",
+      version: cfg.version || "0.1.0",
+      capabilities: cfg.capabilities,
+      agents: normalizeAgents(cfg.agents || [])
+    };
   }
-};
-var logger = new MCPLogger("mcpc");
-function createLogger(name, server2) {
-  return new MCPLogger(name, server2);
+  throw new Error("Invalid configuration format");
+}
+function normalizeAgents(agents) {
+  return agents.map((agent) => {
+    if (agent.deps && !agent.deps.mcpServers) {
+      agent.deps.mcpServers = {};
+    }
+    return agent;
+  });
 }
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/logging-plugin.js
-var createLoggingPlugin = (options = {}) => {
-  const { enabled = true, verbose = false, compact: compact2 = true } = options;
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/compose.js
+import { CallToolRequestSchema, ListToolsRequestSchema, SetLevelRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/schema.js
+var schemaSymbol = Symbol.for("mcpc.schema");
+var vercelSchemaSymbol = Symbol.for("vercel.ai.schema");
+var validatorSymbol = Symbol.for("mcpc.validator");
+function jsonSchema(schema, options = {}) {
+  if (isWrappedSchema(schema)) {
+    return schema;
+  }
   return {
-    name: "built-in-logging",
-    version: "1.0.0",
-    composeEnd: async (context2) => {
-      if (!enabled) return;
-      const logger2 = createLogger("mcpc.plugin.logging", context2.server);
-      if (compact2) {
-        const pluginCount = context2.pluginNames.length;
-        const { stats } = context2;
-        await logger2.info(`[${context2.toolName}] ${pluginCount} plugins \u2022 ${stats.publicTools} public \u2022 ${stats.hiddenTools} hidden`);
-      } else if (verbose) {
-        await logger2.info(`[${context2.toolName}] Composition complete`);
-        await logger2.info(`   \u251C\u2500 Plugins: ${context2.pluginNames.join(", ")}`);
-        const { stats } = context2;
-        const server2 = context2.server;
-        const publicTools = Array.from(new Set(server2.getPublicToolNames().map(String)));
-        const internalTools = Array.from(new Set(server2.getInternalToolNames().map(String)));
-        const hiddenTools = Array.from(new Set(server2.getHiddenToolNames().map(String)));
-        const normalInternal = internalTools.filter((name) => !hiddenTools.includes(name));
-        if (publicTools.length > 0) {
-          await logger2.info(`   \u251C\u2500 Public: ${publicTools.join(", ")}`);
+    [schemaSymbol]: true,
+    [validatorSymbol]: true,
+    _type: void 0,
+    jsonSchema: schema,
+    validate: options.validate
+  };
+}
+function isWrappedSchema(value) {
+  return typeof value === "object" && value !== null && (schemaSymbol in value && value[schemaSymbol] === true || vercelSchemaSymbol in value && value[vercelSchemaSymbol] === true);
+}
+function extractJsonSchema(schema) {
+  if (isWrappedSchema(schema)) {
+    return schema.jsonSchema;
+  }
+  return schema;
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/compose.js
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/json.js
+import { jsonrepair } from "jsonrepair";
+function stripMarkdownAndText(text) {
+  text = text.trim();
+  text = text.replace(/^```(?:json)?\s*\n?/i, "");
+  text = text.replace(/\n?```\s*$/, "");
+  text = text.replace(/^(?:here is|here's|response|result|output|json):\s*/i, "");
+  const firstJsonIndex = text.search(/[\{\[]/);
+  if (firstJsonIndex >= 0) {
+    text = text.slice(firstJsonIndex);
+    let depth = 0;
+    let inString = false;
+    let escapeNext = false;
+    const startChar = text[0];
+    const endChar = startChar === "{" ? "}" : "]";
+    for (let i = 0; i < text.length; i++) {
+      const char = text[i];
+      if (escapeNext) {
+        escapeNext = false;
+        continue;
+      }
+      if (char === "\\") {
+        escapeNext = true;
+        continue;
+      }
+      if (char === '"' && !inString) {
+        inString = true;
+        continue;
+      }
+      if (char === '"' && inString) {
+        inString = false;
+        continue;
+      }
+      if (inString) continue;
+      if (char === startChar) {
+        depth++;
+      } else if (char === endChar) {
+        depth--;
+        if (depth === 0) {
+          return text.slice(0, i + 1);
         }
-        if (internalTools.length > 0) {
-          const parts = [];
-          if (normalInternal.length > 0) {
-            parts.push(normalInternal.join(", "));
-          }
-          if (hiddenTools.length > 0) {
-            parts.push(`(${hiddenTools.join(", ")})`);
-          }
-          await logger2.info(`   \u251C\u2500 Internal: ${parts.join(", ")}`);
+      }
+    }
+  }
+  return text.trim();
+}
+function parseJSON(text, throwError) {
+  try {
+    return JSON.parse(text);
+  } catch (_error) {
+    try {
+      const cleanedText = stripMarkdownAndText(text);
+      try {
+        return JSON.parse(cleanedText);
+      } catch {
+        const repairedText = jsonrepair(cleanedText);
+        console.warn(`Failed to parse JSON, cleaned and repaired. Original: ${text.slice(0, 100)}...`);
+        return JSON.parse(repairedText);
+      }
+    } catch (_repairError) {
+      if (throwError) {
+        throw new Error(`Failed to parse JSON after cleanup and repair. Original error: ${_error instanceof Error ? _error.message : String(_error)}`);
+      }
+      return null;
+    }
+  }
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/ai.js
+var p = (template, options = {}) => {
+  const { missingVariableHandling = "warn" } = options;
+  const names = /* @__PURE__ */ new Set();
+  const regex = /\{((\w|\.)+)\}/g;
+  let match;
+  while ((match = regex.exec(template)) !== null) {
+    names.add(match[1]);
+  }
+  const required = Array.from(names);
+  return (input) => {
+    let result = template;
+    for (const name of required) {
+      const key = name;
+      const value = input[key];
+      const re = new RegExp(`\\{${String(name)}\\}`, "g");
+      if (value !== void 0 && value !== null) {
+        result = result.replace(re, String(value));
+      } else {
+        switch (missingVariableHandling) {
+          case "error":
+            throw new Error(`Missing variable "${String(name)}" in input for template.`);
+          case "empty":
+            result = result.replace(re, "");
+            break;
+          case "warn":
+          case "ignore":
+          default:
+            break;
         }
-        await logger2.info(`   \u2514\u2500 Total: ${stats.totalTools} tools`);
       }
     }
+    return result;
   };
 };
-var logging_plugin_default = createLoggingPlugin({
-  verbose: true,
-  compact: false
-});
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/prompts/index.js
-var SystemPrompts = {
-  /**
-   * Base system prompt for autonomous MCP execution
-   */
-  AUTONOMOUS_EXECUTION: `Agentic tool \`{toolName}\` that executes complex tasks by iteratively selecting and calling tools, gathering results, and continuing until completion. Use this tool when the task matches the manual below.
-
-You must follow the <manual/>, obey the <execution_rules/>, and use the <call_format/>.
-
-<manual>
-{description}
-</manual>
 
-<parameters>
-\`useTool\` - Which tool to execute this iteration
-\`hasDefinitions\` - Tool names whose schemas you already have
-\`definitionsOf\` - Tool names whose schemas you need
-</parameters>
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/tool-tags.js
+import { load } from "cheerio";
+function parseTags(htmlString, tags) {
+  const $ = load(htmlString, {
+    xml: {
+      decodeEntities: false
+    }
+  });
+  const tagToResults = {};
+  for (const tag of tags) {
+    const elements = $(tag);
+    tagToResults[tag] = elements.toArray();
+  }
+  return {
+    tagToResults,
+    $
+  };
+}
 
-<execution_rules>
-1. **First call**: No tool definitions available\u2014you must request them via \`definitionsOf\`
-2. **When executing tools**: Must provide \`hasDefinitions\` with ALL tools you have schemas for (avoid duplicate requests and reduce tokens)
-3. **When requesting definitions**: Use \`definitionsOf\` to request tool schemas you need
-4. **Both together**: Execute tool AND request new definitions in one call for efficiency
-5. **Never request definitions you already have**
-6. **Select** one tool to execute per call using \`useTool\`
-7. **Provide** parameters matching the selected tool name
-8. Note: You are an agent exposed as an MCP tool - **\`useTool\` is an internal parameter for choosing which tool to execute, NOT an external MCP tool you can call**
-</execution_rules>
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 
-<call_format>
-Initial definition request:
-\`\`\`json
-{
-  "hasDefinitions": [],
-  "definitionsOf": ["tool1", "tool2"]
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/registory.js
+function connectToSmitheryServer(smitheryConfig) {
+  const serverUrl = new URL(smitheryConfig.deploymentUrl);
+  serverUrl.searchParams.set("config", btoa(JSON.stringify(smitheryConfig.config)));
+  serverUrl.searchParams.set("api_key", smitheryConfig?.smitheryApiKey ?? smitheryConfig?.config?.smitheryApiKey);
+  return {
+    url: serverUrl.toString()
+  };
 }
-\`\`\`
-
-Execute tool + get new definitions:
-\`\`\`json
-{
-  "useTool": "tool1",
-  "tool1": { /* parameters */ },
-  "hasDefinitions": ["tool1", "tool2"],
-  "definitionsOf": ["tool3"]
+function smitheryToolNameCompatibale(name, scope) {
+  if (!name.startsWith("toolbox_")) {
+    return {
+      toolNameWithScope: `${scope}.${name}`,
+      toolName: name
+    };
+  }
+  const [, ...toolNames] = name.split("_");
+  const toolName = toolNames.join("_");
+  const toolNameWithScope = `${scope}.${toolName}`;
+  return {
+    toolNameWithScope,
+    toolName
+  };
 }
-\`\`\`
-</call_format>`,
-  /**
-   * Workflow execution system prompt
-   */
-  WORKFLOW_EXECUTION: `Workflow tool \`{toolName}\` that executes multi-step workflows. Use this when your task requires sequential steps.
 
-<manual>
-{description}
-</manual>
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/config.js
+import process3 from "node:process";
+var GEMINI_PREFERRED_FORMAT = process3.env.GEMINI_PREFERRED_FORMAT === "0" ? false : true;
 
-<rules>
-1. First call: {planningInstructions}
-2. Subsequent calls: Provide only current step parameters
-3. Use \`decision: "proceed"\` to advance, \`"retry"\` to retry, \`"complete"\` when done
-4. Include \`steps\` ONLY with \`init: true\`, never during execution
-</rules>`,
-  /**
-   * JSON-only execution system prompt for autonomous sampling mode
-   *
-   * Note: Sampling mode runs an internal LLM loop that autonomously calls tools until complete.
-   */
-  SAMPLING_EXECUTION: `Agent \`{toolName}\` that completes tasks by calling tools in an autonomous loop.
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/json.js
+import { jsonrepair as jsonrepair2 } from "jsonrepair";
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/provider.js
+function sanitizePropertyKey(name) {
+  return name.replace(/[@.,/\\:;!?#$%^&*()[\]{}]/g, "_").substring(0, 64);
+}
+var createGoogleCompatibleJSONSchema = (schema) => {
+  if (!GEMINI_PREFERRED_FORMAT) {
+    return schema;
+  }
+  const { oneOf: _oneOf, allOf: _allOf, anyOf: _anyOf, ...cleanSchema } = schema;
+  const removeAdditionalProperties = (obj) => {
+    if (Array.isArray(obj)) {
+      return obj.map(removeAdditionalProperties);
+    }
+    if (obj && typeof obj === "object") {
+      const result = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (key !== "additionalProperties") {
+          result[key] = removeAdditionalProperties(value);
+        }
+      }
+      return result;
+    }
+    return obj;
+  };
+  return removeAdditionalProperties(cleanSchema);
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
+import { cwd } from "node:process";
+import process4 from "node:process";
+import { createHash } from "node:crypto";
+var mcpClientPool = /* @__PURE__ */ new Map();
+var mcpClientConnecting = /* @__PURE__ */ new Map();
+var shortHash = (s) => createHash("sha256").update(s).digest("hex").slice(0, 8);
+function defSignature(def) {
+  const defCopy = {
+    ...def
+  };
+  if (defCopy.transportType === "memory" || defCopy.transport) {
+    return `memory:${Date.now()}:${Math.random()}`;
+  }
+  return JSON.stringify(defCopy);
+}
+function createTransport(def) {
+  const defAny = def;
+  const explicitType = defAny.transportType || defAny.type;
+  if (explicitType === "memory") {
+    if (!defAny.server) {
+      throw new Error("In-memory transport requires a 'server' field with a Server instance");
+    }
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    defAny.server.connect(serverTransport).catch((err) => {
+      console.error("Error connecting in-memory server:", err);
+    });
+    return clientTransport;
+  }
+  if (explicitType === "sse") {
+    const options = {};
+    if (defAny.headers) {
+      options.requestInit = {
+        headers: defAny.headers
+      };
+      options.eventSourceInit = {
+        headers: defAny.headers
+      };
+    }
+    return new SSEClientTransport(new URL(defAny.url), options);
+  }
+  if (defAny.url && typeof defAny.url === "string") {
+    const options = {};
+    if (defAny.headers) {
+      options.requestInit = {
+        headers: defAny.headers
+      };
+    }
+    return new StreamableHTTPClientTransport(new URL(defAny.url), options);
+  }
+  if (explicitType === "stdio" || defAny.command) {
+    return new StdioClientTransport({
+      command: defAny.command,
+      args: defAny.args,
+      env: {
+        ...process4.env,
+        ...defAny.env ?? {}
+      },
+      cwd: cwd()
+    });
+  }
+  throw new Error(`Unsupported transport configuration: ${JSON.stringify(def)}`);
+}
+async function getOrCreateMcpClient(defKey, def) {
+  const pooled = mcpClientPool.get(defKey);
+  if (pooled) {
+    pooled.refCount += 1;
+    return pooled.client;
+  }
+  const existingConnecting = mcpClientConnecting.get(defKey);
+  if (existingConnecting) {
+    const client = await existingConnecting;
+    const entry = mcpClientPool.get(defKey);
+    if (entry) entry.refCount += 1;
+    return client;
+  }
+  const transport2 = createTransport(def);
+  const connecting = (async () => {
+    const client = new Client({
+      name: `mcp_${shortHash(defSignature(def))}`,
+      version: "1.0.0"
+    });
+    await client.connect(transport2, {
+      timeout: 6e4 * 10
+    });
+    return client;
+  })();
+  mcpClientConnecting.set(defKey, connecting);
+  try {
+    const client = await connecting;
+    mcpClientPool.set(defKey, {
+      client,
+      refCount: 1
+    });
+    return client;
+  } finally {
+    mcpClientConnecting.delete(defKey);
+  }
+}
+async function releaseMcpClient(defKey) {
+  const entry = mcpClientPool.get(defKey);
+  if (!entry) return;
+  entry.refCount -= 1;
+  if (entry.refCount <= 0) {
+    mcpClientPool.delete(defKey);
+    try {
+      await entry.client.close();
+    } catch (err) {
+      console.error("Error closing MCP client:", err);
+    }
+  }
+}
+var cleanupAllPooledClients = async () => {
+  const entries = Array.from(mcpClientPool.entries());
+  mcpClientPool.clear();
+  await Promise.all(entries.map(async ([, { client }]) => {
+    try {
+      await client.close();
+    } catch (err) {
+      console.error("Error closing MCP client:", err);
+    }
+  }));
+};
+process4.once?.("exit", () => {
+  cleanupAllPooledClients();
+});
+process4.once?.("SIGINT", () => {
+  cleanupAllPooledClients().finally(() => process4.exit(0));
+});
+async function composeMcpDepTools(mcpConfig, filterIn) {
+  const allTools = {};
+  const allClients = {};
+  const acquiredKeys = [];
+  for (const [name, definition] of Object.entries(mcpConfig.mcpServers)) {
+    const def = definition;
+    if (def.disabled) continue;
+    const defKey = shortHash(defSignature(def));
+    const serverId = name;
+    try {
+      const client = await getOrCreateMcpClient(defKey, def);
+      acquiredKeys.push(defKey);
+      allClients[serverId] = client;
+      const { tools } = await client.listTools();
+      tools.forEach((tool) => {
+        const { toolNameWithScope, toolName: internalToolName } = smitheryToolNameCompatibale(tool.name, name);
+        const rawToolId = `${serverId}_${internalToolName}`;
+        const toolId = sanitizePropertyKey(rawToolId);
+        if (filterIn && !filterIn({
+          action: internalToolName,
+          tool,
+          mcpName: name,
+          toolNameWithScope,
+          internalToolName,
+          toolId
+        })) {
+          return;
+        }
+        const execute = (args) => allClients[serverId].callTool({
+          name: internalToolName,
+          arguments: args
+        }, void 0, {
+          timeout: def.toolCallTimeout
+        });
+        allTools[toolId] = {
+          ...tool,
+          execute,
+          _originalName: toolNameWithScope
+        };
+      });
+    } catch (error) {
+      console.error(`Error creating MCP client for ${name}:`, error);
+    }
+  }
+  const cleanupClients = async () => {
+    await Promise.all(acquiredKeys.map((k) => releaseMcpClient(k)));
+    acquiredKeys.length = 0;
+    Object.keys(allTools).forEach((key) => delete allTools[key]);
+    Object.keys(allClients).forEach((key) => delete allClients[key]);
+  };
+  return {
+    tools: allTools,
+    clients: allClients,
+    cleanupClients
+  };
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/tool-tag-processor.js
+var ALL_TOOLS_PLACEHOLDER = "__ALL__";
+function findToolId(toolName, tools, toolNameMapping) {
+  const mappedId = toolNameMapping?.get(toolName);
+  if (mappedId) {
+    return mappedId;
+  }
+  return Object.keys(tools).find((id) => {
+    const dotNotation = id.replace(/_/g, ".");
+    return toolName === id || toolName === dotNotation;
+  });
+}
+function processToolTags({ description, tagToResults, $, tools, toolOverrides, toolNameMapping }) {
+  tagToResults.tool.forEach((toolEl) => {
+    const toolName = toolEl.attribs.name;
+    if (!toolName || toolName.includes(ALL_TOOLS_PLACEHOLDER)) {
+      $(toolEl).remove();
+      return;
+    }
+    const override = toolOverrides.get(toolName);
+    if (override?.visibility?.hidden) {
+      $(toolEl).remove();
+    } else if (override?.visibility?.public) {
+      $(toolEl).replaceWith(`<tool name="${toolName}"/>`);
+    } else {
+      const toolId = findToolId(toolName, tools, toolNameMapping);
+      if (toolId) {
+        $(toolEl).replaceWith(`<tool name="${toolId}"/>`);
+      } else {
+        $(toolEl).remove();
+      }
+    }
+  });
+  return $.root().html() ?? description;
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/config-plugin.js
+var createConfigPlugin = () => ({
+  name: "built-in-config",
+  version: "1.0.0",
+  enforce: "pre",
+  transformTool: (tool, context2) => {
+    const server2 = context2.server;
+    const config2 = server2.findToolConfig?.(context2.toolName);
+    if (config2?.description) {
+      tool.description = config2.description;
+    }
+    return tool;
+  }
+});
+var config_plugin_default = createConfigPlugin();
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/tool-name-mapping-plugin.js
+var createToolNameMappingPlugin = () => ({
+  name: "built-in-tool-name-mapping",
+  version: "1.0.0",
+  enforce: "pre",
+  transformTool: (tool, context2) => {
+    const server2 = context2.server;
+    const toolName = context2.toolName;
+    const originalName = tool._originalName || toolName;
+    const dotNotation = originalName.replace(/_/g, ".");
+    const underscoreNotation = originalName.replace(/\./g, "_");
+    if (dotNotation !== originalName && server2.toolNameMapping) {
+      server2.toolNameMapping.set(dotNotation, toolName);
+    }
+    if (underscoreNotation !== originalName && server2.toolNameMapping) {
+      server2.toolNameMapping.set(underscoreNotation, toolName);
+    }
+    if (originalName !== toolName && server2.toolNameMapping) {
+      server2.toolNameMapping.set(originalName, toolName);
+    }
+    return tool;
+  }
+});
+var tool_name_mapping_plugin_default = createToolNameMappingPlugin();
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/logger.js
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  notice: 2,
+  warning: 3,
+  error: 4,
+  critical: 5,
+  alert: 6,
+  emergency: 7
+};
+var MCPLogger = class _MCPLogger {
+  server;
+  loggerName;
+  minLevel = "debug";
+  constructor(loggerName = "mcpc", server2) {
+    this.loggerName = loggerName;
+    this.server = server2;
+  }
+  setServer(server2) {
+    this.server = server2;
+  }
+  setLevel(level) {
+    this.minLevel = level;
+  }
+  async log(level, data) {
+    if (LOG_LEVELS[level] < LOG_LEVELS[this.minLevel]) {
+      return;
+    }
+    this.logToConsole(level, data);
+    if (this.server) {
+      try {
+        await this.server.sendLoggingMessage({
+          level,
+          logger: this.loggerName,
+          data
+        });
+      } catch {
+      }
+    }
+  }
+  logToConsole(level, data) {
+    const message = typeof data === "string" ? data : JSON.stringify(data);
+    const prefix = `[${this.loggerName}:${level}]`;
+    console.error(prefix, message);
+  }
+  debug(data) {
+    return this.log("debug", data);
+  }
+  info(data) {
+    return this.log("info", data);
+  }
+  notice(data) {
+    return this.log("notice", data);
+  }
+  warning(data) {
+    return this.log("warning", data);
+  }
+  error(data) {
+    return this.log("error", data);
+  }
+  critical(data) {
+    return this.log("critical", data);
+  }
+  alert(data) {
+    return this.log("alert", data);
+  }
+  emergency(data) {
+    return this.log("emergency", data);
+  }
+  child(name) {
+    const child = new _MCPLogger(`${this.loggerName}.${name}`, this.server);
+    child.setLevel(this.minLevel);
+    return child;
+  }
+};
+var logger = new MCPLogger("mcpc");
+function createLogger(name, server2) {
+  return new MCPLogger(name, server2);
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/logging-plugin.js
+var createLoggingPlugin = (options = {}) => {
+  const { enabled = true, verbose = false, compact: compact2 = true } = options;
+  return {
+    name: "built-in-logging",
+    version: "1.0.0",
+    composeEnd: async (context2) => {
+      if (!enabled) return;
+      const logger2 = createLogger("mcpc.plugin.logging", context2.server);
+      if (compact2) {
+        const pluginCount = context2.pluginNames.length;
+        const { stats } = context2;
+        await logger2.info(`[${context2.toolName}] ${pluginCount} plugins \u2022 ${stats.publicTools} public \u2022 ${stats.hiddenTools} hidden`);
+      } else if (verbose) {
+        await logger2.info(`[${context2.toolName}] Composition complete`);
+        await logger2.info(`   \u251C\u2500 Plugins: ${context2.pluginNames.join(", ")}`);
+        const { stats } = context2;
+        const server2 = context2.server;
+        const publicTools = Array.from(new Set(server2.getPublicToolNames().map(String)));
+        const internalTools = Array.from(new Set(server2.getInternalToolNames().map(String)));
+        const hiddenTools = Array.from(new Set(server2.getHiddenToolNames().map(String)));
+        const normalInternal = internalTools.filter((name) => !hiddenTools.includes(name));
+        if (publicTools.length > 0) {
+          await logger2.info(`   \u251C\u2500 Public: ${publicTools.join(", ")}`);
+        }
+        if (internalTools.length > 0) {
+          const parts = [];
+          if (normalInternal.length > 0) {
+            parts.push(normalInternal.join(", "));
+          }
+          if (hiddenTools.length > 0) {
+            parts.push(`(${hiddenTools.join(", ")})`);
+          }
+          await logger2.info(`   \u251C\u2500 Internal: ${parts.join(", ")}`);
+        }
+        await logger2.info(`   \u2514\u2500 Total: ${stats.totalTools} tools`);
+      }
+    }
+  };
+};
+var logging_plugin_default = createLoggingPlugin({
+  verbose: true,
+  compact: false
+});
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/prompts/index.js
+var SystemPrompts = {
+  /**
+   * Base system prompt for autonomous MCP execution
+   */
+  AUTONOMOUS_EXECUTION: `Agentic tool \`{toolName}\` that executes complex tasks by iteratively selecting and calling tools, gathering results, and continuing until completion. Use this tool when the task matches the manual below.
+
+You must follow the <manual/>, obey the <execution_rules/>, and use the <call_format/>.
+
+<manual>
+{description}
+</manual>
+
+<parameters>
+\`useTool\` - Which tool to execute this iteration
+\`hasDefinitions\` - Tool names whose schemas you already have
+\`definitionsOf\` - Tool names whose schemas you need
+</parameters>
+
+<execution_rules>
+1. **First call**: No tool definitions available\u2014you must request them via \`definitionsOf\`
+2. **When executing tools**: Must provide \`hasDefinitions\` with ALL tools you have schemas for (avoid duplicate requests and reduce tokens)
+3. **When requesting definitions**: Use \`definitionsOf\` to request tool schemas you need
+4. **Both together**: Execute tool AND request new definitions in one call for efficiency
+5. **Never request definitions you already have**
+6. **Select** one tool to execute per call using \`useTool\`
+7. **Provide** parameters matching the selected tool name
+8. Note: You are an agent exposed as an MCP tool - **\`useTool\` is an internal parameter for choosing which tool to execute, NOT an external MCP tool you can call**
+</execution_rules>
+
+<call_format>
+Initial definition request:
+\`\`\`json
+{
+  "hasDefinitions": [],
+  "definitionsOf": ["tool1", "tool2"]
+}
+\`\`\`
+
+Execute tool + get new definitions:
+\`\`\`json
+{
+  "useTool": "tool1",
+  "tool1": { /* parameters */ },
+  "hasDefinitions": ["tool1", "tool2"],
+  "definitionsOf": ["tool3"]
+}
+\`\`\`
+</call_format>`,
+  /**
+   * Workflow execution system prompt
+   */
+  WORKFLOW_EXECUTION: `Workflow tool \`{toolName}\` that executes multi-step workflows. Use this when your task requires sequential steps.
+
+<manual>
+{description}
+</manual>
+
+<rules>
+1. First call: {planningInstructions}
+2. Subsequent calls: Provide only current step parameters
+3. Use \`decision: "proceed"\` to advance, \`"retry"\` to retry, \`"complete"\` when done
+4. Include \`steps\` ONLY with \`init: true\`, never during execution
+</rules>`,
+  /**
+   * JSON-only execution system prompt for autonomous sampling mode
+   *
+   * Note: Sampling mode runs an internal LLM loop that autonomously calls tools until complete.
+   */
+  SAMPLING_EXECUTION: `Agent \`{toolName}\` that completes tasks by calling tools in an autonomous loop.
 
 <manual>
 {description}
@@ -1101,7 +1529,7 @@ function endSpan(span, error) {
 }
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-executor.js
-import process4 from "node:process";
+import process5 from "node:process";
 var AgenticExecutor = class {
   name;
   allToolNames;
@@ -1119,13 +1547,13 @@ var AgenticExecutor = class {
     this.tracingEnabled = false;
     this.logger = createLogger(`mcpc.agentic.${name}`, server2);
     try {
-      this.tracingEnabled = process4.env.MCPC_TRACING_ENABLED === "true";
+      this.tracingEnabled = process5.env.MCPC_TRACING_ENABLED === "true";
       if (this.tracingEnabled) {
         initializeTracing({
           enabled: true,
           serviceName: `mcpc-agentic-${name}`,
-          exportTo: process4.env.MCPC_TRACING_EXPORT ?? "otlp",
-          otlpEndpoint: process4.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
+          exportTo: process5.env.MCPC_TRACING_EXPORT ?? "otlp",
+          otlpEndpoint: process5.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
         });
       }
     } catch {
@@ -1168,7 +1596,21 @@ var AgenticExecutor = class {
       const useTool = args[this.USE_TOOL_KEY];
       const definitionsOf = args.definitionsOf || [];
       const hasDefinitions = args.hasDefinitions || [];
-      if (executeSpan && useTool) {
+      if (!useTool) {
+        if (executeSpan) {
+          executeSpan.setAttributes({
+            toolType: "none",
+            completion: true
+          });
+          endSpan(executeSpan);
+        }
+        const result2 = {
+          content: []
+        };
+        this.appendToolSchemas(result2, definitionsOf, hasDefinitions);
+        return result2;
+      }
+      if (executeSpan) {
         try {
           const safeTool = String(useTool).replace(/\s+/g, "_");
           if (typeof executeSpan.updateName === "function") {
@@ -1254,14 +1696,14 @@ var AgenticExecutor = class {
       if (executeSpan) {
         executeSpan.setAttributes({
           toolType: "not_found",
-          useTool: useTool || "unknown",
-          completion: true
+          useTool
         });
         endSpan(executeSpan);
       }
-      this.logger.debug({
-        message: "Tool not found, returning completion message",
-        useTool
+      this.logger.warning({
+        message: "Tool not found",
+        useTool,
+        availableTools: this.allToolNames
       });
       const result = {
         content: []
@@ -2265,7 +2707,7 @@ var createWorkflowModePlugin = () => ({
 var mode_workflow_plugin_default = createWorkflowModePlugin();
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/sampling/base-sampling-executor.js
-import process5 from "node:process";
+import process6 from "node:process";
 var BaseSamplingExecutor = class {
   name;
   description;
@@ -2298,10 +2740,10 @@ var BaseSamplingExecutor = class {
     this.logger = createLogger(`mcpc.sampling.${name}`, server2);
     try {
       const tracingConfig = {
-        enabled: process5.env.MCPC_TRACING_ENABLED === "true",
+        enabled: process6.env.MCPC_TRACING_ENABLED === "true",
         serviceName: `mcpc-sampling-${name}`,
-        exportTo: process5.env.MCPC_TRACING_EXPORT ?? "otlp",
-        otlpEndpoint: process5.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
+        exportTo: process6.env.MCPC_TRACING_EXPORT ?? "otlp",
+        otlpEndpoint: process6.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
       };
       this.tracingEnabled = tracingConfig.enabled;
       if (this.tracingEnabled) {
@@ -3864,9 +4306,16 @@ var ComposableMCPServer = class extends Server {
     const toolNameToIdMapping = /* @__PURE__ */ new Map();
     const requestedToolNames = /* @__PURE__ */ new Set();
     const availableToolNames = /* @__PURE__ */ new Set();
+    const allPlaceholderUsages = [];
     tagToResults.tool.forEach((tool) => {
       if (tool.attribs.name) {
-        requestedToolNames.add(sanitizePropertyKey(tool.attribs.name));
+        const originalName = tool.attribs.name;
+        const toolName = sanitizePropertyKey(originalName);
+        if (toolName.endsWith(`_${ALL_TOOLS_PLACEHOLDER2}`) || toolName === ALL_TOOLS_PLACEHOLDER2) {
+          allPlaceholderUsages.push(originalName);
+        } else {
+          requestedToolNames.add(toolName);
+        }
       }
     });
     const { tools, cleanupClients } = await composeMcpDepTools(depsConfig, ({ mcpName, toolNameWithScope, toolId }) => {
@@ -3907,6 +4356,14 @@ var ComposableMCPServer = class extends Server {
       }
       availableToolNames.add(toolName);
     });
+    if (allPlaceholderUsages.length > 0) {
+      await this.logger.warning(`Found ${allPlaceholderUsages.length} __ALL__ placeholder(s) for agent "${name}":`);
+      allPlaceholderUsages.forEach((usage) => {
+        this.logger.warning(`   \u2022 "${usage}" - consider using specific tool names`);
+      });
+      const available = Array.from(availableToolNames).sort().join(", ");
+      await this.logger.warning(`   Available tools: ${available}`);
+    }
     const unmatchedTools = Array.from(requestedToolNames).filter((toolName) => !allTools[toolName]);
     if (unmatchedTools.length > 0) {
       await this.logger.warning(`Tool matching warnings for agent "${name}":`);
@@ -3996,12 +4453,12 @@ var ComposableMCPServer = class extends Server {
 };
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/env.js
-import process6 from "node:process";
-var isSCF = () => Boolean(process6.env.SCF_RUNTIME || process6.env.PROD_SCF);
+import process7 from "node:process";
+var isSCF = () => Boolean(process7.env.SCF_RUNTIME || process7.env.PROD_SCF);
 if (isSCF()) {
   console.log({
     isSCF: isSCF(),
-    SCF_RUNTIME: process6.env.SCF_RUNTIME
+    SCF_RUNTIME: process7.env.SCF_RUNTIME
   });
 }
 
@@ -4047,14 +4504,14 @@ async function mcpc(serverConf, composeConf, setupCallback) {
 }
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/large-result.js
-import { mkdtemp, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { mkdtemp, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/search-tool.js
 import rg from "@mcpc-tech/ripgrep-napi";
 import { tmpdir } from "node:os";
-import { resolve } from "node:path";
+import { resolve as resolve2 } from "node:path";
 import { relative } from "node:path";
 function createSearchPlugin(options = {}) {
   const maxResults = options.maxResults || 20;
@@ -4114,8 +4571,8 @@ Only search within the allowed directory: ${allowedSearchDir}`, jsonSchema({
           const requestedPath = args.path || allowedSearchDir;
           const limit = args.maxResults || maxResults;
           if (args.path) {
-            const resolvedRequested = resolve(args.path);
-            const resolvedAllowed = resolve(allowedSearchDir);
+            const resolvedRequested = resolve2(args.path);
+            const resolvedAllowed = resolve2(allowedSearchDir);
             const relativePath = relative(resolvedAllowed, resolvedRequested);
             if (relativePath && relativePath.startsWith("..")) {
               return {
@@ -4285,447 +4742,112 @@ function createLargeResultPlugin(options = {}) {
   let tempDir = options.tempDir || null;
   const configuredServers = /* @__PURE__ */ new Map();
   const searchConfig = {
-    maxResults: options.search?.maxResults || 15,
-    maxOutputSize: options.search?.maxOutputSize || 4e3,
-    global: true
-  };
-  return {
-    name: "plugin-large-result-handler",
-    version: "1.0.0",
-    dependencies: [],
-    configureServer: async (server2) => {
-      if (!configuredServers.has(server2)) {
-        const searchPlugin = createSearchPlugin(searchConfig);
-        await server2.addPlugin(searchPlugin);
-        configuredServers.set(server2, true);
-      }
-    },
-    transformTool: (tool, context2) => {
-      const originalExecute = tool.execute;
-      tool.execute = async (args) => {
-        try {
-          const result = await originalExecute(args);
-          const resultText = JSON.stringify(result);
-          if (resultText.length <= maxSize) {
-            return result;
-          }
-          if (!tempDir) {
-            tempDir = await mkdtemp(join(tmpdir2(), "mcpc-results-"));
-          }
-          const safeToolName = encodeURIComponent(context2.toolName ?? "tool");
-          const fileName = `${safeToolName}-${Date.now()}.txt`;
-          const filePath = join(tempDir, fileName);
-          await writeFile(filePath, resultText);
-          const preview = resultText.slice(0, previewSize);
-          const sizeKB = (resultText.length / 1024).toFixed(1);
-          return {
-            content: [
-              {
-                type: "text",
-                text: `**Result too large (${resultText.length} chars), saved to file**
-
-\u{1F4C1} **File:** ${filePath}
-\u{1F4CA} **Size:** ${sizeKB} KB
-
-**Preview (${previewSize} chars):**
-\`\`\`
-${preview}
-\`\`\`
-
-**To read/understand the full content:**
-- Use the \`search-tool-result\` tool with pattern: \`search-tool-result {"pattern": "your-search-term"}\`
-- Search supports regex patterns for advanced queries`
-              }
-            ]
-          };
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error);
-          console.error(`Large result plugin error for ${context2.toolName}: ${errorMsg}`);
-          throw error;
-        }
-      };
-      return tool;
-    },
-    dispose: () => {
-      configuredServers.clear();
-      tempDir = null;
-    }
-  };
-}
-var defaultLargeResultPlugin = createLargeResultPlugin({
-  maxSize: 8e3,
-  previewSize: 4e3
-});
-
-// __mcpc__cli_latest/node_modules/@mcpc/cli/src/app.js
-var createServer = async (config2) => {
-  const serverConfig = config2 || {
-    name: "large-result-plugin-example",
-    version: "0.1.0",
-    agents: [
-      {
-        name: null,
-        description: "",
-        plugins: [
-          createLargeResultPlugin({})
-        ]
-      }
-    ]
-  };
-  return await mcpc([
-    {
-      name: serverConfig.name || "mcpc-server",
-      version: serverConfig.version || "0.1.0"
-    },
-    {
-      capabilities: serverConfig?.capabilities || {
-        tools: {},
-        sampling: {},
-        logging: {}
-      }
-    }
-  ], serverConfig.agents);
-};
-
-// __mcpc__cli_latest/node_modules/@mcpc/cli/src/config/loader.js
-import { readFile } from "node:fs/promises";
-import { resolve as resolve2 } from "node:path";
-import process7 from "node:process";
-function extractServerName(command, commandArgs) {
-  for (const arg of commandArgs) {
-    if (!arg.startsWith("-")) {
-      const name2 = arg.replace(/[@.,/\\:;!?#$%^&*()[\]{}]/g, "_").substring(0, 64);
-      if (name2) return name2;
-    }
-  }
-  const name = command.replace(/[@.,/\\:;!?#$%^&*()[\]{}]/g, "_").substring(0, 64);
-  return name || "agentic-tool";
-}
-function createProxyConfig(args) {
-  if (!args.proxyCommand || args.proxyCommand.length === 0) {
-    console.error("Error: --proxy requires a command after --");
-    console.error("Example: mcpc --proxy --transport-type stdio -- npx -y @wonderwhy-er/desktop-commander");
-    process7.exit(1);
-  }
-  if (!args.transportType) {
-    console.error("Error: --proxy requires --transport-type to be specified");
-    console.error("Supported types: stdio, streamable-http, sse");
-    console.error("Example: mcpc --proxy --transport-type stdio -- npx -y @wonderwhy-er/desktop-commander");
-    process7.exit(1);
-  }
-  const validTransports = [
-    "stdio",
-    "streamable-http",
-    "sse"
-  ];
-  if (!validTransports.includes(args.transportType)) {
-    console.error(`Error: Invalid transport type '${args.transportType}'`);
-    console.error(`Supported types: ${validTransports.join(", ")}`);
-    process7.exit(1);
-  }
-  const command = args.proxyCommand[0];
-  const commandArgs = args.proxyCommand.slice(1);
-  const serverName = args.name || extractServerName(command, commandArgs);
-  const config2 = {
-    name: `${serverName}-proxy`,
-    version: "0.1.0",
-    capabilities: {
-      tools: {},
-      sampling: {}
-    },
-    agents: [
-      {
-        name: serverName,
-        description: `Orchestrate ${serverName} MCP server tools`,
-        deps: {
-          mcpServers: {
-            [serverName]: {
-              command,
-              args: commandArgs,
-              transportType: args.transportType
-            }
-          }
-        },
-        options: {
-          mode: args.mode || "agentic",
-          refs: [
-            `<tool name="${serverName}.__ALL__"/>`
-          ]
-        }
-      }
-    ]
-  };
-  console.error(`Created proxy configuration for ${serverName}`);
-  console.error(`Transport: ${args.transportType}`);
-  console.error(`Command: ${command} ${commandArgs.join(" ")}`);
-  if (args.mode) {
-    console.error(`Mode: ${args.mode}`);
-  }
-  return config2;
-}
-function printHelp() {
-  console.log(`
-MCPC CLI - Model Context Protocol Composer
-
-USAGE:
-    mcpc [OPTIONS]
-
-OPTIONS:
-    --help, -h              Show this help message
-    --config <json>         Inline JSON configuration string
-    --config-url <url>      Fetch configuration from URL
-    --config-file <path>    Load configuration from file path
-    --request-headers <header>, -H <header>
-                           Add custom HTTP header for URL fetching
-                           Format: "Key: Value" or "Key=Value"
-                           Can be used multiple times
-    --mode <mode>           Set execution mode for all agents
-                           Supported modes:
-                           - agentic: Fully autonomous agent mode (default)
-                           - agentic_workflow: Agent workflow mode with dynamic or predefined steps
-                           - agentic_sampling: Autonomous sampling mode for agentic execution
-                           - agentic_workflow_sampling: Autonomous sampling mode for workflow execution
-                           - code_execution: Code execution mode for most efficient token usage
-    --proxy                 Proxy mode: automatically configure MCPC to wrap an MCP server
-                           Use with --transport-type to specify the transport
-                           Example: --proxy --transport-type stdio -- npx -y @wonderwhy-er/desktop-commander
-    --transport-type <type> Transport type for proxy mode
-                           Supported types: stdio, streamable-http, sse
-    --name <name>           Custom server name for proxy mode (overrides auto-detection)
-
-ENVIRONMENT VARIABLES:
-    MCPC_CONFIG            Inline JSON configuration (same as --config)
-    MCPC_CONFIG_URL        URL to fetch config from (same as --config-url)
-    MCPC_CONFIG_FILE       Path to config file (same as --config-file)
-
-EXAMPLES:
-    # Show help
-    mcpc --help
-
-    # Proxy mode - wrap an existing MCP server (stdio)
-    mcpc --proxy --transport-type stdio -- npx -y @wonderwhy-er/desktop-commander
-
-    # Proxy mode with custom server name
-    mcpc --proxy --transport-type stdio --name my-server -- npx shadcn@latest mcp
-
-    # Proxy mode - wrap an MCP server (streamable-http)
-    mcpc --proxy --transport-type streamable-http -- https://api.example.com/mcp
-
-    # Proxy mode - wrap an MCP server (sse)
-    mcpc --proxy --transport-type sse -- https://api.example.com/sse
-
-    # Load from URL
-    mcpc --config-url \\
-      "https://raw.githubusercontent.com/mcpc-tech/mcpc/main/packages/cli/examples/configs/codex-fork.json"
-
-    # Load from URL with custom headers
-    mcpc \\
-      --config-url "https://api.example.com/config.json" \\
-      -H "Authorization: Bearer token123" \\
-      -H "X-Custom-Header: value"
-
-    # Load from file
-    mcpc --config-file ./my-config.json
-
-    # Override execution mode for all agents
-    mcpc --config-file ./my-config.json --mode agentic_workflow
-
-    # Using environment variable
-    export MCPC_CONFIG='[{"name":"agent","description":"..."}]'
-    mcpc
+    maxResults: options.search?.maxResults || 15,
+    maxOutputSize: options.search?.maxOutputSize || 4e3,
+    global: true
+  };
+  return {
+    name: "plugin-large-result-handler",
+    version: "1.0.0",
+    dependencies: [],
+    configureServer: async (server2) => {
+      if (!configuredServers.has(server2)) {
+        const searchPlugin = createSearchPlugin(searchConfig);
+        await server2.addPlugin(searchPlugin);
+        configuredServers.set(server2, true);
+      }
+    },
+    transformTool: (tool, context2) => {
+      const originalExecute = tool.execute;
+      tool.execute = async (args) => {
+        try {
+          const result = await originalExecute(args);
+          const resultText = JSON.stringify(result);
+          if (resultText.length <= maxSize) {
+            return result;
+          }
+          if (!tempDir) {
+            tempDir = await mkdtemp(join2(tmpdir2(), "mcpc-results-"));
+          }
+          const safeToolName = encodeURIComponent(context2.toolName ?? "tool");
+          const fileName = `${safeToolName}-${Date.now()}.txt`;
+          const filePath = join2(tempDir, fileName);
+          await writeFile2(filePath, resultText);
+          const preview = resultText.slice(0, previewSize);
+          const sizeKB = (resultText.length / 1024).toFixed(1);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `**Result too large (${resultText.length} chars), saved to file**
 
-    # Use default configuration (./mcpc.config.json)
-    mcpc
+\u{1F4C1} **File:** ${filePath}
+\u{1F4CA} **Size:** ${sizeKB} KB
 
-CONFIGURATION:
-    Configuration files support environment variable substitution using $VAR_NAME syntax.
-    
-    Priority order:
-    1. --config (inline JSON)
-    2. MCPC_CONFIG environment variable
-    3. --config-url or MCPC_CONFIG_URL
-    4. --config-file or MCPC_CONFIG_FILE
-    5. ./mcpc.config.json (default)
+**Preview (${previewSize} chars):**
+\`\`\`
+${preview}
+\`\`\`
 
-For more information, visit: https://github.com/mcpc-tech/mcpc
-`);
-}
-function parseArgs() {
-  const args = process7.argv.slice(2);
-  const result = {};
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "--config" && i + 1 < args.length) {
-      result.config = args[++i];
-    } else if (arg === "--config-url" && i + 1 < args.length) {
-      result.configUrl = args[++i];
-    } else if (arg === "--config-file" && i + 1 < args.length) {
-      result.configFile = args[++i];
-    } else if ((arg === "--request-headers" || arg === "-H") && i + 1 < args.length) {
-      const headerStr = args[++i];
-      const colonIdx = headerStr.indexOf(":");
-      const equalIdx = headerStr.indexOf("=");
-      const separatorIdx = colonIdx !== -1 ? equalIdx !== -1 ? Math.min(colonIdx, equalIdx) : colonIdx : equalIdx;
-      if (separatorIdx !== -1) {
-        const key = headerStr.substring(0, separatorIdx).trim();
-        const value = headerStr.substring(separatorIdx + 1).trim();
-        if (!result.requestHeaders) {
-          result.requestHeaders = {};
+**To read/understand the full content:**
+- Use the \`search-tool-result\` tool with pattern: \`search-tool-result {"pattern": "your-search-term"}\`
+- Search supports regex patterns for advanced queries`
+              }
+            ]
+          };
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          console.error(`Large result plugin error for ${context2.toolName}: ${errorMsg}`);
+          throw error;
         }
-        result.requestHeaders[key] = value;
-      }
-    } else if (arg === "--help" || arg === "-h") {
-      result.help = true;
-    } else if (arg === "--proxy") {
-      result.proxy = true;
-    } else if (arg === "--transport-type" && i + 1 < args.length) {
-      result.transportType = args[++i];
-    } else if (arg === "--mode" && i + 1 < args.length) {
-      result.mode = args[++i];
-    } else if (arg === "--name" && i + 1 < args.length) {
-      result.name = args[++i];
-    } else if (arg === "--") {
-      result.proxyCommand = args.slice(i + 1);
-      break;
+      };
+      return tool;
+    },
+    dispose: () => {
+      configuredServers.clear();
+      tempDir = null;
     }
-  }
-  return result;
+  };
 }
-async function loadConfig() {
-  const args = parseArgs();
-  if (args.help) {
-    printHelp();
-    process7.exit(0);
-  }
-  if (args.proxy) {
-    return createProxyConfig(args);
-  }
-  if (args.config) {
-    try {
-      const parsed = JSON.parse(args.config);
-      return applyModeOverride(normalizeConfig(parsed), args.mode);
-    } catch (error) {
-      console.error("Failed to parse --config argument:", error);
-      throw error;
-    }
-  }
-  if (process7.env.MCPC_CONFIG) {
-    try {
-      const parsed = JSON.parse(process7.env.MCPC_CONFIG);
-      return applyModeOverride(normalizeConfig(parsed), args.mode);
-    } catch (error) {
-      console.error("Failed to parse MCPC_CONFIG environment variable:", error);
-      throw error;
-    }
-  }
-  const configUrl = args.configUrl || process7.env.MCPC_CONFIG_URL;
-  if (configUrl) {
-    try {
-      const headers = {
-        "User-Agent": "MCPC-CLI/0.1.0",
-        ...args.requestHeaders
-      };
-      const response = await fetch(configUrl, {
-        headers
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+var defaultLargeResultPlugin = createLargeResultPlugin({
+  maxSize: 8e3,
+  previewSize: 4e3
+});
+
+// __mcpc__cli_latest/node_modules/@mcpc/cli/src/app.js
+import { codeExecutionPlugin } from "@mcpc-tech/plugin-code-execution";
+var createServer = async (config2) => {
+  const serverConfig = config2 || {
+    name: "mcpc-server",
+    version: "0.1.0",
+    agents: [
+      {
+        name: null,
+        description: "",
+        plugins: [
+          createLargeResultPlugin({}),
+          codeExecutionPlugin()
+        ],
+        options: {
+          mode: "code_execution"
+        }
       }
-      const content = await response.text();
-      const parsed = JSON.parse(content);
-      return applyModeOverride(normalizeConfig(parsed), args.mode);
-    } catch (error) {
-      console.error(`Failed to fetch config from ${configUrl}:`, error);
-      throw error;
-    }
-  }
-  const configFile = args.configFile || process7.env.MCPC_CONFIG_FILE;
-  if (configFile) {
-    try {
-      const content = await readFile(configFile, "utf-8");
-      const parsed = JSON.parse(content);
-      return applyModeOverride(normalizeConfig(parsed), args.mode);
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        console.error(`Config file not found: ${configFile}`);
-        throw error;
-      } else {
-        console.error(`Failed to load config from ${configFile}:`, error);
-        throw error;
+    ]
+  };
+  return await mcpc([
+    {
+      name: serverConfig.name || "mcpc-server",
+      version: serverConfig.version || "0.1.0"
+    },
+    {
+      capabilities: serverConfig?.capabilities || {
+        tools: {},
+        sampling: {},
+        logging: {}
       }
     }
-  }
-  const defaultConfigPath = resolve2(process7.cwd(), "mcpc.config.json");
-  try {
-    const content = await readFile(defaultConfigPath, "utf-8");
-    const parsed = JSON.parse(content);
-    return applyModeOverride(normalizeConfig(parsed), args.mode);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return null;
-    } else {
-      console.error(`Failed to load config from ${defaultConfigPath}:`, error);
-      throw error;
-    }
-  }
-}
-function replaceEnvVars(str) {
-  return str.replace(/\$([A-Z_][A-Z0-9_]*)/g, (_match, varName) => {
-    return process7.env[varName] || "";
-  });
-}
-function replaceEnvVarsInConfig(obj) {
-  if (typeof obj === "string") {
-    return replaceEnvVars(obj);
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => replaceEnvVarsInConfig(item));
-  }
-  if (obj && typeof obj === "object") {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      result[key] = replaceEnvVarsInConfig(value);
-    }
-    return result;
-  }
-  return obj;
-}
-function applyModeOverride(config2, mode) {
-  if (!mode) return config2;
-  config2.agents.forEach((agent) => {
-    if (!agent.options) agent.options = {};
-    agent.options.mode = mode;
-  });
-  return config2;
-}
-function normalizeConfig(config2) {
-  config2 = replaceEnvVarsInConfig(config2);
-  if (Array.isArray(config2)) {
-    return {
-      name: "mcpc-server",
-      version: "0.1.0",
-      agents: normalizeAgents(config2)
-    };
-  }
-  if (config2 && typeof config2 === "object") {
-    const cfg = config2;
-    return {
-      name: cfg.name || "mcpc-server",
-      version: cfg.version || "0.1.0",
-      capabilities: cfg.capabilities,
-      agents: normalizeAgents(cfg.agents || [])
-    };
-  }
-  throw new Error("Invalid configuration format");
-}
-function normalizeAgents(agents) {
-  return agents.map((agent) => {
-    if (agent.deps && !agent.deps.mcpServers) {
-      agent.deps.mcpServers = {};
-    }
-    return agent;
-  });
-}
+  ], serverConfig.agents);
+};
 
 // __mcpc__cli_latest/node_modules/@mcpc/cli/src/bin.ts
 import { createCodeExecutionPlugin } from "@mcpc-tech/plugin-code-execution";