turbollm 0.6.2 → 0.7.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { openSync as openSync3, readFileSync as readFileSync8 } from "fs";
 import { serve } from "@hono/node-server";
 import { dirname as dirname7, join as join14 } from "path";
@@ -88,7 +88,9 @@ function defaultConfig() {
     modelDefaults: { ctx: 8192, ngl: 99, imageMaxTokens: 0, maxTokens: 0 },
     featuredOverrideUrl: "",
     comfyui: { enabled: false, gatePath: "", url: "", reverseGate: false, cachePersist: false },
-    gateway: { autoSwap: true, keepN: 1 }
+    gateway: { autoSwap: true, keepN: 1 },
+    tools: {},
+    mcp: { servers: [] }
   };
 }
 var ConfigStore = class _ConfigStore {
@@ -234,6 +236,15 @@ function normalize(c) {
     autoSwap: gw.autoSwap !== false,
     keepN: typeof gw.keepN === "number" && gw.keepN >= 1 ? Math.min(Math.floor(gw.keepN), 4) : 1
   };
+  const tl = c.tools ?? {};
+  c.tools = {};
+  if (tl.tavily && typeof tl.tavily.apiKey === "string") {
+    c.tools.tavily = { apiKey: tl.tavily.apiKey };
+  }
+  const mc = c.mcp ?? {};
+  c.mcp = {
+    servers: Array.isArray(mc.servers) ? mc.servers.filter((s) => typeof s === "object" && s !== null && typeof s.id === "string" && typeof s.name === "string" && (s.transport === "stdio" || s.transport === "sse")) : []
+  };
   c.telemetry.level = normalizeTelemetryLevel(c.telemetry.level);
   for (const e of c.engines) {
     e.capabilities ??= { kvTypes: [], flags: [] };
@@ -2597,10 +2608,10 @@ function safeJson(s) {
   }
 }
 function rowToConv(r) {
-  return { id: r.id, title: r.title, systemPrompt: r.system_prompt, modelKey: r.model_key, sampling: safeJson(r.sampling), expertMode: r.expert_mode === 1, createdAt: r.created_at, updatedAt: r.updated_at };
+  return { id: r.id, title: r.title, systemPrompt: r.system_prompt, modelKey: r.model_key, sampling: safeJson(r.sampling), expertMode: r.expert_mode === 1, toolPolicy: r.tool_policy ?? void 0, createdAt: r.created_at, updatedAt: r.updated_at };
 }
 function rowToMsg(r) {
-  return { id: r.id, convId: r.conv_id, seq: r.seq, role: r.role, content: r.content, reasoning: r.reasoning, attachments: safeJson(r.attachments), textAttachments: r.text_attachments ? safeJson(r.text_attachments) : [], stats: safeJson(r.stats), createdAt: r.created_at };
+  return { id: r.id, convId: r.conv_id, seq: r.seq, role: r.role, content: r.content, reasoning: r.reasoning, attachments: safeJson(r.attachments), textAttachments: r.text_attachments ? safeJson(r.text_attachments) : [], toolCalls: r.tool_calls ? safeJson(r.tool_calls) : [], stats: safeJson(r.stats), createdAt: r.created_at };
 }
 var ConversationStore = class {
   db;
@@ -2648,6 +2659,18 @@ var ConversationStore = class {
         PRAGMA user_version = 4;
       `);
     }
+    if (v < 5) {
+      this.db.exec(`
+        ALTER TABLE messages ADD COLUMN tool_calls TEXT;
+        PRAGMA user_version = 5;
+      `);
+    }
+    if (v < 6) {
+      this.db.exec(`
+        ALTER TABLE conversations ADD COLUMN tool_policy TEXT;
+        PRAGMA user_version = 6;
+      `);
+    }
   }
   listConversations(q) {
     if (q) {
@@ -2664,7 +2687,7 @@ var ConversationStore = class {
   createConversation(partial) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const id = randomUUID3();
-    this.db.prepare(`INSERT INTO conversations (id,title,system_prompt,model_key,sampling,expert_mode,created_at,updated_at) VALUES ($id,$title,$sp,$mk,$samp,$expert,$now,$now)`).run({ $id: id, $title: partial?.title ?? "New chat", $sp: partial?.systemPrompt ?? "", $mk: partial?.modelKey ?? "", $samp: JSON.stringify(partial?.sampling ?? {}), $expert: partial?.expertMode ? 1 : 0, $now: now });
+    this.db.prepare(`INSERT INTO conversations (id,title,system_prompt,model_key,sampling,expert_mode,tool_policy,created_at,updated_at) VALUES ($id,$title,$sp,$mk,$samp,$expert,$tp,$now,$now)`).run({ $id: id, $title: partial?.title ?? "New chat", $sp: partial?.systemPrompt ?? "", $mk: partial?.modelKey ?? "", $samp: JSON.stringify(partial?.sampling ?? {}), $expert: partial?.expertMode ? 1 : 0, $tp: partial?.toolPolicy ?? null, $now: now });
     return this.getConversation(id);
   }
   getConversation(id, withMessages = false) {
@@ -2707,7 +2730,8 @@ var ConversationStore = class {
     const row = this.db.prepare(`SELECT COALESCE(MAX(seq),0) AS ms FROM messages WHERE conv_id = $id`).get({ $id: convId });
     const modelKey = role === "assistant" ? this.conversationModelKey(convId) : null;
     const textAttachments = extra?.textAttachments?.length ? JSON.stringify(extra.textAttachments) : null;
-    this.db.prepare(`INSERT INTO messages (id,conv_id,seq,role,content,reasoning,attachments,text_attachments,stats,model_key,created_at) VALUES ($id,$cid,$seq,$role,$content,$reasoning,$attachments,$ta,$stats,$mk,$now)`).run({ $id: id, $cid: convId, $seq: row.ms + 1, $role: role, $content: content, $reasoning: extra?.reasoning ?? "", $attachments: JSON.stringify(extra?.attachments ?? []), $ta: textAttachments, $stats: JSON.stringify(extra?.stats ?? {}), $mk: modelKey, $now: now });
+    const toolCalls = extra?.toolCalls?.length ? JSON.stringify(extra.toolCalls) : null;
+    this.db.prepare(`INSERT INTO messages (id,conv_id,seq,role,content,reasoning,attachments,text_attachments,tool_calls,stats,model_key,created_at) VALUES ($id,$cid,$seq,$role,$content,$reasoning,$attachments,$ta,$tc,$stats,$mk,$now)`).run({ $id: id, $cid: convId, $seq: row.ms + 1, $role: role, $content: content, $reasoning: extra?.reasoning ?? "", $attachments: JSON.stringify(extra?.attachments ?? []), $ta: textAttachments, $tc: toolCalls, $stats: JSON.stringify(extra?.stats ?? {}), $mk: modelKey, $now: now });
     this.touchConversation(convId);
     return this.getMessage(id);
   }
@@ -2731,6 +2755,10 @@ var ConversationStore = class {
       sets.push("reasoning = $reasoning");
       params.$reasoning = patch.reasoning;
     }
+    if (patch.toolCalls !== void 0) {
+      sets.push("tool_calls = $tc");
+      params.$tc = JSON.stringify(patch.toolCalls);
+    }
     if (patch.stats !== void 0) {
       sets.push("stats = $stats");
       params.$stats = JSON.stringify(patch.stats);
@@ -3859,8 +3887,497 @@ function sleep3(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
-// src/cli-launch.ts
+// src/tools/builtin.ts
+import { runInNewContext } from "vm";
+var WEB_SEARCH_TOOL = {
+  type: "function",
+  function: {
+    name: "web_search",
+    description: "Search the web for real-time information. Call this BEFORE answering any question that depends on current events, recent data, prices, specific facts, or anything your training data may not cover accurately. Formulate a precise, keyword-focused query \u2014 include names, dates, or version numbers when relevant. Run multiple focused searches rather than one broad one for complex questions.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: 'A precise, specific search query. Use key terms and identifiers. Good: "Python 3.13 release date new features". Bad: "Python new stuff". Good: "NVIDIA RTX 5090 benchmark 2025". Bad: "new GPU benchmarks".'
+        },
+        max_results: { type: "number", description: "Number of results to return (default 5, max 10)." }
+      },
+      required: ["query"]
+    }
+  }
+};
+var FETCH_URL_TOOL = {
+  type: "function",
+  function: {
+    name: "fetch_url",
+    description: "Fetch the text content of a URL. Returns the main text of the page, stripped of HTML.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "The URL to fetch." }
+      },
+      required: ["url"]
+    }
+  }
+};
+var RUN_CODE_TOOL = {
+  type: "function",
+  function: {
+    name: "run_code",
+    description: "Execute a JavaScript snippet and return the result. Useful for calculations, data transformation, and logic. No network, file, or process access.",
+    parameters: {
+      type: "object",
+      properties: {
+        code: { type: "string", description: "JavaScript code to execute. The last expression is the return value." }
+      },
+      required: ["code"]
+    }
+  }
+};
+async function execWebSearch(args, tavilyApiKey) {
+  const query = String(args.query ?? "");
+  if (!query.trim()) return "Error: query is required.";
+  const maxResults = Math.min(10, Math.max(1, Number(args.max_results ?? 5) || 5));
+  let resp;
+  try {
+    resp = await fetch("https://api.tavily.com/search", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        api_key: tavilyApiKey,
+        query,
+        max_results: maxResults,
+        search_depth: "advanced",
+        include_answer: true
+      }),
+      signal: AbortSignal.timeout(2e4)
+    });
+  } catch (e) {
+    return `Error: could not reach Tavily \u2014 ${e.message}`;
+  }
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => "");
+    return `Error: Tavily returned ${resp.status}${text ? ` \u2014 ${text.slice(0, 200)}` : ""}`;
+  }
+  const data = await resp.json();
+  const results = data.results ?? [];
+  if (results.length === 0) return "No results found.";
+  const lines = [];
+  if (data.answer) lines.push(`ANSWER: ${data.answer}
+`);
+  lines.push(`SOURCES (${results.length} results for "${query}"):`);
+  for (const [i, r] of results.entries()) {
+    lines.push(`
+[${i + 1}] ${r.title}`);
+    lines.push(`Source: ${r.url}`);
+    lines.push(r.content.slice(0, 700));
+  }
+  return lines.join("\n").trim();
+}
+async function execFetchUrl(args) {
+  const url = String(args.url ?? "").trim();
+  if (!url) return "Error: url is required.";
+  if (!/^https?:\/\//i.test(url)) return "Error: URL must start with http:// or https://";
+  let resp;
+  try {
+    resp = await fetch(url, {
+      headers: { "User-Agent": "TurboLLM/0.7 (tool-fetch)" },
+      signal: AbortSignal.timeout(15e3)
+    });
+  } catch (e) {
+    return `Error: could not fetch URL \u2014 ${e.message}`;
+  }
+  const contentType2 = resp.headers.get("content-type") ?? "";
+  const text = await resp.text().catch(() => "");
+  let content;
+  if (contentType2.includes("text/html")) {
+    content = text.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/\s{2,}/g, " ").trim();
+  } else {
+    content = text.trim();
+  }
+  if (content.length > 4e3) content = content.slice(0, 4e3) + "\n[truncated]";
+  return content || "(empty response)";
+}
+function execRunCode(args) {
+  const code = String(args.code ?? "").trim();
+  if (!code) return "Error: code is required.";
+  const output = [];
+  const sandbox = {
+    console: {
+      log: (...a) => output.push(a.map(String).join(" ")),
+      error: (...a) => output.push("ERROR: " + a.map(String).join(" ")),
+      warn: (...a) => output.push("WARN: " + a.map(String).join(" "))
+    },
+    Math,
+    JSON,
+    Array,
+    Object,
+    String,
+    Number,
+    Boolean,
+    Date,
+    RegExp,
+    parseInt,
+    parseFloat,
+    isNaN,
+    isFinite,
+    encodeURIComponent,
+    decodeURIComponent
+  };
+  let result;
+  try {
+    result = runInNewContext(`(function(){${code}})()`, sandbox, { timeout: 5e3 });
+  } catch (e) {
+    return `Error: ${e.message}`;
+  }
+  const parts = [];
+  if (output.length > 0) parts.push(output.join("\n"));
+  if (result !== void 0) {
+    try {
+      parts.push(typeof result === "string" ? result : JSON.stringify(result, null, 2));
+    } catch {
+      parts.push(String(result));
+    }
+  }
+  return parts.join("\n") || "(no output)";
+}
+
+// src/tools/mcp-client.ts
 import { spawn as spawn2 } from "child_process";
+import { EventEmitter } from "events";
+var StdioMcpClient = class {
+  serverId;
+  serverName;
+  command;
+  args;
+  env;
+  proc = null;
+  pending = /* @__PURE__ */ new Map();
+  buf = "";
+  msgId = 0;
+  initialized = false;
+  constructor(opts) {
+    this.serverId = opts.id;
+    this.serverName = opts.name;
+    this.command = opts.command;
+    this.args = opts.args ?? [];
+    this.env = opts.env ?? {};
+  }
+  async connect() {
+    if (this.proc) return;
+    this.proc = spawn2(this.command, this.args, {
+      env: { ...process.env, ...this.env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.proc.stdout?.on("data", (chunk) => {
+      this.buf += chunk.toString("utf8");
+      const lines = this.buf.split("\n");
+      this.buf = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const msg = JSON.parse(trimmed);
+          if ("id" in msg && msg.id != null) {
+            const pending = this.pending.get(msg.id);
+            if (pending) {
+              this.pending.delete(msg.id);
+              pending.resolve(msg);
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    this.proc.on("error", () => this.cleanup());
+    this.proc.on("exit", () => this.cleanup());
+    await this.sendRequest("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: { tools: {} },
+      clientInfo: { name: "turbollm", version: "0.7.0" }
+    });
+    await this.sendNotification("notifications/initialized", {});
+    this.initialized = true;
+  }
+  disconnect() {
+    this.cleanup();
+  }
+  async listTools() {
+    if (!this.initialized) await this.connect();
+    const result = await this.sendRequest("tools/list", {});
+    return result.tools ?? [];
+  }
+  async callTool(name, args) {
+    if (!this.initialized) await this.connect();
+    const result = await this.sendRequest("tools/call", { name, arguments: args });
+    const text = (result.content ?? []).filter((c) => c.type === "text" && c.text).map((c) => c.text).join("\n");
+    return result.isError ? `Error: ${text}` : text || "(no output)";
+  }
+  sendRequest(method, params) {
+    const id = ++this.msgId;
+    const req = { jsonrpc: "2.0", id, method, params };
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`MCP request timeout: ${method}`));
+      }, 3e4);
+      this.pending.set(id, {
+        resolve: (r) => {
+          clearTimeout(timer);
+          if (r.error) reject(new Error(r.error.message));
+          else resolve2(r.result);
+        }
+      });
+      this.write(req);
+    });
+  }
+  sendNotification(method, params) {
+    const msg = { jsonrpc: "2.0", method, params };
+    this.write(msg);
+  }
+  write(msg) {
+    if (!this.proc?.stdin?.writable) return;
+    try {
+      this.proc.stdin.write(JSON.stringify(msg) + "\n");
+    } catch {
+    }
+  }
+  cleanup() {
+    for (const p of this.pending.values()) {
+      p.resolve({ jsonrpc: "2.0", id: -1, error: { code: -1, message: "MCP server disconnected" } });
+    }
+    this.pending.clear();
+    try {
+      this.proc?.kill();
+    } catch {
+    }
+    this.proc = null;
+    this.initialized = false;
+  }
+};
+var SseMcpClient = class {
+  serverId;
+  serverName;
+  baseUrl;
+  msgId = 0;
+  sseEndpoint = "";
+  sseAbort = null;
+  emitter = new EventEmitter();
+  initialized = false;
+  constructor(opts) {
+    this.serverId = opts.id;
+    this.serverName = opts.name;
+    this.baseUrl = opts.url.replace(/\/$/, "");
+  }
+  async connect() {
+    if (this.initialized) return;
+    this.sseAbort = new AbortController();
+    const endpoint = await new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => reject(new Error("SSE connect timeout")), 15e3);
+      fetch(`${this.baseUrl}/sse`, { signal: this.sseAbort.signal }).then(async (resp) => {
+        if (!resp.ok || !resp.body) {
+          clearTimeout(timer);
+          reject(new Error(`SSE connect failed: ${resp.status}`));
+          return;
+        }
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        let resolved = false;
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buf += decoder.decode(value, { stream: true });
+          const lines = buf.split("\n");
+          buf = lines.pop() ?? "";
+          for (const line of lines) {
+            if (line.startsWith("data:")) {
+              const data = line.slice(5).trim();
+              if (!resolved) {
+                resolved = true;
+                clearTimeout(timer);
+                resolve2(data);
+              }
+              try {
+                const msg = JSON.parse(data);
+                if (msg.id != null) this.emitter.emit(`rpc:${msg.id}`, msg);
+              } catch {
+              }
+            }
+          }
+        }
+      }).catch((e) => {
+        clearTimeout(timer);
+        if (!this.sseAbort?.signal.aborted) reject(e);
+      });
+    });
+    this.sseEndpoint = endpoint.startsWith("http") ? endpoint : `${this.baseUrl}${endpoint}`;
+    await this.sendRequest("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: { tools: {} },
+      clientInfo: { name: "turbollm", version: "0.7.0" }
+    });
+    await this.post({ jsonrpc: "2.0", method: "notifications/initialized", params: {} });
+    this.initialized = true;
+  }
+  disconnect() {
+    this.sseAbort?.abort();
+    this.sseAbort = null;
+    this.initialized = false;
+  }
+  async listTools() {
+    if (!this.initialized) await this.connect();
+    const result = await this.sendRequest("tools/list", {});
+    return result.tools ?? [];
+  }
+  async callTool(name, args) {
+    if (!this.initialized) await this.connect();
+    const result = await this.sendRequest("tools/call", { name, arguments: args });
+    const text = (result.content ?? []).filter((c) => c.type === "text" && c.text).map((c) => c.text).join("\n");
+    return result.isError ? `Error: ${text}` : text || "(no output)";
+  }
+  async sendRequest(method, params) {
+    const id = ++this.msgId;
+    const req = { jsonrpc: "2.0", id, method, params };
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        this.emitter.removeAllListeners(`rpc:${id}`);
+        reject(new Error(`MCP SSE request timeout: ${method}`));
+      }, 3e4);
+      this.emitter.once(`rpc:${id}`, (msg) => {
+        clearTimeout(timer);
+        if (msg.error) reject(new Error(msg.error.message));
+        else resolve2(msg.result);
+      });
+      this.post(req).catch((e) => {
+        clearTimeout(timer);
+        reject(e);
+      });
+    });
+  }
+  async post(msg) {
+    const url = this.sseEndpoint || `${this.baseUrl}/messages`;
+    await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(msg),
+      signal: AbortSignal.timeout(1e4)
+    });
+  }
+};
+function createMcpClient(server2) {
+  if (server2.transport === "sse") {
+    if (!server2.url) throw new Error(`MCP server "${server2.name}" has transport=sse but no url`);
+    return new SseMcpClient({ id: server2.id, name: server2.name, url: server2.url });
+  }
+  if (!server2.command) throw new Error(`MCP server "${server2.name}" has transport=stdio but no command`);
+  return new StdioMcpClient({
+    id: server2.id,
+    name: server2.name,
+    command: server2.command,
+    args: server2.args,
+    env: server2.env
+  });
+}
+
+// src/tools/tool-registry.ts
+var ToolRegistry = class {
+  toolsCfg;
+  mcpClients = /* @__PURE__ */ new Map();
+  constructor(toolsCfg) {
+    this.toolsCfg = toolsCfg;
+  }
+  /** Update config (called on settings change without restart). */
+  updateConfig(toolsCfg) {
+    this.toolsCfg = toolsCfg;
+  }
+  /** Connect/disconnect MCP servers to match the current config list. */
+  async syncMcpServers(servers) {
+    const enabledIds = new Set(servers.filter((s) => s.enabled).map((s) => s.id));
+    for (const [id, client] of this.mcpClients) {
+      if (!enabledIds.has(id)) {
+        client.disconnect();
+        this.mcpClients.delete(id);
+      }
+    }
+    for (const srv of servers) {
+      if (!srv.enabled || this.mcpClients.has(srv.id)) continue;
+      try {
+        const client = createMcpClient(srv);
+        await client.connect();
+        this.mcpClients.set(srv.id, client);
+      } catch {
+      }
+    }
+  }
+  disconnectAll() {
+    for (const client of this.mcpClients.values()) client.disconnect();
+    this.mcpClients.clear();
+  }
+  /** Build the full tools array to send to the engine. Returns [] when no tools are available. */
+  async buildToolDefinitions() {
+    const defs = [];
+    if (this.toolsCfg.tavily?.apiKey) defs.push(WEB_SEARCH_TOOL);
+    defs.push(FETCH_URL_TOOL);
+    defs.push(RUN_CODE_TOOL);
+    for (const client of this.mcpClients.values()) {
+      try {
+        const mcpTools = await client.listTools();
+        for (const t of mcpTools) {
+          defs.push({
+            type: "function",
+            function: {
+              name: `mcp__${client.serverId.replace(/-/g, "_")}__${t.name}`,
+              description: `[${client.serverName}] ${t.description ?? ""}`,
+              parameters: t.inputSchema ?? { type: "object", properties: {} }
+            }
+          });
+        }
+      } catch {
+      }
+    }
+    return defs;
+  }
+  /** Execute a single tool call. Returns the result string. */
+  async executeTool(call) {
+    const name = call.name;
+    const args = call.args;
+    if (name === "web_search") {
+      const key = this.toolsCfg.tavily?.apiKey;
+      if (!key) return "Error: Tavily API key not configured. Add it in Settings \u2192 Tools.";
+      return execWebSearch(args, key);
+    }
+    if (name === "fetch_url") return execFetchUrl(args);
+    if (name === "run_code") return execRunCode(args);
+    const mcpMatch = name.match(/^mcp__([^_]+(?:_[^_]+)*)__(.+)$/);
+    if (mcpMatch) {
+      const rawServerId = mcpMatch[1].replace(/_/g, "-");
+      const toolName = mcpMatch[2];
+      let client = this.mcpClients.get(rawServerId);
+      if (!client) {
+        for (const [id, c] of this.mcpClients) {
+          if (id.replace(/-/g, "_") === mcpMatch[1]) {
+            client = c;
+            break;
+          }
+        }
+      }
+      if (!client) return `Error: MCP server "${rawServerId}" not connected.`;
+      return client.callTool(toolName, args);
+    }
+    return `Error: unknown tool "${name}"`;
+  }
+  /** Whether any tools are currently available (determines if tools should be sent to engine). */
+  hasTools() {
+    if (this.toolsCfg.tavily?.apiKey) return true;
+    if (this.mcpClients.size > 0) return true;
+    return true;
+  }
+};
+
+// src/cli-launch.ts
+import { spawn as spawn3 } from "child_process";
 var SUPPORTED = {
   claude: { bin: "claude", label: "Claude Code", install: "npm install -g @anthropic-ai/claude-code" }
 };
@@ -3897,7 +4414,7 @@ Open ${base2} \u2192 Models \u2192 Load a model, then run this again.
   const model = status.model.name;
   process.stdout.write(`\u25B8 Launching ${spec.label} \u2192 TurboLLM  (model: ${model}, ${base2})
 `);
-  const child = spawn2(spec.bin, passthrough, {
+  const child = spawn3(spec.bin, passthrough, {
     stdio: "inherit",
     // On Windows the CLI is usually a `.cmd`/`.ps1` shim; a shell resolves it via PATHEXT.
     shell: process.platform === "win32",
@@ -4781,7 +5298,14 @@ function registerApi(app2, d) {
       if (b.autoLoadOnStart !== void 0) cfg2.autoLoadOnStart = !!b.autoLoadOnStart;
       if (telemetryLevel !== void 0) cfg2.telemetry.level = telemetryLevel;
       if (b.hfToken !== void 0) cfg2.hf.token = String(b.hfToken).trim();
+      if (b.tavilyApiKey !== void 0) {
+        const key = String(b.tavilyApiKey).trim();
+        cfg2.tools.tavily = key ? { apiKey: key } : void 0;
+      }
     });
+    if (b.tavilyApiKey !== void 0) {
+      d.tools?.updateConfig(d.store.snapshot().tools);
+    }
     const after = d.store.snapshot().daemon;
     const lanChanged = after.lanBind !== before.lanBind;
     const portChanged = after.port !== before.port;
@@ -4793,6 +5317,59 @@ function registerApi(app2, d) {
     }
     return c.json({ ...settingsPayload(d), rebind });
   });
+  app2.post("/api/v1/mcp/servers", async (c) => {
+    const b = await body(c);
+    const transport = b.transport === "sse" ? "sse" : "stdio";
+    if (!b.name?.trim()) return err(c, 400, "invalid_config_value", "name is required.");
+    if (transport === "stdio" && !b.command?.trim()) return err(c, 400, "invalid_config_value", "command is required for stdio transport.");
+    if (transport === "sse" && !b.url?.trim()) return err(c, 400, "invalid_config_value", "url is required for sse transport.");
+    if (transport === "sse" && !/^https?:\/\//i.test(b.url ?? "")) return err(c, 400, "invalid_config_value", "url must be an http(s):// address.");
+    const { randomUUID: randomUUID8 } = await import("crypto");
+    const server2 = {
+      id: randomUUID8(),
+      name: b.name.trim(),
+      transport,
+      enabled: b.enabled !== false,
+      ...transport === "stdio" ? { command: b.command.trim(), args: b.args ?? [], env: b.env ?? {} } : { url: b.url.trim() }
+    };
+    d.store.update((cfg2) => {
+      cfg2.mcp.servers.push(server2);
+    });
+    if (server2.enabled) await d.tools?.syncMcpServers(d.store.snapshot().mcp.servers).catch(() => {
+    });
+    return c.json(server2, 201);
+  });
+  app2.put("/api/v1/mcp/servers/:id", async (c) => {
+    const id = c.req.param("id");
+    const b = await body(c);
+    const cfg2 = d.store.snapshot();
+    if (!cfg2.mcp.servers.some((s) => s.id === id)) return err(c, 404, "not_found", "MCP server not found.");
+    if (b.transport && b.transport !== "stdio" && b.transport !== "sse") return err(c, 400, "invalid_config_value", "transport must be stdio or sse.");
+    if (b.url && !/^https?:\/\//i.test(b.url)) return err(c, 400, "invalid_config_value", "url must be an http(s):// address.");
+    d.store.update((c2) => {
+      const s = c2.mcp.servers.find((x) => x.id === id);
+      if (b.name !== void 0) s.name = b.name.trim();
+      if (b.transport !== void 0) s.transport = b.transport;
+      if (b.enabled !== void 0) s.enabled = !!b.enabled;
+      if (b.command !== void 0) s.command = b.command;
+      if (b.args !== void 0) s.args = b.args;
+      if (b.env !== void 0) s.env = b.env;
+      if (b.url !== void 0) s.url = b.url;
+    });
+    await d.tools?.syncMcpServers(d.store.snapshot().mcp.servers).catch(() => {
+    });
+    return c.json(d.store.snapshot().mcp.servers.find((s) => s.id === id));
+  });
+  app2.delete("/api/v1/mcp/servers/:id", (c) => {
+    const id = c.req.param("id");
+    const cfg2 = d.store.snapshot();
+    if (!cfg2.mcp.servers.some((s) => s.id === id)) return err(c, 404, "not_found", "MCP server not found.");
+    d.store.update((c2) => {
+      c2.mcp.servers = c2.mcp.servers.filter((s) => s.id !== id);
+    });
+    void d.tools?.syncMcpServers(d.store.snapshot().mcp.servers);
+    return c.json({ ok: true });
+  });
   app2.get("/api/v1/telemetry/preview", (c) => {
     const raw = (c.req.query("level") ?? "").trim();
     const level = ["off", "anon", "full"].includes(raw) ? raw : "off";
@@ -5045,7 +5622,10 @@ function settingsPayload(d) {
     gateway: cfg2.gateway,
     // The HF token is write-only over the wire (spec 10 §4): we never echo it back,
     // only whether one is set, so the UI can show "configured" without leaking it.
-    hfTokenSet: cfg2.hf.token.length > 0
+    hfTokenSet: cfg2.hf.token.length > 0,
+    // Tavily API key is write-only: expose only whether it is set.
+    tavilyKeySet: !!cfg2.tools.tavily?.apiKey,
+    mcp: cfg2.mcp
   };
 }
 function telemetryPreview(level, version2) {
@@ -5326,7 +5906,7 @@ function registerChatRoutes(app2, d) {
   });
   app2.post("/api/v1/conversations", async (c) => {
     const b = await body2(c);
-    const conv = db2.createConversation({ title: b.title, systemPrompt: b.systemPrompt, modelKey: b.modelKey });
+    const conv = db2.createConversation({ title: b.title, systemPrompt: b.systemPrompt, modelKey: b.modelKey, toolPolicy: b.toolPolicy });
     return c.json(conv, 201);
   });
   app2.post("/api/v1/conversations/expert", async (c) => {
@@ -5466,7 +6046,7 @@ ${content}` : b.docContext : content;
 }
 async function runGeneration(d, stream, ctx) {
   const { db: db2 } = d;
-  const { convId, conv, engineMessages, assistantMsg, ms, target, ac, disableThinking } = ctx;
+  const { convId, conv, assistantMsg, ms, target, ac, disableThinking } = ctx;
   const convS = conv.sampling ?? {};
   const SAMPLING_KEYS = {
     temp: "temperature",
@@ -5484,179 +6064,247 @@ async function runGeneration(d, stream, ctx) {
   for (const [k, v] of Object.entries(convS)) {
     if (!(k in SAMPLING_KEYS) && k !== "stop") samplingOverride[k] = v;
   }
-  const reqBody = {
-    // mlx-lm / vLLM serve under a fixed alias and 404 on TurboLLM's internal key;
-    // llama.cpp ignores the field. engineModelAlias() returns the right value per kind.
-    model: engineModelAlias(d.registry.active()?.kind ?? "") ?? ms.model.key,
-    messages: engineMessages,
-    stream: true,
-    stream_options: { include_usage: true },
-    return_progress: true,
-    ...samplingOverride
-  };
   const stopStrings = convS.stop;
-  if (stopStrings?.length) reqBody.stop = stopStrings;
   const maxLimit = d.store.snapshot().modelDefaults.maxTokens ?? 0;
-  const cappedMax = clampMaxTokens(reqBody.max_tokens, maxLimit);
-  if (cappedMax != null) reqBody.max_tokens = cappedMax;
-  else delete reqBody.max_tokens;
-  if (disableThinking) {
-    reqBody.reasoning_budget = 0;
-    reqBody.chat_template_kwargs = { enable_thinking: false };
-  }
+  const iterMessages = ctx.engineMessages.map((m) => ({ role: m.role, content: m.content }));
+  const MAX_TOOL_ITER = 10;
+  let toolIter = 0;
+  let fullContent = "";
+  let fullReasoning = "";
+  const allToolCalls = [];
   const requestStart = Date.now();
   let ttftMs = 0;
-  let firstDelta = false;
   let thinkStart = 0;
   let thinkEnd = 0;
-  let fullContent = "";
-  let fullReasoning = "";
-  let inThink = false;
-  let pendingThinkBuf = "";
   let finalUsage = {};
   let finalTimings = {};
   let aborted = false;
   let liveOut = 0;
   d.manager.generationStart();
   try {
-    const res = await fetch(`${target}/v1/chat/completions`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(reqBody),
-      signal: ac.signal,
-      duplex: "half"
-    });
-    if (!res.ok || !res.body) {
-      await stream.writeSSE({ event: "error", data: JSON.stringify({ code: "engine_error", message: `Engine returned ${res.status}` }) });
-      return;
-    }
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let buf = "";
-    const cancelReader = () => void reader.cancel();
-    if (ac.signal.aborted) {
-      cancelReader();
-    } else {
-      ac.signal.addEventListener("abort", cancelReader, { once: true });
-    }
-    outer: while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buf += decoder.decode(value, { stream: true });
-      const lines = buf.split("\n");
-      buf = lines.pop() ?? "";
-      for (const line of lines) {
-        if (!line.startsWith("data: ")) continue;
-        const raw = line.slice(6).trim();
-        if (raw === "[DONE]") break outer;
-        let chunk;
-        try {
-          chunk = JSON.parse(raw);
-        } catch {
-          continue;
-        }
-        const pp = chunk.prompt_progress;
-        if (pp && pp.total) {
-          const pct = Math.round((pp.processed ?? 0) / pp.total * 100);
-          d.manager.setLiveGen({ phase: "prompt", pct, outputTokens: 0 });
-          await stream.writeSSE({ event: "progress", data: JSON.stringify({ phase: "prompt", processed: pp.processed, total: pp.total, pct, tps: pp.tps ?? 0 }) });
-          continue;
-        }
-        if (chunk.usage) finalUsage = chunk.usage;
-        if (chunk.timings) finalTimings = chunk.timings;
-        const choices = chunk.choices;
-        if (!choices?.length) continue;
-        const delta = choices[0].delta ?? {};
-        if (delta.reasoning_content) {
-          const rc = delta.reasoning_content;
-          if (!thinkStart) thinkStart = Date.now();
-          thinkEnd = Date.now();
-          fullReasoning += rc;
-          await stream.writeSSE({ event: "reasoning", data: JSON.stringify({ delta: rc }) });
-          continue;
-        }
-        const raw_content = delta.content ?? "";
-        if (!raw_content) continue;
-        let toProcess = raw_content;
-        while (toProcess.length > 0) {
-          if (!inThink && !firstDelta) {
-            pendingThinkBuf += toProcess;
-            const openIdx = pendingThinkBuf.indexOf("<think>");
-            if (openIdx === 0) {
-              inThink = true;
-              if (!thinkStart) thinkStart = Date.now();
-              pendingThinkBuf = pendingThinkBuf.slice(7);
-              toProcess = "";
-            } else if (openIdx > 0) {
-              const before = pendingThinkBuf.slice(0, openIdx);
-              fullContent += before;
-              firstDelta = true;
-              if (!ttftMs) {
-                ttftMs = Date.now() - requestStart;
-                firstDelta = true;
+    const toolDefs = d.tools ? await d.tools.buildToolDefinitions() : [];
+    outerLoop: while (toolIter <= MAX_TOOL_ITER) {
+      toolIter++;
+      const reqBody = {
+        model: engineModelAlias(d.registry.active()?.kind ?? "") ?? ms.model.key,
+        messages: iterMessages,
+        stream: true,
+        stream_options: { include_usage: true },
+        return_progress: true,
+        ...samplingOverride
+      };
+      if (stopStrings?.length) reqBody.stop = stopStrings;
+      const cappedMax = clampMaxTokens(reqBody.max_tokens, maxLimit);
+      if (cappedMax != null) reqBody.max_tokens = cappedMax;
+      else delete reqBody.max_tokens;
+      if (disableThinking) {
+        reqBody.reasoning_budget = 0;
+        reqBody.chat_template_kwargs = { enable_thinking: false };
+      }
+      if (toolDefs.length > 0) reqBody.tools = toolDefs;
+      if (conv.toolPolicy === "force_web_search" && toolIter <= 2 && toolDefs.some((t) => t.function.name === "web_search")) {
+        reqBody.tool_choice = { type: "function", function: { name: "web_search" } };
+      }
+      const res = await fetch(`${target}/v1/chat/completions`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(reqBody),
+        signal: ac.signal,
+        duplex: "half"
+      });
+      if (!res.ok || !res.body) {
+        await stream.writeSSE({ event: "error", data: JSON.stringify({ code: "engine_error", message: `Engine returned ${res.status}` }) });
+        return;
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buf = "";
+      const cancelReader = () => void reader.cancel();
+      if (ac.signal.aborted) {
+        cancelReader();
+      } else {
+        ac.signal.addEventListener("abort", cancelReader, { once: true });
+      }
+      let roundContent = "";
+      let inThink = false;
+      let pendingThinkBuf = "";
+      let firstDelta = false;
+      let finishReason = "";
+      const pendingToolCalls = /* @__PURE__ */ new Map();
+      roundLoop: while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buf += decoder.decode(value, { stream: true });
+        const lines = buf.split("\n");
+        buf = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const raw = line.slice(6).trim();
+          if (raw === "[DONE]") break roundLoop;
+          let chunk;
+          try {
+            chunk = JSON.parse(raw);
+          } catch {
+            continue;
+          }
+          const pp = chunk.prompt_progress;
+          if (pp && pp.total) {
+            const pct = Math.round((pp.processed ?? 0) / pp.total * 100);
+            d.manager.setLiveGen({ phase: "prompt", pct, outputTokens: 0 });
+            await stream.writeSSE({ event: "progress", data: JSON.stringify({ phase: "prompt", processed: pp.processed, total: pp.total, pct, tps: pp.tps ?? 0 }) });
+            continue;
+          }
+          if (chunk.usage) finalUsage = chunk.usage;
+          if (chunk.timings) finalTimings = chunk.timings;
+          const choices = chunk.choices;
+          if (!choices?.length) continue;
+          if (choices[0].finish_reason) finishReason = choices[0].finish_reason;
+          const delta = choices[0].delta ?? {};
+          if (delta.tool_calls?.length) {
+            for (const tc of delta.tool_calls) {
+              if (!pendingToolCalls.has(tc.index)) {
+                pendingToolCalls.set(tc.index, { id: "", name: "", argsBuffer: "" });
               }
-              await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: before }) });
-              inThink = true;
-              if (!thinkStart) thinkStart = Date.now();
-              pendingThinkBuf = pendingThinkBuf.slice(openIdx + 7);
-              toProcess = "";
-            } else if (pendingThinkBuf.length > 20) {
-              const flush = pendingThinkBuf;
-              pendingThinkBuf = "";
-              fullContent += flush;
-              firstDelta = true;
-              if (!ttftMs) ttftMs = Date.now() - requestStart;
-              await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: flush }) });
-              toProcess = "";
-            } else {
-              toProcess = "";
+              const entry = pendingToolCalls.get(tc.index);
+              if (tc.id && !entry.id) entry.id = tc.id;
+              if (tc.function?.name && !entry.name) entry.name = tc.function.name;
+              if (tc.function?.arguments) entry.argsBuffer += tc.function.arguments;
             }
-          } else if (inThink) {
-            pendingThinkBuf += toProcess;
-            const closeIdx = pendingThinkBuf.indexOf("</think>");
-            if (closeIdx >= 0) {
-              const thinkChunk = pendingThinkBuf.slice(0, closeIdx);
-              if (thinkChunk) {
-                thinkEnd = Date.now();
-                fullReasoning += thinkChunk;
-                await stream.writeSSE({ event: "reasoning", data: JSON.stringify({ delta: thinkChunk }) });
-              }
-              inThink = false;
-              thinkEnd = Date.now();
-              pendingThinkBuf = pendingThinkBuf.slice(closeIdx + 8);
-              toProcess = "";
-              if (pendingThinkBuf) {
-                fullContent += pendingThinkBuf;
+            continue;
+          }
+          if (delta.reasoning_content) {
+            const rc = delta.reasoning_content;
+            if (!thinkStart) thinkStart = Date.now();
+            thinkEnd = Date.now();
+            fullReasoning += rc;
+            await stream.writeSSE({ event: "reasoning", data: JSON.stringify({ delta: rc }) });
+            continue;
+          }
+          const raw_content = delta.content ?? "";
+          if (!raw_content) continue;
+          let toProcess = raw_content;
+          while (toProcess.length > 0) {
+            if (!inThink && !firstDelta) {
+              pendingThinkBuf += toProcess;
+              const openIdx = pendingThinkBuf.indexOf("<think>");
+              if (openIdx === 0) {
+                inThink = true;
+                if (!thinkStart) thinkStart = Date.now();
+                pendingThinkBuf = pendingThinkBuf.slice(7);
+                toProcess = "";
+              } else if (openIdx > 0) {
+                const before = pendingThinkBuf.slice(0, openIdx);
+                fullContent += before;
+                roundContent += before;
                 firstDelta = true;
                 if (!ttftMs) ttftMs = Date.now() - requestStart;
-                await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: pendingThinkBuf }) });
+                await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: before }) });
+                inThink = true;
+                if (!thinkStart) thinkStart = Date.now();
+                pendingThinkBuf = pendingThinkBuf.slice(openIdx + 7);
+                toProcess = "";
+              } else if (pendingThinkBuf.length > 20) {
+                const flush = pendingThinkBuf;
                 pendingThinkBuf = "";
+                fullContent += flush;
+                roundContent += flush;
+                firstDelta = true;
+                if (!ttftMs) ttftMs = Date.now() - requestStart;
+                await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: flush }) });
+                toProcess = "";
+              } else {
+                toProcess = "";
+              }
+            } else if (inThink) {
+              pendingThinkBuf += toProcess;
+              const closeIdx = pendingThinkBuf.indexOf("</think>");
+              if (closeIdx >= 0) {
+                const thinkChunk = pendingThinkBuf.slice(0, closeIdx);
+                if (thinkChunk) {
+                  thinkEnd = Date.now();
+                  fullReasoning += thinkChunk;
+                  await stream.writeSSE({ event: "reasoning", data: JSON.stringify({ delta: thinkChunk }) });
+                }
+                inThink = false;
+                thinkEnd = Date.now();
+                pendingThinkBuf = pendingThinkBuf.slice(closeIdx + 8);
+                toProcess = "";
+                if (pendingThinkBuf) {
+                  fullContent += pendingThinkBuf;
+                  roundContent += pendingThinkBuf;
+                  firstDelta = true;
+                  if (!ttftMs) ttftMs = Date.now() - requestStart;
+                  await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: pendingThinkBuf }) });
+                  pendingThinkBuf = "";
+                }
+              } else {
+                thinkEnd = Date.now();
+                fullReasoning += pendingThinkBuf;
+                await stream.writeSSE({ event: "reasoning", data: JSON.stringify({ delta: pendingThinkBuf }) });
+                pendingThinkBuf = "";
+                toProcess = "";
               }
             } else {
-              thinkEnd = Date.now();
-              fullReasoning += pendingThinkBuf;
-              await stream.writeSSE({ event: "reasoning", data: JSON.stringify({ delta: pendingThinkBuf }) });
-              pendingThinkBuf = "";
+              if (!ttftMs) ttftMs = Date.now() - requestStart;
+              firstDelta = true;
+              fullContent += toProcess;
+              roundContent += toProcess;
+              d.manager.setLiveGen({ phase: "gen", pct: 0, outputTokens: ++liveOut });
+              await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: toProcess }) });
               toProcess = "";
             }
-          } else {
-            if (!ttftMs) ttftMs = Date.now() - requestStart;
-            firstDelta = true;
-            fullContent += toProcess;
-            d.manager.setLiveGen({ phase: "gen", pct: 0, outputTokens: ++liveOut });
-            await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: toProcess }) });
-            toProcess = "";
           }
         }
       }
-    }
-    ac.signal.removeEventListener("abort", cancelReader);
-    if (pendingThinkBuf && inThink) {
-      fullReasoning += pendingThinkBuf;
-      await stream.writeSSE({ event: "reasoning", data: JSON.stringify({ delta: pendingThinkBuf }) });
-    } else if (pendingThinkBuf) {
-      fullContent += pendingThinkBuf;
-      await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: pendingThinkBuf }) });
+      ac.signal.removeEventListener("abort", cancelReader);
+      if (pendingThinkBuf && inThink) {
+        fullReasoning += pendingThinkBuf;
+        await stream.writeSSE({ event: "reasoning", data: JSON.stringify({ delta: pendingThinkBuf }) });
+      } else if (pendingThinkBuf) {
+        fullContent += pendingThinkBuf;
+        roundContent += pendingThinkBuf;
+        await stream.writeSSE({ event: "delta", data: JSON.stringify({ delta: pendingThinkBuf }) });
+      }
+      if ((finishReason === "tool_calls" || pendingToolCalls.size > 0) && d.tools && toolIter <= MAX_TOOL_ITER) {
+        const roundToolCalls = Array.from(pendingToolCalls.values());
+        iterMessages.push({
+          role: "assistant",
+          content: roundContent || null,
+          tool_calls: roundToolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: { name: tc.name, arguments: tc.argsBuffer }
+          }))
+        });
+        for (const tc of roundToolCalls) {
+          let parsedArgs;
+          try {
+            parsedArgs = JSON.parse(tc.argsBuffer || "{}");
+          } catch {
+            parsedArgs = {};
+          }
+          await stream.writeSSE({
+            event: "tool_call",
+            data: JSON.stringify({ id: tc.id, name: tc.name, args: parsedArgs, status: "pending" })
+          });
+          let result = "";
+          let callError;
+          try {
+            result = await d.tools.executeTool({ id: tc.id, name: tc.name, args: parsedArgs });
+          } catch (e) {
+            callError = e.message;
+            result = `Error: ${callError}`;
+          }
+          allToolCalls.push({ id: tc.id, name: tc.name, args: parsedArgs, result: callError ? void 0 : result, error: callError });
+          await stream.writeSSE({
+            event: "tool_call",
+            data: JSON.stringify({ id: tc.id, name: tc.name, args: parsedArgs, status: callError ? "error" : "done", result })
+          });
+          iterMessages.push({ role: "tool", content: result, tool_call_id: tc.id });
+        }
+        continue outerLoop;
+      }
+      break outerLoop;
     }
   } catch (e) {
     const isAbort = e?.name === "AbortError";
@@ -5698,7 +6346,7 @@ async function runGeneration(d, stream, ctx) {
     stats.tps = stats.genMs > 0 ? Math.round(stats.genTokens / stats.genMs * 1e3 * 10) / 10 : 0;
     stats.cachedTokens = cachedExplicit ?? 0;
   }
-  db2.updateMessage(assistantMsg.id, { content: fullContent, reasoning: fullReasoning, stats });
+  db2.updateMessage(assistantMsg.id, { content: fullContent, reasoning: fullReasoning, toolCalls: allToolCalls, stats });
   db2.touchConversation(convId);
   try {
     d.manager.recordCompletion({
@@ -5713,7 +6361,7 @@ async function runGeneration(d, stream, ctx) {
   await stream.writeSSE({ event: "done", data: JSON.stringify({ message: finalMsg }) });
   if (!aborted && conv.title === "New chat" && d.store.snapshot().daemon.autoGenerateTitles) {
     setTimeout(() => {
-      void autoTitle(d, convId, engineMessages, fullContent, target);
+      void autoTitle(d, convId, ctx.engineMessages, fullContent, target);
     }, 1e3);
   }
 }
@@ -6503,8 +7151,13 @@ var downloads = new DownloadManager(store, () => void scanner.rescan(), () => hf
 var bench = new BenchRunner(manager, store, scanner, registry, version);
 var comfy = new ComfyGuard(store, manager);
 var modelRouter = new ModelRouter(store, registry, manager, scanner, comfy);
+var toolRegistry = new ToolRegistry(store.snapshot().tools);
+void (async () => {
+  const cfg2 = store.snapshot();
+  await toolRegistry.syncMcpServers(cfg2.mcp.servers);
+})();
 var startedAt = Date.now();
-var deps = { store, registry, manager, scanner, hashes, db, provision, hf, downloads, bench, modelRouter, comfy, version, startedAt };
+var deps = { store, registry, manager, scanner, hashes, db, provision, hf, downloads, bench, modelRouter, comfy, tools: toolRegistry, version, startedAt };
 var app = createApp(deps);
 var cfg = store.snapshot();
 var defaultHost = cfg.daemon.lanBind ? "0.0.0.0" : cfg.daemon.host || "127.0.0.1";
@@ -6531,7 +7184,7 @@ function openBrowser(url) {
     cmd = "xdg-open";
     args = [url];
   }
-  const child = spawn3(cmd, args, { detached: true, stdio: "ignore" });
+  const child = spawn4(cmd, args, { detached: true, stdio: "ignore" });
   child.unref();
   child.on("error", () => {
     console.log(`  Could not open browser automatically. Visit the URL above manually.`);
@@ -6622,7 +7275,7 @@ function spawnReplacement() {
   } catch {
     out = "ignore";
   }
-  const child = spawn3(process.execPath, process.argv.slice(1), {
+  const child = spawn4(process.execPath, process.argv.slice(1), {
     cwd: process.cwd(),
     detached: true,
     stdio: ["ignore", out, out]
@@ -6715,6 +7368,7 @@ for (const sig of ["SIGINT", "SIGTERM"]) {
     shuttingDown = true;
     console.log("shutting down");
     comfy.stop();
+    toolRegistry.disconnectAll();
     void manager.shutdown().finally(() => {
       db.close();
       server.close(() => process.exit(0));