@mcpc-tech/cli 0.1.28 → 0.1.30

package/bin/mcpc.cjs

@@ -389,7 +389,7 @@ var require_parse = __commonJS({
     "use strict";
     var path = require("path");
     var resolveCommand = require_resolveCommand();
-    var escape2 = require_escape();
+    var escape = require_escape();
     var readShebang = require_readShebang();
     var isWin = process.platform === "win32";
     var isExecutableRegExp = /\.(?:com|exe)$/i;
@@ -413,8 +413,8 @@ var require_parse = __commonJS({
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
         parsed.command = path.normalize(parsed.command);
-        parsed.command = escape2.command(parsed.command);
-        parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars));
+        parsed.command = escape.command(parsed.command);
+        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
         const shellCommand = [parsed.command].concat(parsed.args).join(" ");
         parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
         parsed.command = process.env.comspec || "cmd.exe";
@@ -2035,8 +2035,8 @@ var UrlElicitationRequiredError = class extends McpError {
 
 // __mcpc__cli_latest/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
 var ReadBuffer = class {
-  append(chunk2) {
-    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk2]) : chunk2;
+  append(chunk) {
+    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
   }
   readMessage() {
     if (!this._buffer) {
@@ -2068,8 +2068,8 @@ var StdioServerTransport = class {
     this._stdout = _stdout;
     this._readBuffer = new ReadBuffer();
     this._started = false;
-    this._ondata = (chunk2) => {
-      this._readBuffer.append(chunk2);
+    this._ondata = (chunk) => {
+      this._readBuffer.append(chunk);
       this.processReadBuffer();
     };
     this._onerror = (error) => {
@@ -2508,9 +2508,8 @@ OPTIONS:
     --mode <mode>           Set execution mode for all agents
                            Supported modes:
                            - agentic: Fully autonomous agent mode (default)
-                           - agentic_workflow: Agent workflow mode with dynamic or predefined steps
-                           - agentic_sampling: Autonomous sampling mode for agentic execution
-                           - agentic_workflow_sampling: Autonomous sampling mode for workflow execution
+                           - ai_sampling: AI SDK sampling mode for autonomous execution
+                           - ai_acp: AI SDK ACP mode for coding agents
                            - code_execution: Code execution mode for most efficient token usage
     --add                   Add MCP servers to ~/.mcpc/config.json and exit
                            Then run 'mcpc' to start the server with saved config
@@ -2563,7 +2562,7 @@ EXAMPLES:
     mcpc --config-file ./my-config.json
 
     # Override execution mode for all agents
-    mcpc --config-file ./my-config.json --mode agentic_workflow
+    mcpc --config-file ./my-config.json --mode ai_sampling
 
     # Using environment variable
     export MCPC_CONFIG='[{"name":"agent","description":"..."}]'
@@ -3074,11 +3073,11 @@ var Protocol = class {
     const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
     controller?.abort(notification.params.reason);
   }
-  _setupTimeout(messageId, timeout2, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
+  _setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
     this._timeoutInfo.set(messageId, {
-      timeoutId: setTimeout(onTimeout, timeout2),
+      timeoutId: setTimeout(onTimeout, timeout),
       startTime: Date.now(),
-      timeout: timeout2,
+      timeout,
       maxTotalTimeout,
       resetTimeoutOnProgress,
       onTimeout
@@ -3522,9 +3521,9 @@ var Protocol = class {
       options?.signal?.addEventListener("abort", () => {
         cancel(options?.signal?.reason);
       });
-      const timeout2 = options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
-      const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout: timeout2 }));
-      this._setupTimeout(messageId, timeout2, options?.maxTotalTimeout, timeoutHandler, options?.resetTimeoutOnProgress ?? false);
+      const timeout = options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
+      const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
+      this._setupTimeout(messageId, timeout, options?.maxTotalTimeout, timeoutHandler, options?.resetTimeoutOnProgress ?? false);
       const relatedTaskId = relatedTask?.taskId;
       if (relatedTaskId) {
         const responseResolver = (response) => {
@@ -4429,71 +4428,6 @@ var Server = class extends Protocol {
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/json.js
 var import_jsonrepair = require("jsonrepair");
-function stripMarkdownAndText(text) {
-  text = text.trim();
-  text = text.replace(/^```(?:json)?\s*\n?/i, "");
-  text = text.replace(/\n?```\s*$/, "");
-  text = text.replace(/^(?:here is|here's|response|result|output|json):\s*/i, "");
-  const firstJsonIndex = text.search(/[\{\[]/);
-  if (firstJsonIndex >= 0) {
-    text = text.slice(firstJsonIndex);
-    let depth = 0;
-    let inString = false;
-    let escapeNext = false;
-    const startChar = text[0];
-    const endChar = startChar === "{" ? "}" : "]";
-    for (let i = 0; i < text.length; i++) {
-      const char = text[i];
-      if (escapeNext) {
-        escapeNext = false;
-        continue;
-      }
-      if (char === "\\") {
-        escapeNext = true;
-        continue;
-      }
-      if (char === '"' && !inString) {
-        inString = true;
-        continue;
-      }
-      if (char === '"' && inString) {
-        inString = false;
-        continue;
-      }
-      if (inString) continue;
-      if (char === startChar) {
-        depth++;
-      } else if (char === endChar) {
-        depth--;
-        if (depth === 0) {
-          return text.slice(0, i + 1);
-        }
-      }
-    }
-  }
-  return text.trim();
-}
-function parseJSON(text, throwError) {
-  try {
-    return JSON.parse(text);
-  } catch (_error) {
-    try {
-      const cleanedText = stripMarkdownAndText(text);
-      try {
-        return JSON.parse(cleanedText);
-      } catch {
-        const repairedText = (0, import_jsonrepair.jsonrepair)(cleanedText);
-        console.warn(`Failed to parse JSON, cleaned and repaired. Original: ${text.slice(0, 100)}...`);
-        return JSON.parse(repairedText);
-      }
-    } catch (_repairError) {
-      if (throwError) {
-        throw new Error(`Failed to parse JSON after cleanup and repair. Original error: ${_error instanceof Error ? _error.message : String(_error)}`);
-      }
-      return null;
-    }
-  }
-}
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__utils/src/ai.js
 var p = (template, options = {}) => {
@@ -5299,8 +5233,8 @@ var StdioClientTransport = class {
       this._process.stdin?.on("error", (error) => {
         this.onerror?.(error);
       });
-      this._process.stdout?.on("data", (chunk2) => {
-        this._readBuffer.append(chunk2);
+      this._process.stdout?.on("data", (chunk) => {
+        this._readBuffer.append(chunk);
         this.processReadBuffer();
       });
       this._process.stdout?.on("error", (error) => {
@@ -5409,7 +5343,7 @@ function createParser(callbacks) {
   const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks;
   let incompleteLine = "", isFirstChunk = true, id, data = "", eventType = "";
   function feed(newChunk) {
-    const chunk2 = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk2}`);
+    const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
     for (const line of complete)
       parseLine(line);
     incompleteLine = incomplete, isFirstChunk = false;
@@ -5477,19 +5411,19 @@ function createParser(callbacks) {
   }
   return { feed, reset };
 }
-function splitLines(chunk2) {
+function splitLines(chunk) {
   const lines = [];
   let incompleteLine = "", searchIndex = 0;
-  for (; searchIndex < chunk2.length; ) {
-    const crIndex = chunk2.indexOf("\r", searchIndex), lfIndex = chunk2.indexOf(`
+  for (; searchIndex < chunk.length; ) {
+    const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
 `, searchIndex);
     let lineEnd = -1;
-    if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk2.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
-      incompleteLine = chunk2.slice(searchIndex);
+    if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
+      incompleteLine = chunk.slice(searchIndex);
       break;
     } else {
-      const line = chunk2.slice(searchIndex, lineEnd);
-      lines.push(line), searchIndex = lineEnd + 1, chunk2[searchIndex - 1] === "\r" && chunk2[searchIndex] === `
+      const line = chunk.slice(searchIndex, lineEnd);
+      lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
 ` && searchIndex++;
     }
   }
@@ -6824,8 +6758,8 @@ var EventSourceParserStream = class extends TransformStream {
           onComment
         });
       },
-      transform(chunk2) {
-        parser.feed(chunk2);
+      transform(chunk) {
+        parser.feed(chunk);
       }
     });
   }
@@ -6933,14 +6867,14 @@ var StreamableHTTPClientTransport = class {
    * @param attempt Current reconnection attempt count for the specific stream
    * @returns Time to wait in milliseconds before next reconnection attempt
    */
-  _getNextReconnectionDelay(attempt2) {
+  _getNextReconnectionDelay(attempt) {
     if (this._serverRetryMs !== void 0) {
       return this._serverRetryMs;
     }
     const initialDelay = this._reconnectionOptions.initialReconnectionDelay;
     const growFactor = this._reconnectionOptions.reconnectionDelayGrowFactor;
     const maxDelay = this._reconnectionOptions.maxReconnectionDelay;
-    return Math.min(initialDelay * Math.pow(growFactor, attempt2), maxDelay);
+    return Math.min(initialDelay * Math.pow(growFactor, attempt), maxDelay);
   }
   /**
    * Schedule a reconnection attempt using server-provided retry interval or backoff
@@ -6954,13 +6888,13 @@ var StreamableHTTPClientTransport = class {
       this.onerror?.(new Error(`Maximum reconnection attempts (${maxRetries}) exceeded.`));
       return;
     }
-    const delay2 = this._getNextReconnectionDelay(attemptCount);
+    const delay = this._getNextReconnectionDelay(attemptCount);
     this._reconnectionTimeout = setTimeout(() => {
       this._startOrAuthSse(options).catch((error) => {
         this.onerror?.(new Error(`Failed to reconnect SSE stream: ${error instanceof Error ? error.message : String(error)}`));
         this._scheduleReconnection(options, attemptCount + 1);
       });
-    }, delay2);
+    }, delay);
   }
   _handleSseStream(stream, options, isReconnectable) {
     if (!stream) {
@@ -7294,8 +7228,8 @@ var createModelCompatibleJSONSchema = (schema) => {
   ]);
   let cleanSchema = schema;
   if (GEMINI_PREFERRED_FORMAT) {
-    const { oneOf: _oneOf, allOf: _allOf, anyOf: _anyOf, ...rest2 } = schema;
-    cleanSchema = rest2;
+    const { oneOf: _oneOf, allOf: _allOf, anyOf: _anyOf, ...rest } = schema;
+    cleanSchema = rest;
   }
   const cleanRecursively = (obj) => {
     if (Array.isArray(obj)) {
@@ -7314,6 +7248,34 @@ var createModelCompatibleJSONSchema = (schema) => {
   };
   return cleanRecursively(cleanSchema);
 };
+var INTERNAL_SCHEMA_KEYS = /* @__PURE__ */ new Set([
+  "$schema",
+  "_originalName",
+  "_type",
+  "annotations"
+]);
+var cleanToolSchema = (schema) => {
+  const cleanRecursively = (obj) => {
+    if (Array.isArray(obj)) {
+      return obj.map(cleanRecursively);
+    }
+    if (obj && typeof obj === "object") {
+      const record2 = obj;
+      if ("jsonSchema" in record2 && typeof record2.jsonSchema === "object" && record2.jsonSchema !== null) {
+        return cleanRecursively(record2.jsonSchema);
+      }
+      const result = {};
+      for (const [key, value] of Object.entries(record2)) {
+        if (!INTERNAL_SCHEMA_KEYS.has(key)) {
+          result[key] = cleanRecursively(value);
+        }
+      }
+      return result;
+    }
+    return obj;
+  };
+  return cleanRecursively(schema);
+};
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
 var import_node_process5 = require("node:process");
@@ -7662,14 +7624,14 @@ function createLogger(name, server) {
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/logging-plugin.js
 var createLoggingPlugin = (options = {}) => {
-  const { enabled = true, verbose = false, compact: compact2 = true } = options;
+  const { enabled = true, verbose = false, compact = true } = options;
   return {
     name: "built-in-logging",
     version: "1.0.0",
     composeEnd: async (context2) => {
       if (!enabled) return;
       const logger2 = createLogger("mcpc.plugin.logging", context2.server);
-      if (compact2) {
+      if (compact) {
         const pluginCount = context2.pluginNames.length;
         const { stats } = context2;
         await logger2.info(`[${context2.toolName}] ${pluginCount} plugins \u2022 ${stats.publicTools} public \u2022 ${stats.hiddenTools} hidden`);
@@ -7709,296 +7671,85 @@ var logging_plugin_default = createLoggingPlugin({
 var SystemPrompts = {
   /**
    * Base system prompt for autonomous MCP execution
+   *
+   * Uses simplified Unix-style interface:
+   * - `tool` + `args` for clean, consistent structure
+   * - `man` command for fetching tool schemas (like Unix manual)
+   * - No `hasDefinitions` - trusts model's context memory
    */
-  AUTONOMOUS_EXECUTION: `Agentic tool \`{toolName}\` that executes complex tasks by iteratively selecting and calling tools, gathering results, and continuing until completion. Use this tool when the task matches the manual below.
+  AUTONOMOUS_EXECUTION: `Agentic tool \`{toolName}\` that executes complex tasks by iteratively selecting and calling tools.
 
-You must follow the <manual/>, obey the <execution_rules/>, and use the <call_format/>.
+You must follow the <manual/>, obey the <rules/>, and use the <format/>.
 
 <manual>
 {description}
 </manual>
 
 <parameters>
-\`useTool\` - Which tool to execute this iteration
-\`hasDefinitions\` - Tool names whose schemas you already have
-\`definitionsOf\` - Tool names whose schemas you need
+\`tool\` - Which tool to execute: "man" to get schemas, or a tool name to execute
+\`args\` - For "man": { tools: ["tool1", "tool2"] }. For other tools: tool parameters that strictly adhere to the tool's JSON schema.
 </parameters>
 
-<execution_rules>
-1. **First call**: No tool definitions available\u2014you must request them via \`definitionsOf\`
-2. **When executing tools**: Must provide \`hasDefinitions\` with ALL tools you have schemas for (avoid duplicate requests and reduce tokens)
-3. **When requesting definitions**: Use \`definitionsOf\` to request tool schemas you need
-4. **Both together**: Execute tool AND request new definitions in one call for efficiency
-5. **Never request definitions you already have**
-6. **Select** one tool to execute per call using \`useTool\`
-7. **Provide** parameters matching the selected tool name
-8. Note: You are an agent exposed as an MCP tool - **\`useTool\` is an internal parameter for choosing which tool to execute, NOT an external MCP tool you can call**
-</execution_rules>
-
-<call_format>
-Initial definition request:
-\`\`\`json
-{
-  "hasDefinitions": [],
-  "definitionsOf": ["tool1", "tool2"]
-}
-\`\`\`
-
-Execute tool + get new definitions:
-\`\`\`json
-{
-  "useTool": "tool1",
-  "tool1": { /* parameters */ },
-  "hasDefinitions": ["tool1", "tool2"],
-  "definitionsOf": ["tool3"]
-}
-\`\`\`
-</call_format>`,
-  /**
-   * Workflow execution system prompt
-   */
-  WORKFLOW_EXECUTION: `Workflow tool \`{toolName}\` that executes multi-step workflows. Use this when your task requires sequential steps.
-
-<manual>
-{description}
-</manual>
-
-<rules>
-1. First call: {planningInstructions}
-2. Subsequent calls: Provide only current step parameters
-3. Use \`decision: "proceed"\` to advance, \`"retry"\` to retry, \`"complete"\` when done
-4. Include \`steps\` ONLY with \`init: true\`, never during execution
-</rules>`,
-  /**
-   * Tool-based execution system prompt for autonomous sampling mode with native tools
-   *
-   * Note: Used when client supports sampling.tools capability
-   */
-  SAMPLING_EXECUTION_TOOLS: `Agent \`{toolName}\` that completes tasks by calling tools.
-
-<manual>
-{description}
-</manual>
-
-<rules>
-1. Execute one action per iteration
-2. Adapt based on results from previous actions
-3. Continue until task is complete
-</rules>
-
-<tools>
-{toolList}
-</tools>`,
-  /**
-   * JSON-only execution system prompt for autonomous sampling mode
-   *
-   * Note: Sampling mode runs an internal LLM loop that autonomously calls tools until complete.
-   */
-  SAMPLING_EXECUTION: `Agent \`{toolName}\` that completes tasks by calling tools in an autonomous loop.
-
-<manual>
-{description}
-</manual>
-
 <rules>
-1. **YOUR ENTIRE RESPONSE MUST BE A SINGLE JSON OBJECT** - no text before or after
-2. Execute one tool per iteration  
-3. Specify which tool to use with \`useTool\`
-4. Adapt based on results from previous actions
-5. Continue until task is complete
+1. **First call**: Use \`man\` to get tool schemas you need
+2. **Execute tools**: Use tool name in \`tool\` and parameters in \`args\`
+3. **Parallel calls**: If your client supports it, call \`man\` and execute tools simultaneously
+4. Note: You are an agent exposed as an MCP tool
 </rules>
 
 <format>
-CORRECT:
-\`\`\`json
-{"useTool": "tool_name", "decision": "proceed", "tool_name": {...}}
-\`\`\`
-
-WRONG - No explanations:
-\`\`\`
-I will list the directory
-{"useTool": "list_directory", ...}
-\`\`\`
-
-During execution:
+Get tool schemas:
 \`\`\`json
 {
-  "useTool": "tool_name",
-  "decision": "proceed",
-  "tool_name": { /* tool parameters */ }
+  "tool": "man",
+  "args": { "tools": ["tool1", "tool2"] }
 }
 \`\`\`
 
-When complete:
+Execute a tool:
 \`\`\`json
-{ "decision": "complete" }
+{
+  "tool": "tool_name",
+  "args": { /* tool parameters */ }
+}
 \`\`\`
-
-Decisions:
-- \`proceed\` = action succeeded, continue
-- \`retry\` = action failed, try again  
-- \`complete\` = task finished
-</format>
-
-<tools>
-{toolList}
-</tools>`,
+</format>`,
   /**
    * Tool description for sampling tools (shown in MCP tools list)
-   * Explains how to use userRequest and context parameters
+   * Explains how to use prompt and context parameters
    */
-  SAMPLING_TOOL_DESCRIPTION: `Subagent tool \`{toolName}\`  that executes complex tasks.
+  SAMPLING_TOOL_DESCRIPTION: `Subagent tool \`{toolName}\` that executes complex tasks.
 
-<manual>
-{description}
-</manual>
-
-<rules>
-Call this tool with:
-- **userRequest**: The task you want completed (e.g., "organize my desktop files", "create a project structure")
-- **context**: Relevant information needed for the task (e.g., working directory, file paths, preferences)
-</rules>`,
-  /**
-   * Tool-based workflow execution system prompt for sampling mode with native tools
-   *
-   * Note: Used when client supports sampling.tools capability
-   */
-  SAMPLING_WORKFLOW_EXECUTION_TOOLS: `Workflow agent \`{toolName}\` that executes multi-step workflows.
+You must follow the <manual/>, obey the <rules/>, and use the <format/>.
 
 <manual>
 {description}
 </manual>
 
+<format>
+\`prompt\` - The task to be completed (e.g., "organize my desktop files")
+\`context\` - Execution context object (e.g., { cwd: "/path/to/dir" })
+</format>
+
 <rules>
-1. First iteration: Plan workflow and initialize
-2. Subsequent iterations: Execute current step
-3. Adapt based on step results
-4. Continue until all steps complete
+1. Always provide both \`prompt\` and \`context\` parameters
+2. \`prompt\` must be a clear, actionable description
+3. \`context\` must include relevant environment info (e.g., working directory)
 </rules>`,
   /**
-   * Sampling workflow execution system prompt combining sampling with workflow capabilities
-   *
-   * Note: Sampling mode runs an internal LLM loop that autonomously executes workflows.
+   * System prompt for AI sampling loop (ai_sampling/ai_acp modes)
+   * Used inside the execution loop when AI calls native tools.
+   * Note: Tool schemas are passed via AI SDK native tool calling, not in prompt.
    */
-  SAMPLING_WORKFLOW_EXECUTION: `Workflow agent \`{toolName}\` that executes multi-step workflows autonomously.
+  AI_LOOP_SYSTEM: `Agent \`{toolName}\` that completes tasks by calling tools.
 
 <manual>
 {description}
 </manual>
 
 <rules>
-1. Return valid JSON only
-2. First iteration: Plan workflow and initialize with \`init: true\`
-3. Subsequent iterations: Execute current step
-4. Adapt based on step results
-5. Continue until all steps complete
-</rules>
-
-<format>
-Initialize workflow (first iteration):
-\`\`\`json
-{
-  "action": "{toolName}",
-  "init": true,
-  "steps": [/* workflow steps */]
-}
-\`\`\`
-
-Execute step (subsequent iterations):
-\`\`\`json
-{
-  "action": "{toolName}",
-  "decision": "proceed|retry",
-  /* step parameters */
-}
-\`\`\`
-
-Complete workflow (omit action):
-\`\`\`json
-{ "decision": "complete" }
-\`\`\`
-
-Decisions:
-- \`proceed\` = step succeeded, next step
-- \`retry\` = step failed, retry current
-- \`complete\` = workflow finished
-
-Rules:
-- Include \`steps\` ONLY with \`init: true\`
-- Omit \`steps\` during step execution
-- Use \`decision: "retry"\` for failed steps
-</format>`
-};
-var WorkflowPrompts = {
-  /**
-   * Workflow initialization instructions
-   */
-  WORKFLOW_INIT: `Workflow initialized with {stepCount} steps. Execute step 1: \`{currentStepDescription}\`
-
-Schema: {schemaDefinition}
-
-Call \`{toolName}\` with:
-- Parameters matching schema above
-- \`decision: "proceed"\` to advance, \`"retry"\` to retry, \`"complete"\` when done
-- Omit \`steps\` (only used with \`init: true\`)
-
-{workflowSteps}`,
-  /**
-   * Tool description enhancement for workflow mode
-   */
-  WORKFLOW_TOOL_DESCRIPTION: `{description}
-{initTitle}
-{ensureStepActions}
-{schemaDefinition}`,
-  /**
-   * Planning instructions for predefined workflows
-   */
-  PREDEFINED_WORKFLOW_PLANNING: `- Set \`init: true\` (steps are predefined)`,
-  /**
-   * Planning instructions for dynamic workflows
-   */
-  DYNAMIC_WORKFLOW_PLANNING: `- Set \`init: true\` and define complete \`steps\` array`,
-  /**
-   * Next step decision prompt
-   */
-  NEXT_STEP_DECISION: `Previous step completed.
-
-Choose action:
-- RETRY: Call \`{toolName}\` with \`decision: "retry"\`
-- PROCEED: Call \`{toolName}\` with \`decision: "proceed"\` and parameters below
-
-Next: \`{nextStepDescription}\`
-{nextStepSchema}
-
-(Omit \`steps\` parameter)`,
-  /**
-   * Final step completion prompt
-   */
-  FINAL_STEP_COMPLETION: `Final step executed {statusIcon} - {statusText}
-
-Choose:
-- RETRY: \`decision: "retry"\`
-- COMPLETE: \`decision: "complete"\`
-- NEW: \`init: true\`{newWorkflowInstructions}`,
-  /**
-   * Workflow completion success message
-   */
-  WORKFLOW_COMPLETED: `Workflow completed ({totalSteps} steps)
-
-Start new workflow: \`{toolName}\` with \`init: true\`{newWorkflowInstructions}`,
-  /**
-   * Error messages
-   */
-  ERRORS: {
-    NOT_INITIALIZED: {
-      WITH_PREDEFINED: "Error: Workflow not initialized. Please provide 'init' parameter to start a new workflow.",
-      WITHOUT_PREDEFINED: "Error: Workflow not initialized. Please provide 'init' and 'steps' parameter to start a new workflow."
-    },
-    ALREADY_AT_FINAL: "Error: Cannot proceed, already at the final step.",
-    CANNOT_COMPLETE_NOT_AT_FINAL: "Error: Cannot complete workflow - you are not at the final step. Please use decision=proceed to continue to the next step.",
-    NO_STEPS_PROVIDED: "Error: No steps provided",
-    NO_CURRENT_STEP: "Error: No current step to execute"
-  }
+{rules}
+</rules>{context}`
 };
 var ResponseTemplates = {
   /**
@@ -8021,9 +7772,6 @@ Next: Execute \`{nextAction}\` by calling \`{toolName}\` 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
    */
@@ -8042,78 +7790,116 @@ Fix parameters and call with \`decision: "retry"\``,
 };
 var CompiledPrompts = {
   autonomousExecution: p(SystemPrompts.AUTONOMOUS_EXECUTION),
-  workflowExecution: p(SystemPrompts.WORKFLOW_EXECUTION),
-  samplingExecution: p(SystemPrompts.SAMPLING_EXECUTION),
-  samplingExecutionTools: p(SystemPrompts.SAMPLING_EXECUTION_TOOLS),
   samplingToolDescription: p(SystemPrompts.SAMPLING_TOOL_DESCRIPTION),
-  samplingWorkflowExecution: p(SystemPrompts.SAMPLING_WORKFLOW_EXECUTION),
-  samplingWorkflowExecutionTools: p(SystemPrompts.SAMPLING_WORKFLOW_EXECUTION_TOOLS),
-  workflowInit: p(WorkflowPrompts.WORKFLOW_INIT),
-  workflowToolDescription: p(WorkflowPrompts.WORKFLOW_TOOL_DESCRIPTION),
-  nextStepDecision: p(WorkflowPrompts.NEXT_STEP_DECISION),
-  finalStepCompletion: p(WorkflowPrompts.FINAL_STEP_COMPLETION),
-  workflowCompleted: p(WorkflowPrompts.WORKFLOW_COMPLETED),
+  aiLoopSystem: p(SystemPrompts.AI_LOOP_SYSTEM),
   actionSuccess: p(ResponseTemplates.ACTION_SUCCESS),
   planningPrompt: p(ResponseTemplates.PLANNING_PROMPT),
   errorResponse: p(ResponseTemplates.ERROR_RESPONSE),
-  workflowErrorResponse: p(ResponseTemplates.WORKFLOW_ERROR_RESPONSE),
   securityPassed: p(ResponseTemplates.SECURITY_VALIDATION.PASSED),
   securityFailed: p(ResponseTemplates.SECURITY_VALIDATION.FAILED),
   auditLog: p(ResponseTemplates.AUDIT_LOG),
   completionMessage: () => ResponseTemplates.COMPLETION_MESSAGE
 };
-var PromptUtils = {
-  /**
-   * Generate tool list for descriptions
-   */
-  generateToolList: (tools) => {
-    return tools.filter((tool2) => !tool2.hide).map((tool2) => `<tool name="${tool2.name}"${tool2.description ? ` description="${tool2.description}"` : ""}/>`).join("\n");
-  },
-  /**
-   * Generate hidden tool list for descriptions
-   */
-  generateHiddenToolList: (tools) => {
-    return tools.filter((tool2) => tool2.hide).map((tool2) => `<tool name="${tool2.name}" hide/>`).join("\n");
-  },
-  /**
-   * Format workflow steps for display
-   */
-  formatWorkflowSteps: (steps) => {
-    if (!steps.length) return "";
-    return `## Workflow Steps
-${JSON.stringify(steps, null, 2)}`;
-  },
-  /**
-   * Format workflow progress display with status icons
-   */
-  formatWorkflowProgress: (progressData) => {
-    const statusIcons = {
-      pending: "[PENDING]",
-      running: "[RUNNING]",
-      completed: "[DONE]",
-      failed: "[FAILED]"
-    };
-    return progressData.steps.map((step, index) => {
-      const status = progressData.statuses[index] || "pending";
-      const icon = statusIcons[status] || "[PENDING]";
-      const current = index === progressData.currentStepIndex ? " **[CURRENT]**" : "";
-      const actions = step.actions.length > 0 ? ` | Action: ${step.actions.join(", ")}` : "";
-      return `${icon} **Step ${index + 1}:** ${step.description}${actions}${current}`;
-    }).join("\n");
-  },
-  /**
-   * Generate user info for audit logs
-   */
-  formatUserInfo: (user) => {
-    return user ? ` by ${user}` : "";
-  },
-  /**
-   * Format timestamp for logs
-   */
-  formatTimestamp: () => {
-    return (/* @__PURE__ */ new Date()).toISOString();
-  }
-};
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/factories/args-def-factory.js
+function createArgsDefFactory(_name, _allToolNames, _depGroups, _predefinedSteps, _ensureStepActions) {
+  return {
+    forSampling: function() {
+      return {
+        type: "object",
+        description: "Provide prompt for autonomous tool execution",
+        properties: {
+          prompt: {
+            type: "string",
+            description: "The task to be completed autonomously by the agentic system using available tools"
+          },
+          context: {
+            type: "object",
+            description: "Execution context, e.g., { cwd: '/path/to/dir' }. Any relevant fields allowed.",
+            additionalProperties: true
+          }
+        },
+        required: [
+          "prompt",
+          "context"
+        ],
+        errorMessage: {
+          required: {
+            prompt: "Missing required field 'prompt'. Please provide a clear task description.",
+            context: "Missing required field 'context'. Please provide relevant context (e.g., { cwd: '...' })."
+          }
+        }
+      };
+    },
+    /**
+     * Agentic schema - simplified Unix-style interface
+     *
+     * Only two fields:
+     * - `tool`: which tool to execute (enum includes "man" + all tool names)
+     * - `args`: object with parameters. For "man": { tools: ["a", "b"] }. For others: tool parameters.
+     */
+    forAgentic: function(allToolNames) {
+      const toolEnum = [
+        "man",
+        ...allToolNames
+      ];
+      return {
+        type: "object",
+        properties: {
+          tool: {
+            type: "string",
+            enum: toolEnum,
+            description: 'Which tool to execute. Use "man" to get tool schemas, or a tool name to execute.',
+            errorMessage: {
+              enum: `Invalid tool. Available: ${toolEnum.join(", ")}`
+            }
+          },
+          args: {
+            type: "object",
+            description: `For "man": { tools: ["tool1", "tool2"] }. For other tools: tool parameters that strictly adhere to the tool's JSON schema.`
+          }
+        },
+        required: [
+          "tool"
+        ],
+        additionalProperties: false
+      };
+    },
+    /**
+     * Schema for "man" command args validation
+     * Expected format: { tools: ["tool1", "tool2"] }
+     */
+    forMan: function(allToolNames) {
+      return {
+        type: "object",
+        properties: {
+          tools: {
+            type: "array",
+            items: {
+              type: "string",
+              enum: allToolNames,
+              errorMessage: {
+                enum: `Invalid tool name. Available: ${allToolNames.join(", ")}`
+              }
+            },
+            minItems: 1,
+            errorMessage: {
+              minItems: "At least one tool name is required"
+            }
+          }
+        },
+        required: [
+          "tools"
+        ],
+        errorMessage: {
+          required: {
+            tools: 'Missing "tools" field. Expected: { tools: ["tool1", "tool2"] }'
+          }
+        }
+      };
+    }
+  };
+}
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/schema-validator.js
 var import_ajv2 = require("ajv");
@@ -8122,13 +7908,14 @@ var import_ajv_errors = __toESM(require("ajv-errors"), 1);
 var import_ajv_human_errors = require("@segment/ajv-human-errors");
 var ajv = new import_ajv2.Ajv({
   allErrors: true,
-  verbose: true
+  verbose: true,
+  strict: false
 });
 import_ajv_formats2.default.default(ajv);
 import_ajv_errors.default.default(ajv);
-function validateSchema(args, schema) {
+function validateSchema(data, schema) {
   const validate = ajv.compile(schema);
-  if (!validate(args)) {
+  if (!validate(data)) {
     const errors = validate.errors;
     const customErrors = errors.filter((err) => err.keyword === "errorMessage");
     if (customErrors.length > 0) {
@@ -8225,17 +8012,17 @@ var AgenticExecutor = class {
   allToolNames;
   toolNameToDetailList;
   server;
-  USE_TOOL_KEY;
   logger;
   tracingEnabled;
-  constructor(name, allToolNames, toolNameToDetailList, server, USE_TOOL_KEY = "useTool") {
+  toolSchemaMap;
+  constructor(name, allToolNames, toolNameToDetailList, server) {
     this.name = name;
     this.allToolNames = allToolNames;
     this.toolNameToDetailList = toolNameToDetailList;
     this.server = server;
-    this.USE_TOOL_KEY = USE_TOOL_KEY;
     this.tracingEnabled = false;
     this.logger = createLogger(`mcpc.agentic.${name}`, server);
+    this.toolSchemaMap = new Map(toolNameToDetailList);
     try {
       this.tracingEnabled = import_node_process7.default.env.MCPC_TRACING_ENABLED === "true";
       if (this.tracingEnabled) {
@@ -8253,7 +8040,7 @@ var AgenticExecutor = class {
   async execute(args, schema, parentSpan) {
     const executeSpan = this.tracingEnabled ? startSpan("mcpc.agentic_execute", {
       agent: this.name,
-      selectTool: String(args[this.USE_TOOL_KEY] ?? "unknown"),
+      tool: String(args.tool ?? "unknown"),
       args: JSON.stringify(args)
     }, parentSpan ?? void 0) : null;
     try {
@@ -8268,7 +8055,7 @@ var AgenticExecutor = class {
         }
         this.logger.warning({
           message: "Validation failed",
-          selectTool: args[this.USE_TOOL_KEY],
+          tool: args.tool,
           error: validationResult.error
         });
         return {
@@ -8283,1852 +8070,237 @@ var AgenticExecutor = class {
           isError: true
         };
       }
-      const useTool = args[this.USE_TOOL_KEY];
-      const definitionsOf = args.definitionsOf || [];
-      const hasDefinitions = args.hasDefinitions || [];
-      if (!useTool) {
-        if (executeSpan) {
-          executeSpan.setAttributes({
-            toolType: "none",
-            completion: true
-          });
-          endSpan(executeSpan);
-        }
-        const result = {
-          content: []
-        };
-        this.appendToolSchemas(result, definitionsOf, hasDefinitions);
-        if (result.content.length === 0 && definitionsOf.length > 0) {
-          result.content.push({
-            type: "text",
-            text: `All requested tool schemas are already in hasDefinitions. You can now call a tool using "${this.USE_TOOL_KEY}".`
-          });
+      const tool2 = args.tool;
+      if (tool2 === "man") {
+        const createArgsDef = createArgsDefFactory(this.name, this.allToolNames, {});
+        const manSchema = createArgsDef.forMan(this.allToolNames);
+        const manValidation = validateSchema(args.args ?? {}, manSchema);
+        if (!manValidation.valid) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Invalid args for "man": ${manValidation.error}`
+              }
+            ],
+            isError: true
+          };
         }
-        return result;
+        const argsObj = args.args;
+        return this.handleManCommand(argsObj.tools, executeSpan);
       }
+      const toolArgs = args.args || {};
+      return await this.executeTool(tool2, toolArgs, executeSpan);
+    } catch (error) {
       if (executeSpan) {
-        try {
-          const safeTool = String(useTool).replace(/\s+/g, "_");
-          if (typeof executeSpan.updateName === "function") {
-            executeSpan.updateName(`mcpc.agentic_execute.${safeTool}`);
-          }
-        } catch {
-        }
+        endSpan(executeSpan, error);
       }
-      const currentTool = this.toolNameToDetailList.find(([name, _detail]) => name === useTool)?.[1];
-      if (currentTool) {
-        if (executeSpan) {
-          executeSpan.setAttributes({
-            toolType: "external",
-            selectedTool: useTool
-          });
-        }
-        this.logger.debug({
-          message: "Executing external tool",
-          selectTool: useTool
-        });
-        const currentResult = await currentTool.execute({
-          ...args[useTool]
-        });
-        this.appendToolSchemas(currentResult, definitionsOf, hasDefinitions);
-        if (executeSpan) {
-          executeSpan.setAttributes({
-            success: true,
-            isError: !!currentResult.isError,
-            resultContentLength: currentResult.content?.length || 0,
-            toolResult: JSON.stringify(currentResult)
-          });
-          endSpan(executeSpan);
-        }
-        return currentResult;
-      }
-      if (this.allToolNames.includes(useTool)) {
-        if (executeSpan) {
-          executeSpan.setAttributes({
-            toolType: "internal",
-            selectedTool: useTool
-          });
-        }
-        this.logger.debug({
-          message: "Executing internal tool",
-          selectTool: useTool
-        });
-        try {
-          const result = await this.server.callTool(useTool, args[useTool]);
-          const callToolResult = result ?? {
-            content: []
-          };
-          this.appendToolSchemas(callToolResult, definitionsOf, hasDefinitions);
-          if (executeSpan) {
-            executeSpan.setAttributes({
-              success: true,
-              isError: !!callToolResult.isError,
-              resultContentLength: callToolResult.content?.length || 0,
-              toolResult: JSON.stringify(callToolResult)
-            });
-            endSpan(executeSpan);
-          }
-          return callToolResult;
-        } catch (error) {
-          if (executeSpan) {
-            endSpan(executeSpan, error);
-          }
-          this.logger.error({
-            message: "Error executing internal tool",
-            useTool,
-            error: String(error)
-          });
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error executing internal tool ${useTool}: ${error instanceof Error ? error.message : String(error)}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
-      if (executeSpan) {
-        executeSpan.setAttributes({
-          toolType: "not_found",
-          useTool
-        });
-        endSpan(executeSpan);
-      }
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Tool "${useTool}" not found. Available tools: ${this.allToolNames.join(", ")}.`
-          }
-        ],
-        isError: true
-      };
-    } catch (error) {
-      if (executeSpan) {
-        endSpan(executeSpan, error);
-      }
-      this.logger.error({
-        message: "Unexpected error in execute",
-        error: String(error)
-      });
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Unexpected error: ${error instanceof Error ? error.message : String(error)}`
-          }
-        ],
-        isError: true
-      };
-    }
-  }
-  // Append tool schemas to result if requested
-  appendToolSchemas(result, definitionsOf, hasDefinitions) {
-    const schemasToProvide = definitionsOf.filter((toolName) => !hasDefinitions.includes(toolName));
-    if (schemasToProvide.length === 0) {
-      return;
-    }
-    const definitionTexts = [];
-    for (const toolName of schemasToProvide) {
-      const toolDetail = this.toolNameToDetailList.find(([name]) => name === toolName);
-      if (toolDetail) {
-        const [name, schema] = toolDetail;
-        const schemaJson = JSON.stringify(schema, null, 2);
-        definitionTexts.push(`<tool_definition name="${name}">
-${schemaJson}
-</tool_definition>`);
-      }
-    }
-    if (definitionTexts.length > 0) {
-      result.content.push({
-        type: "text",
-        text: `${definitionTexts.join("\n\n")}`
-      });
-    }
-  }
-  // Validate arguments using JSON schema
-  validate(args, schema) {
-    return validateSchema(args, schema);
-  }
-};
-
-// __mcpc__cli_latest/node_modules/@jsr/es-toolkit__es-toolkit/src/function/partial.js
-function partial(func, ...partialArgs) {
-  return partialImpl(func, placeholderSymbol, ...partialArgs);
-}
-function partialImpl(func, placeholder, ...partialArgs) {
-  const partialed = function(...providedArgs) {
-    let providedArgsIndex = 0;
-    const substitutedArgs = partialArgs.slice().map((arg) => arg === placeholder ? providedArgs[providedArgsIndex++] : arg);
-    const remainingArgs = providedArgs.slice(providedArgsIndex);
-    return func.apply(this, substitutedArgs.concat(remainingArgs));
-  };
-  if (func.prototype) {
-    partialed.prototype = Object.create(func.prototype);
-  }
-  return partialed;
-}
-var placeholderSymbol = Symbol("partial.placeholder");
-partial.placeholder = placeholderSymbol;
-
-// __mcpc__cli_latest/node_modules/@jsr/es-toolkit__es-toolkit/src/function/partialRight.js
-function partialRight(func, ...partialArgs) {
-  return partialRightImpl(func, placeholderSymbol2, ...partialArgs);
-}
-function partialRightImpl(func, placeholder, ...partialArgs) {
-  const partialedRight = function(...providedArgs) {
-    const placeholderLength = partialArgs.filter((arg) => arg === placeholder).length;
-    const rangeLength = Math.max(providedArgs.length - placeholderLength, 0);
-    const remainingArgs = providedArgs.slice(0, rangeLength);
-    let providedArgsIndex = rangeLength;
-    const substitutedArgs = partialArgs.slice().map((arg) => arg === placeholder ? providedArgs[providedArgsIndex++] : arg);
-    return func.apply(this, remainingArgs.concat(substitutedArgs));
-  };
-  if (func.prototype) {
-    partialedRight.prototype = Object.create(func.prototype);
-  }
-  return partialedRight;
-}
-var placeholderSymbol2 = Symbol("partialRight.placeholder");
-partialRight.placeholder = placeholderSymbol2;
-
-// __mcpc__cli_latest/node_modules/@jsr/es-toolkit__es-toolkit/src/function/retry.js
-var DEFAULT_RETRIES = Number.POSITIVE_INFINITY;
-
-// __mcpc__cli_latest/node_modules/@jsr/es-toolkit__es-toolkit/src/object/pick.js
-function pick(obj, keys) {
-  const result = {};
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    if (Object.hasOwn(obj, key)) {
-      result[key] = obj[key];
-    }
-  }
-  return result;
-}
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/factories/args-def-factory.js
-var DECISION_OPTIONS = {
-  RETRY: "retry",
-  PROCEED: "proceed",
-  COMPLETE: "complete"
-};
-function createArgsDefFactory(name, allToolNames, depGroups, predefinedSteps, ensureStepActions) {
-  const formatEnsureStepActions = () => {
-    if (!ensureStepActions || ensureStepActions.length === 0) {
-      return "";
-    }
-    return `
-
-## Required Actions
-The workflow MUST include at least one of these actions:
-${ensureStepActions.map((action) => `- \`${action}\``).join("\n")}`;
-  };
-  return {
-    common: (extra, optionalFields = []) => {
-      const requiredFields = Object.keys(extra).filter((key) => !optionalFields.includes(key));
-      return {
-        type: "object",
-        description: `**Tool parameters dynamically update per workflow step**`,
-        properties: {
-          ...extra
-        },
-        required: requiredFields
-      };
-    },
-    steps: () => ({
-      type: "array",
-      description: `
-Workflow step definitions - provide ONLY on initial call.
-
-**CRITICAL RULES:**
-- **Sequential Dependency:** If Action B depends on Action A's result \u2192 separate steps
-- **Concurrent Actions:** Independent actions can share one step  
-- **Complete Mapping:** Include ALL requested operations
-- **Predefined Steps:** Leave unspecified if predefined steps exist
-
-**BEST PRACTICES:**
-- Atomic, focused steps
-- Idempotent actions for safe retries
-- Clear step descriptions with input/output context`,
-      items: {
-        type: "object",
-        description: `A single step containing actions that execute concurrently. All actions in this step run simultaneously with no guaranteed order.`,
-        properties: {
-          description: {
-            type: "string",
-            description: `**Step purpose, required inputs, and expected outputs**`
-          },
-          actions: {
-            type: "array",
-            description: `Array of action names for this step. **CURRENT LIMITATION: Only 1 action per step is allowed.** Action names must match available tool names exactly.`,
-            items: {
-              ...{
-                enum: allToolNames
-              },
-              type: "string",
-              description: `Individual action name from available tools. Must be exactly one of the allowed tool names.`
-            },
-            uniqueItems: true,
-            minItems: 0,
-            // TODO: remove this restriction when workflow planning is good enough
-            maxItems: 1
-          }
-        },
-        required: [
-          "description",
-          "actions"
-        ],
-        additionalProperties: false
-      },
-      default: predefinedSteps ? predefinedSteps : void 0,
-      minItems: 1
-    }),
-    init: () => ({
-      type: "boolean",
-      description: `Init a new workflow`,
-      enum: [
-        true
-      ]
-    }),
-    decision: () => ({
-      type: "string",
-      enum: Object.values(DECISION_OPTIONS),
-      description: `**Step control: \`${DECISION_OPTIONS.PROCEED}\` = next step, \`${DECISION_OPTIONS.RETRY}\` = retry/repeat current, \`${DECISION_OPTIONS.COMPLETE}\` = finish workflow**`,
-      errorMessage: {
-        enum: `Invalid decision. Must be one of: ${Object.values(DECISION_OPTIONS).join(", ")}.`
-      }
-    }),
-    action: () => ({
-      type: "string",
-      description: "Define the current workflow action to be performed",
-      enum: allToolNames,
-      required: [
-        "action"
-      ],
-      errorMessage: {
-        enum: `Invalid action. Must be one of: ${allToolNames.join(", ")}.`
-      }
-    }),
-    forTool: function() {
-      return this.common({});
-    },
-    forCurrentState: function(state) {
-      const currentStep = state.getCurrentStep();
-      if (!state.isWorkflowInitialized() || !currentStep) {
-        state.reset();
-        const initSchema = {
-          init: this.init()
-        };
-        if (!predefinedSteps) {
-          initSchema.steps = this.steps();
-        }
-        return this.common(initSchema);
-      }
-      const stepDependencies = {
-        ...pick(depGroups, currentStep.actions)
-      };
-      stepDependencies["decision"] = this.decision();
-      stepDependencies["action"] = this.action();
-      return this.common(stepDependencies);
-    },
-    forSampling: function() {
-      return {
-        type: "object",
-        description: "Provide user request for autonomous tool execution",
-        properties: {
-          userRequest: {
-            type: "string",
-            description: "The task or request that should be completed autonomously by the agentic system using available tools"
-          },
-          context: {
-            type: "object",
-            description: "Necessary context for the request, e.g., the absolute path of the current working directory. This is just an example; any relevant context fields are allowed.",
-            additionalProperties: true
-          }
-        },
-        required: [
-          "userRequest",
-          "context"
-        ],
-        errorMessage: {
-          required: {
-            userRequest: "Missing required field 'userRequest'. Please provide a clear task description.",
-            context: "Missing required field 'context'. Please provide relevant context (e.g., current working directory)."
-          }
-        }
-      };
-    },
-    forAgentic: function(toolNameToDetailList, _sampling = false, USE_TOOL_KEY = "useTool") {
-      const allOf = [
-        // When a specific tool is selected, its parameters must be provided
-        ...toolNameToDetailList.map(([toolName, _toolDetail]) => {
-          return {
-            if: {
-              properties: {
-                [USE_TOOL_KEY]: {
-                  const: toolName
-                }
-              },
-              required: [
-                USE_TOOL_KEY
-              ]
-            },
-            then: {
-              required: [
-                toolName
-              ],
-              errorMessage: {
-                required: {
-                  [toolName]: `Tool "${toolName}" is selected but its parameters are missing. Please provide "${toolName}": { ...parameters }.`
-                }
-              }
-            }
-          };
-        })
-      ];
-      const useToolDescription = `Specifies which tool to execute from the available options. **When setting \`useTool: "example_tool"\`, you MUST also provide \`"example_tool": { ...parameters }\` with that tool's parameters**`;
-      const toolItems = allToolNames.length > 0 ? {
-        type: "string",
-        enum: allToolNames
-      } : {
-        type: "string"
-      };
-      const baseProperties = {
-        [USE_TOOL_KEY]: {
-          type: "string",
-          enum: allToolNames,
-          description: useToolDescription,
-          errorMessage: {
-            enum: `Invalid tool name. Available tools: ${allToolNames.join(", ")}.`
-          }
-        },
-        hasDefinitions: {
-          type: "array",
-          items: toolItems,
-          description: "Tool names whose schemas you already have. List all tools you have schemas for to avoid duplicate schema requests and reduce token usage."
-        },
-        definitionsOf: {
-          type: "array",
-          items: toolItems,
-          description: "Tool names whose schemas you need. Request tool schemas before calling them to understand their parameters."
-        }
-      };
-      const requiredFields = [];
-      const schema = {
-        additionalProperties: true,
-        type: "object",
-        properties: baseProperties,
-        required: requiredFields
-      };
-      if (allOf.length > 0) {
-        schema.allOf = allOf;
-      }
-      if (allToolNames.length > 0) {
-        const thenClause = {
-          required: [
-            USE_TOOL_KEY
-          ],
-          errorMessage: {
-            required: {
-              [USE_TOOL_KEY]: `No tool selected. Please specify "${USE_TOOL_KEY}" to select one of: ${allToolNames.join(", ")}. Or use "definitionsOf" with tool names to get their schemas first.`
-            }
-          }
-        };
-        Object.assign(schema, {
-          if: {
-            // definitionsOf is not provided OR is empty array
-            anyOf: [
-              {
-                not: {
-                  required: [
-                    "definitionsOf"
-                  ]
-                }
-              },
-              {
-                properties: {
-                  definitionsOf: {
-                    type: "array",
-                    maxItems: 0
-                  }
-                }
-              }
-            ]
-          },
-          then: thenClause
-        });
-      }
-      return schema;
-    },
-    forNextState: function(state) {
-      if (!state.isWorkflowInitialized() || !state.hasNextStep()) {
-        throw new Error(`Cannot get next state schema: no next step available`);
-      }
-      const currentStepIndex = state.getCurrentStepIndex();
-      const allSteps = state.getSteps();
-      const nextStep = allSteps[currentStepIndex + 1];
-      if (!nextStep) {
-        throw new Error(`Next step not found`);
-      }
-      const stepDependencies = {
-        ...pick(depGroups, nextStep.actions)
-      };
-      stepDependencies["decision"] = this.decision();
-      stepDependencies["action"] = this.action();
-      return this.common(stepDependencies);
-    },
-    forToolDescription: function(description, state) {
-      const enforceToolArgs = this.forCurrentState(state);
-      const initTitle = predefinedSteps ? `**YOU MUST execute this tool with following tool arguments to init the workflow**
-NOTE: The \`steps\` has been predefined` : `**You MUST execute this tool with following tool arguments to plan and init the workflow**`;
-      return CompiledPrompts.workflowToolDescription({
-        description,
-        initTitle,
-        ensureStepActions: formatEnsureStepActions(),
-        schemaDefinition: JSON.stringify(enforceToolArgs, null, 2)
-      });
-    },
-    forInitialStepDescription: function(steps, state) {
-      return CompiledPrompts.workflowInit({
-        stepCount: steps.length.toString(),
-        currentStepDescription: state.getCurrentStep()?.description || "",
-        toolName: name,
-        schemaDefinition: JSON.stringify(this.forCurrentState(state), null, 2),
-        // Remove redundant workflow steps display
-        workflowSteps: ""
-      });
-    }
-  };
-}
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-tool-registrar.js
-function registerAgenticTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList }) {
-  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
-  const agenticExecutor = new AgenticExecutor(name, allToolNames, toolNameToDetailList, server);
-  description = CompiledPrompts.autonomousExecution({
-    toolName: name,
-    description
-  });
-  const agenticArgsDef = createArgsDef.forAgentic(toolNameToDetailList, false);
-  const argsDef = agenticArgsDef;
-  const schema = allToolNames.length > 0 ? argsDef : {
-    type: "object",
-    properties: {}
-  };
-  server.tool(name, description, jsonSchema(createModelCompatibleJSONSchema(schema)), async (args) => {
-    return await agenticExecutor.execute(args, schema);
-  });
-}
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/mode-agentic-plugin.js
-var createAgenticModePlugin = () => ({
-  name: "mode-agentic",
-  version: "1.0.0",
-  // Only apply to agentic mode
-  apply: "agentic",
-  // Register the agent tool
-  registerAgentTool: (context2) => {
-    registerAgenticTool(context2.server, {
-      description: context2.description,
-      name: context2.name,
-      allToolNames: context2.allToolNames,
-      depGroups: context2.depGroups,
-      toolNameToDetailList: context2.toolNameToDetailList
-    });
-  }
-});
-var mode_agentic_plugin_default = createAgenticModePlugin();
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/state.js
-var WorkflowState = class {
-  currentStepIndex = -1;
-  steps = [];
-  stepStatuses = [];
-  stepResults = [];
-  stepErrors = [];
-  isInitialized = false;
-  isStarted = false;
-  constructor(steps) {
-    if (steps) {
-      this.initialize(steps);
-    }
-  }
-  getCurrentStepIndex() {
-    return this.currentStepIndex;
-  }
-  getSteps() {
-    return this.steps;
-  }
-  isWorkflowInitialized() {
-    return this.isInitialized;
-  }
-  getCurrentStep() {
-    if (!this.isInitialized || this.currentStepIndex < 0) {
-      return null;
-    }
-    return this.steps[this.currentStepIndex] || null;
-  }
-  getNextStep() {
-    if (!this.isInitialized) return null;
-    const nextIndex = this.currentStepIndex + 1;
-    return this.steps[nextIndex] || null;
-  }
-  // Get the previous step in the workflow
-  getPreviousStep() {
-    if (!this.isInitialized) return null;
-    const prevIndex = this.currentStepIndex - 1;
-    return this.steps[prevIndex] || null;
-  }
-  hasNextStep() {
-    return this.getNextStep() !== null;
-  }
-  // Check if there is a previous step available
-  hasPreviousStep() {
-    return this.getPreviousStep() !== null;
-  }
-  // Check if currently at the first step
-  isAtFirstStep() {
-    return this.isInitialized && this.currentStepIndex === 0;
-  }
-  // Check if currently at the last step
-  isAtLastStep() {
-    return this.isInitialized && this.currentStepIndex >= this.steps.length - 1;
-  }
-  isWorkflowStarted() {
-    return this.isStarted;
-  }
-  isCompleted() {
-    return this.isInitialized && this.currentStepIndex > this.steps.length - 1;
-  }
-  // Mark workflow as completed by moving beyond the last step
-  markCompleted() {
-    if (this.isInitialized) {
-      this.currentStepIndex = this.steps.length;
-    }
-  }
-  initialize(steps) {
-    this.steps = steps;
-    this.stepStatuses = new Array(steps.length).fill("pending");
-    this.stepResults = new Array(steps.length).fill("");
-    this.stepErrors = new Array(steps.length).fill("");
-    this.currentStepIndex = 0;
-    this.isInitialized = true;
-    this.isStarted = false;
-  }
-  // Mark current step as running
-  markCurrentStepRunning() {
-    if (this.isInitialized && this.currentStepIndex >= 0 && this.currentStepIndex < this.steps.length) {
-      this.stepStatuses[this.currentStepIndex] = "running";
-    }
-  }
-  // Mark current step as completed
-  markCurrentStepCompleted(result) {
-    if (this.isInitialized && this.currentStepIndex >= 0 && this.currentStepIndex < this.steps.length) {
-      this.stepStatuses[this.currentStepIndex] = "completed";
-      if (result) {
-        this.stepResults[this.currentStepIndex] = result;
-      }
-    }
-  }
-  // Mark current step as failed
-  markCurrentStepFailed(error) {
-    if (this.isInitialized && this.currentStepIndex >= 0 && this.currentStepIndex < this.steps.length) {
-      this.stepStatuses[this.currentStepIndex] = "failed";
-      if (error) {
-        this.stepErrors[this.currentStepIndex] = error;
-      }
-    }
-  }
-  // Get steps with their status
-  getStepsWithStatus() {
-    return this.steps.map((step, index) => ({
-      ...step,
-      status: this.stepStatuses[index] || "pending",
-      result: this.stepResults[index] || void 0,
-      error: this.stepErrors[index] || void 0
-    }));
-  }
-  // Get basic workflow progress data for template rendering
-  getProgressData() {
-    return {
-      steps: this.steps,
-      statuses: this.stepStatuses,
-      results: this.stepResults,
-      errors: this.stepErrors,
-      currentStepIndex: this.currentStepIndex,
-      totalSteps: this.steps.length
-    };
-  }
-  start() {
-    this.isStarted = true;
-  }
-  moveToNextStep() {
-    if (!this.hasNextStep()) {
-      return false;
-    }
-    this.currentStepIndex++;
-    return true;
-  }
-  // Move to the previous step in the workflow
-  moveToPreviousStep() {
-    if (!this.hasPreviousStep()) {
-      return false;
-    }
-    this.currentStepIndex--;
-    return true;
-  }
-  // Move to a specific step by index (optional feature)
-  moveToStep(stepIndex) {
-    if (!this.isInitialized || stepIndex < 0 || stepIndex >= this.steps.length) {
-      return false;
-    }
-    this.currentStepIndex = stepIndex;
-    return true;
-  }
-  reset() {
-    this.currentStepIndex = -1;
-    this.steps = [];
-    this.stepStatuses = [];
-    this.stepResults = [];
-    this.stepErrors = [];
-    this.isInitialized = false;
-    this.isStarted = false;
-  }
-  getDebugInfo() {
-    return {
-      currentStepIndex: this.currentStepIndex,
-      totalSteps: this.steps.length,
-      isInitialized: this.isInitialized,
-      currentStep: this.getCurrentStep()?.description,
-      nextStep: this.getNextStep()?.description,
-      previousStep: this.getPreviousStep()?.description,
-      isAtFirstStep: this.isAtFirstStep(),
-      hasPreviousStep: this.hasPreviousStep()
-    };
-  }
-};
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-executor.js
-var WorkflowExecutor = class {
-  name;
-  allToolNames;
-  toolNameToDetailList;
-  createArgsDef;
-  server;
-  predefinedSteps;
-  ensureStepActions;
-  toolNameToIdMapping;
-  constructor(name, allToolNames, toolNameToDetailList, createArgsDef, server, predefinedSteps, ensureStepActions, toolNameToIdMapping) {
-    this.name = name;
-    this.allToolNames = allToolNames;
-    this.toolNameToDetailList = toolNameToDetailList;
-    this.createArgsDef = createArgsDef;
-    this.server = server;
-    this.predefinedSteps = predefinedSteps;
-    this.ensureStepActions = ensureStepActions;
-    this.toolNameToIdMapping = toolNameToIdMapping;
-  }
-  // Helper method to validate required actions are present in workflow steps
-  validateRequiredActions(steps) {
-    if (!this.ensureStepActions || this.ensureStepActions.length === 0) {
-      return {
-        valid: true,
-        missing: []
-      };
-    }
-    const allStepActions = /* @__PURE__ */ new Set();
-    steps.forEach((step) => {
-      step.actions.forEach((action) => allStepActions.add(action));
-    });
-    const missing = [];
-    for (const requiredAction of this.ensureStepActions) {
-      if (allStepActions.has(requiredAction)) {
-        continue;
-      }
-      if (this.toolNameToIdMapping) {
-        const mappedToolId = this.toolNameToIdMapping.get(requiredAction);
-        if (mappedToolId && allStepActions.has(mappedToolId)) {
-          continue;
-        }
-      }
-      missing.push(requiredAction);
-    }
-    return {
-      valid: missing.length === 0,
-      missing
-    };
-  }
-  // Helper method to format workflow progress
-  formatProgress(state) {
-    const progressData = state.getProgressData();
-    return PromptUtils.formatWorkflowProgress(progressData);
-  }
-  async execute(args, state) {
-    if (args.init) {
-      state.reset();
-    } else {
-      if (!state.isWorkflowInitialized() && !args.init) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: this.predefinedSteps ? WorkflowPrompts.ERRORS.NOT_INITIALIZED.WITH_PREDEFINED : WorkflowPrompts.ERRORS.NOT_INITIALIZED.WITHOUT_PREDEFINED
-            }
-          ],
-          isError: true
-        };
-      }
-      const decision2 = args.decision;
-      if (decision2 === "proceed") {
-        if (state.isAtLastStep() && state.isWorkflowStarted()) {
-          state.markCompleted();
-          return {
-            content: [
-              {
-                type: "text",
-                text: `## Workflow Completed!
-
-${this.formatProgress(state)}
-
-${CompiledPrompts.workflowCompleted({
-                  totalSteps: state.getSteps().length,
-                  toolName: this.name,
-                  newWorkflowInstructions: this.predefinedSteps ? "" : " and new `steps` array"
-                })}`
-              }
-            ],
-            isError: false
-          };
-        }
-        if (state.isCompleted()) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: WorkflowPrompts.ERRORS.ALREADY_AT_FINAL
-              }
-            ],
-            isError: true
-          };
-        }
-        const currentStepIndex = state.getCurrentStepIndex();
-        const wasStarted = state.isWorkflowStarted();
-        if (state.isWorkflowStarted()) {
-          state.moveToNextStep();
-        } else {
-          state.start();
-        }
-        const nextStepValidationSchema = this.createArgsDef.forCurrentState(state);
-        const nextStepValidationResult = this.validateInput(args, nextStepValidationSchema);
-        if (!nextStepValidationResult.valid) {
-          if (wasStarted) {
-            state.moveToStep(currentStepIndex);
-          } else {
-            state.moveToStep(currentStepIndex);
-          }
-          return {
-            content: [
-              {
-                type: "text",
-                text: CompiledPrompts.workflowErrorResponse({
-                  errorMessage: `Cannot proceed to next step: ${nextStepValidationResult.error || "Arguments validation failed"}`
-                })
-              }
-            ],
-            isError: true
-          };
-        }
-      } else if (decision2 === "complete") {
-        if (state.isAtLastStep() && state.isWorkflowStarted()) {
-          state.markCompleted();
-          return {
-            content: [
-              {
-                type: "text",
-                text: `## Workflow Completed!
-
-${this.formatProgress(state)}
-
-${CompiledPrompts.workflowCompleted({
-                  totalSteps: state.getSteps().length,
-                  toolName: this.name,
-                  newWorkflowInstructions: this.predefinedSteps ? "" : " and new `steps` array"
-                })}`
-              }
-            ],
-            isError: false
-          };
-        } else {
-          return {
-            content: [
-              {
-                type: "text",
-                text: WorkflowPrompts.ERRORS.CANNOT_COMPLETE_NOT_AT_FINAL
-              }
-            ],
-            isError: true
-          };
-        }
-      }
-    }
-    const decision = args.decision;
-    if (decision !== "proceed") {
-      const validationSchema = this.createArgsDef.forCurrentState(state);
-      const validationResult = this.validateInput(args, validationSchema);
-      if (!validationResult.valid) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: CompiledPrompts.workflowErrorResponse({
-                errorMessage: validationResult.error || "Arguments validation failed"
-              })
-            }
-          ],
-          isError: true
-        };
-      }
-    }
-    if (args.init) {
-      return this.initialize(args, state);
-    }
-    return await this.executeStep(args, state);
-  }
-  initialize(args, state) {
-    const steps = args.steps ?? this.predefinedSteps;
-    if (!steps || steps.length === 0) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: WorkflowPrompts.ERRORS.NO_STEPS_PROVIDED
-          }
-        ],
-        isError: true
-      };
-    }
-    const validation = this.validateRequiredActions(steps);
-    if (!validation.valid) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `## Workflow Validation Failed \u274C
-
-**Missing Required Actions:** The following actions must be included in the workflow steps:
-
-${validation.missing.map((action) => `- \`${this.toolNameToIdMapping?.get(action) ?? action}\``).join("\n")}`
-          }
-        ],
-        isError: true
-      };
-    }
-    state.initialize(steps);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `## Workflow Initialized
-${this.formatProgress(state)}
-${this.createArgsDef.forInitialStepDescription(steps, state)}`
-        }
-      ],
-      isError: false
-    };
-  }
-  async executeStep(args, state) {
-    const currentStep = state.getCurrentStep();
-    if (!currentStep) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: WorkflowPrompts.ERRORS.NO_CURRENT_STEP
-          }
-        ],
-        isError: true
-      };
-    }
-    state.markCurrentStepRunning();
-    const results = {
-      content: [],
-      isError: false
-    };
-    for (const action of currentStep.actions) {
-      try {
-        const actionArgs = args[action] || {};
-        const actionResult = await this.server.callTool(action, actionArgs);
-        if (!results.isError) {
-          results.isError = actionResult.isError;
-        }
-        results.content = results.content.concat(actionResult.content ?? []);
-        results.content.push({
-          type: "text",
-          text: `Action \`${action}\` executed ${actionResult.isError ? "\u274C **FAILED**" : "\u2705 **SUCCESS**"}:`
-        });
-      } catch (error) {
-        results.content.push({
-          type: "text",
-          text: `${error.message}`
-        });
-        results.content.push({
-          type: "text",
-          text: `Action \`${action}\` \u274C **FAILED** with error: `
-        });
-        results.isError = true;
-      }
-    }
-    if (results.isError) {
-      state.markCurrentStepFailed("Step execution failed");
-    } else {
-      state.markCurrentStepCompleted("Step completed successfully");
-    }
-    if (state.hasNextStep()) {
-      const nextStepArgsDef = this.createArgsDef.forNextState(state);
-      results.content.push({
-        type: "text",
-        text: CompiledPrompts.nextStepDecision({
-          toolName: this.name,
-          nextStepDescription: state.getNextStep()?.description || "Unknown step",
-          nextStepSchema: JSON.stringify(nextStepArgsDef, null, 2)
-        })
-      });
-    } else {
-      results.content.push({
-        type: "text",
-        text: CompiledPrompts.finalStepCompletion({
-          statusIcon: results.isError ? "\u274C" : "\u2705",
-          statusText: results.isError ? "with errors" : "successfully",
-          toolName: this.name,
-          newWorkflowInstructions: this.predefinedSteps ? "" : " and new `steps` array"
-        })
-      });
-    }
-    results.content.push({
-      type: "text",
-      text: `## Workflow Progress
-${this.formatProgress(state)}`
-    });
-    return results;
-  }
-  // Validate arguments using JSON schema
-  validateInput(args, schema) {
-    return validateSchema(args, schema);
-  }
-};
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-tool-registrar.js
-function registerAgenticWorkflowTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList, predefinedSteps, ensureStepActions, toolNameToIdMapping }) {
-  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, predefinedSteps, ensureStepActions);
-  const workflowExecutor = new WorkflowExecutor(name, allToolNames, toolNameToDetailList, createArgsDef, server, predefinedSteps, ensureStepActions, toolNameToIdMapping);
-  const workflowState = new WorkflowState();
-  const planningInstructions = predefinedSteps ? "- Set `init: true` (steps are predefined)" : "- Set `init: true` and define complete `steps` array";
-  const baseDescription = CompiledPrompts.workflowExecution({
-    toolName: name,
-    description,
-    planningInstructions
-  });
-  const argsDef = createArgsDef.forTool();
-  const toolDescription = createArgsDef.forToolDescription(baseDescription, workflowState);
-  server.tool(name, toolDescription, jsonSchema(createModelCompatibleJSONSchema(argsDef)), async (args) => {
-    try {
-      return await workflowExecutor.execute(args, workflowState);
-    } catch (error) {
-      workflowState.reset();
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Workflow execution error: ${error.message}`
-          }
-        ],
-        isError: true
-      };
-    }
-  });
-}
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/mode-workflow-plugin.js
-var createWorkflowModePlugin = () => ({
-  name: "mode-workflow",
-  version: "1.0.0",
-  // Only apply to workflow mode
-  apply: "agentic_workflow",
-  // Register the agent tool
-  registerAgentTool: (context2) => {
-    registerAgenticWorkflowTool(context2.server, {
-      description: context2.description,
-      name: context2.name,
-      allToolNames: context2.allToolNames,
-      depGroups: context2.depGroups,
-      toolNameToDetailList: context2.toolNameToDetailList,
-      predefinedSteps: context2.options.steps,
-      ensureStepActions: context2.options.ensureStepActions,
-      toolNameToIdMapping: context2.toolNameToIdMapping
-    });
-  }
-});
-var mode_workflow_plugin_default = createWorkflowModePlugin();
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/sampling/base-sampling-executor.js
-var import_node_process8 = __toESM(require("node:process"), 1);
-var BaseSamplingExecutor = class {
-  name;
-  description;
-  allToolNames;
-  toolNameToDetailList;
-  server;
-  conversationHistory;
-  maxIterations;
-  currentIteration;
-  logger;
-  tracingEnabled;
-  summarize;
-  constructor(name, description, allToolNames, toolNameToDetailList, server, config) {
-    this.name = name;
-    this.description = description;
-    this.allToolNames = allToolNames;
-    this.toolNameToDetailList = toolNameToDetailList;
-    this.server = server;
-    this.conversationHistory = [];
-    this.maxIterations = 55;
-    this.currentIteration = 0;
-    this.tracingEnabled = false;
-    this.summarize = true;
-    if (config?.maxIterations) {
-      this.maxIterations = config.maxIterations;
-    }
-    if (config?.summarize !== void 0) {
-      this.summarize = config.summarize;
-    }
-    this.logger = createLogger(`mcpc.sampling.${name}`, server);
-    try {
-      const tracingConfig = {
-        enabled: import_node_process8.default.env.MCPC_TRACING_ENABLED === "true",
-        serviceName: `mcpc-sampling-${name}`,
-        exportTo: import_node_process8.default.env.MCPC_TRACING_EXPORT ?? "otlp",
-        otlpEndpoint: import_node_process8.default.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
-      };
-      this.tracingEnabled = tracingConfig.enabled;
-      if (this.tracingEnabled) {
-        initializeTracing(tracingConfig);
-      }
-    } catch {
-      this.tracingEnabled = false;
-    }
-  }
-  /**
-   * Convert toolNameToDetailList to MCP Tool format for sampling
-   */
-  convertToMcpTools() {
-    return this.toolNameToDetailList.map(([name, detail]) => ({
-      name,
-      description: detail.description || `Tool: ${name}`,
-      inputSchema: {
-        type: "object",
-        ...detail.inputSchema
-      }
-    }));
-  }
-  /**
-   * Check if client supports sampling with tools
-   */
-  supportsSamplingTools() {
-    const capabilities = this.server.getClientCapabilities();
-    return !!capabilities?.sampling?.tools;
-  }
-  /**
-   * Check if response contains tool use
-   */
-  isToolUseResponse(response) {
-    if (!response.content) return false;
-    const content = Array.isArray(response.content) ? response.content : [
-      response.content
-    ];
-    return content.some((block) => block.type === "tool_use");
-  }
-  /**
-   * Extract tool calls from response
-   */
-  extractToolCalls(response) {
-    if (!response.content) return [];
-    const content = Array.isArray(response.content) ? response.content : [
-      response.content
-    ];
-    return content.filter((block) => block.type === "tool_use").map((block) => "id" in block && "name" in block && "input" in block ? {
-      id: block.id,
-      name: block.name,
-      input: block.input || {}
-    } : {
-      id: "",
-      name: "",
-      input: {}
-    });
-  }
-  async runSamplingLoop(systemPrompt, schema, state) {
-    const useTools = this.supportsSamplingTools();
-    this.logger.debug({
-      message: "Sampling mode determined",
-      useTools,
-      mode: useTools ? "native_tools" : "json_fallback"
-    });
-    this.conversationHistory = [
-      {
-        // Failed: 400 {"error":{"message":"messages: at least one message is required","code":"invalid_request_body"}}
-        role: "user",
-        content: {
-          type: "text",
-          text: `start`
-        }
-      }
-    ];
-    const loopSpan = this.tracingEnabled ? startSpan("mcpc.sampling_loop", {
-      agent: this.name,
-      maxIterations: this.maxIterations,
-      systemPrompt: systemPrompt()
-    }) : null;
-    try {
-      for (this.currentIteration = 0; this.currentIteration < this.maxIterations; this.currentIteration++) {
-        let iterationSpan = null;
-        try {
-          let createMessageParams;
-          if (useTools) {
-            createMessageParams = {
-              systemPrompt: systemPrompt(),
-              messages: this.conversationHistory,
-              maxTokens: 55e3,
-              tools: this.convertToMcpTools(),
-              toolChoice: {
-                mode: "auto"
-              }
-            };
-          } else {
-            createMessageParams = {
-              systemPrompt: systemPrompt(),
-              messages: this.conversationHistory,
-              maxTokens: 55e3
-            };
-          }
-          const response = await this.server.createMessage(createMessageParams);
-          const model = response.model;
-          const stopReason = response.stopReason;
-          const role = response.role;
-          if (useTools && this.isToolUseResponse(response)) {
-            const toolCalls = this.extractToolCalls(response);
-            if (toolCalls.length === 0) {
-              const contentArray = Array.isArray(response.content) ? response.content : [
-                response.content
-              ];
-              const textBlock = contentArray.find((c) => c.type === "text");
-              const textContent2 = textBlock && "text" in textBlock ? textBlock.text : void 0;
-              if (textContent2) {
-                return await this.createCompletionResult(textContent2, loopSpan);
-              }
-              continue;
-            }
-            iterationSpan = this.tracingEnabled ? startSpan("mcpc.sampling_iteration.tool_use", {
-              iteration: this.currentIteration + 1,
-              agent: this.name,
-              toolCalls: toolCalls.length,
-              maxIterations: this.maxIterations
-            }, loopSpan ?? void 0) : null;
-            this.conversationHistory.push({
-              role: "assistant",
-              content: response.content
-            });
-            const toolResults = [];
-            for (const toolCall of toolCalls) {
-              try {
-                const result2 = await this.server.callTool(toolCall.name, toolCall.input);
-                toolResults.push({
-                  type: "tool_result",
-                  toolUseId: toolCall.id,
-                  content: result2.content || [],
-                  isError: result2.isError
-                });
-              } catch (error) {
-                toolResults.push({
-                  type: "tool_result",
-                  toolUseId: toolCall.id,
-                  content: [
-                    {
-                      type: "text",
-                      text: `Error: ${error instanceof Error ? error.message : String(error)}`
-                    }
-                  ],
-                  isError: true
-                });
-              }
-            }
-            this.conversationHistory.push({
-              role: "user",
-              content: toolResults
-            });
-            if (iterationSpan) {
-              iterationSpan.setAttributes({
-                toolExecutions: toolResults.length,
-                hasErrors: toolResults.some((r) => r.isError)
-              });
-              endSpan(iterationSpan);
-            }
-            continue;
-          }
-          const content = Array.isArray(response.content) ? response.content : [
-            response.content
-          ];
-          const textContent = content.find((c) => c.type === "text");
-          const responseContent = textContent?.text || "{}";
-          let parsedData;
-          try {
-            parsedData = parseJSON(responseContent.trim(), true);
-          } catch (parseError) {
-            iterationSpan = this.tracingEnabled ? startSpan("mcpc.sampling_iteration.parse_error", {
-              iteration: this.currentIteration + 1,
-              agent: this.name,
-              error: String(parseError),
-              maxIterations: this.maxIterations
-            }, loopSpan ?? void 0) : null;
-            this.addParsingErrorToHistory(responseContent, parseError);
-            if (iterationSpan) endSpan(iterationSpan);
-            continue;
-          }
-          this.conversationHistory.push({
-            role: "assistant",
-            content: {
-              type: "text",
-              text: JSON.stringify(parsedData, null, 2)
-            }
-          });
-          const decision = parsedData["decision"];
-          const useTool = parsedData["useTool"];
-          const actionStr = decision === "complete" ? "completion" : useTool && typeof useTool === "string" ? String(useTool) : "unknown_action";
-          const spanName = `mcpc.sampling_iteration.${actionStr}`;
-          iterationSpan = this.tracingEnabled ? startSpan(spanName, {
-            iteration: this.currentIteration + 1,
-            agent: this.name,
-            action: actionStr,
-            systemPrompt: systemPrompt(),
-            maxTokens: String(Number.MAX_SAFE_INTEGER),
-            maxIterations: this.maxIterations,
-            messages: JSON.stringify(this.conversationHistory)
-          }, loopSpan ?? void 0) : null;
-          const result = await this.processAction(parsedData, schema, state, iterationSpan);
-          this.logIterationProgress(parsedData, result, model, stopReason, role);
-          if (iterationSpan) {
-            let rawJson = "{}";
-            try {
-              rawJson = parsedData ? JSON.stringify(parsedData) : "{}";
-            } catch {
-            }
-            const attr = {
-              isError: !!result.isError,
-              isComplete: !!result.isComplete,
-              iteration: this.currentIteration + 1,
-              maxIterations: this.maxIterations,
-              parsed: rawJson,
-              action: typeof useTool === "string" ? useTool : String(useTool),
-              decision: typeof decision === "string" ? decision : String(decision),
-              samplingResponse: responseContent,
-              toolResult: JSON.stringify(result),
-              model,
-              role
-            };
-            if (stopReason) {
-              attr.stopReason = stopReason;
-            }
-            iterationSpan.setAttributes(attr);
-          }
-          if (result.isError) {
-            const errorText = result.content?.[0] && "text" in result.content[0] ? result.content[0].text : "Unknown error";
-            this.conversationHistory.push({
-              role: "user",
-              content: {
-                type: "text",
-                text: errorText
-              }
-            });
-            if (iterationSpan) endSpan(iterationSpan);
-            continue;
-          }
-          if (result.isComplete) {
-            if (iterationSpan) endSpan(iterationSpan);
-            if (loopSpan) endSpan(loopSpan);
-            return result;
-          }
-          if (iterationSpan) endSpan(iterationSpan);
-        } catch (iterError) {
-          if (iterationSpan) endSpan(iterationSpan, iterError);
-          throw iterError;
-        }
-      }
-      if (loopSpan) endSpan(loopSpan);
-      return await this.createMaxIterationsError(loopSpan);
-    } catch (error) {
-      if (loopSpan) endSpan(loopSpan, error);
-      return await this.createExecutionError(error, loopSpan);
-    }
-  }
-  addParsingErrorToHistory(_responseText, parseError) {
-    const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
-    this.conversationHistory.push({
-      role: "user",
-      content: {
-        type: "text",
-        text: `Invalid JSON: ${errorMsg}
-
-Respond with valid JSON.`
-      }
-    });
-  }
-  async createMaxIterationsError(parentSpan) {
-    const result = await this.createCompletionResult(`Reached max iterations (${this.maxIterations}). Try a more specific request.`, parentSpan);
-    result.isError = true;
-    result.isComplete = false;
-    return result;
-  }
-  async createExecutionError(error, parentSpan) {
-    const result = await this.createCompletionResult(`Execution error: ${error instanceof Error ? error.message : String(error)}`, parentSpan);
-    result.isError = true;
-    result.isComplete = false;
-    return result;
-  }
-  async createCompletionResult(text, parentSpan) {
-    const summary = this.summarize ? await this.summarizeConversation(parentSpan) : this.formatConversation();
-    return {
-      content: [
-        {
-          type: "text",
-          text: `${text}
-
-**Execution Summary:**
-- Iterations used: ${this.currentIteration + 1}/${this.maxIterations}
-- Agent: ${this.name}
-${summary}`
-        }
-      ],
-      isError: false,
-      isComplete: true
-    };
-  }
-  // Use LLM to create high-signal summary for parent agent
-  async summarizeConversation(parentSpan) {
-    if (this.conversationHistory.length === 0) {
-      return "\n\n**No conversation history**";
-    }
-    if (this.conversationHistory.length <= 3) {
-      return this.formatConversation();
-    }
-    const summarizeSpan = this.tracingEnabled ? startSpan("mcpc.sampling_summarize", {
-      agent: this.name,
-      messageCount: this.conversationHistory.length
-    }, parentSpan ?? void 0) : null;
-    try {
-      this.logger.debug({
-        message: "Starting conversation summarization",
-        messageCount: this.conversationHistory.length
-      });
-      const history = this.conversationHistory.map((msg, i) => {
-        const prefix = `[${i + 1}] ${msg.role.toUpperCase()}`;
-        const contentArray = Array.isArray(msg.content) ? msg.content : [
-          msg.content
-        ];
-        const textBlock = contentArray.find((c) => c.type === "text");
-        const text = textBlock?.text || "(No text content)";
-        return `${prefix}:
-${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 summaryContent = Array.isArray(response.content) ? response.content.find((c) => c.type === "text") : response.content;
-      const summary = "\n\n" + (summaryContent?.text || "No summary available");
-      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",
+      this.logger.error({
+        message: "Unexpected error in execute",
         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}`;
-      const contentArray = Array.isArray(msg.content) ? msg.content : [
-        msg.content
-      ];
-      const textBlock = contentArray.find((c) => c.type === "text");
-      const contentText = textBlock?.text;
-      if (!contentText) {
-        return `${header}\\n(No text content)`;
-      }
-      try {
-        const parsed = JSON.parse(contentText);
-        if (JSON.stringify(parsed).length < 100) {
-          return `${header}\\n${JSON.stringify(parsed)}`;
-        }
-        return `${header}\\n\`\`\`json\\n${JSON.stringify(parsed, null, 2)}\\n\`\`\``;
-      } catch {
-        return `${header}\\n${contentText}`;
-      }
-    });
-    return "\n\n**Conversation History:**\n" + messages.join("\n\n");
-  }
-  logIterationProgress(parsedData, result, model, stopReason, role) {
-    this.logger.debug({
-      iteration: `${this.currentIteration + 1}/${this.maxIterations}`,
-      parsedData,
-      isError: result.isError,
-      isComplete: result.isComplete,
-      model,
-      stopReason,
-      role,
-      result
-    });
-  }
-  formatPromptForMode({ prompt, schema, schemaPrefix = "JSON schema:", schemaSuffix = `STRICT REQUIREMENTS:
-1. Return ONE AND ONLY ONE raw JSON object that passes JSON.parse() - no markdown, code blocks, explanatory text, or multiple JSON objects
-2. Include ALL required fields with correct data types and satisfy ALL schema constraints (anyOf, oneOf, allOf, not, enum, pattern, min/max, conditionals)
-3. Your response must be a single JSON object, nothing else
-
-INVALID: \`\`\`json{"key":"value"}\`\`\` or "Here is: {"key":"value"}" or {"key":"value"}{"key":"value"}
-VALID: {"key":"value"}` }) {
-    if (this.supportsSamplingTools()) {
-      return prompt && prompt.length > 0 ? prompt : "";
-    }
-    return [
-      prompt != null && prompt.length > 0 ? prompt : void 0,
-      prompt != null && prompt.length > 0 ? "" : void 0,
-      schemaPrefix,
-      schema != null ? JSON.stringify(createModelCompatibleJSONSchema(schema), null, 2) : void 0,
-      schemaSuffix
-    ].filter((line) => line != null).join("\n");
-  }
-  // Validate arguments using JSON schema
-  validateInput(args, schema) {
-    return validateSchema(args, schema);
-  }
-};
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/sampling/agentic-sampling-executor.js
-var SamplingExecutor = class extends BaseSamplingExecutor {
-  agenticExecutor;
-  constructor(name, description, allToolNames, toolNameToDetailList, server, config) {
-    super(name, description, allToolNames, toolNameToDetailList, server, config);
-    this.agenticExecutor = new AgenticExecutor(name, allToolNames, toolNameToDetailList, server);
-  }
-  buildDepGroups() {
-    const depGroups = {};
-    this.toolNameToDetailList.forEach(([toolName, tool2]) => {
-      if (tool2?.inputSchema) {
-        depGroups[toolName] = {
-          type: "object",
-          description: tool2.description || `Tool: ${toolName}`,
-          ...tool2.inputSchema
-        };
-      } else {
-        const toolSchema = this.server.getHiddenToolSchema(toolName);
-        if (toolSchema) {
-          depGroups[toolName] = {
-            ...toolSchema.schema,
-            description: toolSchema.description
-          };
-        }
-      }
-    });
-    return depGroups;
-  }
-  executeSampling(args, schema) {
-    const validationResult = validateSchema(args, schema);
-    if (!validationResult.valid) {
       return {
         content: [
           {
             type: "text",
-            text: CompiledPrompts.errorResponse({
-              errorMessage: validationResult.error || "Validation failed"
-            })
+            text: `Unexpected error: ${error instanceof Error ? error.message : String(error)}`
           }
         ],
         isError: true
       };
     }
-    const createArgsDef = createArgsDefFactory(this.name, this.allToolNames, this.buildDepGroups(), void 0, void 0);
-    const agenticSchema = createArgsDef.forAgentic(this.toolNameToDetailList, true);
-    const systemPrompt = this.buildSystemPrompt(args.userRequest, agenticSchema, args.context && typeof args.context === "object" ? args.context : void 0);
-    return this.runSamplingLoop(() => systemPrompt, agenticSchema);
   }
-  async processAction(parsedData, schema, _state, parentSpan) {
-    const toolCallData = parsedData;
-    if (toolCallData.decision === "complete") {
-      return await this.createCompletionResult("Task completed", parentSpan);
+  /**
+   * Handle `man` command - return schemas for requested tools
+   * @param requestedTools - Array of tool names (already validated via JSON Schema)
+   */
+  handleManCommand(requestedTools, executeSpan) {
+    if (executeSpan) {
+      executeSpan.setAttributes({
+        toolType: "man",
+        requestedTools: requestedTools.join(",")
+      });
     }
-    try {
-      const { action: _action, decision: _decision, ..._toolArgs } = toolCallData;
-      const toolResult = await this.agenticExecutor.execute(toolCallData, schema, parentSpan);
-      const resultText = toolResult.content?.filter((content) => content.type === "text")?.map((content) => content.text)?.join("\n") || "No result";
-      this.conversationHistory.push({
-        role: "assistant",
-        content: {
+    const schemas = requestedTools.map((toolName) => {
+      const toolDetail = this.toolSchemaMap.get(toolName);
+      if (toolDetail) {
+        const cleanedSchema = cleanToolSchema(toolDetail);
+        return `<tool_definition name="${toolName}">
+${JSON.stringify(cleanedSchema, null, 2)}
+</tool_definition>`;
+      }
+      return null;
+    }).filter(Boolean);
+    if (executeSpan) {
+      executeSpan.setAttributes({
+        schemasReturned: schemas.length,
+        success: true
+      });
+      endSpan(executeSpan);
+    }
+    return {
+      content: [
+        {
           type: "text",
-          text: resultText
+          text: schemas.length > 0 ? schemas.join("\n\n") : "No schemas found for requested tools."
         }
-      });
-      return toolResult;
-    } catch (error) {
-      return this.createExecutionError(error, parentSpan);
-    }
-  }
-  buildSystemPrompt(userRequest, agenticSchema, context2) {
-    const toolList = this.allToolNames.map((name) => {
-      const tool2 = this.toolNameToDetailList.find(([toolName]) => toolName === name);
-      const toolSchema = this.server.getHiddenToolSchema(name);
-      if (tool2 && tool2[1]) {
-        return `- ${name}: ${tool2[1].description || `Tool: ${name}`}`;
-      } else if (toolSchema) {
-        return `- ${name}: ${toolSchema.description}`;
-      }
-      return `- ${name}`;
-    }).join("\n");
-    let contextInfo = "";
-    if (context2 && typeof context2 === "object" && Object.keys(context2).length > 0) {
-      contextInfo = `
-
-Context:
-${JSON.stringify(context2, null, 2)}`;
-    }
-    const basePrompt = this.supportsSamplingTools() ? CompiledPrompts.samplingExecutionTools({
-      toolName: this.name,
-      description: this.description,
-      toolList
-    }) : CompiledPrompts.samplingExecution({
-      toolName: this.name,
-      description: this.description,
-      toolList
-    });
-    const taskPrompt = `
-
-## Current Task
-You will now use agentic sampling to complete the following task: "${userRequest}"${contextInfo}
-
-When you need to use a tool, specify the tool name in 'useTool' and provide tool-specific parameters as additional properties.`;
-    return this.formatPromptForMode({
-      prompt: basePrompt + taskPrompt,
-      schema: agenticSchema
-    });
-  }
-};
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-sampling-registrar.js
-function registerAgenticSamplingTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList, samplingConfig }) {
-  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
-  const samplingExecutor = new SamplingExecutor(name, description, allToolNames, toolNameToDetailList, server, samplingConfig);
-  const toolDescription = CompiledPrompts.samplingToolDescription({
-    description,
-    toolList: allToolNames.map((name2) => `- ${name2}`).join("\n")
-  });
-  const argsDef = createArgsDef.forSampling();
-  const schema = allToolNames.length > 0 ? argsDef : {
-    type: "object",
-    properties: {}
-  };
-  server.tool(name, toolDescription, jsonSchema(createModelCompatibleJSONSchema(schema)), async (args) => {
-    return await samplingExecutor.executeSampling(args, schema);
-  });
-}
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/mode-agentic-sampling-plugin.js
-var createAgenticSamplingModePlugin = () => ({
-  name: "mode-agentic-sampling",
-  version: "1.0.0",
-  // Only apply to agentic_sampling mode
-  apply: "agentic_sampling",
-  // Register the agent tool with sampling
-  registerAgentTool: (context2) => {
-    registerAgenticSamplingTool(context2.server, {
-      description: context2.description,
-      name: context2.name,
-      allToolNames: context2.allToolNames,
-      depGroups: context2.depGroups,
-      toolNameToDetailList: context2.toolNameToDetailList,
-      samplingConfig: context2.options.samplingConfig
-    });
-  }
-});
-var mode_agentic_sampling_plugin_default = createAgenticSamplingModePlugin();
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/sampling/workflow-sampling-executor.js
-var WorkflowSamplingExecutor = class extends BaseSamplingExecutor {
-  createArgsDef;
-  predefinedSteps;
-  workflowExecutor;
-  constructor(name, description, allToolNames, toolNameToDetailList, createArgsDef, server, predefinedSteps, config) {
-    super(name, description, allToolNames, toolNameToDetailList, server, config), this.createArgsDef = createArgsDef, this.predefinedSteps = predefinedSteps;
-    this.workflowExecutor = new WorkflowExecutor(name, allToolNames, toolNameToDetailList, createArgsDef, server, predefinedSteps);
+      ]
+    };
   }
-  async executeWorkflowSampling(args, schema, state) {
-    const validationResult = validateSchema(args, schema);
-    if (!validationResult.valid) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: CompiledPrompts.workflowErrorResponse({
-              errorMessage: validationResult.error || "Validation failed"
-            })
+  /**
+   * Execute a tool with runtime validation
+   */
+  async executeTool(tool2, toolArgs, executeSpan) {
+    const externalTool = this.toolNameToDetailList.find(([name]) => name === tool2);
+    if (externalTool) {
+      const [, toolDetail] = externalTool;
+      if (executeSpan) {
+        executeSpan.setAttributes({
+          toolType: "external",
+          selectedTool: tool2
+        });
+      }
+      if (toolDetail.inputSchema) {
+        const rawSchema = extractJsonSchema(toolDetail.inputSchema);
+        const validation = validateSchema(toolArgs, rawSchema);
+        if (!validation.valid) {
+          if (executeSpan) {
+            executeSpan.setAttributes({
+              validationError: true,
+              errorMessage: validation.error
+            });
+            endSpan(executeSpan);
           }
-        ],
-        isError: true
-      };
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Parameter validation failed for "${tool2}": ${validation.error}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+      this.logger.debug({
+        message: "Executing external tool",
+        tool: tool2
+      });
+      const result = await toolDetail.execute(toolArgs);
+      if (executeSpan) {
+        executeSpan.setAttributes({
+          success: true,
+          isError: !!result.isError,
+          resultContentLength: result.content?.length || 0
+        });
+        endSpan(executeSpan);
+      }
+      return result;
     }
-    return await this.runSamplingLoop(() => this.buildWorkflowSystemPrompt(args, state), schema, state);
-  }
-  async processAction(parsedData, _schema, state, parentSpan) {
-    const workflowState = state;
-    if (!workflowState) {
-      throw new Error("WorkflowState is required for workflow");
+    if (this.allToolNames.includes(tool2)) {
+      if (executeSpan) {
+        executeSpan.setAttributes({
+          toolType: "internal",
+          selectedTool: tool2
+        });
+      }
+      this.logger.debug({
+        message: "Executing internal tool",
+        tool: tool2
+      });
+      try {
+        const result = await this.server.callTool(tool2, toolArgs);
+        const callToolResult = result ?? {
+          content: []
+        };
+        if (executeSpan) {
+          executeSpan.setAttributes({
+            success: true,
+            isError: !!callToolResult.isError,
+            resultContentLength: callToolResult.content?.length || 0
+          });
+          endSpan(executeSpan);
+        }
+        return callToolResult;
+      } catch (error) {
+        if (executeSpan) {
+          endSpan(executeSpan, error);
+        }
+        this.logger.error({
+          message: "Error executing internal tool",
+          tool: tool2,
+          error: String(error)
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error executing tool "${tool2}": ${error instanceof Error ? error.message : String(error)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-    const toolCallData = parsedData;
-    if (toolCallData.decision === "complete") {
-      return await this.createCompletionResult("Task completed", parentSpan);
+    if (executeSpan) {
+      executeSpan.setAttributes({
+        toolType: "not_found",
+        tool: tool2
+      });
+      endSpan(executeSpan);
     }
-    try {
-      const workflowResult = await this.workflowExecutor.execute(parsedData, workflowState);
-      const resultText = workflowResult.content?.filter((content) => content.type === "text")?.map((content) => content.text)?.join("\n") || "No result";
-      this.conversationHistory.push({
-        role: "assistant",
-        content: {
+    return {
+      content: [
+        {
           type: "text",
-          text: resultText
+          text: `Tool "${tool2}" not found. Available tools: ${this.allToolNames.join(", ")}`
         }
-      });
-      return workflowResult;
-    } catch (error) {
-      return this.createExecutionError(error, parentSpan);
-    }
-  }
-  buildWorkflowSystemPrompt(args, state) {
-    const workflowSchema = this.createArgsDef.forCurrentState(state);
-    const basePrompt = this.supportsSamplingTools() ? CompiledPrompts.samplingWorkflowExecutionTools({
-      toolName: this.name,
-      description: this.description,
-      workflowSchema: `${JSON.stringify(workflowSchema, null, 2)}`
-    }) : CompiledPrompts.samplingWorkflowExecution({
-      toolName: this.name,
-      description: this.description,
-      workflowSchema: `${JSON.stringify(workflowSchema, null, 2)}`
-    });
-    let contextInfo = "";
-    if (args.context && typeof args.context === "object" && Object.keys(args.context).length > 0) {
-      contextInfo = `
-
-Context:
-${JSON.stringify(args.context, null, 2)}`;
-    }
-    const workflowPrompt = `
-
-Current Task: <user_request>${args.userRequest}</user_request>${contextInfo}`;
-    return this.formatPromptForMode({
-      prompt: basePrompt + workflowPrompt,
-      schema: workflowSchema
-    });
+      ],
+      isError: true
+    };
+  }
+  validate(args, schema) {
+    return validateSchema(args, schema);
   }
 };
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/workflow/workflow-sampling-registrar.js
-function registerWorkflowSamplingTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList, predefinedSteps, samplingConfig, ensureStepActions, toolNameToIdMapping: _toolNameToIdMapping }) {
-  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, predefinedSteps, ensureStepActions);
-  const workflowSamplingExecutor = new WorkflowSamplingExecutor(name, description, allToolNames, toolNameToDetailList, createArgsDef, server, predefinedSteps, samplingConfig);
-  const workflowState = new WorkflowState();
-  const baseDescription = CompiledPrompts.samplingExecution({
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-tool-registrar.js
+function registerAgenticTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList }) {
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
+  const agenticExecutor = new AgenticExecutor(name, allToolNames, toolNameToDetailList, server);
+  description = CompiledPrompts.autonomousExecution({
     toolName: name,
-    description,
-    toolList: allToolNames.map((name2) => `- ${name2}`).join("\n")
+    description
   });
-  const argsDef = createArgsDef.forSampling();
+  const agenticArgsDef = createArgsDef.forAgentic(allToolNames);
+  const argsDef = agenticArgsDef;
   const schema = allToolNames.length > 0 ? argsDef : {
     type: "object",
     properties: {}
   };
-  server.tool(name, baseDescription, jsonSchema(createModelCompatibleJSONSchema(schema)), async (args) => {
-    try {
-      return await workflowSamplingExecutor.executeWorkflowSampling(args, schema, workflowState);
-    } catch (error) {
-      workflowState.reset();
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Workflow execution error: ${error.message}`
-          }
-        ],
-        isError: true
-      };
-    }
+  server.tool(name, description, jsonSchema(createModelCompatibleJSONSchema(schema)), async (args) => {
+    return await agenticExecutor.execute(args, schema);
   });
 }
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/mode-workflow-sampling-plugin.js
-var createWorkflowSamplingModePlugin = () => ({
-  name: "mode-agentic-workflow-sampling",
-  version: "1.0.0",
-  // Only apply to agentic_workflow_sampling mode
-  apply: "agentic_workflow_sampling",
-  // Register the agent tool with sampling
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/mode-agentic-plugin.js
+var createAgenticModePlugin = () => ({
+  name: "mode-agentic",
+  version: "2.0.0",
+  // Only apply to agentic mode
+  apply: "agentic",
+  // Register the agent tool
   registerAgentTool: (context2) => {
-    registerWorkflowSamplingTool(context2.server, {
+    registerAgenticTool(context2.server, {
       description: context2.description,
       name: context2.name,
       allToolNames: context2.allToolNames,
       depGroups: context2.depGroups,
-      toolNameToDetailList: context2.toolNameToDetailList,
-      predefinedSteps: context2.options.steps,
-      samplingConfig: context2.options.samplingConfig,
-      ensureStepActions: context2.options.ensureStepActions,
-      toolNameToIdMapping: context2.toolNameToIdMapping
+      toolNameToDetailList: context2.toolNameToDetailList
     });
   }
 });
-var mode_workflow_sampling_plugin_default = createWorkflowSamplingModePlugin();
+var mode_agentic_plugin_default = createAgenticModePlugin();
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/utils.js
 function convertAISDKToMCPMessages(prompt) {
@@ -10185,6 +8357,7 @@ function convertMCPStopReasonToAISDK(stopReason) {
 }
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/language-model.js
+var DEFAULT_MAX_TOKENS = 128e3;
 var MCPSamplingLanguageModel = class {
   specificationVersion = "v2";
   provider;
@@ -10192,11 +8365,13 @@ var MCPSamplingLanguageModel = class {
   supportedUrls = {};
   server;
   modelPreferences;
+  maxTokens;
   constructor(config) {
     this.server = config.server;
     this.modelId = "";
     this.provider = "mcp-client";
     this.modelPreferences = config.modelPreferences;
+    this.maxTokens = config.maxTokens ?? DEFAULT_MAX_TOKENS;
   }
   /**
    * Generate a response using MCP's createMessage capability
@@ -10228,7 +8403,7 @@ var MCPSamplingLanguageModel = class {
     const createMessageParams = {
       systemPrompt,
       messages,
-      maxTokens: options.maxOutputTokens ?? 55e3,
+      maxTokens: options.maxOutputTokens ?? this.maxTokens,
       modelPreferences: this.modelPreferences
     };
     if (useNativeTools && options.tools && options.tools.length > 0) {
@@ -10606,7 +8781,8 @@ var MCPSamplingProvider = class {
   languageModel(options) {
     return new MCPSamplingLanguageModel({
       server: this.config.server,
-      modelPreferences: options?.modelPreferences
+      modelPreferences: options?.modelPreferences,
+      maxTokens: this.config.maxTokens
     });
   }
   /**
@@ -10667,7 +8843,7 @@ var BaseAIExecutor = class {
         messages: [
           {
             role: "user",
-            content: args.userRequest
+            content: args.prompt
           }
         ],
         tools: this.buildTools(),
@@ -10712,19 +8888,12 @@ var BaseAIExecutor = class {
     }
   }
   buildSystemPrompt(args) {
-    return `Agent \`${this.config.name}\` that completes tasks by calling tools.
-
-<manual>
-${this.config.description}
-</manual>
-
-<rules>
-${this.getRules()}
-</rules>
-
-<tools>
-${this.getToolListDescription()}
-</tools>${args.context ? this.formatContext(args.context) : ""}`;
+    return CompiledPrompts.aiLoopSystem({
+      toolName: this.config.name,
+      description: this.config.description,
+      rules: this.getRules(),
+      context: this.formatContext(args.context)
+    });
   }
   getRules() {
     return `1. Use tools to complete the user's request
@@ -10733,10 +8902,10 @@ ${this.getToolListDescription()}
 4. Continue until task is complete
 5. When complete, provide a summary WITHOUT calling more tools`;
   }
-  getToolListDescription() {
-    return "Tools will be provided by AI SDK";
-  }
   formatContext(context2) {
+    if (!context2 || Object.keys(context2).length === 0) {
+      return "";
+    }
     return `
 
 <context>
@@ -10744,11 +8913,12 @@ ${JSON.stringify(context2, null, 2)}
 </context>`;
   }
   convertToAISDKTool(name, toolDetail, execute) {
+    const cleanedSchema = toolDetail.inputSchema ? cleanToolSchema(toolDetail.inputSchema) : {
+      type: "object"
+    };
     return (0, import_ai.tool)({
       description: toolDetail.description || `Tool: ${name}`,
-      inputSchema: (0, import_ai.jsonSchema)(toolDetail.inputSchema || {
-        type: "object"
-      }),
+      inputSchema: (0, import_ai.jsonSchema)(cleanedSchema),
       execute
     });
   }
@@ -10759,17 +8929,20 @@ var AISamplingExecutor = class extends BaseAIExecutor {
   server;
   tools;
   providerOptions;
+  maxTokens;
   model = null;
   constructor(config) {
     super(config, "callTool" in config.server ? config.server : void 0);
     this.server = config.server;
     this.tools = config.tools;
     this.providerOptions = config.providerOptions;
+    this.maxTokens = config.maxTokens;
   }
   initProvider() {
     if (!this.model) {
       const provider = new MCPSamplingProvider({
-        server: this.server
+        server: this.server,
+        maxTokens: this.maxTokens
       });
       this.model = provider.languageModel(this.providerOptions);
     }
@@ -10782,9 +8955,6 @@ var AISamplingExecutor = class extends BaseAIExecutor {
   getExecutorType() {
     return "mcp";
   }
-  getToolListDescription() {
-    return this.tools.map(([name, detail]) => `- ${name}: ${detail.description || "No description"}`).join("\n");
-  }
   buildTools() {
     const aiTools = {};
     for (const [name, detail] of this.tools) {
@@ -10815,7 +8985,7 @@ var AISamplingExecutor = class extends BaseAIExecutor {
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/ai/ai-sampling-registrar.js
 function registerAISamplingTool(server, params) {
-  const { name, description, allToolNames, depGroups, toolNameToDetailList, providerOptions, maxSteps = 50, tracingEnabled = false } = params;
+  const { name, description, allToolNames, depGroups, toolNameToDetailList, providerOptions, maxSteps = 50, tracingEnabled = false, maxTokens } = params;
   const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
   const executor = new AISamplingExecutor({
     name,
@@ -10824,7 +8994,8 @@ function registerAISamplingTool(server, params) {
     tools: toolNameToDetailList,
     providerOptions,
     maxSteps,
-    tracingEnabled
+    tracingEnabled,
+    maxTokens
   });
   const toolDescription = CompiledPrompts.samplingToolDescription({
     toolName: name,
@@ -10837,9 +9008,23 @@ function registerAISamplingTool(server, params) {
     properties: {}
   };
   server.tool(name, toolDescription, jsonSchema(createModelCompatibleJSONSchema(schema)), (args) => {
-    const userRequest = typeof args.userRequest === "string" ? args.userRequest : JSON.stringify(args);
+    const validationResult = validateSchema(args, schema);
+    if (!validationResult.valid) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: CompiledPrompts.errorResponse({
+              errorMessage: validationResult.error || "Validation failed"
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+    const prompt = typeof args.prompt === "string" ? args.prompt : JSON.stringify(args);
     return executor.execute({
-      userRequest,
+      prompt,
       context: args.context
     });
   });
@@ -10860,7 +9045,8 @@ var createAISamplingModePlugin = () => ({
       toolNameToDetailList: context2.toolNameToDetailList,
       providerOptions: opts.providerOptions,
       maxSteps: opts.maxSteps,
-      tracingEnabled: opts.tracingEnabled
+      tracingEnabled: opts.tracingEnabled,
+      maxTokens: opts.maxTokens
     });
   }
 });
@@ -10892,12 +9078,6 @@ var AIACPExecutor = class extends BaseAIExecutor {
   getExecutorType() {
     return "acp";
   }
-  getToolListDescription() {
-    if (this.tools.length === 0) {
-      return "Tools will be provided by ACP agent";
-    }
-    return this.tools.map(([name, detail]) => `- ${name}: ${detail.description || "No description"}`).join("\n");
-  }
   buildTools() {
     const aiTools = {};
     for (const [name, detail] of this.tools) {
@@ -10949,9 +9129,23 @@ function registerAIACPTool(server, params) {
     properties: {}
   };
   server.tool(name, toolDescription, jsonSchema(createModelCompatibleJSONSchema(schema)), (args) => {
-    const userRequest = typeof args.userRequest === "string" ? args.userRequest : JSON.stringify(args);
+    const validationResult = validateSchema(args, schema);
+    if (!validationResult.valid) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: CompiledPrompts.errorResponse({
+              errorMessage: validationResult.error || "Validation failed"
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+    const prompt = typeof args.prompt === "string" ? args.prompt : JSON.stringify(args);
     return executor.execute({
-      userRequest,
+      prompt,
       context: args.context
     });
   });
@@ -10988,9 +9182,6 @@ function getBuiltInPlugins() {
     tool_name_mapping_plugin_default,
     config_plugin_default,
     mode_agentic_plugin_default,
-    mode_workflow_plugin_default,
-    mode_agentic_sampling_plugin_default,
-    mode_workflow_sampling_plugin_default,
     mode_ai_sampling_plugin_default,
     mode_ai_acp_plugin_default,
     logging_plugin_default
@@ -11399,7 +9590,7 @@ var ToolManager = class {
       description,
       schema
     });
-    if (options.internal) {
+    if (options.hidden) {
       this.toolConfigs.set(name, {
         visibility: {
           hidden: true
@@ -11419,6 +9610,11 @@ var ToolManager = class {
         inputSchema: schema
       });
     }
+    this.toolConfigs.set(name, {
+      visibility: {
+        public: true
+      }
+    });
   }
   /**
    * Check if a tool is public (exposed to MCP clients)
@@ -11968,14 +10164,6 @@ var ComposableMCPServer = class extends Server {
       if (!this.toolNameMapping.has(internalName)) {
         this.toolManager.setToolNameMapping(internalName, toolId);
       }
-      const matchingStep = options.steps?.find((step) => step.actions.includes(toolNameWithScope));
-      if (matchingStep) {
-        const actionIndex = matchingStep.actions.indexOf(toolNameWithScope);
-        if (actionIndex !== -1) {
-          matchingStep.actions[actionIndex] = toolId;
-        }
-        return true;
-      }
       return tagToResults.tool.find((tool2) => {
         const selectAll = tool2.attribs.name === `${mcpName}.${ALL_TOOLS_PLACEHOLDER2}` || tool2.attribs.name === `${mcpName}`;
         if (selectAll) {
@@ -12035,11 +10223,11 @@ var ComposableMCPServer = class extends Server {
     const toolNameToDetailList = Object.entries(allTools);
     const publicToolNames = this.getPublicToolNames();
     const hiddenToolNames = this.getHiddenToolNames();
-    const contextToolNames = toolNameToDetailList.map(([name2]) => name2).filter((n) => !hiddenToolNames.includes(n));
+    const contextToolNames = toolNameToDetailList.map(([name2]) => name2).filter((n) => !hiddenToolNames.includes(n) && !publicToolNames.includes(n));
     publicToolNames.forEach((toolId) => {
       const tool2 = allTools[toolId];
       if (!tool2) {
-        throw new Error(`Public tool ${toolId} not found in registry, available: ${Object.keys(allTools).join(", ")}`);
+        return;
       }
       this.tool(toolId, tool2.description || "", jsonSchema(tool2.inputSchema), tool2.execute, {
         internal: false
@@ -12094,12 +10282,12 @@ var ComposableMCPServer = class extends Server {
 };
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/env.js
-var import_node_process9 = __toESM(require("node:process"), 1);
-var isSCF = () => Boolean(import_node_process9.default.env.SCF_RUNTIME || import_node_process9.default.env.PROD_SCF);
+var import_node_process8 = __toESM(require("node:process"), 1);
+var isSCF = () => Boolean(import_node_process8.default.env.SCF_RUNTIME || import_node_process8.default.env.PROD_SCF);
 if (isSCF()) {
   console.log({
     isSCF: isSCF(),
-    SCF_RUNTIME: import_node_process9.default.env.SCF_RUNTIME
+    SCF_RUNTIME: import_node_process8.default.env.SCF_RUNTIME
   });
 }
 
@@ -12148,15 +10336,13 @@ function createSearchPlugin(options = {}) {
   const timeoutMs = options.timeoutMs || 3e4;
   const global2 = options.global ?? true;
   const agentName = options.agentName;
-  const toolName = agentName ? `${agentName}__search-tool-result` : "search-tool-result";
+  const toolName = agentName ? `${agentName}__grep` : "mcpc__grep";
   const activeTimeouts = /* @__PURE__ */ new Set();
   return {
     name: "plugin-search",
     version: "1.0.0",
     configureServer: (server) => {
-      const defaultDescription = agentName ? `Search for text patterns in files for the "${agentName}" agent. Use this to find specific content within large tool results. Provide a simple literal string or a regular expression.
-Only search within the allowed directory: ${allowedSearchDir}` : `Search for text patterns in files and directories. Use this to find specific content, code, or information within files. Provide a simple literal string or a regular expression. If your pattern is a regex, ensure it's valid; otherwise use quotes or escape special characters to treat it as a literal string.
-Only search within the allowed directory: ${allowedSearchDir}`;
+      const defaultDescription = agentName ? `Grep/search for text patterns within large tool result files for the "${agentName}" agent. **IMPORTANT**: You MUST execute the actual tool first and get a "Result too large, saved to file" response before using this grep tool. This tool searches within previously saved large results only. Provide a simple literal string or a regular expression. Only search within the allowed directory: ${allowedSearchDir}` : `Grep/search for text patterns within large tool result files. **IMPORTANT**: You MUST execute the actual tool first and get a "Result too large, saved to file" response before using this grep tool. This tool searches within previously saved large results only. Provide a simple literal string or a regular expression. If your pattern is a regex, ensure it's valid. Only search within the allowed directory: ${allowedSearchDir}`;
       const toolDescription = options.toolDescription || defaultDescription;
       server.tool(toolName, toolDescription, jsonSchema({
         type: "object",
@@ -12375,7 +10561,7 @@ function createLargeResultPlugin(options = {}) {
   let tempDir = options.tempDir || null;
   let serverRef = null;
   let agentName = null;
-  const defaultSearchDescription = `Search within large tool result files that were saved due to size limits. Use when: a tool result was saved to file because it exceeded the context limit. Do NOT use this tool before calling the actual tool first. Provide specific keywords or patterns related to the content you're looking for.`;
+  const defaultSearchDescription = `Grep/search within large tool result files that were saved due to size limits. **IMPORTANT**: You MUST execute the actual tool first and get a "Result too large, saved to file" response before using this grep tool. This tool is ONLY for searching within previously saved large results, not for general file search. Provide specific keywords or regex patterns related to the content you're looking for.`;
   return {
     name: "plugin-large-result-handler",
     version: "1.0.0",
@@ -12390,7 +10576,7 @@ function createLargeResultPlugin(options = {}) {
           maxResults: options.search?.maxResults || 15,
           maxOutputSize: options.search?.maxOutputSize || 4e3,
           toolDescription: options.search?.toolDescription || defaultSearchDescription,
-          global: true,
+          global: false,
           agentName
         };
         const searchPlugin = createSearchPlugin(searchConfig);
@@ -12399,7 +10585,7 @@ function createLargeResultPlugin(options = {}) {
     },
     transformTool: (tool2, context2) => {
       const originalExecute = tool2.execute;
-      const searchToolName = agentName ? `${agentName}__search-tool-result` : "search-tool-result";
+      const searchToolName = agentName ? `${agentName}__grep` : "mcpc__grep";
       tool2.execute = async (args) => {
         try {
           const result = await originalExecute(args);