@mcpc-tech/cli 0.1.2 → 0.1.3

package/server.mjs

@@ -1,4470 +0,0 @@
-#!/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_latest/node_modules/@jsr/mcpc__core/src/utils/schema.js
-function jsonSchema(schema, options = {}) {
-  if (isWrappedSchema(schema)) {
-    return schema;
-  }
-  return {
-    [schemaSymbol]: true,
-    [validatorSymbol]: true,
-    _type: void 0,
-    jsonSchema: schema,
-    validate: options.validate
-  };
-}
-function isWrappedSchema(value) {
-  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true;
-}
-function extractJsonSchema(schema) {
-  if (isWrappedSchema(schema)) {
-    return schema.jsonSchema;
-  }
-  return schema;
-}
-var schemaSymbol, validatorSymbol;
-var init_schema = __esm({
-  "../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/schema.js"() {
-    schemaSymbol = Symbol.for("mcpc.schema");
-    validatorSymbol = Symbol.for("mcpc.validator");
-  }
-});
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/logger.js
-function createLogger(name, server) {
-  return new MCPLogger(name, server);
-}
-var LOG_LEVELS, MCPLogger, logger;
-var init_logger = __esm({
-  "../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/logger.js"() {
-    LOG_LEVELS = {
-      debug: 0,
-      info: 1,
-      notice: 2,
-      warning: 3,
-      error: 4,
-      critical: 5,
-      alert: 6,
-      emergency: 7
-    };
-    MCPLogger = class _MCPLogger {
-      server;
-      loggerName;
-      minLevel = "debug";
-      constructor(loggerName = "mcpc", server) {
-        this.loggerName = loggerName;
-        this.server = server;
-      }
-      setServer(server) {
-        this.server = server;
-      }
-      setLevel(level) {
-        this.minLevel = level;
-      }
-      async log(level, data) {
-        if (LOG_LEVELS[level] < LOG_LEVELS[this.minLevel]) {
-          return;
-        }
-        this.logToConsole(level, data);
-        if (this.server) {
-          try {
-            await this.server.sendLoggingMessage({
-              level,
-              logger: this.loggerName,
-              data
-            });
-          } catch {
-          }
-        }
-      }
-      logToConsole(level, data) {
-        const message = typeof data === "string" ? data : JSON.stringify(data);
-        const prefix = `[${this.loggerName}]`;
-        if (level === "debug") {
-          console.debug(prefix, message);
-        } else if (level === "info" || level === "notice") {
-          console.info(prefix, message);
-        } else if (level === "warning") {
-          console.warn(prefix, message);
-        } else {
-          console.error(prefix, message);
-        }
-      }
-      debug(data) {
-        return this.log("debug", data);
-      }
-      info(data) {
-        return this.log("info", data);
-      }
-      notice(data) {
-        return this.log("notice", data);
-      }
-      warning(data) {
-        return this.log("warning", data);
-      }
-      error(data) {
-        return this.log("error", data);
-      }
-      critical(data) {
-        return this.log("critical", data);
-      }
-      alert(data) {
-        return this.log("alert", data);
-      }
-      emergency(data) {
-        return this.log("emergency", data);
-      }
-      child(name) {
-        const child = new _MCPLogger(`${this.loggerName}.${name}`, this.server);
-        child.setLevel(this.minLevel);
-        return child;
-      }
-    };
-    logger = new MCPLogger("mcpc");
-  }
-});
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/config-plugin.js
-var createConfigPlugin, config_plugin_default;
-var init_config_plugin = __esm({
-  "../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/config-plugin.js"() {
-    createConfigPlugin = () => ({
-      name: "built-in-config",
-      version: "1.0.0",
-      enforce: "pre",
-      transformTool: (tool, context2) => {
-        const server = context2.server;
-        const config2 = server.findToolConfig?.(context2.toolName);
-        if (config2?.description) {
-          tool.description = config2.description;
-        }
-        return tool;
-      }
-    });
-    config_plugin_default = createConfigPlugin();
-  }
-});
-
-// ../__mcpc__cli_latest/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_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/tool-name-mapping-plugin.js"() {
-    createToolNameMappingPlugin = () => ({
-      name: "built-in-tool-name-mapping",
-      version: "1.0.0",
-      enforce: "pre",
-      transformTool: (tool, context2) => {
-        const server = context2.server;
-        const toolName = context2.toolName;
-        const dotNotation = toolName.replace(/_/g, ".");
-        const underscoreNotation = toolName.replace(/\./g, "_");
-        if (dotNotation !== toolName && server.toolNameMapping) {
-          server.toolNameMapping.set(dotNotation, toolName);
-          server.toolNameMapping.set(toolName, dotNotation);
-        }
-        if (underscoreNotation !== toolName && server.toolNameMapping) {
-          server.toolNameMapping.set(underscoreNotation, toolName);
-          server.toolNameMapping.set(toolName, underscoreNotation);
-        }
-        return tool;
-      }
-    });
-    tool_name_mapping_plugin_default = createToolNameMappingPlugin();
-  }
-});
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/logging-plugin.js
-var createLoggingPlugin, logging_plugin_default;
-var init_logging_plugin = __esm({
-  "../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/logging-plugin.js"() {
-    init_logger();
-    createLoggingPlugin = (options = {}) => {
-      const { enabled = true, verbose = false, compact: compact2 = true } = options;
-      return {
-        name: "built-in-logging",
-        version: "1.0.0",
-        composeEnd: async (context2) => {
-          if (!enabled) return;
-          const logger2 = createLogger("mcpc.plugin.logging", context2.server);
-          if (compact2) {
-            const pluginCount = context2.pluginNames.length;
-            const { stats } = context2;
-            await logger2.info(`[${context2.toolName}] ${pluginCount} plugins \u2022 ${stats.publicTools} public \u2022 ${stats.hiddenTools} hidden`);
-          } else if (verbose) {
-            await logger2.info(`[${context2.toolName}] Composition complete`);
-            await logger2.info(`   \u251C\u2500 Plugins: ${context2.pluginNames.join(", ")}`);
-            const { stats } = context2;
-            const server = context2.server;
-            const publicTools = Array.from(new Set(server.getPublicToolNames().map(String)));
-            const hiddenTools = Array.from(new Set(server.getHiddenToolNames().map(String)));
-            if (publicTools.length > 0) {
-              await logger2.info(`   \u251C\u2500 Public: ${publicTools.join(", ")}`);
-            }
-            if (hiddenTools.length > 0) {
-              await logger2.info(`   \u251C\u2500 Hidden: ${hiddenTools.join(", ")}`);
-            }
-            await logger2.info(`   \u2514\u2500 Total: ${stats.totalTools} tools`);
-          }
-        }
-      };
-    };
-    logging_plugin_default = createLoggingPlugin({
-      verbose: true,
-      compact: false
-    });
-  }
-});
-
-// ../__mcpc__cli_latest/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_latest/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_latest/node_modules/@jsr/mcpc__core/src/plugin-utils.js
-var plugin_utils_exports = {};
-__export(plugin_utils_exports, {
-  checkCircularDependencies: () => checkCircularDependencies,
-  clearPluginCache: () => clearPluginCache,
-  getPluginsWithHook: () => getPluginsWithHook,
-  isValidPlugin: () => isValidPlugin,
-  loadPlugin: () => loadPlugin,
-  shouldApplyPlugin: () => shouldApplyPlugin,
-  sortPluginsByOrder: () => sortPluginsByOrder,
-  validatePlugins: () => validatePlugins
-});
-function shouldApplyPlugin(plugin, mode) {
-  if (!plugin.apply) return true;
-  if (typeof plugin.apply === "string") {
-    return mode.includes(plugin.apply);
-  }
-  if (typeof plugin.apply === "function") {
-    try {
-      return plugin.apply(mode);
-    } catch (error) {
-      console.warn(`Plugin "${plugin.name}" apply function failed: ${error}. Defaulting to true.`);
-      return true;
-    }
-  }
-  return true;
-}
-function sortPluginsByOrder(plugins) {
-  const pluginMap = /* @__PURE__ */ new Map();
-  for (const plugin of plugins) {
-    pluginMap.set(plugin.name, plugin);
-  }
-  const visited = /* @__PURE__ */ new Set();
-  const sorted = [];
-  function visit(plugin) {
-    if (visited.has(plugin.name)) return;
-    visited.add(plugin.name);
-    if (plugin.dependencies) {
-      for (const depName of plugin.dependencies) {
-        const dep = pluginMap.get(depName);
-        if (dep) {
-          visit(dep);
-        } else {
-          console.warn(`Plugin "${plugin.name}" depends on "${depName}" which is not loaded`);
-        }
-      }
-    }
-    sorted.push(plugin);
-  }
-  const prePlugins = plugins.filter((p2) => p2.enforce === "pre");
-  const normalPlugins = plugins.filter((p2) => !p2.enforce);
-  const postPlugins = plugins.filter((p2) => p2.enforce === "post");
-  [
-    ...prePlugins,
-    ...normalPlugins,
-    ...postPlugins
-  ].forEach(visit);
-  return sorted;
-}
-function getPluginsWithHook(plugins, hookName) {
-  return plugins.filter((p2) => typeof p2[hookName] === "function");
-}
-function isValidPlugin(plugin) {
-  if (!plugin || typeof plugin !== "object") return false;
-  const p2 = plugin;
-  if (!p2.name || typeof p2.name !== "string" || p2.name.trim() === "") {
-    return false;
-  }
-  const hasHook = typeof p2.configureServer === "function" || typeof p2.composeStart === "function" || typeof p2.transformTool === "function" || typeof p2.finalizeComposition === "function" || typeof p2.composeEnd === "function" || typeof p2.transformInput === "function" || typeof p2.transformOutput === "function" || typeof p2.dispose === "function";
-  if (!hasHook) return false;
-  if (p2.enforce && p2.enforce !== "pre" && p2.enforce !== "post") {
-    return false;
-  }
-  if (p2.apply && typeof p2.apply !== "string" && typeof p2.apply !== "function") {
-    return false;
-  }
-  if (p2.dependencies && !Array.isArray(p2.dependencies)) {
-    return false;
-  }
-  return true;
-}
-function parseQueryParams(params) {
-  const typedParams = {};
-  for (const [key, value] of Object.entries(params)) {
-    const numValue = Number(value);
-    if (!isNaN(numValue) && value.trim() !== "") {
-      typedParams[key] = numValue;
-      continue;
-    }
-    if (value === "true") {
-      typedParams[key] = true;
-      continue;
-    }
-    if (value === "false") {
-      typedParams[key] = false;
-      continue;
-    }
-    if (value.includes(",")) {
-      typedParams[key] = value.split(",").map((v) => v.trim());
-      continue;
-    }
-    typedParams[key] = value;
-  }
-  return typedParams;
-}
-async function loadPlugin(pluginPath, options = {
-  cache: true
-}) {
-  if (options.cache && pluginCache.has(pluginPath)) {
-    return pluginCache.get(pluginPath);
-  }
-  try {
-    const [rawPath, queryString] = pluginPath.split("?", 2);
-    const searchParams = new URLSearchParams(queryString || "");
-    const params = Object.fromEntries(searchParams.entries());
-    const importPath = rawPath;
-    const pluginModule = await import(importPath);
-    const pluginFactory = pluginModule.createPlugin;
-    const defaultPlugin = pluginModule.default;
-    let plugin;
-    if (Object.keys(params).length > 0) {
-      if (typeof pluginFactory !== "function") {
-        throw new Error(`Plugin "${rawPath}" has parameters but no createPlugin export function`);
-      }
-      const typedParams = parseQueryParams(params);
-      plugin = pluginFactory(typedParams);
-    } else {
-      if (defaultPlugin) {
-        plugin = defaultPlugin;
-      } else if (typeof pluginFactory === "function") {
-        plugin = pluginFactory();
-      } else {
-        throw new Error(`Plugin "${rawPath}" has no default export or createPlugin function`);
-      }
-    }
-    if (!isValidPlugin(plugin)) {
-      throw new Error(`Invalid plugin format in "${rawPath}": must have a unique name and at least one lifecycle hook`);
-    }
-    if (options.cache) {
-      pluginCache.set(pluginPath, plugin);
-    }
-    return plugin;
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to load plugin from "${pluginPath}": ${errorMsg}`);
-  }
-}
-function clearPluginCache() {
-  pluginCache.clear();
-}
-function checkCircularDependencies(plugins) {
-  const errors = [];
-  const pluginMap = /* @__PURE__ */ new Map();
-  for (const plugin of plugins) {
-    pluginMap.set(plugin.name, plugin);
-  }
-  function checkCircular(pluginName, visited, path) {
-    if (visited.has(pluginName)) {
-      const cycle = [
-        ...path,
-        pluginName
-      ].join(" -> ");
-      errors.push(`Circular dependency detected: ${cycle}`);
-      return;
-    }
-    const plugin = pluginMap.get(pluginName);
-    if (!plugin || !plugin.dependencies) return;
-    visited.add(pluginName);
-    path.push(pluginName);
-    for (const dep of plugin.dependencies) {
-      checkCircular(dep, new Set(visited), [
-        ...path
-      ]);
-    }
-  }
-  for (const plugin of plugins) {
-    checkCircular(plugin.name, /* @__PURE__ */ new Set(), []);
-  }
-  return errors;
-}
-function validatePlugins(plugins) {
-  const errors = [];
-  const names = /* @__PURE__ */ new Map();
-  for (const plugin of plugins) {
-    const count = names.get(plugin.name) || 0;
-    names.set(plugin.name, count + 1);
-  }
-  for (const [name, count] of names.entries()) {
-    if (count > 1) {
-      errors.push(`Duplicate plugin name: "${name}" (${count} instances)`);
-    }
-  }
-  const circularErrors = checkCircularDependencies(plugins);
-  errors.push(...circularErrors);
-  for (const plugin of plugins) {
-    if (!isValidPlugin(plugin)) {
-      const name = plugin.name || "unknown";
-      errors.push(`Invalid plugin: "${name}"`);
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors
-  };
-}
-var pluginCache;
-var init_plugin_utils = __esm({
-  "../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugin-utils.js"() {
-    pluginCache = /* @__PURE__ */ new Map();
-  }
-});
-
-// ../__mcpc__cli_latest/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;
-}
-var init_schema2 = __esm({
-  "../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/schema.js"() {
-  }
-});
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/compose-helpers.js
-var compose_helpers_exports = {};
-__export(compose_helpers_exports, {
-  buildDependencyGroups: () => buildDependencyGroups,
-  processToolsWithPlugins: () => processToolsWithPlugins,
-  registerGlobalTools: () => registerGlobalTools
-});
-async function processToolsWithPlugins(server, externalTools, mode) {
-  const toolManager = server.toolManager;
-  const pluginManager = server.pluginManager;
-  for (const [toolId, toolData] of toolManager.getToolEntries()) {
-    const defaultSchema = {
-      type: "object",
-      properties: {},
-      additionalProperties: true
-    };
-    const tempTool = {
-      name: toolId,
-      description: toolData.description,
-      inputSchema: toolData.schema || defaultSchema,
-      execute: toolData.callback
-    };
-    const processedTool = await pluginManager.applyTransformToolHooks(tempTool, {
-      toolName: toolId,
-      server,
-      mode,
-      originalTool: {
-        ...tempTool
-      },
-      transformationIndex: 0
-    });
-    toolManager.registerTool(toolId, processedTool.description || toolData.description, processedTool.inputSchema, processedTool.execute);
-    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, server, externalTools);
-        }
-      } catch {
-      }
-      externalTools[toolId] = processedTool;
-    }
-  }
-}
-function buildDependencyGroups(toolNameToDetailList, hiddenToolNames, publicToolNames, server) {
-  const depGroups = {};
-  const toolManager = server.toolManager;
-  toolNameToDetailList.forEach(([toolName, tool]) => {
-    const resolvedName = toolManager.resolveToolName(toolName);
-    if (hiddenToolNames.includes(resolvedName ?? "") || publicToolNames.includes(resolvedName ?? "")) {
-      return;
-    }
-    if (!tool) {
-      const allToolNames = [
-        ...toolNameToDetailList.map(([n]) => n)
-      ];
-      throw new Error(`Action ${toolName} not found, available action list: ${allToolNames.join(", ")}`);
-    }
-    const baseSchema = tool.inputSchema.jsonSchema ?? 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
-    };
-  });
-  return depGroups;
-}
-function registerGlobalTools(globalToolNames, tools, server) {
-  globalToolNames.forEach((toolId) => {
-    const tool = tools[toolId];
-    if (!tool) {
-      throw new Error(`Global tool ${toolId} not found in registry, available: ${Object.keys(tools).join(", ")}`);
-    }
-    server.tool(toolId, tool.description || "No description available", jsonSchema(tool.inputSchema), tool.execute);
-  });
-}
-var init_compose_helpers = __esm({
-  "../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/compose-helpers.js"() {
-    init_schema2();
-    init_schema();
-  }
-});
-
-// ../__mcpc__cli_latest/node_modules/@mcpc/cli/src/server.ts
-import { OpenAPIHono as OpenAPIHono2 } from "@hono/zod-openapi";
-
-// ../__mcpc__cli_latest/node_modules/@mcpc/cli/src/app.js
-import { OpenAPIHono } from "@hono/zod-openapi";
-
-// ../__mcpc__cli_latest/node_modules/@mcpc/cli/src/controllers/messages.controller.js
-import { createRoute } from "@hono/zod-openapi";
-import { z } from "zod";
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/transport/sse.js
-import { JSONRPCMessageSchema } from "@modelcontextprotocol/sdk/types.js";
-
-// ../__mcpc__cli_latest/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_latest/node_modules/@jsr/mcpc__utils/src/transport/sse.js
-var transports = /* @__PURE__ */ new Map();
-async function handleConnecting(request, createServer2, incomingMsgRoutePath) {
-  const url = new URL(request.url);
-  const sessionId = url.searchParams.get("sessionId");
-  const endpoint = `${incomingMsgRoutePath}`;
-  if (sessionId) {
-    if (transports.has(sessionId)) {
-      const transport2 = transports.get(sessionId);
-      return Promise.resolve(transport2.sseResponse);
-    } else {
-      return Promise.resolve(new Response("Invalid or expired sessionId", {
-        status: 404
-      }));
-    }
-  }
-  const server = await createServer2();
-  const transport = new SSEServerTransport(endpoint);
-  const newSessionId = transport.sessionId;
-  transports.set(newSessionId, transport);
-  server.connect(transport);
-  request.signal.addEventListener("abort", () => {
-    console.log(`HTTP connection aborted for session: ${transport.sessionId}`);
-    transport.close();
-  }, {
-    once: true
-  });
-  return Promise.resolve(transport.sseResponse);
-}
-async function handleIncoming(request) {
-  const url = new URL(request.url);
-  const sessionId = url.searchParams.get("sessionId");
-  if (!sessionId) {
-    return new Response("Missing sessionId parameter", {
-      status: 400
-    });
-  }
-  const transport = transports.get(sessionId);
-  if (!transport) {
-    return new Response("Invalid or expired sessionId", {
-      status: 404
-    });
-  }
-  if (!transport.isConnected) {
-    return new Response("SSE connection not established", {
-      status: 500
-    });
-  }
-  const contentTypeHeader = request.headers.get("content-type");
-  if (!contentTypeHeader?.includes("application/json")) {
-    return new Response("Unsupported content-type: Expected application/json", {
-      status: 415
-    });
-  }
-  try {
-    return await transport.handlePostMessage(request);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    return new Response(errorMessage, {
-      status: 400
-    });
-  }
-}
-var SSEServerTransport = class {
-  #sseResponse;
-  #sessionId;
-  #controller;
-  #stream;
-  #endpoint;
-  onclose;
-  onerror;
-  onmessage;
-  /**
-   * Creates a new SSE server transport, which will direct the client to POST messages to the relative or absolute URL identified by `endpoint`.
-   */
-  constructor(endpoint) {
-    this.#endpoint = endpoint;
-    this.#sessionId = crypto.randomUUID();
-    this.#stream = new ReadableStream({
-      start: (controller) => {
-        this.#controller = controller;
-      },
-      // Caveat: cancel() reliably fires on client disconnect in Deno only; use request.signal "abort" for cross-runtime cleanup.
-      cancel: () => {
-        this.#controller = void 0;
-        this.close();
-      }
-    }).pipeThrough(
-      // Support standard sse stream chunk syntax
-      new ServerSentEventStream()
-    );
-  }
-  /**
-   * Handles the initial SSE connection request.
-   *
-   * This should be called when a GET request is made to establish the SSE stream.
-   */
-  async start() {
-    if (this.#sseResponse) {
-      throw new Error("SSEServerTransport already started! If using Server class, note that connect() calls start() automatically.");
-    }
-    this.#controller?.enqueue({
-      event: "endpoint",
-      data: `${this.#endpoint}?sessionId=${this.#sessionId}`,
-      id: Date.now().toString()
-    });
-    this.#sseResponse = new Response(this.#stream, {
-      status: 200,
-      statusText: "OK",
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
-      }
-    });
-    await Promise.resolve();
-  }
-  /**
-   * Handles incoming POST messages.
-   *
-   * This should be called when a POST request is made to send a message to the server.
-   */
-  async handlePostMessage(request) {
-    if (!this.#sseResponse) {
-      const message = "SSE connection not established";
-      return new Response(message, {
-        status: 500
-      });
-    }
-    try {
-      const contentType = request.headers.get("content-type") || "";
-      if (!contentType.includes("application/json")) {
-        throw new Error(`Unsupported content-type: ${contentType}`);
-      }
-      const body = await request.json();
-      await this.handleMessage(body);
-      return new Response("Accepted", {
-        status: 202
-      });
-    } catch (error) {
-      console.log(error);
-      this.onerror?.(error instanceof Error ? error : new Error(String(error)));
-      return new Response(String(error), {
-        status: 400
-      });
-    }
-  }
-  /**
-   * Handle a client message, regardless of how it arrived. This can be used to inform the server of messages that arrive via a means different than HTTP POST.
-   */
-  async handleMessage(message) {
-    let parsedMessage;
-    try {
-      parsedMessage = JSONRPCMessageSchema.parse(message);
-    } catch (error) {
-      this.onerror?.(error instanceof Error ? error : new Error(String(error)));
-      throw error;
-    }
-    this.onmessage?.(parsedMessage);
-    await Promise.resolve();
-  }
-  async close() {
-    transports.delete(this.#sessionId);
-    this.#controller?.close();
-    this.#controller = void 0;
-    this.onclose?.();
-    await Promise.resolve();
-  }
-  async send(message) {
-    if (!this.#controller) {
-      throw new Error("Not connected");
-    }
-    this.#controller.enqueue({
-      data: JSON.stringify(message),
-      event: "message",
-      id: Date.now().toString()
-    });
-    await Promise.resolve();
-  }
-  /**
-   * Returns the session ID for this transport.
-   *
-   * This can be used to route incoming POST requests.
-   */
-  get sessionId() {
-    return this.#sessionId;
-  }
-  get sseStream() {
-    return this.#stream;
-  }
-  get sseResponse() {
-    return this.#sseResponse;
-  }
-  get isConnected() {
-    return this.#controller !== void 0;
-  }
-};
-
-// ../__mcpc__cli_latest/node_modules/@mcpc/cli/src/controllers/messages.controller.js
-var messageHandler = (app2) => app2.openapi(createRoute({
-  hide: true,
-  method: "post",
-  path: `/messages`,
-  responses: {
-    200: {
-      content: {
-        "text/event-stream": {
-          schema: z.any()
-        }
-      },
-      description: "Returns the processed message"
-    },
-    400: {
-      content: {
-        "application/json": {
-          schema: z.any()
-        }
-      },
-      description: "Returns an error"
-    }
-  }
-}), async (c) => {
-  const response = await handleIncoming(c.req.raw);
-  return response;
-}, (result, c) => {
-  if (!result.success) {
-    return c.json({
-      code: 400,
-      message: result.error.message
-    }, 400);
-  }
-});
-
-// ../__mcpc__cli_latest/node_modules/@mcpc/cli/src/controllers/sse.controller.js
-import { createRoute as createRoute2, z as z2 } from "@hono/zod-openapi";
-var sseHandler = (app2) => app2.openapi(createRoute2({
-  hide: true,
-  method: "get",
-  path: "/sse",
-  responses: {
-    200: {
-      content: {
-        "text/event-stream": {
-          schema: z2.any()
-        }
-      },
-      description: "Returns the processed message"
-    },
-    400: {
-      content: {
-        "application/json": {
-          schema: z2.any()
-        }
-      },
-      description: "Returns an error"
-    }
-  }
-}), async (c) => {
-  const response = await handleConnecting(c.req.raw, createServer, "/core/messages");
-  return response;
-}, (result, c) => {
-  if (!result.success) {
-    return c.json({
-      code: 400,
-      message: result.error.message
-    }, 400);
-  }
-});
-
-// ../__mcpc__cli_latest/node_modules/@mcpc/cli/src/controllers/core.controller.js
-var coreHandler = (app2) => {
-  app2.doc("/core-docs", {
-    openapi: "3.0.0",
-    info: {
-      title: "tencentcloudapi openapi spec",
-      version: "1.0.0",
-      description: "openapi definition of tencentcloudapi"
-    }
-  });
-};
-
-// ../__mcpc__cli_latest/node_modules/@mcpc/cli/src/controllers/register.js
-var registerAgent = (app2) => {
-  messageHandler(app2);
-  sseHandler(app2);
-  coreHandler(app2);
-};
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/compose.js
-init_schema();
-import { CallToolRequestSchema, ListToolsRequestSchema, SetLevelRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/json.js
-import { jsonrepair } from "jsonrepair";
-function stripMarkdownAndText(text) {
-  text = text.trim();
-  text = text.replace(/^```(?:json)?\s*\n?/i, "");
-  text = text.replace(/\n?```\s*$/, "");
-  text = text.replace(/^(?:here is|here's|response|result|output|json):\s*/i, "");
-  const jsonMatch = text.match(/(\{[\s\S]*\}|\[[\s\S]*\])/);
-  if (jsonMatch) {
-    text = jsonMatch[1];
-  }
-  return text.trim();
-}
-function parseJSON(text, throwError) {
-  try {
-    return JSON.parse(text);
-  } catch (_error) {
-    try {
-      const cleanedText = stripMarkdownAndText(text);
-      try {
-        return JSON.parse(cleanedText);
-      } catch {
-        const repairedText = jsonrepair(cleanedText);
-        console.warn(`Failed to parse JSON, cleaned and repaired. Original: ${text.slice(0, 100)}...`);
-        return JSON.parse(repairedText);
-      }
-    } catch (_repairError) {
-      if (throwError) {
-        throw new Error(`Failed to parse JSON after cleanup and repair. Original error: ${_error instanceof Error ? _error.message : String(_error)}`);
-      }
-      return null;
-    }
-  }
-}
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/ai.js
-var p = (template, options = {}) => {
-  const { missingVariableHandling = "warn" } = options;
-  const names = /* @__PURE__ */ new Set();
-  const regex = /\{((\w|\.)+)\}/g;
-  let match;
-  while ((match = regex.exec(template)) !== null) {
-    names.add(match[1]);
-  }
-  const required = Array.from(names);
-  return (input) => {
-    let result = template;
-    for (const name of required) {
-      const key = name;
-      const value = input[key];
-      const re = new RegExp(`\\{${String(name)}\\}`, "g");
-      if (value !== void 0 && value !== null) {
-        result = result.replace(re, String(value));
-      } else {
-        switch (missingVariableHandling) {
-          case "error":
-            throw new Error(`Missing variable "${String(name)}" in input for template.`);
-          case "empty":
-            result = result.replace(re, "");
-            break;
-          case "warn":
-          case "ignore":
-          default:
-            break;
-        }
-      }
-    }
-    return result;
-  };
-};
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/tool-tags.js
-import { load } from "cheerio";
-function parseTags(htmlString, tags) {
-  const $ = load(htmlString, {
-    xml: {
-      decodeEntities: false
-    }
-  });
-  const tagToResults = {};
-  for (const tag of tags) {
-    const elements = $(tag);
-    tagToResults[tag] = elements.toArray();
-  }
-  return {
-    tagToResults,
-    $
-  };
-}
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/registory.js
-function connectToSmitheryServer(smitheryConfig) {
-  const serverUrl = new URL(smitheryConfig.deploymentUrl);
-  serverUrl.searchParams.set("config", btoa(JSON.stringify(smitheryConfig.config)));
-  serverUrl.searchParams.set("api_key", smitheryConfig?.smitheryApiKey ?? smitheryConfig?.config?.smitheryApiKey);
-  return {
-    url: serverUrl.toString()
-  };
-}
-function smitheryToolNameCompatibale(name, scope) {
-  if (!name.startsWith("toolbox_")) {
-    return {
-      toolNameWithScope: `${scope}.${name}`,
-      toolName: name
-    };
-  }
-  const [, ...toolNames] = name.split("_");
-  const toolName = toolNames.join("_");
-  const toolNameWithScope = `${scope}.${toolName}`;
-  return {
-    toolNameWithScope,
-    toolName
-  };
-}
-
-// ../__mcpc__cli_latest/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 transport;
-  if (typeof def.transportType === "string" && def.transportType === "sse") {
-    const options = {};
-    if (def.headers) {
-      options.requestInit = {
-        headers: def.headers
-      };
-      options.eventSourceInit = {
-        headers: def.headers
-      };
-    }
-    transport = 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
-      };
-    }
-    transport = new StreamableHTTPClientTransport(new URL(def.url), options);
-  } else if (typeof def.transportType === "string" && def.transportType === "stdio" || "command" in def) {
-    transport = 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(transport, {
-      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_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-tool-registrar.js
-init_schema();
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/config.js
-import process3 from "node:process";
-var GEMINI_PREFERRED_FORMAT = process3.env.GEMINI_PREFERRED_FORMAT === "0" ? false : true;
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/json.js
-import { jsonrepair as jsonrepair2 } from "jsonrepair";
-import { inspect } from "node:util";
-
-// ../__mcpc__cli_latest/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_latest/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_latest/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";
-init_logger();
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/tracing.js
-import { context, SpanStatusCode, trace } from "@opentelemetry/api";
-import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
-import { BatchSpanProcessor, ConsoleSpanExporter, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { Resource } from "@opentelemetry/resources";
-import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
-var tracerProvider = null;
-var tracer = null;
-var isInitialized = false;
-function initializeTracing(config2 = {}) {
-  if (isInitialized) {
-    return;
-  }
-  const { enabled = true, serviceName = "mcpc-sampling", serviceVersion = "0.2.0", exportTo = "console", otlpEndpoint = "http://localhost:4318/v1/traces", otlpHeaders = {} } = config2;
-  if (!enabled) {
-    isInitialized = true;
-    return;
-  }
-  const resource = Resource.default().merge(new Resource({
-    [ATTR_SERVICE_NAME]: serviceName,
-    [ATTR_SERVICE_VERSION]: serviceVersion
-  }));
-  tracerProvider = new NodeTracerProvider({
-    resource
-  });
-  if (exportTo === "console") {
-    tracerProvider.addSpanProcessor(new SimpleSpanProcessor(new ConsoleSpanExporter()));
-  } else if (exportTo === "otlp") {
-    const otlpExporter = new OTLPTraceExporter({
-      url: otlpEndpoint,
-      headers: otlpHeaders
-    });
-    tracerProvider.addSpanProcessor(new BatchSpanProcessor(otlpExporter));
-  }
-  tracerProvider.register();
-  tracer = trace.getTracer(serviceName, serviceVersion);
-  isInitialized = true;
-}
-function getTracer() {
-  if (!isInitialized) {
-    initializeTracing();
-  }
-  return tracer;
-}
-function startSpan(name, attributes, parent) {
-  const tracer2 = getTracer();
-  const ctx = parent ? trace.setSpan(context.active(), parent) : void 0;
-  return tracer2.startSpan(name, {
-    attributes
-  }, ctx);
-}
-function endSpan(span, error) {
-  if (error) {
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: error.message
-    });
-    span.recordException(error);
-  } else {
-    span.setStatus({
-      code: SpanStatusCode.OK
-    });
-  }
-  span.end();
-}
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-executor.js
-import process4 from "node:process";
-var ajv = new Ajv({
-  allErrors: true,
-  verbose: true
-});
-addFormats(ajv);
-var AgenticExecutor = class {
-  name;
-  allToolNames;
-  toolNameToDetailList;
-  server;
-  ACTION_KEY;
-  NEXT_ACTION_KEY;
-  logger;
-  tracingEnabled;
-  constructor(name, allToolNames, toolNameToDetailList, server, ACTION_KEY = "action", NEXT_ACTION_KEY = "nextAction") {
-    this.name = name;
-    this.allToolNames = allToolNames;
-    this.toolNameToDetailList = toolNameToDetailList;
-    this.server = server;
-    this.ACTION_KEY = ACTION_KEY;
-    this.NEXT_ACTION_KEY = NEXT_ACTION_KEY;
-    this.tracingEnabled = false;
-    this.logger = createLogger(`mcpc.agentic.${name}`, server);
-    try {
-      this.tracingEnabled = process4.env.MCPC_TRACING_ENABLED === "true";
-      if (this.tracingEnabled) {
-        initializeTracing({
-          enabled: true,
-          serviceName: `mcpc-agentic-${name}`,
-          exportTo: process4.env.MCPC_TRACING_EXPORT ?? "otlp",
-          otlpEndpoint: process4.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
-        });
-      }
-    } catch {
-      this.tracingEnabled = false;
-    }
-  }
-  async execute(args, schema) {
-    const executeSpan = this.tracingEnabled ? startSpan("mcpc.agentic_execute", {
-      agent: this.name,
-      action: String(args[this.ACTION_KEY] ?? "unknown"),
-      nextAction: String(args[this.NEXT_ACTION_KEY] ?? "none"),
-      args: JSON.stringify(args)
-    }) : null;
-    try {
-      const validationResult = this.validate(args, schema);
-      if (!validationResult.valid) {
-        if (executeSpan) {
-          executeSpan.setAttributes({
-            validationError: true,
-            errorMessage: validationResult.error || "Validation failed"
-          });
-          endSpan(executeSpan);
-        }
-        this.logger.warning({
-          message: "Validation failed",
-          action: args[this.ACTION_KEY],
-          error: validationResult.error
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: CompiledPrompts.errorResponse({
-                errorMessage: validationResult.error || "Validation failed"
-              })
-            }
-          ],
-          isError: true
-        };
-      }
-      const actionName = args[this.ACTION_KEY];
-      if (executeSpan && actionName) {
-        try {
-          const safeAction = String(actionName).replace(/\s+/g, "_");
-          if (typeof executeSpan.updateName === "function") {
-            executeSpan.updateName(`mcpc.agentic_execute.${safeAction}`);
-          }
-        } catch {
-        }
-      }
-      const currentTool = this.toolNameToDetailList.find(([name, _detail]) => name === actionName)?.[1];
-      if (currentTool) {
-        const nextAction = args[this.NEXT_ACTION_KEY];
-        if (executeSpan) {
-          executeSpan.setAttributes({
-            toolType: "external",
-            actionName,
-            nextAction: nextAction || "none"
-          });
-        }
-        this.logger.debug({
-          message: "Executing external tool",
-          action: actionName,
-          nextAction
-        });
-        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
-            })
-          });
-        }
-        if (executeSpan) {
-          executeSpan.setAttributes({
-            success: true,
-            isError: !!currentResult.isError,
-            resultContentLength: currentResult.content?.length || 0,
-            hasNextAction: !!args[nextAction],
-            toolResult: JSON.stringify(currentResult)
-          });
-          endSpan(executeSpan);
-        }
-        return currentResult;
-      }
-      if (this.allToolNames.includes(actionName)) {
-        if (executeSpan) {
-          executeSpan.setAttributes({
-            toolType: "internal",
-            actionName
-          });
-        }
-        this.logger.debug({
-          message: "Executing internal tool",
-          action: 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
-              })
-            });
-          }
-          if (executeSpan) {
-            executeSpan.setAttributes({
-              success: true,
-              isError: !!callToolResult.isError,
-              resultContentLength: callToolResult.content?.length || 0,
-              hasNextAction: !!(nextAction && this.allToolNames.includes(nextAction)),
-              toolResult: JSON.stringify(callToolResult)
-            });
-            endSpan(executeSpan);
-          }
-          return callToolResult;
-        } catch (error) {
-          if (executeSpan) {
-            endSpan(executeSpan, error);
-          }
-          this.logger.error({
-            message: "Error executing internal tool",
-            action: actionName,
-            error: String(error)
-          });
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error executing internal tool ${actionName}: ${error instanceof Error ? error.message : String(error)}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
-      if (executeSpan) {
-        executeSpan.setAttributes({
-          toolType: "not_found",
-          actionName: actionName || "unknown",
-          completion: true
-        });
-        endSpan(executeSpan);
-      }
-      this.logger.debug({
-        message: "Tool not found, returning completion message",
-        action: actionName
-      });
-      return {
-        content: [
-          {
-            type: "text",
-            text: CompiledPrompts.completionMessage()
-          }
-        ]
-      };
-    } catch (error) {
-      if (executeSpan) {
-        endSpan(executeSpan, error);
-      }
-      this.logger.error({
-        message: "Unexpected error in execute",
-        error: String(error)
-      });
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Unexpected error: ${error instanceof Error ? error.message : String(error)}`
-          }
-        ],
-        isError: true
-      };
-    }
-  }
-  // 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_latest/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_latest/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_latest/node_modules/@jsr/es-toolkit__es-toolkit/src/function/retry.js
-var DEFAULT_RETRIES = Number.POSITIVE_INFINITY;
-
-// ../__mcpc__cli_latest/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_latest/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_latest/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"
-          },
-          context: {
-            type: "object",
-            description: "Necessary context for the request, e.g., the absolute path of the current working directory. This is just an example; any relevant context fields are allowed.",
-            additionalProperties: true
-          }
-        },
-        required: [
-          "userRequest",
-          "context"
-        ]
-      };
-    },
-    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_latest/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";
-init_logger();
-import process5 from "node:process";
-var ajv2 = new Ajv2({
-  allErrors: true,
-  verbose: true
-});
-addFormats2(ajv2);
-var BaseSamplingExecutor = class {
-  name;
-  description;
-  allToolNames;
-  toolNameToDetailList;
-  server;
-  conversationHistory;
-  maxIterations;
-  currentIteration;
-  logger;
-  tracingEnabled;
-  summarize;
-  constructor(name, description, allToolNames, toolNameToDetailList, server, config2) {
-    this.name = name;
-    this.description = description;
-    this.allToolNames = allToolNames;
-    this.toolNameToDetailList = toolNameToDetailList;
-    this.server = server;
-    this.conversationHistory = [];
-    this.maxIterations = 55;
-    this.currentIteration = 0;
-    this.tracingEnabled = false;
-    this.summarize = true;
-    if (config2?.maxIterations) {
-      this.maxIterations = config2.maxIterations;
-    }
-    if (config2?.summarize !== void 0) {
-      this.summarize = config2.summarize;
-    }
-    this.logger = createLogger(`mcpc.sampling.${name}`, server);
-    try {
-      const tracingConfig = {
-        enabled: process5.env.MCPC_TRACING_ENABLED === "true",
-        serviceName: `mcpc-sampling-${name}`,
-        exportTo: process5.env.MCPC_TRACING_EXPORT ?? "otlp",
-        otlpEndpoint: process5.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
-      };
-      this.tracingEnabled = tracingConfig.enabled;
-      if (this.tracingEnabled) {
-        initializeTracing(tracingConfig);
-      }
-    } catch {
-      this.tracingEnabled = false;
-    }
-  }
-  async runSamplingLoop(systemPrompt, schema, state) {
-    this.conversationHistory = [
-      {
-        role: "user",
-        content: {
-          type: "text",
-          text: 'Return ONLY raw JSON (no code fences or explanations). The JSON MUST include action and decision. Example: {"action":"<tool>","decision":"proceed|complete","<tool>":{}}'
-        }
-      }
-    ];
-    const loopSpan = this.tracingEnabled ? startSpan("mcpc.sampling_loop", {
-      agent: this.name,
-      maxIterations: this.maxIterations,
-      systemPrompt: systemPrompt()
-    }) : null;
-    try {
-      for (this.currentIteration = 0; this.currentIteration < this.maxIterations; this.currentIteration++) {
-        let iterationSpan = null;
-        try {
-          const response = await this.server.createMessage({
-            systemPrompt: systemPrompt(),
-            messages: this.conversationHistory,
-            maxTokens: 55e3
-          });
-          const responseContent = response.content.text || "{}";
-          const model = response.model;
-          const stopReason = response.stopReason;
-          const role = response.role;
-          let parsedData;
-          try {
-            parsedData = parseJSON(responseContent.trim(), true);
-          } catch (parseError) {
-            iterationSpan = this.tracingEnabled ? startSpan("mcpc.sampling_iteration.parse_error", {
-              iteration: this.currentIteration + 1,
-              agent: this.name,
-              error: String(parseError),
-              maxIterations: this.maxIterations
-            }, loopSpan ?? void 0) : null;
-            this.addParsingErrorToHistory(responseContent, parseError);
-            if (iterationSpan) endSpan(iterationSpan);
-            continue;
-          }
-          if (parsedData) {
-            this.conversationHistory.push({
-              role: "assistant",
-              content: {
-                type: "text",
-                text: JSON.stringify(parsedData, null, 2)
-              }
-            });
-          }
-          const action = parsedData["action"];
-          const actionStr = action && typeof action === "string" ? String(action) : "unknown_action";
-          const spanName = `mcpc.sampling_iteration.${actionStr}`;
-          iterationSpan = this.tracingEnabled ? startSpan(spanName, {
-            iteration: this.currentIteration + 1,
-            agent: this.name,
-            action: actionStr,
-            systemPrompt: systemPrompt(),
-            maxTokens: String(Number.MAX_SAFE_INTEGER),
-            maxIterations: this.maxIterations,
-            messages: JSON.stringify(this.conversationHistory)
-          }, loopSpan ?? void 0) : null;
-          if (!action || typeof parsedData["decision"] !== "string") {
-            this.conversationHistory.push({
-              role: "user",
-              content: {
-                type: "text",
-                text: 'Required fields missing: action or decision. Return ONLY raw JSON, no code fences or explanations. Example: {"action":"<tool>","decision":"proceed|complete","<tool>":{}}'
-              }
-            });
-            if (iterationSpan) endSpan(iterationSpan);
-            continue;
-          }
-          const result = await this.processAction(parsedData, schema, state, loopSpan);
-          this.logIterationProgress(parsedData, result, model, stopReason, role);
-          if (iterationSpan) {
-            let rawJson = "{}";
-            try {
-              rawJson = parsedData ? JSON.stringify(parsedData) : "{}";
-            } catch {
-            }
-            const attr = {
-              isError: !!result.isError,
-              isComplete: !!result.isComplete,
-              iteration: this.currentIteration + 1,
-              maxIterations: this.maxIterations,
-              parsed: rawJson,
-              action: typeof action === "string" ? action : String(action),
-              samplingResponse: responseContent,
-              toolResult: JSON.stringify(result),
-              model,
-              role
-            };
-            if (stopReason) {
-              attr.stopReason = stopReason;
-            }
-            iterationSpan.setAttributes(attr);
-          }
-          if (result.isError) {
-            this.conversationHistory.push({
-              role: "user",
-              content: {
-                type: "text",
-                text: result.content[0].text
-              }
-            });
-            if (iterationSpan) endSpan(iterationSpan);
-            continue;
-          }
-          if (result.isComplete) {
-            if (iterationSpan) endSpan(iterationSpan);
-            if (loopSpan) endSpan(loopSpan);
-            return result;
-          }
-          if (iterationSpan) endSpan(iterationSpan);
-        } catch (iterError) {
-          if (iterationSpan) endSpan(iterationSpan, iterError);
-          throw iterError;
-        }
-      }
-      if (loopSpan) endSpan(loopSpan);
-      return await this.createMaxIterationsError(loopSpan);
-    } catch (error) {
-      if (loopSpan) endSpan(loopSpan, error);
-      return await this.createExecutionError(error, loopSpan);
-    }
-  }
-  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.`
-        })
-      }
-    });
-  }
-  async createMaxIterationsError(parentSpan) {
-    const result = await this.createCompletionResult(`Reached max iterations (${this.maxIterations}). Try a more specific request.`, parentSpan);
-    result.isError = true;
-    result.isComplete = false;
-    return result;
-  }
-  async createExecutionError(error, parentSpan) {
-    const result = await this.createCompletionResult(`Execution error: ${error instanceof Error ? error.message : String(error)}`, parentSpan);
-    result.isError = true;
-    result.isComplete = false;
-    return result;
-  }
-  async createCompletionResult(text, parentSpan) {
-    const summary = this.summarize ? await this.summarizeConversation(parentSpan) : this.formatConversation();
-    return {
-      content: [
-        {
-          type: "text",
-          text: `${text}
-
-**Execution Summary:**
-- Iterations used: ${this.currentIteration + 1}/${this.maxIterations}
-- Agent: ${this.name}
-${summary}`
-        }
-      ],
-      isError: false,
-      isComplete: true
-    };
-  }
-  // Use LLM to create high-signal summary for parent agent
-  async summarizeConversation(parentSpan) {
-    if (this.conversationHistory.length === 0) {
-      return "\n\n**No conversation history**";
-    }
-    if (this.conversationHistory.length <= 3) {
-      return this.formatConversation();
-    }
-    const summarizeSpan = this.tracingEnabled ? startSpan("mcpc.sampling_summarize", {
-      agent: this.name,
-      messageCount: this.conversationHistory.length
-    }, parentSpan ?? void 0) : null;
-    try {
-      this.logger.debug({
-        message: "Starting conversation summarization",
-        messageCount: this.conversationHistory.length
-      });
-      const history = this.conversationHistory.map((msg, i) => {
-        const prefix = `[${i + 1}] ${msg.role.toUpperCase()}`;
-        return `${prefix}:
-${msg.content.text}`;
-      }).join("\n\n---\n\n");
-      const response = await this.server.createMessage({
-        systemPrompt: `Summarize this agent execution:
-
-Final Decision: (include complete JSON if present)
-Key Findings: (most important)
-Actions Taken: (high-level flow)
-Errors/Warnings: (if any)
-
-${history}`,
-        messages: [
-          {
-            role: "user",
-            content: {
-              type: "text",
-              text: "Please provide a concise summary."
-            }
-          }
-        ],
-        maxTokens: 3e3
-      });
-      const summary = "\n\n" + response.content.text;
-      this.logger.debug({
-        message: "Summarization completed",
-        summaryLength: summary.length
-      });
-      if (summarizeSpan) {
-        summarizeSpan.setAttributes({
-          summaryLength: summary.length,
-          summary,
-          success: true
-        });
-        endSpan(summarizeSpan);
-      }
-      return summary;
-    } catch (error) {
-      this.logger.warning({
-        message: "Summarization failed, falling back to full history",
-        error: String(error)
-      });
-      if (summarizeSpan) {
-        endSpan(summarizeSpan, error);
-      }
-      return this.formatConversation();
-    }
-  }
-  // Format full conversation history (for debugging)
-  formatConversation() {
-    if (this.conversationHistory.length === 0) {
-      return "\n\n**No conversation history**";
-    }
-    const messages = this.conversationHistory.map((msg, i) => {
-      const header = `### Message ${i + 1}: ${msg.role}`;
-      try {
-        const parsed = JSON.parse(msg.content.text);
-        if (JSON.stringify(parsed).length < 100) {
-          return `${header}
-${JSON.stringify(parsed)}`;
-        }
-        return `${header}
-\`\`\`json
-${JSON.stringify(parsed, null, 2)}
-\`\`\``;
-      } catch {
-        return `${header}
-${msg.content.text}`;
-      }
-    });
-    return "\n\n**Conversation History:**\n" + messages.join("\n\n");
-  }
-  logIterationProgress(parsedData, result, model, stopReason, role) {
-    this.logger.debug({
-      iteration: `${this.currentIteration + 1}/${this.maxIterations}`,
-      parsedData,
-      isError: result.isError,
-      isComplete: result.isComplete,
-      model,
-      stopReason,
-      role,
-      result
-    });
-  }
-  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_latest/node_modules/@jsr/mcpc__core/src/executors/sampling/agentic-sampling-executor.js
-var SamplingExecutor = class extends BaseSamplingExecutor {
-  agenticExecutor;
-  constructor(name, description, allToolNames, toolNameToDetailList, server, config2) {
-    super(name, description, allToolNames, toolNameToDetailList, server, config2);
-    this.agenticExecutor = new AgenticExecutor(name, allToolNames, toolNameToDetailList, server);
-  }
-  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.getHiddenToolSchema(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, args.context && typeof args.context === "object" ? args.context : void 0);
-    return this.runSamplingLoop(() => systemPrompt, agenticSchema);
-  }
-  async processAction(parsedData, schema, _state, parentSpan) {
-    const toolCallData = parsedData;
-    if (toolCallData.decision === "complete") {
-      return await this.createCompletionResult("Task completed", parentSpan);
-    }
-    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, parentSpan);
-    }
-  }
-  buildSystemPrompt(userRequest, agenticSchema, context2) {
-    const toolList = this.allToolNames.map((name) => {
-      const tool = this.toolNameToDetailList.find(([toolName]) => toolName === name);
-      const toolSchema = this.server.getHiddenToolSchema(name);
-      if (tool && tool[1]) {
-        return `- ${name}: ${tool[1].description || `Tool: ${name}`}`;
-      } else if (toolSchema) {
-        return `- ${name}: ${toolSchema.description}`;
-      }
-      return `- ${name}`;
-    }).join("\n");
-    let contextInfo = "";
-    if (context2 && typeof context2 === "object" && Object.keys(context2).length > 0) {
-      contextInfo = `
-
-Context:
-${JSON.stringify(context2, null, 2)}`;
-    }
-    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}"${contextInfo}
-
-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_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-tool-registrar.js
-function registerAgenticTool(server, { 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, server);
-  const samplingExecutor = new SamplingExecutor(name, description, allToolNames, toolNameToDetailList, server, 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: {}
-  };
-  server.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_latest/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-tool-registrar.js
-init_schema();
-
-// ../__mcpc__cli_latest/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_latest/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, server, predefinedSteps, ensureStepActions, toolNameToIdMapping) {
-    this.name = name;
-    this.allToolNames = allToolNames;
-    this.toolNameToDetailList = toolNameToDetailList;
-    this.createArgsDef = createArgsDef;
-    this.server = server;
-    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_latest/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, server, predefinedSteps, config2) {
-    super(name, description, allToolNames, toolNameToDetailList, server, config2), this.createArgsDef = createArgsDef, this.predefinedSteps = predefinedSteps;
-    this.workflowExecutor = new WorkflowExecutor(name, allToolNames, toolNameToDetailList, createArgsDef, server, 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, parentSpan) {
-    const workflowState = state;
-    if (!workflowState) {
-      throw new Error("WorkflowState is required for workflow");
-    }
-    const toolCallData = parsedData;
-    if (toolCallData.decision === "complete") {
-      return await this.createCompletionResult("Task completed", parentSpan);
-    }
-    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, parentSpan);
-    }
-  }
-  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)}`
-    });
-    let contextInfo = "";
-    if (args.context && typeof args.context === "object" && Object.keys(args.context).length > 0) {
-      contextInfo = `
-
-Context:
-${JSON.stringify(args.context, null, 2)}`;
-    }
-    const workflowPrompt = `
-
-Current Task: <user_request>${args.userRequest}</user_request>${contextInfo}`;
-    return this.injectJsonInstruction({
-      prompt: basePrompt + workflowPrompt,
-      schema: workflowSchema
-    });
-  }
-};
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-tool-registrar.js
-function registerAgenticWorkflowTool(server, { 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, server, predefinedSteps, ensureStepActions, toolNameToIdMapping);
-  const workflowSamplingExecutor = new WorkflowSamplingExecutor(name, description, allToolNames, toolNameToDetailList, createArgsDef, server, 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);
-  server.tool(name, toolDescription, jsonSchema(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_latest/node_modules/@jsr/mcpc__core/src/utils/common/tool-tag-processor.js
-var ALL_TOOLS_PLACEHOLDER = "__ALL__";
-function findToolId(toolName, tools, toolNameMapping) {
-  const mappedId = toolNameMapping?.get(toolName);
-  if (mappedId) {
-    return mappedId;
-  }
-  return Object.keys(tools).find((id) => {
-    const dotNotation = id.replace(/_/g, ".");
-    return toolName === id || toolName === dotNotation;
-  });
-}
-function processToolTags({ description, tagToResults, $, tools, toolOverrides, toolNameMapping }) {
-  tagToResults.tool.forEach((toolEl) => {
-    const toolName = toolEl.attribs.name;
-    if (!toolName || toolName.includes(ALL_TOOLS_PLACEHOLDER)) {
-      $(toolEl).remove();
-      return;
-    }
-    const override = toolOverrides.get(toolName);
-    if (override?.visibility?.hidden) {
-      $(toolEl).remove();
-    } else if (override?.visibility?.public) {
-      $(toolEl).replaceWith(`<tool name="${toolName}"/>`);
-    } else {
-      const toolId = findToolId(toolName, tools, toolNameMapping);
-      if (toolId) {
-        $(toolEl).replaceWith(`<action action="${toolId}"/>`);
-      }
-    }
-  });
-  return $.root().html() ?? description;
-}
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/compose.js
-init_built_in();
-init_logger();
-init_plugin_utils();
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/plugin-manager.js
-init_plugin_utils();
-init_logger();
-var PluginManager = class {
-  server;
-  plugins;
-  logger;
-  constructor(server) {
-    this.server = server;
-    this.plugins = [];
-    this.logger = createLogger("mcpc.plugin-manager");
-    this.logger.setServer(server);
-  }
-  /**
-   * Get all registered plugins
-   */
-  getPlugins() {
-    return [
-      ...this.plugins
-    ];
-  }
-  /**
-   * Get plugin names
-   */
-  getPluginNames() {
-    return this.plugins.map((p2) => p2.name);
-  }
-  /**
-   * Check if a plugin is registered
-   */
-  hasPlugin(name) {
-    return this.plugins.some((p2) => p2.name === name);
-  }
-  /**
-   * Add a plugin with validation and error handling
-   */
-  async addPlugin(plugin) {
-    const validation = validatePlugins([
-      plugin
-    ]);
-    if (!validation.valid) {
-      const errorMsg = validation.errors.join(", ");
-      throw new Error(`Invalid plugin "${plugin.name}": ${errorMsg}`);
-    }
-    if (this.plugins.some((p2) => p2.name === plugin.name)) {
-      await this.logger.warning(`Plugin "${plugin.name}" already registered, skipping`);
-      return;
-    }
-    if (plugin.dependencies) {
-      const missingDeps = plugin.dependencies.filter((dep) => !this.plugins.some((p2) => p2.name === dep));
-      if (missingDeps.length > 0) {
-        throw new Error(`Plugin "${plugin.name}" has missing dependencies: ${missingDeps.join(", ")}`);
-      }
-    }
-    this.plugins.push(plugin);
-    if (plugin.configureServer) {
-      try {
-        await plugin.configureServer(this.server);
-      } catch (error) {
-        this.plugins = this.plugins.filter((p2) => p2.name !== plugin.name);
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        throw new Error(`Plugin "${plugin.name}" configuration failed: ${errorMsg}`);
-      }
-    }
-  }
-  /**
-   * Load and register a plugin from a file path
-   */
-  async loadPluginFromPath(pluginPath, options = {
-    cache: true
-  }) {
-    const plugin = await loadPlugin(pluginPath, options);
-    await this.addPlugin(plugin);
-  }
-  /**
-   * Trigger composeStart hooks for all applicable plugins
-   */
-  async triggerComposeStart(context2) {
-    const startPlugins = this.plugins.filter((p2) => p2.composeStart && shouldApplyPlugin(p2, context2.mode));
-    const sortedPlugins = sortPluginsByOrder(startPlugins);
-    for (const plugin of sortedPlugins) {
-      if (plugin.composeStart) {
-        try {
-          await plugin.composeStart(context2);
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error);
-          await this.logger.error(`Plugin "${plugin.name}" composeStart failed: ${errorMsg}`);
-        }
-      }
-    }
-  }
-  /**
-   * Apply transformTool hooks to a tool during composition
-   */
-  async applyTransformToolHooks(tool, context2) {
-    const transformPlugins = this.plugins.filter((p2) => p2.transformTool && shouldApplyPlugin(p2, context2.mode));
-    if (transformPlugins.length === 0) {
-      return tool;
-    }
-    const sortedPlugins = sortPluginsByOrder(transformPlugins);
-    let currentTool = tool;
-    for (const plugin of sortedPlugins) {
-      if (plugin.transformTool) {
-        try {
-          const result = await plugin.transformTool(currentTool, context2);
-          if (result) {
-            currentTool = result;
-          }
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error);
-          await this.logger.error(`Plugin "${plugin.name}" transformTool failed for "${context2.toolName}": ${errorMsg}`);
-        }
-      }
-    }
-    return currentTool;
-  }
-  /**
-   * Trigger finalizeComposition hooks for all applicable plugins
-   */
-  async triggerFinalizeComposition(tools, context2) {
-    const finalizePlugins = this.plugins.filter((p2) => p2.finalizeComposition && shouldApplyPlugin(p2, context2.mode));
-    const sortedPlugins = sortPluginsByOrder(finalizePlugins);
-    for (const plugin of sortedPlugins) {
-      if (plugin.finalizeComposition) {
-        try {
-          await plugin.finalizeComposition(tools, context2);
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error);
-          await this.logger.error(`Plugin "${plugin.name}" finalizeComposition failed: ${errorMsg}`);
-        }
-      }
-    }
-  }
-  /**
-   * Trigger composeEnd hooks for all applicable plugins
-   */
-  async triggerComposeEnd(context2) {
-    const endPlugins = this.plugins.filter((p2) => p2.composeEnd && shouldApplyPlugin(p2, context2.mode));
-    const sortedPlugins = sortPluginsByOrder(endPlugins);
-    for (const plugin of sortedPlugins) {
-      if (plugin.composeEnd) {
-        try {
-          await plugin.composeEnd(context2);
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error);
-          await this.logger.error(`Plugin "${plugin.name}" composeEnd failed: ${errorMsg}`);
-        }
-      }
-    }
-  }
-  /**
-   * Dispose all plugins and cleanup resources
-   */
-  async dispose() {
-    for (const plugin of this.plugins) {
-      if (plugin.dispose) {
-        try {
-          await plugin.dispose();
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error);
-          await this.logger.error(`Plugin "${plugin.name}" dispose failed: ${errorMsg}`);
-        }
-      }
-    }
-    this.plugins = [];
-  }
-};
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/tool-manager.js
-var ToolManager = class {
-  toolRegistry = /* @__PURE__ */ new Map();
-  toolConfigs = /* @__PURE__ */ new Map();
-  toolNameMapping = /* @__PURE__ */ new Map();
-  publicTools = [];
-  /**
-   * Get tool name mapping (for external access)
-   */
-  getToolNameMapping() {
-    return this.toolNameMapping;
-  }
-  /**
-   * Register a tool in the registry
-   */
-  registerTool(name, description, schema, callback, options = {}) {
-    this.toolRegistry.set(name, {
-      callback,
-      description,
-      schema
-    });
-    if (options.internal) {
-      this.toolConfigs.set(name, {
-        visibility: {
-          hidden: true
-        }
-      });
-    }
-  }
-  /**
-   * Explicitly mark a tool as public (exposed to MCP clients)
-   */
-  addPublicTool(name, description, schema) {
-    const existingTool = this.publicTools.find((t) => t.name === name);
-    if (!existingTool) {
-      this.publicTools.push({
-        name,
-        description,
-        inputSchema: schema
-      });
-    }
-  }
-  /**
-   * Check if a tool is public (exposed to MCP clients)
-   */
-  isPublic(name) {
-    const config2 = this.toolConfigs.get(name);
-    return config2?.visibility?.public === true;
-  }
-  /**
-   * Check if a tool is hidden from agent context
-   */
-  isHidden(name) {
-    const config2 = this.toolConfigs.get(name);
-    return config2?.visibility?.hidden === true;
-  }
-  /**
-   * Get all public tool names (exposed to MCP clients)
-   */
-  getPublicToolNames() {
-    return Array.from(this.toolConfigs.entries()).filter(([_name, config2]) => config2.visibility?.public === true).map(([name]) => this.resolveToolName(name) ?? name);
-  }
-  /**
-   * Get all hidden tool names
-   */
-  getHiddenToolNames() {
-    return Array.from(this.toolConfigs.entries()).filter(([_name, config2]) => config2.visibility?.hidden === true).map(([name]) => this.resolveToolName(name) ?? name);
-  }
-  /**
-   * Get all public tools
-   */
-  getPublicTools() {
-    return [
-      ...this.publicTools
-    ];
-  }
-  /**
-   * Set public tools list
-   */
-  setPublicTools(tools) {
-    this.publicTools = [
-      ...tools
-    ];
-  }
-  /**
-   * Get tool callback by name
-   */
-  getToolCallback(name) {
-    return this.toolRegistry.get(name)?.callback;
-  }
-  /**
-   * Check if tool exists in registry
-   */
-  hasToolNamed(name) {
-    return this.toolRegistry.has(name) || this.toolNameMapping.has(name) && this.toolRegistry.has(this.toolNameMapping.get(name));
-  }
-  /**
-   * 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;
-  }
-  /**
-   * Configure tool behavior
-   */
-  configTool(toolName, config2) {
-    this.toolConfigs.set(toolName, config2);
-  }
-  /**
-   * Get tool configuration
-   */
-  getToolConfig(toolName) {
-    return this.toolConfigs.get(toolName);
-  }
-  /**
-   * Find tool configuration (with mapping fallback)
-   */
-  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;
-  }
-  /**
-   * Remove tool configuration
-   */
-  removeToolConfig(toolName) {
-    return this.toolConfigs.delete(toolName);
-  }
-  /**
-   * Set tool name mapping
-   */
-  setToolNameMapping(from, to) {
-    this.toolNameMapping.set(from, to);
-  }
-  /**
-   * Get tool schema if it's hidden (for internal access)
-   */
-  getHiddenToolSchema(name) {
-    const tool = this.toolRegistry.get(name);
-    const config2 = this.toolConfigs.get(name);
-    if (tool && config2?.visibility?.hidden && tool.schema) {
-      return {
-        description: tool.description,
-        schema: tool.schema
-      };
-    }
-    return void 0;
-  }
-  /**
-   * Get total tool count
-   */
-  getTotalToolCount() {
-    return this.toolRegistry.size;
-  }
-  /**
-   * Get all tool entries
-   */
-  getToolEntries() {
-    return Array.from(this.toolRegistry.entries());
-  }
-  /**
-   * Get tool registry (for external access)
-   */
-  getToolRegistry() {
-    return this.toolRegistry;
-  }
-};
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/compose.js
-init_compose_helpers();
-var ALL_TOOLS_PLACEHOLDER2 = "__ALL__";
-var ComposableMCPServer = class extends Server {
-  pluginManager;
-  toolManager;
-  logger = createLogger("mcpc.compose");
-  // Legacy property for backward compatibility
-  get toolNameMapping() {
-    return this.toolManager.getToolNameMapping();
-  }
-  constructor(_serverInfo, options) {
-    const enhancedOptions = {
-      ...options,
-      capabilities: {
-        logging: {},
-        tools: {},
-        sampling: {},
-        ...options?.capabilities ?? {}
-      }
-    };
-    super(_serverInfo, enhancedOptions);
-    this.logger.setServer(this);
-    this.pluginManager = new PluginManager(this);
-    this.toolManager = new ToolManager();
-  }
-  /**
-   * Initialize built-in plugins - called during setup
-   */
-  async initBuiltInPlugins() {
-    const builtInPlugins = getBuiltInPlugins();
-    const validation = validatePlugins(builtInPlugins);
-    if (!validation.valid) {
-      await this.logger.warning("Built-in plugin validation issues:");
-      for (const error of validation.errors) {
-        await this.logger.warning(`  - ${error}`);
-      }
-    }
-    for (const plugin of builtInPlugins) {
-      await this.pluginManager.addPlugin(plugin);
-    }
-  }
-  /**
-   * Apply plugin transformations to tool arguments/results
-   * Supports runtime transformation hooks for input/output processing
-   */
-  async applyPluginTransforms(toolName, data, direction, originalArgs) {
-    const hookName = direction === "input" ? "transformInput" : "transformOutput";
-    const plugins = this.pluginManager.getPlugins().filter((p2) => p2[hookName]);
-    if (plugins.length === 0) {
-      return data;
-    }
-    const { sortPluginsByOrder: sortPluginsByOrder2 } = await Promise.resolve().then(() => (init_plugin_utils(), plugin_utils_exports));
-    const sortedPlugins = sortPluginsByOrder2(plugins);
-    let currentData = data;
-    const context2 = {
-      toolName,
-      server: this,
-      direction,
-      originalArgs
-    };
-    for (const plugin of sortedPlugins) {
-      const hook = plugin[hookName];
-      if (hook) {
-        try {
-          const result = await hook(currentData, context2);
-          if (result !== void 0) {
-            currentData = result;
-          }
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error);
-          await this.logger.error(`Plugin "${plugin.name}" ${hookName} failed for "${toolName}": ${errorMsg}`);
-        }
-      }
-    }
-    return currentData;
-  }
-  /**
-   * Resolve a tool name to its internal format
-   */
-  resolveToolName(name) {
-    return this.toolManager.resolveToolName(name);
-  }
-  tool(name, description, paramsSchema, cb, options = {}) {
-    const jsonSchemaObj = extractJsonSchema(paramsSchema);
-    this.toolManager.registerTool(name, description, jsonSchemaObj, cb, options);
-    if (!options.internal) {
-      this.toolManager.addPublicTool(name, description, jsonSchemaObj);
-    }
-    if (options.plugins) {
-      for (const plugin of options.plugins) {
-        this.pluginManager.addPlugin(plugin);
-      }
-    }
-    this.setRequestHandler(ListToolsRequestSchema, () => {
-      return {
-        tools: this.toolManager.getPublicTools()
-      };
-    });
-    this.setRequestHandler(CallToolRequestSchema, async (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 = await this.applyPluginTransforms(toolName, args, "input");
-      const result = await handler(processedArgs, extra);
-      return await this.applyPluginTransforms(toolName, result, "output", args);
-    });
-    this.setRequestHandler(SetLevelRequestSchema, (request) => {
-      const { level } = request.params;
-      this.logger.setLevel(level);
-      return {};
-    });
-  }
-  /**
-   * Get tool callback from registry
-   */
-  getToolCallback(name) {
-    return this.toolManager.getToolCallback(name);
-  }
-  /**
-   * Find tool configuration
-   */
-  findToolConfig(toolId) {
-    return this.toolManager.findToolConfig(toolId);
-  }
-  /**
-   * 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 = await this.applyPluginTransforms(resolvedName, args, "input");
-    const result = await callback(processedArgs);
-    return await this.applyPluginTransforms(resolvedName, result, "output", args);
-  }
-  /**
-   * Get all public tool names (exposed to MCP clients)
-   */
-  getPublicToolNames() {
-    return this.toolManager.getPublicToolNames();
-  }
-  /**
-   * Get all public tools (for AI SDK integration)
-   */
-  getPublicTools() {
-    return this.toolManager.getPublicTools();
-  }
-  /**
-   * Get all hidden tool names
-   */
-  getHiddenToolNames() {
-    return this.toolManager.getHiddenToolNames();
-  }
-  /**
-   * Get hidden tool schema by name (for internal access)
-   */
-  getHiddenToolSchema(name) {
-    return this.toolManager.getHiddenToolSchema(name);
-  }
-  /**
-   * Check if a tool exists (visible or hidden)
-   */
-  hasToolNamed(name) {
-    return this.toolManager.hasToolNamed(name);
-  }
-  /**
-   * Configure tool behavior
-   */
-  configTool(toolName, config2) {
-    this.toolManager.configTool(toolName, config2);
-  }
-  /**
-   * Get tool configuration
-   */
-  getToolConfig(toolName) {
-    return this.toolManager.getToolConfig(toolName);
-  }
-  /**
-   * Remove tool configuration
-   */
-  removeToolConfig(toolName) {
-    return this.toolManager.removeToolConfig(toolName);
-  }
-  /**
-   * Register a tool plugin with validation and error handling
-   */
-  async addPlugin(plugin) {
-    await this.pluginManager.addPlugin(plugin);
-  }
-  /**
-   * Load and register a plugin from a file path with optional parameters
-   */
-  async loadPluginFromPath(pluginPath, options = {
-    cache: true
-  }) {
-    await this.pluginManager.loadPluginFromPath(pluginPath, options);
-  }
-  /**
-   * Apply plugins to all tools in registry and handle visibility configurations
-   */
-  async processToolsWithPlugins(externalTools, mode) {
-    const { processToolsWithPlugins: processTools } = await Promise.resolve().then(() => (init_compose_helpers(), compose_helpers_exports));
-    await processTools(this, externalTools, mode);
-  }
-  /**
-   * Dispose all plugins and cleanup resources
-   */
-  async disposePlugins() {
-    await this.pluginManager.dispose();
-  }
-  async compose(name, description, depsConfig = {
-    mcpServers: {}
-  }, options = {
-    mode: "agentic"
-  }) {
-    const refDesc = options.refs?.join("") ?? "";
-    const { tagToResults } = parseTags(description + refDesc, [
-      "tool",
-      "fn"
-    ]);
-    await this.pluginManager.triggerComposeStart({
-      serverName: name ?? "anonymous",
-      description,
-      mode: options.mode ?? "agentic",
-      server: this,
-      availableTools: []
-    });
-    tagToResults.tool.forEach((toolEl) => {
-      const toolName = toolEl.attribs.name;
-      const toolDescription = toolEl.attribs.description;
-      const isHidden = toolEl.attribs.hide !== void 0;
-      const isPublic = toolEl.attribs.global !== void 0;
-      if (toolName) {
-        this.toolManager.configTool(toolName, {
-          description: toolDescription,
-          visibility: {
-            hidden: isHidden,
-            public: isPublic
-          }
-        });
-      }
-    });
-    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.toolManager.setToolNameMapping(toolNameWithScope, toolId);
-      const internalName = toolNameWithScope.includes(".") ? toolNameWithScope.split(".").slice(1).join(".") : toolNameWithScope;
-      if (!this.toolNameMapping.has(internalName)) {
-        this.toolManager.setToolNameMapping(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) {
-      await this.logger.warning(`Tool matching warnings for agent "${name}":`);
-      for (const toolName of unmatchedTools) {
-        await this.logger.warning(`   \u2022 Tool not found: "${toolName}"`);
-      }
-      await this.logger.warning(`   Available tools: ${Array.from(availableToolNames).sort().join(", ")}`);
-    }
-    Object.entries(tools).forEach(([toolId, tool]) => {
-      this.toolManager.registerTool(toolId, tool.description || "No description available", tool.inputSchema, tool.execute);
-    });
-    await this.processToolsWithPlugins(tools, options.mode ?? "agentic");
-    await this.pluginManager.triggerFinalizeComposition(tools, {
-      serverName: name ?? "anonymous",
-      mode: options.mode ?? "agentic",
-      server: this,
-      toolNames: Object.keys(tools)
-    });
-    this.onclose = async () => {
-      await cleanupClients();
-      await this.disposePlugins();
-      await this.logger.info(`[${name}] Event: closed - cleaned up dependent clients and plugins`);
-    };
-    this.onerror = async (error) => {
-      await this.logger.error(`[${name}] Event: error - ${error?.stack ?? String(error)}`);
-      await cleanupClients();
-      await this.disposePlugins();
-      await this.logger.info(`[${name}] Action: cleaned up dependent clients and plugins`);
-    };
-    const toolNameToDetailList = Object.entries(tools);
-    const publicToolNames = this.getPublicToolNames();
-    const hiddenToolNames = this.getHiddenToolNames();
-    const contextToolNames = toolNameToDetailList.map(([name2]) => name2).filter((n) => !hiddenToolNames.includes(n));
-    publicToolNames.forEach((toolId) => {
-      const tool = tools[toolId];
-      if (!tool) {
-        throw new Error(`Public tool ${toolId} not found in registry, available: ${Object.keys(tools).join(", ")}`);
-      }
-      this.tool(toolId, tool.description || "No description available", jsonSchema(tool.inputSchema), tool.execute, {
-        internal: false
-      });
-    });
-    await this.pluginManager.triggerComposeEnd({
-      toolName: name,
-      pluginNames: this.pluginManager.getPluginNames(),
-      mode: options.mode ?? "agentic",
-      server: this,
-      stats: {
-        totalTools: this.toolManager.getTotalToolCount(),
-        publicTools: publicToolNames.length,
-        hiddenTools: hiddenToolNames.length
-      }
-    });
-    if (!name) {
-      return;
-    }
-    const desTags = parseTags(description, [
-      "tool",
-      "fn"
-    ]);
-    description = processToolTags({
-      ...desTags,
-      description,
-      tools,
-      toolOverrides: /* @__PURE__ */ new Map(),
-      toolNameMapping: toolNameToIdMapping
-    });
-    const allToolNames = contextToolNames;
-    const depGroups = buildDependencyGroups(toolNameToDetailList, hiddenToolNames, publicToolNames, this);
-    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_latest/node_modules/@jsr/mcpc__core/src/utils/common/env.js
-import process6 from "node:process";
-var isSCF = () => Boolean(process6.env.SCF_RUNTIME || process6.env.PROD_SCF);
-if (isSCF()) {
-  console.log({
-    isSCF: isSCF(),
-    SCF_RUNTIME: process6.env.SCF_RUNTIME
-  });
-}
-
-// ../__mcpc__cli_latest/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 server = new ComposableMCPServer(...serverConf);
-  const parsed = parseMcpcConfigs(composeConf);
-  await server.initBuiltInPlugins();
-  for (const mcpcConfig of parsed) {
-    if (mcpcConfig.plugins) {
-      for (const plugin of mcpcConfig.plugins) {
-        if (typeof plugin === "string") {
-          await server.loadPluginFromPath(plugin);
-        } else {
-          await server.addPlugin(plugin);
-        }
-      }
-    }
-  }
-  if (setupCallback) {
-    await setupCallback(server);
-  }
-  for (const mcpcConfig of parsed) {
-    await server.compose(mcpcConfig.name, mcpcConfig.description ?? "", mcpcConfig.deps, mcpcConfig.options);
-  }
-  return server;
-}
-
-// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/mod.js
-init_schema();
-
-// ../__mcpc__cli_latest/node_modules/@mcpc/cli/src/app.js
-var createServer = async (config2) => {
-  const serverConfig = config2 || {
-    name: "large-result-plugin-example",
-    version: "0.1.0",
-    agents: [
-      {
-        name: null,
-        description: "",
-        plugins: [
-          "./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: {},
-        logging: {}
-      }
-    }
-  ], serverConfig.agents);
-};
-var createApp = () => {
-  const app2 = new OpenAPIHono();
-  registerAgent(app2);
-  return app2;
-};
-
-// ../__mcpc__cli_latest/node_modules/@mcpc/cli/src/config/loader.js
-import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
-import process7 from "node:process";
-function printHelp() {
-  console.log(`
-MCPC CLI - Model Context Protocol Composer
-
-USAGE:
-    npx -y deno run -A jsr:@mcpc/cli/bin [OPTIONS]
-
-OPTIONS:
-    --help, -h              Show this help message
-    --config <json>         Inline JSON configuration string
-    --config-url <url>      Fetch configuration from URL
-    --config-file <path>    Load configuration from file path
-    --request-headers <header>, -H <header>
-                           Add custom HTTP header for URL fetching
-                           Format: "Key: Value" or "Key=Value"
-                           Can be used multiple times
-
-ENVIRONMENT VARIABLES:
-    MCPC_CONFIG            Inline JSON configuration (same as --config)
-    MCPC_CONFIG_URL        URL to fetch config from (same as --config-url)
-    MCPC_CONFIG_FILE       Path to config file (same as --config-file)
-
-EXAMPLES:
-    # Show help
-    npx -y deno run -A jsr:@mcpc/cli/bin --help
-
-    # Load from URL
-    npx -y deno run -A jsr:@mcpc/cli/bin --config-url \\
-      "https://raw.githubusercontent.com/mcpc-tech/mcpc/main/packages/cli/examples/configs/codex-fork.json"
-
-    # Load from URL with custom headers
-    npx -y deno run -A jsr:@mcpc/cli/bin \\
-      --config-url "https://api.example.com/config.json" \\
-      -H "Authorization: Bearer token123" \\
-      -H "X-Custom-Header: value"
-
-    # Load from file
-    npx -y deno run -A jsr:@mcpc/cli/bin --config-file ./my-config.json
-
-    # Using environment variable
-    export MCPC_CONFIG='[{"name":"agent","description":"..."}]'
-    npx -y deno run -A jsr:@mcpc/cli/bin
-
-    # Use default configuration (./mcpc.config.json)
-    npx -y deno run -A jsr:@mcpc/cli/bin
-
-CONFIGURATION:
-    Configuration files support environment variable substitution using $VAR_NAME syntax.
-    
-    Priority order:
-    1. --config (inline JSON)
-    2. MCPC_CONFIG environment variable
-    3. --config-url or MCPC_CONFIG_URL
-    4. --config-file or MCPC_CONFIG_FILE
-    5. ./mcpc.config.json (default)
-
-For more information, visit: https://github.com/mcpc-tech/mcpc
-`);
-}
-function parseArgs() {
-  const args = process7.argv.slice(2);
-  const result = {};
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "--config" && i + 1 < args.length) {
-      result.config = args[++i];
-    } else if (arg === "--config-url" && i + 1 < args.length) {
-      result.configUrl = args[++i];
-    } else if (arg === "--config-file" && i + 1 < args.length) {
-      result.configFile = args[++i];
-    } else if ((arg === "--request-headers" || arg === "-H") && i + 1 < args.length) {
-      const headerStr = args[++i];
-      const colonIdx = headerStr.indexOf(":");
-      const equalIdx = headerStr.indexOf("=");
-      const separatorIdx = colonIdx !== -1 ? equalIdx !== -1 ? Math.min(colonIdx, equalIdx) : colonIdx : equalIdx;
-      if (separatorIdx !== -1) {
-        const key = headerStr.substring(0, separatorIdx).trim();
-        const value = headerStr.substring(separatorIdx + 1).trim();
-        if (!result.requestHeaders) {
-          result.requestHeaders = {};
-        }
-        result.requestHeaders[key] = value;
-      }
-    } else if (arg === "--help" || arg === "-h") {
-      result.help = true;
-    }
-  }
-  return result;
-}
-async function loadConfig() {
-  const args = parseArgs();
-  if (args.help) {
-    printHelp();
-    process7.exit(0);
-  }
-  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 (process7.env.MCPC_CONFIG) {
-    try {
-      const parsed = JSON.parse(process7.env.MCPC_CONFIG);
-      return normalizeConfig(parsed);
-    } catch (error) {
-      console.error("Failed to parse MCPC_CONFIG environment variable:", error);
-      throw error;
-    }
-  }
-  const configUrl = args.configUrl || process7.env.MCPC_CONFIG_URL;
-  if (configUrl) {
-    try {
-      const headers = {
-        "User-Agent": "MCPC-CLI/0.1.0",
-        ...args.requestHeaders
-      };
-      const response = await fetch(configUrl, {
-        headers
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-      }
-      const content = await response.text();
-      const parsed = JSON.parse(content);
-      return normalizeConfig(parsed);
-    } catch (error) {
-      console.error(`Failed to fetch config from ${configUrl}:`, error);
-      throw error;
-    }
-  }
-  const configFile = args.configFile || process7.env.MCPC_CONFIG_FILE;
-  if (configFile) {
-    try {
-      const content = await readFile(configFile, "utf-8");
-      const parsed = JSON.parse(content);
-      return normalizeConfig(parsed);
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        console.error(`Config file not found: ${configFile}`);
-        throw error;
-      } else {
-        console.error(`Failed to load config from ${configFile}:`, error);
-        throw error;
-      }
-    }
-  }
-  const defaultConfigPath = resolve(process7.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 process7.env[varName] || "";
-  });
-}
-function replaceEnvVarsInConfig(obj) {
-  if (typeof obj === "string") {
-    return replaceEnvVars(obj);
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => replaceEnvVarsInConfig(item));
-  }
-  if (obj && typeof obj === "object") {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      result[key] = replaceEnvVarsInConfig(value);
-    }
-    return result;
-  }
-  return obj;
-}
-function 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_latest/node_modules/@mcpc/cli/src/server.ts
-import process8 from "node:process";
-var port = Number(process8.env.PORT || "9000");
-var hostname = "0.0.0.0";
-var config = await loadConfig();
-if (config) {
-  console.log(`Loaded configuration with ${config.agents.length} agent(s)`);
-} else {
-  console.log("No configuration found, using default example configuration");
-}
-var app = new OpenAPIHono2();
-app.route("core", createApp());
-Deno.serve(
-  {
-    port,
-    hostname
-  },
-  app.fetch
-);