@mcp-use/agent 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/index.cjs

@@ -1,3302 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  BaseAdapter: () => BaseAdapter,
-  DEFAULT_OLLAMA_BASE_URL: () => DEFAULT_OLLAMA_BASE_URL,
-  LlmRequestError: () => LlmRequestError,
-  MCPAgent: () => MCPAgent,
-  NativeAdapter: () => NativeAdapter,
-  OllamaCorsError: () => OllamaCorsError,
-  PROMPTS: () => PROMPTS,
-  RemoteAgent: () => RemoteAgent,
-  buildOllamaApiUrl: () => buildOllamaApiUrl,
-  chat: () => completeChat,
-  completeChat: () => completeChat,
-  convertMessagesToProvider: () => convertMessagesToProvider,
-  normalizeOllamaBaseUrl: () => normalizeOllamaBaseUrl,
-  parseLLMStringToProviderConfig: () => parseLLMStringToProviderConfig,
-  providerConfigFromOptions: () => providerConfigFromOptions
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/agents/mcp_agent.ts
-var import_client5 = require("@mcp-use/client");
-
-// src/adapters/native_adapter.ts
-var import_client2 = require("@mcp-use/client");
-
-// src/adapters/base.ts
-var import_client = require("@mcp-use/client");
-var BaseAdapter = class {
-  /**
-   * List of tool names that should not be available.
-   */
-  disallowedTools;
-  /**
-   * Internal cache that maps a connector instance to the list of tools
-   * generated for it.
-   */
-  connectorToolMap = /* @__PURE__ */ new Map();
-  constructor(disallowedTools) {
-    this.disallowedTools = disallowedTools ?? [];
-  }
-  /**
-   * Create tools from an MCPClient instance.
-   *
-   * This is the recommended way to create tools from an MCPClient, as it handles
-   * session creation and connector extraction automatically.
-   *
-   * @param client          The MCPClient to extract tools from.
-   * @param disallowedTools Optional list of tool names to exclude.
-   * @returns               A promise that resolves with a list of converted tools.
-   */
-  static async createTools(client, disallowedTools) {
-    const adapter = new this(disallowedTools);
-    if (!client.activeSessions || Object.keys(client.activeSessions).length === 0) {
-      import_client.logger.debug("No active sessions found, creating new ones...");
-      await client.createAllSessions();
-    }
-    const sessions = client.getAllActiveSessions();
-    const connectors = Object.values(sessions).map(
-      (session) => session.connector
-    );
-    return adapter.createToolsFromConnectors(connectors);
-  }
-  /**
-   * Dynamically load tools for a specific connector.
-   *
-   * @param connector The connector to load tools for.
-   * @returns         The list of tools that were loaded in the target framework's format.
-   */
-  async loadToolsForConnector(connector) {
-    if (this.connectorToolMap.has(connector)) {
-      const cached = this.connectorToolMap.get(connector);
-      import_client.logger.debug(`Returning ${cached.length} existing tools for connector`);
-      return cached;
-    }
-    const connectorTools = [];
-    const success = await this.ensureConnectorInitialized(connector);
-    if (!success) {
-      return [];
-    }
-    for (const tool of connector.tools) {
-      const converted = this.convertTool(tool, connector);
-      if (converted) {
-        connectorTools.push(converted);
-      }
-    }
-    this.connectorToolMap.set(connector, connectorTools);
-    import_client.logger.debug(
-      `Loaded ${connectorTools.length} new tools for connector: ${connectorTools.map((t) => t?.name ?? String(t)).join(", ")}`
-    );
-    return connectorTools;
-  }
-  /**
-   * Create tools from MCP tools in all provided connectors.
-   *
-   * @param connectors List of MCP connectors to create tools from.
-   * @returns         A promise that resolves with all converted tools.
-   */
-  async createToolsFromConnectors(connectors) {
-    const tools = [];
-    for (const connector of connectors) {
-      const connectorTools = await this.loadToolsForConnector(connector);
-      tools.push(...connectorTools);
-    }
-    import_client.logger.debug(`Available tools: ${tools.length}`);
-    return tools;
-  }
-  /**
-   * Dynamically load resources for a specific connector.
-   *
-   * @param connector The connector to load resources for.
-   * @returns         The list of resources that were loaded in the target framework's format.
-   */
-  async loadResourcesForConnector(connector) {
-    const connectorResources = [];
-    const success = await this.ensureConnectorInitialized(connector);
-    if (!success) {
-      return [];
-    }
-    try {
-      const resourcesResult = await connector.listAllResources();
-      const resources = resourcesResult?.resources || [];
-      if (this.convertResource) {
-        for (const resource of resources) {
-          const converted = this.convertResource(resource, connector);
-          if (converted) {
-            connectorResources.push(converted);
-          }
-        }
-      }
-      import_client.logger.debug(
-        `Loaded ${connectorResources.length} new resources for connector: ${connectorResources.map((r) => r?.name ?? String(r)).join(", ")}`
-      );
-    } catch (err) {
-      import_client.logger.warn(`Error loading resources for connector: ${err}`);
-    }
-    return connectorResources;
-  }
-  /**
-   * Dynamically load prompts for a specific connector.
-   *
-   * @param connector The connector to load prompts for.
-   * @returns         The list of prompts that were loaded in the target framework's format.
-   */
-  async loadPromptsForConnector(connector) {
-    const connectorPrompts = [];
-    const success = await this.ensureConnectorInitialized(connector);
-    if (!success) {
-      return [];
-    }
-    try {
-      const promptsResult = await connector.listPrompts();
-      const prompts = promptsResult?.prompts || [];
-      if (this.convertPrompt) {
-        for (const prompt of prompts) {
-          const converted = this.convertPrompt(prompt, connector);
-          if (converted) {
-            connectorPrompts.push(converted);
-          }
-        }
-      }
-      import_client.logger.debug(
-        `Loaded ${connectorPrompts.length} new prompts for connector: ${connectorPrompts.map((p) => p?.name ?? String(p)).join(", ")}`
-      );
-    } catch (err) {
-      import_client.logger.warn(`Error loading prompts for connector: ${err}`);
-    }
-    return connectorPrompts;
-  }
-  /**
-   * Create resources from MCP resources in all provided connectors.
-   *
-   * @param connectors List of MCP connectors to create resources from.
-   * @returns         A promise that resolves with all converted resources.
-   */
-  async createResourcesFromConnectors(connectors) {
-    const resources = [];
-    for (const connector of connectors) {
-      const connectorResources = await this.loadResourcesForConnector(connector);
-      resources.push(...connectorResources);
-    }
-    import_client.logger.debug(`Available resources: ${resources.length}`);
-    return resources;
-  }
-  /**
-   * Create prompts from MCP prompts in all provided connectors.
-   *
-   * @param connectors List of MCP connectors to create prompts from.
-   * @returns         A promise that resolves with all converted prompts.
-   */
-  async createPromptsFromConnectors(connectors) {
-    const prompts = [];
-    for (const connector of connectors) {
-      const connectorPrompts = await this.loadPromptsForConnector(connector);
-      prompts.push(...connectorPrompts);
-    }
-    import_client.logger.debug(`Available prompts: ${prompts.length}`);
-    return prompts;
-  }
-  /**
-   * Check if a connector is initialized and has tools.
-   *
-   * @param connector The connector to check.
-   * @returns         True if the connector is initialized and has tools, false otherwise.
-   */
-  checkConnectorInitialized(connector) {
-    return Boolean(connector.tools && connector.tools.length);
-  }
-  /**
-   * Ensure a connector is initialized.
-   *
-   * @param connector The connector to initialize.
-   * @returns         True if initialization succeeded, false otherwise.
-   */
-  async ensureConnectorInitialized(connector) {
-    if (!this.checkConnectorInitialized(connector)) {
-      import_client.logger.debug("Connector doesn't have tools, initializing it");
-      try {
-        await connector.initialize();
-        return true;
-      } catch (err) {
-        import_client.logger.error(`Error initializing connector: ${err}`);
-        return false;
-      }
-    }
-    return true;
-  }
-};
-
-// src/adapters/native_adapter.ts
-function sanitizeToolName(name) {
-  return name.replace(/[^A-Za-z0-9_]+/g, "_").toLowerCase().replace(/^_+|_+$/g, "");
-}
-var NativeAdapter = class extends BaseAdapter {
-  usedToolNames = /* @__PURE__ */ new Set();
-  handlers = /* @__PURE__ */ new Map();
-  constructor(disallowedTools = []) {
-    super(disallowedTools);
-  }
-  async createToolsFromConnectors(connectors) {
-    this.usedToolNames.clear();
-    this.handlers.clear();
-    return super.createToolsFromConnectors(connectors);
-  }
-  createCallTool() {
-    const handlers = this.handlers;
-    return async (name, args) => {
-      const handler = handlers.get(name);
-      if (!handler) {
-        throw new Error(`Unknown tool: ${name}`);
-      }
-      try {
-        if (handler.kind === "tool") {
-          return await handler.connector.callTool(handler.mcpName, args);
-        }
-        if (handler.kind === "resource") {
-          const uri = handler.resourceUri ?? handler.mcpName;
-          return await handler.connector.readResource(uri);
-        }
-        return await handler.connector.getPrompt(handler.mcpName, args);
-      } catch (err) {
-        import_client2.logger.error(`Error executing native MCP tool ${name}: ${err}`);
-        throw err;
-      }
-    };
-  }
-  toProviderTools(entries) {
-    return entries.map(({ name, description, inputSchema }) => ({
-      name,
-      description,
-      inputSchema
-    }));
-  }
-  reserveName(name, kind) {
-    if (!this.usedToolNames.has(name)) {
-      this.usedToolNames.add(name);
-      return name;
-    }
-    if (kind) {
-      const prefixed = `${kind}_${name}`;
-      if (!this.usedToolNames.has(prefixed)) {
-        this.usedToolNames.add(prefixed);
-        return prefixed;
-      }
-      let i2 = 2;
-      while (this.usedToolNames.has(`${prefixed}_${i2}`)) i2++;
-      const fallback2 = `${prefixed}_${i2}`;
-      this.usedToolNames.add(fallback2);
-      return fallback2;
-    }
-    let i = 2;
-    while (this.usedToolNames.has(`${name}_${i}`)) i++;
-    const fallback = `${name}_${i}`;
-    this.usedToolNames.add(fallback);
-    return fallback;
-  }
-  register(entry, handler) {
-    this.handlers.set(entry.name, handler);
-    return entry;
-  }
-  convertTool(mcpTool, connector) {
-    if (this.disallowedTools.includes(mcpTool.name)) return null;
-    const toolName = this.reserveName(mcpTool.name ?? "tool");
-    const entry = {
-      name: toolName,
-      dispatchKey: toolName,
-      description: mcpTool.description ?? "",
-      inputSchema: mcpTool.inputSchema ?? {
-        type: "object",
-        properties: {}
-      }
-    };
-    return this.register(entry, {
-      connector,
-      kind: "tool",
-      mcpName: mcpTool.name
-    });
-  }
-  convertResource(mcpResource, connector) {
-    const resourceBaseName = sanitizeToolName(mcpResource.name || mcpResource.uri) || "resource";
-    const resourceName = this.reserveName(resourceBaseName, "resource");
-    const entry = {
-      name: resourceName,
-      dispatchKey: resourceName,
-      description: mcpResource.description || `Return the content of the resource located at URI ${mcpResource.uri}.`,
-      inputSchema: { type: "object", properties: {} }
-    };
-    return this.register(entry, {
-      connector,
-      kind: "resource",
-      mcpName: mcpResource.uri,
-      resourceUri: mcpResource.uri
-    });
-  }
-  convertPrompt(mcpPrompt, connector) {
-    const properties = {};
-    const required = [];
-    if (mcpPrompt.arguments?.length) {
-      for (const arg of mcpPrompt.arguments) {
-        properties[arg.name] = { type: "string", description: arg.description };
-        if (arg.required !== false) required.push(arg.name);
-      }
-    }
-    const promptBaseName = sanitizeToolName(mcpPrompt.name || "prompt") || "prompt";
-    const promptName = this.reserveName(promptBaseName, "prompt");
-    const entry = {
-      name: promptName,
-      dispatchKey: promptName,
-      description: mcpPrompt.description || "",
-      inputSchema: {
-        type: "object",
-        properties,
-        ...required.length > 0 ? { required } : {}
-      }
-    };
-    return this.register(entry, {
-      connector,
-      kind: "prompt",
-      mcpName: mcpPrompt.name
-    });
-  }
-};
-
-// src/llm/toolResultParts.ts
-function makeText(text) {
-  return { type: "text", text };
-}
-function makeImage(data, mimeType) {
-  return {
-    type: "image",
-    url: `data:${mimeType};base64,${data}`,
-    mimeType,
-    data
-  };
-}
-function isMcpResultShape(value) {
-  if (!value || typeof value !== "object") return false;
-  const v = value;
-  if (Array.isArray(v.content)) return true;
-  return "structuredContent" in v;
-}
-function isToolResultError(result) {
-  return typeof result === "object" && result !== null && result.isError === true;
-}
-function blockToPart(block) {
-  if (!block || typeof block !== "object") return null;
-  switch (block.type) {
-    case "text": {
-      const text = block.text;
-      return typeof text === "string" && text.length > 0 ? makeText(text) : null;
-    }
-    case "image": {
-      const b = block;
-      if (typeof b.data !== "string" || !b.data) return null;
-      const mime = typeof b.mimeType === "string" && b.mimeType ? b.mimeType : "image/png";
-      return makeImage(b.data, mime);
-    }
-    case "audio": {
-      const b = block;
-      const mime = typeof b.mimeType === "string" && b.mimeType ? b.mimeType : "audio/*";
-      const bytes = typeof b.data === "string" ? b.data.length : 0;
-      return makeText(`[audio: ${mime}, base64 omitted (${bytes} chars)]`);
-    }
-    case "resource": {
-      const r = block.resource ?? {};
-      if (typeof r.text === "string" && r.text.length > 0) {
-        return makeText(r.text);
-      }
-      if (typeof r.blob === "string" && typeof r.mimeType === "string" && r.mimeType.startsWith("image/")) {
-        return makeImage(r.blob, r.mimeType);
-      }
-      const uri = typeof r.uri === "string" ? r.uri : "<unknown>";
-      const mime = typeof r.mimeType === "string" ? r.mimeType : "unknown";
-      return makeText(`[resource: ${uri} (${mime})]`);
-    }
-    case "resource_link": {
-      const b = block;
-      const uri = typeof b.uri === "string" ? b.uri : "<unknown>";
-      const name = typeof b.name === "string" ? ` "${b.name}"` : "";
-      return makeText(`[resource_link${name}: ${uri}]`);
-    }
-    default: {
-      return makeText(
-        `[unsupported tool content block: ${String(block.type)}]`
-      );
-    }
-  }
-}
-function stripMeta(value) {
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    const { _meta: _ignored, ...rest } = value;
-    return rest;
-  }
-  return value;
-}
-function extractToolResultParts(result) {
-  const stripped = stripMeta(result);
-  if (typeof stripped === "string") {
-    return stripped.length > 0 ? [makeText(stripped)] : [];
-  }
-  if (isMcpResultShape(stripped)) {
-    const r = stripped;
-    const parts = [];
-    if (Array.isArray(r.content)) {
-      for (const block of r.content) {
-        const p = blockToPart(block);
-        if (p) parts.push(p);
-      }
-    }
-    if (r.structuredContent !== void 0) {
-      try {
-        parts.push(
-          makeText(`structuredContent: ${JSON.stringify(r.structuredContent)}`)
-        );
-      } catch {
-      }
-    }
-    if (r.isError) {
-      parts.unshift(makeText("[tool reported isError=true]"));
-    }
-    return parts;
-  }
-  try {
-    return [makeText(JSON.stringify(stripped))];
-  } catch {
-    return [makeText(String(stripped))];
-  }
-}
-function collapseToString(parts) {
-  if (parts.length === 0) return "";
-  if (parts.every((p) => p.type === "text")) {
-    return parts.map((p) => p.text).join("\n");
-  }
-  return null;
-}
-function toolResultToContent(result) {
-  const parts = extractToolResultParts(result);
-  const collapsed = collapseToString(parts);
-  return collapsed !== null ? collapsed : parts;
-}
-function partitionToolContent(content) {
-  if (typeof content === "string") {
-    return { text: content, imageParts: [], isString: true };
-  }
-  const texts = [];
-  const imageParts = [];
-  for (const p of content) {
-    if (p.type === "text") {
-      if (p.text) texts.push(p.text);
-    } else if (p.type === "image") {
-      imageParts.push(p);
-    }
-  }
-  return { text: texts.join("\n"), imageParts, isString: false };
-}
-function toolImageFollowupHeader(toolName, count) {
-  return `(Tool "${toolName ?? "<tool>"}" returned the following image${count === 1 ? "" : "s"}:)`;
-}
-
-// src/llm/messageFormat.ts
-function extractText(m) {
-  const raw = typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((x) => x?.text ?? "").join("\n") : JSON.stringify(m.content ?? "");
-  if (raw.trim()) return raw.trim();
-  if (m.parts?.length) {
-    return m.parts.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("").trim();
-  }
-  return "";
-}
-function convertMessagesToProvider(messages) {
-  const out = [];
-  messages.forEach((m, mi) => {
-    if (m.role === "user") {
-      const text2 = extractText(m) || "[no content]";
-      if (m.attachments?.length) {
-        const parts = [{ type: "text", text: text2 }];
-        for (const a of m.attachments) {
-          if (a.type === "image") {
-            parts.push({
-              type: "image",
-              url: `data:${a.mimeType};base64,${a.data}`,
-              mimeType: a.mimeType,
-              data: a.data
-            });
-          }
-        }
-        out.push({ role: "user", content: parts });
-      } else {
-        out.push({ role: "user", content: text2 });
-      }
-      return;
-    }
-    const toolParts = (m.parts ?? []).filter(
-      (p) => p.type === "tool-invocation" && p.toolInvocation && p.toolInvocation.result !== void 0
-    );
-    if (toolParts.length === 0) {
-      const text2 = extractText(m) || "[no content]";
-      out.push({ role: "assistant", content: text2 });
-      return;
-    }
-    const text = extractText(m);
-    const toolCalls = toolParts.map((p, i) => ({
-      id: `call_${mi}_${i}_${p.toolInvocation.toolName}`,
-      name: p.toolInvocation.toolName,
-      args: p.toolInvocation.args
-    }));
-    out.push({
-      role: "assistant",
-      content: text,
-      toolCalls
-    });
-    toolParts.forEach((p, i) => {
-      const result = p.toolInvocation.result;
-      out.push({
-        role: "tool",
-        content: toolResultToContent(result),
-        toolCallId: `call_${mi}_${i}_${p.toolInvocation.toolName}`,
-        toolName: p.toolInvocation.toolName,
-        toolResult: result,
-        toolIsError: isToolResultError(result)
-      });
-    });
-  });
-  return out;
-}
-function extractSystem(messages) {
-  const sys = [];
-  const rest = [];
-  for (const m of messages) {
-    if (m.role === "system") {
-      if (typeof m.content === "string") sys.push(m.content);
-      else if (Array.isArray(m.content)) {
-        for (const p of m.content) if (p.type === "text") sys.push(p.text);
-      }
-    } else {
-      rest.push(m);
-    }
-  }
-  return {
-    system: sys.length > 0 ? sys.join("\n\n") : void 0,
-    rest
-  };
-}
-function parseDataUrl(url) {
-  const m = url.match(/^data:([^;,]+);base64,(.+)$/);
-  if (!m) return null;
-  return { mimeType: m[1], data: m[2] };
-}
-
-// src/llm/sse.ts
-async function* parseSSE(body, signal) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder("utf-8");
-  let buffer = "";
-  try {
-    while (true) {
-      if (signal?.aborted) return;
-      const { value, done } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      let sep;
-      while ((sep = indexOfEventSeparator(buffer)) !== -1) {
-        const raw = buffer.slice(0, sep);
-        buffer = buffer.slice(sep).replace(/^(\r\n\r\n|\n\n|\r\r)/, "");
-        const parsed = parseSseBlock(raw);
-        if (parsed) yield parsed;
-      }
-    }
-    if (buffer.trim()) {
-      const parsed = parseSseBlock(buffer);
-      if (parsed) yield parsed;
-    }
-  } finally {
-    try {
-      reader.releaseLock();
-    } catch {
-    }
-  }
-}
-function indexOfEventSeparator(s) {
-  const a = s.indexOf("\n\n");
-  const b = s.indexOf("\r\n\r\n");
-  if (a === -1) return b;
-  if (b === -1) return a;
-  return Math.min(a, b);
-}
-function parseSseBlock(raw) {
-  let event;
-  const dataLines = [];
-  for (const line of raw.split(/\r?\n/)) {
-    if (!line || line.startsWith(":")) continue;
-    const idx = line.indexOf(":");
-    const field = idx === -1 ? line : line.slice(0, idx);
-    let value = idx === -1 ? "" : line.slice(idx + 1);
-    if (value.startsWith(" ")) value = value.slice(1);
-    if (field === "event") event = value;
-    else if (field === "data") dataLines.push(value);
-  }
-  if (dataLines.length === 0) return null;
-  return { event, data: dataLines.join("\n") };
-}
-
-// src/llm/usage.ts
-function numberAt(value, ...keys) {
-  for (const key of keys) {
-    const candidate = value[key];
-    if (typeof candidate === "number" && Number.isFinite(candidate)) {
-      return candidate;
-    }
-  }
-  return void 0;
-}
-function tokenUsageFromRecord(raw) {
-  if (!raw || typeof raw !== "object") return void 0;
-  const usage = raw;
-  const inputTokens = numberAt(
-    usage,
-    "inputTokens",
-    "input_tokens",
-    "prompt_tokens",
-    "promptTokenCount",
-    "prompt_eval_count"
-  );
-  const outputTokens = numberAt(
-    usage,
-    "outputTokens",
-    "output_tokens",
-    "completion_tokens",
-    "candidatesTokenCount",
-    "eval_count"
-  );
-  const totalTokens = numberAt(usage, "totalTokens", "total_tokens", "totalTokenCount") ?? (inputTokens !== void 0 && outputTokens !== void 0 ? inputTokens + outputTokens : void 0);
-  const inputDetails = usage.input_tokens_details && typeof usage.input_tokens_details === "object" ? usage.input_tokens_details : void 0;
-  const outputDetails = usage.output_tokens_details && typeof usage.output_tokens_details === "object" ? usage.output_tokens_details : void 0;
-  const cachedInputTokens = numberAt(usage, "cachedInputTokens", "cache_read_input_tokens") ?? (inputDetails ? numberAt(inputDetails, "cached_tokens") : void 0);
-  const reasoningTokens = numberAt(usage, "reasoningTokens", "thoughtsTokenCount") ?? (outputDetails ? numberAt(outputDetails, "reasoning_tokens") : void 0);
-  if (inputTokens === void 0 && outputTokens === void 0 && totalTokens === void 0 && cachedInputTokens === void 0 && reasoningTokens === void 0) {
-    return void 0;
-  }
-  return {
-    inputTokens,
-    outputTokens,
-    totalTokens,
-    cachedInputTokens,
-    reasoningTokens
-  };
-}
-
-// src/llm/providers/anthropic.ts
-var DEFAULT_ENDPOINT = "https://api.anthropic.com/v1/messages";
-var ANTHROPIC_VERSION = "2023-06-01";
-var DEFAULT_MAX_TOKENS = 4096;
-function buildImageBlock(p) {
-  if (p.type !== "image") return null;
-  if (p.data && p.mimeType) {
-    return {
-      type: "image",
-      source: { type: "base64", media_type: p.mimeType, data: p.data }
-    };
-  }
-  const parsed = parseDataUrl(p.url);
-  if (parsed) {
-    return {
-      type: "image",
-      source: {
-        type: "base64",
-        media_type: parsed.mimeType,
-        data: parsed.data
-      }
-    };
-  }
-  return { type: "image", source: { type: "url", url: p.url } };
-}
-function toAnthropicContent(content) {
-  if (typeof content === "string") {
-    return [{ type: "text", text: content || "[no content]" }];
-  }
-  const blocks = [];
-  for (const p of content) {
-    if (p.type === "text") {
-      if (p.text) blocks.push({ type: "text", text: p.text });
-    } else {
-      const img = buildImageBlock(p);
-      if (img) blocks.push(img);
-    }
-  }
-  if (blocks.length === 0) blocks.push({ type: "text", text: "[no content]" });
-  return blocks;
-}
-function toAnthropicToolResultContent(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  const blocks = [];
-  for (const p of content) {
-    if (p.type === "text") {
-      if (p.text) blocks.push({ type: "text", text: p.text });
-    } else if (p.type === "image") {
-      const img = buildImageBlock(p);
-      if (img) blocks.push(img);
-    }
-  }
-  if (blocks.length === 0) {
-    return "[no content]";
-  }
-  return blocks;
-}
-function toAnthropicMessages(messages) {
-  const out = [];
-  for (const m of messages) {
-    if (m.role === "tool") {
-      const last = out[out.length - 1];
-      const block = {
-        type: "tool_result",
-        tool_use_id: m.toolCallId,
-        content: toAnthropicToolResultContent(m.content),
-        ...m.toolIsError ? { is_error: true } : {}
-      };
-      if (last && last.role === "user" && Array.isArray(last.content)) {
-        last.content.push(block);
-      } else {
-        out.push({ role: "user", content: [block] });
-      }
-      continue;
-    }
-    if (m.role === "assistant") {
-      const blocks = [];
-      const textContent = typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((p) => p.type === "text" ? p.text : "").join("") : "";
-      if (textContent) blocks.push({ type: "text", text: textContent });
-      if (m.toolCalls?.length) {
-        for (const tc of m.toolCalls) {
-          blocks.push({
-            type: "tool_use",
-            id: tc.id,
-            name: tc.name,
-            input: tc.args ?? {}
-          });
-        }
-      }
-      if (blocks.length === 0) {
-        blocks.push({ type: "text", text: "[no content]" });
-      }
-      out.push({ role: "assistant", content: blocks });
-      continue;
-    }
-    out.push({ role: "user", content: toAnthropicContent(m.content) });
-  }
-  return out;
-}
-function buildBody(params, stream) {
-  const { config, messages, tools } = params;
-  const { system, rest } = extractSystem(messages);
-  const body = {
-    model: config.model,
-    max_tokens: config.maxTokens ?? DEFAULT_MAX_TOKENS,
-    messages: toAnthropicMessages(rest),
-    ...stream ? { stream: true } : {}
-  };
-  if (config.temperature !== void 0) body.temperature = config.temperature;
-  if (system) body.system = system;
-  if (tools && tools.length > 0) {
-    body.tools = tools.map((t) => ({
-      name: t.name,
-      description: t.description,
-      input_schema: t.inputSchema
-    }));
-  }
-  return body;
-}
-async function* streamChat(params) {
-  const { config, signal } = params;
-  const res = await fetch(DEFAULT_ENDPOINT, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "x-api-key": config.apiKey,
-      "anthropic-version": ANTHROPIC_VERSION,
-      "anthropic-dangerous-direct-browser-access": "true"
-    },
-    body: JSON.stringify(buildBody(params, true)),
-    signal
-  });
-  if (!res.ok || !res.body) {
-    const text = await res.text().catch(() => "");
-    throw new Error(
-      `Anthropic request failed (${res.status} ${res.statusText}): ${text}`
-    );
-  }
-  const blocks = /* @__PURE__ */ new Map();
-  let usage;
-  for await (const ev of parseSSE(res.body, signal)) {
-    let parsed;
-    try {
-      parsed = JSON.parse(ev.data);
-    } catch {
-      continue;
-    }
-    const t = parsed?.type;
-    if (t === "message_start") {
-      usage = tokenUsageFromRecord(parsed?.message?.usage);
-    } else if (t === "message_delta") {
-      const deltaUsage = tokenUsageFromRecord(parsed?.usage);
-      if (deltaUsage) usage = { ...usage, ...deltaUsage };
-    } else if (t === "content_block_start") {
-      const idx = parsed.index;
-      const cb = parsed.content_block ?? {};
-      if (cb.type === "tool_use") {
-        blocks.set(idx, {
-          kind: "tool_use",
-          id: cb.id,
-          name: cb.name,
-          argsJson: "",
-          emittedStart: false
-        });
-        yield {
-          type: "tool-call-start",
-          index: idx,
-          toolCallId: cb.id,
-          toolName: cb.name
-        };
-        const entry = blocks.get(idx);
-        if (entry) entry.emittedStart = true;
-      } else {
-        blocks.set(idx, {
-          kind: "text",
-          argsJson: "",
-          emittedStart: false
-        });
-      }
-    } else if (t === "content_block_delta") {
-      const idx = parsed.index;
-      const d = parsed.delta ?? {};
-      const entry = blocks.get(idx);
-      if (!entry) continue;
-      if (d.type === "text_delta" && typeof d.text === "string") {
-        yield { type: "text-delta", delta: d.text };
-      } else if (d.type === "input_json_delta" && typeof d.partial_json === "string" && entry.kind === "tool_use") {
-        entry.argsJson += d.partial_json;
-        yield {
-          type: "tool-call-args-delta",
-          index: idx,
-          toolCallId: entry.id,
-          toolName: entry.name,
-          argsDelta: d.partial_json
-        };
-      }
-    } else if (t === "content_block_stop") {
-      const idx = parsed.index;
-      const entry = blocks.get(idx);
-      if (entry && entry.kind === "tool_use" && entry.id && entry.name) {
-        let args = {};
-        if (entry.argsJson) {
-          try {
-            args = JSON.parse(entry.argsJson);
-          } catch {
-            args = {};
-          }
-        }
-        yield {
-          type: "tool-call-ready",
-          index: idx,
-          toolCallId: entry.id,
-          toolName: entry.name,
-          args
-        };
-      }
-    } else if (t === "message_stop") {
-      if (usage) {
-        const totalTokens = usage.totalTokens ?? (usage.inputTokens !== void 0 && usage.outputTokens !== void 0 ? usage.inputTokens + usage.outputTokens : void 0);
-        yield { type: "usage", usage: { ...usage, totalTokens } };
-      }
-    } else if (t === "error") {
-      yield {
-        type: "error",
-        message: parsed?.error?.message ?? "Anthropic stream error"
-      };
-    }
-  }
-  yield { type: "done" };
-}
-async function chat(params) {
-  const { config, signal } = params;
-  const res = await fetch(DEFAULT_ENDPOINT, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "x-api-key": config.apiKey,
-      "anthropic-version": ANTHROPIC_VERSION,
-      "anthropic-dangerous-direct-browser-access": "true"
-    },
-    body: JSON.stringify(buildBody(params, false)),
-    signal
-  });
-  if (!res.ok) {
-    const text2 = await res.text().catch(() => "");
-    throw new Error(
-      `Anthropic request failed (${res.status} ${res.statusText}): ${text2}`
-    );
-  }
-  const json = await res.json();
-  let text = "";
-  const toolCalls = [];
-  for (const block of json?.content ?? []) {
-    if (block.type === "text" && typeof block.text === "string") {
-      text += block.text;
-    } else if (block.type === "tool_use") {
-      toolCalls.push({
-        id: block.id,
-        name: block.name,
-        args: block.input && typeof block.input === "object" ? block.input : {}
-      });
-    }
-  }
-  return { text, toolCalls };
-}
-
-// src/llm/schemaUtils.ts
-var ALLOWED_KEYS = /* @__PURE__ */ new Set([
-  "type",
-  "description",
-  "enum",
-  "properties",
-  "required",
-  "items",
-  "format",
-  "nullable",
-  "minimum",
-  "maximum",
-  "minItems",
-  "maxItems",
-  "minLength",
-  "maxLength",
-  "pattern"
-]);
-function sanitizeSchemaForGemini(schema) {
-  if (!schema || typeof schema !== "object") {
-    return { type: "object" };
-  }
-  const cleaned = clean(schema);
-  if (typeof cleaned !== "object" || cleaned === null) {
-    return { type: "object" };
-  }
-  const out = cleaned;
-  if (!out.type) out.type = "object";
-  return out;
-}
-function clean(value) {
-  if (Array.isArray(value)) return value.map(clean);
-  if (!value || typeof value !== "object") return value;
-  const input = value;
-  for (const key of ["oneOf", "anyOf", "allOf"]) {
-    const arr = input[key];
-    if (Array.isArray(arr) && arr.length === 1) {
-      return clean(arr[0]);
-    }
-  }
-  const out = {};
-  for (const [k, v] of Object.entries(input)) {
-    if (!ALLOWED_KEYS.has(k)) continue;
-    if (k === "properties" && v && typeof v === "object") {
-      const props = {};
-      for (const [pk, pv] of Object.entries(v)) {
-        props[pk] = clean(pv);
-      }
-      out[k] = props;
-    } else if (k === "items") {
-      out[k] = clean(v);
-    } else {
-      out[k] = v;
-    }
-  }
-  return out;
-}
-
-// src/llm/providers/google.ts
-function normalizeModelId(model) {
-  const trimmed = model.trim();
-  return trimmed.startsWith("models/") ? trimmed.slice("models/".length) : trimmed;
-}
-function endpointFor(model, mode) {
-  const action = mode === "stream" ? "streamGenerateContent?alt=sse" : "generateContent";
-  return `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(
-    normalizeModelId(model)
-  )}:${action}`;
-}
-function buildInlineData(p) {
-  if (p.type !== "image") return null;
-  if (p.data && p.mimeType) {
-    return { inlineData: { mimeType: p.mimeType, data: p.data } };
-  }
-  const parsed = parseDataUrl(p.url);
-  if (parsed) {
-    return {
-      inlineData: { mimeType: parsed.mimeType, data: parsed.data }
-    };
-  }
-  return null;
-}
-function toGeminiParts(content) {
-  if (typeof content === "string") {
-    return [{ text: content || "[no content]" }];
-  }
-  const parts = [];
-  for (const p of content) {
-    if (p.type === "text") {
-      if (p.text) parts.push({ text: p.text });
-    } else {
-      const block = buildInlineData(p);
-      if (block) parts.push(block);
-    }
-  }
-  if (parts.length === 0) parts.push({ text: "[no content]" });
-  return parts;
-}
-function buildGeminiToolResponse(content) {
-  if (typeof content === "string") {
-    let parsed;
-    try {
-      parsed = JSON.parse(content);
-    } catch {
-      parsed = { result: content };
-    }
-    if (!parsed || typeof parsed !== "object") {
-      parsed = { result: parsed };
-    }
-    return { response: parsed, imageParts: [] };
-  }
-  const { text, imageParts } = partitionToolContent(content);
-  const response = {};
-  if (text) response.text = text;
-  if (imageParts.length > 0) {
-    response.images = imageParts.map((p) => ({
-      mimeType: p.mimeType ?? "image/*",
-      omitted: true
-    }));
-    response.note = "Image bytes were sent in the next user turn as inlineData.";
-  }
-  if (Object.keys(response).length === 0) {
-    response.result = null;
-  }
-  return { response, imageParts };
-}
-function toGeminiContents(messages) {
-  const out = [];
-  for (const m of messages) {
-    if (m.role === "tool") {
-      const { response, imageParts } = buildGeminiToolResponse(m.content);
-      const last = out[out.length - 1];
-      const part = {
-        functionResponse: {
-          name: m.toolName,
-          response
-        }
-      };
-      if (last && last.role === "function") {
-        last.parts.push(part);
-      } else {
-        out.push({ role: "function", parts: [part] });
-      }
-      if (imageParts.length > 0) {
-        const userParts = [
-          { text: toolImageFollowupHeader(m.toolName, imageParts.length) }
-        ];
-        for (const p of imageParts) {
-          const block = buildInlineData(p);
-          if (block) userParts.push(block);
-        }
-        out.push({ role: "user", parts: userParts });
-      }
-      continue;
-    }
-    if (m.role === "assistant") {
-      const parts = [];
-      const textContent = typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((p) => p.type === "text" ? p.text : "").join("") : "";
-      if (textContent) parts.push({ text: textContent });
-      if (m.toolCalls?.length) {
-        for (const tc of m.toolCalls) {
-          parts.push({
-            functionCall: { name: tc.name, args: tc.args ?? {} }
-          });
-        }
-      }
-      if (parts.length === 0) parts.push({ text: "[no content]" });
-      out.push({ role: "model", parts });
-      continue;
-    }
-    out.push({ role: "user", parts: toGeminiParts(m.content) });
-  }
-  return out;
-}
-function buildBody2(params) {
-  const { config, messages, tools } = params;
-  const { system, rest } = extractSystem(messages);
-  const body = {
-    contents: toGeminiContents(rest)
-  };
-  if (system) {
-    body.systemInstruction = { parts: [{ text: system }] };
-  }
-  const genConfig = {};
-  if (config.temperature !== void 0)
-    genConfig.temperature = config.temperature;
-  if (config.maxTokens !== void 0)
-    genConfig.maxOutputTokens = config.maxTokens;
-  if (Object.keys(genConfig).length > 0) body.generationConfig = genConfig;
-  if (tools && tools.length > 0) {
-    body.tools = [
-      {
-        functionDeclarations: tools.map((t) => ({
-          name: t.name,
-          description: t.description,
-          parameters: sanitizeSchemaForGemini(t.inputSchema)
-        }))
-      }
-    ];
-  }
-  return body;
-}
-async function* streamChat2(params) {
-  const { config, signal } = params;
-  const url = `${endpointFor(config.model, "stream")}&key=${encodeURIComponent(
-    config.apiKey
-  )}`;
-  const res = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(buildBody2(params)),
-    signal
-  });
-  if (!res.ok || !res.body) {
-    const text = await res.text().catch(() => "");
-    throw new Error(
-      `Google request failed (${res.status} ${res.statusText}): ${text}`
-    );
-  }
-  let toolCallCounter = 0;
-  let usage;
-  for await (const ev of parseSSE(res.body, signal)) {
-    let parsed;
-    try {
-      parsed = JSON.parse(ev.data);
-    } catch {
-      continue;
-    }
-    usage = tokenUsageFromRecord(parsed?.usageMetadata) ?? usage;
-    const parts = parsed?.candidates?.[0]?.content?.parts ?? [];
-    for (const p of parts) {
-      if (typeof p.text === "string" && p.text.length > 0) {
-        yield { type: "text-delta", delta: p.text };
-      } else if (p.functionCall && typeof p.functionCall === "object") {
-        const idx = toolCallCounter++;
-        const id = `call_${idx}_${p.functionCall.name ?? "tool"}`;
-        const name = p.functionCall.name ?? "";
-        const args = p.functionCall.args && typeof p.functionCall.args === "object" ? p.functionCall.args : {};
-        yield {
-          type: "tool-call-start",
-          index: idx,
-          toolCallId: id,
-          toolName: name
-        };
-        const argsJson = JSON.stringify(args);
-        if (argsJson && argsJson !== "{}") {
-          yield {
-            type: "tool-call-args-delta",
-            index: idx,
-            toolCallId: id,
-            toolName: name,
-            argsDelta: argsJson
-          };
-        }
-        yield {
-          type: "tool-call-ready",
-          index: idx,
-          toolCallId: id,
-          toolName: name,
-          args
-        };
-      }
-    }
-  }
-  if (usage) yield { type: "usage", usage };
-  yield { type: "done" };
-}
-async function chat2(params) {
-  const { config, signal } = params;
-  const url = `${endpointFor(config.model, "single")}?key=${encodeURIComponent(
-    config.apiKey
-  )}`;
-  const res = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(buildBody2(params)),
-    signal
-  });
-  if (!res.ok) {
-    const text2 = await res.text().catch(() => "");
-    throw new Error(
-      `Google request failed (${res.status} ${res.statusText}): ${text2}`
-    );
-  }
-  const json = await res.json();
-  let text = "";
-  const toolCalls = [];
-  const parts = json?.candidates?.[0]?.content?.parts ?? [];
-  for (const p of parts) {
-    if (typeof p.text === "string") text += p.text;
-    else if (p.functionCall) {
-      toolCalls.push({
-        id: `call_${toolCalls.length}_${p.functionCall.name ?? "tool"}`,
-        name: p.functionCall.name ?? "",
-        args: p.functionCall.args && typeof p.functionCall.args === "object" ? p.functionCall.args : {}
-      });
-    }
-  }
-  return { text, toolCalls };
-}
-
-// src/llm/ndjson.ts
-async function* parseNDJSON(body, signal) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (true) {
-      if (signal?.aborted) return;
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        try {
-          yield JSON.parse(trimmed);
-        } catch {
-        }
-      }
-    }
-    const trailing = buffer.trim();
-    if (trailing) {
-      try {
-        yield JSON.parse(trailing);
-      } catch {
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-
-// src/llm/providers/ollama/utils.ts
-var DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434";
-function normalizeOllamaBaseUrl(baseUrl) {
-  const raw = (baseUrl || DEFAULT_OLLAMA_BASE_URL).trim();
-  let end = raw.length;
-  while (end > 0 && raw.charCodeAt(end - 1) === 47) {
-    end--;
-  }
-  const trimmed = raw.slice(0, end);
-  return trimmed.endsWith("/api") ? trimmed.slice(0, -4) : trimmed;
-}
-function buildOllamaApiUrl(baseUrl, path) {
-  return `${normalizeOllamaBaseUrl(baseUrl)}${path}`;
-}
-var OllamaCorsError = class extends Error {
-  constructor(cause) {
-    super(
-      "Could not reach Ollama. If it's running, allow this origin by starting Ollama with `OLLAMA_ORIGINS=*` (or your inspector origin) and try again."
-    );
-    this.name = "OllamaCorsError";
-    this.cause = cause;
-  }
-};
-
-// src/llm/providers/ollama/index.ts
-function toOllamaImages(content) {
-  const images = [];
-  for (const part of content) {
-    if (part.type !== "image") continue;
-    if (part.data) {
-      images.push(part.data);
-      continue;
-    }
-    const parsed = parseDataUrl(part.url);
-    if (parsed?.data) {
-      images.push(parsed.data);
-    }
-  }
-  return images;
-}
-function toOllamaContent(content) {
-  if (typeof content === "string") {
-    return { content };
-  }
-  const text = content.filter(
-    (part) => part.type === "text"
-  ).map((part) => part.text).join("");
-  const images = toOllamaImages(content);
-  return {
-    content: text,
-    ...images.length > 0 ? { images } : {}
-  };
-}
-function toOllamaMessages(messages) {
-  return messages.map((message) => {
-    if (message.role === "tool") {
-      return {
-        role: "tool",
-        tool_name: message.toolName,
-        content: typeof message.content === "string" ? message.content : JSON.stringify(message.toolResult ?? message.content)
-      };
-    }
-    if (message.role === "assistant") {
-      const content = typeof message.content === "string" ? { content: message.content } : toOllamaContent(message.content);
-      return {
-        role: "assistant",
-        ...content,
-        ...message.toolCalls?.length ? {
-          tool_calls: message.toolCalls.map((toolCall, index) => ({
-            type: "function",
-            function: {
-              index,
-              name: toolCall.name,
-              arguments: toolCall.args
-            }
-          }))
-        } : {}
-      };
-    }
-    return {
-      role: message.role,
-      ...toOllamaContent(message.content)
-    };
-  });
-}
-function buildBody3(params, stream) {
-  const { config, messages, tools } = params;
-  const body = {
-    model: config.model,
-    messages: toOllamaMessages(messages),
-    stream
-  };
-  const options = {};
-  if (config.temperature !== void 0)
-    options.temperature = config.temperature;
-  if (config.maxTokens !== void 0) options.num_predict = config.maxTokens;
-  if (Object.keys(options).length > 0) body.options = options;
-  if (tools && tools.length > 0) {
-    body.tools = tools.map((tool) => ({
-      type: "function",
-      function: {
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.inputSchema
-      }
-    }));
-  }
-  return body;
-}
-function buildHeaders(config) {
-  return {
-    "Content-Type": "application/json",
-    ...config.apiKey.trim() ? { Authorization: `Bearer ${config.apiKey.trim()}` } : {}
-  };
-}
-function normalizeToolCalls(toolCalls) {
-  if (!Array.isArray(toolCalls)) return [];
-  return toolCalls.map((toolCall) => {
-    const functionCall = toolCall && typeof toolCall === "object" ? toolCall.function : void 0;
-    const name = typeof functionCall?.name === "string" ? functionCall.name : "";
-    const rawArgs = functionCall?.arguments;
-    const args = rawArgs && typeof rawArgs === "object" ? rawArgs : {};
-    return {
-      name,
-      args
-    };
-  }).filter((toolCall) => toolCall.name);
-}
-async function* streamChat3(params) {
-  const { config, signal } = params;
-  const res = await fetch(buildOllamaApiUrl(config.baseUrl, "/api/chat"), {
-    method: "POST",
-    headers: buildHeaders(config),
-    body: JSON.stringify(buildBody3(params, true)),
-    signal
-  });
-  if (!res.ok || !res.body) {
-    const text = await res.text().catch(() => "");
-    throw new Error(
-      `Ollama request failed (${res.status} ${res.statusText}): ${text}`
-    );
-  }
-  let toolCallsEmitted = false;
-  let usage;
-  for await (const chunk of parseNDJSON(res.body, signal)) {
-    const message = chunk && typeof chunk === "object" ? chunk.message : void 0;
-    if (typeof message?.content === "string" && message.content.length > 0) {
-      yield { type: "text-delta", delta: message.content };
-    }
-    if (!toolCallsEmitted) {
-      const toolCalls = normalizeToolCalls(message?.tool_calls);
-      if (toolCalls.length > 0) {
-        for (const [index, toolCall] of toolCalls.entries()) {
-          const toolCallId = `call_${index}_${toolCall.name || "tool"}`;
-          yield {
-            type: "tool-call-start",
-            index,
-            toolCallId,
-            toolName: toolCall.name
-          };
-          const argsJson = JSON.stringify(toolCall.args);
-          if (argsJson && argsJson !== "{}") {
-            yield {
-              type: "tool-call-args-delta",
-              index,
-              toolCallId,
-              toolName: toolCall.name,
-              argsDelta: argsJson
-            };
-          }
-          yield {
-            type: "tool-call-ready",
-            index,
-            toolCallId,
-            toolName: toolCall.name,
-            args: toolCall.args
-          };
-        }
-        toolCallsEmitted = true;
-      }
-    }
-    if (chunk && typeof chunk === "object" && chunk.error) {
-      yield {
-        type: "error",
-        message: String(chunk.error)
-      };
-    }
-    usage = tokenUsageFromRecord(chunk) ?? usage;
-  }
-  if (usage) yield { type: "usage", usage };
-  yield { type: "done" };
-}
-async function chat3(params) {
-  const { config, signal } = params;
-  const res = await fetch(buildOllamaApiUrl(config.baseUrl, "/api/chat"), {
-    method: "POST",
-    headers: buildHeaders(config),
-    body: JSON.stringify(buildBody3(params, false)),
-    signal
-  });
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    throw new Error(
-      `Ollama request failed (${res.status} ${res.statusText}): ${text}`
-    );
-  }
-  const json = await res.json();
-  const message = json?.message ?? {};
-  return {
-    text: typeof message.content === "string" ? message.content : "",
-    toolCalls: normalizeToolCalls(message.tool_calls).map((tc, index) => ({
-      id: `call_${index}_${tc.name || "tool"}`,
-      name: tc.name,
-      args: tc.args
-    }))
-  };
-}
-
-// src/llm/providers/openai-chat-completions.ts
-var LlmRequestError = class extends Error {
-  status;
-  body;
-  constructor(status, message, body) {
-    super(message);
-    this.name = "LlmRequestError";
-    this.status = status;
-    this.body = body;
-  }
-};
-async function throwLlmRequestError(res) {
-  const text = await res.text().catch(() => "");
-  let body = text;
-  if (text) {
-    try {
-      body = JSON.parse(text);
-    } catch {
-    }
-  }
-  throw new LlmRequestError(
-    res.status,
-    `OpenAI request failed (${res.status} ${res.statusText}): ${text}`,
-    body
-  );
-}
-var OPENAI_BASE_URL = "https://api.openai.com/v1";
-function buildEndpoint(config, path) {
-  return `${config.baseUrl ?? OPENAI_BASE_URL}${path}`;
-}
-function buildHeaders2(config) {
-  const headers = {
-    "Content-Type": "application/json",
-    ...config.extraHeaders
-  };
-  if (config.apiKey) {
-    headers.Authorization = `Bearer ${config.apiKey}`;
-  }
-  return headers;
-}
-function toOpenAIContent(content) {
-  if (typeof content === "string") return content;
-  return content.map((p) => {
-    if (p.type === "text") return { type: "text", text: p.text };
-    return { type: "image_url", image_url: { url: p.url } };
-  });
-}
-function toOpenAIMessages(messages) {
-  const out = [];
-  for (const m of messages) {
-    if (m.role === "tool") {
-      const { text, imageParts } = partitionToolContent(m.content);
-      const fallback = imageParts.length > 0 ? "[image content; see next message]" : "[no content]";
-      out.push({
-        role: "tool",
-        tool_call_id: m.toolCallId,
-        content: text || fallback
-      });
-      if (imageParts.length > 0) {
-        const userParts = [
-          {
-            type: "text",
-            text: toolImageFollowupHeader(m.toolName, imageParts.length)
-          },
-          ...imageParts.map((p) => ({
-            type: "image_url",
-            image_url: { url: p.url }
-          }))
-        ];
-        out.push({ role: "user", content: userParts });
-      }
-      continue;
-    }
-    if (m.role === "assistant") {
-      const entry = {
-        role: "assistant",
-        content: typeof m.content === "string" && m.content.length > 0 ? m.content : null
-      };
-      if (m.toolCalls?.length) {
-        entry.tool_calls = m.toolCalls.map((tc) => ({
-          id: tc.id,
-          type: "function",
-          function: { name: tc.name, arguments: JSON.stringify(tc.args) }
-        }));
-      }
-      out.push(entry);
-      continue;
-    }
-    out.push({ role: m.role, content: toOpenAIContent(m.content) });
-  }
-  return out;
-}
-async function* streamChat4(params) {
-  const { config, messages, tools, signal } = params;
-  const body = {
-    model: config.model,
-    messages: toOpenAIMessages(messages),
-    stream: true
-  };
-  if (config.provider === "openrouter") {
-    body.stream_options = { include_usage: true };
-  }
-  if (config.temperature !== void 0) body.temperature = config.temperature;
-  if (config.maxTokens !== void 0) body.max_tokens = config.maxTokens;
-  if (tools && tools.length > 0) {
-    body.tools = tools.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.inputSchema
-      }
-    }));
-  }
-  const endpoint = buildEndpoint(config, "/chat/completions");
-  const res = await fetch(endpoint, {
-    method: "POST",
-    headers: buildHeaders2(config),
-    body: JSON.stringify(body),
-    signal,
-    ...config.credentials ? { credentials: config.credentials } : {}
-  });
-  const responseBody = res.body;
-  if (!res.ok) {
-    await throwLlmRequestError(res);
-  }
-  if (!responseBody) {
-    await throwLlmRequestError(res);
-  }
-  const stream = responseBody;
-  const buffers = /* @__PURE__ */ new Map();
-  for await (const ev of parseSSE(stream, signal)) {
-    if (!ev.data || ev.data === "[DONE]") continue;
-    let parsed;
-    try {
-      parsed = JSON.parse(ev.data);
-    } catch {
-      continue;
-    }
-    const usage = tokenUsageFromRecord(parsed?.usage);
-    if (usage) {
-      yield { type: "usage", usage };
-    }
-    const choice = parsed?.choices?.[0];
-    if (!choice) continue;
-    const delta = choice.delta ?? {};
-    if (typeof delta.content === "string" && delta.content.length > 0) {
-      yield { type: "text-delta", delta: delta.content };
-    }
-    if (Array.isArray(delta.tool_calls)) {
-      for (const tc of delta.tool_calls) {
-        const idx = typeof tc.index === "number" ? tc.index : 0;
-        let buf = buffers.get(idx);
-        if (!buf) {
-          buf = {
-            id: tc.id ?? `call_${idx}`,
-            name: tc.function?.name ?? "",
-            argsJson: "",
-            started: false
-          };
-          buffers.set(idx, buf);
-        }
-        if (tc.id && !buf.id.startsWith("call_")) buf.id = tc.id;
-        else if (tc.id) buf.id = tc.id;
-        if (tc.function?.name) buf.name = tc.function.name;
-        if (!buf.started && buf.name) {
-          buf.started = true;
-          yield {
-            type: "tool-call-start",
-            index: idx,
-            toolCallId: buf.id,
-            toolName: buf.name
-          };
-        }
-        const argsChunk = tc.function?.arguments;
-        if (typeof argsChunk === "string" && argsChunk.length > 0) {
-          buf.argsJson += argsChunk;
-          if (buf.started) {
-            yield {
-              type: "tool-call-args-delta",
-              index: idx,
-              toolCallId: buf.id,
-              toolName: buf.name,
-              argsDelta: argsChunk
-            };
-          }
-        }
-      }
-    }
-    if (choice.finish_reason) {
-      for (const [idx, buf] of buffers) {
-        let args = {};
-        if (buf.argsJson) {
-          try {
-            args = JSON.parse(buf.argsJson);
-          } catch {
-            args = {};
-          }
-        }
-        yield {
-          type: "tool-call-ready",
-          index: idx,
-          toolCallId: buf.id,
-          toolName: buf.name,
-          args
-        };
-      }
-      buffers.clear();
-    }
-  }
-  yield { type: "done" };
-}
-async function chat4(params) {
-  const { config, messages, tools, signal } = params;
-  const body = {
-    model: config.model,
-    messages: toOpenAIMessages(messages)
-  };
-  if (config.temperature !== void 0) body.temperature = config.temperature;
-  if (config.maxTokens !== void 0) body.max_tokens = config.maxTokens;
-  if (tools && tools.length > 0) {
-    body.tools = tools.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.inputSchema
-      }
-    }));
-  }
-  const endpoint = buildEndpoint(config, "/chat/completions");
-  const res = await fetch(endpoint, {
-    method: "POST",
-    headers: buildHeaders2(config),
-    body: JSON.stringify(body),
-    signal,
-    ...config.credentials ? { credentials: config.credentials } : {}
-  });
-  if (!res.ok) {
-    await throwLlmRequestError(res);
-  }
-  const json = await res.json();
-  const choice = json?.choices?.[0]?.message;
-  const text = typeof choice?.content === "string" ? choice.content : "";
-  const toolCalls = Array.isArray(choice?.tool_calls) ? choice.tool_calls.map((tc) => {
-    let args = {};
-    try {
-      args = JSON.parse(tc?.function?.arguments ?? "{}");
-    } catch {
-      args = {};
-    }
-    return {
-      id: tc.id,
-      name: tc.function?.name ?? "",
-      args
-    };
-  }) : [];
-  return { text, toolCalls };
-}
-
-// src/llm/providers/index.ts
-function withOpenRouter(params) {
-  return {
-    ...params,
-    config: {
-      ...params.config,
-      baseUrl: "https://openrouter.ai/api/v1",
-      extraHeaders: {
-        "HTTP-Referer": "https://inspector.mcp-use.com",
-        "X-Title": "mcp-use Inspector"
-      }
-    }
-  };
-}
-function streamChat5(params) {
-  switch (params.config.provider) {
-    case "openai":
-      throw new Error(
-        "provider 'openai' uses the Responses API via OpenAIResponsesDriver, not streamChat"
-      );
-    case "openai-compatible":
-      return streamChat4(params);
-    case "anthropic":
-      return streamChat(params);
-    case "google":
-      return streamChat2(params);
-    case "openrouter":
-      return streamChat4(withOpenRouter(params));
-    case "ollama":
-      return streamChat3(params);
-    default:
-      throw new Error(`Unsupported LLM provider: ${params.config.provider}`);
-  }
-}
-function chat5(params) {
-  switch (params.config.provider) {
-    case "openai":
-      throw new Error(
-        "provider 'openai' uses the Responses API via OpenAIResponsesDriver, not chat"
-      );
-    case "openai-compatible":
-      return chat4(params);
-    case "anthropic":
-      return chat(params);
-    case "google":
-      return chat2(params);
-    case "openrouter":
-      return chat4(withOpenRouter(params));
-    case "ollama":
-      return chat3(params);
-    default:
-      throw new Error(`Unsupported LLM provider: ${params.config.provider}`);
-  }
-}
-
-// src/llm/providers/openai-shared.ts
-var OPENAI_BASE_URL2 = "https://api.openai.com/v1";
-function buildEndpoint2(config, path) {
-  const base = config.baseUrl ?? OPENAI_BASE_URL2;
-  return `${base.replace(/\/$/, "")}${path}`;
-}
-function buildHeaders3(config) {
-  const headers = {
-    "Content-Type": "application/json",
-    ...config.extraHeaders
-  };
-  if (config.apiKey) {
-    headers.Authorization = `Bearer ${config.apiKey}`;
-  }
-  return headers;
-}
-async function readOpenAIError(res) {
-  const text = await res.text().catch(() => "");
-  return `OpenAI request failed (${res.status} ${res.statusText}): ${text}`;
-}
-
-// src/llm/providers/openai-responses.ts
-function toResponsesUserContent(content) {
-  if (typeof content === "string") return content;
-  return content.map((p) => {
-    if (p.type === "text") return { type: "input_text", text: p.text };
-    return { type: "input_image", image_url: p.url };
-  });
-}
-function seedInputFromMessages(messages) {
-  const systemParts = [];
-  const input = [];
-  for (const m of messages) {
-    if (m.role === "system") {
-      const text = typeof m.content === "string" ? m.content : m.content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
-      if (text) systemParts.push(text);
-      continue;
-    }
-    if (m.role === "user") {
-      input.push({
-        role: "user",
-        content: toResponsesUserContent(m.content)
-      });
-      continue;
-    }
-    if (m.role === "assistant") {
-      if (typeof m.content === "string" && m.content.length > 0) {
-        input.push({
-          type: "message",
-          role: "assistant",
-          content: [{ type: "output_text", text: m.content }]
-        });
-      }
-      for (const tc of m.toolCalls ?? []) {
-        input.push({
-          type: "function_call",
-          call_id: tc.id,
-          name: tc.name,
-          arguments: JSON.stringify(tc.args)
-        });
-      }
-      continue;
-    }
-    if (m.role === "tool") {
-      const { text, imageParts } = partitionToolContent(m.content);
-      const fallback = imageParts.length > 0 ? "[image content; see next message]" : "[no content]";
-      input.push({
-        type: "function_call_output",
-        call_id: m.toolCallId,
-        output: text || fallback
-      });
-      if (imageParts.length > 0) {
-        input.push({
-          role: "user",
-          content: [
-            {
-              type: "input_text",
-              text: toolImageFollowupHeader(m.toolName, imageParts.length)
-            },
-            ...imageParts.map((p) => ({
-              type: "input_image",
-              image_url: p.url
-            }))
-          ]
-        });
-      }
-    }
-  }
-  return {
-    instructions: systemParts.length > 0 ? systemParts.join("\n\n") : void 0,
-    input
-  };
-}
-function toResponsesTools(tools) {
-  return tools.map((t) => ({
-    type: "function",
-    name: t.name,
-    description: t.description,
-    parameters: t.inputSchema,
-    strict: false
-  }));
-}
-function appendToolOutputsToInput(input, callId, toolName, result) {
-  const content = toolResultToContent(result);
-  if (typeof content === "string") {
-    input.push({
-      type: "function_call_output",
-      call_id: callId,
-      output: content
-    });
-    return;
-  }
-  const { text, imageParts } = partitionToolContent(content);
-  input.push({
-    type: "function_call_output",
-    call_id: callId,
-    output: text || "[image content; see next message]"
-  });
-  if (imageParts.length > 0) {
-    input.push({
-      role: "user",
-      content: [
-        {
-          type: "input_text",
-          text: toolImageFollowupHeader(toolName, imageParts.length)
-        },
-        ...imageParts.map((p) => ({
-          type: "input_image",
-          image_url: p.url
-        }))
-      ]
-    });
-  }
-}
-function buildResponsesBody(params, stream) {
-  const body = {
-    model: params.config.model,
-    input: params.input,
-    store: false,
-    include: ["reasoning.encrypted_content"],
-    reasoning: { effort: params.config.reasoningEffort ?? "low" },
-    stream
-  };
-  if (params.instructions) body.instructions = params.instructions;
-  if (params.tools && params.tools.length > 0) {
-    body.tools = toResponsesTools(params.tools);
-  }
-  if (params.config.maxTokens !== void 0) {
-    body.max_output_tokens = params.config.maxTokens;
-  }
-  return body;
-}
-function extractFunctionCalls(output) {
-  const calls = [];
-  for (const item of output) {
-    if (!item || typeof item !== "object") continue;
-    const row = item;
-    if (row.type !== "function_call") continue;
-    if (typeof row.call_id !== "string" || typeof row.name !== "string") {
-      continue;
-    }
-    calls.push({
-      call_id: row.call_id,
-      name: row.name,
-      arguments: typeof row.arguments === "string" ? row.arguments : "{}"
-    });
-  }
-  return calls;
-}
-function extractMessageText(output) {
-  const parts = [];
-  for (const item of output) {
-    if (!item || typeof item !== "object") continue;
-    const row = item;
-    if (row.type !== "message" || row.role !== "assistant") continue;
-    const content = row.content;
-    if (!Array.isArray(content)) continue;
-    for (const block of content) {
-      if (!block || typeof block !== "object") continue;
-      const b = block;
-      if (b.type === "output_text" && typeof b.text === "string") {
-        parts.push(b.text);
-      }
-    }
-  }
-  return parts.join("");
-}
-function parseArgs(argsJson) {
-  if (!argsJson) return {};
-  try {
-    return JSON.parse(argsJson);
-  } catch {
-    return {};
-  }
-}
-async function* streamResponsesTurn(params) {
-  const res = await fetch(buildEndpoint2(params.config, "/responses"), {
-    method: "POST",
-    headers: buildHeaders3(params.config),
-    body: JSON.stringify(buildResponsesBody(params, true)),
-    signal: params.signal
-  });
-  if (!res.ok || !res.body) {
-    throw new Error(await readOpenAIError(res));
-  }
-  const callBuffers = /* @__PURE__ */ new Map();
-  let nextIndex = 0;
-  let completedOutput = [];
-  for await (const ev of parseSSE(res.body, params.signal)) {
-    if (!ev.data || ev.data === "[DONE]") continue;
-    let parsed;
-    try {
-      parsed = JSON.parse(ev.data);
-    } catch {
-      continue;
-    }
-    const type = typeof parsed.type === "string" ? parsed.type : ev.event;
-    if (type === "response.output_text.delta") {
-      const delta = parsed.delta;
-      if (typeof delta === "string" && delta.length > 0) {
-        yield { type: "text-delta", delta };
-      }
-      continue;
-    }
-    if (type === "response.output_item.added") {
-      const item = parsed.item;
-      if (item?.type === "function_call") {
-        const callId = typeof item.call_id === "string" ? item.call_id : `call_${nextIndex}`;
-        const name = typeof item.name === "string" ? item.name : "";
-        const idx = nextIndex++;
-        callBuffers.set(callId, {
-          index: idx,
-          name,
-          argsJson: "",
-          started: true
-        });
-        yield {
-          type: "tool-call-start",
-          index: idx,
-          toolCallId: callId,
-          toolName: name
-        };
-      }
-      continue;
-    }
-    if (type === "response.function_call_arguments.delta") {
-      const callId = typeof parsed.call_id === "string" ? parsed.call_id : "";
-      const delta = typeof parsed.delta === "string" ? parsed.delta : "";
-      const buf = callBuffers.get(callId);
-      if (buf && delta.length > 0) {
-        buf.argsJson += delta;
-        yield {
-          type: "tool-call-args-delta",
-          index: buf.index,
-          toolCallId: callId,
-          toolName: buf.name,
-          argsDelta: delta
-        };
-      }
-      continue;
-    }
-    if (type === "response.function_call_arguments.done") {
-      const callId = typeof parsed.call_id === "string" ? parsed.call_id : "";
-      const argsRaw = typeof parsed.arguments === "string" ? parsed.arguments : "";
-      const buf = callBuffers.get(callId);
-      if (buf) {
-        if (argsRaw) buf.argsJson = argsRaw;
-        yield {
-          type: "tool-call-ready",
-          index: buf.index,
-          toolCallId: callId,
-          toolName: buf.name,
-          args: parseArgs(buf.argsJson || argsRaw)
-        };
-      }
-      continue;
-    }
-    if (type === "response.completed") {
-      const response = parsed.response;
-      if (response && Array.isArray(response.output)) {
-        completedOutput = response.output;
-      }
-      const usage = tokenUsageFromRecord(response?.usage);
-      if (usage) {
-        yield { type: "usage", usage };
-      }
-      continue;
-    }
-    if (type === "error") {
-      const message = typeof parsed.message === "string" ? parsed.message : "OpenAI Responses stream error";
-      yield { type: "error", message };
-      return [];
-    }
-  }
-  yield { type: "done" };
-  return completedOutput;
-}
-async function completeResponsesTurn(params) {
-  const res = await fetch(buildEndpoint2(params.config, "/responses"), {
-    method: "POST",
-    headers: buildHeaders3(params.config),
-    body: JSON.stringify(buildResponsesBody(params, false)),
-    signal: params.signal
-  });
-  if (!res.ok) {
-    throw new Error(await readOpenAIError(res));
-  }
-  const json = await res.json();
-  const status = json.status;
-  if (status !== "completed" && status !== void 0) {
-    throw new Error(`OpenAI response ended with status ${String(status)}`);
-  }
-  const output = Array.isArray(json.output) ? json.output : [];
-  const fnCalls = extractFunctionCalls(output);
-  const text = typeof json.output_text === "string" ? json.output_text : extractMessageText(output);
-  return {
-    text,
-    output,
-    toolCalls: fnCalls.map((c) => ({
-      id: c.call_id,
-      name: c.name,
-      args: parseArgs(c.arguments)
-    }))
-  };
-}
-
-// src/llm/providers/openai-responses-driver.ts
-var OpenAIResponsesDriver = class {
-  constructor(config) {
-    this.config = config;
-  }
-  managesToolLoop = true;
-  stream(params) {
-    return this.streamSingleTurn(params);
-  }
-  async complete(params) {
-    const { instructions, input } = seedInputFromMessages(params.messages);
-    const result = await completeResponsesTurn({
-      config: this.config,
-      instructions,
-      input,
-      tools: params.tools,
-      signal: params.signal
-    });
-    return { text: result.text, toolCalls: result.toolCalls };
-  }
-  async *streamToolLoop(params) {
-    const { instructions, input: seeded } = seedInputFromMessages(
-      params.messages
-    );
-    const input = [...seeded];
-    const maxSteps = params.maxSteps ?? 10;
-    for (let step = 0; step < maxSteps; step++) {
-      if (params.signal?.aborted) return;
-      const turn = streamResponsesTurn({
-        config: this.config,
-        instructions,
-        input,
-        tools: params.tools,
-        signal: params.signal
-      });
-      let output = [];
-      for (; ; ) {
-        const next = await turn.next();
-        if (next.done) {
-          output = next.value ?? [];
-          break;
-        }
-        yield next.value;
-        if (next.value.type === "error") return;
-      }
-      input.push(...output);
-      const functionCalls = extractFunctionCalls(output);
-      if (functionCalls.length === 0) return;
-      for (const call of functionCalls) {
-        if (params.signal?.aborted) return;
-        let args = {};
-        try {
-          args = JSON.parse(call.arguments);
-        } catch {
-          args = {};
-        }
-        let result;
-        let isError = false;
-        try {
-          result = await params.callTool(call.name, args);
-          isError = isToolResultError(result);
-        } catch (err) {
-          isError = true;
-          result = {
-            isError: true,
-            error: err instanceof Error ? err.message : String(err)
-          };
-        }
-        appendToolOutputsToInput(input, call.call_id, call.name, result);
-        yield {
-          type: "tool-result",
-          toolCallId: call.call_id,
-          toolName: call.name,
-          result,
-          isError
-        };
-      }
-    }
-  }
-  async runToolLoopNonStreaming(params) {
-    const { instructions, input: seeded } = seedInputFromMessages(
-      params.messages
-    );
-    const input = [...seeded];
-    const maxSteps = params.maxSteps ?? 10;
-    const transcriptToolCalls = [];
-    let finalText = "";
-    for (let step = 0; step < maxSteps; step++) {
-      if (params.signal?.aborted) break;
-      const turn = await completeResponsesTurn({
-        config: this.config,
-        instructions,
-        input,
-        tools: params.tools,
-        signal: params.signal
-      });
-      input.push(...turn.output);
-      if (turn.toolCalls.length === 0) {
-        finalText = turn.text;
-        break;
-      }
-      for (const tc of turn.toolCalls) {
-        let result;
-        let isError = false;
-        try {
-          result = await params.callTool(tc.name, tc.args);
-          isError = isToolResultError(result);
-        } catch (err) {
-          isError = true;
-          result = {
-            isError: true,
-            error: err instanceof Error ? err.message : String(err)
-          };
-        }
-        transcriptToolCalls.push({
-          toolName: tc.name,
-          args: tc.args,
-          result
-        });
-        appendToolOutputsToInput(input, tc.id, tc.name, result);
-        void isError;
-      }
-    }
-    return { content: finalText, toolCalls: transcriptToolCalls };
-  }
-  async *streamSingleTurn(params) {
-    const { instructions, input } = seedInputFromMessages(params.messages);
-    const turn = streamResponsesTurn({
-      config: this.config,
-      instructions,
-      input,
-      tools: params.tools,
-      signal: params.signal
-    });
-    for (; ; ) {
-      const next = await turn.next();
-      if (next.done) return;
-      yield next.value;
-      if (next.value.type === "error") return;
-    }
-  }
-};
-
-// src/llm/driver.ts
-function createLlmDriver(config) {
-  if (config.provider === "openai") {
-    return new OpenAIResponsesDriver(config);
-  }
-  return new RestLlmDriver(config);
-}
-var RestLlmDriver = class {
-  constructor(config) {
-    this.config = config;
-  }
-  stream(params) {
-    return streamChat5({
-      config: this.config,
-      messages: params.messages,
-      tools: params.tools,
-      signal: params.signal
-    });
-  }
-  async complete(params) {
-    const result = await chat5({
-      config: this.config,
-      messages: params.messages,
-      tools: params.tools,
-      signal: params.signal
-    });
-    return { text: result.text, toolCalls: result.toolCalls };
-  }
-};
-
-// src/llm/toolLoop.ts
-async function* runToolLoop(params) {
-  if (params.driver.managesToolLoop && params.driver.streamToolLoop) {
-    yield* params.driver.streamToolLoop(params);
-    return;
-  }
-  const { driver, tools, callTool, signal } = params;
-  const maxSteps = params.maxSteps ?? 10;
-  const messages = [...params.messages];
-  for (let step = 0; step < maxSteps; step++) {
-    if (signal?.aborted) return;
-    const pendingToolCalls = [];
-    let assistantText = "";
-    try {
-      for await (const ev of driver.stream({
-        messages,
-        tools,
-        signal
-      })) {
-        if (ev.type === "text-delta") {
-          assistantText += ev.delta;
-        } else if (ev.type === "tool-call-ready") {
-          pendingToolCalls.push({
-            id: ev.toolCallId,
-            name: ev.toolName,
-            args: ev.args
-          });
-        }
-        yield ev;
-      }
-    } catch (err) {
-      if (err instanceof LlmRequestError) {
-        throw err;
-      }
-      yield {
-        type: "error",
-        message: err instanceof Error ? err.message : String(err)
-      };
-      return;
-    }
-    if (pendingToolCalls.length === 0) {
-      return;
-    }
-    messages.push({
-      role: "assistant",
-      content: assistantText,
-      toolCalls: pendingToolCalls
-    });
-    for (const tc of pendingToolCalls) {
-      if (signal?.aborted) return;
-      let result;
-      let isError = false;
-      try {
-        result = await callTool(tc.name, tc.args);
-        isError = isToolResultError(result);
-      } catch (err) {
-        isError = true;
-        result = {
-          isError: true,
-          error: err instanceof Error ? err.message : String(err)
-        };
-      }
-      messages.push({
-        role: "tool",
-        content: toolResultToContent(result),
-        toolCallId: tc.id,
-        toolName: tc.name,
-        toolResult: result,
-        toolIsError: isError
-      });
-      yield {
-        type: "tool-result",
-        toolCallId: tc.id,
-        toolName: tc.name,
-        result,
-        isError
-      };
-    }
-  }
-}
-async function runToolLoopNonStreaming(params) {
-  if (params.driver.managesToolLoop && params.driver.runToolLoopNonStreaming) {
-    return params.driver.runToolLoopNonStreaming(params);
-  }
-  const { driver, tools, callTool, signal } = params;
-  const maxSteps = params.maxSteps ?? 10;
-  const messages = [...params.messages];
-  const transcriptToolCalls = [];
-  let finalText = "";
-  for (let step = 0; step < maxSteps; step++) {
-    if (signal?.aborted) break;
-    const { text, toolCalls } = await driver.complete({
-      messages,
-      tools,
-      signal
-    });
-    if (toolCalls.length === 0) {
-      finalText = text;
-      break;
-    }
-    messages.push({
-      role: "assistant",
-      content: text,
-      toolCalls
-    });
-    for (const tc of toolCalls) {
-      let result;
-      let isError = false;
-      try {
-        result = await callTool(tc.name, tc.args);
-        isError = isToolResultError(result);
-      } catch (err) {
-        isError = true;
-        result = {
-          isError: true,
-          error: err instanceof Error ? err.message : String(err)
-        };
-      }
-      transcriptToolCalls.push({
-        toolName: tc.name,
-        args: tc.args,
-        result
-      });
-      messages.push({
-        role: "tool",
-        content: toolResultToContent(result),
-        toolCallId: tc.id,
-        toolName: tc.name,
-        toolResult: result,
-        toolIsError: isError
-      });
-    }
-  }
-  return { content: finalText, toolCalls: transcriptToolCalls };
-}
-
-// src/llm/native_runner.ts
-async function* streamNativeAgent(driver, options) {
-  yield* runToolLoop({
-    driver,
-    messages: options.messages,
-    tools: options.tools,
-    callTool: options.callTool,
-    maxSteps: options.maxSteps,
-    signal: options.signal
-  });
-}
-async function* streamNativeAgentSteps(driver, options) {
-  let finalText = "";
-  let pendingStep = null;
-  for await (const ev of streamNativeAgent(driver, options)) {
-    if (ev.type === "text-delta") {
-      finalText += ev.delta;
-    } else if (ev.type === "tool-call-ready") {
-      pendingStep = {
-        action: {
-          tool: ev.toolName,
-          toolInput: ev.args,
-          log: `Calling tool ${ev.toolName}`
-        },
-        observation: ""
-      };
-      yield pendingStep;
-    } else if (ev.type === "tool-result" && pendingStep) {
-      const observation = typeof ev.result === "string" ? ev.result : JSON.stringify(ev.result ?? "");
-      yield {
-        action: pendingStep.action,
-        observation
-      };
-      pendingStep = null;
-    } else if (ev.type === "error") {
-      throw new Error(ev.message);
-    }
-  }
-  return finalText;
-}
-async function runNativeAgent(driver, options) {
-  const result = await runToolLoopNonStreaming({
-    driver,
-    messages: options.messages,
-    tools: options.tools,
-    callTool: options.callTool,
-    maxSteps: options.maxSteps,
-    signal: options.signal
-  });
-  return result.content;
-}
-
-// src/llm/provider_config.ts
-var import_client3 = require("@mcp-use/client");
-var PROVIDER_ENV = {
-  openai: ["OPENAI_API_KEY"],
-  anthropic: ["ANTHROPIC_API_KEY"],
-  google: ["GOOGLE_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"],
-  openrouter: ["OPENROUTER_API_KEY"],
-  ollama: [],
-  "openai-compatible": ["OPENAI_API_KEY"]
-};
-function resolveApiKey(provider, config) {
-  if (config?.apiKey) return config.apiKey;
-  const envVars = PROVIDER_ENV[provider] ?? [];
-  if (typeof process !== "undefined" && process.env) {
-    for (const envVar of envVars) {
-      const key = process.env[envVar];
-      if (key) {
-        import_client3.logger.debug(`Using API key from ${envVar} for ${provider}`);
-        return key;
-      }
-    }
-  }
-  if (provider === "ollama") return "";
-  const hint = envVars.length > 0 ? envVars.join(" or ") : "apiKey in llmConfig";
-  throw new Error(`API key not found for provider '${provider}'. Set ${hint}.`);
-}
-function parseLLMStringToProviderConfig(llmString, config) {
-  const parts = llmString.split("/");
-  if (parts.length < 2) {
-    throw new Error(
-      `Invalid LLM string '${llmString}'. Expected 'provider/model'.`
-    );
-  }
-  const provider = parts[0].toLowerCase();
-  const model = parts.slice(1).join("/");
-  const supported = [
-    "openai",
-    "anthropic",
-    "google",
-    "openrouter",
-    "ollama",
-    "openai-compatible"
-  ];
-  if (!supported.includes(provider)) {
-    throw new Error(
-      `Unsupported provider '${provider}'. Supported: ${supported.join(", ")}`
-    );
-  }
-  return {
-    provider,
-    model,
-    apiKey: resolveApiKey(provider, config),
-    temperature: config?.temperature,
-    maxTokens: config?.maxTokens,
-    baseUrl: config?.baseUrl,
-    extraHeaders: config?.extraHeaders,
-    credentials: config?.credentials
-  };
-}
-function providerConfigFromOptions(provider, model, config) {
-  return {
-    provider,
-    model,
-    apiKey: resolveApiKey(provider, config),
-    temperature: config?.temperature,
-    maxTokens: config?.maxTokens,
-    baseUrl: config?.baseUrl,
-    extraHeaders: config?.extraHeaders,
-    credentials: config?.credentials
-  };
-}
-
-// src/version.ts
-var VERSION = "2.0.0-beta.1";
-function getPackageVersion() {
-  return VERSION;
-}
-
-// src/agents/normalize_run_options.ts
-function normalizeRunOptions(queryOrOptions, maxSteps, manageConnector, _externalHistory, outputSchema, signal) {
-  if (typeof queryOrOptions === "object" && queryOrOptions !== null) {
-    return {
-      prompt: queryOrOptions.prompt,
-      maxSteps: queryOrOptions.maxSteps,
-      manageConnector: queryOrOptions.manageConnector,
-      messages: queryOrOptions.messages,
-      schema: queryOrOptions.schema,
-      signal: queryOrOptions.signal
-    };
-  }
-  return {
-    prompt: queryOrOptions,
-    maxSteps,
-    manageConnector,
-    schema: outputSchema,
-    signal
-  };
-}
-
-// src/agents/remote.ts
-var import_zod = require("zod");
-var import_client4 = require("@mcp-use/client");
-var API_CHATS_ENDPOINT = "/api/v1/chats";
-var API_CHAT_EXECUTE_ENDPOINT = "/api/v1/chats/{chat_id}/execute";
-function normalizeRemoteRunOptions(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema) {
-  if (typeof queryOrOptions === "object" && queryOrOptions !== null) {
-    const options = queryOrOptions;
-    return {
-      query: options.prompt ?? "",
-      maxSteps: options.maxSteps,
-      manageConnector: options.manageConnector,
-      externalHistory: options.externalHistory,
-      outputSchema: options.schema
-    };
-  }
-  return {
-    query: queryOrOptions,
-    maxSteps,
-    manageConnector,
-    externalHistory,
-    outputSchema
-  };
-}
-var RemoteAgent = class {
-  agentId;
-  apiKey;
-  baseUrl;
-  chatId = null;
-  constructor(options) {
-    this.agentId = options.agentId;
-    this.baseUrl = options.baseUrl ?? "https://cloud.manufact.com";
-    const apiKey = options.apiKey ?? (typeof process !== "undefined" && process.env?.MCP_USE_API_KEY);
-    if (!apiKey) {
-      throw new Error(
-        "API key is required for remote execution. Please provide it as a parameter or set the MCP_USE_API_KEY environment variable. You can get an API key from https://cloud.manufact.com"
-      );
-    }
-    this.apiKey = apiKey;
-  }
-  pydanticToJsonSchema(schema) {
-    return (0, import_zod.toJSONSchema)(schema);
-  }
-  parseStructuredResponse(responseData, outputSchema) {
-    let resultData;
-    if (typeof responseData === "object" && responseData !== null) {
-      if ("result" in responseData) {
-        const outerResult = responseData.result;
-        if (typeof outerResult === "object" && outerResult !== null && "result" in outerResult) {
-          resultData = outerResult.result;
-        } else {
-          resultData = outerResult;
-        }
-      } else {
-        resultData = responseData;
-      }
-    } else if (typeof responseData === "string") {
-      try {
-        resultData = JSON.parse(responseData);
-      } catch {
-        resultData = { content: responseData };
-      }
-    } else {
-      resultData = responseData;
-    }
-    try {
-      return outputSchema.parse(resultData);
-    } catch (e) {
-      import_client4.logger.warn(`Failed to parse structured output: ${e}`);
-      const schemaShape = outputSchema._def?.shape();
-      if (schemaShape && "content" in schemaShape) {
-        return outputSchema.parse({ content: String(resultData) });
-      }
-      throw e;
-    }
-  }
-  async createChatSession() {
-    const chatPayload = {
-      title: `Remote Agent Session - ${this.agentId}`,
-      agent_id: this.agentId,
-      type: "agent_execution"
-    };
-    const headers = {
-      "Content-Type": "application/json",
-      "x-api-key": this.apiKey
-    };
-    const chatUrl = `${this.baseUrl}${API_CHATS_ENDPOINT}`;
-    import_client4.logger.debug(`\u{1F4DD} Creating chat session for agent ${this.agentId}`);
-    try {
-      const response = await fetch(chatUrl, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(chatPayload)
-      });
-      if (!response.ok) {
-        const responseText = await response.text();
-        const statusCode = response.status;
-        if (statusCode === 404) {
-          throw new Error(
-            `Agent not found: Agent '${this.agentId}' does not exist or you don't have access to it. Please verify the agent ID and ensure it exists in your account.`
-          );
-        }
-        throw new Error(
-          `Failed to create chat session: ${statusCode} - ${responseText}`
-        );
-      }
-      const chatData = await response.json();
-      const chatId = chatData.id;
-      import_client4.logger.debug(`\u2705 Chat session created: ${chatId}`);
-      return chatId;
-    } catch (e) {
-      if (e instanceof Error) {
-        throw new TypeError(`Failed to create chat session: ${e.message}`);
-      }
-      throw new Error(`Failed to create chat session: ${String(e)}`);
-    }
-  }
-  async run(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema) {
-    const {
-      query,
-      maxSteps: steps,
-      externalHistory: history,
-      outputSchema: schema
-    } = normalizeRemoteRunOptions(
-      queryOrOptions,
-      maxSteps,
-      manageConnector,
-      externalHistory,
-      outputSchema
-    );
-    if (history !== void 0) {
-      import_client4.logger.warn("External history is not yet supported for remote execution");
-    }
-    try {
-      import_client4.logger.debug(`\u{1F310} Executing query on remote agent ${this.agentId}`);
-      if (this.chatId === null) {
-        this.chatId = await this.createChatSession();
-      }
-      const chatId = this.chatId;
-      const executionPayload = {
-        query,
-        max_steps: steps ?? 10
-      };
-      if (schema) {
-        executionPayload.output_schema = this.pydanticToJsonSchema(schema);
-        import_client4.logger.debug(`\u{1F527} Using structured output with schema`);
-      }
-      const headers = {
-        "Content-Type": "application/json",
-        "x-api-key": this.apiKey
-      };
-      const executionUrl = `${this.baseUrl}${API_CHAT_EXECUTE_ENDPOINT.replace("{chat_id}", chatId)}`;
-      import_client4.logger.debug(`\u{1F680} Executing agent in chat ${chatId}`);
-      const response = await fetch(executionUrl, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(executionPayload),
-        signal: AbortSignal.timeout(3e5)
-        // 5 minute timeout
-      });
-      if (!response.ok) {
-        const responseText = await response.text();
-        const statusCode = response.status;
-        if (statusCode === 401) {
-          import_client4.logger.error(`\u274C Authentication failed: ${responseText}`);
-          throw new Error(
-            "Authentication failed: Invalid or missing API key. Please check your API key and ensure the MCP_USE_API_KEY environment variable is set correctly."
-          );
-        } else if (statusCode === 403) {
-          import_client4.logger.error(`\u274C Access forbidden: ${responseText}`);
-          throw new Error(
-            `Access denied: You don't have permission to execute agent '${this.agentId}'. Check if the agent exists and you have the necessary permissions.`
-          );
-        } else if (statusCode === 404) {
-          import_client4.logger.error(`\u274C Agent not found: ${responseText}`);
-          throw new Error(
-            `Agent not found: Agent '${this.agentId}' does not exist or you don't have access to it. Please verify the agent ID and ensure it exists in your account.`
-          );
-        } else if (statusCode === 422) {
-          import_client4.logger.error(`\u274C Validation error: ${responseText}`);
-          throw new Error(
-            `Request validation failed: ${responseText}. Please check your query parameters and output schema format.`
-          );
-        } else if (statusCode === 500) {
-          import_client4.logger.error(`\u274C Server error: ${responseText}`);
-          throw new Error(
-            "Internal server error occurred during agent execution. Please try again later or contact support if the issue persists."
-          );
-        } else {
-          import_client4.logger.error(
-            `\u274C Remote execution failed with status ${statusCode}: ${responseText}`
-          );
-          throw new Error(
-            `Remote agent execution failed: ${statusCode} - ${responseText}`
-          );
-        }
-      }
-      const result = await response.json();
-      import_client4.logger.debug(`\u{1F527} Response: ${JSON.stringify(result)}`);
-      import_client4.logger.debug("\u2705 Remote execution completed successfully");
-      if (typeof result === "object" && result !== null) {
-        if (result.status === "error" || result.error !== null) {
-          const errorMsg = result.error ?? String(result);
-          import_client4.logger.error(`\u274C Remote agent execution failed: ${errorMsg}`);
-          throw new Error(`Remote agent execution failed: ${errorMsg}`);
-        }
-        if (String(result).includes("failed to initialize")) {
-          import_client4.logger.error(`\u274C Agent initialization failed: ${result}`);
-          throw new Error(
-            `Agent initialization failed on remote server. This usually indicates:
-\u2022 Invalid agent configuration (LLM model, system prompt)
-\u2022 Missing or invalid MCP server configurations
-\u2022 Network connectivity issues with MCP servers
-\u2022 Missing environment variables or credentials
-Raw error: ${result}`
-          );
-        }
-      }
-      if (schema) {
-        return this.parseStructuredResponse(result, schema);
-      }
-      if (typeof result === "object" && result !== null && "result" in result) {
-        return result.result;
-      } else if (typeof result === "string") {
-        return result;
-      } else {
-        return String(result);
-      }
-    } catch (e) {
-      if (e instanceof Error) {
-        if (e.name === "AbortError") {
-          import_client4.logger.error(`\u274C Remote execution timed out: ${e}`);
-          throw new Error(
-            "Remote agent execution timed out. The server may be overloaded or the query is taking too long to process. Try again or use a simpler query."
-          );
-        }
-        import_client4.logger.error(`\u274C Remote execution error: ${e}`);
-        throw new Error(`Remote agent execution failed: ${e.message}`);
-      }
-      import_client4.logger.error(`\u274C Remote execution error: ${e}`);
-      throw new Error(`Remote agent execution failed: ${String(e)}`);
-    }
-  }
-  // eslint-disable-next-line require-yield
-  async *stream(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema) {
-    const result = await this.run(
-      queryOrOptions,
-      maxSteps,
-      manageConnector,
-      externalHistory,
-      outputSchema
-    );
-    return result;
-  }
-  async close() {
-    import_client4.logger.debug("\u{1F50C} Remote agent client closed");
-  }
-};
-
-// src/agents/mcp_agent.ts
-var MCPAgent = class {
-  static getPackageVersion() {
-    return getPackageVersion();
-  }
-  driver;
-  client;
-  connectors = [];
-  clientOwnedByAgent = false;
-  nativeAdapter;
-  providerTools = [];
-  callTool;
-  maxSteps;
-  autoInitialize;
-  systemPrompt;
-  disallowedTools;
-  exposeResourcesAsTools;
-  exposePromptsAsTools;
-  initialized = false;
-  isRemote = false;
-  remoteAgent = null;
-  isSimplifiedMode = false;
-  llmString;
-  llmConfig;
-  mcpServersConfig;
-  explicitProviderConfig;
-  conversationMessages = [];
-  memoryEnabled;
-  boundConnections;
-  constructor(options) {
-    if (options.agentId) {
-      this.isRemote = true;
-      this.remoteAgent = new RemoteAgent({
-        agentId: options.agentId,
-        apiKey: options.apiKey,
-        baseUrl: options.baseUrl
-      });
-      this.maxSteps = options.maxSteps ?? 10;
-      this.autoInitialize = options.autoInitialize ?? false;
-      this.nativeAdapter = new NativeAdapter();
-      this.systemPrompt = options.systemPrompt ?? "You are a helpful assistant with access to MCP tools.";
-      this.disallowedTools = [];
-      this.exposeResourcesAsTools = true;
-      this.exposePromptsAsTools = true;
-      this.memoryEnabled = options.memoryEnabled ?? true;
-      return;
-    }
-    this.maxSteps = options.maxSteps ?? 10;
-    this.autoInitialize = options.autoInitialize ?? false;
-    this.systemPrompt = options.systemPrompt ?? "You are a helpful assistant with access to MCP tools.";
-    this.disallowedTools = options.disallowedTools ?? [];
-    this.exposeResourcesAsTools = options.exposeResourcesAsTools ?? true;
-    this.exposePromptsAsTools = options.exposePromptsAsTools ?? true;
-    this.memoryEnabled = options.memoryEnabled ?? true;
-    this.nativeAdapter = new NativeAdapter(this.disallowedTools);
-    this.llmConfig = options.llmConfig;
-    this.resolveMcpServers(options.mcpServers);
-    if (typeof options.llm === "string") {
-      this.isSimplifiedMode = true;
-      this.llmString = options.llm;
-      if (!this.hasLiveConnections() && (!this.mcpServersConfig || Object.keys(this.mcpServersConfig).length === 0) && !options.client && !options.connectors?.length) {
-        throw new Error(
-          "Simplified mode requires mcpServers, or an existing client/connectors."
-        );
-      }
-    } else {
-      this.explicitProviderConfig = options.llm;
-      this.client = options.client;
-      this.connectors = options.connectors ?? [];
-      if (!this.hasLiveConnections() && !this.client && this.connectors.length === 0 && (!this.mcpServersConfig || Object.keys(this.mcpServersConfig).length === 0)) {
-        throw new Error(
-          "Explicit mode requires mcpServers, client, or connectors."
-        );
-      }
-    }
-    if (options.client) this.client = options.client;
-    if (options.connectors?.length) this.connectors = options.connectors;
-    if (this.hasLiveConnections() && this.explicitProviderConfig) {
-      this.bindConnections(this.boundConnections, this.explicitProviderConfig);
-    } else if (this.hasLiveConnections() && this.llmString) {
-      this.driver = createLlmDriver(
-        parseLLMStringToProviderConfig(this.llmString, this.llmConfig)
-      );
-      this.bindConnections(
-        this.boundConnections,
-        parseLLMStringToProviderConfig(this.llmString, this.llmConfig)
-      );
-    }
-  }
-  resolveMcpServers(mcpServers) {
-    if (!mcpServers) return;
-    if (Array.isArray(mcpServers)) {
-      this.boundConnections = mcpServers;
-      return;
-    }
-    this.mcpServersConfig = mcpServers;
-  }
-  hasLiveConnections() {
-    return (this.boundConnections?.length ?? 0) > 0;
-  }
-  async initialize() {
-    if (this.isRemote) {
-      this.initialized = true;
-      return;
-    }
-    if (this.initialized) return;
-    if (this.isSimplifiedMode) {
-      if (!this.client && this.mcpServersConfig) {
-        const { MCPClient } = await import("@mcp-use/client");
-        this.client = new MCPClient({ mcpServers: this.mcpServersConfig });
-        this.clientOwnedByAgent = true;
-      }
-      if (this.llmString) {
-        this.driver = createLlmDriver(
-          parseLLMStringToProviderConfig(this.llmString, this.llmConfig)
-        );
-      }
-    } else if (this.explicitProviderConfig) {
-      this.driver = createLlmDriver(this.explicitProviderConfig);
-    }
-    if (!this.driver) {
-      throw new Error("LLM driver not configured.");
-    }
-    if (!this.hasLiveConnections()) {
-      await this.loadTools();
-    }
-    this.initialized = true;
-    import_client5.logger.debug("MCPAgent initialized");
-  }
-  async loadTools() {
-    const entries = [];
-    if (this.client) {
-      if (!this.client.activeSessions || Object.keys(this.client.activeSessions).length === 0) {
-        await this.client.createAllSessions();
-      }
-      const sessions = this.client.getAllActiveSessions();
-      const connectors = Object.values(sessions).map((s) => s.connector);
-      entries.push(
-        ...await this.nativeAdapter.createToolsFromConnectors(connectors)
-      );
-      if (this.exposeResourcesAsTools) {
-        entries.push(
-          ...await this.nativeAdapter.createResourcesFromConnectors(
-            connectors
-          )
-        );
-      }
-      if (this.exposePromptsAsTools) {
-        entries.push(
-          ...await this.nativeAdapter.createPromptsFromConnectors(connectors)
-        );
-      }
-    } else {
-      for (const connector of this.connectors) {
-        if (!connector.isClientConnected) await connector.connect();
-      }
-      entries.push(
-        ...await this.nativeAdapter.createToolsFromConnectors(this.connectors)
-      );
-      if (this.exposeResourcesAsTools) {
-        entries.push(
-          ...await this.nativeAdapter.createResourcesFromConnectors(
-            this.connectors
-          )
-        );
-      }
-      if (this.exposePromptsAsTools) {
-        entries.push(
-          ...await this.nativeAdapter.createPromptsFromConnectors(
-            this.connectors
-          )
-        );
-      }
-    }
-    this.providerTools = this.nativeAdapter.toProviderTools(entries);
-    this.callTool = this.nativeAdapter.createCallTool();
-  }
-  bindConnections(connections, providerConfig) {
-    const disallowed = new Set(this.disallowedTools);
-    const usedNames = /* @__PURE__ */ new Set();
-    const routes = /* @__PURE__ */ new Map();
-    const reserveName = (name) => {
-      if (!usedNames.has(name)) {
-        usedNames.add(name);
-        return name;
-      }
-      let i = 2;
-      while (usedNames.has(`${name}_${i}`)) i++;
-      const fallback = `${name}_${i}`;
-      usedNames.add(fallback);
-      return fallback;
-    };
-    const providerTools = [];
-    for (const connection of connections) {
-      for (const tool of connection.tools ?? []) {
-        if (disallowed.has(tool.name)) continue;
-        const name = reserveName(tool.name);
-        routes.set(name, { connection, mcpName: tool.name });
-        providerTools.push({
-          name,
-          description: tool.description,
-          inputSchema: tool.inputSchema ?? {
-            type: "object",
-            properties: {}
-          }
-        });
-      }
-    }
-    this.providerTools = providerTools;
-    this.callTool = async (name, args) => {
-      const route = routes.get(name);
-      if (!route) {
-        throw new Error(`Unknown tool: ${name}`);
-      }
-      return route.connection.callTool(route.mcpName, args);
-    };
-    this.driver = createLlmDriver(providerConfig);
-    this.initialized = true;
-  }
-  buildMessages(options) {
-    const messages = [
-      { role: "system", content: this.systemPrompt }
-    ];
-    if (this.memoryEnabled && this.conversationMessages.length > 0) {
-      messages.push(...this.conversationMessages);
-    }
-    if (options.messages?.length) {
-      messages.push(...options.messages);
-    }
-    if (options.prompt) {
-      messages.push({ role: "user", content: options.prompt });
-    }
-    return messages;
-  }
-  getConversationHistory() {
-    return [...this.conversationMessages];
-  }
-  clearConversationHistory() {
-    this.conversationMessages = [];
-  }
-  setSystemMessage(message) {
-    this.systemPrompt = message;
-  }
-  async ensureReady(manageConnector = true) {
-    if (manageConnector && !this.initialized) {
-      if (this.autoInitialize) {
-        await this.initialize();
-      } else {
-        throw new Error("MCPAgent not initialized. Call initialize() first.");
-      }
-    }
-    if (!this.driver || !this.callTool) {
-      throw new Error("MCPAgent driver or tools not ready.");
-    }
-  }
-  nativeRunParams(options) {
-    return {
-      messages: this.buildMessages(options),
-      tools: this.providerTools,
-      callTool: this.callTool,
-      maxSteps: options.maxSteps ?? this.maxSteps,
-      signal: options.signal
-    };
-  }
-  async run(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema, signal) {
-    const options = normalizeRunOptions(
-      queryOrOptions,
-      maxSteps,
-      manageConnector,
-      externalHistory,
-      outputSchema,
-      signal
-    );
-    if (options.schema) {
-      throw new Error(
-        "Structured output requires @mcp-use/agent/langchain or pass a JSON schema via prompt."
-      );
-    }
-    if (this.isRemote && this.remoteAgent) {
-      return this.remoteAgent.run(
-        options.prompt ?? "",
-        options.maxSteps,
-        options.manageConnector
-      );
-    }
-    await this.ensureReady(options.manageConnector ?? true);
-    const result = await runNativeAgent(
-      this.driver,
-      this.nativeRunParams(options)
-    );
-    if (this.memoryEnabled && options.prompt) {
-      this.conversationMessages.push({
-        role: "user",
-        content: options.prompt
-      });
-      this.conversationMessages.push({
-        role: "assistant",
-        content: result
-      });
-    }
-    return result;
-  }
-  async *stream(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema, signal) {
-    const options = normalizeRunOptions(
-      queryOrOptions,
-      maxSteps,
-      manageConnector,
-      externalHistory,
-      outputSchema,
-      signal
-    );
-    if (this.isRemote && this.remoteAgent) {
-      const result2 = await this.remoteAgent.run(
-        options.prompt ?? "",
-        options.maxSteps,
-        options.manageConnector
-      );
-      return result2;
-    }
-    await this.ensureReady(options.manageConnector ?? true);
-    const result = yield* streamNativeAgentSteps(
-      this.driver,
-      this.nativeRunParams(options)
-    );
-    if (this.memoryEnabled && options.prompt) {
-      this.conversationMessages.push({
-        role: "user",
-        content: options.prompt
-      });
-      this.conversationMessages.push({
-        role: "assistant",
-        content: result
-      });
-    }
-    return result;
-  }
-  async *streamEvents(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema, signal) {
-    const options = normalizeRunOptions(
-      queryOrOptions,
-      maxSteps,
-      manageConnector,
-      externalHistory,
-      outputSchema,
-      signal
-    );
-    if (this.isRemote && this.remoteAgent) {
-      throw new Error("streamEvents is not supported for remote agents.");
-    }
-    await this.ensureReady(options.manageConnector ?? true);
-    yield* streamNativeAgent(this.driver, this.nativeRunParams(options));
-  }
-  /** Single-shot completion without tools (sampling, props generation). */
-  async chat(options) {
-    await this.ensureReady();
-    const result = await this.driver.complete({
-      messages: options.messages,
-      tools: [],
-      signal: options.signal
-    });
-    return result.text;
-  }
-  async close() {
-    if (this.clientOwnedByAgent && this.client) {
-      await this.client.closeAllSessions?.();
-    }
-    this.initialized = false;
-  }
-};
-
-// src/llm/chat.ts
-async function completeChat(params) {
-  const driver = createLlmDriver(params.config);
-  const result = await driver.complete({
-    messages: params.messages,
-    tools: [],
-    signal: params.signal
-  });
-  return result.text;
-}
-
-// src/agents/prompts/index.ts
-var CODE_MODE_PROMPT = "Use code execution mode to discover and call MCP tools programmatically.";
-var PROMPTS = {
-  CODE_MODE: CODE_MODE_PROMPT
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BaseAdapter,
-  DEFAULT_OLLAMA_BASE_URL,
-  LlmRequestError,
-  MCPAgent,
-  NativeAdapter,
-  OllamaCorsError,
-  PROMPTS,
-  RemoteAgent,
-  buildOllamaApiUrl,
-  chat,
-  completeChat,
-  convertMessagesToProvider,
-  normalizeOllamaBaseUrl,
-  parseLLMStringToProviderConfig,
-  providerConfigFromOptions
-});
-//# sourceMappingURL=index.cjs.map