@mcp-use/agent 0.0.0-bootstrap.0 → 2.0.0-beta.1

package/dist/index.js

@@ -0,0 +1,3248 @@
+// src/agents/mcp_agent.ts
+import { logger as logger5 } from "@mcp-use/client";
+
+// src/adapters/native_adapter.ts
+import { logger as logger2 } from "@mcp-use/client";
+
+// src/adapters/base.ts
+import { logger } from "@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) {
+      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);
+      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);
+    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);
+    }
+    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);
+          }
+        }
+      }
+      logger.debug(
+        `Loaded ${connectorResources.length} new resources for connector: ${connectorResources.map((r) => r?.name ?? String(r)).join(", ")}`
+      );
+    } catch (err) {
+      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);
+          }
+        }
+      }
+      logger.debug(
+        `Loaded ${connectorPrompts.length} new prompts for connector: ${connectorPrompts.map((p) => p?.name ?? String(p)).join(", ")}`
+      );
+    } catch (err) {
+      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);
+    }
+    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);
+    }
+    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)) {
+      logger.debug("Connector doesn't have tools, initializing it");
+      try {
+        await connector.initialize();
+        return true;
+      } catch (err) {
+        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) {
+        logger2.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) {
+      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
+import { logger as logger3 } from "@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) {
+        logger3.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.0";
+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
+import { toJSONSchema } from "zod";
+import { logger as logger4 } from "@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 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) {
+      logger4.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}`;
+    logger4.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;
+      logger4.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) {
+      logger4.warn("External history is not yet supported for remote execution");
+    }
+    try {
+      logger4.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);
+        logger4.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)}`;
+      logger4.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) {
+          logger4.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) {
+          logger4.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) {
+          logger4.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) {
+          logger4.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) {
+          logger4.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 {
+          logger4.error(
+            `\u274C Remote execution failed with status ${statusCode}: ${responseText}`
+          );
+          throw new Error(
+            `Remote agent execution failed: ${statusCode} - ${responseText}`
+          );
+        }
+      }
+      const result = await response.json();
+      logger4.debug(`\u{1F527} Response: ${JSON.stringify(result)}`);
+      logger4.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);
+          logger4.error(`\u274C Remote agent execution failed: ${errorMsg}`);
+          throw new Error(`Remote agent execution failed: ${errorMsg}`);
+        }
+        if (String(result).includes("failed to initialize")) {
+          logger4.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") {
+          logger4.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."
+          );
+        }
+        logger4.error(`\u274C Remote execution error: ${e}`);
+        throw new Error(`Remote agent execution failed: ${e.message}`);
+      }
+      logger4.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() {
+    logger4.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;
+    logger5.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
+};
+export {
+  BaseAdapter,
+  DEFAULT_OLLAMA_BASE_URL,
+  LlmRequestError,
+  MCPAgent,
+  NativeAdapter,
+  OllamaCorsError,
+  PROMPTS,
+  RemoteAgent,
+  buildOllamaApiUrl,
+  completeChat as chat,
+  completeChat,
+  convertMessagesToProvider,
+  normalizeOllamaBaseUrl,
+  parseLLMStringToProviderConfig,
+  providerConfigFromOptions
+};
+//# sourceMappingURL=index.js.map