@mcpc-tech/cli 0.1.1-beta.1

package/src/bin.mjs

@@ -0,0 +1,3096 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugins/built-in/config-plugin.js
+var createConfigPlugin, config_plugin_default;
+var init_config_plugin = __esm({
+  "../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugins/built-in/config-plugin.js"() {
+    createConfigPlugin = () => ({
+      name: "built-in-config",
+      enforce: "pre",
+      transformTool: (tool, context) => {
+        const server2 = context.server;
+        const config2 = server2.findToolConfig?.(context.toolName);
+        if (config2?.description) {
+          tool.description = config2.description;
+        }
+        return tool;
+      }
+    });
+    config_plugin_default = createConfigPlugin();
+  }
+});
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugins/built-in/tool-name-mapping-plugin.js
+var createToolNameMappingPlugin, tool_name_mapping_plugin_default;
+var init_tool_name_mapping_plugin = __esm({
+  "../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugins/built-in/tool-name-mapping-plugin.js"() {
+    createToolNameMappingPlugin = () => ({
+      name: "built-in-tool-name-mapping",
+      enforce: "pre",
+      transformTool: (tool, context) => {
+        const server2 = context.server;
+        const toolName = context.toolName;
+        const dotNotation = toolName.replace(/_/g, ".");
+        const underscoreNotation = toolName.replace(/\./g, "_");
+        if (dotNotation !== toolName && server2.toolNameMapping) {
+          server2.toolNameMapping.set(dotNotation, toolName);
+          server2.toolNameMapping.set(toolName, dotNotation);
+        }
+        if (underscoreNotation !== toolName && server2.toolNameMapping) {
+          server2.toolNameMapping.set(underscoreNotation, toolName);
+          server2.toolNameMapping.set(toolName, underscoreNotation);
+        }
+        return tool;
+      }
+    });
+    tool_name_mapping_plugin_default = createToolNameMappingPlugin();
+  }
+});
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugins/built-in/logging-plugin.js
+var createLoggingPlugin, logging_plugin_default;
+var init_logging_plugin = __esm({
+  "../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugins/built-in/logging-plugin.js"() {
+    createLoggingPlugin = (options = {}) => {
+      const { enabled = true, verbose = false, compact: compact2 = true } = options;
+      return {
+        name: "built-in-logging",
+        composeEnd: (context) => {
+          if (!enabled) return;
+          if (compact2) {
+            const pluginCount = context.pluginNames.length;
+            const server2 = context.server;
+            const externalList = server2.getExternalToolNames();
+            const internalList = server2.getInternalToolNames();
+            const hiddenList = server2.getHiddenToolNames();
+            const publicToolNames = server2.getPublicToolNames();
+            const externalCount = externalList.length;
+            const internalCount = internalList.length;
+            const hiddenCount = hiddenList.length;
+            const globalCount = publicToolNames.length;
+            console.log(`\u{1F9E9} [${context.toolName}] ${pluginCount} plugins \u2022 ${externalCount} external \u2022 ${internalCount} internal \u2022 ${hiddenCount} hidden \u2022 ${globalCount} global`);
+          } else if (verbose) {
+            console.log(`\u{1F9E9} [${context.toolName}]`);
+            console.log(`   \u251C\u2500 Plugins: ${context.pluginNames.join(", ")}`);
+            const server2 = context.server;
+            const globalToolNames = Array.from(new Set(server2.getPublicToolNames().map(String)));
+            const external = Array.from(new Set(server2.getExternalToolNames().map(String)));
+            const internal = Array.from(new Set(server2.getInternalToolNames().map(String)));
+            const hidden = Array.from(new Set(server2.getHiddenToolNames().map(String)));
+            const globalNames = globalToolNames.map(String);
+            const totalSet = /* @__PURE__ */ new Set([
+              ...external,
+              ...internal,
+              ...globalNames
+            ]);
+            const totalList = Array.from(totalSet);
+            if (external.length > 0) {
+              console.log(`   \u251C\u2500 External: ${external.join(", ")}`);
+            }
+            if (internal.length > 0) {
+              console.log(`   \u251C\u2500 Internal: ${internal.join(", ")}`);
+            }
+            if (globalNames.length > 0) {
+              console.log(`   \u251C\u2500 Global: ${globalNames.join(", ")}`);
+            }
+            if (hidden.length > 0) {
+              console.log(`   \u251C\u2500 Hidden: ${hidden.join(", ")}`);
+            }
+            if (totalList.length > 0) {
+              console.log(`   \u2514\u2500 Total: ${totalList.length} tools`);
+            }
+          }
+        }
+      };
+    };
+    logging_plugin_default = createLoggingPlugin({
+      verbose: true,
+      compact: false
+    });
+  }
+});
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugins/built-in/index.js
+var built_in_exports = {};
+__export(built_in_exports, {
+  createConfigPlugin: () => createConfigPlugin,
+  createLoggingPlugin: () => createLoggingPlugin,
+  createToolNameMappingPlugin: () => createToolNameMappingPlugin,
+  getBuiltInPlugins: () => getBuiltInPlugins
+});
+function getBuiltInPlugins() {
+  return [
+    tool_name_mapping_plugin_default,
+    config_plugin_default,
+    logging_plugin_default
+  ];
+}
+var init_built_in = __esm({
+  "../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugins/built-in/index.js"() {
+    init_config_plugin();
+    init_tool_name_mapping_plugin();
+    init_logging_plugin();
+    init_config_plugin();
+    init_tool_name_mapping_plugin();
+    init_logging_plugin();
+  }
+});
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@mcpc/cli/src/bin.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@mcpc/cli/src/app.js
+import { OpenAPIHono } from "@hono/zod-openapi";
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@mcpc/cli/src/controllers/messages.controller.js
+import { createRoute } from "@hono/zod-openapi";
+import { z } from "zod";
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__utils/src/transport/sse.js
+import { JSONRPCMessageSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/std__http/server_sent_event_stream.js
+var NEWLINE_REGEXP = /\r\n|\r|\n/;
+var encoder = new TextEncoder();
+function assertHasNoNewline(value, varName, errPrefix) {
+  if (value.match(NEWLINE_REGEXP) !== null) {
+    throw new SyntaxError(`${errPrefix}: ${varName} cannot contain a newline`);
+  }
+}
+function stringify(message) {
+  const lines = [];
+  if (message.comment) {
+    assertHasNoNewline(message.comment, "`message.comment`", "Cannot serialize message");
+    lines.push(`:${message.comment}`);
+  }
+  if (message.event) {
+    assertHasNoNewline(message.event, "`message.event`", "Cannot serialize message");
+    lines.push(`event:${message.event}`);
+  }
+  if (message.data) {
+    message.data.split(NEWLINE_REGEXP).forEach((line) => lines.push(`data:${line}`));
+  }
+  if (message.id) {
+    assertHasNoNewline(message.id.toString(), "`message.id`", "Cannot serialize message");
+    lines.push(`id:${message.id}`);
+  }
+  if (message.retry) lines.push(`retry:${message.retry}`);
+  return encoder.encode(lines.join("\n") + "\n\n");
+}
+var ServerSentEventStream = class extends TransformStream {
+  constructor() {
+    super({
+      transform: (message, controller) => {
+        controller.enqueue(stringify(message));
+      }
+    });
+  }
+};
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@mcpc/cli/src/controllers/sse.controller.js
+import { createRoute as createRoute2, z as z2 } from "@hono/zod-openapi";
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/compose.js
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { jsonSchema as jsonSchema3 } from "ai";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__utils/src/json.js
+import { jsonrepair } from "jsonrepair";
+function parseJSON(text, throwError) {
+  try {
+    return JSON.parse(text);
+  } catch (_error) {
+    try {
+      const repairedText = jsonrepair(text);
+      console.warn(`Failed to parse JSON, attempting to repair, result: ${text}`);
+      if (throwError) {
+        throw _error;
+      }
+      return JSON.parse(repairedText);
+    } catch {
+      if (throwError) {
+        throw new Error("Failed to parse repaired JSON");
+      }
+      return null;
+    }
+  }
+}
+
+// ../__mcpc__cli_0.1.1-beta.1/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;
+        }
+      }
+    }
+    return result;
+  };
+};
+
+// ../__mcpc__cli_0.1.1-beta.1/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,
+    $
+  };
+}
+
+// ../__mcpc__cli_0.1.1-beta.1/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";
+
+// ../__mcpc__cli_0.1.1-beta.1/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
+  };
+}
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
+import { cwd } from "node:process";
+import process2 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) {
+  return 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;
+  }
+  let transport2;
+  if (typeof def.transportType === "string" && def.transportType === "sse") {
+    const options = {};
+    if (def.headers) {
+      options.requestInit = {
+        headers: def.headers
+      };
+      options.eventSourceInit = {
+        headers: def.headers
+      };
+    }
+    transport2 = new SSEClientTransport(new URL(def.url), options);
+  } else if ("url" in def && typeof def.url === "string") {
+    const options = {};
+    if (def.headers) {
+      options.requestInit = {
+        headers: def.headers
+      };
+    }
+    transport2 = new StreamableHTTPClientTransport(new URL(def.url), options);
+  } else if (typeof def.transportType === "string" && def.transportType === "stdio" || "command" in def) {
+    transport2 = new StdioClientTransport({
+      command: def.command,
+      args: def.args,
+      env: {
+        ...process2.env,
+        ...def.env ?? {}
+      },
+      cwd: cwd()
+    });
+  } else {
+    throw new Error(`Unsupported transport type: ${JSON.stringify(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);
+    }
+  }));
+};
+process2.once?.("exit", () => {
+  cleanupAllPooledClients();
+});
+process2.once?.("SIGINT", () => {
+  cleanupAllPooledClients().finally(() => process2.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 toolId = `${serverId}_${internalToolName}`;
+        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
+        };
+      });
+    } 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_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/utils/common/schema.js
+import traverse from "json-schema-traverse";
+function updateRefPaths(schema, wrapperPath) {
+  if (!schema || typeof schema !== "object") {
+    return schema;
+  }
+  if (!wrapperPath || typeof wrapperPath !== "string") {
+    throw new Error("wrapperPath must be a non-empty string");
+  }
+  const clonedSchema = JSON.parse(JSON.stringify(schema));
+  try {
+    traverse(clonedSchema, {
+      allKeys: true,
+      cb: function(schemaNode, _jsonPtr, _rootSchema, _parentJsonPtr, _parentKeyword, _parentSchema, _keyIndex) {
+        if (schemaNode && typeof schemaNode === "object" && schemaNode.$ref) {
+          const ref = schemaNode.$ref;
+          if (ref.startsWith("#/properties/")) {
+            const relativePath = ref.substring(13);
+            schemaNode.$ref = `#/properties/${wrapperPath}/properties/${relativePath}`;
+          } else if (ref === "#") {
+            schemaNode.$ref = `#/properties/${wrapperPath}`;
+          }
+        }
+      }
+    });
+  } catch (error) {
+    console.warn(`Failed to traverse schema for path "${wrapperPath}":`, error);
+    return clonedSchema;
+  }
+  return clonedSchema;
+}
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-tool-registrar.js
+import { jsonSchema } from "ai";
+
+// ../__mcpc__cli_0.1.1-beta.1/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;
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/utils/common/json.js
+import { jsonrepair as jsonrepair2 } from "jsonrepair";
+import { inspect } from "node:util";
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/utils/common/provider.js
+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_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/prompts/index.js
+var SystemPrompts = {
+  /**
+   * Base system prompt for autonomous MCP execution
+   */
+  AUTONOMOUS_EXECUTION: `Autonomous AI Agent \`{toolName}\` that answers user questions through iterative self-invocation and collecting feedback.
+
+<instructions>{description}</instructions>
+
+## Execution Rules
+1. **Follow instructions above** carefully
+2. **Answer user question** as primary goal
+3. **Execute** one action per call  
+4. **Collect feedback** from each action result
+5. **Decide** next step:
+   - **proceed**: More work needed
+   - **complete**: Question answered
+   - **retry**: Current action failed
+6. **Provide** parameter object matching action name
+7. **Continue** until complete
+
+## Call Format
+\`\`\`json
+{
+  "action": "tool_name",
+  "decision": "proceed|retry|complete", 
+  "tool_name": { /* tool parameters */ }
+}
+\`\`\``,
+  /**
+   * Workflow execution system prompt
+   */
+  WORKFLOW_EXECUTION: `Agentic workflow execution tool \`{toolName}\` that processes requests through structured multi-step workflows.
+
+<instructions>{description}</instructions>
+
+## Workflow Execution Protocol
+
+**\u{1F3AF} FIRST CALL (Planning):**
+{planningInstructions}
+
+**\u26A1 SUBSEQUENT CALLS (Execution):**
+- Provide ONLY current step parameters
+- **ADVANCE STEP**: Set \`decision: "proceed"\` to move to next step  
+- **RETRY STEP**: Set \`decision: "retry"\`
+- **COMPLETE WORKFLOW**: Set \`decision: "complete"\` when ready to finish
+
+**\u{1F6AB} Do NOT include \`steps\` parameter during normal execution**
+**\u2705 Include \`steps\` parameter ONLY when restarting workflow with \`init: true\`**
+**\u26A0\uFE0F CRITICAL: When retrying failed steps, MUST use \`decision: "retry"\`**`,
+  /**
+   * JSON-only execution system prompt
+   */
+  SAMPLING_EXECUTION: `Autonomous AI Agent \`{toolName}\` that answers user questions by iteratively collecting feedback and adapting your approach.
+
+<instructions>{description}</instructions>
+
+## Execution Rules
+- Respond with valid JSON only
+- **Follow instructions above** carefully
+- **Answer user question** as primary goal
+- **Collect feedback** from each action result
+- **Adapt approach** based on gathered information
+- action = "X" \u2192 provide parameter "X"
+- Continue until question answered
+
+## JSON Response Format
+\`\`\`json
+{
+  "action": "tool_name",
+  "decision": "proceed|retry|complete",
+  "tool_name": { /* tool parameters */ }
+}
+\`\`\`
+
+## Available Tools
+{toolList}`,
+  /**
+   * Sampling workflow execution system prompt combining sampling with workflow capabilities
+   */
+  SAMPLING_WORKFLOW_EXECUTION: `You are an autonomous AI Agent named \`{toolName}\` that processes instructions through iterative sampling execution within structured workflows.
+
+<instructions>{description}</instructions>
+
+## Agentic Sampling Workflow Protocol
+
+**\u{1F9E0} AGENTIC REASONING (First Call - Workflow Planning):**
+1. **Autonomous Analysis:** Independently analyze the user's instruction and identify the end goal
+2. **Workflow Design:** Autonomously design a structured workflow with clear steps
+3. **Tool Mapping:** Determine which tools are needed for each workflow step
+4. **Initialization:** Start the workflow with proper step definitions
+
+**\u26A1 AGENTIC EXECUTION RULES (Subsequent Calls):**
+- Each response demonstrates autonomous reasoning and decision-making within workflow context
+- Make self-directed choices about step execution, retry, or advancement
+- Adapt your approach based on previous step results without external guidance
+- Balance workflow structure with autonomous flexibility
+
+**\u{1F504} JSON Response Format (Agentic Workflow Decision Output):**
+You MUST respond with a JSON object for workflow execution:
+
+**For Workflow Initialization (First Call):**
+- action: "{toolName}"
+- init: true
+- steps: Autonomously designed workflow steps array
+- [other workflow parameters]: As you autonomously determine
+
+**For Step Execution (Subsequent Calls):**
+- action: "{toolName}"
+- decision: "proceed" (advance), "retry" (retry), or "complete" (finish - sampling mode only)
+- [step parameters]: Tool-specific parameters you autonomously determine for current step
+
+**\u{1F3AF} AGENTIC WORKFLOW CONSTRAINTS:**
+- Response must be pure JSON demonstrating autonomous decision-making within workflow structure
+- Invalid JSON indicates failure in agentic workflow reasoning
+- Tool parameters must reflect your independent analysis and workflow planning
+- Balance autonomous decision-making with structured workflow progression
+
+**\u{1F6AB} Do NOT include \`steps\` parameter during normal execution**
+**\u2705 Include \`steps\` parameter ONLY when restarting workflow with \`init: true\`**
+**\u26A0\uFE0F CRITICAL: When retrying failed steps, MUST use \`decision: "retry"\`**`
+};
+var WorkflowPrompts = {
+  /**
+   * Workflow initialization instructions
+   */
+  WORKFLOW_INIT: `Workflow initialized with {stepCount} steps. Agent MUST start the workflow with the first step to \`{currentStepDescription}\`. 
+              
+## EXECUTE tool \`{toolName}\` with the following new parameter definition
+
+{schemaDefinition}
+
+## Important Instructions
+- **Include 'steps' parameter ONLY when restarting workflow (with 'init: true')**
+- **Do NOT include 'steps' parameter during normal step execution**
+- **MUST Use the provided JSON schema definition above for parameter generation and validation**
+- **ADVANCE STEP: Set 'decision' to "proceed" to advance to next step**
+- **RETRY STEP: Set 'decision' to "retry" to re-execute current step**  
+- **FINAL STEP: Execute normally for workflow completion, do NOT use 'decision: complete' unless workflow is truly finished**
+- **\u26A0\uFE0F CRITICAL: When retrying failed steps, MUST set 'decision' to "retry"**
+- **\u26A0\uFE0F CRITICAL: Only use 'decision: complete' when the entire workflow has been successfully executed**
+
+{workflowSteps}`,
+  /**
+   * Tool description enhancement for workflow mode
+   */
+  WORKFLOW_TOOL_DESCRIPTION: `{description}
+{initTitle}
+{ensureStepActions}
+{schemaDefinition}`,
+  /**
+   * Planning instructions for predefined workflows
+   */
+  PREDEFINED_WORKFLOW_PLANNING: `- Set \`init: true\` (steps are predefined)`,
+  /**
+   * Planning instructions for dynamic workflows
+   */
+  DYNAMIC_WORKFLOW_PLANNING: `- Set \`init: true\` and define complete \`steps\` array`,
+  /**
+   * Next step decision prompt
+   */
+  NEXT_STEP_DECISION: `**Next Step Decision Required**
+
+Previous step completed. Choose your action:
+
+**\u{1F504} RETRY Current Step:** 
+- Call \`{toolName}\` with current parameters
+- \u26A0\uFE0F CRITICAL: Set \`decision: "retry"\`
+
+**\u25B6\uFE0F PROCEED to Next Step:** 
+- Call \`{toolName}\` with parameters below
+- Set \`decision: "proceed"\`
+
+Next step: \`{nextStepDescription}\`
+
+{nextStepSchema}
+
+**Important:** Exclude \`steps\` key from parameters`,
+  /**
+   * Final step completion prompt
+   */
+  FINAL_STEP_COMPLETION: `**Final Step Complete** {statusIcon}
+
+Step executed {statusText}. Choose action:
+
+**\u{1F504} RETRY:** Call \`{toolName}\` with \`decision: "retry"\`
+**\u2705 COMPLETE:** Call \`{toolName}\` with \`decision: "complete"\`
+**\u{1F195} NEW:** Call \`{toolName}\` with \`init: true\`{newWorkflowInstructions}`,
+  /**
+   * Workflow completion success message
+   */
+  WORKFLOW_COMPLETED: `**Workflow Completed Successfully** \u2705
+
+All workflow steps have been executed and the workflow is now complete.
+
+**Summary:**
+- Total steps: {totalSteps}
+- All steps executed successfully
+
+Agent can now start a new workflow if needed by calling \`{toolName}\` with \`init: true\`{newWorkflowInstructions}.`,
+  /**
+   * Error messages
+   */
+  ERRORS: {
+    NOT_INITIALIZED: {
+      WITH_PREDEFINED: "Error: Workflow not initialized. Please provide 'init' parameter to start a new workflow.",
+      WITHOUT_PREDEFINED: "Error: Workflow not initialized. Please provide 'init' and 'steps' parameter to start a new workflow."
+    },
+    ALREADY_AT_FINAL: "Error: Cannot proceed, already at the final step.",
+    CANNOT_COMPLETE_NOT_AT_FINAL: "Error: Cannot complete workflow - you are not at the final step. Please use decision=proceed to continue to the next step.",
+    NO_STEPS_PROVIDED: "Error: No steps provided",
+    NO_CURRENT_STEP: "Error: No current step to execute"
+  }
+};
+var ResponseTemplates = {
+  /**
+   * Success response for action execution
+   */
+  ACTION_SUCCESS: `**Action Completed Successfully** \u2705
+
+Previous action (\`{currentAction}\`) executed successfully. 
+
+**Next Action Required:** \`{nextAction}\`
+
+Agent MUST call tool \`{toolName}\` again with the \`{nextAction}\` action to continue the autonomous execution sequence.
+
+**Instructions:**
+- Analyze the result from previous action: \`{currentAction}\`
+- Execute the next planned action: \`{nextAction}\`
+- Maintain execution context and progress toward the final goal`,
+  /**
+   * Planning prompt when no next action is specified
+   */
+  PLANNING_PROMPT: `**Action Evaluation & Planning Required** \u{1F3AF}
+
+Previous action (\`{currentAction}\`) completed. You need to determine the next step.
+
+**Evaluation & Planning Process:**
+1. **Analyze Results:** Review the outcome of \`{currentAction}\`
+2. **Assess Progress:** Determine how close you are to fulfilling the user request
+3. **Plan Next Action:** Identify the most appropriate next action (if needed)
+4. **Execute Decision:** Call \`{toolName}\` with the planned action
+
+**Options:**
+- **Continue:** If more actions are needed to fulfill the request
+- **Complete:** If the user request has been fully satisfied
+
+Choose the next action that best advances toward completing the user's request.`,
+  /**
+   * Error response template
+   */
+  ERROR_RESPONSE: `Action argument validation failed: {errorMessage}`,
+  WORKFLOW_ERROR_RESPONSE: `Action argument validation failed: {errorMessage}
+Set \`decision: "retry"\` to retry the current step, or check your parameters and try again.`,
+  /**
+   * Completion message
+   */
+  COMPLETION_MESSAGE: `Completed, no dependent actions to execute`,
+  /**
+   * Security validation messages
+   */
+  SECURITY_VALIDATION: {
+    PASSED: `Security validation PASSED for {operation} on {path}`,
+    FAILED: `Security validation FAILED for {operation} on {path}`
+  },
+  /**
+   * Audit log messages
+   */
+  AUDIT_LOG: `Audit log entry created: [{timestamp}] {level}: {action} on {resource}{userInfo}`
+};
+var CompiledPrompts = {
+  autonomousExecution: p(SystemPrompts.AUTONOMOUS_EXECUTION),
+  workflowExecution: p(SystemPrompts.WORKFLOW_EXECUTION),
+  samplingExecution: p(SystemPrompts.SAMPLING_EXECUTION),
+  samplingWorkflowExecution: p(SystemPrompts.SAMPLING_WORKFLOW_EXECUTION),
+  workflowInit: p(WorkflowPrompts.WORKFLOW_INIT),
+  workflowToolDescription: p(WorkflowPrompts.WORKFLOW_TOOL_DESCRIPTION),
+  nextStepDecision: p(WorkflowPrompts.NEXT_STEP_DECISION),
+  finalStepCompletion: p(WorkflowPrompts.FINAL_STEP_COMPLETION),
+  workflowCompleted: p(WorkflowPrompts.WORKFLOW_COMPLETED),
+  actionSuccess: p(ResponseTemplates.ACTION_SUCCESS),
+  planningPrompt: p(ResponseTemplates.PLANNING_PROMPT),
+  errorResponse: p(ResponseTemplates.ERROR_RESPONSE),
+  workflowErrorResponse: p(ResponseTemplates.WORKFLOW_ERROR_RESPONSE),
+  securityPassed: p(ResponseTemplates.SECURITY_VALIDATION.PASSED),
+  securityFailed: p(ResponseTemplates.SECURITY_VALIDATION.FAILED),
+  auditLog: p(ResponseTemplates.AUDIT_LOG),
+  completionMessage: () => ResponseTemplates.COMPLETION_MESSAGE
+};
+var PromptUtils = {
+  /**
+   * Generate tool list for descriptions
+   */
+  generateToolList: (tools) => {
+    return tools.filter((tool) => !tool.hide).map((tool) => `<tool name="${tool.name}"${tool.description ? ` description="${tool.description}"` : ""}/>`).join("\n");
+  },
+  /**
+   * Generate hidden tool list for descriptions
+   */
+  generateHiddenToolList: (tools) => {
+    return tools.filter((tool) => tool.hide).map((tool) => `<tool name="${tool.name}" hide/>`).join("\n");
+  },
+  /**
+   * Format workflow steps for display
+   */
+  formatWorkflowSteps: (steps) => {
+    if (!steps.length) return "";
+    return `## Workflow Steps
+${JSON.stringify(steps, null, 2)}`;
+  },
+  /**
+   * Format workflow progress display with status icons
+   */
+  formatWorkflowProgress: (progressData) => {
+    const statusIcons = {
+      pending: "\u23F3",
+      running: "\u{1F504}",
+      completed: "\u2705",
+      failed: "\u274C"
+    };
+    return progressData.steps.map((step, index) => {
+      const status = progressData.statuses[index] || "pending";
+      const icon = statusIcons[status] || "\u23F3";
+      const current = index === progressData.currentStepIndex ? " **[CURRENT]**" : "";
+      const actions = step.actions.length > 0 ? ` | Action: ${step.actions.join(", ")}` : "";
+      return `${icon} **Step ${index + 1}:** ${step.description}${actions}${current}`;
+    }).join("\n");
+  },
+  /**
+   * Generate user info for audit logs
+   */
+  formatUserInfo: (user) => {
+    return user ? ` by ${user}` : "";
+  },
+  /**
+   * Format timestamp for logs
+   */
+  formatTimestamp: () => {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+};
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-executor.js
+import { Ajv } from "ajv";
+import { AggregateAjvError } from "@segment/ajv-human-errors";
+import addFormats from "ajv-formats";
+var ajv = new Ajv({
+  allErrors: true,
+  verbose: true
+});
+addFormats(ajv);
+var AgenticExecutor = class {
+  name;
+  allToolNames;
+  toolNameToDetailList;
+  server;
+  ACTION_KEY;
+  NEXT_ACTION_KEY;
+  constructor(name, allToolNames, toolNameToDetailList, server2, ACTION_KEY = "action", NEXT_ACTION_KEY = "nextAction") {
+    this.name = name;
+    this.allToolNames = allToolNames;
+    this.toolNameToDetailList = toolNameToDetailList;
+    this.server = server2;
+    this.ACTION_KEY = ACTION_KEY;
+    this.NEXT_ACTION_KEY = NEXT_ACTION_KEY;
+  }
+  async execute(args, schema) {
+    const validationResult = this.validate(args, schema);
+    if (!validationResult.valid) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: CompiledPrompts.errorResponse({
+              errorMessage: validationResult.error || "Validation failed"
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+    const actionName = args[this.ACTION_KEY];
+    const currentTool = this.toolNameToDetailList.find(([name, _detail]) => name === actionName)?.[1];
+    if (currentTool) {
+      const nextAction = args[this.NEXT_ACTION_KEY];
+      const currentResult = await currentTool.execute({
+        ...args[actionName]
+      });
+      if (args[nextAction]) {
+        currentResult?.content?.push({
+          type: "text",
+          text: CompiledPrompts.actionSuccess({
+            toolName: this.name,
+            nextAction,
+            currentAction: actionName
+          })
+        });
+      } else {
+        currentResult?.content?.push({
+          type: "text",
+          text: CompiledPrompts.planningPrompt({
+            currentAction: actionName
+          })
+        });
+      }
+      return currentResult;
+    }
+    if (this.allToolNames.includes(actionName)) {
+      try {
+        const result = await this.server.callTool(actionName, args[actionName]);
+        const nextAction = args[this.NEXT_ACTION_KEY];
+        const callToolResult = result ?? {
+          content: []
+        };
+        if (nextAction && this.allToolNames.includes(nextAction)) {
+          callToolResult.content.push({
+            type: "text",
+            text: CompiledPrompts.actionSuccess({
+              toolName: this.name,
+              nextAction,
+              currentAction: actionName
+            })
+          });
+        } else {
+          callToolResult.content.push({
+            type: "text",
+            text: CompiledPrompts.planningPrompt({
+              currentAction: actionName
+            })
+          });
+        }
+        return callToolResult;
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error executing internal tool ${actionName}: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: CompiledPrompts.completionMessage()
+        }
+      ]
+    };
+  }
+  // Validate arguments using JSON schema
+  validate(args, schema) {
+    if (args.decision === "complete") {
+      return {
+        valid: true
+      };
+    }
+    const validate = ajv.compile(schema);
+    if (!validate(args)) {
+      const errors = new AggregateAjvError(validate.errors);
+      return {
+        valid: false,
+        error: errors.message
+      };
+    }
+    return {
+      valid: true
+    };
+  }
+};
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/es-toolkit__es-toolkit/src/function/partial.js
+function partial(func, ...partialArgs) {
+  return partialImpl(func, placeholderSymbol, ...partialArgs);
+}
+function partialImpl(func, placeholder, ...partialArgs) {
+  const partialed = function(...providedArgs) {
+    let providedArgsIndex = 0;
+    const substitutedArgs = partialArgs.slice().map((arg) => arg === placeholder ? providedArgs[providedArgsIndex++] : arg);
+    const remainingArgs = providedArgs.slice(providedArgsIndex);
+    return func.apply(this, substitutedArgs.concat(remainingArgs));
+  };
+  if (func.prototype) {
+    partialed.prototype = Object.create(func.prototype);
+  }
+  return partialed;
+}
+var placeholderSymbol = Symbol("partial.placeholder");
+partial.placeholder = placeholderSymbol;
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/es-toolkit__es-toolkit/src/function/partialRight.js
+function partialRight(func, ...partialArgs) {
+  return partialRightImpl(func, placeholderSymbol2, ...partialArgs);
+}
+function partialRightImpl(func, placeholder, ...partialArgs) {
+  const partialedRight = function(...providedArgs) {
+    const placeholderLength = partialArgs.filter((arg) => arg === placeholder).length;
+    const rangeLength = Math.max(providedArgs.length - placeholderLength, 0);
+    const remainingArgs = providedArgs.slice(0, rangeLength);
+    let providedArgsIndex = rangeLength;
+    const substitutedArgs = partialArgs.slice().map((arg) => arg === placeholder ? providedArgs[providedArgsIndex++] : arg);
+    return func.apply(this, remainingArgs.concat(substitutedArgs));
+  };
+  if (func.prototype) {
+    partialedRight.prototype = Object.create(func.prototype);
+  }
+  return partialedRight;
+}
+var placeholderSymbol2 = Symbol("partialRight.placeholder");
+partialRight.placeholder = placeholderSymbol2;
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/es-toolkit__es-toolkit/src/function/retry.js
+var DEFAULT_RETRIES = Number.POSITIVE_INFINITY;
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/es-toolkit__es-toolkit/src/object/pick.js
+function pick(obj, keys) {
+  const result = {};
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (Object.hasOwn(obj, key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/es-toolkit__es-toolkit/src/string/deburr.js
+var deburrMap = new Map(
+  // eslint-disable-next-line no-restricted-syntax
+  Object.entries({
+    \u00C6: "Ae",
+    \u00D0: "D",
+    \u00D8: "O",
+    \u00DE: "Th",
+    \u00DF: "ss",
+    \u00E6: "ae",
+    \u00F0: "d",
+    \u00F8: "o",
+    \u00FE: "th",
+    \u0110: "D",
+    \u0111: "d",
+    \u0126: "H",
+    \u0127: "h",
+    \u0131: "i",
+    \u0132: "IJ",
+    \u0133: "ij",
+    \u0138: "k",
+    \u013F: "L",
+    \u0140: "l",
+    \u0141: "L",
+    \u0142: "l",
+    \u0149: "'n",
+    \u014A: "N",
+    \u014B: "n",
+    \u0152: "Oe",
+    \u0153: "oe",
+    \u0166: "T",
+    \u0167: "t",
+    \u017F: "s"
+  })
+);
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/factories/args-def-factory.js
+var DECISION_OPTIONS = {
+  RETRY: "retry",
+  PROCEED: "proceed",
+  COMPLETE: "complete"
+};
+function createArgsDefFactory(name, allToolNames, depGroups, predefinedSteps, ensureStepActions) {
+  const formatEnsureStepActions = () => {
+    if (!ensureStepActions || ensureStepActions.length === 0) {
+      return "";
+    }
+    return `
+
+## Required Actions
+The workflow MUST include at least one of these actions:
+${ensureStepActions.map((action) => `- \`${action}\``).join("\n")}`;
+  };
+  return {
+    common: (extra, optionalFields = []) => {
+      const requiredFields = Object.keys(extra).filter((key) => !optionalFields.includes(key));
+      return {
+        type: "object",
+        description: `**Tool parameters dynamically update per workflow step**`,
+        properties: {
+          ...extra
+        },
+        required: requiredFields
+      };
+    },
+    steps: () => ({
+      type: "array",
+      description: `
+Workflow step definitions - provide ONLY on initial call.
+
+**CRITICAL RULES:**
+- **Sequential Dependency:** If Action B depends on Action A's result \u2192 separate steps
+- **Concurrent Actions:** Independent actions can share one step  
+- **Complete Mapping:** Include ALL requested operations
+- **Predefined Steps:** Leave unspecified if predefined steps exist
+
+**BEST PRACTICES:**
+- Atomic, focused steps
+- Idempotent actions for safe retries
+- Clear step descriptions with input/output context`,
+      items: {
+        type: "object",
+        description: `A single step containing actions that execute concurrently. All actions in this step run simultaneously with no guaranteed order.`,
+        properties: {
+          description: {
+            type: "string",
+            description: `**Step purpose, required inputs, and expected outputs**`
+          },
+          actions: {
+            type: "array",
+            description: `Array of action names for this step. **CURRENT LIMITATION: Only 1 action per step is allowed.** Action names must match available tool names exactly.`,
+            items: {
+              ...{
+                enum: allToolNames
+              },
+              type: "string",
+              description: `Individual action name from available tools. Must be exactly one of the allowed tool names.`
+            },
+            uniqueItems: true,
+            minItems: 0,
+            // TODO: remove this restriction when workflow planning is good enough
+            maxItems: 1
+          }
+        },
+        required: [
+          "description",
+          "actions"
+        ],
+        additionalProperties: false
+      },
+      default: predefinedSteps ? predefinedSteps : void 0,
+      minItems: 1
+    }),
+    init: () => ({
+      type: "boolean",
+      description: `Init a new workflow`,
+      enum: [
+        true
+      ]
+    }),
+    decision: () => ({
+      type: "string",
+      enum: Object.values(DECISION_OPTIONS),
+      description: `**Step control: \`${DECISION_OPTIONS.PROCEED}\` = next step, \`${DECISION_OPTIONS.RETRY}\` = retry/repeat current, \`${DECISION_OPTIONS.COMPLETE}\` = finish workflow**`
+    }),
+    action: () => ({
+      type: "string",
+      description: "Define the current workflow action to be performed",
+      enum: allToolNames,
+      required: [
+        "action"
+      ]
+    }),
+    forTool: function() {
+      return this.common({});
+    },
+    forCurrentState: function(state) {
+      const currentStep = state.getCurrentStep();
+      if (!state.isWorkflowInitialized() || !currentStep) {
+        state.reset();
+        const initSchema = {
+          init: this.init()
+        };
+        if (!predefinedSteps) {
+          initSchema.steps = this.steps();
+        }
+        return this.common(initSchema);
+      }
+      const stepDependencies = {
+        ...pick(depGroups, currentStep.actions)
+      };
+      stepDependencies["decision"] = this.decision();
+      stepDependencies["action"] = this.action();
+      return this.common(stepDependencies);
+    },
+    forSampling: function() {
+      return {
+        type: "object",
+        description: "Provide user request for autonomous tool execution",
+        properties: {
+          userRequest: {
+            type: "string",
+            description: "The task or request that should be completed autonomously by the agentic system using available tools"
+          }
+        },
+        required: [
+          "userRequest"
+        ]
+      };
+    },
+    forAgentic: function(toolNameToDetailList, _sampling = false, ACTION_KEY = "action", NEXT_ACTION_KEY = "nextAction") {
+      const allOf = toolNameToDetailList.map(([toolName, _toolDetail]) => {
+        return {
+          if: {
+            properties: {
+              [ACTION_KEY]: {
+                const: toolName
+              }
+            },
+            required: [
+              ACTION_KEY
+            ]
+          },
+          then: {
+            required: [
+              toolName
+            ]
+          }
+        };
+      });
+      const actionDescription = `Specifies the action to be performed from the enum. **\u26A0\uFE0F When setting \`action: "example_action"\`, you MUST also provide \`"example_action": { ... }\`**`;
+      const baseProperties = {
+        [ACTION_KEY]: {
+          type: "string",
+          enum: allToolNames,
+          description: actionDescription
+        },
+        [NEXT_ACTION_KEY]: {
+          type: "string",
+          enum: allToolNames,
+          description: "Optional: Specify the next action to execute. Only include this when you know additional actions are needed after the current one completes."
+        },
+        decision: this.decision(),
+        ...depGroups
+      };
+      const requiredFields = [
+        ACTION_KEY,
+        "decision"
+      ];
+      const schema = {
+        additionalProperties: false,
+        type: "object",
+        properties: baseProperties,
+        required: requiredFields
+      };
+      if (allOf.length > 0) {
+        schema.allOf = allOf;
+      }
+      return schema;
+    },
+    forNextState: function(state) {
+      if (!state.isWorkflowInitialized() || !state.hasNextStep()) {
+        throw new Error(`Cannot get next state schema: no next step available`);
+      }
+      const currentStepIndex = state.getCurrentStepIndex();
+      const allSteps = state.getSteps();
+      const nextStep = allSteps[currentStepIndex + 1];
+      if (!nextStep) {
+        throw new Error(`Next step not found`);
+      }
+      const stepDependencies = {
+        ...pick(depGroups, nextStep.actions)
+      };
+      stepDependencies["decision"] = this.decision();
+      stepDependencies["action"] = this.action();
+      return this.common(stepDependencies);
+    },
+    forToolDescription: function(description, state) {
+      const enforceToolArgs = this.forCurrentState(state);
+      const initTitle = predefinedSteps ? `**YOU MUST execute this tool with following tool arguments to init the workflow**
+NOTE: The \`steps\` has been predefined` : `**You MUST execute this tool with following tool arguments to plan and init the workflow**`;
+      return CompiledPrompts.workflowToolDescription({
+        description,
+        initTitle,
+        ensureStepActions: formatEnsureStepActions(),
+        schemaDefinition: JSON.stringify(enforceToolArgs, null, 2)
+      });
+    },
+    forInitialStepDescription: function(steps, state) {
+      return CompiledPrompts.workflowInit({
+        stepCount: steps.length.toString(),
+        currentStepDescription: state.getCurrentStep()?.description || "",
+        toolName: name,
+        schemaDefinition: JSON.stringify(this.forCurrentState(state), null, 2),
+        // Remove redundant workflow steps display
+        workflowSteps: ""
+      });
+    }
+  };
+}
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/sampling/base-sampling-executor.js
+import { Ajv as Ajv2 } from "ajv";
+import { AggregateAjvError as AggregateAjvError2 } from "@segment/ajv-human-errors";
+import addFormats2 from "ajv-formats";
+import { inspect as inspect2 } from "node:util";
+var ajv2 = new Ajv2({
+  allErrors: true,
+  verbose: true
+});
+addFormats2(ajv2);
+var BaseSamplingExecutor = class {
+  name;
+  description;
+  allToolNames;
+  toolNameToDetailList;
+  server;
+  conversationHistory;
+  maxIterations;
+  currentIteration;
+  constructor(name, description, allToolNames, toolNameToDetailList, server2, config2) {
+    this.name = name;
+    this.description = description;
+    this.allToolNames = allToolNames;
+    this.toolNameToDetailList = toolNameToDetailList;
+    this.server = server2;
+    this.conversationHistory = [];
+    this.maxIterations = 33;
+    this.currentIteration = 0;
+    if (config2?.maxIterations) {
+      this.maxIterations = config2.maxIterations;
+    }
+  }
+  async runSamplingLoop(systemPrompt, schema, state) {
+    this.conversationHistory = [];
+    try {
+      for (this.currentIteration = 0; this.currentIteration < this.maxIterations; this.currentIteration++) {
+        const response = await this.server.createMessage({
+          systemPrompt: systemPrompt(),
+          messages: this.conversationHistory,
+          maxTokens: Number.MAX_SAFE_INTEGER
+        });
+        const responseContent = response.content.text || "{}";
+        let parsedData;
+        try {
+          parsedData = parseJSON(responseContent.trim(), true);
+        } catch (parseError) {
+          this.addParsingErrorToHistory(responseContent, parseError);
+          continue;
+        }
+        if (parsedData) {
+          this.conversationHistory.push({
+            role: "assistant",
+            content: {
+              type: "text",
+              text: JSON.stringify(parsedData, null, 2)
+            }
+          });
+        }
+        const result = await this.processAction(parsedData, schema, state);
+        this.logIterationProgress(parsedData, result);
+        if (result.isError) {
+          this.conversationHistory.push({
+            role: "user",
+            content: {
+              type: "text",
+              text: result.content[0].text
+            }
+          });
+          continue;
+        }
+        if (result.isComplete) {
+          return result;
+        }
+      }
+      return this.createMaxIterationsError();
+    } catch (error) {
+      return this.createExecutionError(error);
+    }
+  }
+  addParsingErrorToHistory(responseText, parseError) {
+    this.conversationHistory.push({
+      role: "assistant",
+      content: {
+        type: "text",
+        text: `JSON parsing failed. Response was: ${responseText}`
+      }
+    });
+    this.conversationHistory.push({
+      role: "user",
+      content: {
+        type: "text",
+        text: CompiledPrompts.errorResponse({
+          errorMessage: `JSON parsing failed: ${parseError instanceof Error ? parseError.message : String(parseError)}
+
+Please respond with valid JSON.`
+        })
+      }
+    });
+  }
+  createMaxIterationsError() {
+    const result = this.createCompletionResult(`Action argument validation failed: Execution reached maximum iterations (${this.maxIterations}). Please try with a more specific request or break down the task into smaller parts.`);
+    return {
+      ...result,
+      isError: true,
+      isComplete: false
+    };
+  }
+  createExecutionError(error) {
+    const errorMessage = `Sampling execution error: ${error instanceof Error ? error.message : String(error)}`;
+    const result = this.createCompletionResult(errorMessage);
+    return {
+      ...result,
+      isError: true,
+      isComplete: false
+    };
+  }
+  createCompletionResult(text) {
+    const conversationDetails = this.getConversationDetails();
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Task Completed
+${text}
+**Execution Summary:**
+- Iterations used: ${this.currentIteration + 1}/${this.maxIterations}
+- Agent: ${this.name}${conversationDetails}`
+        }
+      ],
+      isError: false,
+      isComplete: true
+    };
+  }
+  getConversationDetails() {
+    if (this.conversationHistory.length === 0) {
+      return "\n\n**No conversation history available**";
+    }
+    let details = "\n\n**Detailed Conversation History:**";
+    this.conversationHistory.forEach((message) => {
+      if (message.role === "assistant") {
+        try {
+          const parsed = JSON.parse(message.content.text);
+          details += "\n```json\n" + JSON.stringify(parsed, null, 2) + "\n```";
+        } catch {
+          details += "\n```\n" + message.content.text + "\n```";
+        }
+      } else {
+        details += "\n```\n" + message.content.text + "\n```";
+      }
+    });
+    return details;
+  }
+  logIterationProgress(parsedData, result) {
+    console.log(`Iteration ${this.currentIteration + 1}/${this.maxIterations}:`, {
+      parsedData,
+      isError: result.isError,
+      isComplete: result.isComplete,
+      result: inspect2(result, {
+        depth: 5,
+        maxArrayLength: 10,
+        breakLength: 120,
+        compact: true,
+        maxStringLength: 120
+      })
+    });
+  }
+  injectJsonInstruction({ prompt, schema, schemaPrefix = "JSON schema:", schemaSuffix = `STRICT REQUIREMENTS:
+1. Return ONLY raw JSON that passes JSON.parse() - no markdown, code blocks, explanatory text, or extra characters
+2. Include ALL required fields with correct data types and satisfy ALL schema constraints (anyOf, oneOf, allOf, not, enum, pattern, min/max, conditionals)
+3. Your response must be the JSON object itself, nothing else
+
+INVALID: \`\`\`json{"key":"value"}\`\`\` or "Here is: {"key":"value"}"
+VALID: {"key":"value"}` }) {
+    return [
+      prompt != null && prompt.length > 0 ? prompt : void 0,
+      prompt != null && prompt.length > 0 ? "" : void 0,
+      schemaPrefix,
+      schema != null ? JSON.stringify(schema, null, 2) : void 0,
+      schemaSuffix
+    ].filter((line) => line != null).join("\n");
+  }
+  // Validate arguments using JSON schema
+  validateSchema(args, schema) {
+    const validate = ajv2.compile(schema);
+    if (!validate(args)) {
+      const errors = new AggregateAjvError2(validate.errors);
+      return {
+        valid: false,
+        error: errors.message
+      };
+    }
+    return {
+      valid: true
+    };
+  }
+};
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/sampling/agentic-sampling-executor.js
+var SamplingExecutor = class extends BaseSamplingExecutor {
+  agenticExecutor;
+  constructor(name, description, allToolNames, toolNameToDetailList, server2, config2) {
+    super(name, description, allToolNames, toolNameToDetailList, server2, config2);
+    this.agenticExecutor = new AgenticExecutor(name, allToolNames, toolNameToDetailList, server2);
+  }
+  buildDepGroups() {
+    const depGroups = {};
+    this.toolNameToDetailList.forEach(([toolName, tool]) => {
+      if (tool?.inputSchema) {
+        depGroups[toolName] = {
+          type: "object",
+          description: tool.description || `Tool: ${toolName}`,
+          ...tool.inputSchema
+        };
+      } else {
+        const toolSchema = this.server.getInternalToolSchema(toolName);
+        if (toolSchema) {
+          depGroups[toolName] = {
+            ...toolSchema.schema,
+            description: toolSchema.description
+          };
+        }
+      }
+    });
+    return depGroups;
+  }
+  executeSampling(args, schema) {
+    const validationResult = this.validateSchema(args, schema);
+    if (!validationResult.valid) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: CompiledPrompts.errorResponse({
+              errorMessage: validationResult.error || "Validation failed"
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+    const createArgsDef = createArgsDefFactory(this.name, this.allToolNames, this.buildDepGroups(), void 0, void 0);
+    const agenticSchema = createArgsDef.forAgentic(this.toolNameToDetailList, true);
+    const systemPrompt = this.buildSystemPrompt(args.userRequest, agenticSchema);
+    return this.runSamplingLoop(() => systemPrompt, agenticSchema);
+  }
+  async processAction(parsedData, schema) {
+    const toolCallData = parsedData;
+    if (toolCallData.decision === "complete") {
+      return this.createCompletionResult("Task completed");
+    }
+    try {
+      const { action: _action, decision: _decision, ..._toolArgs } = toolCallData;
+      const toolResult = await this.agenticExecutor.execute(toolCallData, schema);
+      const resultText = toolResult.content?.filter((content) => content.type === "text")?.map((content) => content.text)?.join("\n") || "No result";
+      this.conversationHistory.push({
+        role: "assistant",
+        content: {
+          type: "text",
+          text: resultText
+        }
+      });
+      return toolResult;
+    } catch (error) {
+      return this.createExecutionError(error);
+    }
+  }
+  buildSystemPrompt(userRequest, agenticSchema) {
+    const toolList = this.allToolNames.map((name) => {
+      const tool = this.toolNameToDetailList.find(([toolName]) => toolName === name);
+      const toolSchema = this.server.getInternalToolSchema(name);
+      if (tool && tool[1]) {
+        return `- ${name}: ${tool[1].description || `Tool: ${name}`}`;
+      } else if (toolSchema) {
+        return `- ${name}: ${toolSchema.description}`;
+      }
+      return `- ${name}`;
+    }).join("\n");
+    const basePrompt = CompiledPrompts.samplingExecution({
+      toolName: this.name,
+      description: this.description,
+      toolList
+    });
+    const taskPrompt = `
+
+## Current Task
+I will now use agentic sampling to complete the following task: "${userRequest}"
+
+When I need to use a tool, I should specify the tool name in 'action' and provide tool-specific parameters as additional properties.
+When the task is complete, I should use "action": "complete".`;
+    return this.injectJsonInstruction({
+      prompt: basePrompt + taskPrompt,
+      schema: agenticSchema
+    });
+  }
+};
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-tool-registrar.js
+function registerAgenticTool(server2, { description, name, allToolNames, depGroups, toolNameToDetailList, sampling = false }) {
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
+  const isSamplingMode = sampling === true || typeof sampling === "object";
+  const samplingConfig = typeof sampling === "object" ? sampling : void 0;
+  const agenticExecutor = new AgenticExecutor(name, allToolNames, toolNameToDetailList, server2);
+  const samplingExecutor = new SamplingExecutor(name, description, allToolNames, toolNameToDetailList, server2, samplingConfig);
+  description = isSamplingMode ? CompiledPrompts.samplingExecution({
+    toolName: name,
+    description,
+    toolList: allToolNames.map((name2) => `- ${name2}`).join("\n")
+  }) : CompiledPrompts.autonomousExecution({
+    toolName: name,
+    description
+  });
+  const agenticArgsDef = createArgsDef.forAgentic(toolNameToDetailList, false);
+  const argsDef = isSamplingMode ? createArgsDef.forSampling() : agenticArgsDef;
+  const schema = allToolNames.length > 0 ? argsDef : {
+    type: "object",
+    properties: {}
+  };
+  server2.tool(name, description, jsonSchema(createGoogleCompatibleJSONSchema(schema)), async (args) => {
+    if (isSamplingMode) {
+      return await samplingExecutor.executeSampling(args, schema);
+    } else {
+      return await agenticExecutor.execute(args, schema);
+    }
+  });
+}
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-tool-registrar.js
+import { jsonSchema as jsonSchema2 } from "ai";
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/utils/state.js
+var WorkflowState = class {
+  currentStepIndex = -1;
+  steps = [];
+  stepStatuses = [];
+  stepResults = [];
+  stepErrors = [];
+  isInitialized = false;
+  isStarted = false;
+  constructor(steps) {
+    if (steps) {
+      this.initialize(steps);
+    }
+  }
+  getCurrentStepIndex() {
+    return this.currentStepIndex;
+  }
+  getSteps() {
+    return this.steps;
+  }
+  isWorkflowInitialized() {
+    return this.isInitialized;
+  }
+  getCurrentStep() {
+    if (!this.isInitialized || this.currentStepIndex < 0) {
+      return null;
+    }
+    return this.steps[this.currentStepIndex] || null;
+  }
+  getNextStep() {
+    if (!this.isInitialized) return null;
+    const nextIndex = this.currentStepIndex + 1;
+    return this.steps[nextIndex] || null;
+  }
+  // Get the previous step in the workflow
+  getPreviousStep() {
+    if (!this.isInitialized) return null;
+    const prevIndex = this.currentStepIndex - 1;
+    return this.steps[prevIndex] || null;
+  }
+  hasNextStep() {
+    return this.getNextStep() !== null;
+  }
+  // Check if there is a previous step available
+  hasPreviousStep() {
+    return this.getPreviousStep() !== null;
+  }
+  // Check if currently at the first step
+  isAtFirstStep() {
+    return this.isInitialized && this.currentStepIndex === 0;
+  }
+  // Check if currently at the last step
+  isAtLastStep() {
+    return this.isInitialized && this.currentStepIndex >= this.steps.length - 1;
+  }
+  isWorkflowStarted() {
+    return this.isStarted;
+  }
+  isCompleted() {
+    return this.isInitialized && this.currentStepIndex > this.steps.length - 1;
+  }
+  // Mark workflow as completed by moving beyond the last step
+  markCompleted() {
+    if (this.isInitialized) {
+      this.currentStepIndex = this.steps.length;
+    }
+  }
+  initialize(steps) {
+    this.steps = steps;
+    this.stepStatuses = new Array(steps.length).fill("pending");
+    this.stepResults = new Array(steps.length).fill("");
+    this.stepErrors = new Array(steps.length).fill("");
+    this.currentStepIndex = 0;
+    this.isInitialized = true;
+    this.isStarted = false;
+  }
+  // Mark current step as running
+  markCurrentStepRunning() {
+    if (this.isInitialized && this.currentStepIndex >= 0 && this.currentStepIndex < this.steps.length) {
+      this.stepStatuses[this.currentStepIndex] = "running";
+    }
+  }
+  // Mark current step as completed
+  markCurrentStepCompleted(result) {
+    if (this.isInitialized && this.currentStepIndex >= 0 && this.currentStepIndex < this.steps.length) {
+      this.stepStatuses[this.currentStepIndex] = "completed";
+      if (result) {
+        this.stepResults[this.currentStepIndex] = result;
+      }
+    }
+  }
+  // Mark current step as failed
+  markCurrentStepFailed(error) {
+    if (this.isInitialized && this.currentStepIndex >= 0 && this.currentStepIndex < this.steps.length) {
+      this.stepStatuses[this.currentStepIndex] = "failed";
+      if (error) {
+        this.stepErrors[this.currentStepIndex] = error;
+      }
+    }
+  }
+  // Get steps with their status
+  getStepsWithStatus() {
+    return this.steps.map((step, index) => ({
+      ...step,
+      status: this.stepStatuses[index] || "pending",
+      result: this.stepResults[index] || void 0,
+      error: this.stepErrors[index] || void 0
+    }));
+  }
+  // Get basic workflow progress data for template rendering
+  getProgressData() {
+    return {
+      steps: this.steps,
+      statuses: this.stepStatuses,
+      results: this.stepResults,
+      errors: this.stepErrors,
+      currentStepIndex: this.currentStepIndex,
+      totalSteps: this.steps.length
+    };
+  }
+  start() {
+    this.isStarted = true;
+  }
+  moveToNextStep() {
+    if (!this.hasNextStep()) {
+      return false;
+    }
+    this.currentStepIndex++;
+    return true;
+  }
+  // Move to the previous step in the workflow
+  moveToPreviousStep() {
+    if (!this.hasPreviousStep()) {
+      return false;
+    }
+    this.currentStepIndex--;
+    return true;
+  }
+  // Move to a specific step by index (optional feature)
+  moveToStep(stepIndex) {
+    if (!this.isInitialized || stepIndex < 0 || stepIndex >= this.steps.length) {
+      return false;
+    }
+    this.currentStepIndex = stepIndex;
+    return true;
+  }
+  reset() {
+    this.currentStepIndex = -1;
+    this.steps = [];
+    this.stepStatuses = [];
+    this.stepResults = [];
+    this.stepErrors = [];
+    this.isInitialized = false;
+    this.isStarted = false;
+  }
+  getDebugInfo() {
+    return {
+      currentStepIndex: this.currentStepIndex,
+      totalSteps: this.steps.length,
+      isInitialized: this.isInitialized,
+      currentStep: this.getCurrentStep()?.description,
+      nextStep: this.getNextStep()?.description,
+      previousStep: this.getPreviousStep()?.description,
+      isAtFirstStep: this.isAtFirstStep(),
+      hasPreviousStep: this.hasPreviousStep()
+    };
+  }
+};
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-executor.js
+import { Ajv as Ajv3 } from "ajv";
+import { AggregateAjvError as AggregateAjvError3 } from "@segment/ajv-human-errors";
+import addFormats3 from "ajv-formats";
+var ajv3 = new Ajv3({
+  allErrors: true,
+  verbose: true
+});
+addFormats3(ajv3);
+var WorkflowExecutor = class {
+  name;
+  allToolNames;
+  toolNameToDetailList;
+  createArgsDef;
+  server;
+  predefinedSteps;
+  ensureStepActions;
+  toolNameToIdMapping;
+  constructor(name, allToolNames, toolNameToDetailList, createArgsDef, server2, predefinedSteps, ensureStepActions, toolNameToIdMapping) {
+    this.name = name;
+    this.allToolNames = allToolNames;
+    this.toolNameToDetailList = toolNameToDetailList;
+    this.createArgsDef = createArgsDef;
+    this.server = server2;
+    this.predefinedSteps = predefinedSteps;
+    this.ensureStepActions = ensureStepActions;
+    this.toolNameToIdMapping = toolNameToIdMapping;
+  }
+  // Helper method to validate required actions are present in workflow steps
+  validateRequiredActions(steps) {
+    if (!this.ensureStepActions || this.ensureStepActions.length === 0) {
+      return {
+        valid: true,
+        missing: []
+      };
+    }
+    const allStepActions = /* @__PURE__ */ new Set();
+    steps.forEach((step) => {
+      step.actions.forEach((action) => allStepActions.add(action));
+    });
+    const missing = [];
+    for (const requiredAction of this.ensureStepActions) {
+      if (allStepActions.has(requiredAction)) {
+        continue;
+      }
+      if (this.toolNameToIdMapping) {
+        const mappedToolId = this.toolNameToIdMapping.get(requiredAction);
+        if (mappedToolId && allStepActions.has(mappedToolId)) {
+          continue;
+        }
+      }
+      missing.push(requiredAction);
+    }
+    return {
+      valid: missing.length === 0,
+      missing
+    };
+  }
+  // Helper method to format workflow progress
+  formatProgress(state) {
+    const progressData = state.getProgressData();
+    return PromptUtils.formatWorkflowProgress(progressData);
+  }
+  async execute(args, state) {
+    if (args.init) {
+      state.reset();
+    } else {
+      if (!state.isWorkflowInitialized() && !args.init) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: this.predefinedSteps ? WorkflowPrompts.ERRORS.NOT_INITIALIZED.WITH_PREDEFINED : WorkflowPrompts.ERRORS.NOT_INITIALIZED.WITHOUT_PREDEFINED
+            }
+          ],
+          isError: true
+        };
+      }
+      const decision2 = args.decision;
+      if (decision2 === "proceed") {
+        if (state.isAtLastStep() && state.isWorkflowStarted()) {
+          state.markCompleted();
+          return {
+            content: [
+              {
+                type: "text",
+                text: `## Workflow Completed!
+
+${this.formatProgress(state)}
+
+${CompiledPrompts.workflowCompleted({
+                  totalSteps: state.getSteps().length,
+                  toolName: this.name,
+                  newWorkflowInstructions: this.predefinedSteps ? "" : " and new `steps` array"
+                })}`
+              }
+            ],
+            isError: false
+          };
+        }
+        if (state.isCompleted()) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: WorkflowPrompts.ERRORS.ALREADY_AT_FINAL
+              }
+            ],
+            isError: true
+          };
+        }
+        const currentStepIndex = state.getCurrentStepIndex();
+        const wasStarted = state.isWorkflowStarted();
+        if (state.isWorkflowStarted()) {
+          state.moveToNextStep();
+        } else {
+          state.start();
+        }
+        const nextStepValidationSchema = this.createArgsDef.forCurrentState(state);
+        const nextStepValidationResult = this.validate(args, nextStepValidationSchema);
+        if (!nextStepValidationResult.valid) {
+          if (wasStarted) {
+            state.moveToStep(currentStepIndex);
+          } else {
+            state.moveToStep(currentStepIndex);
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: CompiledPrompts.workflowErrorResponse({
+                  errorMessage: `Cannot proceed to next step: ${nextStepValidationResult.error || "Arguments validation failed"}`
+                })
+              }
+            ],
+            isError: true
+          };
+        }
+      } else if (decision2 === "complete") {
+        if (state.isAtLastStep() && state.isWorkflowStarted()) {
+          state.markCompleted();
+          return {
+            content: [
+              {
+                type: "text",
+                text: `## Workflow Completed!
+
+${this.formatProgress(state)}
+
+${CompiledPrompts.workflowCompleted({
+                  totalSteps: state.getSteps().length,
+                  toolName: this.name,
+                  newWorkflowInstructions: this.predefinedSteps ? "" : " and new `steps` array"
+                })}`
+              }
+            ],
+            isError: false
+          };
+        } else {
+          return {
+            content: [
+              {
+                type: "text",
+                text: WorkflowPrompts.ERRORS.CANNOT_COMPLETE_NOT_AT_FINAL
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    }
+    const decision = args.decision;
+    if (decision !== "proceed") {
+      const validationSchema = this.createArgsDef.forCurrentState(state);
+      const validationResult = this.validate(args, validationSchema);
+      if (!validationResult.valid) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: CompiledPrompts.workflowErrorResponse({
+                errorMessage: validationResult.error || "Arguments validation failed"
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+    if (args.init) {
+      return this.initialize(args, state);
+    }
+    return await this.executeStep(args, state);
+  }
+  initialize(args, state) {
+    const steps = args.steps ?? this.predefinedSteps;
+    if (!steps || steps.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: WorkflowPrompts.ERRORS.NO_STEPS_PROVIDED
+          }
+        ],
+        isError: true
+      };
+    }
+    const validation = this.validateRequiredActions(steps);
+    if (!validation.valid) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `## Workflow Validation Failed \u274C
+
+**Missing Required Actions:** The following actions must be included in the workflow steps:
+
+${validation.missing.map((action) => `- \`${this.toolNameToIdMapping?.get(action) ?? action}\``).join("\n")}`
+          }
+        ],
+        isError: true
+      };
+    }
+    state.initialize(steps);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `## Workflow Initialized
+${this.formatProgress(state)}
+${this.createArgsDef.forInitialStepDescription(steps, state)}`
+        }
+      ],
+      isError: false
+    };
+  }
+  async executeStep(args, state) {
+    const currentStep = state.getCurrentStep();
+    if (!currentStep) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: WorkflowPrompts.ERRORS.NO_CURRENT_STEP
+          }
+        ],
+        isError: true
+      };
+    }
+    state.markCurrentStepRunning();
+    const results = {
+      content: [],
+      isError: false
+    };
+    for (const action of currentStep.actions) {
+      try {
+        const actionArgs = args[action] || {};
+        const actionResult = await this.server.callTool(action, actionArgs);
+        if (!results.isError) {
+          results.isError = actionResult.isError;
+        }
+        results.content = results.content.concat(actionResult.content ?? []);
+        results.content.push({
+          type: "text",
+          text: `Action \`${action}\` executed ${actionResult.isError ? "\u274C **FAILED**" : "\u2705 **SUCCESS**"}:`
+        });
+      } catch (error) {
+        results.content.push({
+          type: "text",
+          text: `${error.message}`
+        });
+        results.content.push({
+          type: "text",
+          text: `Action \`${action}\` \u274C **FAILED** with error: `
+        });
+        results.isError = true;
+      }
+    }
+    if (results.isError) {
+      state.markCurrentStepFailed("Step execution failed");
+    } else {
+      state.markCurrentStepCompleted("Step completed successfully");
+    }
+    if (state.hasNextStep()) {
+      const nextStepArgsDef = this.createArgsDef.forNextState(state);
+      results.content.push({
+        type: "text",
+        text: CompiledPrompts.nextStepDecision({
+          toolName: this.name,
+          nextStepDescription: state.getNextStep()?.description || "Unknown step",
+          nextStepSchema: JSON.stringify(nextStepArgsDef, null, 2)
+        })
+      });
+    } else {
+      results.content.push({
+        type: "text",
+        text: CompiledPrompts.finalStepCompletion({
+          statusIcon: results.isError ? "\u274C" : "\u2705",
+          statusText: results.isError ? "with errors" : "successfully",
+          toolName: this.name,
+          newWorkflowInstructions: this.predefinedSteps ? "" : " and new `steps` array"
+        })
+      });
+    }
+    results.content.push({
+      type: "text",
+      text: `## Workflow Progress
+${this.formatProgress(state)}`
+    });
+    return results;
+  }
+  // Validate arguments using JSON schema
+  validate(args, schema) {
+    const validate = ajv3.compile(schema);
+    if (!validate(args)) {
+      const errors = new AggregateAjvError3(validate.errors);
+      return {
+        valid: false,
+        error: errors.message
+      };
+    }
+    return {
+      valid: true
+    };
+  }
+};
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/sampling/workflow-sampling-executor.js
+var WorkflowSamplingExecutor = class extends BaseSamplingExecutor {
+  createArgsDef;
+  predefinedSteps;
+  workflowExecutor;
+  constructor(name, description, allToolNames, toolNameToDetailList, createArgsDef, server2, predefinedSteps, config2) {
+    super(name, description, allToolNames, toolNameToDetailList, server2, config2), this.createArgsDef = createArgsDef, this.predefinedSteps = predefinedSteps;
+    this.workflowExecutor = new WorkflowExecutor(name, allToolNames, toolNameToDetailList, createArgsDef, server2, predefinedSteps);
+  }
+  async executeWorkflowSampling(args, schema, state) {
+    const validationResult = this.validateSchema(args, schema);
+    if (!validationResult.valid) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: CompiledPrompts.workflowErrorResponse({
+              errorMessage: validationResult.error || "Validation failed"
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+    return await this.runSamplingLoop(() => this.buildWorkflowSystemPrompt(args, state), schema, state);
+  }
+  async processAction(parsedData, _schema, state) {
+    const workflowState = state;
+    if (!workflowState) {
+      throw new Error("WorkflowState is required for workflow");
+    }
+    const toolCallData = parsedData;
+    if (toolCallData.decision === "complete") {
+      return this.createCompletionResult("Task completed");
+    }
+    try {
+      const workflowResult = await this.workflowExecutor.execute(parsedData, workflowState);
+      const resultText = workflowResult.content?.filter((content) => content.type === "text")?.map((content) => content.text)?.join("\n") || "No result";
+      this.conversationHistory.push({
+        role: "assistant",
+        content: {
+          type: "text",
+          text: resultText
+        }
+      });
+      return workflowResult;
+    } catch (error) {
+      return this.createExecutionError(error);
+    }
+  }
+  buildWorkflowSystemPrompt(args, state) {
+    const workflowSchema = this.createArgsDef.forCurrentState(state);
+    const basePrompt = CompiledPrompts.samplingWorkflowExecution({
+      toolName: this.name,
+      description: this.description,
+      workflowSchema: `${JSON.stringify(workflowSchema, null, 2)}`
+    });
+    const workflowPrompt = `
+
+Current Task: <user_request>${args.userRequest}</user_request>`;
+    return this.injectJsonInstruction({
+      prompt: basePrompt + workflowPrompt,
+      schema: workflowSchema
+    });
+  }
+};
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-tool-registrar.js
+function registerAgenticWorkflowTool(server2, { description, name, allToolNames, depGroups, toolNameToDetailList, predefinedSteps, sampling = false, ensureStepActions, toolNameToIdMapping }) {
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, predefinedSteps, ensureStepActions);
+  const isSamplingMode = sampling === true || typeof sampling === "object";
+  const samplingConfig = typeof sampling === "object" ? sampling : void 0;
+  const workflowExecutor = new WorkflowExecutor(name, allToolNames, toolNameToDetailList, createArgsDef, server2, predefinedSteps, ensureStepActions, toolNameToIdMapping);
+  const workflowSamplingExecutor = new WorkflowSamplingExecutor(name, description, allToolNames, toolNameToDetailList, createArgsDef, server2, predefinedSteps, samplingConfig);
+  const workflowState = new WorkflowState();
+  const planningInstructions = predefinedSteps ? "- Set `init: true` (steps are predefined)" : "- Set `init: true` and define complete `steps` array";
+  const baseDescription = isSamplingMode ? CompiledPrompts.samplingExecution({
+    toolName: name,
+    description,
+    toolList: allToolNames.map((name2) => `- ${name2}`).join("\n")
+  }) : CompiledPrompts.workflowExecution({
+    toolName: name,
+    description,
+    planningInstructions
+  });
+  const argsDef = isSamplingMode ? createArgsDef.forSampling() : createArgsDef.forTool();
+  const toolDescription = isSamplingMode ? baseDescription : createArgsDef.forToolDescription(baseDescription, workflowState);
+  server2.tool(name, toolDescription, jsonSchema2(createGoogleCompatibleJSONSchema(argsDef)), async (args) => {
+    try {
+      if (isSamplingMode) {
+        return await workflowSamplingExecutor.executeWorkflowSampling(args, argsDef, workflowState);
+      } else {
+        return await workflowExecutor.execute(args, workflowState);
+      }
+    } catch (error) {
+      workflowState.reset();
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Workflow execution error: ${error.message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+}
+
+// ../__mcpc__cli_0.1.1-beta.1/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?.hide) {
+      $(toolEl).remove();
+    } else if (override?.visibility?.global) {
+      $(toolEl).replaceWith(`<tool name="${toolName}"/>`);
+    } else {
+      const toolId = findToolId(toolName, tools, toolNameMapping);
+      if (toolId) {
+        $(toolEl).replaceWith(`<action action="${toolId}"/>`);
+      }
+    }
+  });
+  return $.root().html() ?? description;
+}
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/compose.js
+init_built_in();
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugin-utils.js
+function shouldApplyPlugin(plugin, mode) {
+  if (!plugin.apply) return true;
+  if (typeof plugin.apply === "string") {
+    return mode.includes(plugin.apply);
+  }
+  if (typeof plugin.apply === "function") {
+    return plugin.apply(mode);
+  }
+  return plugin.apply;
+}
+function isValidPlugin(plugin) {
+  return plugin && plugin.name && (plugin.configureServer || plugin.composeStart || plugin.transformTool || plugin.finalizeComposition || plugin.composeEnd);
+}
+async function loadPlugin(pluginPath) {
+  try {
+    const [rawPath, queryString] = pluginPath.split("?", 2);
+    const searchParams = new URLSearchParams(queryString || "");
+    const params = Object.fromEntries(searchParams.entries());
+    const pluginModule = await import(rawPath);
+    const pluginFactory = pluginModule.createPlugin;
+    const defaultPlugin = pluginModule.default;
+    let plugin;
+    if (Object.keys(params).length > 0) {
+      if (typeof pluginFactory === "function") {
+        const typedParams = {};
+        for (const [key, value] of Object.entries(params)) {
+          const numValue = Number(value);
+          if (!isNaN(numValue)) {
+            typedParams[key] = numValue;
+          } else if (value === "true") {
+            typedParams[key] = true;
+          } else if (value === "false") {
+            typedParams[key] = false;
+          } else {
+            typedParams[key] = value;
+          }
+        }
+        plugin = pluginFactory(typedParams);
+      } else {
+        throw new Error(`Plugin ${rawPath} has parameters but no createPlugin export`);
+      }
+    } else {
+      plugin = defaultPlugin;
+    }
+    if (isValidPlugin(plugin)) {
+      return plugin;
+    } else {
+      throw new Error(`Invalid plugin format in ${rawPath} - plugin must have a name and at least one lifecycle hook`);
+    }
+  } catch (error) {
+    throw new Error(`Failed to load plugin from ${pluginPath}: ${error}`);
+  }
+}
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/compose.js
+var ALL_TOOLS_PLACEHOLDER2 = "__ALL__";
+var ComposableMCPServer = class extends Server {
+  tools = [];
+  toolRegistry = /* @__PURE__ */ new Map();
+  toolConfigs = /* @__PURE__ */ new Map();
+  globalPlugins = [];
+  toolNameMapping = /* @__PURE__ */ new Map();
+  constructor(_serverInfo, options) {
+    super(_serverInfo, options);
+  }
+  /**
+   * Initialize built-in plugins - called during setup
+   */
+  async initBuiltInPlugins() {
+    const builtInPlugins = getBuiltInPlugins();
+    for (const plugin of builtInPlugins) {
+      await this.addPlugin(plugin);
+    }
+  }
+  /**
+   * Apply plugin transformations to tool arguments/results
+   * TODO: Implement transformResult lifecycle hooks
+   */
+  applyPluginTransforms(_toolName, args, _mode, _originalArgs) {
+    return args;
+  }
+  /**
+   * Resolve a tool name to its internal format
+   */
+  resolveToolName(name) {
+    if (this.toolRegistry.has(name)) {
+      return name;
+    }
+    const mappedName = this.toolNameMapping.get(name);
+    if (mappedName && this.toolRegistry.has(mappedName)) {
+      return mappedName;
+    }
+    if (this.toolConfigs.has(name)) {
+      const cfgMapped = this.toolNameMapping.get(name);
+      if (cfgMapped && this.toolRegistry.has(cfgMapped)) {
+        return cfgMapped;
+      }
+    }
+    return void 0;
+  }
+  tool(name, description, paramsSchema, cb, options = {}) {
+    this.toolRegistry.set(name, {
+      callback: cb,
+      description,
+      schema: paramsSchema.jsonSchema
+    });
+    if (options.plugins) {
+      for (const plugin of options.plugins) {
+        this.globalPlugins.push(plugin);
+      }
+    }
+    if (options.internal) {
+      this.toolConfigs.set(name, {
+        visibility: {
+          internal: true
+        }
+      });
+    } else {
+      const existingTool = this.tools.find((t) => t.name === name);
+      if (!existingTool) {
+        const newTool = {
+          name,
+          description,
+          inputSchema: paramsSchema.jsonSchema
+        };
+        this.tools = [
+          ...this.tools,
+          newTool
+        ];
+      }
+    }
+    this.setRequestHandler(ListToolsRequestSchema, () => {
+      return {
+        tools: this.tools
+      };
+    });
+    this.setRequestHandler(CallToolRequestSchema, (request, extra) => {
+      const { name: toolName, arguments: args } = request.params;
+      const handler = this.getToolCallback(toolName);
+      if (!handler) {
+        throw new Error(`Tool ${toolName} not found`);
+      }
+      const processedArgs = this.applyPluginTransforms(toolName, args, "input");
+      const result = handler(processedArgs, extra);
+      return this.applyPluginTransforms(toolName, result, "output", args);
+    });
+  }
+  /**
+   * Register a tool override with description, hide, args transformation, and/or custom handler
+   */
+  /**
+  * Get tool callback from registry
+  */
+  getToolCallback(name) {
+    return this.toolRegistry.get(name)?.callback;
+  }
+  /**
+   * Find tool configuration (simplified - dot/underscore mapping now handled by plugin)
+   */
+  findToolConfig(toolId) {
+    const directConfig = this.toolConfigs.get(toolId);
+    if (directConfig) {
+      return directConfig;
+    }
+    const mappedName = this.toolNameMapping.get(toolId);
+    if (mappedName && this.toolConfigs.has(mappedName)) {
+      return this.toolConfigs.get(mappedName);
+    }
+    return void 0;
+  }
+  /**
+   * Call any registered tool directly, whether it's public or internal
+   */
+  async callTool(name, args) {
+    const resolvedName = this.resolveToolName(name);
+    if (!resolvedName) {
+      throw new Error(`Tool ${name} not found`);
+    }
+    const callback = this.getToolCallback(resolvedName);
+    if (!callback) {
+      throw new Error(`Tool ${name} not found`);
+    }
+    const processedArgs = this.applyPluginTransforms(resolvedName, args, "input");
+    const result = await callback(processedArgs);
+    return this.applyPluginTransforms(resolvedName, result, "output", args);
+  }
+  /**
+   * Get all internal tool names
+   */
+  getInternalToolNames() {
+    return Array.from(this.toolConfigs.entries()).filter(([_name, config2]) => config2.visibility?.internal).map(([name]) => this.resolveToolName(name) ?? name);
+  }
+  /**
+   * Get all public tool names
+   */
+  getPublicToolNames() {
+    return Array.from(this.toolConfigs.entries()).filter(([_name, config2]) => config2.visibility?.global).map(([name]) => this.resolveToolName(name) ?? name);
+  }
+  /**
+   * Get all external (non-global, non-internal, non-hidden) tool names
+   */
+  getExternalToolNames() {
+    const allRegistered = Array.from(this.toolRegistry.keys());
+    const publicSet = new Set(this.getPublicToolNames());
+    const internalSet = new Set(this.getInternalToolNames());
+    const hiddenSet = new Set(this.getHiddenToolNames());
+    return allRegistered.filter((n) => !publicSet.has(n) && !internalSet.has(n) && !hiddenSet.has(n));
+  }
+  /**
+   * Get all hidden tool names
+   */
+  getHiddenToolNames() {
+    return Array.from(this.toolConfigs.entries()).filter(([_name, config2]) => config2.visibility?.hide).map(([name]) => this.resolveToolName(name) ?? name);
+  }
+  /**
+   * Get internal tool schema by name
+   */
+  getInternalToolSchema(name) {
+    const tool = this.toolRegistry.get(name);
+    const config2 = this.toolConfigs.get(name);
+    if (tool && config2?.visibility?.internal && tool.schema) {
+      return {
+        description: tool.description,
+        schema: tool.schema
+      };
+    }
+    return void 0;
+  }
+  /**
+   * Check if a tool exists (visible or internal)
+   */
+  hasToolNamed(name) {
+    return this.toolRegistry.has(name) || this.toolNameMapping.has(name) && this.toolRegistry.has(this.toolNameMapping.get(name));
+  }
+  /**
+   * Configure tool behavior (simplified replacement for middleware)
+   * @example
+   * ```typescript
+   * // Override description
+   * server.configTool('myTool', {
+   *   callback: originalCallback,
+   *   description: 'Enhanced tool description'
+   * });
+   *
+   * // Hide tool from agentic execution
+   * server.configTool('myTool', {
+   *   callback: originalCallback,
+   *   description: 'Hidden tool',
+   *   visibility: { hide: true }
+   * });
+   *
+   * // Make tool globally available
+   * server.configTool('myTool', {
+   *   callback: originalCallback,
+   *   description: 'Global tool',
+   *   visibility: { global: true }
+   * });
+   * ```
+   */
+  configTool(toolName, config2) {
+    this.toolConfigs.set(toolName, config2);
+  }
+  /**
+   * Get tool configuration
+   */
+  getToolConfig(toolName) {
+    return this.toolConfigs.get(toolName);
+  }
+  /**
+   * Remove tool configuration
+   */
+  removeToolConfig(toolName) {
+    return this.toolConfigs.delete(toolName);
+  }
+  /**
+   * Register a tool plugin
+   * @example
+   * ```typescript
+   * // Global plugin for all tools
+   * server.addPlugin({
+   *   name: 'logger',
+   *   transformTool: (tool, context) => {
+   *     const originalExecute = tool.execute;
+   *     tool.execute = async (args, extra) => {
+   *       console.log(`Calling ${tool.name} with:`, args);
+   *       const result = await originalExecute(args, extra);
+   *       console.log(`Result:`, result);
+   *       return result;
+   *     };
+   *     return tool;
+   *   }
+   * });
+   * ```
+   */
+  async addPlugin(plugin) {
+    if (plugin.configureServer) {
+      await plugin.configureServer(this);
+    }
+    this.globalPlugins.push(plugin);
+  }
+  /**
+   * Load and register a plugin from a file path with optional parameters
+   *
+   * Supports parameter passing via query string syntax:
+   * loadPluginFromPath("path/to/plugin.ts?param1=value1&param2=value2")
+   */
+  async loadPluginFromPath(pluginPath) {
+    const plugin = await loadPlugin(pluginPath);
+    this.addPlugin(plugin);
+  }
+  /**
+   * Apply transformTool hook to a tool during composition
+   */
+  async applyTransformToolHooks(tool, toolName, mode) {
+    const transformPlugins = this.globalPlugins.filter((p2) => p2.transformTool && shouldApplyPlugin(p2, mode));
+    if (transformPlugins.length === 0) {
+      return tool;
+    }
+    const sortedPlugins = [
+      ...transformPlugins.filter((p2) => p2.enforce === "pre"),
+      ...transformPlugins.filter((p2) => !p2.enforce),
+      ...transformPlugins.filter((p2) => p2.enforce === "post")
+    ];
+    const context = {
+      toolName,
+      server: this,
+      mode
+    };
+    let currentTool = tool;
+    for (const plugin of sortedPlugins) {
+      if (plugin.transformTool) {
+        const result = await plugin.transformTool(currentTool, context);
+        if (result) {
+          currentTool = result;
+        }
+      }
+    }
+    return currentTool;
+  }
+  /**
+   * Apply plugins to all tools in registry and handle visibility configurations
+   */
+  async processToolsWithPlugins(externalTools, mode) {
+    for (const [toolId, toolData] of this.toolRegistry.entries()) {
+      const defaultSchema = {
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      };
+      const tempTool = {
+        name: toolId,
+        description: toolData.description,
+        inputSchema: toolData.schema || defaultSchema,
+        execute: toolData.callback
+      };
+      const processedTool = await this.applyTransformToolHooks(tempTool, toolId, mode);
+      this.toolRegistry.set(toolId, {
+        callback: processedTool.execute,
+        description: processedTool.description || toolData.description,
+        schema: processedTool.inputSchema
+      });
+      if (externalTools[toolId]) {
+        try {
+          const builtIn = await Promise.resolve().then(() => (init_built_in(), built_in_exports));
+          if (builtIn && typeof builtIn.processToolVisibility === "function") {
+            builtIn.processToolVisibility(toolId, processedTool, this, externalTools);
+          }
+        } catch {
+        }
+        externalTools[toolId] = processedTool;
+      }
+    }
+  }
+  /**
+   * Trigger composeEnd hooks for all plugins
+   */
+  async triggerComposeEndHooks(context) {
+    const endPlugins = this.globalPlugins.filter((p2) => p2.composeEnd && shouldApplyPlugin(p2, context.mode));
+    for (const plugin of endPlugins) {
+      if (plugin.composeEnd) {
+        await plugin.composeEnd(context);
+      }
+    }
+  }
+  async compose(name, description, depsConfig = {
+    mcpServers: {}
+  }, options = {
+    mode: "agentic"
+  }) {
+    const refDesc = options.refs?.join("") ?? "";
+    const { tagToResults } = parseTags(description + refDesc, [
+      "tool",
+      "fn"
+    ]);
+    tagToResults.tool.forEach((toolEl) => {
+      const toolName = toolEl.attribs.name;
+      const toolDescription = toolEl.attribs.description;
+      const isHidden = toolEl.attribs.hide !== void 0;
+      const isGlobal = toolEl.attribs.global !== void 0;
+      if (toolName) {
+        this.toolConfigs.set(toolName, {
+          description: toolDescription,
+          visibility: {
+            hide: isHidden,
+            global: isGlobal
+          }
+        });
+      }
+    });
+    const toolNameToIdMapping = /* @__PURE__ */ new Map();
+    const requestedToolNames = /* @__PURE__ */ new Set();
+    const availableToolNames = /* @__PURE__ */ new Set();
+    tagToResults.tool.forEach((tool) => {
+      if (tool.attribs.name) {
+        requestedToolNames.add(tool.attribs.name);
+      }
+    });
+    const { tools, cleanupClients } = await composeMcpDepTools(depsConfig, ({ mcpName, toolNameWithScope, toolId }) => {
+      toolNameToIdMapping.set(toolNameWithScope, toolId);
+      availableToolNames.add(toolNameWithScope);
+      availableToolNames.add(toolId);
+      availableToolNames.add(`${mcpName}.${ALL_TOOLS_PLACEHOLDER2}`);
+      availableToolNames.add(mcpName);
+      this.toolNameMapping.set(toolNameWithScope, toolId);
+      const internalName = toolNameWithScope.includes(".") ? toolNameWithScope.split(".").slice(1).join(".") : toolNameWithScope;
+      if (!this.toolNameMapping.has(internalName)) {
+        this.toolNameMapping.set(internalName, toolId);
+      }
+      const matchingStep = options.steps?.find((step) => step.actions.includes(toolNameWithScope));
+      if (matchingStep) {
+        const actionIndex = matchingStep.actions.indexOf(toolNameWithScope);
+        if (actionIndex !== -1) {
+          matchingStep.actions[actionIndex] = toolId;
+        }
+        return true;
+      }
+      return tagToResults.tool.find((tool) => {
+        const selectAll = tool.attribs.name === `${mcpName}.${ALL_TOOLS_PLACEHOLDER2}` || tool.attribs.name === `${mcpName}`;
+        if (selectAll) {
+          return true;
+        }
+        return tool.attribs.name === toolNameWithScope || tool.attribs.name === toolId;
+      });
+    });
+    const unmatchedTools = Array.from(requestedToolNames).filter((toolName) => !availableToolNames.has(toolName));
+    if (unmatchedTools.length > 0) {
+      console.warn(`\u26A0\uFE0F  Tool matching warnings for agent "${name}":`);
+      unmatchedTools.forEach((toolName) => {
+        console.warn(`   \u2022 Tool not found: "${toolName}"`);
+      });
+      console.warn(`   Available tools: ${Array.from(availableToolNames).sort().join(", ")}`);
+    }
+    Object.entries(tools).forEach(([toolId, tool]) => {
+      this.toolRegistry.set(toolId, {
+        callback: tool.execute,
+        description: tool.description || "No description available",
+        schema: tool.inputSchema
+      });
+    });
+    await this.processToolsWithPlugins(tools, options.mode ?? "agentic");
+    this.onclose = async () => {
+      await cleanupClients();
+      console.log(`\u{1F9E9} [${name}]`);
+      console.log(`   \u251C\u2500 Event: closed`);
+      console.log(`   \u2514\u2500 Action: cleaned up dependent clients`);
+    };
+    this.onerror = async (error) => {
+      console.log(`\u{1F9E9} [${name}]`);
+      console.log(`   \u251C\u2500 Event: error, ${error?.stack ?? String(error)}`);
+      await cleanupClients();
+      console.log(`   \u2514\u2500 Action: cleaned up dependent clients`);
+    };
+    const toolNameToDetailList = Object.entries(tools);
+    const globalToolNames = this.getPublicToolNames();
+    const hideToolNames = this.getHiddenToolNames();
+    const internalToolNames = this.getInternalToolNames();
+    const contextToolNames = toolNameToDetailList.map(([name2]) => name2).filter((n) => !globalToolNames.includes(n) && !hideToolNames.includes(n));
+    const allToolNames = [
+      ...contextToolNames,
+      ...internalToolNames
+    ];
+    globalToolNames.forEach((toolId) => {
+      const tool = tools[toolId];
+      if (!tool) {
+        throw new Error(`Global tool ${toolId} not found in registry, available: ${Object.keys(tools).join(", ")}`);
+      }
+      this.tool(toolId, tool.description || "No description available", jsonSchema3(tool.inputSchema), tool.execute);
+    });
+    await this.triggerComposeEndHooks({
+      toolName: name,
+      pluginNames: this.globalPlugins.map((p2) => p2.name),
+      mode: options.mode ?? "agentic",
+      server: this
+    });
+    if (!name) {
+      return;
+    }
+    const desTags = parseTags(description, [
+      "tool",
+      "fn"
+    ]);
+    description = processToolTags({
+      ...desTags,
+      description,
+      tools,
+      toolOverrides: this.toolConfigs,
+      toolNameMapping: toolNameToIdMapping
+    });
+    const depGroups = {};
+    toolNameToDetailList.forEach(([toolName, tool]) => {
+      if (hideToolNames.includes(this.resolveToolName(toolName) ?? "") || globalToolNames.includes(this.resolveToolName(toolName) ?? "")) {
+        return;
+      }
+      if (!tool) {
+        throw new Error(`Action ${toolName} not found, available action list: ${allToolNames.join(", ")}`);
+      }
+      const baseSchema = (
+        // Compatiable with ComposiableleMCPServer.tool() definition
+        tool.inputSchema.jsonSchema ?? // Standard definition
+        tool.inputSchema ?? {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      );
+      const baseProperties = baseSchema.type === "object" && baseSchema.properties ? baseSchema.properties : {};
+      const baseRequired = baseSchema.type === "object" && Array.isArray(baseSchema.required) ? baseSchema.required : [];
+      const updatedProperties = updateRefPaths(baseProperties, toolName);
+      depGroups[toolName] = {
+        type: "object",
+        description: tool.description,
+        properties: updatedProperties,
+        required: [
+          ...baseRequired
+        ],
+        additionalProperties: false
+      };
+    });
+    internalToolNames.forEach((toolName) => {
+      const toolSchema = this.getInternalToolSchema(toolName);
+      if (toolSchema) {
+        depGroups[toolName] = {
+          ...toolSchema.schema,
+          description: toolSchema.description
+        };
+      } else {
+        throw new Error(`Internal tool schema not found for: ${toolName}`);
+      }
+    });
+    switch (options.mode ?? "agentic") {
+      case "agentic":
+        registerAgenticTool(this, {
+          description,
+          name,
+          allToolNames,
+          depGroups,
+          toolNameToDetailList,
+          sampling: options.sampling
+        });
+        break;
+      case "agentic_workflow":
+        registerAgenticWorkflowTool(this, {
+          description,
+          name,
+          allToolNames,
+          depGroups,
+          toolNameToDetailList,
+          predefinedSteps: options.steps,
+          sampling: options.sampling,
+          ensureStepActions: options.ensureStepActions,
+          toolNameToIdMapping
+        });
+        break;
+    }
+  }
+};
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/utils/common/env.js
+import process4 from "node:process";
+var isSCF = () => Boolean(process4.env.SCF_RUNTIME || process4.env.PROD_SCF);
+if (isSCF()) {
+  console.log({
+    isSCF: isSCF(),
+    SCF_RUNTIME: process4.env.SCF_RUNTIME
+  });
+}
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/set-up-mcp-compose.js
+function parseMcpcConfigs(conf) {
+  const mcpcConfigs = conf ?? [];
+  const newMcpcConfigs = [];
+  for (const mcpcConfig of mcpcConfigs) {
+    if (mcpcConfig?.deps?.mcpServers) {
+      for (const [name, config2] of Object.entries(mcpcConfig.deps.mcpServers)) {
+        if (config2.smitheryConfig) {
+          const streamConfig = connectToSmitheryServer(config2.smitheryConfig);
+          mcpcConfig.deps.mcpServers[name] = streamConfig;
+        }
+      }
+    }
+    newMcpcConfigs.push(mcpcConfig);
+  }
+  return newMcpcConfigs;
+}
+async function mcpc(serverConf, composeConf, setupCallback) {
+  const server2 = new ComposableMCPServer(...serverConf);
+  const parsed = parseMcpcConfigs(composeConf);
+  await server2.initBuiltInPlugins();
+  for (const mcpcConfig of parsed) {
+    if (mcpcConfig.plugins) {
+      for (const plugin of mcpcConfig.plugins) {
+        if (typeof plugin === "string") {
+          await server2.loadPluginFromPath(plugin);
+        } else {
+          await server2.addPlugin(plugin);
+        }
+      }
+    }
+  }
+  if (setupCallback) {
+    await setupCallback(server2);
+  }
+  for (const mcpcConfig of parsed) {
+    await server2.compose(mcpcConfig.name, mcpcConfig.description ?? "", mcpcConfig.deps, mcpcConfig.options);
+  }
+  return server2;
+}
+
+// ../__mcpc__cli_0.1.1-beta.1/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: [
+          "./plugins/large-result.ts?maxSize=8000&previewSize=4000"
+        ]
+      }
+    ]
+  };
+  return await mcpc([
+    {
+      name: serverConfig.name || "mcpc-server",
+      version: serverConfig.version || "0.1.0"
+    },
+    {
+      capabilities: serverConfig.capabilities || {
+        tools: {},
+        sampling: {}
+      }
+    }
+  ], serverConfig.agents);
+};
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@mcpc/cli/src/config/loader.js
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import process5 from "node:process";
+function parseArgs() {
+  const args = process5.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];
+    }
+  }
+  return result;
+}
+async function loadConfig() {
+  const args = parseArgs();
+  if (args.config) {
+    try {
+      const parsed = JSON.parse(args.config);
+      return normalizeConfig(parsed);
+    } catch (error) {
+      console.error("Failed to parse --config argument:", error);
+      throw error;
+    }
+  }
+  if (args.configUrl) {
+    try {
+      const response = await fetch(args.configUrl);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const content = await response.text();
+      const parsed = JSON.parse(content);
+      return normalizeConfig(parsed);
+    } catch (error) {
+      console.error(`Failed to fetch config from ${args.configUrl}:`, error);
+      throw error;
+    }
+  }
+  if (args.configFile) {
+    try {
+      const content = await readFile(args.configFile, "utf-8");
+      const parsed = JSON.parse(content);
+      return normalizeConfig(parsed);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        console.error(`Config file not found: ${args.configFile}`);
+        throw error;
+      } else {
+        console.error(`Failed to load config from ${args.configFile}:`, error);
+        throw error;
+      }
+    }
+  }
+  const defaultConfigPath = resolve(process5.cwd(), "mcpc.config.json");
+  try {
+    const content = await readFile(defaultConfigPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return normalizeConfig(parsed);
+  } 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 process5.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 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;
+  });
+}
+
+// ../__mcpc__cli_0.1.1-beta.1/node_modules/@mcpc/cli/src/bin.ts
+var config = await loadConfig();
+if (config) {
+  console.error(`Loaded configuration with ${config.agents.length} agent(s)`);
+} else {
+  console.error("No configuration found, using default example configuration");
+}
+var server = await createServer(config || void 0);
+var transport = new StdioServerTransport();
+await server.connect(transport);