@mcpc-tech/cli 0.1.9 → 0.1.11

package/bin/mcpc.mjs

@@ -25,7 +25,7 @@ function jsonSchema(schema, options = {}) {
   };
 }
 function isWrappedSchema(value) {
-  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true;
+  return typeof value === "object" && value !== null && (schemaSymbol in value && value[schemaSymbol] === true || vercelSchemaSymbol in value && value[vercelSchemaSymbol] === true);
 }
 function extractJsonSchema(schema) {
   if (isWrappedSchema(schema)) {
@@ -33,10 +33,11 @@ function extractJsonSchema(schema) {
   }
   return schema;
 }
-var schemaSymbol, validatorSymbol;
+var schemaSymbol, vercelSchemaSymbol, validatorSymbol;
 var init_schema = __esm({
   "__mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/schema.js"() {
     schemaSymbol = Symbol.for("mcpc.schema");
+    vercelSchemaSymbol = Symbol.for("vercel.ai.schema");
     validatorSymbol = Symbol.for("mcpc.validator");
   }
 });
@@ -59,7 +60,7 @@ var init_json = __esm({
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/provider.js
 function sanitizePropertyKey(name) {
-  return name.replace(/[^a-zA-Z0-9_-]/g, "_").substring(0, 64);
+  return name.replace(/[@.,/\\:;!?#$%^&*()[\]{}]/g, "_").substring(0, 64);
 }
 var createGoogleCompatibleJSONSchema;
 var init_provider = __esm({
@@ -251,12 +252,21 @@ var init_logging_plugin = __esm({
             const { stats } = context2;
             const server2 = context2.server;
             const publicTools = Array.from(new Set(server2.getPublicToolNames().map(String)));
+            const internalTools = Array.from(new Set(server2.getInternalToolNames().map(String)));
             const hiddenTools = Array.from(new Set(server2.getHiddenToolNames().map(String)));
+            const normalInternal = internalTools.filter((name) => !hiddenTools.includes(name));
             if (publicTools.length > 0) {
               await logger2.info(`   \u251C\u2500 Public: ${publicTools.join(", ")}`);
             }
-            if (hiddenTools.length > 0) {
-              await logger2.info(`   \u251C\u2500 Hidden: ${hiddenTools.join(", ")}`);
+            if (internalTools.length > 0) {
+              const parts = [];
+              if (normalInternal.length > 0) {
+                parts.push(normalInternal.join(", "));
+              }
+              if (hiddenTools.length > 0) {
+                parts.push(`(${hiddenTools.join(", ")})`);
+              }
+              await logger2.info(`   \u251C\u2500 Internal: ${parts.join(", ")}`);
             }
             await logger2.info(`   \u2514\u2500 Total: ${stats.totalTools} tools`);
           }
@@ -296,218 +306,6 @@ var init_built_in = __esm({
   }
 });
 
-// __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) {
@@ -827,6 +625,7 @@ 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";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/registory.js
 function connectToSmitheryServer(smitheryConfig) {
@@ -862,54 +661,75 @@ var mcpClientPool = /* @__PURE__ */ new Map();
 var mcpClientConnecting = /* @__PURE__ */ new Map();
 var shortHash = (s) => createHash("sha256").update(s).digest("hex").slice(0, 8);
 function defSignature(def) {
-  return JSON.stringify(def);
-}
-async function getOrCreateMcpClient(defKey, def) {
-  const pooled = mcpClientPool.get(defKey);
-  if (pooled) {
-    pooled.refCount += 1;
-    return pooled.client;
+  const defCopy = {
+    ...def
+  };
+  if (defCopy.transportType === "memory" || defCopy.transport) {
+    return `memory:${Date.now()}:${Math.random()}`;
   }
-  const existingConnecting = mcpClientConnecting.get(defKey);
-  if (existingConnecting) {
-    const client = await existingConnecting;
-    const entry = mcpClientPool.get(defKey);
-    if (entry) entry.refCount += 1;
-    return client;
+  return JSON.stringify(defCopy);
+}
+function createTransport(def) {
+  const defAny = def;
+  const explicitType = defAny.transportType || defAny.type;
+  if (explicitType === "memory") {
+    if (!defAny.server) {
+      throw new Error("In-memory transport requires a 'server' field with a Server instance");
+    }
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    defAny.server.connect(serverTransport).catch((err) => {
+      console.error("Error connecting in-memory server:", err);
+    });
+    return clientTransport;
   }
-  let transport2;
-  if (typeof def.transportType === "string" && def.transportType === "sse") {
+  if (explicitType === "sse") {
     const options = {};
-    if (def.headers) {
+    if (defAny.headers) {
       options.requestInit = {
-        headers: def.headers
+        headers: defAny.headers
       };
       options.eventSourceInit = {
-        headers: def.headers
+        headers: defAny.headers
       };
     }
-    transport2 = new SSEClientTransport(new URL(def.url), options);
-  } else if ("url" in def && typeof def.url === "string") {
+    return new SSEClientTransport(new URL(defAny.url), options);
+  }
+  if (defAny.url && typeof defAny.url === "string") {
     const options = {};
-    if (def.headers) {
+    if (defAny.headers) {
       options.requestInit = {
-        headers: def.headers
+        headers: defAny.headers
       };
     }
-    transport2 = new StreamableHTTPClientTransport(new URL(def.url), options);
-  } else if (typeof def.transportType === "string" && def.transportType === "stdio" || "command" in def) {
-    transport2 = new StdioClientTransport({
-      command: def.command,
-      args: def.args,
+    return new StreamableHTTPClientTransport(new URL(defAny.url), options);
+  }
+  if (explicitType === "stdio" || defAny.command) {
+    return new StdioClientTransport({
+      command: defAny.command,
+      args: defAny.args,
       env: {
         ...process3.env,
-        ...def.env ?? {}
+        ...defAny.env ?? {}
       },
       cwd: cwd()
     });
-  } else {
-    throw new Error(`Unsupported transport type: ${JSON.stringify(def)}`);
   }
+  throw new Error(`Unsupported transport configuration: ${JSON.stringify(def)}`);
+}
+async function getOrCreateMcpClient(defKey, def) {
+  const pooled = mcpClientPool.get(defKey);
+  if (pooled) {
+    pooled.refCount += 1;
+    return pooled.client;
+  }
+  const existingConnecting = mcpClientConnecting.get(defKey);
+  if (existingConnecting) {
+    const client = await existingConnecting;
+    const entry = mcpClientPool.get(defKey);
+    if (entry) entry.refCount += 1;
+    return client;
+  }
+  const transport2 = createTransport(def);
   const connecting = (async () => {
     const client = new Client({
       name: `mcp_${shortHash(defSignature(def))}`,
@@ -1028,160 +848,166 @@ var SystemPrompts = {
   /**
    * Base system prompt for autonomous MCP execution
    */
-  AUTONOMOUS_EXECUTION: `Autonomous AI Agent \`{toolName}\` that answers user questions through iterative self-invocation and collecting feedback.
+  AUTONOMOUS_EXECUTION: `Agentic tool \`{toolName}\` that executes complex tasks by iteratively calling actions, gathering results, and deciding next steps until completion. Use this tool when the task matches the manual below.
+
+You must follow the <manual/>, obey the <execution_rules/>, and use the <call_format/>.
 
-<instructions>{description}</instructions>
+<manual>
+{description}
+</manual>
 
-## Execution Rules
-1. **Follow instructions above** carefully
-2. **Answer user question** as primary goal
-3. **Execute** one action per call  
-4. **Collect feedback** from each action result
-5. **Decide** next step:
+<execution_rules>
+1. **Execute** one action per call
+2. **Collect** feedback from each action result
+3. **Decide** next step based on feedback:
    - **proceed**: More work needed
-   - **complete**: Question answered (do NOT provide action field)
+   - **complete**: Task finished (omit action field)
    - **retry**: Current action failed
-6. **Provide** parameter object matching action name
-7. **Continue** until complete
+4. **Provide** parameters matching the action name
+5. **Continue** until task is complete
+6. Note: You are an agent exposed as an MCP tool - **"action" is an internal parameter, NOT an external MCP tool you can call**
+</execution_rules>
 
-## Call Format
+<call_format>
 \`\`\`json
 {
-  "action": "tool_name",
+  "action": "action_name",
   "decision": "proceed|retry", 
-  "tool_name": { /* tool parameters */ }
+  "action_name": { /* action parameters */ }
 }
 \`\`\`
 
-**When task is complete:**
+When complete:
 \`\`\`json
 {
   "decision": "complete"
 }
-\`\`\``,
+\`\`\`
+</call_format>`,
   /**
    * Workflow execution system prompt
    */
-  WORKFLOW_EXECUTION: `Agentic workflow execution tool \`{toolName}\` that processes requests through structured multi-step workflows.
-
-<instructions>{description}</instructions>
-
-## Workflow Execution Protocol
-
-**\u{1F3AF} FIRST CALL (Planning):**
-{planningInstructions}
-
-**\u26A1 SUBSEQUENT CALLS (Execution):**
-- Provide ONLY current step parameters
-- **ADVANCE STEP**: Set \`decision: "proceed"\` to move to next step  
-- **RETRY STEP**: Set \`decision: "retry"\`
-- **COMPLETE WORKFLOW**: Set \`decision: "complete"\` when ready to finish
-
-**\u{1F6AB} Do NOT include \`steps\` parameter during normal execution**
-**\u2705 Include \`steps\` parameter ONLY when restarting workflow with \`init: true\`**
-**\u26A0\uFE0F CRITICAL: When retrying failed steps, MUST use \`decision: "retry"\`**`,
+  WORKFLOW_EXECUTION: `Workflow tool \`{toolName}\` that executes multi-step workflows. Use this when your task requires sequential steps.
+
+<manual>
+{description}
+</manual>
+
+<rules>
+1. First call: {planningInstructions}
+2. Subsequent calls: Provide only current step parameters
+3. Use \`decision: "proceed"\` to advance, \`"retry"\` to retry, \`"complete"\` when done
+4. Include \`steps\` ONLY with \`init: true\`, never during execution
+</rules>`,
   /**
-   * JSON-only execution system prompt
+   * JSON-only execution system prompt for autonomous sampling mode
+   *
+   * Note: Sampling mode runs an internal LLM loop that autonomously calls tools until complete.
    */
-  SAMPLING_EXECUTION: `Autonomous AI Agent \`{toolName}\` that answers user questions by iteratively collecting feedback and adapting your approach.
-
-<instructions>{description}</instructions>
-
-## Execution Rules
-- Respond with valid JSON only
-- **Follow instructions above** carefully
-- **Answer user question** as primary goal
-- **Collect feedback** from each action result
-- **Adapt approach** based on gathered information
-- action = "X" \u2192 provide parameter "X"
-- Continue until question answered
-
-## JSON Response Format
-**During execution:**
+  SAMPLING_EXECUTION: `Agent \`{toolName}\` that completes tasks by calling tools in an autonomous loop.
+
+<manual>
+{description}
+</manual>
+
+<rules>
+1. Return valid JSON only (no markdown, no explanations)
+2. Execute one action per iteration
+3. When \`action\` is "X", include parameter "X" with tool inputs
+4. Adapt based on results from previous actions
+5. Continue until task is complete
+</rules>
+
+<format>
+During execution:
 \`\`\`json
 {
   "action": "tool_name",
   "decision": "proceed|retry",
-  "tool_name": { /* tool parameters */ }
+  "tool_name": { /* parameters */ }
 }
 \`\`\`
 
-**When task is complete (do NOT include action):**
+When complete (omit action):
 \`\`\`json
-{
-  "decision": "complete"
-}
+{ "decision": "complete" }
 \`\`\`
 
-## Available Tools
-{toolList}`,
+Decisions:
+- \`proceed\` = action succeeded, continue
+- \`retry\` = action failed, try again
+- \`complete\` = task finished
+</format>
+
+<tools>
+{toolList}
+</tools>`,
   /**
    * Sampling workflow execution system prompt combining sampling with workflow capabilities
+   *
+   * Note: Sampling mode runs an internal LLM loop that autonomously executes workflows.
    */
-  SAMPLING_WORKFLOW_EXECUTION: `You are an autonomous AI Agent named \`{toolName}\` that processes instructions through iterative sampling execution within structured workflows.
-
-<instructions>{description}</instructions>
-
-## Agentic Sampling Workflow Protocol
-
-**\u{1F9E0} AGENTIC REASONING (First Call - Workflow Planning):**
-1. **Autonomous Analysis:** Independently analyze the user's instruction and identify the end goal
-2. **Workflow Design:** Autonomously design a structured workflow with clear steps
-3. **Tool Mapping:** Determine which tools are needed for each workflow step
-4. **Initialization:** Start the workflow with proper step definitions
-
-**\u26A1 AGENTIC EXECUTION RULES (Subsequent Calls):**
-- Each response demonstrates autonomous reasoning and decision-making within workflow context
-- Make self-directed choices about step execution, retry, or advancement
-- Adapt your approach based on previous step results without external guidance
-- Balance workflow structure with autonomous flexibility
-
-**\u{1F504} JSON Response Format (Agentic Workflow Decision Output):**
-You MUST respond with a JSON object for workflow execution:
-
-**For Workflow Initialization (First Call):**
-- action: "{toolName}"
-- init: true
-- steps: Autonomously designed workflow steps array
-- [other workflow parameters]: As you autonomously determine
-
-**For Step Execution (Subsequent Calls):**
-- action: "{toolName}"
-- decision: "proceed" (advance), "retry" (retry)
-- [step parameters]: Tool-specific parameters you autonomously determine for current step
-
-**When Workflow is Complete (do NOT include action):**
-- decision: "complete"
-
-**\u{1F3AF} AGENTIC WORKFLOW CONSTRAINTS:**
-- Response must be pure JSON demonstrating autonomous decision-making within workflow structure
-- Invalid JSON indicates failure in agentic workflow reasoning
-- Tool parameters must reflect your independent analysis and workflow planning
-- Balance autonomous decision-making with structured workflow progression
-
-**\u{1F6AB} Do NOT include \`steps\` parameter during normal execution**
-**\u2705 Include \`steps\` parameter ONLY when restarting workflow with \`init: true\`**
-**\u26A0\uFE0F CRITICAL: When retrying failed steps, MUST use \`decision: "retry"\`**`
+  SAMPLING_WORKFLOW_EXECUTION: `Workflow agent \`{toolName}\` that executes multi-step workflows autonomously.
+
+<manual>
+{description}
+</manual>
+
+<rules>
+1. Return valid JSON only
+2. First iteration: Plan workflow and initialize with \`init: true\`
+3. Subsequent iterations: Execute current step
+4. Adapt based on step results
+5. Continue until all steps complete
+</rules>
+
+<format>
+Initialize workflow (first iteration):
+\`\`\`json
+{
+  "action": "{toolName}",
+  "init": true,
+  "steps": [/* workflow steps */]
+}
+\`\`\`
+
+Execute step (subsequent iterations):
+\`\`\`json
+{
+  "action": "{toolName}",
+  "decision": "proceed|retry",
+  /* step parameters */
+}
+\`\`\`
+
+Complete workflow (omit action):
+\`\`\`json
+{ "decision": "complete" }
+\`\`\`
+
+Decisions:
+- \`proceed\` = step succeeded, next step
+- \`retry\` = step failed, retry current
+- \`complete\` = workflow finished
+
+Rules:
+- Include \`steps\` ONLY with \`init: true\`
+- Omit \`steps\` during step execution
+- Use \`decision: "retry"\` for failed steps
+</format>`
 };
 var WorkflowPrompts = {
   /**
    * Workflow initialization instructions
    */
-  WORKFLOW_INIT: `Workflow initialized with {stepCount} steps. Agent MUST start the workflow with the first step to \`{currentStepDescription}\`. 
-              
-## EXECUTE tool \`{toolName}\` with the following new parameter definition
-
-{schemaDefinition}
-
-## Important Instructions
-- **Include 'steps' parameter ONLY when restarting workflow (with 'init: true')**
-- **Do NOT include 'steps' parameter during normal step execution**
-- **MUST Use the provided JSON schema definition above for parameter generation and validation**
-- **ADVANCE STEP: Set 'decision' to "proceed" to advance to next step**
-- **RETRY STEP: Set 'decision' to "retry" to re-execute current step**  
-- **FINAL STEP: Execute normally for workflow completion, do NOT use 'decision: complete' unless workflow is truly finished**
-- **\u26A0\uFE0F CRITICAL: When retrying failed steps, MUST set 'decision' to "retry"**
-- **\u26A0\uFE0F CRITICAL: Only use 'decision: complete' when the entire workflow has been successfully executed**
+  WORKFLOW_INIT: `Workflow initialized with {stepCount} steps. Execute step 1: \`{currentStepDescription}\`
+
+Schema: {schemaDefinition}
+
+Call \`{toolName}\` with:
+- Parameters matching schema above
+- \`decision: "proceed"\` to advance, \`"retry"\` to retry, \`"complete"\` when done
+- Omit \`steps\` (only used with \`init: true\`)
 
 {workflowSteps}`,
   /**
@@ -1202,45 +1028,31 @@ var WorkflowPrompts = {
   /**
    * Next step decision prompt
    */
-  NEXT_STEP_DECISION: `**Next Step Decision Required**
+  NEXT_STEP_DECISION: `Previous step completed.
 
-Previous step completed. Choose your action:
-
-**\u{1F504} RETRY Current Step:** 
-- Call \`{toolName}\` with current parameters
-- \u26A0\uFE0F CRITICAL: Set \`decision: "retry"\`
-
-**\u25B6\uFE0F PROCEED to Next Step:** 
-- Call \`{toolName}\` with parameters below
-- Set \`decision: "proceed"\`
-
-Next step: \`{nextStepDescription}\`
+Choose action:
+- RETRY: Call \`{toolName}\` with \`decision: "retry"\`
+- PROCEED: Call \`{toolName}\` with \`decision: "proceed"\` and parameters below
 
+Next: \`{nextStepDescription}\`
 {nextStepSchema}
 
-**Important:** Exclude \`steps\` key from parameters`,
+(Omit \`steps\` parameter)`,
   /**
    * Final step completion prompt
    */
-  FINAL_STEP_COMPLETION: `**Final Step Complete** {statusIcon}
-
-Step executed {statusText}. Choose action:
+  FINAL_STEP_COMPLETION: `Final step executed {statusIcon} - {statusText}
 
-**\u{1F504} RETRY:** Call \`{toolName}\` with \`decision: "retry"\`
-**\u2705 COMPLETE:** Call \`{toolName}\` with \`decision: "complete"\`
-**\u{1F195} NEW:** Call \`{toolName}\` with \`init: true\`{newWorkflowInstructions}`,
+Choose:
+- RETRY: \`decision: "retry"\`
+- COMPLETE: \`decision: "complete"\`
+- NEW: \`init: true\`{newWorkflowInstructions}`,
   /**
    * Workflow completion success message
    */
-  WORKFLOW_COMPLETED: `**Workflow Completed Successfully** \u2705
+  WORKFLOW_COMPLETED: `Workflow completed ({totalSteps} steps)
 
-All workflow steps have been executed and the workflow is now complete.
-
-**Summary:**
-- Total steps: {totalSteps}
-- All steps executed successfully
-
-Agent can now start a new workflow if needed by calling \`{toolName}\` with \`init: true\`{newWorkflowInstructions}.`,
+Start new workflow: \`{toolName}\` with \`init: true\`{newWorkflowInstructions}`,
   /**
    * Error messages
    */
@@ -1259,57 +1071,41 @@ var ResponseTemplates = {
   /**
    * Success response for action execution
    */
-  ACTION_SUCCESS: `**Action Completed Successfully** \u2705
-
-Previous action (\`{currentAction}\`) executed successfully. 
-
-**Next Action Required:** \`{nextAction}\`
+  ACTION_SUCCESS: `Action \`{currentAction}\` completed.
 
-Agent MUST call tool \`{toolName}\` again with the \`{nextAction}\` action to continue the autonomous execution sequence.
-
-**Instructions:**
-- Analyze the result from previous action: \`{currentAction}\`
-- Execute the next planned action: \`{nextAction}\`
-- Maintain execution context and progress toward the final goal`,
+Next: Execute \`{nextAction}\` by calling \`{toolName}\` again.`,
   /**
    * Planning prompt when no next action is specified
    */
-  PLANNING_PROMPT: `**Action Evaluation & Planning Required** \u{1F3AF}
-
-Previous action (\`{currentAction}\`) completed. You need to determine the next step.
-
-**Evaluation & Planning Process:**
-1. **Analyze Results:** Review the outcome of \`{currentAction}\`
-2. **Assess Progress:** Determine how close you are to fulfilling the user request
-3. **Plan Next Action:** Identify the most appropriate next action (if needed)
-4. **Execute Decision:** Call \`{toolName}\` with the planned action
-
-**Options:**
-- **Continue:** If more actions are needed to fulfill the request
-- **Complete:** If the user request has been fully satisfied
+  PLANNING_PROMPT: `Action \`{currentAction}\` completed. Determine next step:
 
-Choose the next action that best advances toward completing the user's request.`,
+1. Analyze results from \`{currentAction}\`
+2. Decide: Continue with another action or Complete?
+3. Call \`{toolName}\` with chosen action or \`decision: "complete"\``,
   /**
-   * Error response template
+   * Error response templates
    */
-  ERROR_RESPONSE: `Action argument validation failed: {errorMessage}`,
-  WORKFLOW_ERROR_RESPONSE: `Action argument validation failed: {errorMessage}
-Set \`decision: "retry"\` to retry the current step, or check your parameters and try again.`,
+  ERROR_RESPONSE: `Validation failed: {errorMessage}
+
+Adjust parameters and retry.`,
+  WORKFLOW_ERROR_RESPONSE: `Step failed: {errorMessage}
+
+Fix parameters and call with \`decision: "retry"\``,
   /**
    * Completion message
    */
-  COMPLETION_MESSAGE: `Completed, no dependent actions to execute`,
+  COMPLETION_MESSAGE: `Task completed.`,
   /**
    * Security validation messages
    */
   SECURITY_VALIDATION: {
-    PASSED: `Security validation PASSED for {operation} on {path}`,
-    FAILED: `Security validation FAILED for {operation} on {path}`
+    PASSED: `Security check passed: {operation} on {path}`,
+    FAILED: `Security check failed: {operation} on {path}`
   },
   /**
    * Audit log messages
    */
-  AUDIT_LOG: `Audit log entry created: [{timestamp}] {level}: {action} on {resource}{userInfo}`
+  AUDIT_LOG: `[{timestamp}] {level}: {action} on {resource}{userInfo}`
 };
 var CompiledPrompts = {
   autonomousExecution: p(SystemPrompts.AUTONOMOUS_EXECUTION),
@@ -1356,14 +1152,14 @@ ${JSON.stringify(steps, null, 2)}`;
    */
   formatWorkflowProgress: (progressData) => {
     const statusIcons = {
-      pending: "\u23F3",
-      running: "\u{1F504}",
-      completed: "\u2705",
-      failed: "\u274C"
+      pending: "[PENDING]",
+      running: "[RUNNING]",
+      completed: "[DONE]",
+      failed: "[FAILED]"
     };
     return progressData.steps.map((step, index) => {
       const status = progressData.statuses[index] || "pending";
-      const icon = statusIcons[status] || "\u23F3";
+      const icon = statusIcons[status] || "[PENDING]";
       const current = index === progressData.currentStepIndex ? " **[CURRENT]**" : "";
       const actions = step.actions.length > 0 ? ` | Action: ${step.actions.join(", ")}` : "";
       return `${icon} **Step ${index + 1}:** ${step.description}${actions}${current}`;
@@ -3207,10 +3003,199 @@ function processToolTags({ description, tagToResults, $, tools, toolOverrides, t
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/compose.js
 init_built_in();
 init_logger();
-init_plugin_utils();
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugin-utils.js
+var pluginCache = /* @__PURE__ */ new Map();
+function shouldApplyPlugin(plugin, mode) {
+  if (!plugin.apply) return true;
+  if (typeof plugin.apply === "string") {
+    return mode.includes(plugin.apply);
+  }
+  if (typeof plugin.apply === "function") {
+    try {
+      return plugin.apply(mode);
+    } catch (error) {
+      console.warn(`Plugin "${plugin.name}" apply function failed: ${error}. Defaulting to true.`);
+      return true;
+    }
+  }
+  return true;
+}
+function sortPluginsByOrder(plugins) {
+  const pluginMap = /* @__PURE__ */ new Map();
+  for (const plugin of plugins) {
+    pluginMap.set(plugin.name, plugin);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const sorted = [];
+  function visit(plugin) {
+    if (visited.has(plugin.name)) return;
+    visited.add(plugin.name);
+    if (plugin.dependencies) {
+      for (const depName of plugin.dependencies) {
+        const dep = pluginMap.get(depName);
+        if (dep) {
+          visit(dep);
+        } else {
+          console.warn(`Plugin "${plugin.name}" depends on "${depName}" which is not loaded`);
+        }
+      }
+    }
+    sorted.push(plugin);
+  }
+  const prePlugins = plugins.filter((p2) => p2.enforce === "pre");
+  const normalPlugins = plugins.filter((p2) => !p2.enforce);
+  const postPlugins = plugins.filter((p2) => p2.enforce === "post");
+  [
+    ...prePlugins,
+    ...normalPlugins,
+    ...postPlugins
+  ].forEach(visit);
+  return sorted;
+}
+function isValidPlugin(plugin) {
+  if (!plugin || typeof plugin !== "object") return false;
+  const p2 = plugin;
+  if (!p2.name || typeof p2.name !== "string" || p2.name.trim() === "") {
+    return false;
+  }
+  const hasHook = typeof p2.configureServer === "function" || typeof p2.composeStart === "function" || typeof p2.transformTool === "function" || typeof p2.finalizeComposition === "function" || typeof p2.composeEnd === "function" || typeof p2.transformInput === "function" || typeof p2.transformOutput === "function" || typeof p2.dispose === "function";
+  if (!hasHook) return false;
+  if (p2.enforce && p2.enforce !== "pre" && p2.enforce !== "post") {
+    return false;
+  }
+  if (p2.apply && typeof p2.apply !== "string" && typeof p2.apply !== "function") {
+    return false;
+  }
+  if (p2.dependencies && !Array.isArray(p2.dependencies)) {
+    return false;
+  }
+  return true;
+}
+function parseQueryParams(params) {
+  const typedParams = {};
+  for (const [key, value] of Object.entries(params)) {
+    const numValue = Number(value);
+    if (!isNaN(numValue) && value.trim() !== "") {
+      typedParams[key] = numValue;
+      continue;
+    }
+    if (value === "true") {
+      typedParams[key] = true;
+      continue;
+    }
+    if (value === "false") {
+      typedParams[key] = false;
+      continue;
+    }
+    if (value.includes(",")) {
+      typedParams[key] = value.split(",").map((v) => v.trim());
+      continue;
+    }
+    typedParams[key] = value;
+  }
+  return typedParams;
+}
+async function loadPlugin(pluginPath, options = {
+  cache: true
+}) {
+  if (options.cache && pluginCache.has(pluginPath)) {
+    return pluginCache.get(pluginPath);
+  }
+  try {
+    const [rawPath, queryString] = pluginPath.split("?", 2);
+    const searchParams = new URLSearchParams(queryString || "");
+    const params = Object.fromEntries(searchParams.entries());
+    const resolveFn = import.meta.resolve;
+    const importPath = typeof resolveFn === "function" ? resolveFn(rawPath) : new URL(rawPath, import.meta.url).href;
+    const pluginModule = await import(importPath);
+    const pluginFactory = pluginModule.createPlugin;
+    const defaultPlugin = pluginModule.default;
+    let plugin;
+    if (Object.keys(params).length > 0) {
+      if (typeof pluginFactory !== "function") {
+        throw new Error(`Plugin "${rawPath}" has parameters but no createPlugin export function`);
+      }
+      const typedParams = parseQueryParams(params);
+      plugin = pluginFactory(typedParams);
+    } else {
+      if (defaultPlugin) {
+        plugin = defaultPlugin;
+      } else if (typeof pluginFactory === "function") {
+        plugin = pluginFactory();
+      } else {
+        throw new Error(`Plugin "${rawPath}" has no default export or createPlugin function`);
+      }
+    }
+    if (!isValidPlugin(plugin)) {
+      throw new Error(`Invalid plugin format in "${rawPath}": must have a unique name and at least one lifecycle hook`);
+    }
+    if (options.cache) {
+      pluginCache.set(pluginPath, plugin);
+    }
+    return plugin;
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load plugin from "${pluginPath}": ${errorMsg}`);
+  }
+}
+function checkCircularDependencies(plugins) {
+  const errors = [];
+  const pluginMap = /* @__PURE__ */ new Map();
+  for (const plugin of plugins) {
+    pluginMap.set(plugin.name, plugin);
+  }
+  function checkCircular(pluginName, visited, path) {
+    if (visited.has(pluginName)) {
+      const cycle = [
+        ...path,
+        pluginName
+      ].join(" -> ");
+      errors.push(`Circular dependency detected: ${cycle}`);
+      return;
+    }
+    const plugin = pluginMap.get(pluginName);
+    if (!plugin || !plugin.dependencies) return;
+    visited.add(pluginName);
+    path.push(pluginName);
+    for (const dep of plugin.dependencies) {
+      checkCircular(dep, new Set(visited), [
+        ...path
+      ]);
+    }
+  }
+  for (const plugin of plugins) {
+    checkCircular(plugin.name, /* @__PURE__ */ new Set(), []);
+  }
+  return errors;
+}
+function validatePlugins(plugins) {
+  const errors = [];
+  const names = /* @__PURE__ */ new Map();
+  for (const plugin of plugins) {
+    const count = names.get(plugin.name) || 0;
+    names.set(plugin.name, count + 1);
+  }
+  for (const [name, count] of names.entries()) {
+    if (count > 1) {
+      errors.push(`Duplicate plugin name: "${name}" (${count} instances)`);
+    }
+  }
+  const circularErrors = checkCircularDependencies(plugins);
+  errors.push(...circularErrors);
+  for (const plugin of plugins) {
+    if (!isValidPlugin(plugin)) {
+      const name = plugin.name || "unknown";
+      errors.push(`Invalid plugin: "${name}"`);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/plugin-manager.js
-init_plugin_utils();
 init_logger();
 var PluginManager = class {
   server;
@@ -3378,6 +3363,7 @@ var PluginManager = class {
 };
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/tool-manager.js
+init_schema();
 var ToolManager = class {
   toolRegistry = /* @__PURE__ */ new Map();
   toolConfigs = /* @__PURE__ */ new Map();
@@ -3562,10 +3548,33 @@ var ToolManager = class {
   getToolRegistry() {
     return this.toolRegistry;
   }
+  /**
+   * Get all registered tools as ComposedTool objects
+   * This includes tools registered via server.tool() in setup hooks
+   */
+  getRegisteredToolsAsComposed() {
+    const composedTools = {};
+    for (const [name, tool] of this.toolRegistry.entries()) {
+      if (this.toolConfigs.get(name)?.visibility?.public === true) {
+        continue;
+      }
+      composedTools[name] = {
+        name,
+        description: tool.description,
+        inputSchema: jsonSchema(tool.schema || {
+          type: "object",
+          properties: {}
+        }),
+        execute: tool.callback
+      };
+    }
+    return composedTools;
+  }
 };
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/compose.js
 init_compose_helpers();
+init_provider();
 var ALL_TOOLS_PLACEHOLDER2 = "__ALL__";
 var ComposableMCPServer = class extends Server {
   pluginManager;
@@ -3616,8 +3625,7 @@ var ComposableMCPServer = class extends Server {
     if (plugins.length === 0) {
       return data;
     }
-    const { sortPluginsByOrder: sortPluginsByOrder2 } = await Promise.resolve().then(() => (init_plugin_utils(), plugin_utils_exports));
-    const sortedPlugins = sortPluginsByOrder2(plugins);
+    const sortedPlugins = sortPluginsByOrder(plugins);
     let currentData = data;
     const context2 = {
       toolName,
@@ -3725,6 +3733,14 @@ var ComposableMCPServer = class extends Server {
   getHiddenToolNames() {
     return this.toolManager.getHiddenToolNames();
   }
+  /**
+   * Get all internal tool names (tools that are not public)
+   */
+  getInternalToolNames() {
+    const allToolNames = Array.from(this.toolManager.getToolRegistry().keys());
+    const publicToolNames = this.getPublicToolNames();
+    return allToolNames.filter((name) => !publicToolNames.includes(name));
+  }
   /**
    * Get hidden tool schema by name (for internal access)
    */
@@ -3819,15 +3835,13 @@ var ComposableMCPServer = class extends Server {
     const availableToolNames = /* @__PURE__ */ new Set();
     tagToResults.tool.forEach((tool) => {
       if (tool.attribs.name) {
-        requestedToolNames.add(tool.attribs.name);
+        requestedToolNames.add(sanitizePropertyKey(tool.attribs.name));
       }
     });
     const { tools, cleanupClients } = await composeMcpDepTools(depsConfig, ({ mcpName, toolNameWithScope, toolId }) => {
       toolNameToIdMapping.set(toolNameWithScope, toolId);
       availableToolNames.add(toolNameWithScope);
       availableToolNames.add(toolId);
-      availableToolNames.add(`${mcpName}.${ALL_TOOLS_PLACEHOLDER2}`);
-      availableToolNames.add(mcpName);
       this.toolManager.setToolNameMapping(toolNameWithScope, toolId);
       const internalName = toolNameWithScope.includes(".") ? toolNameWithScope.split(".").slice(1).join(".") : toolNameWithScope;
       if (!this.toolNameMapping.has(internalName)) {
@@ -3849,23 +3863,34 @@ var ComposableMCPServer = class extends Server {
         return tool.attribs.name === toolNameWithScope || tool.attribs.name === toolId;
       });
     });
-    const unmatchedTools = Array.from(requestedToolNames).filter((toolName) => !availableToolNames.has(toolName));
+    Object.entries(tools).forEach(([toolId, tool]) => {
+      this.toolManager.registerTool(toolId, tool.description || "", tool.inputSchema, tool.execute);
+    });
+    const registeredTools = this.toolManager.getRegisteredToolsAsComposed();
+    const allTools = {
+      ...tools
+    };
+    Object.entries(registeredTools).forEach(([toolName, tool]) => {
+      if (!allTools[toolName]) {
+        allTools[toolName] = tool;
+      }
+      availableToolNames.add(toolName);
+    });
+    const unmatchedTools = Array.from(requestedToolNames).filter((toolName) => !allTools[toolName]);
     if (unmatchedTools.length > 0) {
       await this.logger.warning(`Tool matching warnings for agent "${name}":`);
-      for (const toolName of unmatchedTools) {
-        await this.logger.warning(`   \u2022 Tool not found: "${toolName}"`);
-      }
-      await this.logger.warning(`   Available tools: ${Array.from(availableToolNames).sort().join(", ")}`);
+      unmatchedTools.forEach((toolName) => {
+        this.logger.warning(`   \u2022 Tool not found: "${toolName}"`);
+      });
+      const available = Array.from(availableToolNames).sort().join(", ");
+      await this.logger.warning(`   Available tools: ${available}`);
     }
-    Object.entries(tools).forEach(([toolId, tool]) => {
-      this.toolManager.registerTool(toolId, tool.description || "No description available", tool.inputSchema, tool.execute);
-    });
-    await this.processToolsWithPlugins(tools, options.mode ?? "agentic");
-    await this.pluginManager.triggerFinalizeComposition(tools, {
+    await this.processToolsWithPlugins(allTools, options.mode ?? "agentic");
+    await this.pluginManager.triggerFinalizeComposition(allTools, {
       serverName: name ?? "anonymous",
       mode: options.mode ?? "agentic",
       server: this,
-      toolNames: Object.keys(tools)
+      toolNames: Object.keys(allTools)
     });
     this.onclose = async () => {
       await cleanupClients();
@@ -3878,16 +3903,16 @@ var ComposableMCPServer = class extends Server {
       await this.disposePlugins();
       await this.logger.info(`[${name}] Action: cleaned up dependent clients and plugins`);
     };
-    const toolNameToDetailList = Object.entries(tools);
+    const toolNameToDetailList = Object.entries(allTools);
     const publicToolNames = this.getPublicToolNames();
     const hiddenToolNames = this.getHiddenToolNames();
     const contextToolNames = toolNameToDetailList.map(([name2]) => name2).filter((n) => !hiddenToolNames.includes(n));
     publicToolNames.forEach((toolId) => {
-      const tool = tools[toolId];
+      const tool = allTools[toolId];
       if (!tool) {
-        throw new Error(`Public tool ${toolId} not found in registry, available: ${Object.keys(tools).join(", ")}`);
+        throw new Error(`Public tool ${toolId} not found in registry, available: ${Object.keys(allTools).join(", ")}`);
       }
-      this.tool(toolId, tool.description || "No description available", jsonSchema(tool.inputSchema), tool.execute, {
+      this.tool(toolId, tool.description || "", jsonSchema(tool.inputSchema), tool.execute, {
         internal: false
       });
     });
@@ -3912,7 +3937,7 @@ var ComposableMCPServer = class extends Server {
     description = processToolTags({
       ...desTags,
       description,
-      tools,
+      tools: allTools,
       toolOverrides: /* @__PURE__ */ new Map(),
       toolNameMapping: toolNameToIdMapping
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcpc-tech/cli",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "homepage": "https://jsr.io/@mcpc/cli",
   "type": "module",
   "dependencies": {