@mcpc-tech/core 0.3.17 → 0.3.19

package/index.cjs

@@ -394,7 +394,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;
@@ -418,8 +418,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";
@@ -540,7 +540,7 @@ __export(mod_exports, {
   jsonSchema: () => jsonSchema,
   mcpc: () => mcpc,
   optionalObject: () => optionalObject,
-  parseJSON: () => parseJSON2,
+  parseJSON: () => parseJSON,
   parseMcpcConfigs: () => parseMcpcConfigs,
   truncateJSON: () => truncateJSON
 });
@@ -2783,15 +2783,15 @@ var $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
       }
     }
     const input = payload.value;
-    const isDate2 = input instanceof Date;
-    const isValidDate = isDate2 && !Number.isNaN(input.getTime());
+    const isDate = input instanceof Date;
+    const isValidDate = isDate && !Number.isNaN(input.getTime());
     if (isValidDate)
       return payload;
     payload.issues.push({
       expected: "date",
       code: "invalid_type",
       input,
-      ...isDate2 ? { received: "Invalid Date" } : {},
+      ...isDate ? { received: "Invalid Date" } : {},
       inst
     });
     return payload;
@@ -3396,8 +3396,8 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
       }
     }
     if (def.rest) {
-      const rest2 = input.slice(items.length);
-      for (const el of rest2) {
+      const rest = input.slice(items.length);
+      for (const el of rest) {
         i++;
         const result = def.rest._zod.run({
           value: el,
@@ -5851,30 +5851,30 @@ var tupleProcessor = (schema, ctx, _json, params) => {
     ...params,
     path: [...params.path, prefixPath, i]
   }));
-  const rest2 = def.rest ? process2(def.rest, ctx, {
+  const rest = def.rest ? process2(def.rest, ctx, {
     ...params,
     path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
   }) : null;
   if (ctx.target === "draft-2020-12") {
     json2.prefixItems = prefixItems;
-    if (rest2) {
-      json2.items = rest2;
+    if (rest) {
+      json2.items = rest;
     }
   } else if (ctx.target === "openapi-3.0") {
     json2.items = {
       anyOf: prefixItems
     };
-    if (rest2) {
-      json2.items.anyOf.push(rest2);
+    if (rest) {
+      json2.items.anyOf.push(rest);
     }
     json2.minItems = prefixItems.length;
-    if (!rest2) {
+    if (!rest) {
       json2.maxItems = prefixItems.length;
     }
   } else {
     json2.items = prefixItems;
-    if (rest2) {
-      json2.additionalItems = rest2;
+    if (rest) {
+      json2.additionalItems = rest;
     }
   }
   const { minimum, maximum } = schema._zod.bag;
@@ -6900,19 +6900,19 @@ var ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
   $ZodTuple.init(inst, def);
   ZodType.init(inst, def);
   inst._zod.processJSONSchema = (ctx, json2, params) => tupleProcessor(inst, ctx, json2, params);
-  inst.rest = (rest2) => inst.clone({
+  inst.rest = (rest) => inst.clone({
     ...inst._zod.def,
-    rest: rest2
+    rest
   });
 });
 function tuple(items, _paramsOrRest, _params) {
   const hasRest = _paramsOrRest instanceof $ZodType;
   const params = hasRest ? _params : _paramsOrRest;
-  const rest2 = hasRest ? _paramsOrRest : null;
+  const rest = hasRest ? _paramsOrRest : null;
   return new ZodTuple({
     type: "tuple",
     items,
-    rest: rest2,
+    rest,
     ...util_exports.normalizeParams(params)
   });
 }
@@ -11856,8 +11856,8 @@ var ZodTuple2 = class _ZodTuple extends ZodType2 {
       });
       return INVALID;
     }
-    const rest2 = this._def.rest;
-    if (!rest2 && ctx.data.length > this._def.items.length) {
+    const rest = this._def.rest;
+    if (!rest && ctx.data.length > this._def.items.length) {
       addIssueToContext(ctx, {
         code: ZodIssueCode2.too_big,
         maximum: this._def.items.length,
@@ -11884,10 +11884,10 @@ var ZodTuple2 = class _ZodTuple extends ZodType2 {
   get items() {
     return this._def.items;
   }
-  rest(rest2) {
+  rest(rest) {
     return new _ZodTuple({
       ...this._def,
-      rest: rest2
+      rest
     });
   }
 };
@@ -13070,11 +13070,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
@@ -13518,9 +13518,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) => {
@@ -14425,71 +14425,6 @@ var Server = class extends Protocol {
 
 // __mcpc__core_latest/node_modules/@jsr/mcpc__utils/src/json.js
 var import_jsonrepair = require("jsonrepair");
-function stripMarkdownAndText(text) {
-  text = text.trim();
-  text = text.replace(/^```(?:json)?\s*\n?/i, "");
-  text = text.replace(/\n?```\s*$/, "");
-  text = text.replace(/^(?:here is|here's|response|result|output|json):\s*/i, "");
-  const firstJsonIndex = text.search(/[\{\[]/);
-  if (firstJsonIndex >= 0) {
-    text = text.slice(firstJsonIndex);
-    let depth = 0;
-    let inString = false;
-    let escapeNext = false;
-    const startChar = text[0];
-    const endChar = startChar === "{" ? "}" : "]";
-    for (let i = 0; i < text.length; i++) {
-      const char = text[i];
-      if (escapeNext) {
-        escapeNext = false;
-        continue;
-      }
-      if (char === "\\") {
-        escapeNext = true;
-        continue;
-      }
-      if (char === '"' && !inString) {
-        inString = true;
-        continue;
-      }
-      if (char === '"' && inString) {
-        inString = false;
-        continue;
-      }
-      if (inString) continue;
-      if (char === startChar) {
-        depth++;
-      } else if (char === endChar) {
-        depth--;
-        if (depth === 0) {
-          return text.slice(0, i + 1);
-        }
-      }
-    }
-  }
-  return text.trim();
-}
-function parseJSON(text, throwError) {
-  try {
-    return JSON.parse(text);
-  } catch (_error) {
-    try {
-      const cleanedText = stripMarkdownAndText(text);
-      try {
-        return JSON.parse(cleanedText);
-      } catch {
-        const repairedText = (0, import_jsonrepair.jsonrepair)(cleanedText);
-        console.warn(`Failed to parse JSON, cleaned and repaired. Original: ${text.slice(0, 100)}...`);
-        return JSON.parse(repairedText);
-      }
-    } catch (_repairError) {
-      if (throwError) {
-        throw new Error(`Failed to parse JSON after cleanup and repair. Original error: ${_error instanceof Error ? _error.message : String(_error)}`);
-      }
-      return null;
-    }
-  }
-}
 
 // __mcpc__core_latest/node_modules/@jsr/mcpc__utils/src/ai.js
 var p = (template, options = {}) => {
@@ -15263,8 +15198,8 @@ var import_node_stream = require("node:stream");
 
 // __mcpc__core_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) {
@@ -15363,8 +15298,8 @@ var StdioClientTransport = class {
       this._process.stdin?.on("error", (error2) => {
         this.onerror?.(error2);
       });
-      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", (error2) => {
@@ -15473,7 +15408,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;
@@ -15541,19 +15476,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++;
     }
   }
@@ -16887,8 +16822,8 @@ var EventSourceParserStream = class extends TransformStream {
           onComment
         });
       },
-      transform(chunk2) {
-        parser.feed(chunk2);
+      transform(chunk) {
+        parser.feed(chunk);
       }
     });
   }
@@ -16996,14 +16931,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
@@ -17017,13 +16952,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((error2) => {
         this.onerror?.(new Error(`Failed to reconnect SSE stream: ${error2 instanceof Error ? error2.message : String(error2)}`));
         this._scheduleReconnection(options, attemptCount + 1);
       });
-    }, delay2);
+    }, delay);
   }
   _handleSseStream(stream, options, isReconnectable) {
     if (!stream) {
@@ -17340,7 +17275,7 @@ var GEMINI_PREFERRED_FORMAT = import_node_process2.default.env.GEMINI_PREFERRED_
 // __mcpc__core_latest/node_modules/@mcpc/core/src/utils/common/json.js
 var import_jsonrepair2 = require("jsonrepair");
 var import_node_util = require("node:util");
-function parseJSON2(text, throwError) {
+function parseJSON(text, throwError) {
   try {
     return JSON.parse(text);
   } catch (_error) {
@@ -17390,8 +17325,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)) {
@@ -17410,6 +17345,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__core_latest/node_modules/@mcpc/core/src/utils/common/mcp.js
 var import_node_process3 = require("node:process");
@@ -17758,14 +17721,14 @@ function createLogger(name, server) {
 
 // __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/built-in/logging-plugin.js
 var createLoggingPlugin = (options = {}) => {
-  const { enabled = true, verbose = false, compact: compact2 = true } = options;
+  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`);
@@ -17805,296 +17768,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": array of tool names. For other tools: object with parameters.
 </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>
+<rules>
+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>
 
-<call_format>
-Initial definition request:
+<format>
+Get tool schemas:
 \`\`\`json
 {
-  "hasDefinitions": [],
-  "definitionsOf": ["tool1", "tool2"]
+  "tool": "man",
+  "args": ["tool1", "tool2"]
 }
 \`\`\`
 
-Execute tool + get new definitions:
+Execute a tool:
 \`\`\`json
 {
-  "useTool": "tool1",
-  "tool1": { /* parameters */ },
-  "hasDefinitions": ["tool1", "tool2"],
-  "definitionsOf": ["tool3"]
+  "tool": "tool_name",
+  "args": { /* tool parameters */ }
 }
 \`\`\`
-</call_format>`,
+</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
+   * Tool description for sampling tools (shown in MCP tools list)
+   * Explains how to use prompt and context parameters
    */
-  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>
+  SAMPLING_TOOL_DESCRIPTION: `Subagent tool \`{toolName}\` that executes complex tasks.
 
-<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.
+You must follow the <manual/>, obey the <rules/>, and use the <format/>.
 
 <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
-</rules>
-
 <format>
-CORRECT:
-\`\`\`json
-{"useTool": "tool_name", "decision": "proceed", "tool_name": {...}}
-\`\`\`
-
-WRONG - No explanations:
-\`\`\`
-I will list the directory
-{"useTool": "list_directory", ...}
-\`\`\`
-
-During execution:
-\`\`\`json
-{
-  "useTool": "tool_name",
-  "decision": "proceed",
-  "tool_name": { /* tool parameters */ }
-}
-\`\`\`
-
-When complete:
-\`\`\`json
-{ "decision": "complete" }
-\`\`\`
-
-Decisions:
-- \`proceed\` = action succeeded, continue
-- \`retry\` = action failed, try again  
-- \`complete\` = task finished
+\`prompt\` - The task to be completed (e.g., "organize my desktop files")
+\`context\` - Execution context object (e.g., { cwd: "/path/to/dir" })
 </format>
 
-<tools>
-{toolList}
-</tools>`,
-  /**
-   * Tool description for sampling tools (shown in MCP tools list)
-   * Explains how to use userRequest and context parameters
-   */
-  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.
-
-<manual>
-{description}
-</manual>
-
 <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 = {
   /**
@@ -18117,9 +17869,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
    */
@@ -18138,78 +17887,16 @@ 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__core_latest/node_modules/@mcpc/core/src/utils/schema-validator.js
 var import_ajv2 = require("ajv");
@@ -18218,13 +17905,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) {
@@ -18321,17 +18009,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_process5.default.env.MCPC_TRACING_ENABLED === "true";
       if (this.tracingEnabled) {
@@ -18349,7 +18037,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 {
@@ -18364,7 +18052,7 @@ var AgenticExecutor = class {
         }
         this.logger.warning({
           message: "Validation failed",
-          selectTool: args[this.USE_TOOL_KEY],
+          tool: args.tool,
           error: validationResult.error
         });
         return {
@@ -18379,128 +18067,39 @@ 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}".`
-          });
-        }
-        return result;
-      }
-      if (executeSpan) {
-        try {
-          const safeTool = String(useTool).replace(/\s+/g, "_");
-          if (typeof executeSpan.updateName === "function") {
-            executeSpan.updateName(`mcpc.agentic_execute.${safeTool}`);
-          }
-        } catch {
-        }
-      }
-      const currentTool = this.toolNameToDetailList.find(([name, _detail]) => name === useTool)?.[1];
-      if (currentTool) {
-        if (executeSpan) {
-          executeSpan.setAttributes({
-            toolType: "external",
-            selectedTool: useTool
-          });
-        }
-        this.logger.debug({
-          message: "Executing external tool",
-          selectTool: useTool
-        });
-        const currentResult = await currentTool.execute({
-          ...args[useTool]
-        });
-        this.appendToolSchemas(currentResult, definitionsOf, hasDefinitions);
-        if (executeSpan) {
-          executeSpan.setAttributes({
-            success: true,
-            isError: !!currentResult.isError,
-            resultContentLength: currentResult.content?.length || 0,
-            toolResult: JSON.stringify(currentResult)
-          });
-          endSpan(executeSpan);
-        }
-        return currentResult;
-      }
-      if (this.allToolNames.includes(useTool)) {
-        if (executeSpan) {
-          executeSpan.setAttributes({
-            toolType: "internal",
-            selectedTool: useTool
-          });
-        }
-        this.logger.debug({
-          message: "Executing internal tool",
-          selectTool: useTool
-        });
-        try {
-          const result = await this.server.callTool(useTool, args[useTool]);
-          const callToolResult = result ?? {
-            content: []
-          };
-          this.appendToolSchemas(callToolResult, definitionsOf, hasDefinitions);
-          if (executeSpan) {
-            executeSpan.setAttributes({
-              success: true,
-              isError: !!callToolResult.isError,
-              resultContentLength: callToolResult.content?.length || 0,
-              toolResult: JSON.stringify(callToolResult)
-            });
-            endSpan(executeSpan);
-          }
-          return callToolResult;
-        } catch (error2) {
-          if (executeSpan) {
-            endSpan(executeSpan, error2);
+      const tool2 = args.tool;
+      if (tool2 === "man") {
+        const manSchema = {
+          type: "array",
+          items: {
+            type: "string",
+            enum: this.allToolNames,
+            errorMessage: {
+              enum: `Invalid tool name. Available: ${this.allToolNames.join(", ")}`
+            }
+          },
+          minItems: 1,
+          errorMessage: {
+            type: 'Expected an array of tool names, e.g. ["tool1", "tool2"]',
+            minItems: "At least one tool name is required"
           }
-          this.logger.error({
-            message: "Error executing internal tool",
-            useTool,
-            error: String(error2)
-          });
+        };
+        const manValidation = validateSchema(args.args ?? [], manSchema);
+        if (!manValidation.valid) {
           return {
             content: [
               {
                 type: "text",
-                text: `Error executing internal tool ${useTool}: ${error2 instanceof Error ? error2.message : String(error2)}`
+                text: `Invalid args for "man": ${manValidation.error}`
               }
             ],
             isError: true
           };
         }
+        return this.handleManCommand(args.args, executeSpan);
       }
-      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
-      };
+      const toolArgs = args.args || {};
+      return await this.executeTool(tool2, toolArgs, executeSpan);
     } catch (error2) {
       if (executeSpan) {
         endSpan(executeSpan, error2);
@@ -18520,1711 +18119,263 @@ var AgenticExecutor = class {
       };
     }
   }
-  // Append tool schemas to result if requested
-  appendToolSchemas(result, definitionsOf, hasDefinitions) {
-    const schemasToProvide = definitionsOf.filter((toolName) => !hasDefinitions.includes(toolName));
-    if (schemasToProvide.length === 0) {
-      return;
+  /**
+   * 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(",")
+      });
     }
-    const definitionTexts = [];
-    for (const toolName of schemasToProvide) {
-      const toolDetail = this.toolNameToDetailList.find(([name]) => name === toolName);
+    const schemas = requestedTools.map((toolName) => {
+      const toolDetail = this.toolSchemaMap.get(toolName);
       if (toolDetail) {
-        const [name, schema] = toolDetail;
-        const schemaJson = JSON.stringify(schema, null, 2);
-        definitionTexts.push(`<tool_definition name="${name}">
-${schemaJson}
-</tool_definition>`);
+        const cleanedSchema = cleanToolSchema(toolDetail);
+        return `<tool_definition name="${toolName}">
+${JSON.stringify(cleanedSchema, null, 2)}
+</tool_definition>`;
       }
-    }
-    if (definitionTexts.length > 0) {
-      result.content.push({
-        type: "text",
-        text: `${definitionTexts.join("\n\n")}`
+      return null;
+    }).filter(Boolean);
+    if (executeSpan) {
+      executeSpan.setAttributes({
+        schemasReturned: schemas.length,
+        success: true
       });
+      endSpan(executeSpan);
     }
-  }
-  // Validate arguments using JSON schema
-  validate(args, schema) {
-    return validateSchema(args, schema);
-  }
-};
-
-// __mcpc__core_latest/node_modules/@jsr/es-toolkit__es-toolkit/src/function/partial.js
-function partial2(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");
-partial2.placeholder = placeholderSymbol;
-
-// __mcpc__core_latest/node_modules/@jsr/es-toolkit__es-toolkit/src/function/partialRight.js
-function partialRight(func, ...partialArgs) {
-  return partialRightImpl(func, placeholderSymbol2, ...partialArgs);
-}
-function partialRightImpl(func, placeholder, ...partialArgs) {
-  const partialedRight = function(...providedArgs) {
-    const placeholderLength = partialArgs.filter((arg) => arg === placeholder).length;
-    const rangeLength = Math.max(providedArgs.length - placeholderLength, 0);
-    const remainingArgs = providedArgs.slice(0, rangeLength);
-    let providedArgsIndex = rangeLength;
-    const substitutedArgs = partialArgs.slice().map((arg) => arg === placeholder ? providedArgs[providedArgsIndex++] : arg);
-    return func.apply(this, remainingArgs.concat(substitutedArgs));
-  };
-  if (func.prototype) {
-    partialedRight.prototype = Object.create(func.prototype);
-  }
-  return partialedRight;
-}
-var placeholderSymbol2 = Symbol("partialRight.placeholder");
-partialRight.placeholder = placeholderSymbol2;
-
-// __mcpc__core_latest/node_modules/@jsr/es-toolkit__es-toolkit/src/function/retry.js
-var DEFAULT_RETRIES = Number.POSITIVE_INFINITY;
-
-// __mcpc__core_latest/node_modules/@jsr/es-toolkit__es-toolkit/src/object/pick.js
-function pick2(obj, keys) {
-  const result = {};
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    if (Object.hasOwn(obj, key)) {
-      result[key] = obj[key];
-    }
-  }
-  return result;
-}
-
-// __mcpc__core_latest/node_modules/@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 = {
-        ...pick2(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 = {
-        ...pick2(depGroups, nextStep.actions)
-      };
-      stepDependencies["decision"] = this.decision();
-      stepDependencies["action"] = this.action();
-      return this.common(stepDependencies);
-    },
-    forToolDescription: function(description, state) {
-      const enforceToolArgs = this.forCurrentState(state);
-      const initTitle = predefinedSteps ? `**YOU MUST execute this tool with following tool arguments to init the workflow**
-NOTE: The \`steps\` has been predefined` : `**You MUST execute this tool with following tool arguments to plan and init the workflow**`;
-      return CompiledPrompts.workflowToolDescription({
-        description,
-        initTitle,
-        ensureStepActions: formatEnsureStepActions(),
-        schemaDefinition: JSON.stringify(enforceToolArgs, null, 2)
-      });
-    },
-    forInitialStepDescription: function(steps, state) {
-      return CompiledPrompts.workflowInit({
-        stepCount: steps.length.toString(),
-        currentStepDescription: state.getCurrentStep()?.description || "",
-        toolName: name,
-        schemaDefinition: JSON.stringify(this.forCurrentState(state), null, 2),
-        // Remove redundant workflow steps display
-        workflowSteps: ""
-      });
-    }
-  };
-}
-
-// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/agentic/agentic-tool-registrar.js
-function registerAgenticTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList }) {
-  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
-  const agenticExecutor = new AgenticExecutor(name, allToolNames, toolNameToDetailList, server);
-  description = CompiledPrompts.autonomousExecution({
-    toolName: name,
-    description
-  });
-  const agenticArgsDef = createArgsDef.forAgentic(toolNameToDetailList, false);
-  const argsDef = agenticArgsDef;
-  const schema = allToolNames.length > 0 ? argsDef : {
-    type: "object",
-    properties: {}
-  };
-  server.tool(name, description, jsonSchema(createModelCompatibleJSONSchema(schema)), async (args) => {
-    return await agenticExecutor.execute(args, schema);
-  });
-}
-
-// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/built-in/mode-agentic-plugin.js
-var createAgenticModePlugin = () => ({
-  name: "mode-agentic",
-  version: "1.0.0",
-  // Only apply to agentic mode
-  apply: "agentic",
-  // Register the agent tool
-  registerAgentTool: (context2) => {
-    registerAgenticTool(context2.server, {
-      description: context2.description,
-      name: context2.name,
-      allToolNames: context2.allToolNames,
-      depGroups: context2.depGroups,
-      toolNameToDetailList: context2.toolNameToDetailList
-    });
-  }
-});
-var mode_agentic_plugin_default = createAgenticModePlugin();
-
-// __mcpc__core_latest/node_modules/@mcpc/core/src/utils/state.js
-var WorkflowState = class {
-  currentStepIndex = -1;
-  steps = [];
-  stepStatuses = [];
-  stepResults = [];
-  stepErrors = [];
-  isInitialized = false;
-  isStarted = false;
-  constructor(steps) {
-    if (steps) {
-      this.initialize(steps);
-    }
-  }
-  getCurrentStepIndex() {
-    return this.currentStepIndex;
-  }
-  getSteps() {
-    return this.steps;
-  }
-  isWorkflowInitialized() {
-    return this.isInitialized;
-  }
-  getCurrentStep() {
-    if (!this.isInitialized || this.currentStepIndex < 0) {
-      return null;
-    }
-    return this.steps[this.currentStepIndex] || null;
-  }
-  getNextStep() {
-    if (!this.isInitialized) return null;
-    const nextIndex = this.currentStepIndex + 1;
-    return this.steps[nextIndex] || null;
-  }
-  // Get the previous step in the workflow
-  getPreviousStep() {
-    if (!this.isInitialized) return null;
-    const prevIndex = this.currentStepIndex - 1;
-    return this.steps[prevIndex] || null;
-  }
-  hasNextStep() {
-    return this.getNextStep() !== null;
-  }
-  // Check if there is a previous step available
-  hasPreviousStep() {
-    return this.getPreviousStep() !== null;
-  }
-  // Check if currently at the first step
-  isAtFirstStep() {
-    return this.isInitialized && this.currentStepIndex === 0;
-  }
-  // Check if currently at the last step
-  isAtLastStep() {
-    return this.isInitialized && this.currentStepIndex >= this.steps.length - 1;
-  }
-  isWorkflowStarted() {
-    return this.isStarted;
-  }
-  isCompleted() {
-    return this.isInitialized && this.currentStepIndex > this.steps.length - 1;
-  }
-  // Mark workflow as completed by moving beyond the last step
-  markCompleted() {
-    if (this.isInitialized) {
-      this.currentStepIndex = this.steps.length;
-    }
-  }
-  initialize(steps) {
-    this.steps = steps;
-    this.stepStatuses = new Array(steps.length).fill("pending");
-    this.stepResults = new Array(steps.length).fill("");
-    this.stepErrors = new Array(steps.length).fill("");
-    this.currentStepIndex = 0;
-    this.isInitialized = true;
-    this.isStarted = false;
-  }
-  // Mark current step as running
-  markCurrentStepRunning() {
-    if (this.isInitialized && this.currentStepIndex >= 0 && this.currentStepIndex < this.steps.length) {
-      this.stepStatuses[this.currentStepIndex] = "running";
-    }
-  }
-  // Mark current step as completed
-  markCurrentStepCompleted(result) {
-    if (this.isInitialized && this.currentStepIndex >= 0 && this.currentStepIndex < this.steps.length) {
-      this.stepStatuses[this.currentStepIndex] = "completed";
-      if (result) {
-        this.stepResults[this.currentStepIndex] = result;
-      }
-    }
-  }
-  // Mark current step as failed
-  markCurrentStepFailed(error2) {
-    if (this.isInitialized && this.currentStepIndex >= 0 && this.currentStepIndex < this.steps.length) {
-      this.stepStatuses[this.currentStepIndex] = "failed";
-      if (error2) {
-        this.stepErrors[this.currentStepIndex] = error2;
-      }
-    }
-  }
-  // Get steps with their status
-  getStepsWithStatus() {
-    return this.steps.map((step, index) => ({
-      ...step,
-      status: this.stepStatuses[index] || "pending",
-      result: this.stepResults[index] || void 0,
-      error: this.stepErrors[index] || void 0
-    }));
-  }
-  // Get basic workflow progress data for template rendering
-  getProgressData() {
-    return {
-      steps: this.steps,
-      statuses: this.stepStatuses,
-      results: this.stepResults,
-      errors: this.stepErrors,
-      currentStepIndex: this.currentStepIndex,
-      totalSteps: this.steps.length
-    };
-  }
-  start() {
-    this.isStarted = true;
-  }
-  moveToNextStep() {
-    if (!this.hasNextStep()) {
-      return false;
-    }
-    this.currentStepIndex++;
-    return true;
-  }
-  // Move to the previous step in the workflow
-  moveToPreviousStep() {
-    if (!this.hasPreviousStep()) {
-      return false;
-    }
-    this.currentStepIndex--;
-    return true;
-  }
-  // Move to a specific step by index (optional feature)
-  moveToStep(stepIndex) {
-    if (!this.isInitialized || stepIndex < 0 || stepIndex >= this.steps.length) {
-      return false;
-    }
-    this.currentStepIndex = stepIndex;
-    return true;
-  }
-  reset() {
-    this.currentStepIndex = -1;
-    this.steps = [];
-    this.stepStatuses = [];
-    this.stepResults = [];
-    this.stepErrors = [];
-    this.isInitialized = false;
-    this.isStarted = false;
-  }
-  getDebugInfo() {
-    return {
-      currentStepIndex: this.currentStepIndex,
-      totalSteps: this.steps.length,
-      isInitialized: this.isInitialized,
-      currentStep: this.getCurrentStep()?.description,
-      nextStep: this.getNextStep()?.description,
-      previousStep: this.getPreviousStep()?.description,
-      isAtFirstStep: this.isAtFirstStep(),
-      hasPreviousStep: this.hasPreviousStep()
-    };
-  }
-};
-
-// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/workflow/workflow-executor.js
-var WorkflowExecutor = class {
-  name;
-  allToolNames;
-  toolNameToDetailList;
-  createArgsDef;
-  server;
-  predefinedSteps;
-  ensureStepActions;
-  toolNameToIdMapping;
-  constructor(name, allToolNames, toolNameToDetailList, createArgsDef, server, predefinedSteps, ensureStepActions, toolNameToIdMapping) {
-    this.name = name;
-    this.allToolNames = allToolNames;
-    this.toolNameToDetailList = toolNameToDetailList;
-    this.createArgsDef = createArgsDef;
-    this.server = server;
-    this.predefinedSteps = predefinedSteps;
-    this.ensureStepActions = ensureStepActions;
-    this.toolNameToIdMapping = toolNameToIdMapping;
-  }
-  // Helper method to validate required actions are present in workflow steps
-  validateRequiredActions(steps) {
-    if (!this.ensureStepActions || this.ensureStepActions.length === 0) {
-      return {
-        valid: true,
-        missing: []
-      };
-    }
-    const allStepActions = /* @__PURE__ */ new Set();
-    steps.forEach((step) => {
-      step.actions.forEach((action) => allStepActions.add(action));
-    });
-    const missing = [];
-    for (const requiredAction of this.ensureStepActions) {
-      if (allStepActions.has(requiredAction)) {
-        continue;
-      }
-      if (this.toolNameToIdMapping) {
-        const mappedToolId = this.toolNameToIdMapping.get(requiredAction);
-        if (mappedToolId && allStepActions.has(mappedToolId)) {
-          continue;
-        }
-      }
-      missing.push(requiredAction);
-    }
-    return {
-      valid: missing.length === 0,
-      missing
-    };
-  }
-  // Helper method to format workflow progress
-  formatProgress(state) {
-    const progressData = state.getProgressData();
-    return PromptUtils.formatWorkflowProgress(progressData);
-  }
-  async execute(args, state) {
-    if (args.init) {
-      state.reset();
-    } else {
-      if (!state.isWorkflowInitialized() && !args.init) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: this.predefinedSteps ? WorkflowPrompts.ERRORS.NOT_INITIALIZED.WITH_PREDEFINED : WorkflowPrompts.ERRORS.NOT_INITIALIZED.WITHOUT_PREDEFINED
-            }
-          ],
-          isError: true
-        };
-      }
-      const decision2 = args.decision;
-      if (decision2 === "proceed") {
-        if (state.isAtLastStep() && state.isWorkflowStarted()) {
-          state.markCompleted();
-          return {
-            content: [
-              {
-                type: "text",
-                text: `## Workflow Completed!
-
-${this.formatProgress(state)}
-
-${CompiledPrompts.workflowCompleted({
-                  totalSteps: state.getSteps().length,
-                  toolName: this.name,
-                  newWorkflowInstructions: this.predefinedSteps ? "" : " and new `steps` array"
-                })}`
-              }
-            ],
-            isError: false
-          };
-        }
-        if (state.isCompleted()) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: WorkflowPrompts.ERRORS.ALREADY_AT_FINAL
-              }
-            ],
-            isError: true
-          };
-        }
-        const currentStepIndex = state.getCurrentStepIndex();
-        const wasStarted = state.isWorkflowStarted();
-        if (state.isWorkflowStarted()) {
-          state.moveToNextStep();
-        } else {
-          state.start();
-        }
-        const nextStepValidationSchema = this.createArgsDef.forCurrentState(state);
-        const nextStepValidationResult = this.validateInput(args, nextStepValidationSchema);
-        if (!nextStepValidationResult.valid) {
-          if (wasStarted) {
-            state.moveToStep(currentStepIndex);
-          } else {
-            state.moveToStep(currentStepIndex);
-          }
-          return {
-            content: [
-              {
-                type: "text",
-                text: CompiledPrompts.workflowErrorResponse({
-                  errorMessage: `Cannot proceed to next step: ${nextStepValidationResult.error || "Arguments validation failed"}`
-                })
-              }
-            ],
-            isError: true
-          };
-        }
-      } else if (decision2 === "complete") {
-        if (state.isAtLastStep() && state.isWorkflowStarted()) {
-          state.markCompleted();
-          return {
-            content: [
-              {
-                type: "text",
-                text: `## Workflow Completed!
-
-${this.formatProgress(state)}
-
-${CompiledPrompts.workflowCompleted({
-                  totalSteps: state.getSteps().length,
-                  toolName: this.name,
-                  newWorkflowInstructions: this.predefinedSteps ? "" : " and new `steps` array"
-                })}`
-              }
-            ],
-            isError: false
-          };
-        } else {
-          return {
-            content: [
-              {
-                type: "text",
-                text: WorkflowPrompts.ERRORS.CANNOT_COMPLETE_NOT_AT_FINAL
-              }
-            ],
-            isError: true
-          };
-        }
-      }
-    }
-    const decision = args.decision;
-    if (decision !== "proceed") {
-      const validationSchema = this.createArgsDef.forCurrentState(state);
-      const validationResult = this.validateInput(args, validationSchema);
-      if (!validationResult.valid) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: CompiledPrompts.workflowErrorResponse({
-                errorMessage: validationResult.error || "Arguments validation failed"
-              })
-            }
-          ],
-          isError: true
-        };
-      }
-    }
-    if (args.init) {
-      return this.initialize(args, state);
-    }
-    return await this.executeStep(args, state);
-  }
-  initialize(args, state) {
-    const steps = args.steps ?? this.predefinedSteps;
-    if (!steps || steps.length === 0) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: WorkflowPrompts.ERRORS.NO_STEPS_PROVIDED
-          }
-        ],
-        isError: true
-      };
-    }
-    const validation = this.validateRequiredActions(steps);
-    if (!validation.valid) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `## Workflow Validation Failed \u274C
-
-**Missing Required Actions:** The following actions must be included in the workflow steps:
-
-${validation.missing.map((action) => `- \`${this.toolNameToIdMapping?.get(action) ?? action}\``).join("\n")}`
-          }
-        ],
-        isError: true
-      };
-    }
-    state.initialize(steps);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `## Workflow Initialized
-${this.formatProgress(state)}
-${this.createArgsDef.forInitialStepDescription(steps, state)}`
-        }
-      ],
-      isError: false
-    };
-  }
-  async executeStep(args, state) {
-    const currentStep = state.getCurrentStep();
-    if (!currentStep) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: WorkflowPrompts.ERRORS.NO_CURRENT_STEP
-          }
-        ],
-        isError: true
-      };
-    }
-    state.markCurrentStepRunning();
-    const results = {
-      content: [],
-      isError: false
-    };
-    for (const action of currentStep.actions) {
-      try {
-        const actionArgs = args[action] || {};
-        const actionResult = await this.server.callTool(action, actionArgs);
-        if (!results.isError) {
-          results.isError = actionResult.isError;
-        }
-        results.content = results.content.concat(actionResult.content ?? []);
-        results.content.push({
-          type: "text",
-          text: `Action \`${action}\` executed ${actionResult.isError ? "\u274C **FAILED**" : "\u2705 **SUCCESS**"}:`
-        });
-      } catch (error2) {
-        results.content.push({
-          type: "text",
-          text: `${error2.message}`
-        });
-        results.content.push({
-          type: "text",
-          text: `Action \`${action}\` \u274C **FAILED** with error: `
-        });
-        results.isError = true;
-      }
-    }
-    if (results.isError) {
-      state.markCurrentStepFailed("Step execution failed");
-    } else {
-      state.markCurrentStepCompleted("Step completed successfully");
-    }
-    if (state.hasNextStep()) {
-      const nextStepArgsDef = this.createArgsDef.forNextState(state);
-      results.content.push({
-        type: "text",
-        text: CompiledPrompts.nextStepDecision({
-          toolName: this.name,
-          nextStepDescription: state.getNextStep()?.description || "Unknown step",
-          nextStepSchema: JSON.stringify(nextStepArgsDef, null, 2)
-        })
-      });
-    } else {
-      results.content.push({
-        type: "text",
-        text: CompiledPrompts.finalStepCompletion({
-          statusIcon: results.isError ? "\u274C" : "\u2705",
-          statusText: results.isError ? "with errors" : "successfully",
-          toolName: this.name,
-          newWorkflowInstructions: this.predefinedSteps ? "" : " and new `steps` array"
-        })
-      });
-    }
-    results.content.push({
-      type: "text",
-      text: `## Workflow Progress
-${this.formatProgress(state)}`
-    });
-    return results;
-  }
-  // Validate arguments using JSON schema
-  validateInput(args, schema) {
-    return validateSchema(args, schema);
-  }
-};
-
-// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/workflow/workflow-tool-registrar.js
-function registerAgenticWorkflowTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList, predefinedSteps, ensureStepActions, toolNameToIdMapping }) {
-  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, predefinedSteps, ensureStepActions);
-  const workflowExecutor = new WorkflowExecutor(name, allToolNames, toolNameToDetailList, createArgsDef, server, predefinedSteps, ensureStepActions, toolNameToIdMapping);
-  const workflowState = new WorkflowState();
-  const planningInstructions = predefinedSteps ? "- Set `init: true` (steps are predefined)" : "- Set `init: true` and define complete `steps` array";
-  const baseDescription = CompiledPrompts.workflowExecution({
-    toolName: name,
-    description,
-    planningInstructions
-  });
-  const argsDef = createArgsDef.forTool();
-  const toolDescription = createArgsDef.forToolDescription(baseDescription, workflowState);
-  server.tool(name, toolDescription, jsonSchema(createModelCompatibleJSONSchema(argsDef)), async (args) => {
-    try {
-      return await workflowExecutor.execute(args, workflowState);
-    } catch (error2) {
-      workflowState.reset();
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Workflow execution error: ${error2.message}`
-          }
-        ],
-        isError: true
-      };
-    }
-  });
-}
-
-// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/built-in/mode-workflow-plugin.js
-var createWorkflowModePlugin = () => ({
-  name: "mode-workflow",
-  version: "1.0.0",
-  // Only apply to workflow mode
-  apply: "agentic_workflow",
-  // Register the agent tool
-  registerAgentTool: (context2) => {
-    registerAgenticWorkflowTool(context2.server, {
-      description: context2.description,
-      name: context2.name,
-      allToolNames: context2.allToolNames,
-      depGroups: context2.depGroups,
-      toolNameToDetailList: context2.toolNameToDetailList,
-      predefinedSteps: context2.options.steps,
-      ensureStepActions: context2.options.ensureStepActions,
-      toolNameToIdMapping: context2.toolNameToIdMapping
-    });
-  }
-});
-var mode_workflow_plugin_default = createWorkflowModePlugin();
-
-// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/sampling/base-sampling-executor.js
-var import_node_process6 = __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, config2) {
-    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 (config2?.maxIterations) {
-      this.maxIterations = config2.maxIterations;
-    }
-    if (config2?.summarize !== void 0) {
-      this.summarize = config2.summarize;
-    }
-    this.logger = createLogger(`mcpc.sampling.${name}`, server);
-    try {
-      const tracingConfig = {
-        enabled: import_node_process6.default.env.MCPC_TRACING_ENABLED === "true",
-        serviceName: `mcpc-sampling-${name}`,
-        exportTo: import_node_process6.default.env.MCPC_TRACING_EXPORT ?? "otlp",
-        otlpEndpoint: import_node_process6.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");
+    return {
+      content: [
+        {
+          type: "text",
+          text: schemas.length > 0 ? schemas.join("\n\n") : "No schemas found for requested tools."
+        }
+      ]
+    };
   }
   /**
-   * Extract tool calls from response
+   * Execute a tool with runtime validation
    */
-  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`
-        }
+  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
+        });
       }
-    ];
-    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 (error2) {
-                toolResults.push({
-                  type: "tool_result",
-                  toolUseId: toolCall.id,
-                  content: [
-                    {
-                      type: "text",
-                      text: `Error: ${error2 instanceof Error ? error2.message : String(error2)}`
-                    }
-                  ],
-                  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 (toolDetail.inputSchema) {
+        const rawSchema = extractJsonSchema(toolDetail.inputSchema);
+        const validation = validateSchema(toolArgs, rawSchema);
+        if (!validation.valid) {
+          if (executeSpan) {
+            executeSpan.setAttributes({
+              validationError: true,
+              errorMessage: validation.error
             });
-            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 (error2) {
-      if (loopSpan) endSpan(loopSpan, error2);
-      return await this.createExecutionError(error2, 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(error2, parentSpan) {
-    const result = await this.createCompletionResult(`Execution error: ${error2 instanceof Error ? error2.message : String(error2)}`, 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."
-            }
+            endSpan(executeSpan);
           }
-        ],
-        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");
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Parameter validation failed for "${tool2}": ${validation.error}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
       this.logger.debug({
-        message: "Summarization completed",
-        summaryLength: summary.length
+        message: "Executing external tool",
+        tool: tool2
       });
-      if (summarizeSpan) {
-        summarizeSpan.setAttributes({
-          summaryLength: summary.length,
-          summary,
-          success: true
+      const result = await toolDetail.execute(toolArgs);
+      if (executeSpan) {
+        executeSpan.setAttributes({
+          success: true,
+          isError: !!result.isError,
+          resultContentLength: result.content?.length || 0
         });
-        endSpan(summarizeSpan);
-      }
-      return summary;
-    } catch (error2) {
-      this.logger.warning({
-        message: "Summarization failed, falling back to full history",
-        error: String(error2)
-      });
-      if (summarizeSpan) {
-        endSpan(summarizeSpan, error2);
+        endSpan(executeSpan);
       }
-      return this.formatConversation();
-    }
-  }
-  // Format full conversation history (for debugging)
-  formatConversation() {
-    if (this.conversationHistory.length === 0) {
-      return "\n\n**No conversation history**";
+      return result;
     }
-    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)`;
+    if (this.allToolNames.includes(tool2)) {
+      if (executeSpan) {
+        executeSpan.setAttributes({
+          toolType: "internal",
+          selectedTool: tool2
+        });
       }
+      this.logger.debug({
+        message: "Executing internal tool",
+        tool: tool2
+      });
       try {
-        const parsed = JSON.parse(contentText);
-        if (JSON.stringify(parsed).length < 100) {
-          return `${header}\\n${JSON.stringify(parsed)}`;
+        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 `${header}\\n\`\`\`json\\n${JSON.stringify(parsed, null, 2)}\\n\`\`\``;
-      } catch {
-        return `${header}\\n${contentText}`;
+        return callToolResult;
+      } catch (error2) {
+        if (executeSpan) {
+          endSpan(executeSpan, error2);
+        }
+        this.logger.error({
+          message: "Error executing internal tool",
+          tool: tool2,
+          error: String(error2)
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error executing tool "${tool2}": ${error2 instanceof Error ? error2.message : String(error2)}`
+            }
+          ],
+          isError: true
+        };
       }
-    });
-    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) {
+    if (executeSpan) {
+      executeSpan.setAttributes({
+        toolType: "not_found",
+        tool: tool2
+      });
+      endSpan(executeSpan);
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Tool "${tool2}" not found. Available tools: ${this.allToolNames.join(", ")}`
+        }
+      ],
+      isError: true
+    };
+  }
+  validate(args, schema) {
     return validateSchema(args, schema);
   }
 };
 
-// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/sampling/agentic-sampling-executor.js
-var SamplingExecutor = class extends BaseSamplingExecutor {
-  agenticExecutor;
-  constructor(name, description, allToolNames, toolNameToDetailList, server, config2) {
-    super(name, description, allToolNames, toolNameToDetailList, server, config2);
-    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) {
+// __mcpc__core_latest/node_modules/@mcpc/core/src/factories/args-def-factory.js
+function createArgsDefFactory(_name, _allToolNames, _depGroups, _predefinedSteps, _ensureStepActions) {
+  return {
+    forSampling: function() {
       return {
-        content: [
-          {
-            type: "text",
-            text: CompiledPrompts.errorResponse({
-              errorMessage: validationResult.error || "Validation failed"
-            })
+        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"
         ],
-        isError: true
-      };
-    }
-    const createArgsDef = createArgsDefFactory(this.name, this.allToolNames, this.buildDepGroups(), void 0, void 0);
-    const agenticSchema = createArgsDef.forAgentic(this.toolNameToDetailList, true);
-    const systemPrompt = this.buildSystemPrompt(args.userRequest, agenticSchema, args.context && typeof args.context === "object" ? args.context : void 0);
-    return this.runSamplingLoop(() => systemPrompt, agenticSchema);
-  }
-  async processAction(parsedData, schema, _state, parentSpan) {
-    const toolCallData = parsedData;
-    if (toolCallData.decision === "complete") {
-      return await this.createCompletionResult("Task completed", parentSpan);
-    }
-    try {
-      const { action: _action, decision: _decision, ..._toolArgs } = toolCallData;
-      const toolResult = await this.agenticExecutor.execute(toolCallData, schema, parentSpan);
-      const resultText = toolResult.content?.filter((content) => content.type === "text")?.map((content) => content.text)?.join("\n") || "No result";
-      this.conversationHistory.push({
-        role: "assistant",
-        content: {
-          type: "text",
-          text: resultText
+        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: '...' })."
+          }
         }
-      });
-      return toolResult;
-    } catch (error2) {
-      return this.createExecutionError(error2, 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__core_latest/node_modules/@mcpc/core/src/executors/agentic/agentic-sampling-registrar.js
-function registerAgenticSamplingTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList, samplingConfig }) {
-  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
-  const samplingExecutor = new SamplingExecutor(name, description, allToolNames, toolNameToDetailList, server, samplingConfig);
-  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__core_latest/node_modules/@mcpc/core/src/plugins/built-in/mode-agentic-sampling-plugin.js
-var createAgenticSamplingModePlugin = () => ({
-  name: "mode-agentic-sampling",
-  version: "1.0.0",
-  // Only apply to agentic_sampling mode
-  apply: "agentic_sampling",
-  // Register the agent tool with sampling
-  registerAgentTool: (context2) => {
-    registerAgenticSamplingTool(context2.server, {
-      description: context2.description,
-      name: context2.name,
-      allToolNames: context2.allToolNames,
-      depGroups: context2.depGroups,
-      toolNameToDetailList: context2.toolNameToDetailList,
-      samplingConfig: context2.options.samplingConfig
-    });
-  }
-});
-var mode_agentic_sampling_plugin_default = createAgenticSamplingModePlugin();
-
-// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/sampling/workflow-sampling-executor.js
-var WorkflowSamplingExecutor = class extends BaseSamplingExecutor {
-  createArgsDef;
-  predefinedSteps;
-  workflowExecutor;
-  constructor(name, description, allToolNames, toolNameToDetailList, createArgsDef, server, predefinedSteps, config2) {
-    super(name, description, allToolNames, toolNameToDetailList, server, config2), 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) {
+      };
+    },
+    /**
+     * Agentic schema - simplified Unix-style interface
+     *
+     * Only two fields:
+     * - `tool`: which tool to execute (enum includes "man" + all tool names)
+     * - `args`: parameters for the tool (array for "man", object for others)
+     */
+    forAgentic: function(allToolNames) {
+      const toolEnum = [
+        "man",
+        ...allToolNames
+      ];
       return {
-        content: [
-          {
-            type: "text",
-            text: CompiledPrompts.workflowErrorResponse({
-              errorMessage: validationResult.error || "Validation failed"
-            })
+        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: {
+            description: 'For "man": array of tool names ["tool1", "tool2"]. For other tools: object with parameters.'
           }
+        },
+        required: [
+          "tool"
         ],
-        isError: true
+        additionalProperties: false
       };
     }
-    return await this.runSamplingLoop(() => this.buildWorkflowSystemPrompt(args, state), schema, state);
-  }
-  async processAction(parsedData, _schema, state, parentSpan) {
-    const workflowState = state;
-    if (!workflowState) {
-      throw new Error("WorkflowState is required for workflow");
-    }
-    const toolCallData = parsedData;
-    if (toolCallData.decision === "complete") {
-      return await this.createCompletionResult("Task completed", parentSpan);
-    }
-    try {
-      const workflowResult = await this.workflowExecutor.execute(parsedData, workflowState);
-      const resultText = workflowResult.content?.filter((content) => content.type === "text")?.map((content) => content.text)?.join("\n") || "No result";
-      this.conversationHistory.push({
-        role: "assistant",
-        content: {
-          type: "text",
-          text: resultText
-        }
-      });
-      return workflowResult;
-    } catch (error2) {
-      return this.createExecutionError(error2, 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
-    });
-  }
-};
+  };
+}
 
-// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/workflow/workflow-sampling-registrar.js
-function registerWorkflowSamplingTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList, predefinedSteps, samplingConfig, ensureStepActions, toolNameToIdMapping: _toolNameToIdMapping }) {
-  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, predefinedSteps, ensureStepActions);
-  const workflowSamplingExecutor = new WorkflowSamplingExecutor(name, description, allToolNames, toolNameToDetailList, createArgsDef, server, predefinedSteps, samplingConfig);
-  const workflowState = new WorkflowState();
-  const baseDescription = CompiledPrompts.samplingExecution({
+// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/agentic/agentic-tool-registrar.js
+function registerAgenticTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList }) {
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
+  const agenticExecutor = new AgenticExecutor(name, allToolNames, toolNameToDetailList, server);
+  description = CompiledPrompts.autonomousExecution({
     toolName: name,
-    description,
-    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 (error2) {
-      workflowState.reset();
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Workflow execution error: ${error2.message}`
-          }
-        ],
-        isError: true
-      };
-    }
+  server.tool(name, description, jsonSchema(createModelCompatibleJSONSchema(schema)), async (args) => {
+    return await agenticExecutor.execute(args, schema);
   });
 }
 
-// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/built-in/mode-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__core_latest/node_modules/@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__core_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/utils.js
 function convertAISDKToMCPMessages(prompt) {
@@ -20281,6 +18432,7 @@ function convertMCPStopReasonToAISDK(stopReason) {
 }
 
 // __mcpc__core_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/language-model.js
+var DEFAULT_MAX_TOKENS = 128e3;
 var MCPSamplingLanguageModel = class {
   specificationVersion = "v2";
   provider;
@@ -20288,11 +18440,13 @@ var MCPSamplingLanguageModel = class {
   supportedUrls = {};
   server;
   modelPreferences;
+  maxTokens;
   constructor(config2) {
     this.server = config2.server;
     this.modelId = "";
     this.provider = "mcp-client";
     this.modelPreferences = config2.modelPreferences;
+    this.maxTokens = config2.maxTokens ?? DEFAULT_MAX_TOKENS;
   }
   /**
    * Generate a response using MCP's createMessage capability
@@ -20324,7 +18478,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) {
@@ -20702,7 +18856,8 @@ var MCPSamplingProvider = class {
   languageModel(options) {
     return new MCPSamplingLanguageModel({
       server: this.config.server,
-      modelPreferences: options?.modelPreferences
+      modelPreferences: options?.modelPreferences,
+      maxTokens: this.config.maxTokens
     });
   }
   /**
@@ -20763,7 +18918,7 @@ var BaseAIExecutor = class {
         messages: [
           {
             role: "user",
-            content: args.userRequest
+            content: args.prompt
           }
         ],
         tools: this.buildTools(),
@@ -20808,19 +18963,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
@@ -20829,10 +18977,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>
@@ -20840,11 +18988,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
     });
   }
@@ -20855,17 +19004,20 @@ var AISamplingExecutor = class extends BaseAIExecutor {
   server;
   tools;
   providerOptions;
+  maxTokens;
   model = null;
   constructor(config2) {
     super(config2, "callTool" in config2.server ? config2.server : void 0);
     this.server = config2.server;
     this.tools = config2.tools;
     this.providerOptions = config2.providerOptions;
+    this.maxTokens = config2.maxTokens;
   }
   initProvider() {
     if (!this.model) {
       const provider = new MCPSamplingProvider({
-        server: this.server
+        server: this.server,
+        maxTokens: this.maxTokens
       });
       this.model = provider.languageModel(this.providerOptions);
     }
@@ -20878,9 +19030,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) {
@@ -20911,7 +19060,7 @@ var AISamplingExecutor = class extends BaseAIExecutor {
 
 // __mcpc__core_latest/node_modules/@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,
@@ -20920,7 +19069,8 @@ function registerAISamplingTool(server, params) {
     tools: toolNameToDetailList,
     providerOptions,
     maxSteps,
-    tracingEnabled
+    tracingEnabled,
+    maxTokens
   });
   const toolDescription = CompiledPrompts.samplingToolDescription({
     toolName: name,
@@ -20933,9 +19083,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
     });
   });
@@ -20956,7 +19120,8 @@ var createAISamplingModePlugin = () => ({
       toolNameToDetailList: context2.toolNameToDetailList,
       providerOptions: opts.providerOptions,
       maxSteps: opts.maxSteps,
-      tracingEnabled: opts.tracingEnabled
+      tracingEnabled: opts.tracingEnabled,
+      maxTokens: opts.maxTokens
     });
   }
 });
@@ -20988,12 +19153,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) {
@@ -21045,9 +19204,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
     });
   });
@@ -21084,9 +19257,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
@@ -22064,14 +20234,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) {
@@ -22190,13 +20352,13 @@ var ComposableMCPServer = class extends Server {
 };
 
 // __mcpc__core_latest/node_modules/@mcpc/core/src/utils/common/env.js
-var import_node_process7 = __toESM(require("node:process"), 1);
-var isProdEnv = () => import_node_process7.default.env.NODE_ENV === "production";
-var isSCF = () => Boolean(import_node_process7.default.env.SCF_RUNTIME || import_node_process7.default.env.PROD_SCF);
+var import_node_process6 = __toESM(require("node:process"), 1);
+var isProdEnv = () => import_node_process6.default.env.NODE_ENV === "production";
+var isSCF = () => Boolean(import_node_process6.default.env.SCF_RUNTIME || import_node_process6.default.env.PROD_SCF);
 if (isSCF()) {
   console.log({
     isSCF: isSCF(),
-    SCF_RUNTIME: import_node_process7.default.env.SCF_RUNTIME
+    SCF_RUNTIME: import_node_process6.default.env.SCF_RUNTIME
   });
 }