@mcpc-tech/core 0.3.9 → 0.3.10

package/index.cjs

@@ -0,0 +1,4174 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// __mcpc__core_latest/node_modules/@mcpc/core/mod.ts
+var mod_exports = {};
+__export(mod_exports, {
+  ComposableMCPServer: () => ComposableMCPServer,
+  composeMcpDepTools: () => composeMcpDepTools,
+  convertToAISDKTools: () => convertToAISDKTools,
+  extractJsonSchema: () => extractJsonSchema,
+  isProdEnv: () => isProdEnv,
+  isSCF: () => isSCF,
+  isWrappedSchema: () => isWrappedSchema,
+  jsonSchema: () => jsonSchema,
+  mcpc: () => mcpc,
+  optionalObject: () => optionalObject,
+  parseJSON: () => parseJSON2,
+  parseMcpcConfigs: () => parseMcpcConfigs,
+  truncateJSON: () => truncateJSON
+});
+module.exports = __toCommonJS(mod_exports);
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/compose.js
+var import_types2 = require("@modelcontextprotocol/sdk/types.js");
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/utils/schema.js
+var schemaSymbol = Symbol.for("mcpc.schema");
+var vercelSchemaSymbol = Symbol.for("vercel.ai.schema");
+var validatorSymbol = Symbol.for("mcpc.validator");
+function jsonSchema(schema, options = {}) {
+  if (isWrappedSchema(schema)) {
+    return schema;
+  }
+  return {
+    [schemaSymbol]: true,
+    [validatorSymbol]: true,
+    _type: void 0,
+    jsonSchema: schema,
+    validate: options.validate
+  };
+}
+function isWrappedSchema(value) {
+  return typeof value === "object" && value !== null && (schemaSymbol in value && value[schemaSymbol] === true || vercelSchemaSymbol in value && value[vercelSchemaSymbol] === true);
+}
+function extractJsonSchema(schema) {
+  if (isWrappedSchema(schema)) {
+    return schema.jsonSchema;
+  }
+  return schema;
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/compose.js
+var import_server = require("@modelcontextprotocol/sdk/server/index.js");
+
+// __mcpc__core_latest/node_modules/@jsr/mcpc__utils/src/json.js
+var import_jsonrepair = require("jsonrepair");
+function stripMarkdownAndText(text) {
+  text = text.trim();
+  text = text.replace(/^```(?:json)?\s*\n?/i, "");
+  text = text.replace(/\n?```\s*$/, "");
+  text = text.replace(/^(?:here is|here's|response|result|output|json):\s*/i, "");
+  const firstJsonIndex = text.search(/[\{\[]/);
+  if (firstJsonIndex >= 0) {
+    text = text.slice(firstJsonIndex);
+    let depth = 0;
+    let inString = false;
+    let escapeNext = false;
+    const startChar = text[0];
+    const endChar = startChar === "{" ? "}" : "]";
+    for (let i = 0; i < text.length; i++) {
+      const char = text[i];
+      if (escapeNext) {
+        escapeNext = false;
+        continue;
+      }
+      if (char === "\\") {
+        escapeNext = true;
+        continue;
+      }
+      if (char === '"' && !inString) {
+        inString = true;
+        continue;
+      }
+      if (char === '"' && inString) {
+        inString = false;
+        continue;
+      }
+      if (inString) continue;
+      if (char === startChar) {
+        depth++;
+      } else if (char === endChar) {
+        depth--;
+        if (depth === 0) {
+          return text.slice(0, i + 1);
+        }
+      }
+    }
+  }
+  return text.trim();
+}
+function parseJSON(text, throwError) {
+  try {
+    return JSON.parse(text);
+  } catch (_error) {
+    try {
+      const cleanedText = stripMarkdownAndText(text);
+      try {
+        return JSON.parse(cleanedText);
+      } catch {
+        const repairedText = (0, import_jsonrepair.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__core_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__core_latest/node_modules/@jsr/mcpc__utils/src/tool-tags.js
+var import_cheerio = require("cheerio");
+function parseTags(htmlString, tags) {
+  const $ = (0, import_cheerio.load)(htmlString, {
+    xml: {
+      decodeEntities: false
+    }
+  });
+  const tagToResults = {};
+  for (const tag of tags) {
+    const elements = $(tag);
+    tagToResults[tag] = elements.toArray();
+  }
+  return {
+    tagToResults,
+    $
+  };
+}
+
+// __mcpc__core_latest/node_modules/@jsr/mcpc__utils/src/transport/sse.js
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+
+// __mcpc__core_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__core_latest/node_modules/@mcpc/core/src/utils/common/mcp.js
+var import_client = require("@modelcontextprotocol/sdk/client/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+var import_sse = require("@modelcontextprotocol/sdk/client/sse.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+var import_inMemory = require("@modelcontextprotocol/sdk/inMemory.js");
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/utils/common/config.js
+var import_node_process = __toESM(require("node:process"), 1);
+var GEMINI_PREFERRED_FORMAT = import_node_process.default.env.GEMINI_PREFERRED_FORMAT === "0" ? false : true;
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/utils/common/json.js
+var import_jsonrepair2 = require("jsonrepair");
+var import_node_util = require("node:util");
+function parseJSON2(text, throwError) {
+  try {
+    return JSON.parse(text);
+  } catch (_error) {
+    try {
+      const repairedText = (0, import_jsonrepair2.jsonrepair)(text);
+      console.warn(`Failed to parse JSON, attempting to repair, result: ${text}`);
+      if (throwError) {
+        throw _error;
+      }
+      return JSON.parse(repairedText);
+    } catch {
+      if (throwError) {
+        throw new Error("Failed to parse repaired JSON");
+      }
+      return null;
+    }
+  }
+}
+function truncateJSON(obj) {
+  return (0, import_node_util.inspect)(obj, {
+    depth: 3,
+    colors: false,
+    maxStringLength: 120
+  });
+}
+function optionalObject(obj, condition) {
+  if (condition) {
+    return obj;
+  }
+  return {};
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/utils/common/provider.js
+function sanitizePropertyKey(name) {
+  return name.replace(/[@.,/\\:;!?#$%^&*()[\]{}]/g, "_").substring(0, 64);
+}
+var createModelCompatibleJSONSchema = (schema) => {
+  const validatorOnlyKeys = [
+    "errorMessage"
+  ];
+  const geminiRestrictedKeys = GEMINI_PREFERRED_FORMAT ? [
+    "additionalProperties"
+  ] : [];
+  const keysToRemove = /* @__PURE__ */ new Set([
+    ...validatorOnlyKeys,
+    ...geminiRestrictedKeys
+  ]);
+  let cleanSchema = schema;
+  if (GEMINI_PREFERRED_FORMAT) {
+    const { oneOf: _oneOf, allOf: _allOf, anyOf: _anyOf, ...rest2 } = schema;
+    cleanSchema = rest2;
+  }
+  const cleanRecursively = (obj) => {
+    if (Array.isArray(obj)) {
+      return obj.map(cleanRecursively);
+    }
+    if (obj && typeof obj === "object") {
+      const result = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (!keysToRemove.has(key)) {
+          result[key] = cleanRecursively(value);
+        }
+      }
+      return result;
+    }
+    return obj;
+  };
+  return cleanRecursively(cleanSchema);
+};
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/utils/common/mcp.js
+var import_node_process2 = require("node:process");
+var import_node_process3 = __toESM(require("node:process"), 1);
+var import_node_crypto = require("node:crypto");
+var mcpClientPool = /* @__PURE__ */ new Map();
+var mcpClientConnecting = /* @__PURE__ */ new Map();
+var shortHash = (s) => (0, import_node_crypto.createHash)("sha256").update(s).digest("hex").slice(0, 8);
+function defSignature(def) {
+  const defCopy = {
+    ...def
+  };
+  if (defCopy.transportType === "memory" || defCopy.transport) {
+    return `memory:${Date.now()}:${Math.random()}`;
+  }
+  return JSON.stringify(defCopy);
+}
+function createTransport(def) {
+  const defAny = def;
+  const explicitType = defAny.transportType || defAny.type;
+  if (explicitType === "memory") {
+    if (!defAny.server) {
+      throw new Error("In-memory transport requires a 'server' field with a Server instance");
+    }
+    const [clientTransport, serverTransport] = import_inMemory.InMemoryTransport.createLinkedPair();
+    defAny.server.connect(serverTransport).catch((err) => {
+      console.error("Error connecting in-memory server:", err);
+    });
+    return clientTransport;
+  }
+  if (explicitType === "sse") {
+    const options = {};
+    if (defAny.headers) {
+      options.requestInit = {
+        headers: defAny.headers
+      };
+      options.eventSourceInit = {
+        headers: defAny.headers
+      };
+    }
+    return new import_sse.SSEClientTransport(new URL(defAny.url), options);
+  }
+  if (defAny.url && typeof defAny.url === "string") {
+    const options = {};
+    if (defAny.headers) {
+      options.requestInit = {
+        headers: defAny.headers
+      };
+    }
+    return new import_streamableHttp.StreamableHTTPClientTransport(new URL(defAny.url), options);
+  }
+  if (explicitType === "stdio" || defAny.command) {
+    return new import_stdio.StdioClientTransport({
+      command: defAny.command,
+      args: defAny.args,
+      env: {
+        ...import_node_process3.default.env,
+        ...defAny.env ?? {}
+      },
+      cwd: (0, import_node_process2.cwd)()
+    });
+  }
+  throw new Error(`Unsupported transport configuration: ${JSON.stringify(def)}`);
+}
+async function getOrCreateMcpClient(defKey, def) {
+  const pooled = mcpClientPool.get(defKey);
+  if (pooled) {
+    pooled.refCount += 1;
+    return pooled.client;
+  }
+  const existingConnecting = mcpClientConnecting.get(defKey);
+  if (existingConnecting) {
+    const client = await existingConnecting;
+    const entry = mcpClientPool.get(defKey);
+    if (entry) entry.refCount += 1;
+    return client;
+  }
+  const transport = createTransport(def);
+  const connecting = (async () => {
+    const client = new import_client.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);
+    }
+  }));
+};
+import_node_process3.default.once?.("exit", () => {
+  cleanupAllPooledClients();
+});
+import_node_process3.default.once?.("SIGINT", () => {
+  cleanupAllPooledClients().finally(() => import_node_process3.default.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 = `${name}.${tool.name}`;
+        const internalToolName = tool.name;
+        const rawToolId = `${serverId}_${internalToolName}`;
+        const toolId = sanitizePropertyKey(rawToolId);
+        if (filterIn && !filterIn({
+          action: internalToolName,
+          tool,
+          mcpName: name,
+          toolNameWithScope,
+          internalToolName,
+          toolId
+        })) {
+          return;
+        }
+        const execute = (args) => allClients[serverId].callTool({
+          name: internalToolName,
+          arguments: args
+        }, void 0, {
+          timeout: def.toolCallTimeout
+        });
+        allTools[toolId] = {
+          ...tool,
+          execute,
+          _originalName: toolNameWithScope
+        };
+      });
+    } catch (error) {
+      console.error(`Error creating MCP client for ${name}:`, error);
+    }
+  }
+  const cleanupClients = async () => {
+    await Promise.all(acquiredKeys.map((k) => releaseMcpClient(k)));
+    acquiredKeys.length = 0;
+    Object.keys(allTools).forEach((key) => delete allTools[key]);
+    Object.keys(allClients).forEach((key) => delete allClients[key]);
+  };
+  return {
+    tools: allTools,
+    clients: allClients,
+    cleanupClients
+  };
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/utils/common/tool-tag-processor.js
+var ALL_TOOLS_PLACEHOLDER = "__ALL__";
+function findToolId(toolName, tools, toolNameMapping) {
+  const mappedId = toolNameMapping?.get(toolName);
+  if (mappedId) {
+    return mappedId;
+  }
+  return Object.keys(tools).find((id) => {
+    const dotNotation = id.replace(/_/g, ".");
+    return toolName === id || toolName === dotNotation;
+  });
+}
+function processToolTags({ description, tagToResults, $, tools, toolOverrides, toolNameMapping }) {
+  tagToResults.tool.forEach((toolEl) => {
+    const toolName = toolEl.attribs.name;
+    if (!toolName || toolName.includes(ALL_TOOLS_PLACEHOLDER)) {
+      $(toolEl).remove();
+      return;
+    }
+    const override = toolOverrides.get(toolName);
+    if (override?.visibility?.hidden) {
+      $(toolEl).remove();
+    } else if (override?.visibility?.public) {
+      $(toolEl).replaceWith(`<tool name="${toolName}"/>`);
+    } else {
+      const toolId = findToolId(toolName, tools, toolNameMapping);
+      if (toolId) {
+        $(toolEl).replaceWith(`<tool name="${toolId}"/>`);
+      } else {
+        $(toolEl).remove();
+      }
+    }
+  });
+  return $.root().html() ?? description;
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/built-in/config-plugin.js
+var createConfigPlugin = () => ({
+  name: "built-in-config",
+  version: "1.0.0",
+  enforce: "pre",
+  transformTool: (tool, context2) => {
+    const server = context2.server;
+    const config = server.findToolConfig?.(context2.toolName);
+    if (config?.description) {
+      tool.description = config.description;
+    }
+    return tool;
+  }
+});
+var config_plugin_default = createConfigPlugin();
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/built-in/tool-name-mapping-plugin.js
+var createToolNameMappingPlugin = () => ({
+  name: "built-in-tool-name-mapping",
+  version: "1.0.0",
+  enforce: "pre",
+  transformTool: (tool, context2) => {
+    const server = context2.server;
+    const toolName = context2.toolName;
+    const originalName = tool._originalName || toolName;
+    const dotNotation = originalName.replace(/_/g, ".");
+    const underscoreNotation = originalName.replace(/\./g, "_");
+    if (dotNotation !== originalName && server.toolNameMapping) {
+      server.toolNameMapping.set(dotNotation, toolName);
+    }
+    if (underscoreNotation !== originalName && server.toolNameMapping) {
+      server.toolNameMapping.set(underscoreNotation, toolName);
+    }
+    if (originalName !== toolName && server.toolNameMapping) {
+      server.toolNameMapping.set(originalName, toolName);
+    }
+    return tool;
+  }
+});
+var tool_name_mapping_plugin_default = createToolNameMappingPlugin();
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/utils/logger.js
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  notice: 2,
+  warning: 3,
+  error: 4,
+  critical: 5,
+  alert: 6,
+  emergency: 7
+};
+var MCPLogger = class _MCPLogger {
+  server;
+  loggerName;
+  minLevel = "debug";
+  constructor(loggerName = "mcpc", 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}:${level}]`;
+    console.error(prefix, message);
+  }
+  debug(data) {
+    return this.log("debug", data);
+  }
+  info(data) {
+    return this.log("info", data);
+  }
+  notice(data) {
+    return this.log("notice", data);
+  }
+  warning(data) {
+    return this.log("warning", data);
+  }
+  error(data) {
+    return this.log("error", data);
+  }
+  critical(data) {
+    return this.log("critical", data);
+  }
+  alert(data) {
+    return this.log("alert", data);
+  }
+  emergency(data) {
+    return this.log("emergency", data);
+  }
+  child(name) {
+    const child = new _MCPLogger(`${this.loggerName}.${name}`, this.server);
+    child.setLevel(this.minLevel);
+    return child;
+  }
+};
+var logger = new MCPLogger("mcpc");
+function createLogger(name, server) {
+  return new MCPLogger(name, server);
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/built-in/logging-plugin.js
+var createLoggingPlugin = (options = {}) => {
+  const { enabled = true, verbose = false, compact: compact2 = true } = options;
+  return {
+    name: "built-in-logging",
+    version: "1.0.0",
+    composeEnd: async (context2) => {
+      if (!enabled) return;
+      const logger2 = createLogger("mcpc.plugin.logging", context2.server);
+      if (compact2) {
+        const pluginCount = context2.pluginNames.length;
+        const { stats } = context2;
+        await logger2.info(`[${context2.toolName}] ${pluginCount} plugins \u2022 ${stats.publicTools} public \u2022 ${stats.hiddenTools} hidden`);
+      } else if (verbose) {
+        await logger2.info(`[${context2.toolName}] Composition complete`);
+        await logger2.info(`   \u251C\u2500 Plugins: ${context2.pluginNames.join(", ")}`);
+        const { stats } = context2;
+        const server = context2.server;
+        const publicTools = Array.from(new Set(server.getPublicToolNames().map(String)));
+        const internalTools = Array.from(new Set(server.getInternalToolNames().map(String)));
+        const hiddenTools = Array.from(new Set(server.getHiddenToolNames().map(String)));
+        const normalInternal = internalTools.filter((name) => !hiddenTools.includes(name));
+        if (publicTools.length > 0) {
+          await logger2.info(`   \u251C\u2500 Public: ${publicTools.join(", ")}`);
+        }
+        if (internalTools.length > 0) {
+          const parts = [];
+          if (normalInternal.length > 0) {
+            parts.push(normalInternal.join(", "));
+          }
+          if (hiddenTools.length > 0) {
+            parts.push(`(${hiddenTools.join(", ")})`);
+          }
+          await logger2.info(`   \u251C\u2500 Internal: ${parts.join(", ")}`);
+        }
+        await logger2.info(`   \u2514\u2500 Total: ${stats.totalTools} tools`);
+      }
+    }
+  };
+};
+var logging_plugin_default = createLoggingPlugin({
+  verbose: true,
+  compact: false
+});
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/prompts/index.js
+var SystemPrompts = {
+  /**
+   * Base system prompt for autonomous MCP execution
+   */
+  AUTONOMOUS_EXECUTION: `Agentic tool \`{toolName}\` that executes complex tasks by iteratively selecting and calling tools, gathering results, and continuing until completion. Use this tool when the task matches the manual below.
+
+You must follow the <manual/>, obey the <execution_rules/>, and use the <call_format/>.
+
+<manual>
+{description}
+</manual>
+
+<parameters>
+\`useTool\` - Which tool to execute this iteration
+\`hasDefinitions\` - Tool names whose schemas you already have
+\`definitionsOf\` - Tool names whose schemas you need
+</parameters>
+
+<execution_rules>
+1. **First call**: No tool definitions available\u2014you must request them via \`definitionsOf\`
+2. **When executing tools**: Must provide \`hasDefinitions\` with ALL tools you have schemas for (avoid duplicate requests and reduce tokens)
+3. **When requesting definitions**: Use \`definitionsOf\` to request tool schemas you need
+4. **Both together**: Execute tool AND request new definitions in one call for efficiency
+5. **Never request definitions you already have**
+6. **Select** one tool to execute per call using \`useTool\`
+7. **Provide** parameters matching the selected tool name
+8. Note: You are an agent exposed as an MCP tool - **\`useTool\` is an internal parameter for choosing which tool to execute, NOT an external MCP tool you can call**
+</execution_rules>
+
+<call_format>
+Initial definition request:
+\`\`\`json
+{
+  "hasDefinitions": [],
+  "definitionsOf": ["tool1", "tool2"]
+}
+\`\`\`
+
+Execute tool + get new definitions:
+\`\`\`json
+{
+  "useTool": "tool1",
+  "tool1": { /* parameters */ },
+  "hasDefinitions": ["tool1", "tool2"],
+  "definitionsOf": ["tool3"]
+}
+\`\`\`
+</call_format>`,
+  /**
+   * Workflow execution system prompt
+   */
+  WORKFLOW_EXECUTION: `Workflow tool \`{toolName}\` that executes multi-step workflows. Use this when your task requires sequential steps.
+
+<manual>
+{description}
+</manual>
+
+<rules>
+1. First call: {planningInstructions}
+2. Subsequent calls: Provide only current step parameters
+3. Use \`decision: "proceed"\` to advance, \`"retry"\` to retry, \`"complete"\` when done
+4. Include \`steps\` ONLY with \`init: true\`, never during execution
+</rules>`,
+  /**
+   * JSON-only execution system prompt for autonomous sampling mode
+   *
+   * Note: Sampling mode runs an internal LLM loop that autonomously calls tools until complete.
+   */
+  SAMPLING_EXECUTION: `Agent \`{toolName}\` that completes tasks by calling tools in an autonomous loop.
+
+<manual>
+{description}
+</manual>
+
+<rules>
+1. Return valid JSON only (no markdown, no explanations)
+2. Execute one action per iteration
+3. When \`action\` is "X", include parameter "X" with tool inputs
+4. Adapt based on results from previous actions
+5. Continue until task is complete
+</rules>
+
+<format>
+During execution:
+\`\`\`json
+{
+  "action": "tool_name",
+  "decision": "proceed|retry",
+  "tool_name": { /* parameters */ }
+}
+\`\`\`
+
+When complete (omit action):
+\`\`\`json
+{ "decision": "complete" }
+\`\`\`
+
+Decisions:
+- \`proceed\` = action succeeded, continue
+- \`retry\` = action failed, try again
+- \`complete\` = task finished
+</format>
+
+<tools>
+{toolList}
+</tools>`,
+  /**
+   * Sampling workflow execution system prompt combining sampling with workflow capabilities
+   *
+   * Note: Sampling mode runs an internal LLM loop that autonomously executes workflows.
+   */
+  SAMPLING_WORKFLOW_EXECUTION: `Workflow agent \`{toolName}\` that executes multi-step workflows autonomously.
+
+<manual>
+{description}
+</manual>
+
+<rules>
+1. Return valid JSON only
+2. First iteration: Plan workflow and initialize with \`init: true\`
+3. Subsequent iterations: Execute current step
+4. Adapt based on step results
+5. Continue until all steps complete
+</rules>
+
+<format>
+Initialize workflow (first iteration):
+\`\`\`json
+{
+  "action": "{toolName}",
+  "init": true,
+  "steps": [/* workflow steps */]
+}
+\`\`\`
+
+Execute step (subsequent iterations):
+\`\`\`json
+{
+  "action": "{toolName}",
+  "decision": "proceed|retry",
+  /* step parameters */
+}
+\`\`\`
+
+Complete workflow (omit action):
+\`\`\`json
+{ "decision": "complete" }
+\`\`\`
+
+Decisions:
+- \`proceed\` = step succeeded, next step
+- \`retry\` = step failed, retry current
+- \`complete\` = workflow finished
+
+Rules:
+- Include \`steps\` ONLY with \`init: true\`
+- Omit \`steps\` during step execution
+- Use \`decision: "retry"\` for failed steps
+</format>`
+};
+var WorkflowPrompts = {
+  /**
+   * Workflow initialization instructions
+   */
+  WORKFLOW_INIT: `Workflow initialized with {stepCount} steps. Execute step 1: \`{currentStepDescription}\`
+
+Schema: {schemaDefinition}
+
+Call \`{toolName}\` with:
+- Parameters matching schema above
+- \`decision: "proceed"\` to advance, \`"retry"\` to retry, \`"complete"\` when done
+- Omit \`steps\` (only used with \`init: true\`)
+
+{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: `Previous step completed.
+
+Choose action:
+- RETRY: Call \`{toolName}\` with \`decision: "retry"\`
+- PROCEED: Call \`{toolName}\` with \`decision: "proceed"\` and parameters below
+
+Next: \`{nextStepDescription}\`
+{nextStepSchema}
+
+(Omit \`steps\` parameter)`,
+  /**
+   * Final step completion prompt
+   */
+  FINAL_STEP_COMPLETION: `Final step executed {statusIcon} - {statusText}
+
+Choose:
+- RETRY: \`decision: "retry"\`
+- COMPLETE: \`decision: "complete"\`
+- NEW: \`init: true\`{newWorkflowInstructions}`,
+  /**
+   * Workflow completion success message
+   */
+  WORKFLOW_COMPLETED: `Workflow completed ({totalSteps} steps)
+
+Start new workflow: \`{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 \`{currentAction}\` completed.
+
+Next: Execute \`{nextAction}\` by calling \`{toolName}\` again.`,
+  /**
+   * Planning prompt when no next action is specified
+   */
+  PLANNING_PROMPT: `Action \`{currentAction}\` completed. Determine next step:
+
+1. Analyze results from \`{currentAction}\`
+2. Decide: Continue with another action or Complete?
+3. Call \`{toolName}\` with chosen action or \`decision: "complete"\``,
+  /**
+   * Error response templates
+   */
+  ERROR_RESPONSE: `Validation failed: {errorMessage}
+
+Adjust parameters and retry.`,
+  WORKFLOW_ERROR_RESPONSE: `Step failed: {errorMessage}
+
+Fix parameters and call with \`decision: "retry"\``,
+  /**
+   * Completion message
+   */
+  COMPLETION_MESSAGE: `Task completed.`,
+  /**
+   * Security validation messages
+   */
+  SECURITY_VALIDATION: {
+    PASSED: `Security check passed: {operation} on {path}`,
+    FAILED: `Security check failed: {operation} on {path}`
+  },
+  /**
+   * Audit log messages
+   */
+  AUDIT_LOG: `[{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: "[PENDING]",
+      running: "[RUNNING]",
+      completed: "[DONE]",
+      failed: "[FAILED]"
+    };
+    return progressData.steps.map((step, index) => {
+      const status = progressData.statuses[index] || "pending";
+      const icon = statusIcons[status] || "[PENDING]";
+      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__core_latest/node_modules/@mcpc/core/src/utils/schema-validator.js
+var import_ajv = require("ajv");
+var import_ajv_formats = __toESM(require("ajv-formats"), 1);
+var import_ajv_errors = __toESM(require("ajv-errors"), 1);
+var import_ajv_human_errors = require("@segment/ajv-human-errors");
+var ajv = new import_ajv.Ajv({
+  allErrors: true,
+  verbose: true
+});
+import_ajv_formats.default.default(ajv);
+import_ajv_errors.default.default(ajv);
+function validateSchema(args, schema) {
+  const validate = ajv.compile(schema);
+  if (!validate(args)) {
+    const errors = validate.errors;
+    const customErrors = errors.filter((err) => err.keyword === "errorMessage");
+    if (customErrors.length > 0) {
+      const messages = [
+        ...new Set(customErrors.map((err) => err.message))
+      ];
+      return {
+        valid: false,
+        error: messages.join("; ")
+      };
+    }
+    const aggregateError = new import_ajv_human_errors.AggregateAjvError(errors);
+    return {
+      valid: false,
+      error: aggregateError.message
+    };
+  }
+  return {
+    valid: true
+  };
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/utils/tracing.js
+var import_api = require("@opentelemetry/api");
+var import_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+var import_resources = require("@opentelemetry/resources");
+var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+var tracerProvider = null;
+var tracer = null;
+var isInitialized = false;
+function initializeTracing(config = {}) {
+  if (isInitialized) {
+    return;
+  }
+  const { enabled = true, serviceName = "mcpc-sampling", serviceVersion = "0.2.0", exportTo = "console", otlpEndpoint = "http://localhost:4318/v1/traces", otlpHeaders = {} } = config;
+  if (!enabled) {
+    isInitialized = true;
+    return;
+  }
+  const resource = import_resources.Resource.default().merge(new import_resources.Resource({
+    [import_semantic_conventions.ATTR_SERVICE_NAME]: serviceName,
+    [import_semantic_conventions.ATTR_SERVICE_VERSION]: serviceVersion
+  }));
+  tracerProvider = new import_sdk_trace_node.NodeTracerProvider({
+    resource
+  });
+  if (exportTo === "console") {
+    tracerProvider.addSpanProcessor(new import_sdk_trace_base.SimpleSpanProcessor(new import_sdk_trace_base.ConsoleSpanExporter()));
+  } else if (exportTo === "otlp") {
+    const otlpExporter = new import_exporter_trace_otlp_http.OTLPTraceExporter({
+      url: otlpEndpoint,
+      headers: otlpHeaders
+    });
+    tracerProvider.addSpanProcessor(new import_sdk_trace_base.BatchSpanProcessor(otlpExporter));
+  }
+  tracerProvider.register();
+  tracer = import_api.trace.getTracer(serviceName, serviceVersion);
+  isInitialized = true;
+}
+function getTracer() {
+  if (!isInitialized) {
+    initializeTracing();
+  }
+  return tracer;
+}
+function startSpan(name, attributes, parent) {
+  const tracer2 = getTracer();
+  const ctx = parent ? import_api.trace.setSpan(import_api.context.active(), parent) : void 0;
+  return tracer2.startSpan(name, {
+    attributes
+  }, ctx);
+}
+function endSpan(span, error) {
+  if (error) {
+    span.setStatus({
+      code: import_api.SpanStatusCode.ERROR,
+      message: error.message
+    });
+    span.recordException(error);
+  } else {
+    span.setStatus({
+      code: import_api.SpanStatusCode.OK
+    });
+  }
+  span.end();
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/agentic/agentic-executor.js
+var import_node_process4 = __toESM(require("node:process"), 1);
+var AgenticExecutor = class {
+  name;
+  allToolNames;
+  toolNameToDetailList;
+  server;
+  USE_TOOL_KEY;
+  logger;
+  tracingEnabled;
+  constructor(name, allToolNames, toolNameToDetailList, server, USE_TOOL_KEY = "useTool") {
+    this.name = name;
+    this.allToolNames = allToolNames;
+    this.toolNameToDetailList = toolNameToDetailList;
+    this.server = server;
+    this.USE_TOOL_KEY = USE_TOOL_KEY;
+    this.tracingEnabled = false;
+    this.logger = createLogger(`mcpc.agentic.${name}`, server);
+    try {
+      this.tracingEnabled = import_node_process4.default.env.MCPC_TRACING_ENABLED === "true";
+      if (this.tracingEnabled) {
+        initializeTracing({
+          enabled: true,
+          serviceName: `mcpc-agentic-${name}`,
+          exportTo: import_node_process4.default.env.MCPC_TRACING_EXPORT ?? "otlp",
+          otlpEndpoint: import_node_process4.default.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
+        });
+      }
+    } catch {
+      this.tracingEnabled = false;
+    }
+  }
+  async execute(args, schema, parentSpan) {
+    const executeSpan = this.tracingEnabled ? startSpan("mcpc.agentic_execute", {
+      agent: this.name,
+      selectTool: String(args[this.USE_TOOL_KEY] ?? "unknown"),
+      args: JSON.stringify(args)
+    }, parentSpan ?? void 0) : 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",
+          selectTool: args[this.USE_TOOL_KEY],
+          error: validationResult.error
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: CompiledPrompts.errorResponse({
+                errorMessage: validationResult.error || "Validation failed"
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      const useTool = args[this.USE_TOOL_KEY];
+      const definitionsOf = args.definitionsOf || [];
+      const hasDefinitions = args.hasDefinitions || [];
+      if (!useTool) {
+        if (executeSpan) {
+          executeSpan.setAttributes({
+            toolType: "none",
+            completion: true
+          });
+          endSpan(executeSpan);
+        }
+        const result = {
+          content: []
+        };
+        this.appendToolSchemas(result, definitionsOf, hasDefinitions);
+        if (result.content.length === 0 && definitionsOf.length > 0) {
+          result.content.push({
+            type: "text",
+            text: `All requested tool schemas are already in hasDefinitions. You can now call a tool using "${this.USE_TOOL_KEY}".`
+          });
+        }
+        return result;
+      }
+      if (executeSpan) {
+        try {
+          const safeTool = String(useTool).replace(/\s+/g, "_");
+          if (typeof executeSpan.updateName === "function") {
+            executeSpan.updateName(`mcpc.agentic_execute.${safeTool}`);
+          }
+        } catch {
+        }
+      }
+      const currentTool = this.toolNameToDetailList.find(([name, _detail]) => name === useTool)?.[1];
+      if (currentTool) {
+        if (executeSpan) {
+          executeSpan.setAttributes({
+            toolType: "external",
+            selectedTool: useTool
+          });
+        }
+        this.logger.debug({
+          message: "Executing external tool",
+          selectTool: useTool
+        });
+        const currentResult = await currentTool.execute({
+          ...args[useTool]
+        });
+        this.appendToolSchemas(currentResult, definitionsOf, hasDefinitions);
+        if (executeSpan) {
+          executeSpan.setAttributes({
+            success: true,
+            isError: !!currentResult.isError,
+            resultContentLength: currentResult.content?.length || 0,
+            toolResult: JSON.stringify(currentResult)
+          });
+          endSpan(executeSpan);
+        }
+        return currentResult;
+      }
+      if (this.allToolNames.includes(useTool)) {
+        if (executeSpan) {
+          executeSpan.setAttributes({
+            toolType: "internal",
+            selectedTool: useTool
+          });
+        }
+        this.logger.debug({
+          message: "Executing internal tool",
+          selectTool: useTool
+        });
+        try {
+          const result = await this.server.callTool(useTool, args[useTool]);
+          const callToolResult = result ?? {
+            content: []
+          };
+          this.appendToolSchemas(callToolResult, definitionsOf, hasDefinitions);
+          if (executeSpan) {
+            executeSpan.setAttributes({
+              success: true,
+              isError: !!callToolResult.isError,
+              resultContentLength: callToolResult.content?.length || 0,
+              toolResult: JSON.stringify(callToolResult)
+            });
+            endSpan(executeSpan);
+          }
+          return callToolResult;
+        } catch (error) {
+          if (executeSpan) {
+            endSpan(executeSpan, error);
+          }
+          this.logger.error({
+            message: "Error executing internal tool",
+            useTool,
+            error: String(error)
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error executing internal tool ${useTool}: ${error instanceof Error ? error.message : String(error)}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+      if (executeSpan) {
+        executeSpan.setAttributes({
+          toolType: "not_found",
+          useTool
+        });
+        endSpan(executeSpan);
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Tool "${useTool}" not found. Available tools: ${this.allToolNames.join(", ")}.`
+          }
+        ],
+        isError: true
+      };
+    } 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
+      };
+    }
+  }
+  // Append tool schemas to result if requested
+  appendToolSchemas(result, definitionsOf, hasDefinitions) {
+    const schemasToProvide = definitionsOf.filter((toolName) => !hasDefinitions.includes(toolName));
+    if (schemasToProvide.length === 0) {
+      return;
+    }
+    const definitionTexts = [];
+    for (const toolName of schemasToProvide) {
+      const toolDetail = this.toolNameToDetailList.find(([name]) => name === toolName);
+      if (toolDetail) {
+        const [name, schema] = toolDetail;
+        const schemaJson = JSON.stringify(schema, null, 2);
+        definitionTexts.push(`<tool_definition name="${name}">
+${schemaJson}
+</tool_definition>`);
+      }
+    }
+    if (definitionTexts.length > 0) {
+      result.content.push({
+        type: "text",
+        text: `${definitionTexts.join("\n\n")}`
+      });
+    }
+  }
+  // Validate arguments using JSON schema
+  validate(args, schema) {
+    return validateSchema(args, schema);
+  }
+};
+
+// __mcpc__core_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__core_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__core_latest/node_modules/@jsr/es-toolkit__es-toolkit/src/function/retry.js
+var DEFAULT_RETRIES = Number.POSITIVE_INFINITY;
+
+// __mcpc__core_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__core_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__core_latest/node_modules/@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**`,
+      errorMessage: {
+        enum: `Invalid decision. Must be one of: ${Object.values(DECISION_OPTIONS).join(", ")}.`
+      }
+    }),
+    action: () => ({
+      type: "string",
+      description: "Define the current workflow action to be performed",
+      enum: allToolNames,
+      required: [
+        "action"
+      ],
+      errorMessage: {
+        enum: `Invalid action. Must be one of: ${allToolNames.join(", ")}.`
+      }
+    }),
+    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"
+        ],
+        errorMessage: {
+          required: {
+            userRequest: "Missing required field 'userRequest'. Please provide a clear task description.",
+            context: "Missing required field 'context'. Please provide relevant context (e.g., current working directory)."
+          }
+        }
+      };
+    },
+    forAgentic: function(toolNameToDetailList, _sampling = false, USE_TOOL_KEY = "useTool") {
+      const allOf = [
+        // When a specific tool is selected, its parameters must be provided
+        ...toolNameToDetailList.map(([toolName, _toolDetail]) => {
+          return {
+            if: {
+              properties: {
+                [USE_TOOL_KEY]: {
+                  const: toolName
+                }
+              },
+              required: [
+                USE_TOOL_KEY
+              ]
+            },
+            then: {
+              required: [
+                toolName
+              ],
+              errorMessage: {
+                required: {
+                  [toolName]: `Tool "${toolName}" is selected but its parameters are missing. Please provide "${toolName}": { ...parameters }.`
+                }
+              }
+            }
+          };
+        })
+      ];
+      const useToolDescription = `Specifies which tool to execute from the available options. **When setting \`useTool: "example_tool"\`, you MUST also provide \`"example_tool": { ...parameters }\` with that tool's parameters**`;
+      const toolItems = allToolNames.length > 0 ? {
+        type: "string",
+        enum: allToolNames
+      } : {
+        type: "string"
+      };
+      const baseProperties = {
+        [USE_TOOL_KEY]: {
+          type: "string",
+          enum: allToolNames,
+          description: useToolDescription,
+          errorMessage: {
+            enum: `Invalid tool name. Available tools: ${allToolNames.join(", ")}.`
+          }
+        },
+        hasDefinitions: {
+          type: "array",
+          items: toolItems,
+          description: "Tool names whose schemas you already have. List all tools you have schemas for to avoid duplicate schema requests and reduce token usage."
+        },
+        definitionsOf: {
+          type: "array",
+          items: toolItems,
+          description: "Tool names whose schemas you need. Request tool schemas before calling them to understand their parameters."
+        }
+      };
+      const requiredFields = [];
+      const schema = {
+        additionalProperties: true,
+        type: "object",
+        properties: baseProperties,
+        required: requiredFields
+      };
+      if (allOf.length > 0) {
+        schema.allOf = allOf;
+      }
+      if (allToolNames.length > 0) {
+        const thenClause = {
+          required: [
+            USE_TOOL_KEY
+          ],
+          errorMessage: {
+            required: {
+              [USE_TOOL_KEY]: `No tool selected. Please specify "${USE_TOOL_KEY}" to select one of: ${allToolNames.join(", ")}. Or use "definitionsOf" with tool names to get their schemas first.`
+            }
+          }
+        };
+        Object.assign(schema, {
+          if: {
+            // definitionsOf is not provided OR is empty array
+            anyOf: [
+              {
+                not: {
+                  required: [
+                    "definitionsOf"
+                  ]
+                }
+              },
+              {
+                properties: {
+                  definitionsOf: {
+                    type: "array",
+                    maxItems: 0
+                  }
+                }
+              }
+            ]
+          },
+          then: thenClause
+        });
+      }
+      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__core_latest/node_modules/@mcpc/core/src/executors/agentic/agentic-tool-registrar.js
+function registerAgenticTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList }) {
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
+  const agenticExecutor = new AgenticExecutor(name, allToolNames, toolNameToDetailList, server);
+  description = CompiledPrompts.autonomousExecution({
+    toolName: name,
+    description
+  });
+  const agenticArgsDef = createArgsDef.forAgentic(toolNameToDetailList, false);
+  const argsDef = agenticArgsDef;
+  const schema = allToolNames.length > 0 ? argsDef : {
+    type: "object",
+    properties: {}
+  };
+  server.tool(name, description, jsonSchema(createModelCompatibleJSONSchema(schema)), async (args) => {
+    return await agenticExecutor.execute(args, schema);
+  });
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/built-in/mode-agentic-plugin.js
+var createAgenticModePlugin = () => ({
+  name: "mode-agentic",
+  version: "1.0.0",
+  // Only apply to agentic mode
+  apply: "agentic",
+  // Register the agent tool
+  registerAgentTool: (context2) => {
+    registerAgenticTool(context2.server, {
+      description: context2.description,
+      name: context2.name,
+      allToolNames: context2.allToolNames,
+      depGroups: context2.depGroups,
+      toolNameToDetailList: context2.toolNameToDetailList
+    });
+  }
+});
+var mode_agentic_plugin_default = createAgenticModePlugin();
+
+// __mcpc__core_latest/node_modules/@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__core_latest/node_modules/@mcpc/core/src/executors/workflow/workflow-executor.js
+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.validateInput(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.validateInput(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
+  validateInput(args, schema) {
+    return validateSchema(args, schema);
+  }
+};
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/workflow/workflow-tool-registrar.js
+function registerAgenticWorkflowTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList, predefinedSteps, ensureStepActions, toolNameToIdMapping }) {
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, predefinedSteps, ensureStepActions);
+  const workflowExecutor = new WorkflowExecutor(name, allToolNames, toolNameToDetailList, createArgsDef, server, predefinedSteps, ensureStepActions, toolNameToIdMapping);
+  const workflowState = new WorkflowState();
+  const planningInstructions = predefinedSteps ? "- Set `init: true` (steps are predefined)" : "- Set `init: true` and define complete `steps` array";
+  const baseDescription = CompiledPrompts.workflowExecution({
+    toolName: name,
+    description,
+    planningInstructions
+  });
+  const argsDef = createArgsDef.forTool();
+  const toolDescription = createArgsDef.forToolDescription(baseDescription, workflowState);
+  server.tool(name, toolDescription, jsonSchema(createModelCompatibleJSONSchema(argsDef)), async (args) => {
+    try {
+      return await workflowExecutor.execute(args, workflowState);
+    } catch (error) {
+      workflowState.reset();
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Workflow execution error: ${error.message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/built-in/mode-workflow-plugin.js
+var createWorkflowModePlugin = () => ({
+  name: "mode-workflow",
+  version: "1.0.0",
+  // Only apply to workflow mode
+  apply: "agentic_workflow",
+  // Register the agent tool
+  registerAgentTool: (context2) => {
+    registerAgenticWorkflowTool(context2.server, {
+      description: context2.description,
+      name: context2.name,
+      allToolNames: context2.allToolNames,
+      depGroups: context2.depGroups,
+      toolNameToDetailList: context2.toolNameToDetailList,
+      predefinedSteps: context2.options.steps,
+      ensureStepActions: context2.options.ensureStepActions,
+      toolNameToIdMapping: context2.toolNameToIdMapping
+    });
+  }
+});
+var mode_workflow_plugin_default = createWorkflowModePlugin();
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/sampling/base-sampling-executor.js
+var import_node_process5 = __toESM(require("node:process"), 1);
+var BaseSamplingExecutor = class {
+  name;
+  description;
+  allToolNames;
+  toolNameToDetailList;
+  server;
+  conversationHistory;
+  maxIterations;
+  currentIteration;
+  logger;
+  tracingEnabled;
+  summarize;
+  constructor(name, description, allToolNames, toolNameToDetailList, server, config) {
+    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 (config?.maxIterations) {
+      this.maxIterations = config.maxIterations;
+    }
+    if (config?.summarize !== void 0) {
+      this.summarize = config.summarize;
+    }
+    this.logger = createLogger(`mcpc.sampling.${name}`, server);
+    try {
+      const tracingConfig = {
+        enabled: import_node_process5.default.env.MCPC_TRACING_ENABLED === "true",
+        serviceName: `mcpc-sampling-${name}`,
+        exportTo: import_node_process5.default.env.MCPC_TRACING_EXPORT ?? "otlp",
+        otlpEndpoint: import_node_process5.default.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 ONE AND ONLY ONE raw JSON object (no code fences, explanations, or multiple objects). During execution provide: {"action":"<tool>","decision":"proceed|retry","<tool>":{}}. When complete provide: {"decision":"complete"}'
+        }
+      }
+    ];
+    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;
+          }
+          this.conversationHistory.push({
+            role: "assistant",
+            content: {
+              type: "text",
+              text: JSON.stringify(parsedData, null, 2)
+            }
+          });
+          const action = parsedData["action"];
+          const decision = parsedData["decision"];
+          if (typeof decision !== "string") {
+            this.conversationHistory.push({
+              role: "user",
+              content: {
+                type: "text",
+                text: 'Missing required field "decision". Provide: {"action":"<tool>","decision":"proceed|retry","<tool>":{}} or {"decision":"complete"}'
+              }
+            });
+            if (iterationSpan) endSpan(iterationSpan);
+            continue;
+          }
+          if (decision === "complete" && action) {
+            this.conversationHistory.push({
+              role: "user",
+              content: {
+                type: "text",
+                text: 'Invalid: Cannot have both "decision":"complete" and "action" field. When complete, only provide {"decision":"complete"}.'
+              }
+            });
+            if (iterationSpan) endSpan(iterationSpan);
+            continue;
+          }
+          if (decision !== "complete" && !action) {
+            this.conversationHistory.push({
+              role: "user",
+              content: {
+                type: "text",
+                text: 'Missing required field "action". When executing, provide: {"action":"<tool>","decision":"proceed|retry","<tool>":{}}'
+              }
+            });
+            if (iterationSpan) endSpan(iterationSpan);
+            continue;
+          }
+          const actionStr = decision === "complete" ? "completion" : 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;
+          const result = await this.processAction(parsedData, schema, state, iterationSpan);
+          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),
+              decision: typeof decision === "string" ? decision : String(decision),
+              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) {
+    const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+    this.conversationHistory.push({
+      role: "user",
+      content: {
+        type: "text",
+        text: `Invalid JSON: ${errorMsg}
+
+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 ONE AND ONLY ONE raw JSON object that passes JSON.parse() - no markdown, code blocks, explanatory text, or multiple JSON objects
+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 a single JSON object, nothing else
+
+INVALID: \`\`\`json{"key":"value"}\`\`\` or "Here is: {"key":"value"}" or {"key":"value"}{"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(createModelCompatibleJSONSchema(schema), null, 2) : void 0,
+      schemaSuffix
+    ].filter((line) => line != null).join("\n");
+  }
+  // Validate arguments using JSON schema
+  validateInput(args, schema) {
+    return validateSchema(args, schema);
+  }
+};
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/sampling/agentic-sampling-executor.js
+var SamplingExecutor = class extends BaseSamplingExecutor {
+  agenticExecutor;
+  constructor(name, description, allToolNames, toolNameToDetailList, server, config) {
+    super(name, description, allToolNames, toolNameToDetailList, server, config);
+    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 = 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, parentSpan);
+      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
+You will now use agentic sampling to complete the following task: "${userRequest}"${contextInfo}
+
+When you need to use a tool, specify the tool name in 'action' and provide tool-specific parameters as additional properties.`;
+    return this.injectJsonInstruction({
+      prompt: basePrompt + taskPrompt,
+      schema: agenticSchema
+    });
+  }
+};
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/agentic/agentic-sampling-registrar.js
+function registerAgenticSamplingTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList, samplingConfig }) {
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
+  const samplingExecutor = new SamplingExecutor(name, description, allToolNames, toolNameToDetailList, server, samplingConfig);
+  description = CompiledPrompts.samplingExecution({
+    toolName: name,
+    description,
+    toolList: allToolNames.map((name2) => `- ${name2}`).join("\n")
+  });
+  const argsDef = createArgsDef.forSampling();
+  const schema = allToolNames.length > 0 ? argsDef : {
+    type: "object",
+    properties: {}
+  };
+  server.tool(name, description, jsonSchema(createModelCompatibleJSONSchema(schema)), async (args) => {
+    return await samplingExecutor.executeSampling(args, schema);
+  });
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/built-in/mode-agentic-sampling-plugin.js
+var createAgenticSamplingModePlugin = () => ({
+  name: "mode-agentic-sampling",
+  version: "1.0.0",
+  // Only apply to agentic_sampling mode
+  apply: "agentic_sampling",
+  // Register the agent tool with sampling
+  registerAgentTool: (context2) => {
+    registerAgenticSamplingTool(context2.server, {
+      description: context2.description,
+      name: context2.name,
+      allToolNames: context2.allToolNames,
+      depGroups: context2.depGroups,
+      toolNameToDetailList: context2.toolNameToDetailList,
+      samplingConfig: context2.options.samplingConfig
+    });
+  }
+});
+var mode_agentic_sampling_plugin_default = createAgenticSamplingModePlugin();
+
+// __mcpc__core_latest/node_modules/@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, config) {
+    super(name, description, allToolNames, toolNameToDetailList, server, config), this.createArgsDef = createArgsDef, this.predefinedSteps = predefinedSteps;
+    this.workflowExecutor = new WorkflowExecutor(name, allToolNames, toolNameToDetailList, createArgsDef, server, predefinedSteps);
+  }
+  async executeWorkflowSampling(args, schema, state) {
+    const validationResult = 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__core_latest/node_modules/@mcpc/core/src/executors/workflow/workflow-sampling-registrar.js
+function registerWorkflowSamplingTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList, predefinedSteps, samplingConfig, ensureStepActions, toolNameToIdMapping: _toolNameToIdMapping }) {
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, predefinedSteps, ensureStepActions);
+  const workflowSamplingExecutor = new WorkflowSamplingExecutor(name, description, allToolNames, toolNameToDetailList, createArgsDef, server, predefinedSteps, samplingConfig);
+  const workflowState = new WorkflowState();
+  const baseDescription = CompiledPrompts.samplingExecution({
+    toolName: name,
+    description,
+    toolList: allToolNames.map((name2) => `- ${name2}`).join("\n")
+  });
+  const argsDef = createArgsDef.forSampling();
+  const schema = allToolNames.length > 0 ? argsDef : {
+    type: "object",
+    properties: {}
+  };
+  server.tool(name, baseDescription, jsonSchema(createModelCompatibleJSONSchema(schema)), async (args) => {
+    try {
+      return await workflowSamplingExecutor.executeWorkflowSampling(args, schema, workflowState);
+    } catch (error) {
+      workflowState.reset();
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Workflow execution error: ${error.message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/built-in/mode-workflow-sampling-plugin.js
+var createWorkflowSamplingModePlugin = () => ({
+  name: "mode-agentic-workflow-sampling",
+  version: "1.0.0",
+  // Only apply to agentic_workflow_sampling mode
+  apply: "agentic_workflow_sampling",
+  // Register the agent tool with sampling
+  registerAgentTool: (context2) => {
+    registerWorkflowSamplingTool(context2.server, {
+      description: context2.description,
+      name: context2.name,
+      allToolNames: context2.allToolNames,
+      depGroups: context2.depGroups,
+      toolNameToDetailList: context2.toolNameToDetailList,
+      predefinedSteps: context2.options.steps,
+      samplingConfig: context2.options.samplingConfig,
+      ensureStepActions: context2.options.ensureStepActions,
+      toolNameToIdMapping: context2.toolNameToIdMapping
+    });
+  }
+});
+var mode_workflow_sampling_plugin_default = createWorkflowSamplingModePlugin();
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/built-in/index.js
+function getBuiltInPlugins() {
+  return [
+    tool_name_mapping_plugin_default,
+    config_plugin_default,
+    mode_agentic_plugin_default,
+    mode_workflow_plugin_default,
+    mode_agentic_sampling_plugin_default,
+    mode_workflow_sampling_plugin_default,
+    logging_plugin_default
+  ];
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/plugin-utils.js
+var import_meta = {};
+var pluginCache = /* @__PURE__ */ new Map();
+function shouldApplyPlugin(plugin, mode) {
+  if (!plugin.apply) return true;
+  if (typeof plugin.apply === "string") {
+    return mode === 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 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.registerAgentTool === "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 resolveFn = import_meta.resolve;
+    const importPath = typeof resolveFn === "function" ? resolveFn(rawPath) : new URL(rawPath, import_meta.url).href;
+    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 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
+  };
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/utils/plugin-manager.js
+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}`);
+        }
+      }
+    }
+  }
+  /**
+   * Trigger registerAgentTool hook - allows plugins to register the main agent tool
+   * Returns true if any plugin handled the registration
+   */
+  async triggerRegisterAgentTool(context2) {
+    const registerPlugins = this.plugins.filter((p2) => p2.registerAgentTool && shouldApplyPlugin(p2, context2.mode));
+    if (registerPlugins.length === 0) {
+      return false;
+    }
+    const sortedPlugins = sortPluginsByOrder(registerPlugins).reverse();
+    for (const plugin of sortedPlugins) {
+      if (plugin.registerAgentTool) {
+        try {
+          await plugin.registerAgentTool(context2);
+          return true;
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          await this.logger.error(`Plugin "${plugin.name}" registerAgentTool failed: ${errorMsg}`);
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * 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__core_latest/node_modules/@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 config = this.toolConfigs.get(name);
+    return config?.visibility?.public === true;
+  }
+  /**
+   * Check if a tool is hidden from agent context
+   */
+  isHidden(name) {
+    const config = this.toolConfigs.get(name);
+    return config?.visibility?.hidden === true;
+  }
+  /**
+   * Get all public tool names (exposed to MCP clients)
+   */
+  getPublicToolNames() {
+    return Array.from(this.toolConfigs.entries()).filter(([_name, config]) => config.visibility?.public === true).map(([name]) => this.resolveToolName(name) ?? name);
+  }
+  /**
+   * Get all hidden tool names
+   */
+  getHiddenToolNames() {
+    return Array.from(this.toolConfigs.entries()).filter(([_name, config]) => config.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, config) {
+    this.toolConfigs.set(toolName, config);
+  }
+  /**
+   * 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 config = this.toolConfigs.get(name);
+    if (tool && config?.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;
+  }
+  /**
+   * Get all registered tools as ComposedTool objects
+   * This includes tools registered via server.tool() in setup hooks
+   */
+  getRegisteredToolsAsComposed() {
+    const composedTools = {};
+    for (const [name, tool] of this.toolRegistry.entries()) {
+      if (this.toolConfigs.get(name)?.visibility?.public === true) {
+        continue;
+      }
+      composedTools[name] = {
+        name,
+        description: tool.description,
+        inputSchema: jsonSchema(tool.schema || {
+          type: "object",
+          properties: {}
+        }),
+        execute: tool.callback
+      };
+    }
+    return composedTools;
+  }
+};
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/utils/common/schema.js
+var import_json_schema_traverse = __toESM(require("json-schema-traverse"), 1);
+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 {
+    (0, import_json_schema_traverse.default)(clonedSchema, {
+      allKeys: true,
+      cb: function(schemaNode, _jsonPtr, _rootSchema, _parentJsonPtr, _parentKeyword, _parentSchema, _keyIndex) {
+        if (schemaNode && typeof schemaNode === "object" && schemaNode.$ref) {
+          const ref = schemaNode.$ref;
+          if (ref.startsWith("#/properties/")) {
+            const relativePath = ref.substring(13);
+            schemaNode.$ref = `#/properties/${wrapperPath}/properties/${relativePath}`;
+          } else if (ref === "#") {
+            schemaNode.$ref = `#/properties/${wrapperPath}`;
+          }
+        }
+      }
+    });
+  } catch (error) {
+    console.warn(`Failed to traverse schema for path "${wrapperPath}":`, error);
+    return clonedSchema;
+  }
+  return clonedSchema;
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/utils/compose-helpers.js
+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);
+  }
+}
+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);
+    const sanitizedKey = sanitizePropertyKey(toolName);
+    depGroups[sanitizedKey] = {
+      type: "object",
+      description: tool.description,
+      properties: updatedProperties,
+      required: [
+        ...baseRequired
+      ],
+      additionalProperties: false
+    };
+  });
+  return depGroups;
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/compose.js
+var ALL_TOOLS_PLACEHOLDER2 = "__ALL__";
+var ComposableMCPServer = class extends import_server.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 sortedPlugins = sortPluginsByOrder(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(import_types2.ListToolsRequestSchema, () => {
+      return {
+        tools: this.toolManager.getPublicTools()
+      };
+    });
+    this.setRequestHandler(import_types2.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(import_types2.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 all internal tool names (tools that are not public)
+   */
+  getInternalToolNames() {
+    const allToolNames = Array.from(this.toolManager.getToolRegistry().keys());
+    const publicToolNames = this.getPublicToolNames();
+    return allToolNames.filter((name) => !publicToolNames.includes(name));
+  }
+  /**
+   * 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, config) {
+    this.toolManager.configTool(toolName, config);
+  }
+  /**
+   * 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) {
+    await processToolsWithPlugins(this, externalTools, mode);
+  }
+  /**
+   * Dispose all plugins and cleanup resources
+   */
+  async disposePlugins() {
+    await this.pluginManager.dispose();
+  }
+  /**
+   * Close the server and ensure all plugins are disposed
+   */
+  async close() {
+    await this.disposePlugins();
+    await super.close();
+  }
+  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();
+    const allPlaceholderUsages = [];
+    tagToResults.tool.forEach((tool) => {
+      if (tool.attribs.name) {
+        const originalName = tool.attribs.name;
+        const toolName = sanitizePropertyKey(originalName);
+        if (toolName.endsWith(`_${ALL_TOOLS_PLACEHOLDER2}`) || toolName === ALL_TOOLS_PLACEHOLDER2) {
+          allPlaceholderUsages.push(originalName);
+        } else {
+          requestedToolNames.add(toolName);
+        }
+      }
+    });
+    const { tools, cleanupClients } = await composeMcpDepTools(depsConfig, ({ mcpName, toolNameWithScope, toolId }) => {
+      toolNameToIdMapping.set(toolNameWithScope, toolId);
+      availableToolNames.add(toolNameWithScope);
+      availableToolNames.add(toolId);
+      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;
+      });
+    });
+    Object.entries(tools).forEach(([toolId, tool]) => {
+      this.toolManager.registerTool(toolId, tool.description || "", tool.inputSchema, tool.execute);
+    });
+    const registeredTools = this.toolManager.getRegisteredToolsAsComposed();
+    const allTools = {
+      ...tools
+    };
+    Object.entries(registeredTools).forEach(([toolName, tool]) => {
+      if (!allTools[toolName]) {
+        allTools[toolName] = tool;
+      }
+      availableToolNames.add(toolName);
+    });
+    if (allPlaceholderUsages.length > 0) {
+      await this.logger.warning(`Found ${allPlaceholderUsages.length} __ALL__ placeholder(s) for agent "${name}":`);
+      allPlaceholderUsages.forEach((usage) => {
+        this.logger.warning(`   \u2022 "${usage}" - consider using specific tool names`);
+      });
+      const available = Array.from(availableToolNames).sort().join(", ");
+      await this.logger.warning(`   Available tools: ${available}`);
+    }
+    const unmatchedTools = Array.from(requestedToolNames).filter((toolName) => !allTools[toolName]);
+    if (unmatchedTools.length > 0) {
+      await this.logger.warning(`Tool matching warnings for agent "${name}":`);
+      unmatchedTools.forEach((toolName) => {
+        this.logger.warning(`   \u2022 Tool not found: "${toolName}"`);
+      });
+      const available = Array.from(availableToolNames).sort().join(", ");
+      await this.logger.warning(`   Available tools: ${available}`);
+    }
+    await this.processToolsWithPlugins(allTools, options.mode ?? "agentic");
+    await this.pluginManager.triggerFinalizeComposition(allTools, {
+      serverName: name ?? "anonymous",
+      mode: options.mode ?? "agentic",
+      server: this,
+      toolNames: Object.keys(allTools)
+    });
+    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(allTools);
+    const publicToolNames = this.getPublicToolNames();
+    const hiddenToolNames = this.getHiddenToolNames();
+    const contextToolNames = toolNameToDetailList.map(([name2]) => name2).filter((n) => !hiddenToolNames.includes(n));
+    publicToolNames.forEach((toolId) => {
+      const tool = allTools[toolId];
+      if (!tool) {
+        throw new Error(`Public tool ${toolId} not found in registry, available: ${Object.keys(allTools).join(", ")}`);
+      }
+      this.tool(toolId, tool.description || "", 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: allTools,
+      toolOverrides: /* @__PURE__ */ new Map(),
+      toolNameMapping: toolNameToIdMapping
+    });
+    const allToolNames = contextToolNames;
+    const depGroups = buildDependencyGroups(toolNameToDetailList, hiddenToolNames, publicToolNames, this);
+    const mode = options.mode ?? "agentic";
+    const context2 = {
+      server: this,
+      name,
+      description,
+      mode,
+      allToolNames,
+      toolNameToDetailList,
+      depGroups,
+      toolNameToIdMapping,
+      publicToolNames,
+      hiddenToolNames,
+      options
+    };
+    const handled = await this.pluginManager.triggerRegisterAgentTool(context2);
+    if (!handled) {
+      throw new Error(`No plugin registered to handle execution mode "${mode}". Did you override the default mode plugin, but in the wrong way?`);
+    }
+  }
+};
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/utils/common/env.js
+var import_node_process6 = __toESM(require("node:process"), 1);
+var isProdEnv = () => import_node_process6.default.env.NODE_ENV === "production";
+var isSCF = () => Boolean(import_node_process6.default.env.SCF_RUNTIME || import_node_process6.default.env.PROD_SCF);
+if (isSCF()) {
+  console.log({
+    isSCF: isSCF(),
+    SCF_RUNTIME: import_node_process6.default.env.SCF_RUNTIME
+  });
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/ai-sdk-adapter.js
+function convertToAISDKTools(server, helpers) {
+  const { tool, jsonSchema: jsonSchema2 } = helpers;
+  const mcpcTools = server.getPublicTools();
+  return Object.fromEntries(mcpcTools.map((mcpcTool) => [
+    mcpcTool.name,
+    tool({
+      description: mcpcTool.description || "No description",
+      inputSchema: jsonSchema2(mcpcTool.inputSchema),
+      execute: async (input) => {
+        return await server.callTool(mcpcTool.name, input);
+      }
+    })
+  ]));
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/set-up-mcp-compose.js
+function parseMcpcConfigs(conf) {
+  return conf ?? [];
+}
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ComposableMCPServer,
+  composeMcpDepTools,
+  convertToAISDKTools,
+  extractJsonSchema,
+  isProdEnv,
+  isSCF,
+  isWrappedSchema,
+  jsonSchema,
+  mcpc,
+  optionalObject,
+  parseJSON,
+  parseMcpcConfigs,
+  truncateJSON
+});