@mcpc-tech/cli 0.1.11 → 0.1.13

package/bin/mcpc.mjs

@@ -1,442 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/schema.js
-function jsonSchema(schema, options = {}) {
-  if (isWrappedSchema(schema)) {
-    return schema;
-  }
-  return {
-    [schemaSymbol]: true,
-    [validatorSymbol]: true,
-    _type: void 0,
-    jsonSchema: schema,
-    validate: options.validate
-  };
-}
-function isWrappedSchema(value) {
-  return typeof value === "object" && value !== null && (schemaSymbol in value && value[schemaSymbol] === true || vercelSchemaSymbol in value && value[vercelSchemaSymbol] === true);
-}
-function extractJsonSchema(schema) {
-  if (isWrappedSchema(schema)) {
-    return schema.jsonSchema;
-  }
-  return schema;
-}
-var schemaSymbol, vercelSchemaSymbol, validatorSymbol;
-var init_schema = __esm({
-  "__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/schema.js"() {
-    schemaSymbol = Symbol.for("mcpc.schema");
-    vercelSchemaSymbol = Symbol.for("vercel.ai.schema");
-    validatorSymbol = Symbol.for("mcpc.validator");
-  }
-});
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/config.js
-import process2 from "node:process";
-var GEMINI_PREFERRED_FORMAT;
-var init_config = __esm({
-  "__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/config.js"() {
-    GEMINI_PREFERRED_FORMAT = process2.env.GEMINI_PREFERRED_FORMAT === "0" ? false : true;
-  }
-});
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/json.js
-import { jsonrepair as jsonrepair2 } from "jsonrepair";
-var init_json = __esm({
-  "__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/json.js"() {
-  }
-});
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/provider.js
-function sanitizePropertyKey(name) {
-  return name.replace(/[@.,/\\:;!?#$%^&*()[\]{}]/g, "_").substring(0, 64);
-}
-var createGoogleCompatibleJSONSchema;
-var init_provider = __esm({
-  "__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/provider.js"() {
-    init_config();
-    init_json();
-    createGoogleCompatibleJSONSchema = (schema) => {
-      if (!GEMINI_PREFERRED_FORMAT) {
-        return schema;
-      }
-      const { oneOf: _oneOf, allOf: _allOf, anyOf: _anyOf, ...cleanSchema } = schema;
-      const removeAdditionalProperties = (obj) => {
-        if (Array.isArray(obj)) {
-          return obj.map(removeAdditionalProperties);
-        }
-        if (obj && typeof obj === "object") {
-          const result = {};
-          for (const [key, value] of Object.entries(obj)) {
-            if (key !== "additionalProperties") {
-              result[key] = removeAdditionalProperties(value);
-            }
-          }
-          return result;
-        }
-        return obj;
-      };
-      return removeAdditionalProperties(cleanSchema);
-    };
-  }
-});
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/logger.js
-function createLogger(name, server2) {
-  return new MCPLogger(name, server2);
-}
-var LOG_LEVELS, MCPLogger, logger;
-var init_logger = __esm({
-  "__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/logger.js"() {
-    LOG_LEVELS = {
-      debug: 0,
-      info: 1,
-      notice: 2,
-      warning: 3,
-      error: 4,
-      critical: 5,
-      alert: 6,
-      emergency: 7
-    };
-    MCPLogger = class _MCPLogger {
-      server;
-      loggerName;
-      minLevel = "debug";
-      constructor(loggerName = "mcpc", server2) {
-        this.loggerName = loggerName;
-        this.server = server2;
-      }
-      setServer(server2) {
-        this.server = server2;
-      }
-      setLevel(level) {
-        this.minLevel = level;
-      }
-      async log(level, data) {
-        if (LOG_LEVELS[level] < LOG_LEVELS[this.minLevel]) {
-          return;
-        }
-        this.logToConsole(level, data);
-        if (this.server) {
-          try {
-            await this.server.sendLoggingMessage({
-              level,
-              logger: this.loggerName,
-              data
-            });
-          } catch {
-          }
-        }
-      }
-      logToConsole(level, data) {
-        const message = typeof data === "string" ? data : JSON.stringify(data);
-        const prefix = `[${this.loggerName}:${level}]`;
-        console.error(prefix, message);
-      }
-      debug(data) {
-        return this.log("debug", data);
-      }
-      info(data) {
-        return this.log("info", data);
-      }
-      notice(data) {
-        return this.log("notice", data);
-      }
-      warning(data) {
-        return this.log("warning", data);
-      }
-      error(data) {
-        return this.log("error", data);
-      }
-      critical(data) {
-        return this.log("critical", data);
-      }
-      alert(data) {
-        return this.log("alert", data);
-      }
-      emergency(data) {
-        return this.log("emergency", data);
-      }
-      child(name) {
-        const child = new _MCPLogger(`${this.loggerName}.${name}`, this.server);
-        child.setLevel(this.minLevel);
-        return child;
-      }
-    };
-    logger = new MCPLogger("mcpc");
-  }
-});
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/config-plugin.js
-var createConfigPlugin, config_plugin_default;
-var init_config_plugin = __esm({
-  "__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/config-plugin.js"() {
-    createConfigPlugin = () => ({
-      name: "built-in-config",
-      version: "1.0.0",
-      enforce: "pre",
-      transformTool: (tool, context2) => {
-        const server2 = context2.server;
-        const config2 = server2.findToolConfig?.(context2.toolName);
-        if (config2?.description) {
-          tool.description = config2.description;
-        }
-        return tool;
-      }
-    });
-    config_plugin_default = createConfigPlugin();
-  }
-});
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/tool-name-mapping-plugin.js
-var createToolNameMappingPlugin, tool_name_mapping_plugin_default;
-var init_tool_name_mapping_plugin = __esm({
-  "__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/tool-name-mapping-plugin.js"() {
-    createToolNameMappingPlugin = () => ({
-      name: "built-in-tool-name-mapping",
-      version: "1.0.0",
-      enforce: "pre",
-      transformTool: (tool, context2) => {
-        const server2 = context2.server;
-        const toolName = context2.toolName;
-        const originalName = tool._originalName || toolName;
-        const dotNotation = originalName.replace(/_/g, ".");
-        const underscoreNotation = originalName.replace(/\./g, "_");
-        if (dotNotation !== originalName && server2.toolNameMapping) {
-          server2.toolNameMapping.set(dotNotation, toolName);
-        }
-        if (underscoreNotation !== originalName && server2.toolNameMapping) {
-          server2.toolNameMapping.set(underscoreNotation, toolName);
-        }
-        if (originalName !== toolName && server2.toolNameMapping) {
-          server2.toolNameMapping.set(originalName, toolName);
-        }
-        return tool;
-      }
-    });
-    tool_name_mapping_plugin_default = createToolNameMappingPlugin();
-  }
-});
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/logging-plugin.js
-var createLoggingPlugin, logging_plugin_default;
-var init_logging_plugin = __esm({
-  "__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/logging-plugin.js"() {
-    init_logger();
-    createLoggingPlugin = (options = {}) => {
-      const { enabled = true, verbose = false, compact: compact2 = true } = options;
-      return {
-        name: "built-in-logging",
-        version: "1.0.0",
-        composeEnd: async (context2) => {
-          if (!enabled) return;
-          const logger2 = createLogger("mcpc.plugin.logging", context2.server);
-          if (compact2) {
-            const pluginCount = context2.pluginNames.length;
-            const { stats } = context2;
-            await logger2.info(`[${context2.toolName}] ${pluginCount} plugins \u2022 ${stats.publicTools} public \u2022 ${stats.hiddenTools} hidden`);
-          } else if (verbose) {
-            await logger2.info(`[${context2.toolName}] Composition complete`);
-            await logger2.info(`   \u251C\u2500 Plugins: ${context2.pluginNames.join(", ")}`);
-            const { stats } = context2;
-            const server2 = context2.server;
-            const publicTools = Array.from(new Set(server2.getPublicToolNames().map(String)));
-            const internalTools = Array.from(new Set(server2.getInternalToolNames().map(String)));
-            const hiddenTools = Array.from(new Set(server2.getHiddenToolNames().map(String)));
-            const normalInternal = internalTools.filter((name) => !hiddenTools.includes(name));
-            if (publicTools.length > 0) {
-              await logger2.info(`   \u251C\u2500 Public: ${publicTools.join(", ")}`);
-            }
-            if (internalTools.length > 0) {
-              const parts = [];
-              if (normalInternal.length > 0) {
-                parts.push(normalInternal.join(", "));
-              }
-              if (hiddenTools.length > 0) {
-                parts.push(`(${hiddenTools.join(", ")})`);
-              }
-              await logger2.info(`   \u251C\u2500 Internal: ${parts.join(", ")}`);
-            }
-            await logger2.info(`   \u2514\u2500 Total: ${stats.totalTools} tools`);
-          }
-        }
-      };
-    };
-    logging_plugin_default = createLoggingPlugin({
-      verbose: true,
-      compact: false
-    });
-  }
-});
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/index.js
-var built_in_exports = {};
-__export(built_in_exports, {
-  createConfigPlugin: () => createConfigPlugin,
-  createLoggingPlugin: () => createLoggingPlugin,
-  createToolNameMappingPlugin: () => createToolNameMappingPlugin,
-  getBuiltInPlugins: () => getBuiltInPlugins
-});
-function getBuiltInPlugins() {
-  return [
-    tool_name_mapping_plugin_default,
-    config_plugin_default,
-    logging_plugin_default
-  ];
-}
-var init_built_in = __esm({
-  "__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/index.js"() {
-    init_config_plugin();
-    init_tool_name_mapping_plugin();
-    init_logging_plugin();
-    init_config_plugin();
-    init_tool_name_mapping_plugin();
-    init_logging_plugin();
-  }
-});
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/schema.js
-import traverse from "json-schema-traverse";
-function updateRefPaths(schema, wrapperPath) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  if (!wrapperPath || typeof wrapperPath !== "string") {
-    throw new Error("wrapperPath must be a non-empty string");
-  }
-  const clonedSchema = JSON.parse(JSON.stringify(schema));
-  try {
-    traverse(clonedSchema, {
-      allKeys: true,
-      cb: function(schemaNode, _jsonPtr, _rootSchema, _parentJsonPtr, _parentKeyword, _parentSchema, _keyIndex) {
-        if (schemaNode && typeof schemaNode === "object" && schemaNode.$ref) {
-          const ref = schemaNode.$ref;
-          if (ref.startsWith("#/properties/")) {
-            const relativePath = ref.substring(13);
-            schemaNode.$ref = `#/properties/${wrapperPath}/properties/${relativePath}`;
-          } else if (ref === "#") {
-            schemaNode.$ref = `#/properties/${wrapperPath}`;
-          }
-        }
-      }
-    });
-  } catch (error) {
-    console.warn(`Failed to traverse schema for path "${wrapperPath}":`, error);
-    return clonedSchema;
-  }
-  return clonedSchema;
-}
-var init_schema2 = __esm({
-  "__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/schema.js"() {
-  }
-});
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/compose-helpers.js
-var compose_helpers_exports = {};
-__export(compose_helpers_exports, {
-  buildDependencyGroups: () => buildDependencyGroups,
-  processToolsWithPlugins: () => processToolsWithPlugins,
-  registerGlobalTools: () => registerGlobalTools
-});
-async function processToolsWithPlugins(server2, externalTools, mode) {
-  const toolManager = server2.toolManager;
-  const pluginManager = server2.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: server2,
-      mode,
-      originalTool: {
-        ...tempTool
-      },
-      transformationIndex: 0
-    });
-    toolManager.registerTool(toolId, processedTool.description || toolData.description, processedTool.inputSchema, processedTool.execute);
-    if (externalTools[toolId]) {
-      try {
-        const builtIn = await Promise.resolve().then(() => (init_built_in(), built_in_exports));
-        if (builtIn && typeof builtIn.processToolVisibility === "function") {
-          builtIn.processToolVisibility(toolId, processedTool, server2, externalTools);
-        }
-      } catch {
-      }
-      externalTools[toolId] = processedTool;
-    }
-  }
-}
-function buildDependencyGroups(toolNameToDetailList, hiddenToolNames, publicToolNames, server2) {
-  const depGroups = {};
-  const toolManager = server2.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;
-}
-function registerGlobalTools(globalToolNames, tools, server2) {
-  globalToolNames.forEach((toolId) => {
-    const tool = tools[toolId];
-    if (!tool) {
-      throw new Error(`Global tool ${toolId} not found in registry, available: ${Object.keys(tools).join(", ")}`);
-    }
-    server2.tool(toolId, tool.description || "No description available", jsonSchema(tool.inputSchema), tool.execute);
-  });
-}
-var init_compose_helpers = __esm({
-  "__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/compose-helpers.js"() {
-    init_schema2();
-    init_schema();
-    init_provider();
-  }
-});
 
 // __mcpc__cli_latest/node_modules/@mcpc/cli/src/bin.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -493,32 +57,59 @@ var ServerSentEventStream = class extends TransformStream {
 import { createRoute as createRoute2, z as z2 } from "@hono/zod-openapi";
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/compose.js
-init_schema();
 import { CallToolRequestSchema, ListToolsRequestSchema, SetLevelRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/json.js
-import { jsonrepair } from "jsonrepair";
-function stripMarkdownAndText(text) {
-  text = text.trim();
-  text = text.replace(/^```(?:json)?\s*\n?/i, "");
-  text = text.replace(/\n?```\s*$/, "");
-  text = text.replace(/^(?:here is|here's|response|result|output|json):\s*/i, "");
-  const 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 === "\\") {
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/schema.js
+var schemaSymbol = Symbol.for("mcpc.schema");
+var vercelSchemaSymbol = Symbol.for("vercel.ai.schema");
+var validatorSymbol = Symbol.for("mcpc.validator");
+function jsonSchema(schema, options = {}) {
+  if (isWrappedSchema(schema)) {
+    return schema;
+  }
+  return {
+    [schemaSymbol]: true,
+    [validatorSymbol]: true,
+    _type: void 0,
+    jsonSchema: schema,
+    validate: options.validate
+  };
+}
+function isWrappedSchema(value) {
+  return typeof value === "object" && value !== null && (schemaSymbol in value && value[schemaSymbol] === true || vercelSchemaSymbol in value && value[vercelSchemaSymbol] === true);
+}
+function extractJsonSchema(schema) {
+  if (isWrappedSchema(schema)) {
+    return schema.jsonSchema;
+  }
+  return schema;
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/compose.js
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/json.js
+import { jsonrepair } from "jsonrepair";
+function stripMarkdownAndText(text) {
+  text = text.trim();
+  text = text.replace(/^```(?:json)?\s*\n?/i, "");
+  text = text.replace(/\n?```\s*$/, "");
+  text = text.replace(/^(?:here is|here's|response|result|output|json):\s*/i, "");
+  const firstJsonIndex = text.search(/[\{\[]/);
+  if (firstJsonIndex >= 0) {
+    text = text.slice(firstJsonIndex);
+    let depth = 0;
+    let inString = false;
+    let escapeNext = false;
+    const startChar = text[0];
+    const endChar = startChar === "{" ? "}" : "]";
+    for (let i = 0; i < text.length; i++) {
+      const char = text[i];
+      if (escapeNext) {
+        escapeNext = false;
+        continue;
+      }
+      if (char === "\\") {
         escapeNext = true;
         continue;
       }
@@ -652,8 +243,41 @@ function smitheryToolNameCompatibale(name, scope) {
   };
 }
 
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/config.js
+import process2 from "node:process";
+var GEMINI_PREFERRED_FORMAT = process2.env.GEMINI_PREFERRED_FORMAT === "0" ? false : true;
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/json.js
+import { jsonrepair as jsonrepair2 } from "jsonrepair";
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/provider.js
+function sanitizePropertyKey(name) {
+  return name.replace(/[@.,/\\:;!?#$%^&*()[\]{}]/g, "_").substring(0, 64);
+}
+var createGoogleCompatibleJSONSchema = (schema) => {
+  if (!GEMINI_PREFERRED_FORMAT) {
+    return schema;
+  }
+  const { oneOf: _oneOf, allOf: _allOf, anyOf: _anyOf, ...cleanSchema } = schema;
+  const removeAdditionalProperties = (obj) => {
+    if (Array.isArray(obj)) {
+      return obj.map(removeAdditionalProperties);
+    }
+    if (obj && typeof obj === "object") {
+      const result = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (key !== "additionalProperties") {
+          result[key] = removeAdditionalProperties(value);
+        }
+      }
+      return result;
+    }
+    return obj;
+  };
+  return removeAdditionalProperties(cleanSchema);
+};
+
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
-init_provider();
 import { cwd } from "node:process";
 import process3 from "node:process";
 import { createHash } from "node:crypto";
@@ -839,16 +463,215 @@ async function composeMcpDepTools(mcpConfig, filterIn) {
   };
 }
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-tool-registrar.js
-init_schema();
-init_provider();
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/tool-tag-processor.js
+var ALL_TOOLS_PLACEHOLDER = "__ALL__";
+function findToolId(toolName, tools, toolNameMapping) {
+  const mappedId = toolNameMapping?.get(toolName);
+  if (mappedId) {
+    return mappedId;
+  }
+  return Object.keys(tools).find((id) => {
+    const dotNotation = id.replace(/_/g, ".");
+    return toolName === id || toolName === dotNotation;
+  });
+}
+function processToolTags({ description, tagToResults, $, tools, toolOverrides, toolNameMapping }) {
+  tagToResults.tool.forEach((toolEl) => {
+    const toolName = toolEl.attribs.name;
+    if (!toolName || toolName.includes(ALL_TOOLS_PLACEHOLDER)) {
+      $(toolEl).remove();
+      return;
+    }
+    const override = toolOverrides.get(toolName);
+    if (override?.visibility?.hidden) {
+      $(toolEl).remove();
+    } else if (override?.visibility?.public) {
+      $(toolEl).replaceWith(`<tool name="${toolName}"/>`);
+    } else {
+      const toolId = findToolId(toolName, tools, toolNameMapping);
+      if (toolId) {
+        $(toolEl).replaceWith(`<tool name="${toolId}"/>`);
+      } else {
+        $(toolEl).remove();
+      }
+    }
+  });
+  return $.root().html() ?? description;
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/config-plugin.js
+var createConfigPlugin = () => ({
+  name: "built-in-config",
+  version: "1.0.0",
+  enforce: "pre",
+  transformTool: (tool, context2) => {
+    const server2 = context2.server;
+    const config2 = server2.findToolConfig?.(context2.toolName);
+    if (config2?.description) {
+      tool.description = config2.description;
+    }
+    return tool;
+  }
+});
+var config_plugin_default = createConfigPlugin();
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/tool-name-mapping-plugin.js
+var createToolNameMappingPlugin = () => ({
+  name: "built-in-tool-name-mapping",
+  version: "1.0.0",
+  enforce: "pre",
+  transformTool: (tool, context2) => {
+    const server2 = context2.server;
+    const toolName = context2.toolName;
+    const originalName = tool._originalName || toolName;
+    const dotNotation = originalName.replace(/_/g, ".");
+    const underscoreNotation = originalName.replace(/\./g, "_");
+    if (dotNotation !== originalName && server2.toolNameMapping) {
+      server2.toolNameMapping.set(dotNotation, toolName);
+    }
+    if (underscoreNotation !== originalName && server2.toolNameMapping) {
+      server2.toolNameMapping.set(underscoreNotation, toolName);
+    }
+    if (originalName !== toolName && server2.toolNameMapping) {
+      server2.toolNameMapping.set(originalName, toolName);
+    }
+    return tool;
+  }
+});
+var tool_name_mapping_plugin_default = createToolNameMappingPlugin();
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/logger.js
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  notice: 2,
+  warning: 3,
+  error: 4,
+  critical: 5,
+  alert: 6,
+  emergency: 7
+};
+var MCPLogger = class _MCPLogger {
+  server;
+  loggerName;
+  minLevel = "debug";
+  constructor(loggerName = "mcpc", server2) {
+    this.loggerName = loggerName;
+    this.server = server2;
+  }
+  setServer(server2) {
+    this.server = server2;
+  }
+  setLevel(level) {
+    this.minLevel = level;
+  }
+  async log(level, data) {
+    if (LOG_LEVELS[level] < LOG_LEVELS[this.minLevel]) {
+      return;
+    }
+    this.logToConsole(level, data);
+    if (this.server) {
+      try {
+        await this.server.sendLoggingMessage({
+          level,
+          logger: this.loggerName,
+          data
+        });
+      } catch {
+      }
+    }
+  }
+  logToConsole(level, data) {
+    const message = typeof data === "string" ? data : JSON.stringify(data);
+    const prefix = `[${this.loggerName}:${level}]`;
+    console.error(prefix, message);
+  }
+  debug(data) {
+    return this.log("debug", data);
+  }
+  info(data) {
+    return this.log("info", data);
+  }
+  notice(data) {
+    return this.log("notice", data);
+  }
+  warning(data) {
+    return this.log("warning", data);
+  }
+  error(data) {
+    return this.log("error", data);
+  }
+  critical(data) {
+    return this.log("critical", data);
+  }
+  alert(data) {
+    return this.log("alert", data);
+  }
+  emergency(data) {
+    return this.log("emergency", data);
+  }
+  child(name) {
+    const child = new _MCPLogger(`${this.loggerName}.${name}`, this.server);
+    child.setLevel(this.minLevel);
+    return child;
+  }
+};
+var logger = new MCPLogger("mcpc");
+function createLogger(name, server2) {
+  return new MCPLogger(name, server2);
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/logging-plugin.js
+var createLoggingPlugin = (options = {}) => {
+  const { enabled = true, verbose = false, compact: compact2 = true } = options;
+  return {
+    name: "built-in-logging",
+    version: "1.0.0",
+    composeEnd: async (context2) => {
+      if (!enabled) return;
+      const logger2 = createLogger("mcpc.plugin.logging", context2.server);
+      if (compact2) {
+        const pluginCount = context2.pluginNames.length;
+        const { stats } = context2;
+        await logger2.info(`[${context2.toolName}] ${pluginCount} plugins \u2022 ${stats.publicTools} public \u2022 ${stats.hiddenTools} hidden`);
+      } else if (verbose) {
+        await logger2.info(`[${context2.toolName}] Composition complete`);
+        await logger2.info(`   \u251C\u2500 Plugins: ${context2.pluginNames.join(", ")}`);
+        const { stats } = context2;
+        const server2 = context2.server;
+        const publicTools = Array.from(new Set(server2.getPublicToolNames().map(String)));
+        const internalTools = Array.from(new Set(server2.getInternalToolNames().map(String)));
+        const hiddenTools = Array.from(new Set(server2.getHiddenToolNames().map(String)));
+        const normalInternal = internalTools.filter((name) => !hiddenTools.includes(name));
+        if (publicTools.length > 0) {
+          await logger2.info(`   \u251C\u2500 Public: ${publicTools.join(", ")}`);
+        }
+        if (internalTools.length > 0) {
+          const parts = [];
+          if (normalInternal.length > 0) {
+            parts.push(normalInternal.join(", "));
+          }
+          if (hiddenTools.length > 0) {
+            parts.push(`(${hiddenTools.join(", ")})`);
+          }
+          await logger2.info(`   \u251C\u2500 Internal: ${parts.join(", ")}`);
+        }
+        await logger2.info(`   \u2514\u2500 Total: ${stats.totalTools} tools`);
+      }
+    }
+  };
+};
+var logging_plugin_default = createLoggingPlugin({
+  verbose: true,
+  compact: false
+});
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/prompts/index.js
 var SystemPrompts = {
   /**
    * Base system prompt for autonomous MCP execution
    */
-  AUTONOMOUS_EXECUTION: `Agentic tool \`{toolName}\` that executes complex tasks by iteratively calling actions, gathering results, and deciding next steps until completion. Use this tool when the task matches the manual below.
+  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/>.
 
@@ -856,31 +679,39 @@ You must follow the <manual/>, obey the <execution_rules/>, and use the <call_fo
 {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. **Execute** one action per call
-2. **Collect** feedback from each action result
-3. **Decide** next step based on feedback:
-   - **proceed**: More work needed
-   - **complete**: Task finished (omit action field)
-   - **retry**: Current action failed
-4. **Provide** parameters matching the action name
-5. **Continue** until task is complete
-6. Note: You are an agent exposed as an MCP tool - **"action" is an internal parameter, NOT an external MCP tool you can call**
+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
 {
-  "action": "action_name",
-  "decision": "proceed|retry", 
-  "action_name": { /* action parameters */ }
+  "hasDefinitions": [],
+  "definitionsOf": ["tool1", "tool2"]
 }
 \`\`\`
 
-When complete:
+Execute tool + get new definitions:
 \`\`\`json
 {
-  "decision": "complete"
+  "useTool": "tool1",
+  "tool1": { /* parameters */ },
+  "hasDefinitions": ["tool1", "tool2"],
+  "definitionsOf": ["tool3"]
 }
 \`\`\`
 </call_format>`,
@@ -1179,11 +1010,28 @@ ${JSON.stringify(steps, null, 2)}`;
   }
 };
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-executor.js
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/schema-validator.js
 import { Ajv } from "ajv";
-import { AggregateAjvError } from "@segment/ajv-human-errors";
 import addFormats from "ajv-formats";
-init_logger();
+import { AggregateAjvError } from "@segment/ajv-human-errors";
+var ajv = new Ajv({
+  allErrors: true,
+  verbose: true
+});
+addFormats.default(ajv);
+function validateSchema(args, schema) {
+  const validate = ajv.compile(schema);
+  if (!validate(args)) {
+    const errors = new AggregateAjvError(validate.errors);
+    return {
+      valid: false,
+      error: errors.message
+    };
+  }
+  return {
+    valid: true
+  };
+}
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/tracing.js
 import { context, SpanStatusCode, trace } from "@opentelemetry/api";
@@ -1254,27 +1102,20 @@ function endSpan(span, error) {
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-executor.js
 import process4 from "node:process";
-var ajv = new Ajv({
-  allErrors: true,
-  verbose: true
-});
-addFormats(ajv);
 var AgenticExecutor = class {
   name;
   allToolNames;
   toolNameToDetailList;
   server;
-  ACTION_KEY;
-  NEXT_ACTION_KEY;
+  USE_TOOL_KEY;
   logger;
   tracingEnabled;
-  constructor(name, allToolNames, toolNameToDetailList, server2, ACTION_KEY = "action", NEXT_ACTION_KEY = "nextAction") {
+  constructor(name, allToolNames, toolNameToDetailList, server2, USE_TOOL_KEY = "useTool") {
     this.name = name;
     this.allToolNames = allToolNames;
     this.toolNameToDetailList = toolNameToDetailList;
     this.server = server2;
-    this.ACTION_KEY = ACTION_KEY;
-    this.NEXT_ACTION_KEY = NEXT_ACTION_KEY;
+    this.USE_TOOL_KEY = USE_TOOL_KEY;
     this.tracingEnabled = false;
     this.logger = createLogger(`mcpc.agentic.${name}`, server2);
     try {
@@ -1294,8 +1135,7 @@ var AgenticExecutor = class {
   async execute(args, schema, parentSpan) {
     const executeSpan = this.tracingEnabled ? startSpan("mcpc.agentic_execute", {
       agent: this.name,
-      action: String(args[this.ACTION_KEY] ?? "unknown"),
-      nextAction: String(args[this.NEXT_ACTION_KEY] ?? "none"),
+      selectTool: String(args[this.USE_TOOL_KEY] ?? "unknown"),
       args: JSON.stringify(args)
     }, parentSpan ?? void 0) : null;
     try {
@@ -1310,7 +1150,7 @@ var AgenticExecutor = class {
         }
         this.logger.warning({
           message: "Validation failed",
-          action: args[this.ACTION_KEY],
+          selectTool: args[this.USE_TOOL_KEY],
           error: validationResult.error
         });
         return {
@@ -1325,103 +1165,67 @@ var AgenticExecutor = class {
           isError: true
         };
       }
-      const actionName = args[this.ACTION_KEY];
-      if (executeSpan && actionName) {
+      const useTool = args[this.USE_TOOL_KEY];
+      const definitionsOf = args.definitionsOf || [];
+      const hasDefinitions = args.hasDefinitions || [];
+      if (executeSpan && useTool) {
         try {
-          const safeAction = String(actionName).replace(/\s+/g, "_");
+          const safeTool = String(useTool).replace(/\s+/g, "_");
           if (typeof executeSpan.updateName === "function") {
-            executeSpan.updateName(`mcpc.agentic_execute.${safeAction}`);
+            executeSpan.updateName(`mcpc.agentic_execute.${safeTool}`);
           }
         } catch {
         }
       }
-      const currentTool = this.toolNameToDetailList.find(([name, _detail]) => name === actionName)?.[1];
+      const currentTool = this.toolNameToDetailList.find(([name, _detail]) => name === useTool)?.[1];
       if (currentTool) {
-        const nextAction = args[this.NEXT_ACTION_KEY];
         if (executeSpan) {
           executeSpan.setAttributes({
             toolType: "external",
-            actionName,
-            nextAction: nextAction || "none"
+            selectedTool: useTool
           });
         }
         this.logger.debug({
           message: "Executing external tool",
-          action: actionName,
-          nextAction
+          selectTool: useTool
         });
         const currentResult = await currentTool.execute({
-          ...args[actionName]
+          ...args[useTool]
         });
-        if (args[nextAction]) {
-          currentResult?.content?.push({
-            type: "text",
-            text: CompiledPrompts.actionSuccess({
-              toolName: this.name,
-              nextAction,
-              currentAction: actionName
-            })
-          });
-        } else {
-          currentResult?.content?.push({
-            type: "text",
-            text: CompiledPrompts.planningPrompt({
-              currentAction: actionName
-            })
-          });
-        }
+        this.appendToolSchemas(currentResult, definitionsOf, hasDefinitions);
         if (executeSpan) {
           executeSpan.setAttributes({
             success: true,
             isError: !!currentResult.isError,
             resultContentLength: currentResult.content?.length || 0,
-            hasNextAction: !!args[nextAction],
             toolResult: JSON.stringify(currentResult)
           });
           endSpan(executeSpan);
         }
         return currentResult;
       }
-      if (this.allToolNames.includes(actionName)) {
+      if (this.allToolNames.includes(useTool)) {
         if (executeSpan) {
           executeSpan.setAttributes({
             toolType: "internal",
-            actionName
+            selectedTool: useTool
           });
         }
         this.logger.debug({
           message: "Executing internal tool",
-          action: actionName
+          selectTool: useTool
         });
         try {
-          const result = await this.server.callTool(actionName, args[actionName]);
-          const nextAction = args[this.NEXT_ACTION_KEY];
-          const callToolResult = result ?? {
+          const result2 = await this.server.callTool(useTool, args[useTool]);
+          const callToolResult = result2 ?? {
             content: []
           };
-          if (nextAction && this.allToolNames.includes(nextAction)) {
-            callToolResult.content.push({
-              type: "text",
-              text: CompiledPrompts.actionSuccess({
-                toolName: this.name,
-                nextAction,
-                currentAction: actionName
-              })
-            });
-          } else {
-            callToolResult.content.push({
-              type: "text",
-              text: CompiledPrompts.planningPrompt({
-                currentAction: actionName
-              })
-            });
-          }
+          this.appendToolSchemas(callToolResult, definitionsOf, hasDefinitions);
           if (executeSpan) {
             executeSpan.setAttributes({
               success: true,
               isError: !!callToolResult.isError,
               resultContentLength: callToolResult.content?.length || 0,
-              hasNextAction: !!(nextAction && this.allToolNames.includes(nextAction)),
               toolResult: JSON.stringify(callToolResult)
             });
             endSpan(executeSpan);
@@ -1433,14 +1237,14 @@ var AgenticExecutor = class {
           }
           this.logger.error({
             message: "Error executing internal tool",
-            action: actionName,
+            useTool,
             error: String(error)
           });
           return {
             content: [
               {
                 type: "text",
-                text: `Error executing internal tool ${actionName}: ${error instanceof Error ? error.message : String(error)}`
+                text: `Error executing internal tool ${useTool}: ${error instanceof Error ? error.message : String(error)}`
               }
             ],
             isError: true
@@ -1450,23 +1254,20 @@ var AgenticExecutor = class {
       if (executeSpan) {
         executeSpan.setAttributes({
           toolType: "not_found",
-          actionName: actionName || "unknown",
+          useTool: useTool || "unknown",
           completion: true
         });
         endSpan(executeSpan);
       }
       this.logger.debug({
         message: "Tool not found, returning completion message",
-        action: actionName
+        useTool
       });
-      return {
-        content: [
-          {
-            type: "text",
-            text: CompiledPrompts.completionMessage()
-          }
-        ]
+      const result = {
+        content: []
       };
+      this.appendToolSchemas(result, definitionsOf, hasDefinitions);
+      return result;
     } catch (error) {
       if (executeSpan) {
         endSpan(executeSpan, error);
@@ -1486,24 +1287,33 @@ var AgenticExecutor = class {
       };
     }
   }
-  // Validate arguments using JSON schema
-  validate(args, schema) {
-    if (args.decision === "complete") {
-      return {
-        valid: 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 validate = ajv.compile(schema);
-    if (!validate(args)) {
-      const errors = new AggregateAjvError(validate.errors);
-      return {
-        valid: false,
-        error: errors.message
-      };
+    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")}`
+      });
     }
-    return {
-      valid: true
-    };
+  }
+  // Validate arguments using JSON schema
+  validate(args, schema) {
+    return validateSchema(args, schema);
   }
 };
 
@@ -1738,47 +1548,103 @@ Workflow step definitions - provide ONLY on initial call.
         ]
       };
     },
-    forAgentic: function(toolNameToDetailList, _sampling = false, ACTION_KEY = "action", NEXT_ACTION_KEY = "nextAction") {
-      const allOf = toolNameToDetailList.map(([toolName, _toolDetail]) => {
-        return {
+    forAgentic: function(toolNameToDetailList, _sampling = false, USE_TOOL_KEY = "useTool") {
+      const allOf = [
+        // When hasDefinitions is empty, definitionsOf must be provided
+        {
           if: {
             properties: {
-              [ACTION_KEY]: {
-                const: toolName
+              hasDefinitions: {
+                type: "array",
+                maxItems: 0
               }
             },
             required: [
-              ACTION_KEY
+              "hasDefinitions"
             ]
           },
           then: {
             required: [
-              toolName
+              "definitionsOf"
             ]
           }
-        };
-      });
-      const actionDescription = `Specifies the action to be performed from the enum. **\u26A0\uFE0F When setting \`action: "example_action"\`, you MUST also provide \`"example_action": { ... }\`**`;
+        },
+        // When useTool is present, hasDefinitions must contain that tool
+        ...toolNameToDetailList.map(([toolName, _toolDetail]) => {
+          return {
+            if: {
+              properties: {
+                [USE_TOOL_KEY]: {
+                  const: toolName
+                }
+              },
+              required: [
+                USE_TOOL_KEY
+              ]
+            },
+            then: {
+              properties: {
+                hasDefinitions: {
+                  type: "array",
+                  contains: {
+                    const: toolName
+                  }
+                }
+              },
+              required: [
+                "hasDefinitions"
+              ]
+            }
+          };
+        }),
+        // 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
+              ]
+            }
+          };
+        })
+      ];
+      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 = {
-        [ACTION_KEY]: {
+        [USE_TOOL_KEY]: {
           type: "string",
           enum: allToolNames,
-          description: actionDescription
+          description: useToolDescription
         },
-        [NEXT_ACTION_KEY]: {
-          type: "string",
-          enum: allToolNames,
-          description: "Optional: Specify the next action to execute. Only include this when you know additional actions are needed after the current one completes."
+        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."
         },
-        decision: this.decision(),
-        ...depGroups
+        definitionsOf: {
+          type: "array",
+          items: toolItems,
+          description: "Tool names whose schemas you need. Request tool schemas before calling them to understand their parameters."
+        }
       };
-      const requiredFields = [
-        ACTION_KEY,
-        "decision"
-      ];
+      const requiredFields = [];
       const schema = {
-        additionalProperties: false,
+        additionalProperties: true,
         type: "object",
         properties: baseProperties,
         required: requiredFields
@@ -1829,1025 +1695,1082 @@ NOTE: The \`steps\` has been predefined` : `**You MUST execute this tool with fo
   };
 }
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/sampling/base-sampling-executor.js
-import { Ajv as Ajv2 } from "ajv";
-import { AggregateAjvError as AggregateAjvError2 } from "@segment/ajv-human-errors";
-import addFormats2 from "ajv-formats";
-init_logger();
-import process5 from "node:process";
-var ajv2 = new Ajv2({
-  allErrors: true,
-  verbose: true
-});
-addFormats2(ajv2);
-var BaseSamplingExecutor = class {
-  name;
-  description;
-  allToolNames;
-  toolNameToDetailList;
-  server;
-  conversationHistory;
-  maxIterations;
-  currentIteration;
-  logger;
-  tracingEnabled;
-  summarize;
-  constructor(name, description, allToolNames, toolNameToDetailList, server2, config2) {
-    this.name = name;
-    this.description = description;
-    this.allToolNames = allToolNames;
-    this.toolNameToDetailList = toolNameToDetailList;
-    this.server = server2;
-    this.conversationHistory = [];
-    this.maxIterations = 55;
-    this.currentIteration = 0;
-    this.tracingEnabled = false;
-    this.summarize = true;
-    if (config2?.maxIterations) {
-      this.maxIterations = config2.maxIterations;
-    }
-    if (config2?.summarize !== void 0) {
-      this.summarize = config2.summarize;
-    }
-    this.logger = createLogger(`mcpc.sampling.${name}`, server2);
-    try {
-      const tracingConfig = {
-        enabled: process5.env.MCPC_TRACING_ENABLED === "true",
-        serviceName: `mcpc-sampling-${name}`,
-        exportTo: process5.env.MCPC_TRACING_EXPORT ?? "otlp",
-        otlpEndpoint: process5.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
-      };
-      this.tracingEnabled = tracingConfig.enabled;
-      if (this.tracingEnabled) {
-        initializeTracing(tracingConfig);
-      }
-    } catch {
-      this.tracingEnabled = false;
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-tool-registrar.js
+function registerAgenticTool(server2, { description, name, allToolNames, depGroups, toolNameToDetailList }) {
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
+  const agenticExecutor = new AgenticExecutor(name, allToolNames, toolNameToDetailList, server2);
+  description = CompiledPrompts.autonomousExecution({
+    toolName: name,
+    description
+  });
+  const agenticArgsDef = createArgsDef.forAgentic(toolNameToDetailList, false);
+  const argsDef = agenticArgsDef;
+  const schema = allToolNames.length > 0 ? argsDef : {
+    type: "object",
+    properties: {}
+  };
+  server2.tool(name, description, jsonSchema(createGoogleCompatibleJSONSchema(schema)), async (args) => {
+    return await agenticExecutor.execute(args, schema);
+  });
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/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__cli_latest/node_modules/@jsr/mcpc__core/src/utils/state.js
+var WorkflowState = class {
+  currentStepIndex = -1;
+  steps = [];
+  stepStatuses = [];
+  stepResults = [];
+  stepErrors = [];
+  isInitialized = false;
+  isStarted = false;
+  constructor(steps) {
+    if (steps) {
+      this.initialize(steps);
     }
   }
-  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);
+  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;
   }
-  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.`
-      }
-    });
+  getNextStep() {
+    if (!this.isInitialized) return null;
+    const nextIndex = this.currentStepIndex + 1;
+    return this.steps[nextIndex] || null;
   }
-  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;
+  // Get the previous step in the workflow
+  getPreviousStep() {
+    if (!this.isInitialized) return null;
+    const prevIndex = this.currentStepIndex - 1;
+    return this.steps[prevIndex] || null;
   }
-  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;
+  hasNextStep() {
+    return this.getNextStep() !== null;
   }
-  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
-    };
+  // Check if there is a previous step available
+  hasPreviousStep() {
+    return this.getPreviousStep() !== null;
   }
-  // Use LLM to create high-signal summary for parent agent
-  async summarizeConversation(parentSpan) {
-    if (this.conversationHistory.length === 0) {
-      return "\n\n**No conversation history**";
+  // 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;
     }
-    if (this.conversationHistory.length <= 3) {
-      return this.formatConversation();
+  }
+  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";
     }
-    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);
+  }
+  // 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;
       }
-      return summary;
-    } catch (error) {
-      this.logger.warning({
-        message: "Summarization failed, falling back to full history",
-        error: String(error)
-      });
-      if (summarizeSpan) {
-        endSpan(summarizeSpan, error);
+    }
+  }
+  // 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;
       }
-      return this.formatConversation();
     }
   }
-  // Format full conversation history (for debugging)
-  formatConversation() {
-    if (this.conversationHistory.length === 0) {
-      return "\n\n**No conversation history**";
+  // 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;
     }
-    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");
+    this.currentStepIndex--;
+    return true;
   }
-  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
-    });
+  // 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;
   }
-  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
+  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()
+    };
+  }
+};
 
-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(schema, null, 2) : void 0,
-      schemaSuffix
-    ].filter((line) => line != null).join("\n");
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-executor.js
+var WorkflowExecutor = class {
+  name;
+  allToolNames;
+  toolNameToDetailList;
+  createArgsDef;
+  server;
+  predefinedSteps;
+  ensureStepActions;
+  toolNameToIdMapping;
+  constructor(name, allToolNames, toolNameToDetailList, createArgsDef, server2, predefinedSteps, ensureStepActions, toolNameToIdMapping) {
+    this.name = name;
+    this.allToolNames = allToolNames;
+    this.toolNameToDetailList = toolNameToDetailList;
+    this.createArgsDef = createArgsDef;
+    this.server = server2;
+    this.predefinedSteps = predefinedSteps;
+    this.ensureStepActions = ensureStepActions;
+    this.toolNameToIdMapping = toolNameToIdMapping;
   }
-  // Validate arguments using JSON schema
-  validateSchema(args, schema) {
-    const validate = ajv2.compile(schema);
-    if (!validate(args)) {
-      const errors = new AggregateAjvError2(validate.errors);
+  // Helper method to validate required actions are present in workflow steps
+  validateRequiredActions(steps) {
+    if (!this.ensureStepActions || this.ensureStepActions.length === 0) {
       return {
-        valid: false,
-        error: errors.message
+        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: true
+      valid: missing.length === 0,
+      missing
     };
   }
-};
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/sampling/agentic-sampling-executor.js
-var SamplingExecutor = class extends BaseSamplingExecutor {
-  agenticExecutor;
-  constructor(name, description, allToolNames, toolNameToDetailList, server2, config2) {
-    super(name, description, allToolNames, toolNameToDetailList, server2, config2);
-    this.agenticExecutor = new AgenticExecutor(name, allToolNames, toolNameToDetailList, server2);
+  // Helper method to format workflow progress
+  formatProgress(state) {
+    const progressData = state.getProgressData();
+    return PromptUtils.formatWorkflowProgress(progressData);
   }
-  buildDepGroups() {
-    const depGroups = {};
-    this.toolNameToDetailList.forEach(([toolName, tool]) => {
-      if (tool?.inputSchema) {
-        depGroups[toolName] = {
-          type: "object",
-          description: tool.description || `Tool: ${toolName}`,
-          ...tool.inputSchema
+  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
         };
-      } else {
-        const toolSchema = this.server.getHiddenToolSchema(toolName);
-        if (toolSchema) {
-          depGroups[toolName] = {
-            ...toolSchema.schema,
-            description: toolSchema.description
+      }
+      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
           };
         }
       }
-    });
-    return depGroups;
+    }
+    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);
   }
-  executeSampling(args, schema) {
-    const validationResult = this.validateSchema(args, schema);
-    if (!validationResult.valid) {
+  initialize(args, state) {
+    const steps = args.steps ?? this.predefinedSteps;
+    if (!steps || steps.length === 0) {
       return {
         content: [
           {
             type: "text",
-            text: CompiledPrompts.errorResponse({
-              errorMessage: validationResult.error || "Validation failed"
-            })
+            text: WorkflowPrompts.ERRORS.NO_STEPS_PROVIDED
           }
         ],
         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__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-tool-registrar.js
-function registerAgenticTool(server2, { description, name, allToolNames, depGroups, toolNameToDetailList, sampling = false }) {
-  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
-  const isSamplingMode = sampling === true || typeof sampling === "object";
-  const samplingConfig = typeof sampling === "object" ? sampling : void 0;
-  const agenticExecutor = new AgenticExecutor(name, allToolNames, toolNameToDetailList, server2);
-  const samplingExecutor = new SamplingExecutor(name, description, allToolNames, toolNameToDetailList, server2, samplingConfig);
-  description = isSamplingMode ? CompiledPrompts.samplingExecution({
-    toolName: name,
-    description,
-    toolList: allToolNames.map((name2) => `- ${name2}`).join("\n")
-  }) : CompiledPrompts.autonomousExecution({
-    toolName: name,
-    description
-  });
-  const agenticArgsDef = createArgsDef.forAgentic(toolNameToDetailList, false);
-  const argsDef = isSamplingMode ? createArgsDef.forSampling() : agenticArgsDef;
-  const schema = allToolNames.length > 0 ? argsDef : {
-    type: "object",
-    properties: {}
-  };
-  server2.tool(name, description, jsonSchema(createGoogleCompatibleJSONSchema(schema)), async (args) => {
-    if (isSamplingMode) {
-      return await samplingExecutor.executeSampling(args, schema);
-    } else {
-      return await agenticExecutor.execute(args, schema);
-    }
-  });
-}
+    const validation = this.validateRequiredActions(steps);
+    if (!validation.valid) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `## Workflow Validation Failed \u274C
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-tool-registrar.js
-init_schema();
+**Missing Required Actions:** The following actions must be included in the workflow steps:
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/state.js
-var WorkflowState = class {
-  currentStepIndex = -1;
-  steps = [];
-  stepStatuses = [];
-  stepResults = [];
-  stepErrors = [];
-  isInitialized = false;
-  isStarted = false;
-  constructor(steps) {
-    if (steps) {
-      this.initialize(steps);
-    }
-  }
-  getCurrentStepIndex() {
-    return this.currentStepIndex;
-  }
-  getSteps() {
-    return this.steps;
-  }
-  isWorkflowInitialized() {
-    return this.isInitialized;
-  }
-  getCurrentStep() {
-    if (!this.isInitialized || this.currentStepIndex < 0) {
-      return null;
-    }
-    return this.steps[this.currentStepIndex] || null;
-  }
-  getNextStep() {
-    if (!this.isInitialized) return null;
-    const nextIndex = this.currentStepIndex + 1;
-    return this.steps[nextIndex] || null;
-  }
-  // Get the previous step in the workflow
-  getPreviousStep() {
-    if (!this.isInitialized) return null;
-    const prevIndex = this.currentStepIndex - 1;
-    return this.steps[prevIndex] || null;
-  }
-  hasNextStep() {
-    return this.getNextStep() !== null;
-  }
-  // Check if there is a previous step available
-  hasPreviousStep() {
-    return this.getPreviousStep() !== null;
-  }
-  // Check if currently at the first step
-  isAtFirstStep() {
-    return this.isInitialized && this.currentStepIndex === 0;
-  }
-  // Check if currently at the last step
-  isAtLastStep() {
-    return this.isInitialized && this.currentStepIndex >= this.steps.length - 1;
-  }
-  isWorkflowStarted() {
-    return this.isStarted;
-  }
-  isCompleted() {
-    return this.isInitialized && this.currentStepIndex > this.steps.length - 1;
-  }
-  // Mark workflow as completed by moving beyond the last step
-  markCompleted() {
-    if (this.isInitialized) {
-      this.currentStepIndex = this.steps.length;
-    }
-  }
-  initialize(steps) {
-    this.steps = steps;
-    this.stepStatuses = new Array(steps.length).fill("pending");
-    this.stepResults = new Array(steps.length).fill("");
-    this.stepErrors = new Array(steps.length).fill("");
-    this.currentStepIndex = 0;
-    this.isInitialized = true;
-    this.isStarted = false;
-  }
-  // Mark current step as running
-  markCurrentStepRunning() {
-    if (this.isInitialized && this.currentStepIndex >= 0 && this.currentStepIndex < this.steps.length) {
-      this.stepStatuses[this.currentStepIndex] = "running";
-    }
-  }
-  // Mark current step as completed
-  markCurrentStepCompleted(result) {
-    if (this.isInitialized && this.currentStepIndex >= 0 && this.currentStepIndex < this.steps.length) {
-      this.stepStatuses[this.currentStepIndex] = "completed";
-      if (result) {
-        this.stepResults[this.currentStepIndex] = result;
-      }
-    }
-  }
-  // Mark current step as failed
-  markCurrentStepFailed(error) {
-    if (this.isInitialized && this.currentStepIndex >= 0 && this.currentStepIndex < this.steps.length) {
-      this.stepStatuses[this.currentStepIndex] = "failed";
-      if (error) {
-        this.stepErrors[this.currentStepIndex] = error;
-      }
-    }
-  }
-  // Get steps with their status
-  getStepsWithStatus() {
-    return this.steps.map((step, index) => ({
-      ...step,
-      status: this.stepStatuses[index] || "pending",
-      result: this.stepResults[index] || void 0,
-      error: this.stepErrors[index] || void 0
-    }));
-  }
-  // Get basic workflow progress data for template rendering
-  getProgressData() {
-    return {
-      steps: this.steps,
-      statuses: this.stepStatuses,
-      results: this.stepResults,
-      errors: this.stepErrors,
-      currentStepIndex: this.currentStepIndex,
-      totalSteps: this.steps.length
+${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
     };
   }
-  start() {
-    this.isStarted = true;
-  }
-  moveToNextStep() {
-    if (!this.hasNextStep()) {
-      return false;
+  async executeStep(args, state) {
+    const currentStep = state.getCurrentStep();
+    if (!currentStep) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: WorkflowPrompts.ERRORS.NO_CURRENT_STEP
+          }
+        ],
+        isError: true
+      };
     }
-    this.currentStepIndex++;
-    return true;
-  }
-  // Move to the previous step in the workflow
-  moveToPreviousStep() {
-    if (!this.hasPreviousStep()) {
-      return false;
+    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;
+      }
     }
-    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;
+    if (results.isError) {
+      state.markCurrentStepFailed("Step execution failed");
+    } else {
+      state.markCurrentStepCompleted("Step completed successfully");
     }
-    this.currentStepIndex = stepIndex;
-    return true;
-  }
-  reset() {
-    this.currentStepIndex = -1;
-    this.steps = [];
-    this.stepStatuses = [];
-    this.stepResults = [];
-    this.stepErrors = [];
-    this.isInitialized = false;
-    this.isStarted = false;
+    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;
   }
-  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()
-    };
+  // Validate arguments using JSON schema
+  validateInput(args, schema) {
+    return validateSchema(args, schema);
   }
 };
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-tool-registrar.js
-init_provider();
+function registerAgenticWorkflowTool(server2, { description, name, allToolNames, depGroups, toolNameToDetailList, predefinedSteps, ensureStepActions, toolNameToIdMapping }) {
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, predefinedSteps, ensureStepActions);
+  const workflowExecutor = new WorkflowExecutor(name, allToolNames, toolNameToDetailList, createArgsDef, server2, 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);
+  server2.tool(name, toolDescription, jsonSchema(createGoogleCompatibleJSONSchema(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__cli_latest/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-executor.js
-import { Ajv as Ajv3 } from "ajv";
-import { AggregateAjvError as AggregateAjvError3 } from "@segment/ajv-human-errors";
-import addFormats3 from "ajv-formats";
-var ajv3 = new Ajv3({
-  allErrors: true,
-  verbose: true
+// __mcpc__cli_latest/node_modules/@jsr/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
+    });
+  }
 });
-addFormats3(ajv3);
-var WorkflowExecutor = class {
+var mode_workflow_plugin_default = createWorkflowModePlugin();
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/sampling/base-sampling-executor.js
+import process5 from "node:process";
+var BaseSamplingExecutor = class {
   name;
+  description;
   allToolNames;
   toolNameToDetailList;
-  createArgsDef;
   server;
-  predefinedSteps;
-  ensureStepActions;
-  toolNameToIdMapping;
-  constructor(name, allToolNames, toolNameToDetailList, createArgsDef, server2, predefinedSteps, ensureStepActions, toolNameToIdMapping) {
+  conversationHistory;
+  maxIterations;
+  currentIteration;
+  logger;
+  tracingEnabled;
+  summarize;
+  constructor(name, description, allToolNames, toolNameToDetailList, server2, config2) {
     this.name = name;
+    this.description = description;
     this.allToolNames = allToolNames;
     this.toolNameToDetailList = toolNameToDetailList;
-    this.createArgsDef = createArgsDef;
     this.server = server2;
-    this.predefinedSteps = predefinedSteps;
-    this.ensureStepActions = ensureStepActions;
-    this.toolNameToIdMapping = toolNameToIdMapping;
-  }
-  // Helper method to validate required actions are present in workflow steps
-  validateRequiredActions(steps) {
-    if (!this.ensureStepActions || this.ensureStepActions.length === 0) {
-      return {
-        valid: true,
-        missing: []
-      };
+    this.conversationHistory = [];
+    this.maxIterations = 55;
+    this.currentIteration = 0;
+    this.tracingEnabled = false;
+    this.summarize = true;
+    if (config2?.maxIterations) {
+      this.maxIterations = config2.maxIterations;
     }
-    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;
-        }
+    if (config2?.summarize !== void 0) {
+      this.summarize = config2.summarize;
+    }
+    this.logger = createLogger(`mcpc.sampling.${name}`, server2);
+    try {
+      const tracingConfig = {
+        enabled: process5.env.MCPC_TRACING_ENABLED === "true",
+        serviceName: `mcpc-sampling-${name}`,
+        exportTo: process5.env.MCPC_TRACING_EXPORT ?? "otlp",
+        otlpEndpoint: process5.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
+      };
+      this.tracingEnabled = tracingConfig.enabled;
+      if (this.tracingEnabled) {
+        initializeTracing(tracingConfig);
       }
-      missing.push(requiredAction);
+    } catch {
+      this.tracingEnabled = false;
     }
-    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: [
-            {
+  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: this.predefinedSteps ? WorkflowPrompts.ERRORS.NOT_INITIALIZED.WITH_PREDEFINED : WorkflowPrompts.ERRORS.NOT_INITIALIZED.WITHOUT_PREDEFINED
+              text: JSON.stringify(parsedData, null, 2)
             }
-          ],
-          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: [
-              {
+          });
+          const action = parsedData["action"];
+          const decision = parsedData["decision"];
+          if (typeof decision !== "string") {
+            this.conversationHistory.push({
+              role: "user",
+              content: {
                 type: "text",
-                text: WorkflowPrompts.ERRORS.ALREADY_AT_FINAL
+                text: 'Missing required field "decision". Provide: {"action":"<tool>","decision":"proceed|retry","<tool>":{}} or {"decision":"complete"}'
               }
-            ],
-            isError: true
-          };
-        }
-        const currentStepIndex = state.getCurrentStepIndex();
-        const wasStarted = state.isWorkflowStarted();
-        if (state.isWorkflowStarted()) {
-          state.moveToNextStep();
-        } else {
-          state.start();
-        }
-        const nextStepValidationSchema = this.createArgsDef.forCurrentState(state);
-        const nextStepValidationResult = this.validate(args, nextStepValidationSchema);
-        if (!nextStepValidationResult.valid) {
-          if (wasStarted) {
-            state.moveToStep(currentStepIndex);
-          } else {
-            state.moveToStep(currentStepIndex);
+            });
+            if (iterationSpan) endSpan(iterationSpan);
+            continue;
           }
-          return {
-            content: [
-              {
+          if (decision === "complete" && action) {
+            this.conversationHistory.push({
+              role: "user",
+              content: {
                 type: "text",
-                text: CompiledPrompts.workflowErrorResponse({
-                  errorMessage: `Cannot proceed to next step: ${nextStepValidationResult.error || "Arguments validation failed"}`
-                })
+                text: 'Invalid: Cannot have both "decision":"complete" and "action" field. When complete, only provide {"decision":"complete"}.'
               }
-            ],
-            isError: true
-          };
-        }
-      } else if (decision2 === "complete") {
-        if (state.isAtLastStep() && state.isWorkflowStarted()) {
-          state.markCompleted();
-          return {
-            content: [
-              {
+            });
+            if (iterationSpan) endSpan(iterationSpan);
+            continue;
+          }
+          if (decision !== "complete" && !action) {
+            this.conversationHistory.push({
+              role: "user",
+              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"
-                })}`
+                text: 'Missing required field "action". When executing, provide: {"action":"<tool>","decision":"proceed|retry","<tool>":{}}'
               }
-            ],
-            isError: false
-          };
-        } else {
-          return {
-            content: [
-              {
+            });
+            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: WorkflowPrompts.ERRORS.CANNOT_COMPLETE_NOT_AT_FINAL
+                text: result.content[0].text
               }
-            ],
-            isError: true
-          };
+            });
+            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 decision = args.decision;
-    if (decision !== "proceed") {
-      const validationSchema = this.createArgsDef.forCurrentState(state);
-      const validationResult = this.validate(args, validationSchema);
-      if (!validationResult.valid) {
-        return {
-          content: [
-            {
+    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: CompiledPrompts.workflowErrorResponse({
-                errorMessage: validationResult.error || "Arguments validation failed"
-              })
+              text: "Please provide a concise summary."
             }
-          ],
-          isError: true
-        };
+          }
+        ],
+        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();
     }
-    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
-      };
+  // Format full conversation history (for debugging)
+  formatConversation() {
+    if (this.conversationHistory.length === 0) {
+      return "\n\n**No conversation history**";
     }
-    const validation = this.validateRequiredActions(steps);
-    if (!validation.valid) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `## Workflow Validation Failed \u274C
+    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
 
-**Missing Required Actions:** The following actions must be included in the workflow steps:
+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(schema, null, 2) : void 0,
+      schemaSuffix
+    ].filter((line) => line != null).join("\n");
+  }
+  // Validate arguments using JSON schema
+  validateInput(args, schema) {
+    return validateSchema(args, schema);
+  }
+};
 
-${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)}`
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/sampling/agentic-sampling-executor.js
+var SamplingExecutor = class extends BaseSamplingExecutor {
+  agenticExecutor;
+  constructor(name, description, allToolNames, toolNameToDetailList, server2, config2) {
+    super(name, description, allToolNames, toolNameToDetailList, server2, config2);
+    this.agenticExecutor = new AgenticExecutor(name, allToolNames, toolNameToDetailList, server2);
+  }
+  buildDepGroups() {
+    const depGroups = {};
+    this.toolNameToDetailList.forEach(([toolName, tool]) => {
+      if (tool?.inputSchema) {
+        depGroups[toolName] = {
+          type: "object",
+          description: tool.description || `Tool: ${toolName}`,
+          ...tool.inputSchema
+        };
+      } else {
+        const toolSchema = this.server.getHiddenToolSchema(toolName);
+        if (toolSchema) {
+          depGroups[toolName] = {
+            ...toolSchema.schema,
+            description: toolSchema.description
+          };
         }
-      ],
-      isError: false
-    };
+      }
+    });
+    return depGroups;
   }
-  async executeStep(args, state) {
-    const currentStep = state.getCurrentStep();
-    if (!currentStep) {
+  executeSampling(args, schema) {
+    const validationResult = validateSchema(args, schema);
+    if (!validationResult.valid) {
       return {
         content: [
           {
             type: "text",
-            text: WorkflowPrompts.ERRORS.NO_CURRENT_STEP
+            text: CompiledPrompts.errorResponse({
+              errorMessage: validationResult.error || "Validation failed"
+            })
           }
         ],
         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"
-        })
+    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);
     }
-    results.content.push({
-      type: "text",
-      text: `## Workflow Progress
-${this.formatProgress(state)}`
-    });
-    return results;
   }
-  // Validate arguments using JSON schema
-  validate(args, schema) {
-    const validate = ajv3.compile(schema);
-    if (!validate(args)) {
-      const errors = new AggregateAjvError3(validate.errors);
-      return {
-        valid: false,
-        error: errors.message
-      };
+  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)}`;
     }
-    return {
-      valid: true
-    };
+    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__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-sampling-registrar.js
+function registerAgenticSamplingTool(server2, { description, name, allToolNames, depGroups, toolNameToDetailList, samplingConfig }) {
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
+  const samplingExecutor = new SamplingExecutor(name, description, allToolNames, toolNameToDetailList, server2, 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: {}
+  };
+  server2.tool(name, description, jsonSchema(createGoogleCompatibleJSONSchema(schema)), async (args) => {
+    return await samplingExecutor.executeSampling(args, schema);
+  });
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/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__cli_latest/node_modules/@jsr/mcpc__core/src/executors/sampling/workflow-sampling-executor.js
 var WorkflowSamplingExecutor = class extends BaseSamplingExecutor {
   createArgsDef;
@@ -2858,7 +2781,7 @@ var WorkflowSamplingExecutor = class extends BaseSamplingExecutor {
     this.workflowExecutor = new WorkflowExecutor(name, allToolNames, toolNameToDetailList, createArgsDef, server2, predefinedSteps);
   }
   async executeWorkflowSampling(args, schema, state) {
-    const validationResult = this.validateSchema(args, schema);
+    const validationResult = validateSchema(args, schema);
     if (!validationResult.valid) {
       return {
         content: [
@@ -2922,33 +2845,24 @@ Current Task: <user_request>${args.userRequest}</user_request>${contextInfo}`;
   }
 };
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-tool-registrar.js
-function registerAgenticWorkflowTool(server2, { description, name, allToolNames, depGroups, toolNameToDetailList, predefinedSteps, sampling = false, ensureStepActions, toolNameToIdMapping }) {
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-sampling-registrar.js
+function registerWorkflowSamplingTool(server2, { description, name, allToolNames, depGroups, toolNameToDetailList, predefinedSteps, samplingConfig, ensureStepActions, toolNameToIdMapping: _toolNameToIdMapping }) {
   const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, predefinedSteps, ensureStepActions);
-  const isSamplingMode = sampling === true || typeof sampling === "object";
-  const samplingConfig = typeof sampling === "object" ? sampling : void 0;
-  const workflowExecutor = new WorkflowExecutor(name, allToolNames, toolNameToDetailList, createArgsDef, server2, predefinedSteps, ensureStepActions, toolNameToIdMapping);
   const workflowSamplingExecutor = new WorkflowSamplingExecutor(name, description, allToolNames, toolNameToDetailList, createArgsDef, server2, predefinedSteps, samplingConfig);
   const workflowState = new WorkflowState();
-  const planningInstructions = predefinedSteps ? "- Set `init: true` (steps are predefined)" : "- Set `init: true` and define complete `steps` array";
-  const baseDescription = isSamplingMode ? CompiledPrompts.samplingExecution({
+  const baseDescription = CompiledPrompts.samplingExecution({
     toolName: name,
     description,
     toolList: allToolNames.map((name2) => `- ${name2}`).join("\n")
-  }) : CompiledPrompts.workflowExecution({
-    toolName: name,
-    description,
-    planningInstructions
   });
-  const argsDef = isSamplingMode ? createArgsDef.forSampling() : createArgsDef.forTool();
-  const toolDescription = isSamplingMode ? baseDescription : createArgsDef.forToolDescription(baseDescription, workflowState);
-  server2.tool(name, toolDescription, jsonSchema(createGoogleCompatibleJSONSchema(argsDef)), async (args) => {
+  const argsDef = createArgsDef.forSampling();
+  const schema = allToolNames.length > 0 ? argsDef : {
+    type: "object",
+    properties: {}
+  };
+  server2.tool(name, baseDescription, jsonSchema(createGoogleCompatibleJSONSchema(schema)), async (args) => {
     try {
-      if (isSamplingMode) {
-        return await workflowSamplingExecutor.executeWorkflowSampling(args, argsDef, workflowState);
-      } else {
-        return await workflowExecutor.execute(args, workflowState);
-      }
+      return await workflowSamplingExecutor.executeWorkflowSampling(args, schema, workflowState);
     } catch (error) {
       workflowState.reset();
       return {
@@ -2964,52 +2878,48 @@ function registerAgenticWorkflowTool(server2, { description, name, allToolNames,
   });
 }
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/tool-tag-processor.js
-var ALL_TOOLS_PLACEHOLDER = "__ALL__";
-function findToolId(toolName, tools, toolNameMapping) {
-  const mappedId = toolNameMapping?.get(toolName);
-  if (mappedId) {
-    return mappedId;
+// __mcpc__cli_latest/node_modules/@jsr/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
+    });
   }
-  return Object.keys(tools).find((id) => {
-    const dotNotation = id.replace(/_/g, ".");
-    return toolName === id || toolName === dotNotation;
-  });
-}
-function processToolTags({ description, tagToResults, $, tools, toolOverrides, toolNameMapping }) {
-  tagToResults.tool.forEach((toolEl) => {
-    const toolName = toolEl.attribs.name;
-    if (!toolName || toolName.includes(ALL_TOOLS_PLACEHOLDER)) {
-      $(toolEl).remove();
-      return;
-    }
-    const override = toolOverrides.get(toolName);
-    if (override?.visibility?.hidden) {
-      $(toolEl).remove();
-    } else if (override?.visibility?.public) {
-      $(toolEl).replaceWith(`<tool name="${toolName}"/>`);
-    } else {
-      const toolId = findToolId(toolName, tools, toolNameMapping);
-      if (toolId) {
-        $(toolEl).replaceWith(`<action action="${toolId}"/>`);
-      } else {
-        $(toolEl).remove();
-      }
-    }
-  });
-  return $.root().html() ?? description;
-}
+});
+var mode_workflow_sampling_plugin_default = createWorkflowSamplingModePlugin();
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/compose.js
-init_built_in();
-init_logger();
+// __mcpc__cli_latest/node_modules/@jsr/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__cli_latest/node_modules/@jsr/mcpc__core/src/plugin-utils.js
 var pluginCache = /* @__PURE__ */ new Map();
 function shouldApplyPlugin(plugin, mode) {
   if (!plugin.apply) return true;
   if (typeof plugin.apply === "string") {
-    return mode.includes(plugin.apply);
+    return mode === plugin.apply;
   }
   if (typeof plugin.apply === "function") {
     try {
@@ -3059,7 +2969,7 @@ function isValidPlugin(plugin) {
   if (!p2.name || typeof p2.name !== "string" || p2.name.trim() === "") {
     return false;
   }
-  const hasHook = typeof p2.configureServer === "function" || typeof p2.composeStart === "function" || typeof p2.transformTool === "function" || typeof p2.finalizeComposition === "function" || typeof p2.composeEnd === "function" || typeof p2.transformInput === "function" || typeof p2.transformOutput === "function" || typeof p2.dispose === "function";
+  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;
@@ -3196,7 +3106,6 @@ function validatePlugins(plugins) {
 }
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/plugin-manager.js
-init_logger();
 var PluginManager = class {
   server;
   plugins;
@@ -3344,6 +3253,29 @@ var PluginManager = class {
       }
     }
   }
+  /**
+   * 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
    */
@@ -3363,7 +3295,6 @@ var PluginManager = class {
 };
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/tool-manager.js
-init_schema();
 var ToolManager = class {
   toolRegistry = /* @__PURE__ */ new Map();
   toolConfigs = /* @__PURE__ */ new Map();
@@ -3572,9 +3503,103 @@ var ToolManager = class {
   }
 };
 
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/schema.js
+import traverse from "json-schema-traverse";
+function updateRefPaths(schema, wrapperPath) {
+  if (!schema || typeof schema !== "object") {
+    return schema;
+  }
+  if (!wrapperPath || typeof wrapperPath !== "string") {
+    throw new Error("wrapperPath must be a non-empty string");
+  }
+  const clonedSchema = JSON.parse(JSON.stringify(schema));
+  try {
+    traverse(clonedSchema, {
+      allKeys: true,
+      cb: function(schemaNode, _jsonPtr, _rootSchema, _parentJsonPtr, _parentKeyword, _parentSchema, _keyIndex) {
+        if (schemaNode && typeof schemaNode === "object" && schemaNode.$ref) {
+          const ref = schemaNode.$ref;
+          if (ref.startsWith("#/properties/")) {
+            const relativePath = ref.substring(13);
+            schemaNode.$ref = `#/properties/${wrapperPath}/properties/${relativePath}`;
+          } else if (ref === "#") {
+            schemaNode.$ref = `#/properties/${wrapperPath}`;
+          }
+        }
+      }
+    });
+  } catch (error) {
+    console.warn(`Failed to traverse schema for path "${wrapperPath}":`, error);
+    return clonedSchema;
+  }
+  return clonedSchema;
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/compose-helpers.js
+async function processToolsWithPlugins(server2, _externalTools, mode) {
+  const toolManager = server2.toolManager;
+  const pluginManager = server2.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: server2,
+      mode,
+      originalTool: {
+        ...tempTool
+      },
+      transformationIndex: 0
+    });
+    toolManager.registerTool(toolId, processedTool.description || toolData.description, processedTool.inputSchema, processedTool.execute);
+  }
+}
+function buildDependencyGroups(toolNameToDetailList, hiddenToolNames, publicToolNames, server2) {
+  const depGroups = {};
+  const toolManager = server2.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__cli_latest/node_modules/@jsr/mcpc__core/src/compose.js
-init_compose_helpers();
-init_provider();
 var ALL_TOOLS_PLACEHOLDER2 = "__ALL__";
 var ComposableMCPServer = class extends Server {
   pluginManager;
@@ -3789,8 +3814,7 @@ var ComposableMCPServer = class extends Server {
    * Apply plugins to all tools in registry and handle visibility configurations
    */
   async processToolsWithPlugins(externalTools, mode) {
-    const { processToolsWithPlugins: processTools } = await Promise.resolve().then(() => (init_compose_helpers(), compose_helpers_exports));
-    await processTools(this, externalTools, mode);
+    await processToolsWithPlugins(this, externalTools, mode);
   }
   /**
    * Dispose all plugins and cleanup resources
@@ -3798,6 +3822,13 @@ var ComposableMCPServer = class extends Server {
   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 = {
@@ -3943,30 +3974,23 @@ var ComposableMCPServer = class extends Server {
     });
     const allToolNames = contextToolNames;
     const depGroups = buildDependencyGroups(toolNameToDetailList, hiddenToolNames, publicToolNames, this);
-    switch (options.mode ?? "agentic") {
-      case "agentic":
-        registerAgenticTool(this, {
-          description,
-          name,
-          allToolNames,
-          depGroups,
-          toolNameToDetailList,
-          sampling: options.sampling
-        });
-        break;
-      case "agentic_workflow":
-        registerAgenticWorkflowTool(this, {
-          description,
-          name,
-          allToolNames,
-          depGroups,
-          toolNameToDetailList,
-          predefinedSteps: options.steps,
-          sampling: options.sampling,
-          ensureStepActions: options.ensureStepActions,
-          toolNameToIdMapping
-        });
-        break;
+    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?`);
     }
   }
 };
@@ -3981,9 +4005,6 @@ if (isSCF()) {
   });
 }
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/mod.js
-init_json();
-
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/set-up-mcp-compose.js
 function parseMcpcConfigs(conf) {
   const mcpcConfigs = conf ?? [];
@@ -4025,16 +4046,12 @@ async function mcpc(serverConf, composeConf, setupCallback) {
   return server2;
 }
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/mod.js
-init_schema();
-
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/large-result.js
 import { mkdtemp, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/search-tool.js
-init_schema();
 import rg from "@mcpc-tech/ripgrep-napi";
 import { tmpdir } from "node:os";
 import { resolve } from "node:path";