@mcpc-tech/cli 0.1.1-beta.1 → 0.1.2

package/{src/bin.mjs → bin.mjs}

@@ -9,16 +9,141 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugins/built-in/config-plugin.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/schema.js
+function jsonSchema(schema, options = {}) {
+  if (isWrappedSchema(schema)) {
+    return schema;
+  }
+  return {
+    [schemaSymbol]: true,
+    [validatorSymbol]: true,
+    _type: void 0,
+    jsonSchema: schema,
+    validate: options.validate
+  };
+}
+function isWrappedSchema(value) {
+  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true;
+}
+function extractJsonSchema(schema) {
+  if (isWrappedSchema(schema)) {
+    return schema.jsonSchema;
+  }
+  return schema;
+}
+var schemaSymbol, validatorSymbol;
+var init_schema = __esm({
+  "../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/schema.js"() {
+    schemaSymbol = Symbol.for("mcpc.schema");
+    validatorSymbol = Symbol.for("mcpc.validator");
+  }
+});
+
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/logger.js
+function createLogger(name, 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}]`;
+        if (level === "debug") {
+          console.debug(prefix, message);
+        } else if (level === "info" || level === "notice") {
+          console.info(prefix, message);
+        } else if (level === "warning") {
+          console.warn(prefix, message);
+        } else {
+          console.error(prefix, message);
+        }
+      }
+      debug(data) {
+        return this.log("debug", data);
+      }
+      info(data) {
+        return this.log("info", data);
+      }
+      notice(data) {
+        return this.log("notice", data);
+      }
+      warning(data) {
+        return this.log("warning", data);
+      }
+      error(data) {
+        return this.log("error", data);
+      }
+      critical(data) {
+        return this.log("critical", data);
+      }
+      alert(data) {
+        return this.log("alert", data);
+      }
+      emergency(data) {
+        return this.log("emergency", data);
+      }
+      child(name) {
+        const child = new _MCPLogger(`${this.loggerName}.${name}`, this.server);
+        child.setLevel(this.minLevel);
+        return child;
+      }
+    };
+    logger = new MCPLogger("mcpc");
+  }
+});
+
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/config-plugin.js
 var createConfigPlugin, config_plugin_default;
 var init_config_plugin = __esm({
-  "../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugins/built-in/config-plugin.js"() {
+  "../__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, context) => {
-        const server2 = context.server;
-        const config2 = server2.findToolConfig?.(context.toolName);
+      transformTool: (tool, context2) => {
+        const server2 = context2.server;
+        const config2 = server2.findToolConfig?.(context2.toolName);
         if (config2?.description) {
           tool.description = config2.description;
         }
@@ -29,16 +154,17 @@ var init_config_plugin = __esm({
   }
 });
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugins/built-in/tool-name-mapping-plugin.js
+// ../__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_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugins/built-in/tool-name-mapping-plugin.js"() {
+  "../__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, context) => {
-        const server2 = context.server;
-        const toolName = context.toolName;
+      transformTool: (tool, context2) => {
+        const server2 = context2.server;
+        const toolName = context2.toolName;
         const dotNotation = toolName.replace(/_/g, ".");
         const underscoreNotation = toolName.replace(/\./g, "_");
         if (dotNotation !== toolName && server2.toolNameMapping) {
@@ -56,58 +182,37 @@ var init_tool_name_mapping_plugin = __esm({
   }
 });
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugins/built-in/logging-plugin.js
+// ../__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_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugins/built-in/logging-plugin.js"() {
+  "../__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",
-        composeEnd: (context) => {
+        version: "1.0.0",
+        composeEnd: async (context2) => {
           if (!enabled) return;
+          const logger2 = createLogger("mcpc.plugin.logging", context2.server);
           if (compact2) {
-            const pluginCount = context.pluginNames.length;
-            const server2 = context.server;
-            const externalList = server2.getExternalToolNames();
-            const internalList = server2.getInternalToolNames();
-            const hiddenList = server2.getHiddenToolNames();
-            const publicToolNames = server2.getPublicToolNames();
-            const externalCount = externalList.length;
-            const internalCount = internalList.length;
-            const hiddenCount = hiddenList.length;
-            const globalCount = publicToolNames.length;
-            console.log(`\u{1F9E9} [${context.toolName}] ${pluginCount} plugins \u2022 ${externalCount} external \u2022 ${internalCount} internal \u2022 ${hiddenCount} hidden \u2022 ${globalCount} global`);
+            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) {
-            console.log(`\u{1F9E9} [${context.toolName}]`);
-            console.log(`   \u251C\u2500 Plugins: ${context.pluginNames.join(", ")}`);
-            const server2 = context.server;
-            const globalToolNames = Array.from(new Set(server2.getPublicToolNames().map(String)));
-            const external = Array.from(new Set(server2.getExternalToolNames().map(String)));
-            const internal = Array.from(new Set(server2.getInternalToolNames().map(String)));
-            const hidden = Array.from(new Set(server2.getHiddenToolNames().map(String)));
-            const globalNames = globalToolNames.map(String);
-            const totalSet = /* @__PURE__ */ new Set([
-              ...external,
-              ...internal,
-              ...globalNames
-            ]);
-            const totalList = Array.from(totalSet);
-            if (external.length > 0) {
-              console.log(`   \u251C\u2500 External: ${external.join(", ")}`);
-            }
-            if (internal.length > 0) {
-              console.log(`   \u251C\u2500 Internal: ${internal.join(", ")}`);
-            }
-            if (globalNames.length > 0) {
-              console.log(`   \u251C\u2500 Global: ${globalNames.join(", ")}`);
-            }
-            if (hidden.length > 0) {
-              console.log(`   \u251C\u2500 Hidden: ${hidden.join(", ")}`);
+            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 hiddenTools = Array.from(new Set(server2.getHiddenToolNames().map(String)));
+            if (publicTools.length > 0) {
+              await logger2.info(`   \u251C\u2500 Public: ${publicTools.join(", ")}`);
             }
-            if (totalList.length > 0) {
-              console.log(`   \u2514\u2500 Total: ${totalList.length} tools`);
+            if (hiddenTools.length > 0) {
+              await logger2.info(`   \u251C\u2500 Hidden: ${hiddenTools.join(", ")}`);
             }
+            await logger2.info(`   \u2514\u2500 Total: ${stats.totalTools} tools`);
           }
         }
       };
@@ -119,7 +224,7 @@ var init_logging_plugin = __esm({
   }
 });
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugins/built-in/index.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/index.js
 var built_in_exports = {};
 __export(built_in_exports, {
   createConfigPlugin: () => createConfigPlugin,
@@ -135,7 +240,7 @@ function getBuiltInPlugins() {
   ];
 }
 var init_built_in = __esm({
-  "../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugins/built-in/index.js"() {
+  "../__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();
@@ -145,20 +250,362 @@ var init_built_in = __esm({
   }
 });
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@mcpc/cli/src/bin.ts
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugin-utils.js
+var plugin_utils_exports = {};
+__export(plugin_utils_exports, {
+  checkCircularDependencies: () => checkCircularDependencies,
+  clearPluginCache: () => clearPluginCache,
+  getPluginsWithHook: () => getPluginsWithHook,
+  isValidPlugin: () => isValidPlugin,
+  loadPlugin: () => loadPlugin,
+  shouldApplyPlugin: () => shouldApplyPlugin,
+  sortPluginsByOrder: () => sortPluginsByOrder,
+  validatePlugins: () => validatePlugins
+});
+function shouldApplyPlugin(plugin, mode) {
+  if (!plugin.apply) return true;
+  if (typeof plugin.apply === "string") {
+    return mode.includes(plugin.apply);
+  }
+  if (typeof plugin.apply === "function") {
+    try {
+      return plugin.apply(mode);
+    } catch (error) {
+      console.warn(`Plugin "${plugin.name}" apply function failed: ${error}. Defaulting to true.`);
+      return true;
+    }
+  }
+  return true;
+}
+function sortPluginsByOrder(plugins) {
+  const pluginMap = /* @__PURE__ */ new Map();
+  for (const plugin of plugins) {
+    pluginMap.set(plugin.name, plugin);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const sorted = [];
+  function visit(plugin) {
+    if (visited.has(plugin.name)) return;
+    visited.add(plugin.name);
+    if (plugin.dependencies) {
+      for (const depName of plugin.dependencies) {
+        const dep = pluginMap.get(depName);
+        if (dep) {
+          visit(dep);
+        } else {
+          console.warn(`Plugin "${plugin.name}" depends on "${depName}" which is not loaded`);
+        }
+      }
+    }
+    sorted.push(plugin);
+  }
+  const prePlugins = plugins.filter((p2) => p2.enforce === "pre");
+  const normalPlugins = plugins.filter((p2) => !p2.enforce);
+  const postPlugins = plugins.filter((p2) => p2.enforce === "post");
+  [
+    ...prePlugins,
+    ...normalPlugins,
+    ...postPlugins
+  ].forEach(visit);
+  return sorted;
+}
+function getPluginsWithHook(plugins, hookName) {
+  return plugins.filter((p2) => typeof p2[hookName] === "function");
+}
+function isValidPlugin(plugin) {
+  if (!plugin || typeof plugin !== "object") return false;
+  const p2 = plugin;
+  if (!p2.name || typeof p2.name !== "string" || p2.name.trim() === "") {
+    return false;
+  }
+  const hasHook = typeof p2.configureServer === "function" || typeof p2.composeStart === "function" || typeof p2.transformTool === "function" || typeof p2.finalizeComposition === "function" || typeof p2.composeEnd === "function" || typeof p2.transformInput === "function" || typeof p2.transformOutput === "function" || typeof p2.dispose === "function";
+  if (!hasHook) return false;
+  if (p2.enforce && p2.enforce !== "pre" && p2.enforce !== "post") {
+    return false;
+  }
+  if (p2.apply && typeof p2.apply !== "string" && typeof p2.apply !== "function") {
+    return false;
+  }
+  if (p2.dependencies && !Array.isArray(p2.dependencies)) {
+    return false;
+  }
+  return true;
+}
+function parseQueryParams(params) {
+  const typedParams = {};
+  for (const [key, value] of Object.entries(params)) {
+    const numValue = Number(value);
+    if (!isNaN(numValue) && value.trim() !== "") {
+      typedParams[key] = numValue;
+      continue;
+    }
+    if (value === "true") {
+      typedParams[key] = true;
+      continue;
+    }
+    if (value === "false") {
+      typedParams[key] = false;
+      continue;
+    }
+    if (value.includes(",")) {
+      typedParams[key] = value.split(",").map((v) => v.trim());
+      continue;
+    }
+    typedParams[key] = value;
+  }
+  return typedParams;
+}
+async function loadPlugin(pluginPath, options = {
+  cache: true
+}) {
+  if (options.cache && pluginCache.has(pluginPath)) {
+    return pluginCache.get(pluginPath);
+  }
+  try {
+    const [rawPath, queryString] = pluginPath.split("?", 2);
+    const searchParams = new URLSearchParams(queryString || "");
+    const params = Object.fromEntries(searchParams.entries());
+    const importPath = rawPath;
+    const pluginModule = await import(importPath);
+    const pluginFactory = pluginModule.createPlugin;
+    const defaultPlugin = pluginModule.default;
+    let plugin;
+    if (Object.keys(params).length > 0) {
+      if (typeof pluginFactory !== "function") {
+        throw new Error(`Plugin "${rawPath}" has parameters but no createPlugin export function`);
+      }
+      const typedParams = parseQueryParams(params);
+      plugin = pluginFactory(typedParams);
+    } else {
+      if (defaultPlugin) {
+        plugin = defaultPlugin;
+      } else if (typeof pluginFactory === "function") {
+        plugin = pluginFactory();
+      } else {
+        throw new Error(`Plugin "${rawPath}" has no default export or createPlugin function`);
+      }
+    }
+    if (!isValidPlugin(plugin)) {
+      throw new Error(`Invalid plugin format in "${rawPath}": must have a unique name and at least one lifecycle hook`);
+    }
+    if (options.cache) {
+      pluginCache.set(pluginPath, plugin);
+    }
+    return plugin;
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load plugin from "${pluginPath}": ${errorMsg}`);
+  }
+}
+function clearPluginCache() {
+  pluginCache.clear();
+}
+function checkCircularDependencies(plugins) {
+  const errors = [];
+  const pluginMap = /* @__PURE__ */ new Map();
+  for (const plugin of plugins) {
+    pluginMap.set(plugin.name, plugin);
+  }
+  function checkCircular(pluginName, visited, path) {
+    if (visited.has(pluginName)) {
+      const cycle = [
+        ...path,
+        pluginName
+      ].join(" -> ");
+      errors.push(`Circular dependency detected: ${cycle}`);
+      return;
+    }
+    const plugin = pluginMap.get(pluginName);
+    if (!plugin || !plugin.dependencies) return;
+    visited.add(pluginName);
+    path.push(pluginName);
+    for (const dep of plugin.dependencies) {
+      checkCircular(dep, new Set(visited), [
+        ...path
+      ]);
+    }
+  }
+  for (const plugin of plugins) {
+    checkCircular(plugin.name, /* @__PURE__ */ new Set(), []);
+  }
+  return errors;
+}
+function validatePlugins(plugins) {
+  const errors = [];
+  const names = /* @__PURE__ */ new Map();
+  for (const plugin of plugins) {
+    const count = names.get(plugin.name) || 0;
+    names.set(plugin.name, count + 1);
+  }
+  for (const [name, count] of names.entries()) {
+    if (count > 1) {
+      errors.push(`Duplicate plugin name: "${name}" (${count} instances)`);
+    }
+  }
+  const circularErrors = checkCircularDependencies(plugins);
+  errors.push(...circularErrors);
+  for (const plugin of plugins) {
+    if (!isValidPlugin(plugin)) {
+      const name = plugin.name || "unknown";
+      errors.push(`Invalid plugin: "${name}"`);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+var pluginCache;
+var init_plugin_utils = __esm({
+  "../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugin-utils.js"() {
+    pluginCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/schema.js
+import traverse from "json-schema-traverse";
+function updateRefPaths(schema, wrapperPath) {
+  if (!schema || typeof schema !== "object") {
+    return schema;
+  }
+  if (!wrapperPath || typeof wrapperPath !== "string") {
+    throw new Error("wrapperPath must be a non-empty string");
+  }
+  const clonedSchema = JSON.parse(JSON.stringify(schema));
+  try {
+    traverse(clonedSchema, {
+      allKeys: true,
+      cb: function(schemaNode, _jsonPtr, _rootSchema, _parentJsonPtr, _parentKeyword, _parentSchema, _keyIndex) {
+        if (schemaNode && typeof schemaNode === "object" && schemaNode.$ref) {
+          const ref = schemaNode.$ref;
+          if (ref.startsWith("#/properties/")) {
+            const relativePath = ref.substring(13);
+            schemaNode.$ref = `#/properties/${wrapperPath}/properties/${relativePath}`;
+          } else if (ref === "#") {
+            schemaNode.$ref = `#/properties/${wrapperPath}`;
+          }
+        }
+      }
+    });
+  } catch (error) {
+    console.warn(`Failed to traverse schema for path "${wrapperPath}":`, error);
+    return clonedSchema;
+  }
+  return clonedSchema;
+}
+var init_schema2 = __esm({
+  "../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/schema.js"() {
+  }
+});
+
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/compose-helpers.js
+var compose_helpers_exports = {};
+__export(compose_helpers_exports, {
+  buildDependencyGroups: () => buildDependencyGroups,
+  processToolsWithPlugins: () => processToolsWithPlugins,
+  registerGlobalTools: () => registerGlobalTools
+});
+async function processToolsWithPlugins(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);
+    depGroups[toolName] = {
+      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();
+  }
+});
+
+// ../__mcpc__cli_latest/node_modules/@mcpc/cli/src/bin.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@mcpc/cli/src/app.js
+// ../__mcpc__cli_latest/node_modules/@mcpc/cli/src/app.js
 import { OpenAPIHono } from "@hono/zod-openapi";
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@mcpc/cli/src/controllers/messages.controller.js
+// ../__mcpc__cli_latest/node_modules/@mcpc/cli/src/controllers/messages.controller.js
 import { createRoute } from "@hono/zod-openapi";
 import { z } from "zod";
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__utils/src/transport/sse.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/transport/sse.js
 import { JSONRPCMessageSchema } from "@modelcontextprotocol/sdk/types.js";
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/std__http/server_sent_event_stream.js
+// ../__mcpc__cli_latest/node_modules/@jsr/std__http/server_sent_event_stream.js
 var NEWLINE_REGEXP = /\r\n|\r|\n/;
 var encoder = new TextEncoder();
 function assertHasNoNewline(value, varName, errPrefix) {
@@ -196,37 +643,50 @@ var ServerSentEventStream = class extends TransformStream {
   }
 };
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@mcpc/cli/src/controllers/sse.controller.js
+// ../__mcpc__cli_latest/node_modules/@mcpc/cli/src/controllers/sse.controller.js
 import { createRoute as createRoute2, z as z2 } from "@hono/zod-openapi";
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/compose.js
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { jsonSchema as jsonSchema3 } from "ai";
+// ../__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_0.1.1-beta.1/node_modules/@jsr/mcpc__utils/src/json.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/json.js
 import { jsonrepair } from "jsonrepair";
+function stripMarkdownAndText(text) {
+  text = text.trim();
+  text = text.replace(/^```(?:json)?\s*\n?/i, "");
+  text = text.replace(/\n?```\s*$/, "");
+  text = text.replace(/^(?:here is|here's|response|result|output|json):\s*/i, "");
+  const jsonMatch = text.match(/(\{[\s\S]*\}|\[[\s\S]*\])/);
+  if (jsonMatch) {
+    text = jsonMatch[1];
+  }
+  return text.trim();
+}
 function parseJSON(text, throwError) {
   try {
     return JSON.parse(text);
   } catch (_error) {
     try {
-      const repairedText = jsonrepair(text);
-      console.warn(`Failed to parse JSON, attempting to repair, result: ${text}`);
-      if (throwError) {
-        throw _error;
+      const cleanedText = stripMarkdownAndText(text);
+      try {
+        return JSON.parse(cleanedText);
+      } catch {
+        const repairedText = jsonrepair(cleanedText);
+        console.warn(`Failed to parse JSON, cleaned and repaired. Original: ${text.slice(0, 100)}...`);
+        return JSON.parse(repairedText);
       }
-      return JSON.parse(repairedText);
-    } catch {
+    } catch (_repairError) {
       if (throwError) {
-        throw new Error("Failed to parse repaired JSON");
+        throw new Error(`Failed to parse JSON after cleanup and repair. Original error: ${_error instanceof Error ? _error.message : String(_error)}`);
       }
       return null;
     }
   }
 }
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__utils/src/ai.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/ai.js
 var p = (template, options = {}) => {
   const { missingVariableHandling = "warn" } = options;
   const names = /* @__PURE__ */ new Set();
@@ -262,7 +722,7 @@ var p = (template, options = {}) => {
   };
 };
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__utils/src/tool-tags.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/tool-tags.js
 import { load } from "cheerio";
 function parseTags(htmlString, tags) {
   const $ = load(htmlString, {
@@ -281,13 +741,13 @@ function parseTags(htmlString, tags) {
   };
 }
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/utils/common/registory.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/registory.js
 function connectToSmitheryServer(smitheryConfig) {
   const serverUrl = new URL(smitheryConfig.deploymentUrl);
   serverUrl.searchParams.set("config", btoa(JSON.stringify(smitheryConfig.config)));
@@ -312,7 +772,7 @@ function smitheryToolNameCompatibale(name, scope) {
   };
 }
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
 import { cwd } from "node:process";
 import process2 from "node:process";
 import { createHash } from "node:crypto";
@@ -475,50 +935,18 @@ async function composeMcpDepTools(mcpConfig, filterIn) {
   };
 }
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/utils/common/schema.js
-import traverse from "json-schema-traverse";
-function updateRefPaths(schema, wrapperPath) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  if (!wrapperPath || typeof wrapperPath !== "string") {
-    throw new Error("wrapperPath must be a non-empty string");
-  }
-  const clonedSchema = JSON.parse(JSON.stringify(schema));
-  try {
-    traverse(clonedSchema, {
-      allKeys: true,
-      cb: function(schemaNode, _jsonPtr, _rootSchema, _parentJsonPtr, _parentKeyword, _parentSchema, _keyIndex) {
-        if (schemaNode && typeof schemaNode === "object" && schemaNode.$ref) {
-          const ref = schemaNode.$ref;
-          if (ref.startsWith("#/properties/")) {
-            const relativePath = ref.substring(13);
-            schemaNode.$ref = `#/properties/${wrapperPath}/properties/${relativePath}`;
-          } else if (ref === "#") {
-            schemaNode.$ref = `#/properties/${wrapperPath}`;
-          }
-        }
-      }
-    });
-  } catch (error) {
-    console.warn(`Failed to traverse schema for path "${wrapperPath}":`, error);
-    return clonedSchema;
-  }
-  return clonedSchema;
-}
-
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-tool-registrar.js
-import { jsonSchema } from "ai";
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-tool-registrar.js
+init_schema();
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/utils/common/config.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/config.js
 import process3 from "node:process";
 var GEMINI_PREFERRED_FORMAT = process3.env.GEMINI_PREFERRED_FORMAT === "0" ? false : true;
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/utils/common/json.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/json.js
 import { jsonrepair as jsonrepair2 } from "jsonrepair";
 import { inspect } from "node:util";
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/utils/common/provider.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/provider.js
 var createGoogleCompatibleJSONSchema = (schema) => {
   if (!GEMINI_PREFERRED_FORMAT) {
     return schema;
@@ -542,7 +970,7 @@ var createGoogleCompatibleJSONSchema = (schema) => {
   return removeAdditionalProperties(cleanSchema);
 };
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/prompts/index.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/prompts/index.js
 var SystemPrompts = {
   /**
    * Base system prompt for autonomous MCP execution
@@ -884,10 +1312,81 @@ ${JSON.stringify(steps, null, 2)}`;
   }
 };
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-executor.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-executor.js
 import { Ajv } from "ajv";
 import { AggregateAjvError } from "@segment/ajv-human-errors";
 import addFormats from "ajv-formats";
+init_logger();
+
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/tracing.js
+import { context, SpanStatusCode, trace } from "@opentelemetry/api";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { BatchSpanProcessor, ConsoleSpanExporter, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { Resource } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+var tracerProvider = null;
+var tracer = null;
+var isInitialized = false;
+function initializeTracing(config2 = {}) {
+  if (isInitialized) {
+    return;
+  }
+  const { enabled = true, serviceName = "mcpc-sampling", serviceVersion = "0.2.0", exportTo = "console", otlpEndpoint = "http://localhost:4318/v1/traces", otlpHeaders = {} } = config2;
+  if (!enabled) {
+    isInitialized = true;
+    return;
+  }
+  const resource = Resource.default().merge(new Resource({
+    [ATTR_SERVICE_NAME]: serviceName,
+    [ATTR_SERVICE_VERSION]: serviceVersion
+  }));
+  tracerProvider = new NodeTracerProvider({
+    resource
+  });
+  if (exportTo === "console") {
+    tracerProvider.addSpanProcessor(new SimpleSpanProcessor(new ConsoleSpanExporter()));
+  } else if (exportTo === "otlp") {
+    const otlpExporter = new OTLPTraceExporter({
+      url: otlpEndpoint,
+      headers: otlpHeaders
+    });
+    tracerProvider.addSpanProcessor(new BatchSpanProcessor(otlpExporter));
+  }
+  tracerProvider.register();
+  tracer = trace.getTracer(serviceName, serviceVersion);
+  isInitialized = true;
+}
+function getTracer() {
+  if (!isInitialized) {
+    initializeTracing();
+  }
+  return tracer;
+}
+function startSpan(name, attributes, parent) {
+  const tracer2 = getTracer();
+  const ctx = parent ? trace.setSpan(context.active(), parent) : void 0;
+  return tracer2.startSpan(name, {
+    attributes
+  }, ctx);
+}
+function endSpan(span, error) {
+  if (error) {
+    span.setStatus({
+      code: SpanStatusCode.ERROR,
+      message: error.message
+    });
+    span.recordException(error);
+  } else {
+    span.setStatus({
+      code: SpanStatusCode.OK
+    });
+  }
+  span.end();
+}
+
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-executor.js
+import process4 from "node:process";
 var ajv = new Ajv({
   allErrors: true,
   verbose: true
@@ -900,6 +1399,8 @@ var AgenticExecutor = class {
   server;
   ACTION_KEY;
   NEXT_ACTION_KEY;
+  logger;
+  tracingEnabled;
   constructor(name, allToolNames, toolNameToDetailList, server2, ACTION_KEY = "action", NEXT_ACTION_KEY = "nextAction") {
     this.name = name;
     this.allToolNames = allToolNames;
@@ -907,93 +1408,216 @@ var AgenticExecutor = class {
     this.server = server2;
     this.ACTION_KEY = ACTION_KEY;
     this.NEXT_ACTION_KEY = NEXT_ACTION_KEY;
-  }
-  async execute(args, schema) {
-    const validationResult = this.validate(args, schema);
-    if (!validationResult.valid) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: CompiledPrompts.errorResponse({
-              errorMessage: validationResult.error || "Validation failed"
-            })
-          }
-        ],
-        isError: true
-      };
-    }
-    const actionName = args[this.ACTION_KEY];
-    const currentTool = this.toolNameToDetailList.find(([name, _detail]) => name === actionName)?.[1];
-    if (currentTool) {
-      const nextAction = args[this.NEXT_ACTION_KEY];
-      const currentResult = await currentTool.execute({
-        ...args[actionName]
-      });
-      if (args[nextAction]) {
-        currentResult?.content?.push({
-          type: "text",
-          text: CompiledPrompts.actionSuccess({
-            toolName: this.name,
-            nextAction,
-            currentAction: actionName
-          })
-        });
-      } else {
-        currentResult?.content?.push({
-          type: "text",
-          text: CompiledPrompts.planningPrompt({
-            currentAction: actionName
-          })
+    this.tracingEnabled = false;
+    this.logger = createLogger(`mcpc.agentic.${name}`, server2);
+    try {
+      this.tracingEnabled = process4.env.MCPC_TRACING_ENABLED === "true";
+      if (this.tracingEnabled) {
+        initializeTracing({
+          enabled: true,
+          serviceName: `mcpc-agentic-${name}`,
+          exportTo: process4.env.MCPC_TRACING_EXPORT ?? "otlp",
+          otlpEndpoint: process4.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
         });
       }
-      return currentResult;
+    } catch {
+      this.tracingEnabled = false;
     }
-    if (this.allToolNames.includes(actionName)) {
-      try {
-        const result = await this.server.callTool(actionName, args[actionName]);
-        const nextAction = args[this.NEXT_ACTION_KEY];
-        const callToolResult = result ?? {
-          content: []
-        };
-        if (nextAction && this.allToolNames.includes(nextAction)) {
-          callToolResult.content.push({
-            type: "text",
-            text: CompiledPrompts.actionSuccess({
-              toolName: this.name,
-              nextAction,
-              currentAction: actionName
-            })
-          });
-        } else {
-          callToolResult.content.push({
-            type: "text",
-            text: CompiledPrompts.planningPrompt({
-              currentAction: actionName
-            })
+  }
+  async execute(args, schema) {
+    const executeSpan = this.tracingEnabled ? startSpan("mcpc.agentic_execute", {
+      agent: this.name,
+      action: String(args[this.ACTION_KEY] ?? "unknown"),
+      nextAction: String(args[this.NEXT_ACTION_KEY] ?? "none"),
+      args: JSON.stringify(args)
+    }) : null;
+    try {
+      const validationResult = this.validate(args, schema);
+      if (!validationResult.valid) {
+        if (executeSpan) {
+          executeSpan.setAttributes({
+            validationError: true,
+            errorMessage: validationResult.error || "Validation failed"
           });
+          endSpan(executeSpan);
         }
-        return callToolResult;
-      } catch (error) {
+        this.logger.warning({
+          message: "Validation failed",
+          action: args[this.ACTION_KEY],
+          error: validationResult.error
+        });
         return {
           content: [
             {
               type: "text",
-              text: `Error executing internal tool ${actionName}: ${error instanceof Error ? error.message : String(error)}`
+              text: CompiledPrompts.errorResponse({
+                errorMessage: validationResult.error || "Validation failed"
+              })
             }
           ],
           isError: true
         };
       }
-    }
-    return {
-      content: [
-        {
-          type: "text",
-          text: CompiledPrompts.completionMessage()
+      const actionName = args[this.ACTION_KEY];
+      if (executeSpan && actionName) {
+        try {
+          const safeAction = String(actionName).replace(/\s+/g, "_");
+          if (typeof executeSpan.updateName === "function") {
+            executeSpan.updateName(`mcpc.agentic_execute.${safeAction}`);
+          }
+        } catch {
         }
-      ]
-    };
+      }
+      const currentTool = this.toolNameToDetailList.find(([name, _detail]) => name === actionName)?.[1];
+      if (currentTool) {
+        const nextAction = args[this.NEXT_ACTION_KEY];
+        if (executeSpan) {
+          executeSpan.setAttributes({
+            toolType: "external",
+            actionName,
+            nextAction: nextAction || "none"
+          });
+        }
+        this.logger.debug({
+          message: "Executing external tool",
+          action: actionName,
+          nextAction
+        });
+        const currentResult = await currentTool.execute({
+          ...args[actionName]
+        });
+        if (args[nextAction]) {
+          currentResult?.content?.push({
+            type: "text",
+            text: CompiledPrompts.actionSuccess({
+              toolName: this.name,
+              nextAction,
+              currentAction: actionName
+            })
+          });
+        } else {
+          currentResult?.content?.push({
+            type: "text",
+            text: CompiledPrompts.planningPrompt({
+              currentAction: actionName
+            })
+          });
+        }
+        if (executeSpan) {
+          executeSpan.setAttributes({
+            success: true,
+            isError: !!currentResult.isError,
+            resultContentLength: currentResult.content?.length || 0,
+            hasNextAction: !!args[nextAction],
+            toolResult: JSON.stringify(currentResult)
+          });
+          endSpan(executeSpan);
+        }
+        return currentResult;
+      }
+      if (this.allToolNames.includes(actionName)) {
+        if (executeSpan) {
+          executeSpan.setAttributes({
+            toolType: "internal",
+            actionName
+          });
+        }
+        this.logger.debug({
+          message: "Executing internal tool",
+          action: actionName
+        });
+        try {
+          const result = await this.server.callTool(actionName, args[actionName]);
+          const nextAction = args[this.NEXT_ACTION_KEY];
+          const callToolResult = result ?? {
+            content: []
+          };
+          if (nextAction && this.allToolNames.includes(nextAction)) {
+            callToolResult.content.push({
+              type: "text",
+              text: CompiledPrompts.actionSuccess({
+                toolName: this.name,
+                nextAction,
+                currentAction: actionName
+              })
+            });
+          } else {
+            callToolResult.content.push({
+              type: "text",
+              text: CompiledPrompts.planningPrompt({
+                currentAction: actionName
+              })
+            });
+          }
+          if (executeSpan) {
+            executeSpan.setAttributes({
+              success: true,
+              isError: !!callToolResult.isError,
+              resultContentLength: callToolResult.content?.length || 0,
+              hasNextAction: !!(nextAction && this.allToolNames.includes(nextAction)),
+              toolResult: JSON.stringify(callToolResult)
+            });
+            endSpan(executeSpan);
+          }
+          return callToolResult;
+        } catch (error) {
+          if (executeSpan) {
+            endSpan(executeSpan, error);
+          }
+          this.logger.error({
+            message: "Error executing internal tool",
+            action: actionName,
+            error: String(error)
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error executing internal tool ${actionName}: ${error instanceof Error ? error.message : String(error)}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+      if (executeSpan) {
+        executeSpan.setAttributes({
+          toolType: "not_found",
+          actionName: actionName || "unknown",
+          completion: true
+        });
+        endSpan(executeSpan);
+      }
+      this.logger.debug({
+        message: "Tool not found, returning completion message",
+        action: actionName
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: CompiledPrompts.completionMessage()
+          }
+        ]
+      };
+    } catch (error) {
+      if (executeSpan) {
+        endSpan(executeSpan, error);
+      }
+      this.logger.error({
+        message: "Unexpected error in execute",
+        error: String(error)
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Unexpected error: ${error instanceof Error ? error.message : String(error)}`
+          }
+        ],
+        isError: true
+      };
+    }
   }
   // Validate arguments using JSON schema
   validate(args, schema) {
@@ -1016,7 +1640,7 @@ var AgenticExecutor = class {
   }
 };
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/es-toolkit__es-toolkit/src/function/partial.js
+// ../__mcpc__cli_latest/node_modules/@jsr/es-toolkit__es-toolkit/src/function/partial.js
 function partial(func, ...partialArgs) {
   return partialImpl(func, placeholderSymbol, ...partialArgs);
 }
@@ -1035,7 +1659,7 @@ function partialImpl(func, placeholder, ...partialArgs) {
 var placeholderSymbol = Symbol("partial.placeholder");
 partial.placeholder = placeholderSymbol;
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/es-toolkit__es-toolkit/src/function/partialRight.js
+// ../__mcpc__cli_latest/node_modules/@jsr/es-toolkit__es-toolkit/src/function/partialRight.js
 function partialRight(func, ...partialArgs) {
   return partialRightImpl(func, placeholderSymbol2, ...partialArgs);
 }
@@ -1056,10 +1680,10 @@ function partialRightImpl(func, placeholder, ...partialArgs) {
 var placeholderSymbol2 = Symbol("partialRight.placeholder");
 partialRight.placeholder = placeholderSymbol2;
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/es-toolkit__es-toolkit/src/function/retry.js
+// ../__mcpc__cli_latest/node_modules/@jsr/es-toolkit__es-toolkit/src/function/retry.js
 var DEFAULT_RETRIES = Number.POSITIVE_INFINITY;
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/es-toolkit__es-toolkit/src/object/pick.js
+// ../__mcpc__cli_latest/node_modules/@jsr/es-toolkit__es-toolkit/src/object/pick.js
 function pick(obj, keys) {
   const result = {};
   for (let i = 0; i < keys.length; i++) {
@@ -1071,7 +1695,7 @@ function pick(obj, keys) {
   return result;
 }
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/es-toolkit__es-toolkit/src/string/deburr.js
+// ../__mcpc__cli_latest/node_modules/@jsr/es-toolkit__es-toolkit/src/string/deburr.js
 var deburrMap = new Map(
   // eslint-disable-next-line no-restricted-syntax
   Object.entries({
@@ -1107,7 +1731,7 @@ var deburrMap = new Map(
   })
 );
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/factories/args-def-factory.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/factories/args-def-factory.js
 var DECISION_OPTIONS = {
   RETRY: "retry",
   PROCEED: "proceed",
@@ -1234,10 +1858,16 @@ Workflow step definitions - provide ONLY on initial call.
           userRequest: {
             type: "string",
             description: "The task or request that should be completed autonomously by the agentic system using available tools"
+          },
+          context: {
+            type: "object",
+            description: "Necessary context for the request, e.g., the absolute path of the current working directory. This is just an example; any relevant context fields are allowed.",
+            additionalProperties: true
           }
         },
         required: [
-          "userRequest"
+          "userRequest",
+          "context"
         ]
       };
     },
@@ -1332,11 +1962,12 @@ NOTE: The \`steps\` has been predefined` : `**You MUST execute this tool with fo
   };
 }
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/sampling/base-sampling-executor.js
+// ../__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";
-import { inspect as inspect2 } from "node:util";
+init_logger();
+import process5 from "node:process";
 var ajv2 = new Ajv2({
   allErrors: true,
   verbose: true
@@ -1351,6 +1982,9 @@ var BaseSamplingExecutor = class {
   conversationHistory;
   maxIterations;
   currentIteration;
+  logger;
+  tracingEnabled;
+  summarize;
   constructor(name, description, allToolNames, toolNameToDetailList, server2, config2) {
     this.name = name;
     this.description = description;
@@ -1358,57 +1992,158 @@ var BaseSamplingExecutor = class {
     this.toolNameToDetailList = toolNameToDetailList;
     this.server = server2;
     this.conversationHistory = [];
-    this.maxIterations = 33;
+    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;
+    }
   }
   async runSamplingLoop(systemPrompt, schema, state) {
-    this.conversationHistory = [];
+    this.conversationHistory = [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: 'Return ONLY raw JSON (no code fences or explanations). The JSON MUST include action and decision. Example: {"action":"<tool>","decision":"proceed|complete","<tool>":{}}'
+        }
+      }
+    ];
+    const loopSpan = this.tracingEnabled ? startSpan("mcpc.sampling_loop", {
+      agent: this.name,
+      maxIterations: this.maxIterations,
+      systemPrompt: systemPrompt()
+    }) : null;
     try {
       for (this.currentIteration = 0; this.currentIteration < this.maxIterations; this.currentIteration++) {
-        const response = await this.server.createMessage({
-          systemPrompt: systemPrompt(),
-          messages: this.conversationHistory,
-          maxTokens: Number.MAX_SAFE_INTEGER
-        });
-        const responseContent = response.content.text || "{}";
-        let parsedData;
+        let iterationSpan = null;
         try {
-          parsedData = parseJSON(responseContent.trim(), true);
-        } catch (parseError) {
-          this.addParsingErrorToHistory(responseContent, parseError);
-          continue;
-        }
-        if (parsedData) {
-          this.conversationHistory.push({
-            role: "assistant",
-            content: {
-              type: "text",
-              text: JSON.stringify(parsedData, null, 2)
-            }
+          const response = await this.server.createMessage({
+            systemPrompt: systemPrompt(),
+            messages: this.conversationHistory,
+            maxTokens: 55e3
           });
-        }
-        const result = await this.processAction(parsedData, schema, state);
-        this.logIterationProgress(parsedData, result);
-        if (result.isError) {
-          this.conversationHistory.push({
-            role: "user",
-            content: {
-              type: "text",
-              text: result.content[0].text
+          const responseContent = response.content.text || "{}";
+          const model = response.model;
+          const stopReason = response.stopReason;
+          const role = response.role;
+          let parsedData;
+          try {
+            parsedData = parseJSON(responseContent.trim(), true);
+          } catch (parseError) {
+            iterationSpan = this.tracingEnabled ? startSpan("mcpc.sampling_iteration.parse_error", {
+              iteration: this.currentIteration + 1,
+              agent: this.name,
+              error: String(parseError),
+              maxIterations: this.maxIterations
+            }, loopSpan ?? void 0) : null;
+            this.addParsingErrorToHistory(responseContent, parseError);
+            if (iterationSpan) endSpan(iterationSpan);
+            continue;
+          }
+          if (parsedData) {
+            this.conversationHistory.push({
+              role: "assistant",
+              content: {
+                type: "text",
+                text: JSON.stringify(parsedData, null, 2)
+              }
+            });
+          }
+          const action = parsedData["action"];
+          const actionStr = action && typeof action === "string" ? String(action) : "unknown_action";
+          const spanName = `mcpc.sampling_iteration.${actionStr}`;
+          iterationSpan = this.tracingEnabled ? startSpan(spanName, {
+            iteration: this.currentIteration + 1,
+            agent: this.name,
+            action: actionStr,
+            systemPrompt: systemPrompt(),
+            maxTokens: String(Number.MAX_SAFE_INTEGER),
+            maxIterations: this.maxIterations,
+            messages: JSON.stringify(this.conversationHistory)
+          }, loopSpan ?? void 0) : null;
+          if (!action || typeof parsedData["decision"] !== "string") {
+            this.conversationHistory.push({
+              role: "user",
+              content: {
+                type: "text",
+                text: 'Required fields missing: action or decision. Return ONLY raw JSON, no code fences or explanations. Example: {"action":"<tool>","decision":"proceed|complete","<tool>":{}}'
+              }
+            });
+            if (iterationSpan) endSpan(iterationSpan);
+            continue;
+          }
+          const result = await this.processAction(parsedData, schema, state, loopSpan);
+          this.logIterationProgress(parsedData, result, model, stopReason, role);
+          if (iterationSpan) {
+            let rawJson = "{}";
+            try {
+              rawJson = parsedData ? JSON.stringify(parsedData) : "{}";
+            } catch {
             }
-          });
-          continue;
-        }
-        if (result.isComplete) {
-          return result;
+            const attr = {
+              isError: !!result.isError,
+              isComplete: !!result.isComplete,
+              iteration: this.currentIteration + 1,
+              maxIterations: this.maxIterations,
+              parsed: rawJson,
+              action: typeof action === "string" ? action : String(action),
+              samplingResponse: responseContent,
+              toolResult: JSON.stringify(result),
+              model,
+              role
+            };
+            if (stopReason) {
+              attr.stopReason = stopReason;
+            }
+            iterationSpan.setAttributes(attr);
+          }
+          if (result.isError) {
+            this.conversationHistory.push({
+              role: "user",
+              content: {
+                type: "text",
+                text: result.content[0].text
+              }
+            });
+            if (iterationSpan) endSpan(iterationSpan);
+            continue;
+          }
+          if (result.isComplete) {
+            if (iterationSpan) endSpan(iterationSpan);
+            if (loopSpan) endSpan(loopSpan);
+            return result;
+          }
+          if (iterationSpan) endSpan(iterationSpan);
+        } catch (iterError) {
+          if (iterationSpan) endSpan(iterationSpan, iterError);
+          throw iterError;
         }
       }
-      return this.createMaxIterationsError();
+      if (loopSpan) endSpan(loopSpan);
+      return await this.createMaxIterationsError(loopSpan);
     } catch (error) {
-      return this.createExecutionError(error);
+      if (loopSpan) endSpan(loopSpan, error);
+      return await this.createExecutionError(error, loopSpan);
     }
   }
   addParsingErrorToHistory(responseText, parseError) {
@@ -1431,71 +2166,137 @@ Please respond with valid JSON.`
       }
     });
   }
-  createMaxIterationsError() {
-    const result = this.createCompletionResult(`Action argument validation failed: Execution reached maximum iterations (${this.maxIterations}). Please try with a more specific request or break down the task into smaller parts.`);
-    return {
-      ...result,
-      isError: true,
-      isComplete: false
-    };
+  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;
   }
-  createExecutionError(error) {
-    const errorMessage = `Sampling execution error: ${error instanceof Error ? error.message : String(error)}`;
-    const result = this.createCompletionResult(errorMessage);
-    return {
-      ...result,
-      isError: true,
-      isComplete: false
-    };
+  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;
   }
-  createCompletionResult(text) {
-    const conversationDetails = this.getConversationDetails();
+  async createCompletionResult(text, parentSpan) {
+    const summary = this.summarize ? await this.summarizeConversation(parentSpan) : this.formatConversation();
     return {
       content: [
         {
           type: "text",
-          text: `Task Completed
-${text}
+          text: `${text}
+
 **Execution Summary:**
 - Iterations used: ${this.currentIteration + 1}/${this.maxIterations}
-- Agent: ${this.name}${conversationDetails}`
+- Agent: ${this.name}
+${summary}`
         }
       ],
       isError: false,
       isComplete: true
     };
   }
-  getConversationDetails() {
+  // Use LLM to create high-signal summary for parent agent
+  async summarizeConversation(parentSpan) {
     if (this.conversationHistory.length === 0) {
-      return "\n\n**No conversation history available**";
+      return "\n\n**No conversation history**";
     }
-    let details = "\n\n**Detailed Conversation History:**";
-    this.conversationHistory.forEach((message) => {
-      if (message.role === "assistant") {
-        try {
-          const parsed = JSON.parse(message.content.text);
-          details += "\n```json\n" + JSON.stringify(parsed, null, 2) + "\n```";
-        } catch {
-          details += "\n```\n" + message.content.text + "\n```";
+    if (this.conversationHistory.length <= 3) {
+      return this.formatConversation();
+    }
+    const summarizeSpan = this.tracingEnabled ? startSpan("mcpc.sampling_summarize", {
+      agent: this.name,
+      messageCount: this.conversationHistory.length
+    }, parentSpan ?? void 0) : null;
+    try {
+      this.logger.debug({
+        message: "Starting conversation summarization",
+        messageCount: this.conversationHistory.length
+      });
+      const history = this.conversationHistory.map((msg, i) => {
+        const prefix = `[${i + 1}] ${msg.role.toUpperCase()}`;
+        return `${prefix}:
+${msg.content.text}`;
+      }).join("\n\n---\n\n");
+      const response = await this.server.createMessage({
+        systemPrompt: `Summarize this agent execution:
+
+Final Decision: (include complete JSON if present)
+Key Findings: (most important)
+Actions Taken: (high-level flow)
+Errors/Warnings: (if any)
+
+${history}`,
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: "Please provide a concise summary."
+            }
+          }
+        ],
+        maxTokens: 3e3
+      });
+      const summary = "\n\n" + response.content.text;
+      this.logger.debug({
+        message: "Summarization completed",
+        summaryLength: summary.length
+      });
+      if (summarizeSpan) {
+        summarizeSpan.setAttributes({
+          summaryLength: summary.length,
+          summary,
+          success: true
+        });
+        endSpan(summarizeSpan);
+      }
+      return summary;
+    } catch (error) {
+      this.logger.warning({
+        message: "Summarization failed, falling back to full history",
+        error: String(error)
+      });
+      if (summarizeSpan) {
+        endSpan(summarizeSpan, error);
+      }
+      return this.formatConversation();
+    }
+  }
+  // Format full conversation history (for debugging)
+  formatConversation() {
+    if (this.conversationHistory.length === 0) {
+      return "\n\n**No conversation history**";
+    }
+    const messages = this.conversationHistory.map((msg, i) => {
+      const header = `### Message ${i + 1}: ${msg.role}`;
+      try {
+        const parsed = JSON.parse(msg.content.text);
+        if (JSON.stringify(parsed).length < 100) {
+          return `${header}
+${JSON.stringify(parsed)}`;
         }
-      } else {
-        details += "\n```\n" + message.content.text + "\n```";
+        return `${header}
+\`\`\`json
+${JSON.stringify(parsed, null, 2)}
+\`\`\``;
+      } catch {
+        return `${header}
+${msg.content.text}`;
       }
     });
-    return details;
+    return "\n\n**Conversation History:**\n" + messages.join("\n\n");
   }
-  logIterationProgress(parsedData, result) {
-    console.log(`Iteration ${this.currentIteration + 1}/${this.maxIterations}:`, {
+  logIterationProgress(parsedData, result, model, stopReason, role) {
+    this.logger.debug({
+      iteration: `${this.currentIteration + 1}/${this.maxIterations}`,
       parsedData,
       isError: result.isError,
       isComplete: result.isComplete,
-      result: inspect2(result, {
-        depth: 5,
-        maxArrayLength: 10,
-        breakLength: 120,
-        compact: true,
-        maxStringLength: 120
-      })
+      model,
+      stopReason,
+      role,
+      result
     });
   }
   injectJsonInstruction({ prompt, schema, schemaPrefix = "JSON schema:", schemaSuffix = `STRICT REQUIREMENTS:
@@ -1529,7 +2330,7 @@ VALID: {"key":"value"}` }) {
   }
 };
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/sampling/agentic-sampling-executor.js
+// ../__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) {
@@ -1546,7 +2347,7 @@ var SamplingExecutor = class extends BaseSamplingExecutor {
           ...tool.inputSchema
         };
       } else {
-        const toolSchema = this.server.getInternalToolSchema(toolName);
+        const toolSchema = this.server.getHiddenToolSchema(toolName);
         if (toolSchema) {
           depGroups[toolName] = {
             ...toolSchema.schema,
@@ -1574,13 +2375,13 @@ var SamplingExecutor = class extends BaseSamplingExecutor {
     }
     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);
+    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) {
+  async processAction(parsedData, schema, _state, parentSpan) {
     const toolCallData = parsedData;
     if (toolCallData.decision === "complete") {
-      return this.createCompletionResult("Task completed");
+      return await this.createCompletionResult("Task completed", parentSpan);
     }
     try {
       const { action: _action, decision: _decision, ..._toolArgs } = toolCallData;
@@ -1595,13 +2396,13 @@ var SamplingExecutor = class extends BaseSamplingExecutor {
       });
       return toolResult;
     } catch (error) {
-      return this.createExecutionError(error);
+      return this.createExecutionError(error, parentSpan);
     }
   }
-  buildSystemPrompt(userRequest, agenticSchema) {
+  buildSystemPrompt(userRequest, agenticSchema, context2) {
     const toolList = this.allToolNames.map((name) => {
       const tool = this.toolNameToDetailList.find(([toolName]) => toolName === name);
-      const toolSchema = this.server.getInternalToolSchema(name);
+      const toolSchema = this.server.getHiddenToolSchema(name);
       if (tool && tool[1]) {
         return `- ${name}: ${tool[1].description || `Tool: ${name}`}`;
       } else if (toolSchema) {
@@ -1609,6 +2410,13 @@ var SamplingExecutor = class extends BaseSamplingExecutor {
       }
       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,
@@ -1617,7 +2425,7 @@ var SamplingExecutor = class extends BaseSamplingExecutor {
     const taskPrompt = `
 
 ## Current Task
-I will now use agentic sampling to complete the following task: "${userRequest}"
+I will now use agentic sampling to complete the following task: "${userRequest}"${contextInfo}
 
 When I need to use a tool, I should specify the tool name in 'action' and provide tool-specific parameters as additional properties.
 When the task is complete, I should use "action": "complete".`;
@@ -1628,7 +2436,7 @@ When the task is complete, I should use "action": "complete".`;
   }
 };
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-tool-registrar.js
+// ../__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";
@@ -1658,10 +2466,10 @@ function registerAgenticTool(server2, { description, name, allToolNames, depGrou
   });
 }
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-tool-registrar.js
-import { jsonSchema as jsonSchema2 } from "ai";
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-tool-registrar.js
+init_schema();
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/utils/state.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/state.js
 var WorkflowState = class {
   currentStepIndex = -1;
   steps = [];
@@ -1830,7 +2638,7 @@ var WorkflowState = class {
   }
 };
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-executor.js
+// ../__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";
@@ -2157,7 +2965,7 @@ ${this.formatProgress(state)}`
   }
 };
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/sampling/workflow-sampling-executor.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/sampling/workflow-sampling-executor.js
 var WorkflowSamplingExecutor = class extends BaseSamplingExecutor {
   createArgsDef;
   predefinedSteps;
@@ -2183,14 +2991,14 @@ var WorkflowSamplingExecutor = class extends BaseSamplingExecutor {
     }
     return await this.runSamplingLoop(() => this.buildWorkflowSystemPrompt(args, state), schema, state);
   }
-  async processAction(parsedData, _schema, state) {
+  async processAction(parsedData, _schema, state, parentSpan) {
     const workflowState = state;
     if (!workflowState) {
       throw new Error("WorkflowState is required for workflow");
     }
     const toolCallData = parsedData;
     if (toolCallData.decision === "complete") {
-      return this.createCompletionResult("Task completed");
+      return await this.createCompletionResult("Task completed", parentSpan);
     }
     try {
       const workflowResult = await this.workflowExecutor.execute(parsedData, workflowState);
@@ -2204,7 +3012,7 @@ var WorkflowSamplingExecutor = class extends BaseSamplingExecutor {
       });
       return workflowResult;
     } catch (error) {
-      return this.createExecutionError(error);
+      return this.createExecutionError(error, parentSpan);
     }
   }
   buildWorkflowSystemPrompt(args, state) {
@@ -2214,9 +3022,16 @@ var WorkflowSamplingExecutor = class extends BaseSamplingExecutor {
       description: this.description,
       workflowSchema: `${JSON.stringify(workflowSchema, null, 2)}`
     });
+    let contextInfo = "";
+    if (args.context && typeof args.context === "object" && Object.keys(args.context).length > 0) {
+      contextInfo = `
+
+Context:
+${JSON.stringify(args.context, null, 2)}`;
+    }
     const workflowPrompt = `
 
-Current Task: <user_request>${args.userRequest}</user_request>`;
+Current Task: <user_request>${args.userRequest}</user_request>${contextInfo}`;
     return this.injectJsonInstruction({
       prompt: basePrompt + workflowPrompt,
       schema: workflowSchema
@@ -2224,7 +3039,7 @@ Current Task: <user_request>${args.userRequest}</user_request>`;
   }
 };
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-tool-registrar.js
+// ../__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 }) {
   const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, predefinedSteps, ensureStepActions);
   const isSamplingMode = sampling === true || typeof sampling === "object";
@@ -2244,7 +3059,7 @@ function registerAgenticWorkflowTool(server2, { description, name, allToolNames,
   });
   const argsDef = isSamplingMode ? createArgsDef.forSampling() : createArgsDef.forTool();
   const toolDescription = isSamplingMode ? baseDescription : createArgsDef.forToolDescription(baseDescription, workflowState);
-  server2.tool(name, toolDescription, jsonSchema2(createGoogleCompatibleJSONSchema(argsDef)), async (args) => {
+  server2.tool(name, toolDescription, jsonSchema(createGoogleCompatibleJSONSchema(argsDef)), async (args) => {
     try {
       if (isSamplingMode) {
         return await workflowSamplingExecutor.executeWorkflowSampling(args, argsDef, workflowState);
@@ -2266,7 +3081,7 @@ function registerAgenticWorkflowTool(server2, { description, name, allToolNames,
   });
 }
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/utils/common/tool-tag-processor.js
+// ../__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);
@@ -2286,9 +3101,9 @@ function processToolTags({ description, tagToResults, $, tools, toolOverrides, t
       return;
     }
     const override = toolOverrides.get(toolName);
-    if (override?.visibility?.hide) {
+    if (override?.visibility?.hidden) {
       $(toolEl).remove();
-    } else if (override?.visibility?.global) {
+    } else if (override?.visibility?.public) {
       $(toolEl).replaceWith(`<tool name="${toolName}"/>`);
     } else {
       const toolId = findToolId(toolName, tools, toolNameMapping);
@@ -2300,168 +3115,308 @@ function processToolTags({ description, tagToResults, $, tools, toolOverrides, t
   return $.root().html() ?? description;
 }
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/compose.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/compose.js
 init_built_in();
+init_logger();
+init_plugin_utils();
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/plugin-utils.js
-function shouldApplyPlugin(plugin, mode) {
-  if (!plugin.apply) return true;
-  if (typeof plugin.apply === "string") {
-    return mode.includes(plugin.apply);
-  }
-  if (typeof plugin.apply === "function") {
-    return plugin.apply(mode);
-  }
-  return plugin.apply;
-}
-function isValidPlugin(plugin) {
-  return plugin && plugin.name && (plugin.configureServer || plugin.composeStart || plugin.transformTool || plugin.finalizeComposition || plugin.composeEnd);
-}
-async function loadPlugin(pluginPath) {
-  try {
-    const [rawPath, queryString] = pluginPath.split("?", 2);
-    const searchParams = new URLSearchParams(queryString || "");
-    const params = Object.fromEntries(searchParams.entries());
-    const pluginModule = await import(rawPath);
-    const pluginFactory = pluginModule.createPlugin;
-    const defaultPlugin = pluginModule.default;
-    let plugin;
-    if (Object.keys(params).length > 0) {
-      if (typeof pluginFactory === "function") {
-        const typedParams = {};
-        for (const [key, value] of Object.entries(params)) {
-          const numValue = Number(value);
-          if (!isNaN(numValue)) {
-            typedParams[key] = numValue;
-          } else if (value === "true") {
-            typedParams[key] = true;
-          } else if (value === "false") {
-            typedParams[key] = false;
-          } else {
-            typedParams[key] = value;
-          }
-        }
-        plugin = pluginFactory(typedParams);
-      } else {
-        throw new Error(`Plugin ${rawPath} has parameters but no createPlugin export`);
-      }
-    } else {
-      plugin = defaultPlugin;
-    }
-    if (isValidPlugin(plugin)) {
-      return plugin;
-    } else {
-      throw new Error(`Invalid plugin format in ${rawPath} - plugin must have a name and at least one lifecycle hook`);
-    }
-  } catch (error) {
-    throw new Error(`Failed to load plugin from ${pluginPath}: ${error}`);
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/plugin-manager.js
+init_plugin_utils();
+init_logger();
+var PluginManager = class {
+  server;
+  plugins;
+  logger;
+  constructor(server2) {
+    this.server = server2;
+    this.plugins = [];
+    this.logger = createLogger("mcpc.plugin-manager");
+    this.logger.setServer(server2);
   }
-}
-
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/compose.js
-var ALL_TOOLS_PLACEHOLDER2 = "__ALL__";
-var ComposableMCPServer = class extends Server {
-  tools = [];
-  toolRegistry = /* @__PURE__ */ new Map();
-  toolConfigs = /* @__PURE__ */ new Map();
-  globalPlugins = [];
-  toolNameMapping = /* @__PURE__ */ new Map();
-  constructor(_serverInfo, options) {
-    super(_serverInfo, options);
+  /**
+   * Get all registered plugins
+   */
+  getPlugins() {
+    return [
+      ...this.plugins
+    ];
   }
   /**
-   * Initialize built-in plugins - called during setup
+   * Get plugin names
    */
-  async initBuiltInPlugins() {
-    const builtInPlugins = getBuiltInPlugins();
-    for (const plugin of builtInPlugins) {
-      await this.addPlugin(plugin);
-    }
+  getPluginNames() {
+    return this.plugins.map((p2) => p2.name);
   }
   /**
-   * Apply plugin transformations to tool arguments/results
-   * TODO: Implement transformResult lifecycle hooks
+   * Check if a plugin is registered
    */
-  applyPluginTransforms(_toolName, args, _mode, _originalArgs) {
-    return args;
+  hasPlugin(name) {
+    return this.plugins.some((p2) => p2.name === name);
   }
   /**
-   * Resolve a tool name to its internal format
+   * Add a plugin with validation and error handling
    */
-  resolveToolName(name) {
-    if (this.toolRegistry.has(name)) {
-      return name;
+  async addPlugin(plugin) {
+    const validation = validatePlugins([
+      plugin
+    ]);
+    if (!validation.valid) {
+      const errorMsg = validation.errors.join(", ");
+      throw new Error(`Invalid plugin "${plugin.name}": ${errorMsg}`);
     }
-    const mappedName = this.toolNameMapping.get(name);
-    if (mappedName && this.toolRegistry.has(mappedName)) {
-      return mappedName;
+    if (this.plugins.some((p2) => p2.name === plugin.name)) {
+      await this.logger.warning(`Plugin "${plugin.name}" already registered, skipping`);
+      return;
     }
-    if (this.toolConfigs.has(name)) {
-      const cfgMapped = this.toolNameMapping.get(name);
-      if (cfgMapped && this.toolRegistry.has(cfgMapped)) {
-        return cfgMapped;
+    if (plugin.dependencies) {
+      const missingDeps = plugin.dependencies.filter((dep) => !this.plugins.some((p2) => p2.name === dep));
+      if (missingDeps.length > 0) {
+        throw new Error(`Plugin "${plugin.name}" has missing dependencies: ${missingDeps.join(", ")}`);
+      }
+    }
+    this.plugins.push(plugin);
+    if (plugin.configureServer) {
+      try {
+        await plugin.configureServer(this.server);
+      } catch (error) {
+        this.plugins = this.plugins.filter((p2) => p2.name !== plugin.name);
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        throw new Error(`Plugin "${plugin.name}" configuration failed: ${errorMsg}`);
       }
     }
-    return void 0;
   }
-  tool(name, description, paramsSchema, cb, options = {}) {
-    this.toolRegistry.set(name, {
-      callback: cb,
-      description,
-      schema: paramsSchema.jsonSchema
-    });
-    if (options.plugins) {
-      for (const plugin of options.plugins) {
-        this.globalPlugins.push(plugin);
+  /**
+   * Load and register a plugin from a file path
+   */
+  async loadPluginFromPath(pluginPath, options = {
+    cache: true
+  }) {
+    const plugin = await loadPlugin(pluginPath, options);
+    await this.addPlugin(plugin);
+  }
+  /**
+   * Trigger composeStart hooks for all applicable plugins
+   */
+  async triggerComposeStart(context2) {
+    const startPlugins = this.plugins.filter((p2) => p2.composeStart && shouldApplyPlugin(p2, context2.mode));
+    const sortedPlugins = sortPluginsByOrder(startPlugins);
+    for (const plugin of sortedPlugins) {
+      if (plugin.composeStart) {
+        try {
+          await plugin.composeStart(context2);
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          await this.logger.error(`Plugin "${plugin.name}" composeStart failed: ${errorMsg}`);
+        }
       }
     }
-    if (options.internal) {
-      this.toolConfigs.set(name, {
-        visibility: {
-          internal: true
+  }
+  /**
+   * Apply transformTool hooks to a tool during composition
+   */
+  async applyTransformToolHooks(tool, context2) {
+    const transformPlugins = this.plugins.filter((p2) => p2.transformTool && shouldApplyPlugin(p2, context2.mode));
+    if (transformPlugins.length === 0) {
+      return tool;
+    }
+    const sortedPlugins = sortPluginsByOrder(transformPlugins);
+    let currentTool = tool;
+    for (const plugin of sortedPlugins) {
+      if (plugin.transformTool) {
+        try {
+          const result = await plugin.transformTool(currentTool, context2);
+          if (result) {
+            currentTool = result;
+          }
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          await this.logger.error(`Plugin "${plugin.name}" transformTool failed for "${context2.toolName}": ${errorMsg}`);
         }
-      });
-    } else {
-      const existingTool = this.tools.find((t) => t.name === name);
-      if (!existingTool) {
-        const newTool = {
-          name,
-          description,
-          inputSchema: paramsSchema.jsonSchema
-        };
-        this.tools = [
-          ...this.tools,
-          newTool
-        ];
       }
     }
-    this.setRequestHandler(ListToolsRequestSchema, () => {
-      return {
-        tools: this.tools
-      };
-    });
-    this.setRequestHandler(CallToolRequestSchema, (request, extra) => {
-      const { name: toolName, arguments: args } = request.params;
-      const handler = this.getToolCallback(toolName);
-      if (!handler) {
-        throw new Error(`Tool ${toolName} not found`);
+    return currentTool;
+  }
+  /**
+   * Trigger finalizeComposition hooks for all applicable plugins
+   */
+  async triggerFinalizeComposition(tools, context2) {
+    const finalizePlugins = this.plugins.filter((p2) => p2.finalizeComposition && shouldApplyPlugin(p2, context2.mode));
+    const sortedPlugins = sortPluginsByOrder(finalizePlugins);
+    for (const plugin of sortedPlugins) {
+      if (plugin.finalizeComposition) {
+        try {
+          await plugin.finalizeComposition(tools, context2);
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          await this.logger.error(`Plugin "${plugin.name}" finalizeComposition failed: ${errorMsg}`);
+        }
+      }
+    }
+  }
+  /**
+   * Trigger composeEnd hooks for all applicable plugins
+   */
+  async triggerComposeEnd(context2) {
+    const endPlugins = this.plugins.filter((p2) => p2.composeEnd && shouldApplyPlugin(p2, context2.mode));
+    const sortedPlugins = sortPluginsByOrder(endPlugins);
+    for (const plugin of sortedPlugins) {
+      if (plugin.composeEnd) {
+        try {
+          await plugin.composeEnd(context2);
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          await this.logger.error(`Plugin "${plugin.name}" composeEnd failed: ${errorMsg}`);
+        }
       }
-      const processedArgs = this.applyPluginTransforms(toolName, args, "input");
-      const result = handler(processedArgs, extra);
-      return this.applyPluginTransforms(toolName, result, "output", args);
+    }
+  }
+  /**
+   * Dispose all plugins and cleanup resources
+   */
+  async dispose() {
+    for (const plugin of this.plugins) {
+      if (plugin.dispose) {
+        try {
+          await plugin.dispose();
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          await this.logger.error(`Plugin "${plugin.name}" dispose failed: ${errorMsg}`);
+        }
+      }
+    }
+    this.plugins = [];
+  }
+};
+
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/tool-manager.js
+var ToolManager = class {
+  toolRegistry = /* @__PURE__ */ new Map();
+  toolConfigs = /* @__PURE__ */ new Map();
+  toolNameMapping = /* @__PURE__ */ new Map();
+  publicTools = [];
+  /**
+   * Get tool name mapping (for external access)
+   */
+  getToolNameMapping() {
+    return this.toolNameMapping;
+  }
+  /**
+   * Register a tool in the registry
+   */
+  registerTool(name, description, schema, callback, options = {}) {
+    this.toolRegistry.set(name, {
+      callback,
+      description,
+      schema
     });
+    if (options.internal) {
+      this.toolConfigs.set(name, {
+        visibility: {
+          hidden: true
+        }
+      });
+    }
+  }
+  /**
+   * Explicitly mark a tool as public (exposed to MCP clients)
+   */
+  addPublicTool(name, description, schema) {
+    const existingTool = this.publicTools.find((t) => t.name === name);
+    if (!existingTool) {
+      this.publicTools.push({
+        name,
+        description,
+        inputSchema: schema
+      });
+    }
+  }
+  /**
+   * Check if a tool is public (exposed to MCP clients)
+   */
+  isPublic(name) {
+    const config2 = this.toolConfigs.get(name);
+    return config2?.visibility?.public === true;
+  }
+  /**
+   * Check if a tool is hidden from agent context
+   */
+  isHidden(name) {
+    const config2 = this.toolConfigs.get(name);
+    return config2?.visibility?.hidden === true;
+  }
+  /**
+   * Get all public tool names (exposed to MCP clients)
+   */
+  getPublicToolNames() {
+    return Array.from(this.toolConfigs.entries()).filter(([_name, config2]) => config2.visibility?.public === true).map(([name]) => this.resolveToolName(name) ?? name);
   }
   /**
-   * Register a tool override with description, hide, args transformation, and/or custom handler
+   * Get all hidden tool names
    */
+  getHiddenToolNames() {
+    return Array.from(this.toolConfigs.entries()).filter(([_name, config2]) => config2.visibility?.hidden === true).map(([name]) => this.resolveToolName(name) ?? name);
+  }
+  /**
+   * Get all public tools
+   */
+  getPublicTools() {
+    return [
+      ...this.publicTools
+    ];
+  }
   /**
-  * Get tool callback from registry
-  */
+   * Set public tools list
+   */
+  setPublicTools(tools) {
+    this.publicTools = [
+      ...tools
+    ];
+  }
+  /**
+   * Get tool callback by name
+   */
   getToolCallback(name) {
     return this.toolRegistry.get(name)?.callback;
   }
   /**
-   * Find tool configuration (simplified - dot/underscore mapping now handled by plugin)
+   * Check if tool exists in registry
+   */
+  hasToolNamed(name) {
+    return this.toolRegistry.has(name) || this.toolNameMapping.has(name) && this.toolRegistry.has(this.toolNameMapping.get(name));
+  }
+  /**
+   * Resolve a tool name to its internal format
+   */
+  resolveToolName(name) {
+    if (this.toolRegistry.has(name)) {
+      return name;
+    }
+    const mappedName = this.toolNameMapping.get(name);
+    if (mappedName && this.toolRegistry.has(mappedName)) {
+      return mappedName;
+    }
+    if (this.toolConfigs.has(name)) {
+      const cfgMapped = this.toolNameMapping.get(name);
+      if (cfgMapped && this.toolRegistry.has(cfgMapped)) {
+        return cfgMapped;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Configure tool behavior
+   */
+  configTool(toolName, config2) {
+    this.toolConfigs.set(toolName, config2);
+  }
+  /**
+   * Get tool configuration
+   */
+  getToolConfig(toolName) {
+    return this.toolConfigs.get(toolName);
+  }
+  /**
+   * Find tool configuration (with mapping fallback)
    */
   findToolConfig(toolId) {
     const directConfig = this.toolConfigs.get(toolId);
@@ -2474,6 +3429,179 @@ var ComposableMCPServer = class extends Server {
     }
     return void 0;
   }
+  /**
+   * Remove tool configuration
+   */
+  removeToolConfig(toolName) {
+    return this.toolConfigs.delete(toolName);
+  }
+  /**
+   * Set tool name mapping
+   */
+  setToolNameMapping(from, to) {
+    this.toolNameMapping.set(from, to);
+  }
+  /**
+   * Get tool schema if it's hidden (for internal access)
+   */
+  getHiddenToolSchema(name) {
+    const tool = this.toolRegistry.get(name);
+    const config2 = this.toolConfigs.get(name);
+    if (tool && config2?.visibility?.hidden && tool.schema) {
+      return {
+        description: tool.description,
+        schema: tool.schema
+      };
+    }
+    return void 0;
+  }
+  /**
+   * Get total tool count
+   */
+  getTotalToolCount() {
+    return this.toolRegistry.size;
+  }
+  /**
+   * Get all tool entries
+   */
+  getToolEntries() {
+    return Array.from(this.toolRegistry.entries());
+  }
+  /**
+   * Get tool registry (for external access)
+   */
+  getToolRegistry() {
+    return this.toolRegistry;
+  }
+};
+
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/compose.js
+init_compose_helpers();
+var ALL_TOOLS_PLACEHOLDER2 = "__ALL__";
+var ComposableMCPServer = class extends Server {
+  pluginManager;
+  toolManager;
+  logger = createLogger("mcpc.compose");
+  // Legacy property for backward compatibility
+  get toolNameMapping() {
+    return this.toolManager.getToolNameMapping();
+  }
+  constructor(_serverInfo, options) {
+    const enhancedOptions = {
+      ...options,
+      capabilities: {
+        logging: {},
+        tools: {},
+        sampling: {},
+        ...options?.capabilities ?? {}
+      }
+    };
+    super(_serverInfo, enhancedOptions);
+    this.logger.setServer(this);
+    this.pluginManager = new PluginManager(this);
+    this.toolManager = new ToolManager();
+  }
+  /**
+   * Initialize built-in plugins - called during setup
+   */
+  async initBuiltInPlugins() {
+    const builtInPlugins = getBuiltInPlugins();
+    const validation = validatePlugins(builtInPlugins);
+    if (!validation.valid) {
+      await this.logger.warning("Built-in plugin validation issues:");
+      for (const error of validation.errors) {
+        await this.logger.warning(`  - ${error}`);
+      }
+    }
+    for (const plugin of builtInPlugins) {
+      await this.pluginManager.addPlugin(plugin);
+    }
+  }
+  /**
+   * Apply plugin transformations to tool arguments/results
+   * Supports runtime transformation hooks for input/output processing
+   */
+  async applyPluginTransforms(toolName, data, direction, originalArgs) {
+    const hookName = direction === "input" ? "transformInput" : "transformOutput";
+    const plugins = this.pluginManager.getPlugins().filter((p2) => p2[hookName]);
+    if (plugins.length === 0) {
+      return data;
+    }
+    const { sortPluginsByOrder: sortPluginsByOrder2 } = await Promise.resolve().then(() => (init_plugin_utils(), plugin_utils_exports));
+    const sortedPlugins = sortPluginsByOrder2(plugins);
+    let currentData = data;
+    const context2 = {
+      toolName,
+      server: this,
+      direction,
+      originalArgs
+    };
+    for (const plugin of sortedPlugins) {
+      const hook = plugin[hookName];
+      if (hook) {
+        try {
+          const result = await hook(currentData, context2);
+          if (result !== void 0) {
+            currentData = result;
+          }
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          await this.logger.error(`Plugin "${plugin.name}" ${hookName} failed for "${toolName}": ${errorMsg}`);
+        }
+      }
+    }
+    return currentData;
+  }
+  /**
+   * Resolve a tool name to its internal format
+   */
+  resolveToolName(name) {
+    return this.toolManager.resolveToolName(name);
+  }
+  tool(name, description, paramsSchema, cb, options = {}) {
+    const jsonSchemaObj = extractJsonSchema(paramsSchema);
+    this.toolManager.registerTool(name, description, jsonSchemaObj, cb, options);
+    if (!options.internal) {
+      this.toolManager.addPublicTool(name, description, jsonSchemaObj);
+    }
+    if (options.plugins) {
+      for (const plugin of options.plugins) {
+        this.pluginManager.addPlugin(plugin);
+      }
+    }
+    this.setRequestHandler(ListToolsRequestSchema, () => {
+      return {
+        tools: this.toolManager.getPublicTools()
+      };
+    });
+    this.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+      const { name: toolName, arguments: args } = request.params;
+      const handler = this.getToolCallback(toolName);
+      if (!handler) {
+        throw new Error(`Tool ${toolName} not found`);
+      }
+      const processedArgs = await this.applyPluginTransforms(toolName, args, "input");
+      const result = await handler(processedArgs, extra);
+      return await this.applyPluginTransforms(toolName, result, "output", args);
+    });
+    this.setRequestHandler(SetLevelRequestSchema, (request) => {
+      const { level } = request.params;
+      this.logger.setLevel(level);
+      return {};
+    });
+  }
+  /**
+   * Get tool callback from registry
+   */
+  getToolCallback(name) {
+    return this.toolManager.getToolCallback(name);
+  }
+  /**
+   * Find tool configuration
+   */
+  findToolConfig(toolId) {
+    return this.toolManager.findToolConfig(toolId);
+  }
   /**
    * Call any registered tool directly, whether it's public or internal
    */
@@ -2486,207 +3614,84 @@ var ComposableMCPServer = class extends Server {
     if (!callback) {
       throw new Error(`Tool ${name} not found`);
     }
-    const processedArgs = this.applyPluginTransforms(resolvedName, args, "input");
+    const processedArgs = await this.applyPluginTransforms(resolvedName, args, "input");
     const result = await callback(processedArgs);
-    return this.applyPluginTransforms(resolvedName, result, "output", args);
-  }
-  /**
-   * Get all internal tool names
-   */
-  getInternalToolNames() {
-    return Array.from(this.toolConfigs.entries()).filter(([_name, config2]) => config2.visibility?.internal).map(([name]) => this.resolveToolName(name) ?? name);
+    return await this.applyPluginTransforms(resolvedName, result, "output", args);
   }
   /**
-   * Get all public tool names
+   * Get all public tool names (exposed to MCP clients)
    */
   getPublicToolNames() {
-    return Array.from(this.toolConfigs.entries()).filter(([_name, config2]) => config2.visibility?.global).map(([name]) => this.resolveToolName(name) ?? name);
+    return this.toolManager.getPublicToolNames();
   }
   /**
-   * Get all external (non-global, non-internal, non-hidden) tool names
+   * Get all public tools (for AI SDK integration)
    */
-  getExternalToolNames() {
-    const allRegistered = Array.from(this.toolRegistry.keys());
-    const publicSet = new Set(this.getPublicToolNames());
-    const internalSet = new Set(this.getInternalToolNames());
-    const hiddenSet = new Set(this.getHiddenToolNames());
-    return allRegistered.filter((n) => !publicSet.has(n) && !internalSet.has(n) && !hiddenSet.has(n));
+  getPublicTools() {
+    return this.toolManager.getPublicTools();
   }
   /**
    * Get all hidden tool names
    */
   getHiddenToolNames() {
-    return Array.from(this.toolConfigs.entries()).filter(([_name, config2]) => config2.visibility?.hide).map(([name]) => this.resolveToolName(name) ?? name);
+    return this.toolManager.getHiddenToolNames();
   }
   /**
-   * Get internal tool schema by name
+   * Get hidden tool schema by name (for internal access)
    */
-  getInternalToolSchema(name) {
-    const tool = this.toolRegistry.get(name);
-    const config2 = this.toolConfigs.get(name);
-    if (tool && config2?.visibility?.internal && tool.schema) {
-      return {
-        description: tool.description,
-        schema: tool.schema
-      };
-    }
-    return void 0;
+  getHiddenToolSchema(name) {
+    return this.toolManager.getHiddenToolSchema(name);
   }
   /**
-   * Check if a tool exists (visible or internal)
+   * Check if a tool exists (visible or hidden)
    */
   hasToolNamed(name) {
-    return this.toolRegistry.has(name) || this.toolNameMapping.has(name) && this.toolRegistry.has(this.toolNameMapping.get(name));
+    return this.toolManager.hasToolNamed(name);
   }
   /**
-   * Configure tool behavior (simplified replacement for middleware)
-   * @example
-   * ```typescript
-   * // Override description
-   * server.configTool('myTool', {
-   *   callback: originalCallback,
-   *   description: 'Enhanced tool description'
-   * });
-   *
-   * // Hide tool from agentic execution
-   * server.configTool('myTool', {
-   *   callback: originalCallback,
-   *   description: 'Hidden tool',
-   *   visibility: { hide: true }
-   * });
-   *
-   * // Make tool globally available
-   * server.configTool('myTool', {
-   *   callback: originalCallback,
-   *   description: 'Global tool',
-   *   visibility: { global: true }
-   * });
-   * ```
+   * Configure tool behavior
    */
   configTool(toolName, config2) {
-    this.toolConfigs.set(toolName, config2);
+    this.toolManager.configTool(toolName, config2);
   }
   /**
    * Get tool configuration
    */
   getToolConfig(toolName) {
-    return this.toolConfigs.get(toolName);
+    return this.toolManager.getToolConfig(toolName);
   }
   /**
    * Remove tool configuration
    */
   removeToolConfig(toolName) {
-    return this.toolConfigs.delete(toolName);
+    return this.toolManager.removeToolConfig(toolName);
   }
   /**
-   * Register a tool plugin
-   * @example
-   * ```typescript
-   * // Global plugin for all tools
-   * server.addPlugin({
-   *   name: 'logger',
-   *   transformTool: (tool, context) => {
-   *     const originalExecute = tool.execute;
-   *     tool.execute = async (args, extra) => {
-   *       console.log(`Calling ${tool.name} with:`, args);
-   *       const result = await originalExecute(args, extra);
-   *       console.log(`Result:`, result);
-   *       return result;
-   *     };
-   *     return tool;
-   *   }
-   * });
-   * ```
+   * Register a tool plugin with validation and error handling
    */
   async addPlugin(plugin) {
-    if (plugin.configureServer) {
-      await plugin.configureServer(this);
-    }
-    this.globalPlugins.push(plugin);
+    await this.pluginManager.addPlugin(plugin);
   }
   /**
    * Load and register a plugin from a file path with optional parameters
-   *
-   * Supports parameter passing via query string syntax:
-   * loadPluginFromPath("path/to/plugin.ts?param1=value1&param2=value2")
    */
-  async loadPluginFromPath(pluginPath) {
-    const plugin = await loadPlugin(pluginPath);
-    this.addPlugin(plugin);
-  }
-  /**
-   * Apply transformTool hook to a tool during composition
-   */
-  async applyTransformToolHooks(tool, toolName, mode) {
-    const transformPlugins = this.globalPlugins.filter((p2) => p2.transformTool && shouldApplyPlugin(p2, mode));
-    if (transformPlugins.length === 0) {
-      return tool;
-    }
-    const sortedPlugins = [
-      ...transformPlugins.filter((p2) => p2.enforce === "pre"),
-      ...transformPlugins.filter((p2) => !p2.enforce),
-      ...transformPlugins.filter((p2) => p2.enforce === "post")
-    ];
-    const context = {
-      toolName,
-      server: this,
-      mode
-    };
-    let currentTool = tool;
-    for (const plugin of sortedPlugins) {
-      if (plugin.transformTool) {
-        const result = await plugin.transformTool(currentTool, context);
-        if (result) {
-          currentTool = result;
-        }
-      }
-    }
-    return currentTool;
+  async loadPluginFromPath(pluginPath, options = {
+    cache: true
+  }) {
+    await this.pluginManager.loadPluginFromPath(pluginPath, options);
   }
   /**
    * Apply plugins to all tools in registry and handle visibility configurations
    */
   async processToolsWithPlugins(externalTools, mode) {
-    for (const [toolId, toolData] of this.toolRegistry.entries()) {
-      const defaultSchema = {
-        type: "object",
-        properties: {},
-        additionalProperties: true
-      };
-      const tempTool = {
-        name: toolId,
-        description: toolData.description,
-        inputSchema: toolData.schema || defaultSchema,
-        execute: toolData.callback
-      };
-      const processedTool = await this.applyTransformToolHooks(tempTool, toolId, mode);
-      this.toolRegistry.set(toolId, {
-        callback: processedTool.execute,
-        description: processedTool.description || toolData.description,
-        schema: processedTool.inputSchema
-      });
-      if (externalTools[toolId]) {
-        try {
-          const builtIn = await Promise.resolve().then(() => (init_built_in(), built_in_exports));
-          if (builtIn && typeof builtIn.processToolVisibility === "function") {
-            builtIn.processToolVisibility(toolId, processedTool, this, externalTools);
-          }
-        } catch {
-        }
-        externalTools[toolId] = processedTool;
-      }
-    }
+    const { processToolsWithPlugins: processTools } = await Promise.resolve().then(() => (init_compose_helpers(), compose_helpers_exports));
+    await processTools(this, externalTools, mode);
   }
   /**
-   * Trigger composeEnd hooks for all plugins
+   * Dispose all plugins and cleanup resources
    */
-  async triggerComposeEndHooks(context) {
-    const endPlugins = this.globalPlugins.filter((p2) => p2.composeEnd && shouldApplyPlugin(p2, context.mode));
-    for (const plugin of endPlugins) {
-      if (plugin.composeEnd) {
-        await plugin.composeEnd(context);
-      }
-    }
+  async disposePlugins() {
+    await this.pluginManager.dispose();
   }
   async compose(name, description, depsConfig = {
     mcpServers: {}
@@ -2698,17 +3703,24 @@ var ComposableMCPServer = class extends Server {
       "tool",
       "fn"
     ]);
+    await this.pluginManager.triggerComposeStart({
+      serverName: name ?? "anonymous",
+      description,
+      mode: options.mode ?? "agentic",
+      server: this,
+      availableTools: []
+    });
     tagToResults.tool.forEach((toolEl) => {
       const toolName = toolEl.attribs.name;
       const toolDescription = toolEl.attribs.description;
       const isHidden = toolEl.attribs.hide !== void 0;
-      const isGlobal = toolEl.attribs.global !== void 0;
+      const isPublic = toolEl.attribs.global !== void 0;
       if (toolName) {
-        this.toolConfigs.set(toolName, {
+        this.toolManager.configTool(toolName, {
           description: toolDescription,
           visibility: {
-            hide: isHidden,
-            global: isGlobal
+            hidden: isHidden,
+            public: isPublic
           }
         });
       }
@@ -2727,10 +3739,10 @@ var ComposableMCPServer = class extends Server {
       availableToolNames.add(toolId);
       availableToolNames.add(`${mcpName}.${ALL_TOOLS_PLACEHOLDER2}`);
       availableToolNames.add(mcpName);
-      this.toolNameMapping.set(toolNameWithScope, toolId);
+      this.toolManager.setToolNameMapping(toolNameWithScope, toolId);
       const internalName = toolNameWithScope.includes(".") ? toolNameWithScope.split(".").slice(1).join(".") : toolNameWithScope;
       if (!this.toolNameMapping.has(internalName)) {
-        this.toolNameMapping.set(internalName, toolId);
+        this.toolManager.setToolNameMapping(internalName, toolId);
       }
       const matchingStep = options.steps?.find((step) => step.actions.includes(toolNameWithScope));
       if (matchingStep) {
@@ -2750,53 +3762,56 @@ var ComposableMCPServer = class extends Server {
     });
     const unmatchedTools = Array.from(requestedToolNames).filter((toolName) => !availableToolNames.has(toolName));
     if (unmatchedTools.length > 0) {
-      console.warn(`\u26A0\uFE0F  Tool matching warnings for agent "${name}":`);
-      unmatchedTools.forEach((toolName) => {
-        console.warn(`   \u2022 Tool not found: "${toolName}"`);
-      });
-      console.warn(`   Available tools: ${Array.from(availableToolNames).sort().join(", ")}`);
+      await this.logger.warning(`Tool matching warnings for agent "${name}":`);
+      for (const toolName of unmatchedTools) {
+        await this.logger.warning(`   \u2022 Tool not found: "${toolName}"`);
+      }
+      await this.logger.warning(`   Available tools: ${Array.from(availableToolNames).sort().join(", ")}`);
     }
     Object.entries(tools).forEach(([toolId, tool]) => {
-      this.toolRegistry.set(toolId, {
-        callback: tool.execute,
-        description: tool.description || "No description available",
-        schema: tool.inputSchema
-      });
+      this.toolManager.registerTool(toolId, tool.description || "No description available", tool.inputSchema, tool.execute);
     });
     await this.processToolsWithPlugins(tools, options.mode ?? "agentic");
+    await this.pluginManager.triggerFinalizeComposition(tools, {
+      serverName: name ?? "anonymous",
+      mode: options.mode ?? "agentic",
+      server: this,
+      toolNames: Object.keys(tools)
+    });
     this.onclose = async () => {
       await cleanupClients();
-      console.log(`\u{1F9E9} [${name}]`);
-      console.log(`   \u251C\u2500 Event: closed`);
-      console.log(`   \u2514\u2500 Action: cleaned up dependent clients`);
+      await this.disposePlugins();
+      await this.logger.info(`[${name}] Event: closed - cleaned up dependent clients and plugins`);
     };
     this.onerror = async (error) => {
-      console.log(`\u{1F9E9} [${name}]`);
-      console.log(`   \u251C\u2500 Event: error, ${error?.stack ?? String(error)}`);
+      await this.logger.error(`[${name}] Event: error - ${error?.stack ?? String(error)}`);
       await cleanupClients();
-      console.log(`   \u2514\u2500 Action: cleaned up dependent clients`);
+      await this.disposePlugins();
+      await this.logger.info(`[${name}] Action: cleaned up dependent clients and plugins`);
     };
     const toolNameToDetailList = Object.entries(tools);
-    const globalToolNames = this.getPublicToolNames();
-    const hideToolNames = this.getHiddenToolNames();
-    const internalToolNames = this.getInternalToolNames();
-    const contextToolNames = toolNameToDetailList.map(([name2]) => name2).filter((n) => !globalToolNames.includes(n) && !hideToolNames.includes(n));
-    const allToolNames = [
-      ...contextToolNames,
-      ...internalToolNames
-    ];
-    globalToolNames.forEach((toolId) => {
+    const publicToolNames = this.getPublicToolNames();
+    const hiddenToolNames = this.getHiddenToolNames();
+    const contextToolNames = toolNameToDetailList.map(([name2]) => name2).filter((n) => !hiddenToolNames.includes(n));
+    publicToolNames.forEach((toolId) => {
       const tool = tools[toolId];
       if (!tool) {
-        throw new Error(`Global tool ${toolId} not found in registry, available: ${Object.keys(tools).join(", ")}`);
+        throw new Error(`Public tool ${toolId} not found in registry, available: ${Object.keys(tools).join(", ")}`);
       }
-      this.tool(toolId, tool.description || "No description available", jsonSchema3(tool.inputSchema), tool.execute);
+      this.tool(toolId, tool.description || "No description available", jsonSchema(tool.inputSchema), tool.execute, {
+        internal: false
+      });
     });
-    await this.triggerComposeEndHooks({
+    await this.pluginManager.triggerComposeEnd({
       toolName: name,
-      pluginNames: this.globalPlugins.map((p2) => p2.name),
+      pluginNames: this.pluginManager.getPluginNames(),
       mode: options.mode ?? "agentic",
-      server: this
+      server: this,
+      stats: {
+        totalTools: this.toolManager.getTotalToolCount(),
+        publicTools: publicToolNames.length,
+        hiddenTools: hiddenToolNames.length
+      }
     });
     if (!name) {
       return;
@@ -2809,50 +3824,11 @@ var ComposableMCPServer = class extends Server {
       ...desTags,
       description,
       tools,
-      toolOverrides: this.toolConfigs,
+      toolOverrides: /* @__PURE__ */ new Map(),
       toolNameMapping: toolNameToIdMapping
     });
-    const depGroups = {};
-    toolNameToDetailList.forEach(([toolName, tool]) => {
-      if (hideToolNames.includes(this.resolveToolName(toolName) ?? "") || globalToolNames.includes(this.resolveToolName(toolName) ?? "")) {
-        return;
-      }
-      if (!tool) {
-        throw new Error(`Action ${toolName} not found, available action list: ${allToolNames.join(", ")}`);
-      }
-      const baseSchema = (
-        // Compatiable with ComposiableleMCPServer.tool() definition
-        tool.inputSchema.jsonSchema ?? // Standard definition
-        tool.inputSchema ?? {
-          type: "object",
-          properties: {},
-          required: []
-        }
-      );
-      const baseProperties = baseSchema.type === "object" && baseSchema.properties ? baseSchema.properties : {};
-      const baseRequired = baseSchema.type === "object" && Array.isArray(baseSchema.required) ? baseSchema.required : [];
-      const updatedProperties = updateRefPaths(baseProperties, toolName);
-      depGroups[toolName] = {
-        type: "object",
-        description: tool.description,
-        properties: updatedProperties,
-        required: [
-          ...baseRequired
-        ],
-        additionalProperties: false
-      };
-    });
-    internalToolNames.forEach((toolName) => {
-      const toolSchema = this.getInternalToolSchema(toolName);
-      if (toolSchema) {
-        depGroups[toolName] = {
-          ...toolSchema.schema,
-          description: toolSchema.description
-        };
-      } else {
-        throw new Error(`Internal tool schema not found for: ${toolName}`);
-      }
-    });
+    const allToolNames = contextToolNames;
+    const depGroups = buildDependencyGroups(toolNameToDetailList, hiddenToolNames, publicToolNames, this);
     switch (options.mode ?? "agentic") {
       case "agentic":
         registerAgenticTool(this, {
@@ -2881,17 +3857,17 @@ var ComposableMCPServer = class extends Server {
   }
 };
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/utils/common/env.js
-import process4 from "node:process";
-var isSCF = () => Boolean(process4.env.SCF_RUNTIME || process4.env.PROD_SCF);
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/env.js
+import process6 from "node:process";
+var isSCF = () => Boolean(process6.env.SCF_RUNTIME || process6.env.PROD_SCF);
 if (isSCF()) {
   console.log({
     isSCF: isSCF(),
-    SCF_RUNTIME: process4.env.SCF_RUNTIME
+    SCF_RUNTIME: process6.env.SCF_RUNTIME
   });
 }
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@jsr/mcpc__core/src/set-up-mcp-compose.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/set-up-mcp-compose.js
 function parseMcpcConfigs(conf) {
   const mcpcConfigs = conf ?? [];
   const newMcpcConfigs = [];
@@ -2932,7 +3908,10 @@ async function mcpc(serverConf, composeConf, setupCallback) {
   return server2;
 }
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@mcpc/cli/src/app.js
+// ../__mcpc__cli_latest/node_modules/@jsr/mcpc__core/mod.js
+init_schema();
+
+// ../__mcpc__cli_latest/node_modules/@mcpc/cli/src/app.js
 var createServer = async (config2) => {
   const serverConfig = config2 || {
     name: "large-result-plugin-example",
@@ -2953,20 +3932,80 @@ var createServer = async (config2) => {
       version: serverConfig.version || "0.1.0"
     },
     {
-      capabilities: serverConfig.capabilities || {
+      capabilities: serverConfig?.capabilities || {
         tools: {},
-        sampling: {}
+        sampling: {},
+        logging: {}
       }
     }
   ], serverConfig.agents);
 };
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@mcpc/cli/src/config/loader.js
+// ../__mcpc__cli_latest/node_modules/@mcpc/cli/src/config/loader.js
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import process5 from "node:process";
+import process7 from "node:process";
+function printHelp() {
+  console.log(`
+MCPC CLI - Model Context Protocol Composer
+
+USAGE:
+    npx -y deno run -A jsr:@mcpc/cli/bin [OPTIONS]
+
+OPTIONS:
+    --help, -h              Show this help message
+    --config <json>         Inline JSON configuration string
+    --config-url <url>      Fetch configuration from URL
+    --config-file <path>    Load configuration from file path
+    --request-headers <header>, -H <header>
+                           Add custom HTTP header for URL fetching
+                           Format: "Key: Value" or "Key=Value"
+                           Can be used multiple times
+
+ENVIRONMENT VARIABLES:
+    MCPC_CONFIG            Inline JSON configuration (same as --config)
+    MCPC_CONFIG_URL        URL to fetch config from (same as --config-url)
+    MCPC_CONFIG_FILE       Path to config file (same as --config-file)
+
+EXAMPLES:
+    # Show help
+    npx -y deno run -A jsr:@mcpc/cli/bin --help
+
+    # Load from URL
+    npx -y deno run -A jsr:@mcpc/cli/bin --config-url \\
+      "https://raw.githubusercontent.com/mcpc-tech/mcpc/main/packages/cli/examples/configs/codex-fork.json"
+
+    # Load from URL with custom headers
+    npx -y deno run -A jsr:@mcpc/cli/bin \\
+      --config-url "https://api.example.com/config.json" \\
+      -H "Authorization: Bearer token123" \\
+      -H "X-Custom-Header: value"
+
+    # Load from file
+    npx -y deno run -A jsr:@mcpc/cli/bin --config-file ./my-config.json
+
+    # Using environment variable
+    export MCPC_CONFIG='[{"name":"agent","description":"..."}]'
+    npx -y deno run -A jsr:@mcpc/cli/bin
+
+    # Use default configuration (./mcpc.config.json)
+    npx -y deno run -A jsr:@mcpc/cli/bin
+
+CONFIGURATION:
+    Configuration files support environment variable substitution using $VAR_NAME syntax.
+    
+    Priority order:
+    1. --config (inline JSON)
+    2. MCPC_CONFIG environment variable
+    3. --config-url or MCPC_CONFIG_URL
+    4. --config-file or MCPC_CONFIG_FILE
+    5. ./mcpc.config.json (default)
+
+For more information, visit: https://github.com/mcpc-tech/mcpc
+`);
+}
 function parseArgs() {
-  const args = process5.argv.slice(2);
+  const args = process7.argv.slice(2);
   const result = {};
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -2976,12 +4015,31 @@ function parseArgs() {
       result.configUrl = args[++i];
     } else if (arg === "--config-file" && i + 1 < args.length) {
       result.configFile = args[++i];
+    } else if ((arg === "--request-headers" || arg === "-H") && i + 1 < args.length) {
+      const headerStr = args[++i];
+      const colonIdx = headerStr.indexOf(":");
+      const equalIdx = headerStr.indexOf("=");
+      const separatorIdx = colonIdx !== -1 ? equalIdx !== -1 ? Math.min(colonIdx, equalIdx) : colonIdx : equalIdx;
+      if (separatorIdx !== -1) {
+        const key = headerStr.substring(0, separatorIdx).trim();
+        const value = headerStr.substring(separatorIdx + 1).trim();
+        if (!result.requestHeaders) {
+          result.requestHeaders = {};
+        }
+        result.requestHeaders[key] = value;
+      }
+    } else if (arg === "--help" || arg === "-h") {
+      result.help = true;
     }
   }
   return result;
 }
 async function loadConfig() {
   const args = parseArgs();
+  if (args.help) {
+    printHelp();
+    process7.exit(0);
+  }
   if (args.config) {
     try {
       const parsed = JSON.parse(args.config);
@@ -2991,9 +4049,25 @@ async function loadConfig() {
       throw error;
     }
   }
-  if (args.configUrl) {
+  if (process7.env.MCPC_CONFIG) {
+    try {
+      const parsed = JSON.parse(process7.env.MCPC_CONFIG);
+      return normalizeConfig(parsed);
+    } catch (error) {
+      console.error("Failed to parse MCPC_CONFIG environment variable:", error);
+      throw error;
+    }
+  }
+  const configUrl = args.configUrl || process7.env.MCPC_CONFIG_URL;
+  if (configUrl) {
     try {
-      const response = await fetch(args.configUrl);
+      const headers = {
+        "User-Agent": "MCPC-CLI/0.1.0",
+        ...args.requestHeaders
+      };
+      const response = await fetch(configUrl, {
+        headers
+      });
       if (!response.ok) {
         throw new Error(`HTTP ${response.status}: ${response.statusText}`);
       }
@@ -3001,26 +4075,27 @@ async function loadConfig() {
       const parsed = JSON.parse(content);
       return normalizeConfig(parsed);
     } catch (error) {
-      console.error(`Failed to fetch config from ${args.configUrl}:`, error);
+      console.error(`Failed to fetch config from ${configUrl}:`, error);
       throw error;
     }
   }
-  if (args.configFile) {
+  const configFile = args.configFile || process7.env.MCPC_CONFIG_FILE;
+  if (configFile) {
     try {
-      const content = await readFile(args.configFile, "utf-8");
+      const content = await readFile(configFile, "utf-8");
       const parsed = JSON.parse(content);
       return normalizeConfig(parsed);
     } catch (error) {
       if (error.code === "ENOENT") {
-        console.error(`Config file not found: ${args.configFile}`);
+        console.error(`Config file not found: ${configFile}`);
         throw error;
       } else {
-        console.error(`Failed to load config from ${args.configFile}:`, error);
+        console.error(`Failed to load config from ${configFile}:`, error);
         throw error;
       }
     }
   }
-  const defaultConfigPath = resolve(process5.cwd(), "mcpc.config.json");
+  const defaultConfigPath = resolve(process7.cwd(), "mcpc.config.json");
   try {
     const content = await readFile(defaultConfigPath, "utf-8");
     const parsed = JSON.parse(content);
@@ -3036,7 +4111,7 @@ async function loadConfig() {
 }
 function replaceEnvVars(str) {
   return str.replace(/\$([A-Z_][A-Z0-9_]*)/g, (_match, varName) => {
-    return process5.env[varName] || "";
+    return process7.env[varName] || "";
   });
 }
 function replaceEnvVarsInConfig(obj) {
@@ -3084,7 +4159,7 @@ function normalizeAgents(agents) {
   });
 }
 
-// ../__mcpc__cli_0.1.1-beta.1/node_modules/@mcpc/cli/src/bin.ts
+// ../__mcpc__cli_latest/node_modules/@mcpc/cli/src/bin.ts
 var config = await loadConfig();
 if (config) {
   console.error(`Loaded configuration with ${config.agents.length} agent(s)`);