@mcpc-tech/plugin-markdown-loader 0.0.8 → 0.0.9

package/index.mjs

@@ -2,2003 +2,6 @@
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
 
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/compose.js
-import { CallToolRequestSchema, ListToolsRequestSchema, SetLevelRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/schema.js
-var schemaSymbol = Symbol.for("mcpc.schema");
-var vercelSchemaSymbol = Symbol.for("vercel.ai.schema");
-var validatorSymbol = Symbol.for("mcpc.validator");
-function jsonSchema(schema, options = {}) {
-  if (isWrappedSchema(schema)) {
-    return schema;
-  }
-  return {
-    [schemaSymbol]: true,
-    [validatorSymbol]: true,
-    _type: void 0,
-    jsonSchema: schema,
-    validate: options.validate
-  };
-}
-function isWrappedSchema(value) {
-  return typeof value === "object" && value !== null && (schemaSymbol in value && value[schemaSymbol] === true || vercelSchemaSymbol in value && value[vercelSchemaSymbol] === true);
-}
-function extractJsonSchema(schema) {
-  if (isWrappedSchema(schema)) {
-    return schema.jsonSchema;
-  }
-  return schema;
-}
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/compose.js
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__utils/src/json.js
-import { jsonrepair } from "jsonrepair";
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__utils/src/ai.js
-var p = (template, options = {}) => {
-  const { missingVariableHandling = "warn" } = options;
-  const names = /* @__PURE__ */ new Set();
-  const regex = /\{((\w|\.)+)\}/g;
-  let match;
-  while ((match = regex.exec(template)) !== null) {
-    names.add(match[1]);
-  }
-  const required = Array.from(names);
-  return (input) => {
-    let result = template;
-    for (const name of required) {
-      const key = name;
-      const value = input[key];
-      const re = new RegExp(`\\{${String(name)}\\}`, "g");
-      if (value !== void 0 && value !== null) {
-        result = result.replace(re, String(value));
-      } else {
-        switch (missingVariableHandling) {
-          case "error":
-            throw new Error(`Missing variable "${String(name)}" in input for template.`);
-          case "empty":
-            result = result.replace(re, "");
-            break;
-          case "warn":
-          case "ignore":
-          default:
-            break;
-        }
-      }
-    }
-    return result;
-  };
-};
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__utils/src/tool-tags.js
-import { load } from "cheerio";
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__utils/src/transport/sse.js
-import { JSONRPCMessageSchema } from "@modelcontextprotocol/sdk/types.js";
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__http/server_sent_event_stream.js
-var NEWLINE_REGEXP = /\r\n|\r|\n/;
-var encoder = new TextEncoder();
-function assertHasNoNewline(value, varName, errPrefix) {
-  if (value.match(NEWLINE_REGEXP) !== null) {
-    throw new SyntaxError(`${errPrefix}: ${varName} cannot contain a newline`);
-  }
-}
-function stringify(message) {
-  const lines = [];
-  if (message.comment) {
-    assertHasNoNewline(message.comment, "`message.comment`", "Cannot serialize message");
-    lines.push(`:${message.comment}`);
-  }
-  if (message.event) {
-    assertHasNoNewline(message.event, "`message.event`", "Cannot serialize message");
-    lines.push(`event:${message.event}`);
-  }
-  if (message.data) {
-    message.data.split(NEWLINE_REGEXP).forEach((line) => lines.push(`data:${line}`));
-  }
-  if (message.id) {
-    assertHasNoNewline(message.id.toString(), "`message.id`", "Cannot serialize message");
-    lines.push(`id:${message.id}`);
-  }
-  if (message.retry) lines.push(`retry:${message.retry}`);
-  return encoder.encode(lines.join("\n") + "\n\n");
-}
-var ServerSentEventStream = class extends TransformStream {
-  constructor() {
-    super({
-      transform: (message, controller) => {
-        controller.enqueue(stringify(message));
-      }
-    });
-  }
-};
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/common/config.js
-import process from "node:process";
-var GEMINI_PREFERRED_FORMAT = process.env.GEMINI_PREFERRED_FORMAT === "0" ? false : true;
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/common/json.js
-import { jsonrepair as jsonrepair2 } from "jsonrepair";
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/common/provider.js
-var createModelCompatibleJSONSchema = (schema) => {
-  const validatorOnlyKeys = [
-    "errorMessage"
-  ];
-  const geminiRestrictedKeys = GEMINI_PREFERRED_FORMAT ? [
-    "additionalProperties"
-  ] : [];
-  const keysToRemove = /* @__PURE__ */ new Set([
-    ...validatorOnlyKeys,
-    ...geminiRestrictedKeys
-  ]);
-  let cleanSchema = schema;
-  if (GEMINI_PREFERRED_FORMAT) {
-    const { oneOf: _oneOf, allOf: _allOf, anyOf: _anyOf, ...rest } = schema;
-    cleanSchema = rest;
-  }
-  const cleanRecursively = (obj) => {
-    if (Array.isArray(obj)) {
-      return obj.map(cleanRecursively);
-    }
-    if (obj && typeof obj === "object") {
-      const result = {};
-      for (const [key, value] of Object.entries(obj)) {
-        if (!keysToRemove.has(key)) {
-          result[key] = cleanRecursively(value);
-        }
-      }
-      return result;
-    }
-    return obj;
-  };
-  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 record = obj;
-      if ("jsonSchema" in record && typeof record.jsonSchema === "object" && record.jsonSchema !== null) {
-        return cleanRecursively(record.jsonSchema);
-      }
-      const result = {};
-      for (const [key, value] of Object.entries(record)) {
-        if (!INTERNAL_SCHEMA_KEYS.has(key)) {
-          result[key] = cleanRecursively(value);
-        }
-      }
-      return result;
-    }
-    return obj;
-  };
-  return cleanRecursively(schema);
-};
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
-import process2 from "node:process";
-var mcpClientPool = /* @__PURE__ */ new Map();
-var cleanupAllPooledClients = async () => {
-  const entries = Array.from(mcpClientPool.entries());
-  mcpClientPool.clear();
-  await Promise.all(entries.map(async ([, { client }]) => {
-    try {
-      await client.close();
-    } catch (err) {
-      console.error("Error closing MCP client:", err);
-    }
-  }));
-};
-process2.once?.("exit", () => {
-  cleanupAllPooledClients();
-});
-process2.once?.("SIGINT", () => {
-  cleanupAllPooledClients().finally(() => process2.exit(0));
-});
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/config-plugin.js
-var createConfigPlugin = () => ({
-  name: "built-in-config",
-  version: "1.0.0",
-  enforce: "pre",
-  transformTool: (tool2, context2) => {
-    const server = context2.server;
-    const config = server.findToolConfig?.(context2.toolName);
-    if (config?.description) {
-      tool2.description = config.description;
-    }
-    return tool2;
-  }
-});
-var config_plugin_default = createConfigPlugin();
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/tool-name-mapping-plugin.js
-var createToolNameMappingPlugin = () => ({
-  name: "built-in-tool-name-mapping",
-  version: "1.0.0",
-  enforce: "pre",
-  transformTool: (tool2, context2) => {
-    const server = context2.server;
-    const toolName = context2.toolName;
-    const originalName = tool2._originalName || toolName;
-    const dotNotation = originalName.replace(/_/g, ".");
-    const underscoreNotation = originalName.replace(/\./g, "_");
-    if (dotNotation !== originalName && server.toolNameMapping) {
-      server.toolNameMapping.set(dotNotation, toolName);
-    }
-    if (underscoreNotation !== originalName && server.toolNameMapping) {
-      server.toolNameMapping.set(underscoreNotation, toolName);
-    }
-    if (originalName !== toolName && server.toolNameMapping) {
-      server.toolNameMapping.set(originalName, toolName);
-    }
-    return tool2;
-  }
-});
-var tool_name_mapping_plugin_default = createToolNameMappingPlugin();
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/logger.js
-var LOG_LEVELS = {
-  debug: 0,
-  info: 1,
-  notice: 2,
-  warning: 3,
-  error: 4,
-  critical: 5,
-  alert: 6,
-  emergency: 7
-};
-var MCPLogger = class _MCPLogger {
-  server;
-  loggerName;
-  minLevel = "debug";
-  constructor(loggerName = "mcpc", server) {
-    this.loggerName = loggerName;
-    this.server = server;
-  }
-  setServer(server) {
-    this.server = server;
-  }
-  setLevel(level) {
-    this.minLevel = level;
-  }
-  async log(level, data) {
-    if (LOG_LEVELS[level] < LOG_LEVELS[this.minLevel]) {
-      return;
-    }
-    this.logToConsole(level, data);
-    if (this.server) {
-      try {
-        await this.server.sendLoggingMessage({
-          level,
-          logger: this.loggerName,
-          data
-        });
-      } catch {
-      }
-    }
-  }
-  logToConsole(level, data) {
-    const message = typeof data === "string" ? data : JSON.stringify(data);
-    const prefix = `[${this.loggerName}:${level}]`;
-    console.error(prefix, message);
-  }
-  debug(data) {
-    return this.log("debug", data);
-  }
-  info(data) {
-    return this.log("info", data);
-  }
-  notice(data) {
-    return this.log("notice", data);
-  }
-  warning(data) {
-    return this.log("warning", data);
-  }
-  error(data) {
-    return this.log("error", data);
-  }
-  critical(data) {
-    return this.log("critical", data);
-  }
-  alert(data) {
-    return this.log("alert", data);
-  }
-  emergency(data) {
-    return this.log("emergency", data);
-  }
-  child(name) {
-    const child = new _MCPLogger(`${this.loggerName}.${name}`, this.server);
-    child.setLevel(this.minLevel);
-    return child;
-  }
-};
-var logger = new MCPLogger("mcpc");
-function createLogger(name, server) {
-  return new MCPLogger(name, server);
-}
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/logging-plugin.js
-var createLoggingPlugin = (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 (compact) {
-        const pluginCount = context2.pluginNames.length;
-        const { stats } = context2;
-        await logger2.info(`[${context2.toolName}] ${pluginCount} plugins \u2022 ${stats.publicTools} public \u2022 ${stats.hiddenTools} hidden`);
-      } else if (verbose) {
-        await logger2.info(`[${context2.toolName}] Composition complete`);
-        await logger2.info(`   \u251C\u2500 Plugins: ${context2.pluginNames.join(", ")}`);
-        const { stats } = context2;
-        const server = context2.server;
-        const publicTools = Array.from(new Set(server.getPublicToolNames().map(String)));
-        const internalTools = Array.from(new Set(server.getInternalToolNames().map(String)));
-        const hiddenTools = Array.from(new Set(server.getHiddenToolNames().map(String)));
-        const normalInternal = internalTools.filter((name) => !hiddenTools.includes(name));
-        if (publicTools.length > 0) {
-          await logger2.info(`   \u251C\u2500 Public: ${publicTools.join(", ")}`);
-        }
-        if (internalTools.length > 0) {
-          const parts = [];
-          if (normalInternal.length > 0) {
-            parts.push(normalInternal.join(", "));
-          }
-          if (hiddenTools.length > 0) {
-            parts.push(`(${hiddenTools.join(", ")})`);
-          }
-          await logger2.info(`   \u251C\u2500 Internal: ${parts.join(", ")}`);
-        }
-        await logger2.info(`   \u2514\u2500 Total: ${stats.totalTools} tools`);
-      }
-    }
-  };
-};
-var logging_plugin_default = createLoggingPlugin({
-  verbose: true,
-  compact: false
-});
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/prompts/index.js
-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 tasks by calling its tools, following the <manual/>, obeying the <rules/>, and using the <format/>.
-
-<manual>
-{description}
-</manual>
-
-<parameters>
-\`tool\` - Which tool to execute: "man" to get schemas, or a tool name to execute
-\`args\` - For "man": { tools: ["tool1", "tool2"] }. For other tools: tool parameters that strictly adhere to the tool's JSON schema.
-</parameters>
-
-<rules>
-1. **First call**: Use \`man\` to get tool schemas you need
-2. **Execute tools**: Use tool name in \`tool\` and parameters in \`args\`
-</rules>
-
-<format>
-Get tool schemas: \`{ "tool": "man", "args": { "tools": ["tool1", "tool2"] } }\`
-Execute a tool: \`{ "tool": "tool_name", "args": { /* parameters */ } }\`
-</format>`,
-  /**
-   * Compact system prompt for autonomous MCP execution (when manual is provided)
-   *
-   * Uses simplified description with progressive disclosure:
-   * - Short description shown by default
-   * - Use `man` command with args `{ manual: true }` to get full manual
-   */
-  AUTONOMOUS_EXECUTION_COMPACT: `Agentic tool \`{toolName}\` that executes tasks by calling its tools, following the <rules/> and using the <format/>.
-
-{description}
-
-<rules>
-1. **First call**: Use \`man\` to get tool schemas and full manual
-2. **Execute tools**: Use tool name in \`tool\` and parameters in \`args\`
-</rules>
-
-<format>
-Get manual + schemas: \`{ "tool": "man", "args": { "tools": ["tool1"], "manual": true } }\`
-Execute a tool: \`{ "tool": "tool_name", "args": { /* parameters */ } }\`
-</format>`,
-  /**
-   * Tool description for sampling tools (shown in MCP tools list)
-   * Explains how to use prompt and context parameters
-   */
-  SAMPLING_TOOL_DESCRIPTION: `Subagent tool \`{toolName}\` that executes complex tasks.
-
-You must follow the <manual/>, obey the <rules/>, and use the <format/>.
-
-<manual>
-{description}
-</manual>
-
-<format>
-\`prompt\` - The task to be completed (e.g., "organize my desktop files")
-\`context\` - Execution context object (e.g., { cwd: "/path/to/dir" })
-</format>
-
-<rules>
-1. 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>`,
-  /**
-   * 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.
-   */
-  AI_LOOP_SYSTEM: `Agent \`{toolName}\` that completes tasks by calling tools.
-
-<manual>
-{description}
-</manual>
-
-<rules>
-{rules}
-</rules>{context}`
-};
-var ResponseTemplates = {
-  /**
-   * Error response templates
-   */
-  ERROR_RESPONSE: `Validation failed: {errorMessage}
-
-Adjust parameters and retry.`,
-  /**
-   * Security validation messages
-   */
-  SECURITY_VALIDATION: {
-    PASSED: `Security check passed: {operation} on {path}`,
-    FAILED: `Security check failed: {operation} on {path}`
-  },
-  /**
-   * Audit log messages
-   */
-  AUDIT_LOG: `[{timestamp}] {level}: {action} on {resource}{userInfo}`
-};
-var CompiledPrompts = {
-  autonomousExecution: p(SystemPrompts.AUTONOMOUS_EXECUTION),
-  autonomousExecutionCompact: p(SystemPrompts.AUTONOMOUS_EXECUTION_COMPACT),
-  samplingToolDescription: p(SystemPrompts.SAMPLING_TOOL_DESCRIPTION),
-  aiLoopSystem: p(SystemPrompts.AI_LOOP_SYSTEM),
-  errorResponse: p(ResponseTemplates.ERROR_RESPONSE),
-  securityPassed: p(ResponseTemplates.SECURITY_VALIDATION.PASSED),
-  securityFailed: p(ResponseTemplates.SECURITY_VALIDATION.FAILED),
-  auditLog: p(ResponseTemplates.AUDIT_LOG)
-};
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/factories/args-def-factory.js
-function createArgsDefFactory(_name, _allToolNames, _depGroups, _predefinedSteps, _ensureStepActions) {
-  return {
-    forSampling: function() {
-      return {
-        type: "object",
-        description: "Provide prompt for autonomous tool execution",
-        properties: {
-          prompt: {
-            type: "string",
-            description: "The task to be completed autonomously by the agentic system using available tools"
-          },
-          context: {
-            type: "object",
-            description: "Execution context, e.g., { cwd: '/path/to/dir' }. Any relevant fields allowed.",
-            additionalProperties: true
-          }
-        },
-        required: [
-          "prompt",
-          "context"
-        ],
-        errorMessage: {
-          required: {
-            prompt: "Missing required field 'prompt'. Please provide a clear task description.",
-            context: "Missing required field 'context'. Please provide relevant context (e.g., { cwd: '...' })."
-          }
-        }
-      };
-    },
-    /**
-     * Agentic schema - simplified Unix-style interface
-     *
-     * Only two fields:
-     * - `tool`: which tool to execute (enum includes "man" + all tool names)
-     * - `args`: object with parameters. For "man": { tools: ["a", "b"] }. For others: tool parameters.
-     */
-    forAgentic: function(allToolNames) {
-      const toolEnum = [
-        "man",
-        ...allToolNames
-      ];
-      return {
-        type: "object",
-        properties: {
-          tool: {
-            type: "string",
-            enum: toolEnum,
-            description: 'Which tool to execute. Use "man" to get tool schemas, or a tool name to execute.',
-            errorMessage: {
-              enum: `Invalid tool. Available: ${toolEnum.join(", ")}`
-            }
-          },
-          args: {
-            type: "object",
-            description: `For "man": { tools: ["tool1", "tool2"], manual?: true }. For other tools: tool parameters that strictly adhere to the tool's JSON schema.`
-          }
-        },
-        required: [
-          "tool"
-        ],
-        additionalProperties: false
-      };
-    },
-    /**
-     * Schema for "man" command args validation
-     * Expected format: { tools: ["tool1", "tool2"], manual?: true }
-     *
-     * - Always require `tools`
-     * - Allow empty tools only when `manual: true`
-     */
-    forMan: function(allToolNames) {
-      return {
-        type: "object",
-        properties: {
-          tools: {
-            type: "array",
-            items: {
-              type: "string",
-              enum: allToolNames,
-              errorMessage: {
-                enum: `Invalid tool name. Available: ${allToolNames.join(", ")}`
-              }
-            }
-          },
-          manual: {
-            type: "boolean",
-            description: "Set to true to get the full manual for this agent (progressive disclosure)."
-          }
-        },
-        required: [
-          "tools"
-        ],
-        additionalProperties: false,
-        anyOf: [
-          // manual-only (tools can be empty)
-          {
-            properties: {
-              manual: {
-                enum: [
-                  true
-                ]
-              },
-              tools: {
-                minItems: 0
-              }
-            },
-            required: [
-              "tools",
-              "manual"
-            ]
-          },
-          // tool schemas (require at least one tool)
-          {
-            properties: {
-              tools: {
-                minItems: 1,
-                errorMessage: {
-                  minItems: "At least one tool name is required"
-                }
-              }
-            },
-            required: [
-              "tools"
-            ]
-          }
-        ],
-        errorMessage: {
-          required: {
-            tools: 'Missing "tools" field. Expected: { tools: ["tool1", "tool2"] }'
-          }
-        }
-      };
-    }
-  };
-}
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/schema-validator.js
-import { Ajv } from "ajv";
-import addFormats from "ajv-formats";
-import ajvErrors from "ajv-errors";
-import { AggregateAjvError } from "@segment/ajv-human-errors";
-var ajv = new Ajv({
-  allErrors: true,
-  verbose: true,
-  strict: false
-});
-addFormats.default(ajv);
-ajvErrors.default(ajv);
-function validateSchema(data, schema) {
-  const validate = ajv.compile(schema);
-  if (!validate(data)) {
-    const errors = validate.errors;
-    const customErrors = errors.filter((err) => err.keyword === "errorMessage");
-    if (customErrors.length > 0) {
-      const messages = [
-        ...new Set(customErrors.map((err) => err.message))
-      ];
-      return {
-        valid: false,
-        error: messages.join("; ")
-      };
-    }
-    const aggregateError = new AggregateAjvError(errors);
-    return {
-      valid: false,
-      error: aggregateError.message
-    };
-  }
-  return {
-    valid: true
-  };
-}
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/tracing.js
-import { context, SpanStatusCode, trace } from "@opentelemetry/api";
-import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
-import { BatchSpanProcessor, ConsoleSpanExporter, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { Resource } from "@opentelemetry/resources";
-import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
-var tracerProvider = null;
-var tracer = null;
-var isInitialized = false;
-function initializeTracing(config = {}) {
-  if (isInitialized) {
-    return;
-  }
-  const { enabled = true, serviceName = "mcpc-sampling", serviceVersion = "0.2.0", exportTo = "console", otlpEndpoint = "http://localhost:4318/v1/traces", otlpHeaders = {} } = config;
-  if (!enabled) {
-    isInitialized = true;
-    return;
-  }
-  const resource = Resource.default().merge(new Resource({
-    [ATTR_SERVICE_NAME]: serviceName,
-    [ATTR_SERVICE_VERSION]: serviceVersion
-  }));
-  tracerProvider = new NodeTracerProvider({
-    resource
-  });
-  if (exportTo === "console") {
-    tracerProvider.addSpanProcessor(new SimpleSpanProcessor(new ConsoleSpanExporter()));
-  } else if (exportTo === "otlp") {
-    const otlpExporter = new OTLPTraceExporter({
-      url: otlpEndpoint,
-      headers: otlpHeaders
-    });
-    tracerProvider.addSpanProcessor(new BatchSpanProcessor(otlpExporter));
-  }
-  tracerProvider.register();
-  tracer = trace.getTracer(serviceName, serviceVersion);
-  isInitialized = true;
-}
-function getTracer() {
-  if (!isInitialized) {
-    initializeTracing();
-  }
-  return tracer;
-}
-function startSpan(name, attributes, parent) {
-  const tracer2 = getTracer();
-  const ctx = parent ? trace.setSpan(context.active(), parent) : void 0;
-  return tracer2.startSpan(name, {
-    attributes
-  }, ctx);
-}
-function endSpan(span, error) {
-  if (error) {
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: error.message
-    });
-    span.recordException(error);
-  } else {
-    span.setStatus({
-      code: SpanStatusCode.OK
-    });
-  }
-  span.end();
-}
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-executor.js
-import process3 from "node:process";
-var AgenticExecutor = class {
-  name;
-  allToolNames;
-  toolNameToDetailList;
-  server;
-  manual;
-  logger;
-  tracingEnabled;
-  toolSchemaMap;
-  constructor(name, allToolNames, toolNameToDetailList, server, manual) {
-    this.name = name;
-    this.allToolNames = allToolNames;
-    this.toolNameToDetailList = toolNameToDetailList;
-    this.server = server;
-    this.manual = manual;
-    this.tracingEnabled = false;
-    this.logger = createLogger(`mcpc.agentic.${name}`, server);
-    this.toolSchemaMap = new Map(toolNameToDetailList);
-    try {
-      this.tracingEnabled = process3.env.MCPC_TRACING_ENABLED === "true";
-      if (this.tracingEnabled) {
-        initializeTracing({
-          enabled: true,
-          serviceName: `mcpc-agentic-${name}`,
-          exportTo: process3.env.MCPC_TRACING_EXPORT ?? "otlp",
-          otlpEndpoint: process3.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
-        });
-      }
-    } catch {
-      this.tracingEnabled = false;
-    }
-  }
-  async execute(args, schema, parentSpan) {
-    const executeSpan = this.tracingEnabled ? startSpan("mcpc.agentic_execute", {
-      agent: this.name,
-      tool: String(args.tool ?? "unknown"),
-      args: JSON.stringify(args)
-    }, parentSpan ?? void 0) : null;
-    try {
-      const validationResult = this.validate(args, schema);
-      if (!validationResult.valid) {
-        if (executeSpan) {
-          executeSpan.setAttributes({
-            validationError: true,
-            errorMessage: validationResult.error || "Validation failed"
-          });
-          endSpan(executeSpan);
-        }
-        this.logger.warning({
-          message: "Validation failed",
-          tool: args.tool,
-          error: validationResult.error
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: CompiledPrompts.errorResponse({
-                errorMessage: validationResult.error || "Validation failed"
-              })
-            }
-          ],
-          isError: true
-        };
-      }
-      const tool2 = args.tool;
-      if (tool2 === "man") {
-        const createArgsDef = createArgsDefFactory(this.name, this.allToolNames, {});
-        const manSchema = createArgsDef.forMan(this.allToolNames);
-        const manValidation = validateSchema(args.args ?? {}, manSchema);
-        if (!manValidation.valid) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Invalid args for "man": ${manValidation.error}`
-              }
-            ],
-            isError: true
-          };
-        }
-        const argsObj = args.args;
-        const tools = argsObj.tools ?? [];
-        const wantManual = argsObj.manual === true;
-        const wantTools = tools.length > 0;
-        if (wantTools && wantManual) {
-          const toolSchemas = this.handleManCommand(tools, null);
-          const manualResult = this.handleManualRequest(null);
-          if (executeSpan) {
-            executeSpan.setAttributes({
-              toolType: "man",
-              requestType: "tools+manual"
-            });
-            endSpan(executeSpan);
-          }
-          return {
-            content: [
-              ...toolSchemas.content,
-              {
-                type: "text",
-                text: "\n---\n"
-              },
-              ...manualResult.content
-            ]
-          };
-        }
-        if (wantManual) {
-          return this.handleManualRequest(executeSpan);
-        }
-        return this.handleManCommand(tools, executeSpan);
-      }
-      const toolArgs = args.args || {};
-      return await this.executeTool(tool2, toolArgs, executeSpan);
-    } catch (error) {
-      if (executeSpan) {
-        endSpan(executeSpan, error);
-      }
-      this.logger.error({
-        message: "Unexpected error in execute",
-        error: String(error)
-      });
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Unexpected error: ${error instanceof Error ? error.message : String(error)}`
-          }
-        ],
-        isError: true
-      };
-    }
-  }
-  /**
-   * Handle `man { manual: true }` - return full manual for progressive disclosure
-   */
-  handleManualRequest(executeSpan) {
-    if (executeSpan) {
-      executeSpan.setAttributes({
-        toolType: "man",
-        requestType: "manual"
-      });
-    }
-    if (!this.manual) {
-      if (executeSpan) {
-        endSpan(executeSpan);
-      }
-      return {
-        content: [
-          {
-            type: "text",
-            text: "No manual available for this agent."
-          }
-        ]
-      };
-    }
-    if (executeSpan) {
-      executeSpan.setAttributes({
-        success: true
-      });
-      endSpan(executeSpan);
-    }
-    return {
-      content: [
-        {
-          type: "text",
-          text: this.manual
-        }
-      ]
-    };
-  }
-  /**
-   * 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 schemas = requestedTools.map((toolName) => {
-      const toolDetail = this.toolSchemaMap.get(toolName);
-      if (toolDetail) {
-        const cleanedSchema = cleanToolSchema(toolDetail);
-        return `<tool_definition name="${toolName}">
-${JSON.stringify(cleanedSchema, null, 2)}
-</tool_definition>`;
-      }
-      return null;
-    }).filter(Boolean);
-    if (executeSpan) {
-      executeSpan.setAttributes({
-        schemasReturned: schemas.length,
-        success: true
-      });
-      endSpan(executeSpan);
-    }
-    return {
-      content: [
-        {
-          type: "text",
-          text: schemas.length > 0 ? schemas.join("\n\n") : "No schemas found for requested tools."
-        }
-      ]
-    };
-  }
-  /**
-   * Execute a tool with runtime validation
-   */
-  async executeTool(tool2, toolArgs, executeSpan) {
-    const isExternalTool = this.toolNameToDetailList.some(([name]) => name === tool2);
-    const isInternalTool = this.allToolNames.includes(tool2);
-    if (!isExternalTool && !isInternalTool) {
-      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
-      };
-    }
-    if (isExternalTool) {
-      const externalTool = this.toolNameToDetailList.find(([name]) => name === tool2);
-      const [, toolDetail] = externalTool;
-      if (toolDetail.inputSchema) {
-        const rawSchema = extractJsonSchema(toolDetail.inputSchema);
-        const validation = validateSchema(toolArgs, rawSchema);
-        if (!validation.valid) {
-          if (executeSpan) {
-            executeSpan.setAttributes({
-              validationError: true,
-              errorMessage: validation.error
-            });
-            endSpan(executeSpan);
-          }
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Parameter validation failed for "${tool2}": ${validation.error}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
-    }
-    const toolType = isExternalTool ? "external" : "internal";
-    if (executeSpan) {
-      executeSpan.setAttributes({
-        toolType,
-        selectedTool: tool2
-      });
-    }
-    this.logger.debug({
-      message: `Executing ${toolType} tool`,
-      tool: tool2
-    });
-    try {
-      const result = await this.server.callTool(tool2, toolArgs, {
-        agentName: this.name
-      });
-      const callToolResult = result ?? {
-        content: []
-      };
-      if (executeSpan) {
-        executeSpan.setAttributes({
-          success: true,
-          isError: !!callToolResult.isError,
-          resultContentLength: callToolResult.content?.length || 0
-        });
-        endSpan(executeSpan);
-      }
-      return callToolResult;
-    } catch (error) {
-      if (executeSpan) {
-        endSpan(executeSpan, error);
-      }
-      this.logger.error({
-        message: `Error executing ${toolType} tool`,
-        tool: tool2,
-        error: String(error)
-      });
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error executing tool "${tool2}": ${error instanceof Error ? error.message : String(error)}`
-          }
-        ],
-        isError: true
-      };
-    }
-  }
-  validate(args, schema) {
-    return validateSchema(args, schema);
-  }
-};
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-tool-registrar.js
-function registerAgenticTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList, manual }) {
-  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
-  const agenticExecutor = new AgenticExecutor(name, allToolNames, toolNameToDetailList, server, manual);
-  description = manual ? CompiledPrompts.autonomousExecutionCompact({
-    toolName: name,
-    description
-  }) : CompiledPrompts.autonomousExecution({
-    toolName: name,
-    description
-  });
-  const agenticArgsDef = createArgsDef.forAgentic(allToolNames);
-  const schema = agenticArgsDef;
-  server.tool(name, description, jsonSchema(createModelCompatibleJSONSchema(schema)), async (args) => {
-    return await agenticExecutor.execute(args, schema);
-  });
-}
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/mode-agentic-plugin.js
-var createAgenticModePlugin = () => ({
-  name: "mode-agentic",
-  version: "2.0.0",
-  // Only apply to agentic mode
-  apply: "agentic",
-  // Register the agent tool
-  registerAgentTool: (context2) => {
-    registerAgenticTool(context2.server, {
-      description: context2.description,
-      name: context2.name,
-      allToolNames: context2.allToolNames,
-      depGroups: context2.depGroups,
-      toolNameToDetailList: context2.toolNameToDetailList,
-      manual: context2.manual
-    });
-  }
-});
-var mode_agentic_plugin_default = createAgenticModePlugin();
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/utils.js
-function convertAISDKToMCPMessages(prompt) {
-  const messages = [];
-  for (const msg of prompt) {
-    if (msg.role === "system") continue;
-    const role = msg.role === "assistant" ? "assistant" : "user";
-    const textParts = msg.content.filter((c) => c.type === "text");
-    const toolCalls = msg.content.filter((c) => c.type === "tool-call");
-    const toolResults = msg.content.filter((c) => c.type === "tool-result");
-    const parts = [];
-    if (textParts.length > 0) {
-      parts.push(textParts.map((c) => c.text).join("\n"));
-    }
-    if (toolCalls.length > 0) {
-      const calls = toolCalls.map((c) => {
-        const call = c;
-        const toolArgs = call.args ?? call.input ?? {};
-        return `<use_tool tool="${call.toolName}">
-${JSON.stringify(toolArgs)}
-</use_tool>`;
-      });
-      parts.push(calls.join("\n"));
-    }
-    if (toolResults.length > 0) {
-      const results = toolResults.map((c) => {
-        const result = c;
-        const resultValue = result.result ?? result.output ?? "undefined";
-        const output = JSON.stringify(resultValue);
-        return `Tool "${result.toolName}" result:
-${output}`;
-      });
-      parts.push(results.join("\n\n"));
-    }
-    const text = parts.join("\n\n");
-    if (text) {
-      messages.push({
-        role,
-        content: {
-          type: "text",
-          text
-        }
-      });
-    }
-  }
-  return messages;
-}
-function convertMCPStopReasonToAISDK(stopReason) {
-  if (stopReason === "endTurn" || stopReason === "stopSequence") {
-    return "stop";
-  }
-  if (stopReason === "maxTokens") return "length";
-  return stopReason ?? "unknown";
-}
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/language-model.js
-var DEFAULT_MAX_TOKENS = 128e3;
-var MCPSamplingLanguageModel = class {
-  specificationVersion = "v2";
-  provider;
-  modelId;
-  supportedUrls = {};
-  server;
-  modelPreferences;
-  maxTokens;
-  constructor(config) {
-    this.server = config.server;
-    this.modelId = "";
-    this.provider = "mcp-client";
-    this.modelPreferences = config.modelPreferences;
-    this.maxTokens = config.maxTokens ?? DEFAULT_MAX_TOKENS;
-  }
-  /**
-   * Generate a response using MCP's createMessage capability
-   */
-  async doGenerate(options) {
-    const useNativeTools = this.supportsSamplingTools();
-    this.server.sendLoggingMessage({
-      level: "info",
-      data: `Client supports native tools: ${useNativeTools}`
-    });
-    const messages = this.convertMessages(options.prompt, useNativeTools);
-    this.server.sendLoggingMessage({
-      level: "info",
-      data: `Converted messages for MCP: ${JSON.stringify(messages)}`
-    });
-    let systemPrompt;
-    for (const msg of options.prompt) {
-      if (msg.role === "system") {
-        systemPrompt = msg.content;
-        break;
-      }
-    }
-    this.server.sendLoggingMessage({
-      level: "info",
-      data: `Client supports native tools: ${useNativeTools}`
-    });
-    systemPrompt = this.injectResponseFormatInstructions(systemPrompt, options.responseFormat, useNativeTools);
-    systemPrompt = this.injectToolInstructions(systemPrompt, options.tools, useNativeTools);
-    const createMessageParams = {
-      systemPrompt,
-      messages,
-      maxTokens: options.maxOutputTokens ?? this.maxTokens,
-      modelPreferences: this.modelPreferences
-    };
-    if (useNativeTools && options.tools && options.tools.length > 0) {
-      createMessageParams.tools = this.convertAISDKToolsToMCP(options.tools);
-      createMessageParams.toolChoice = {
-        mode: "auto"
-      };
-      this.server.sendLoggingMessage({
-        level: "info",
-        data: `Converted ${options.tools.length} tools to MCP format: ${JSON.stringify(createMessageParams.tools?.map((t) => t.name))}`
-      });
-    } else if (options.tools && options.tools.length > 0) {
-      this.server.sendLoggingMessage({
-        level: "info",
-        data: `Tools provided but not using native mode - injecting into system prompt instead`
-      });
-    }
-    this.server.sendLoggingMessage({
-      level: "info",
-      data: `Calling createMessage with params: ${JSON.stringify({
-        hasSystemPrompt: !!systemPrompt,
-        hasTools: !!createMessageParams.tools,
-        toolCount: createMessageParams.tools?.length || 0,
-        createMessageParams
-      }, null, 2)}`
-    });
-    const result = await this.server.createMessage(createMessageParams);
-    this.server.sendLoggingMessage({
-      level: "info",
-      data: `createMessage result: ${JSON.stringify({
-        contentType: result.content.type,
-        stopReason: result.stopReason,
-        text: result.content
-      })}`
-    });
-    const content = [];
-    if (useNativeTools) {
-      const contentArray = Array.isArray(result.content) ? result.content : [
-        result.content
-      ];
-      for (const block of contentArray) {
-        if (block.type === "text" && "text" in block) {
-          content.push({
-            type: "text",
-            text: block.text
-          });
-        } else if (block.type === "tool_use" && "id" in block && "name" in block) {
-          const toolInput = block.input || {};
-          content.push({
-            type: "tool-call",
-            toolCallId: block.id,
-            toolName: block.name,
-            input: JSON.stringify(toolInput)
-          });
-        }
-      }
-    } else {
-      if (result.content.type === "text" && result.content.text) {
-        const { text, toolCalls } = this.extractToolCalls(result.content.text, options.tools);
-        if (text.trim()) {
-          const textContent = {
-            type: "text",
-            text
-          };
-          content.push(textContent);
-        }
-        content.push(...toolCalls);
-      }
-    }
-    const finishReason = this.mapStopReason(result.stopReason);
-    return {
-      content,
-      finishReason,
-      usage: {
-        inputTokens: void 0,
-        outputTokens: void 0,
-        totalTokens: 0
-      },
-      request: {
-        body: JSON.stringify({
-          systemPrompt,
-          messages
-        })
-      },
-      response: {
-        modelId: result.model
-      },
-      warnings: []
-    };
-  }
-  /**
-   * Stream a response using MCP's createMessage capability
-   *
-   * Since MCP doesn't support native streaming, we generate the full response
-   * and emit it as stream events following AI SDK's protocol.
-   */
-  async doStream(options) {
-    const result = await this.doGenerate(options);
-    const stream = new ReadableStream({
-      start(controller) {
-        if (result.response?.modelId) {
-          controller.enqueue({
-            type: "response-metadata",
-            modelId: result.response.modelId,
-            ...result.response.headers && {
-              headers: result.response.headers
-            }
-          });
-        }
-        let textIndex = 0;
-        for (const part of result.content) {
-          if (part.type === "text") {
-            const id = `text-${++textIndex}`;
-            controller.enqueue({
-              type: "text-start",
-              id
-            });
-            controller.enqueue({
-              type: "text-delta",
-              id,
-              delta: part.text
-            });
-            controller.enqueue({
-              type: "text-end",
-              id
-            });
-          } else if (part.type === "tool-call") {
-            controller.enqueue({
-              type: "tool-call",
-              toolCallId: part.toolCallId,
-              toolName: part.toolName,
-              input: part.input
-            });
-          }
-        }
-        controller.enqueue({
-          type: "finish",
-          finishReason: result.finishReason,
-          usage: result.usage
-        });
-        controller.close();
-      }
-    });
-    return {
-      stream,
-      request: result.request,
-      warnings: result.warnings
-    };
-  }
-  /**
-   * Convert AI SDK messages to MCP sampling format
-   */
-  convertMessages(prompt, useNativeTools) {
-    if (!useNativeTools) {
-      return convertAISDKToMCPMessages(prompt);
-    }
-    const messages = [];
-    for (const msg of prompt) {
-      if (msg.role === "system") continue;
-      const role = msg.role === "assistant" ? "assistant" : "user";
-      const contentBlocks = [];
-      for (const part of msg.content) {
-        if (part.type === "text") {
-          contentBlocks.push({
-            type: "text",
-            text: part.text
-          });
-        } else if (part.type === "tool-call") {
-          const call = part;
-          contentBlocks.push({
-            type: "tool_use",
-            id: call.toolCallId,
-            name: call.toolName,
-            input: call.args ?? call.input ?? {}
-          });
-        } else if (part.type === "tool-result") {
-          const result = part;
-          contentBlocks.push({
-            type: "tool_result",
-            toolUseId: result.toolCallId,
-            // TODO: Handle different result types properly
-            content: [
-              {
-                type: "text",
-                text: result.output.type === "text" ? result.output.value?.toString() : JSON.stringify(result.output)
-              }
-            ]
-          });
-        }
-      }
-      if (contentBlocks.length > 0) {
-        messages.push({
-          role,
-          content: contentBlocks
-        });
-      }
-    }
-    return messages;
-  }
-  /**
-   * Map MCP stop reason to AI SDK finish reason
-   */
-  mapStopReason(stopReason) {
-    return convertMCPStopReasonToAISDK(stopReason);
-  }
-  /**
-   * Check if client supports native tool use in sampling
-   */
-  supportsSamplingTools() {
-    const capabilities = this.server.getClientCapabilities();
-    const supportsTools = !!capabilities?.sampling?.tools;
-    this.server.sendLoggingMessage({
-      level: "info",
-      data: `Client capabilities check: sampling=${!!capabilities?.sampling}, tools=${supportsTools}`
-    });
-    return supportsTools;
-  }
-  /**
-   * Convert AI SDK tools to MCP Tool format
-   */
-  convertAISDKToolsToMCP(tools) {
-    if (!tools || tools.length === 0) return [];
-    return tools.filter((tool2) => tool2.type === "function").map((tool2) => {
-      const toolAny = tool2;
-      return {
-        name: tool2.name,
-        description: toolAny.description || `Tool: ${tool2.name}`,
-        inputSchema: {
-          type: "object",
-          ...toolAny.inputSchema || toolAny.parameters
-        }
-      };
-    });
-  }
-  /**
-   * Inject response format instructions into system prompt
-   *
-   * Only injects formatting instructions in JSON fallback mode.
-   * In native tools mode, structured output is handled by the provider.
-   */
-  injectResponseFormatInstructions(systemPrompt, responseFormat, useNativeTools) {
-    if (!responseFormat) {
-      return systemPrompt;
-    }
-    if (useNativeTools) {
-      return systemPrompt;
-    }
-    let enhanced = systemPrompt || "";
-    if (responseFormat.type === "json") {
-      const jsonPrompt = `
-
-IMPORTANT: You MUST respond with valid JSON only. Do not include any text before or after the JSON.
-- Your response must be a valid JSON object
-- Do not wrap the JSON in markdown code blocks
-- Do not include explanations or comments
-- Ensure all JSON is properly formatted and parseable`;
-      enhanced = enhanced ? `${enhanced}${jsonPrompt}` : jsonPrompt.trim();
-      if (responseFormat.schema) {
-        const schemaInfo = `
-- Follow this JSON schema structure: ${JSON.stringify(responseFormat.schema)}`;
-        enhanced += schemaInfo;
-      }
-    }
-    return enhanced || void 0;
-  }
-  /**
-   * Inject tool definitions into system prompt
-   *
-   * WORKAROUND: MCP sampling currently doesn't support native tools parameter.
-   * This method injects tool descriptions and usage instructions into the system prompt.
-   *
-   * TODO: Remove this workaround when MCP protocol adds native support for:
-   * - tools parameter in createMessage
-   * - Tool calling and function execution
-   * - Structured tool responses
-   */
-  injectToolInstructions(systemPrompt, tools, useNativeTools) {
-    if (!tools || tools.length === 0) {
-      return systemPrompt;
-    }
-    if (useNativeTools) {
-      this.server.sendLoggingMessage({
-        level: "info",
-        data: `Using native tools mode - skipping XML tool injection`
-      });
-      return systemPrompt;
-    }
-    this.server.sendLoggingMessage({
-      level: "info",
-      data: `Injecting ${tools.length} tools into system prompt (fallback mode)`
-    });
-    let enhanced = systemPrompt || "";
-    const toolsPrompt = `
-
-<available_tools>
-You have access to the following tools. To use a tool, respond with this XML format:
-<use_tool tool="tool_name">
-{"param1": "value1", "param2": "value2"}
-</use_tool>
-
-Follow the JSON schema definition for each tool's parameters.
-You can use multiple tools in one response. DO NOT include text before or after tool calls - wait for the tool results first.
-
-<tools>`;
-    const toolDescriptions = tools.map((tool2) => {
-      if (tool2.type === "function") {
-        const toolAny = tool2;
-        const description = toolAny.description || "No description provided";
-        const schema = toolAny.inputSchema || toolAny.parameters;
-        const schemaStr = schema ? `
-<schema>
-${JSON.stringify(schema, null, 2)}
-</schema>` : "";
-        return `
-<tool name="${tool2.name}">
-<description>
-${description}
-</description>${schemaStr}
-</tool>`;
-      } else if (tool2.type === "provider-defined") {
-        return `
-<tool name="${tool2.name}">
-<description>${tool2.id || "No description provided"}</description>
-</tool>`;
-      }
-      return "";
-    }).filter(Boolean).join("");
-    const toolsEnd = `
-</tools>
-</available_tools>`;
-    enhanced = enhanced ? `${enhanced}${toolsPrompt}${toolDescriptions}${toolsEnd}` : `${toolsPrompt}${toolDescriptions}${toolsEnd}`.trim();
-    return enhanced || void 0;
-  }
-  /**
-   * Extract tool calls from LLM response text
-   *
-   * Parses XML-style tool call tags from the response:
-   * <use_tool tool="tool_name">{"arg": "value"}</use_tool>
-   */
-  extractToolCalls(responseText, tools) {
-    if (!tools || tools.length === 0) {
-      return {
-        text: responseText,
-        toolCalls: []
-      };
-    }
-    const toolCalls = [];
-    const toolCallRegex = /<use_tool\s+tool="([^"]+)">([\s\S]*?)<\/use_tool>/g;
-    let match;
-    let lastIndex = 0;
-    const textParts = [];
-    let callIndex = 0;
-    while ((match = toolCallRegex.exec(responseText)) !== null) {
-      textParts.push(responseText.slice(lastIndex, match.index));
-      const toolName = match[1];
-      const argsText = match[2].trim?.();
-      toolCalls.push({
-        type: "tool-call",
-        toolCallId: `call_${Date.now()}_${callIndex++}`,
-        toolName,
-        input: argsText
-      });
-      lastIndex = match.index + match[0].length;
-    }
-    textParts.push(responseText.slice(lastIndex));
-    const text = textParts.join("").trim();
-    return {
-      text,
-      toolCalls
-    };
-  }
-};
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/provider.js
-var MCPSamplingProvider = class {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Create a language model instance for a specific MCP tool/agent
-   *
-   * @param options - Optional configuration overrides
-   * @returns A LanguageModelV2 instance
-   */
-  languageModel(options) {
-    return new MCPSamplingLanguageModel({
-      server: this.config.server,
-      modelPreferences: options?.modelPreferences,
-      maxTokens: this.config.maxTokens
-    });
-  }
-  /**
-   * Shorthand for creating a language model
-   */
-  call(options) {
-    return this.languageModel(options);
-  }
-};
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/client-sampling.js
-import { CreateMessageRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/executors/ai/base-ai-executor.js
-import { trace as trace2 } from "@opentelemetry/api";
-import { jsonSchema as jsonSchema2, stepCountIs, streamText, tool } from "ai";
-var BaseAIExecutor = class {
-  config;
-  tracer;
-  logger;
-  constructor(config, server) {
-    this.config = {
-      maxSteps: 50,
-      tracingEnabled: true,
-      ...config
-    };
-    this.tracer = trace2.getTracer(`mcpc.ai.${config.name}`);
-    this.logger = createLogger(`mcpc.ai.${config.name}`, server);
-  }
-  execute(args) {
-    if (this.config.tracingEnabled) {
-      return this.executeWithTracing(args);
-    }
-    return this.executeCore(args);
-  }
-  executeWithTracing(args) {
-    return this.tracer.startActiveSpan(`mcpc.ai.${this.config.name}`, async (span) => {
-      try {
-        span.setAttributes({
-          "mcpc.executor": this.config.name,
-          "mcpc.type": this.getExecutorType()
-        });
-        const result = await this.executeCore(args, span);
-        span.setAttributes({
-          "mcpc.error": !!result.isError
-        });
-        return result;
-      } catch (error) {
-        span.recordException(error);
-        throw error;
-      } finally {
-        span.end();
-      }
-    });
-  }
-  async executeCore(args, span) {
-    try {
-      const result = streamText({
-        model: this.getModel(),
-        system: this.buildSystemPrompt(args),
-        messages: [
-          {
-            role: "user",
-            content: args.prompt
-          }
-        ],
-        tools: this.buildTools(),
-        stopWhen: stepCountIs(this.config.maxSteps),
-        experimental_telemetry: this.config.tracingEnabled ? {
-          isEnabled: true,
-          functionId: `mcpc.${this.config.name}`,
-          tracer: this.tracer
-        } : void 0,
-        onStepFinish: (step) => {
-          if (span) {
-            span.addEvent("step", {
-              tools: step.toolCalls?.length ?? 0,
-              reason: step.finishReason ?? ""
-            });
-          }
-        }
-      });
-      return {
-        content: [
-          {
-            type: "text",
-            text: await result.text || `Completed in ${(await result.steps)?.length ?? "unknown"} step(s).`
-          }
-        ],
-        isError: false
-      };
-    } catch (error) {
-      this.logger.error({
-        message: "Execution error",
-        error
-      });
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: ${error instanceof Error ? error.message : String(error)}`
-          }
-        ],
-        isError: true
-      };
-    }
-  }
-  buildSystemPrompt(args) {
-    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
-2. Review results after each tool call
-3. Adapt your approach based on outcomes
-4. Continue until task is complete
-5. When complete, provide a summary WITHOUT calling more tools`;
-  }
-  formatContext(context2) {
-    if (!context2 || Object.keys(context2).length === 0) {
-      return "";
-    }
-    return `
-
-<context>
-${JSON.stringify(context2, null, 2)}
-</context>`;
-  }
-  convertToAISDKTool(name, toolDetail, execute) {
-    const cleanedSchema = toolDetail.inputSchema ? cleanToolSchema(toolDetail.inputSchema) : {
-      type: "object"
-    };
-    return tool({
-      description: toolDetail.description || `Tool: ${name}`,
-      inputSchema: jsonSchema2(cleanedSchema),
-      execute
-    });
-  }
-};
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/executors/ai/ai-sampling-executor.js
-var AISamplingExecutor = class extends BaseAIExecutor {
-  server;
-  tools;
-  providerOptions;
-  maxTokens;
-  model = null;
-  constructor(config) {
-    super(config, "callTool" in config.server ? config.server : void 0);
-    this.server = config.server;
-    this.tools = config.tools;
-    this.providerOptions = config.providerOptions;
-    this.maxTokens = config.maxTokens;
-  }
-  initProvider() {
-    if (!this.model) {
-      const provider = new MCPSamplingProvider({
-        server: this.server,
-        maxTokens: this.maxTokens
-      });
-      this.model = provider.languageModel(this.providerOptions);
-    }
-    return this.model;
-  }
-  getModel() {
-    if (!this.model) throw new Error("Model not initialized");
-    return this.model;
-  }
-  getExecutorType() {
-    return "mcp";
-  }
-  buildTools() {
-    const aiTools = {};
-    for (const [name, detail] of this.tools) {
-      aiTools[name] = this.convertToAISDKTool(name, detail, async (input) => {
-        const result = await this.callTool(name, input);
-        return this.formatResult(result);
-      });
-    }
-    return aiTools;
-  }
-  async callTool(name, input) {
-    if ("callTool" in this.server) {
-      return await this.server.callTool(name, input);
-    }
-    const detail = this.tools.find(([n]) => n === name)?.[1];
-    if (detail?.execute) return await detail.execute(input);
-    throw new Error(`Cannot call tool "${name}"`);
-  }
-  formatResult(result) {
-    const texts = result.content?.filter((c) => c.type === "text").map((c) => c.text);
-    return texts?.length ? texts.join("\n") : JSON.stringify(result.content);
-  }
-  execute(args) {
-    this.initProvider();
-    return super.execute(args);
-  }
-};
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/executors/ai/ai-sampling-registrar.js
-function registerAISamplingTool(server, params) {
-  const { name, description, allToolNames, depGroups, toolNameToDetailList, providerOptions, maxSteps = 50, tracingEnabled = false, maxTokens } = params;
-  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
-  const executor = new AISamplingExecutor({
-    name,
-    description,
-    server,
-    tools: toolNameToDetailList,
-    providerOptions,
-    maxSteps,
-    tracingEnabled,
-    maxTokens
-  });
-  const toolDescription = CompiledPrompts.samplingToolDescription({
-    toolName: name,
-    description,
-    toolList: allToolNames.map((n) => `- ${n}`).join("\n")
-  });
-  const argsDef = createArgsDef.forSampling();
-  const schema = allToolNames.length > 0 ? argsDef : {
-    type: "object",
-    properties: {}
-  };
-  server.tool(name, toolDescription, jsonSchema(createModelCompatibleJSONSchema(schema)), (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({
-      prompt,
-      context: args.context
-    });
-  });
-}
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/mode-ai-sampling-plugin.js
-var createAISamplingModePlugin = () => ({
-  name: "mode-ai-sampling",
-  version: "1.0.0",
-  apply: "ai_sampling",
-  registerAgentTool: (context2) => {
-    const opts = context2.options;
-    registerAISamplingTool(context2.server, {
-      description: context2.description,
-      name: context2.name,
-      allToolNames: context2.allToolNames,
-      depGroups: context2.depGroups,
-      toolNameToDetailList: context2.toolNameToDetailList,
-      providerOptions: opts.providerOptions,
-      maxSteps: opts.maxSteps,
-      tracingEnabled: opts.tracingEnabled,
-      maxTokens: opts.maxTokens
-    });
-  }
-});
-var mode_ai_sampling_plugin_default = createAISamplingModePlugin();
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/executors/ai/ai-acp-executor.js
-import { acpTools, createACPProvider } from "@mcpc-tech/acp-ai-provider";
-var AIACPExecutor = class extends BaseAIExecutor {
-  acpSettings;
-  tools;
-  provider = null;
-  model = null;
-  constructor(config) {
-    super(config);
-    this.acpSettings = config.acpSettings;
-    this.tools = config.tools;
-  }
-  initProvider() {
-    if (!this.model) {
-      this.provider = createACPProvider(this.acpSettings);
-      this.model = this.provider.languageModel();
-    }
-    return this.model;
-  }
-  getModel() {
-    if (!this.model) throw new Error("Model not initialized");
-    return this.model;
-  }
-  getExecutorType() {
-    return "acp";
-  }
-  buildTools() {
-    const aiTools = {};
-    for (const [name, detail] of this.tools) {
-      if (!detail.execute) continue;
-      aiTools[name] = this.convertToAISDKTool(name, detail, async (input) => {
-        const result = await detail.execute(input);
-        return this.formatResult(result);
-      });
-    }
-    return acpTools(aiTools);
-  }
-  formatResult(result) {
-    const texts = result.content?.filter((c) => c.type === "text").map((c) => c.text);
-    return texts?.length ? texts.join("\n") : JSON.stringify(result.content);
-  }
-  execute(args) {
-    this.initProvider();
-    return super.execute(args);
-  }
-  cleanup() {
-    if (this.provider && typeof this.provider.cleanup === "function") {
-      this.provider.cleanup();
-    }
-    this.model = null;
-    this.provider = null;
-  }
-};
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/executors/ai/ai-acp-registrar.js
-function registerAIACPTool(server, params) {
-  const { name, description, allToolNames, depGroups, toolNameToDetailList, acpSettings, maxSteps = 50, tracingEnabled = false } = params;
-  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
-  const executor = new AIACPExecutor({
-    name,
-    description,
-    acpSettings,
-    tools: toolNameToDetailList,
-    maxSteps,
-    tracingEnabled
-  });
-  const toolDescription = CompiledPrompts.samplingToolDescription({
-    toolName: name,
-    description,
-    toolList: allToolNames.length > 0 ? allToolNames.map((n) => `- ${n}`).join("\n") : "Agent has its own tools"
-  });
-  const argsDef = createArgsDef.forSampling();
-  const schema = allToolNames.length > 0 ? argsDef : {
-    type: "object",
-    properties: {}
-  };
-  server.tool(name, toolDescription, jsonSchema(createModelCompatibleJSONSchema(schema)), (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({
-      prompt,
-      context: args.context
-    });
-  });
-  return executor;
-}
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/mode-ai-acp-plugin.js
-var createAIACPModePlugin = () => ({
-  name: "mode-ai-acp",
-  version: "1.0.0",
-  apply: "ai_acp",
-  registerAgentTool: (context2) => {
-    const opts = context2.options;
-    if (!opts.acpSettings) {
-      throw new Error("ai_acp mode requires acpSettings in options");
-    }
-    registerAIACPTool(context2.server, {
-      description: context2.description,
-      name: context2.name,
-      allToolNames: context2.allToolNames,
-      depGroups: context2.depGroups,
-      toolNameToDetailList: context2.toolNameToDetailList,
-      acpSettings: opts.acpSettings,
-      maxSteps: opts.maxSteps,
-      tracingEnabled: opts.tracingEnabled
-    });
-  }
-});
-var mode_ai_acp_plugin_default = createAIACPModePlugin();
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/common/schema.js
-import traverse from "json-schema-traverse";
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/common/env.js
-import process4 from "node:process";
-var isSCF = () => Boolean(process4.env.SCF_RUNTIME || process4.env.PROD_SCF);
-if (isSCF()) {
-  console.log({
-    isSCF: isSCF(),
-    SCF_RUNTIME: process4.env.SCF_RUNTIME
-  });
-}
-
-// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/set-up-mcp-compose.js
-var markdownAgentLoader = null;
-function setMarkdownAgentLoader(loader) {
-  markdownAgentLoader = loader;
-}
-function isMarkdownFile(path) {
-  return path.endsWith(".md") || path.endsWith(".markdown");
-}
-
 // __mcpc__plugin-markdown-loader_latest/node_modules/@mcpc/plugin-markdown-loader/src/markdown-loader.js
 import { readdir, readFile, stat } from "node:fs/promises";
 
@@ -3940,10 +1943,13 @@ function parse(content, options = {}) {
 
 // __mcpc__plugin-markdown-loader_latest/node_modules/@mcpc/plugin-markdown-loader/src/markdown-loader.js
 import { join } from "node:path";
-import process5 from "node:process";
+import process from "node:process";
+function isMarkdownFile(path) {
+  return path.endsWith(".md") || path.endsWith(".markdown");
+}
 function replaceEnvVars(str2) {
   return str2.replace(/\$([A-Za-z_][A-Za-z0-9_]*)(?!\s*\()/g, (match, varName) => {
-    const value = process5.env[varName];
+    const value = process.env[varName];
     if (value !== void 0) {
       return value;
     }
@@ -4072,8 +2078,9 @@ function markdownLoaderPlugin() {
     version: "1.0.0",
     enforce: "pre",
     // Run before other plugins
-    configureServer: () => {
-      setMarkdownAgentLoader(loadMarkdownAgentFile);
+    configureServer: (server) => {
+      server.registerFileLoader(".md", loadMarkdownAgentFile);
+      server.registerFileLoader(".markdown", loadMarkdownAgentFile);
     }
   };
 }
@@ -4089,6 +2096,5 @@ export {
   loadMarkdownAgentFile,
   markdownAgentToComposeDefinition,
   markdownLoaderPlugin,
-  parseMarkdownAgent,
-  setMarkdownAgentLoader
+  parseMarkdownAgent
 };