@trops/dash-core 0.1.47 → 0.1.49

package/dist/electron/index.js

@@ -22,6 +22,8 @@ var require$$2$4 = require('algoliasearch');
 var require$$3$2 = require('node:path');
 var require$$0$3 = require('openai');
 require('live-plugin-manager');
+var require$$0$5 = require('@anthropic-ai/sdk');
+var require$$0$4 = require('child_process');
 var require$$2$6 = require('os');
 var require$$3$3 = require('adm-zip');
 var require$$4$1 = require('url');
@@ -513,6 +515,40 @@ var openaiEvents$1 = {
   OPENAI_DESCRIBE_IMAGE_ERROR,
 };
 
+/**
+ * Event Constants File - LLM Events
+ *
+ * This file contains event constants for LLM (Large Language Model)
+ * chat IPC communication — streaming, tool-use, and lifecycle.
+ */
+
+// --- Renderer → Main (invoke) ---
+const LLM_SEND_MESSAGE$1 = "llm-send-message";
+const LLM_ABORT_REQUEST$1 = "llm-abort-request";
+const LLM_LIST_CONNECTED_TOOLS$1 = "llm-list-connected-tools";
+const LLM_CHECK_CLI_AVAILABLE$1 = "llm-check-cli-available";
+const LLM_CLEAR_CLI_SESSION$1 = "llm-clear-cli-session";
+
+// --- Main → Renderer (send) ---
+const LLM_STREAM_DELTA$3 = "llm-stream-delta";
+const LLM_STREAM_TOOL_CALL$3 = "llm-stream-tool-call";
+const LLM_STREAM_TOOL_RESULT$3 = "llm-stream-tool-result";
+const LLM_STREAM_COMPLETE$3 = "llm-stream-complete";
+const LLM_STREAM_ERROR$3 = "llm-stream-error";
+
+var llmEvents$1 = {
+  LLM_SEND_MESSAGE: LLM_SEND_MESSAGE$1,
+  LLM_ABORT_REQUEST: LLM_ABORT_REQUEST$1,
+  LLM_LIST_CONNECTED_TOOLS: LLM_LIST_CONNECTED_TOOLS$1,
+  LLM_CHECK_CLI_AVAILABLE: LLM_CHECK_CLI_AVAILABLE$1,
+  LLM_CLEAR_CLI_SESSION: LLM_CLEAR_CLI_SESSION$1,
+  LLM_STREAM_DELTA: LLM_STREAM_DELTA$3,
+  LLM_STREAM_TOOL_CALL: LLM_STREAM_TOOL_CALL$3,
+  LLM_STREAM_TOOL_RESULT: LLM_STREAM_TOOL_RESULT$3,
+  LLM_STREAM_COMPLETE: LLM_STREAM_COMPLETE$3,
+  LLM_STREAM_ERROR: LLM_STREAM_ERROR$3,
+};
+
 /**
  * Event Constants File - Client Cache Events
  *
@@ -550,6 +586,7 @@ const registryEvents = registryEvents$1;
 const algoliaEvents = algoliaEvents$1;
 const menuItemEvents = menuItemEvents$1;
 const openaiEvents = openaiEvents$1;
+const llmEvents = llmEvents$1;
 const clientCacheEvents = clientCacheEvents$1;
 
 const publicEvents = {
@@ -571,6 +608,7 @@ var events$8 = {
   ...algoliaEvents,
   ...menuItemEvents,
   ...openaiEvents,
+  ...llmEvents,
   ...clientCacheEvents,
 };
 
@@ -4776,28 +4814,28 @@ const fs$5 = require$$2;
 /**
  * Cached shell PATH result (resolved once, reused for all spawns).
  */
-let _shellPath = null;
+let _shellPath$1 = null;
 
 /**
  * Get the user's full shell PATH (including nvm, homebrew, volta, etc.).
  * Electron GUI apps on macOS don't inherit the shell PATH, so we
  * resolve it once by invoking a login shell.
  */
-function getShellPath() {
-  if (_shellPath !== null) return _shellPath;
+function getShellPath$1() {
+  if (_shellPath$1 !== null) return _shellPath$1;
 
   try {
     const { execSync } = require("child_process");
     const shell = process.env.SHELL || "/bin/bash";
-    _shellPath = execSync(`${shell} -ilc 'echo -n "$PATH"'`, {
+    _shellPath$1 = execSync(`${shell} -ilc 'echo -n "$PATH"'`, {
       encoding: "utf8",
       timeout: 5000,
     });
   } catch {
-    _shellPath = process.env.PATH || "";
+    _shellPath$1 = process.env.PATH || "";
   }
 
-  return _shellPath;
+  return _shellPath$1;
 }
 
 /**
@@ -4839,7 +4877,7 @@ function interpolate(template, credentials) {
   });
 }
 
-const mcpController$1 = {
+const mcpController$2 = {
   /**
    * startServer
    * Start an MCP server with the given config and credentials
@@ -4877,7 +4915,7 @@ const mcpController$1 = {
       try {
         // Stop if in stale/error state
         if (activeServers.has(serverName)) {
-          await mcpController$1.stopServer(win, serverName);
+          await mcpController$2.stopServer(win, serverName);
         }
 
         console.log(
@@ -4915,7 +4953,7 @@ const mcpController$1 = {
           const env = { ...process.env };
           // Ensure full shell PATH is available (Electron GUI apps
           // on macOS don't inherit nvm/homebrew paths)
-          env.PATH = getShellPath();
+          env.PATH = getShellPath$1();
           if (mcpConfig.envMapping && credentials) {
             Object.entries(mcpConfig.envMapping).forEach(
               ([envVar, credentialKey]) => {
@@ -5313,6 +5351,28 @@ const mcpController$1 = {
     }
   },
 
+  /**
+   * listConnectedServers
+   * Returns all connected servers with their cached tool lists.
+   * Used by llmController to discover available MCP tools.
+   *
+   * @returns {Array<{ serverName, tools, resources, status }>}
+   */
+  listConnectedServers: () => {
+    const servers = [];
+    for (const [serverName, server] of activeServers) {
+      if (server.status === STATUS.CONNECTED) {
+        servers.push({
+          serverName,
+          tools: server.tools || [],
+          resources: server.resources || [],
+          status: server.status,
+        });
+      }
+    }
+    return servers;
+  },
+
   /**
    * stopAllServers
    * Stop all running MCP servers (called on app quit)
@@ -5328,14 +5388,14 @@ const mcpController$1 = {
     );
     const promises = [];
     for (const [serverName] of activeServers) {
-      promises.push(mcpController$1.stopServer(null, serverName));
+      promises.push(mcpController$2.stopServer(null, serverName));
     }
     await Promise.allSettled(promises);
     console.log("[mcpController] All servers stopped");
   },
 };
 
-var mcpController_1 = mcpController$1;
+var mcpController_1 = mcpController$2;
 
 /**
  * registryController.js
@@ -6262,6 +6322,709 @@ const pluginController$1 = {
 
 var pluginController_1 = pluginController$1;
 
+/**
+ * cliController.js
+ *
+ * Manages Claude Code CLI (`claude -p`) as an alternative LLM backend.
+ * Spawns the CLI subprocess, parses stream-json NDJSON output, and emits
+ * the same LLM_STREAM_* events as the Anthropic SDK path.
+ *
+ * Users with a Claude Pro/Max subscription and Claude Code installed
+ * can use the Chat widget without a separate API key.
+ */
+
+const { spawn, execSync } = require$$0$4;
+const {
+  LLM_STREAM_DELTA: LLM_STREAM_DELTA$2,
+  LLM_STREAM_TOOL_CALL: LLM_STREAM_TOOL_CALL$2,
+  LLM_STREAM_TOOL_RESULT: LLM_STREAM_TOOL_RESULT$2,
+  LLM_STREAM_COMPLETE: LLM_STREAM_COMPLETE$2,
+  LLM_STREAM_ERROR: LLM_STREAM_ERROR$2,
+} = llmEvents$1;
+
+/**
+ * Cached shell PATH result (resolved once, reused for all spawns).
+ * Same pattern as mcpController.js.
+ */
+let _shellPath = null;
+
+function getShellPath() {
+  if (_shellPath !== null) return _shellPath;
+
+  try {
+    const shell = process.env.SHELL || "/bin/bash";
+    _shellPath = execSync(`${shell} -ilc 'echo -n "$PATH"'`, {
+      encoding: "utf8",
+      timeout: 5000,
+    });
+  } catch {
+    _shellPath = process.env.PATH || "";
+  }
+
+  return _shellPath;
+}
+
+/**
+ * Cached CLI binary path (resolved once via `which claude`).
+ */
+let _cliBinaryPath = undefined; // undefined = not yet checked
+
+function resolveCliBinary() {
+  if (_cliBinaryPath !== undefined) return _cliBinaryPath;
+
+  try {
+    const fullPath = getShellPath();
+    _cliBinaryPath = execSync("which claude", {
+      encoding: "utf8",
+      timeout: 5000,
+      env: { ...process.env, PATH: fullPath },
+    }).trim();
+  } catch {
+    _cliBinaryPath = null;
+  }
+
+  return _cliBinaryPath;
+}
+
+/**
+ * Active CLI processes for abort support.
+ * Map<requestId, ChildProcess>
+ */
+const activeProcesses = new Map();
+
+/**
+ * Session IDs for conversation continuity.
+ * Map<widgetUuid, sessionId>
+ */
+const sessions = new Map();
+
+/**
+ * Send events safely to a window.
+ */
+function safeSend(win, channel, data) {
+  if (win && !win.isDestroyed()) {
+    win.webContents.send(channel, data);
+  }
+}
+
+const cliController$2 = {
+  /**
+   * isAvailable
+   * Check if the Claude Code CLI is installed and accessible.
+   *
+   * @returns {{ available: boolean, path?: string }}
+   */
+  isAvailable: () => {
+    const binaryPath = resolveCliBinary();
+    if (binaryPath) {
+      return { available: true, path: binaryPath };
+    }
+    return { available: false };
+  },
+
+  /**
+   * sendMessage
+   * Stream a response from the Claude Code CLI with NDJSON parsing.
+   *
+   * @param {BrowserWindow} win - the window to send stream events to
+   * @param {string} requestId - unique ID for this request
+   * @param {object} params - { model, messages, systemPrompt, maxToolRounds, widgetUuid }
+   */
+  sendMessage: async (win, requestId, params) => {
+    const { model, messages, systemPrompt, widgetUuid } = params;
+
+    const binaryPath = resolveCliBinary();
+    if (!binaryPath) {
+      safeSend(win, LLM_STREAM_ERROR$2, {
+        requestId,
+        error:
+          "Claude Code CLI not found. Install from https://claude.ai/download",
+        code: "CLI_NOT_FOUND",
+      });
+      return;
+    }
+
+    // Build CLI args
+    const args = ["-p", "--output-format", "stream-json", "--verbose"];
+
+    if (model) {
+      args.push("--model", model);
+    }
+
+    if (systemPrompt) {
+      args.push("--append-system-prompt", systemPrompt);
+    }
+
+    // Resume existing session for conversation continuity
+    const sessionId = widgetUuid ? sessions.get(widgetUuid) : null;
+    if (sessionId) {
+      args.push("--resume", sessionId);
+    }
+
+    // Extract the user message (last user message in the array)
+    const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
+    const userText =
+      typeof lastUserMsg?.content === "string"
+        ? lastUserMsg.content
+        : Array.isArray(lastUserMsg?.content)
+          ? lastUserMsg.content
+              .filter((b) => b.type === "text")
+              .map((b) => b.text)
+              .join("\n")
+          : "";
+
+    if (!userText) {
+      safeSend(win, LLM_STREAM_ERROR$2, {
+        requestId,
+        error: "No user message to send.",
+        code: "CLI_ERROR",
+      });
+      return;
+    }
+
+    try {
+      const fullPath = getShellPath();
+      const child = spawn(binaryPath, args, {
+        env: { ...process.env, PATH: fullPath },
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+
+      activeProcesses.set(requestId, child);
+
+      // Pipe user message via stdin (not visible in ps)
+      child.stdin.write(userText);
+      child.stdin.end();
+
+      let stdoutBuffer = "";
+      let stderrBuffer = "";
+      let capturedSessionId = null;
+      let retried = false;
+
+      // Track active tool calls for mapping results
+      const activeToolCalls = new Map();
+
+      child.stdout.on("data", (chunk) => {
+        stdoutBuffer += chunk.toString();
+
+        // Process complete lines
+        const lines = stdoutBuffer.split("\n");
+        stdoutBuffer = lines.pop(); // keep incomplete line in buffer
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+
+          let parsed;
+          try {
+            parsed = JSON.parse(line);
+          } catch {
+            console.warn("[cliController] Skipping invalid JSON line:", line);
+            continue;
+          }
+
+          // Capture session ID from any message that has it
+          if (parsed.session_id && widgetUuid) {
+            capturedSessionId = parsed.session_id;
+            sessions.set(widgetUuid, capturedSessionId);
+          }
+
+          // Map CLI stream-json events to IPC events
+          if (parsed.type === "content_block_delta") {
+            if (parsed.delta?.type === "text_delta" && parsed.delta.text) {
+              safeSend(win, LLM_STREAM_DELTA$2, {
+                requestId,
+                text: parsed.delta.text,
+              });
+            } else if (parsed.delta?.type === "input_json_delta") {
+              // Update tool input incrementally
+              const tc = activeToolCalls.get(parsed.index);
+              if (tc) {
+                tc.partialInput =
+                  (tc.partialInput || "") + (parsed.delta.partial_json || "");
+              }
+            }
+          } else if (parsed.type === "content_block_start") {
+            if (parsed.content_block?.type === "tool_use") {
+              const toolBlock = parsed.content_block;
+              activeToolCalls.set(parsed.index, {
+                toolUseId: toolBlock.id,
+                toolName: toolBlock.name,
+                partialInput: "",
+              });
+              safeSend(win, LLM_STREAM_TOOL_CALL$2, {
+                requestId,
+                toolUseId: toolBlock.id,
+                toolName: toolBlock.name,
+                serverName: "Claude Code",
+                input: toolBlock.input || {},
+              });
+            }
+          } else if (parsed.type === "content_block_stop") {
+            // Tool call completed — try to parse the accumulated input
+            const tc = activeToolCalls.get(parsed.index);
+            if (tc && tc.partialInput) {
+              try {
+                tc.finalInput = JSON.parse(tc.partialInput);
+              } catch {
+                tc.finalInput = tc.partialInput;
+              }
+            }
+          } else if (parsed.type === "message_stop") {
+            // Individual message completed (may be followed by more in tool-use loops)
+          } else if (parsed.type === "result") {
+            // Final result — conversation complete
+            const content = [];
+            if (parsed.result) {
+              content.push({ type: "text", text: parsed.result });
+            }
+
+            safeSend(win, LLM_STREAM_COMPLETE$2, {
+              requestId,
+              content,
+              stopReason: parsed.stop_reason || "end_turn",
+              usage: parsed.usage || {},
+            });
+          }
+        }
+      });
+
+      child.stderr.on("data", (chunk) => {
+        stderrBuffer += chunk.toString();
+      });
+
+      child.on("error", (err) => {
+        activeProcesses.delete(requestId);
+        safeSend(win, LLM_STREAM_ERROR$2, {
+          requestId,
+          error: `Failed to start Claude CLI: ${err.message}`,
+          code: "CLI_SPAWN_ERROR",
+        });
+      });
+
+      child.on("close", (code) => {
+        activeProcesses.delete(requestId);
+
+        // Process any remaining buffer
+        if (stdoutBuffer.trim()) {
+          try {
+            const parsed = JSON.parse(stdoutBuffer);
+            if (parsed.session_id && widgetUuid) {
+              sessions.set(widgetUuid, parsed.session_id);
+            }
+            if (parsed.type === "result") {
+              const content = [];
+              if (parsed.result) {
+                content.push({ type: "text", text: parsed.result });
+              }
+              safeSend(win, LLM_STREAM_COMPLETE$2, {
+                requestId,
+                content,
+                stopReason: parsed.stop_reason || "end_turn",
+                usage: parsed.usage || {},
+              });
+              return;
+            }
+          } catch {
+            // ignore
+          }
+        }
+
+        if (code !== 0 && code !== null) {
+          // Check if resume failed and retry without it
+          if (sessionId && !retried && stderrBuffer.includes("session")) {
+            retried = true;
+            if (widgetUuid) sessions.delete(widgetUuid);
+            // Retry without --resume
+            cliController$2.sendMessage(win, requestId, {
+              ...params,
+              _retryWithoutResume: true,
+            });
+            return;
+          }
+
+          // Check for auth errors
+          if (
+            stderrBuffer.includes("auth") ||
+            stderrBuffer.includes("login") ||
+            stderrBuffer.includes("not authenticated")
+          ) {
+            safeSend(win, LLM_STREAM_ERROR$2, {
+              requestId,
+              error:
+                "Claude Code CLI is not authenticated. Run `claude auth login` in your terminal.",
+              code: "CLI_AUTH_ERROR",
+            });
+            return;
+          }
+
+          safeSend(win, LLM_STREAM_ERROR$2, {
+            requestId,
+            error: `Claude CLI exited with code ${code}${stderrBuffer ? ": " + stderrBuffer.slice(0, 500) : ""}`,
+            code: "CLI_ERROR",
+          });
+        }
+      });
+    } catch (err) {
+      activeProcesses.delete(requestId);
+      safeSend(win, LLM_STREAM_ERROR$2, {
+        requestId,
+        error: `Failed to start Claude CLI: ${err.message}`,
+        code: "CLI_SPAWN_ERROR",
+      });
+    }
+  },
+
+  /**
+   * abortRequest
+   * Kill an in-flight CLI process.
+   *
+   * @param {string} requestId - the request to cancel
+   * @returns {{ success: boolean }}
+   */
+  abortRequest: (requestId) => {
+    const child = activeProcesses.get(requestId);
+    if (child) {
+      child.kill("SIGTERM");
+      activeProcesses.delete(requestId);
+      return { success: true };
+    }
+    return { success: false, message: "Request not found" };
+  },
+
+  /**
+   * clearSession
+   * Remove the stored session ID for a widget (called on "New Chat").
+   *
+   * @param {string} widgetUuid - the widget whose session to clear
+   * @returns {{ success: boolean }}
+   */
+  clearSession: (widgetUuid) => {
+    if (widgetUuid && sessions.has(widgetUuid)) {
+      sessions.delete(widgetUuid);
+      return { success: true };
+    }
+    return { success: false };
+  },
+};
+
+var cliController_1 = cliController$2;
+
+/**
+ * llmController.js
+ *
+ * Manages LLM chat interactions in the main process.
+ * Streams responses from Anthropic's Messages API, handles tool-use loops
+ * by calling MCP tools via mcpController, and supports request cancellation.
+ *
+ * Conversation state lives in the renderer — this controller is stateless
+ * per-request, receiving the full messages array each time.
+ */
+
+const Anthropic = require$$0$5;
+const mcpController$1 = mcpController_1;
+const cliController$1 = cliController_1;
+const {
+  LLM_STREAM_DELTA: LLM_STREAM_DELTA$1,
+  LLM_STREAM_TOOL_CALL: LLM_STREAM_TOOL_CALL$1,
+  LLM_STREAM_TOOL_RESULT: LLM_STREAM_TOOL_RESULT$1,
+  LLM_STREAM_COMPLETE: LLM_STREAM_COMPLETE$1,
+  LLM_STREAM_ERROR: LLM_STREAM_ERROR$1,
+} = llmEvents$1;
+
+/**
+ * In-flight requests for cancellation support.
+ * Map<requestId, AbortController>
+ */
+const activeRequests = new Map();
+
+/**
+ * Default maximum tool-use rounds to prevent infinite loops.
+ */
+const DEFAULT_MAX_TOOL_ROUNDS = 10;
+
+/**
+ * Convert MCP tool format to Anthropic tool format.
+ * MCP: { name, description, inputSchema }
+ * Anthropic: { name, description, input_schema }
+ */
+function mcpToolToAnthropic(tool) {
+  return {
+    name: tool.name,
+    description: tool.description || "",
+    input_schema: tool.inputSchema || { type: "object", properties: {} },
+  };
+}
+
+/**
+ * Extract text content from an MCP tool result.
+ * MCP results can be { content: [{ type: "text", text: "..." }] } or plain strings.
+ */
+function extractToolResultText(mcpResult) {
+  if (!mcpResult) return "No result returned.";
+  if (mcpResult.error) return `Error: ${mcpResult.message}`;
+
+  const result = mcpResult.result;
+  if (!result) return "No result returned.";
+
+  // MCP standard: { content: [{ type, text }] }
+  if (result.content && Array.isArray(result.content)) {
+    return result.content
+      .filter((c) => c.type === "text")
+      .map((c) => c.text)
+      .join("\n");
+  }
+
+  // Plain string
+  if (typeof result === "string") return result;
+
+  // Fallback: JSON stringify
+  return JSON.stringify(result);
+}
+
+const llmController$1 = {
+  /**
+   * sendMessage
+   * Stream a response from the Anthropic Messages API with tool-use support.
+   *
+   * @param {BrowserWindow} win - the window to send stream events to
+   * @param {string} requestId - unique ID for this request (for filtering + cancellation)
+   * @param {object} params - { apiKey, model, messages, tools, toolServerMap, systemPrompt, maxToolRounds }
+   */
+  sendMessage: async (win, requestId, params) => {
+    // Route to CLI backend if specified
+    if (params.backend === "claude-code") {
+      return cliController$1.sendMessage(win, requestId, params);
+    }
+
+    const {
+      apiKey,
+      model = "claude-sonnet-4-20250514",
+      messages,
+      tools = [],
+      toolServerMap = {},
+      systemPrompt,
+      maxToolRounds = DEFAULT_MAX_TOOL_ROUNDS,
+    } = params;
+
+    // Set up abort controller
+    const abortController = new AbortController();
+    activeRequests.set(requestId, abortController);
+
+    try {
+      if (!apiKey) {
+        throw new Error(
+          "API key is required. Add an Anthropic provider in your dashboard settings.",
+        );
+      }
+
+      const client = new Anthropic({ apiKey });
+
+      // Convert MCP tools to Anthropic format
+      const anthropicTools = tools.map(mcpToolToAnthropic);
+
+      // Build the conversation — mutable copy for tool-use loop
+      let currentMessages = [...messages];
+      let toolRound = 0;
+
+      while (toolRound <= maxToolRounds) {
+        // Check for abort before each API call
+        if (abortController.signal.aborted) {
+          return;
+        }
+
+        // Build request params
+        const requestParams = {
+          model,
+          max_tokens: 8192,
+          messages: currentMessages,
+          stream: true,
+        };
+        if (systemPrompt) {
+          requestParams.system = systemPrompt;
+        }
+        if (anthropicTools.length > 0) {
+          requestParams.tools = anthropicTools;
+        }
+
+        // Stream the response
+        const stream = client.messages.stream(requestParams, {
+          signal: abortController.signal,
+        });
+
+        let responseContentBlocks = [];
+        let stopReason = null;
+
+        // Collect text deltas and content blocks
+        stream.on("text", (text) => {
+          if (win && !win.isDestroyed()) {
+            win.webContents.send(LLM_STREAM_DELTA$1, { requestId, text });
+          }
+        });
+
+        // Wait for the full message
+        const finalMessage = await stream.finalMessage();
+        responseContentBlocks = finalMessage.content;
+        stopReason = finalMessage.stop_reason;
+
+        // Check for tool use
+        const toolUseBlocks = responseContentBlocks.filter(
+          (block) => block.type === "tool_use",
+        );
+
+        if (stopReason === "end_turn" || toolUseBlocks.length === 0) {
+          // Done — send complete event
+          if (win && !win.isDestroyed()) {
+            win.webContents.send(LLM_STREAM_COMPLETE$1, {
+              requestId,
+              content: responseContentBlocks,
+              stopReason,
+              usage: finalMessage.usage,
+            });
+          }
+          return;
+        }
+
+        // Tool use round
+        toolRound++;
+
+        // Append assistant message with tool_use blocks
+        currentMessages.push({
+          role: "assistant",
+          content: responseContentBlocks,
+        });
+
+        // Execute each tool call
+        const toolResults = [];
+        for (const toolBlock of toolUseBlocks) {
+          if (abortController.signal.aborted) return;
+
+          const serverName = toolServerMap[toolBlock.name];
+
+          // Notify renderer of tool call
+          if (win && !win.isDestroyed()) {
+            win.webContents.send(LLM_STREAM_TOOL_CALL$1, {
+              requestId,
+              toolUseId: toolBlock.id,
+              toolName: toolBlock.name,
+              serverName,
+              input: toolBlock.input,
+            });
+          }
+
+          let resultText;
+          let isError = false;
+
+          if (!serverName) {
+            resultText = `Error: No MCP server found for tool "${toolBlock.name}". The server may have disconnected.`;
+            isError = true;
+          } else {
+            try {
+              const mcpResult = await mcpController$1.callTool(
+                win,
+                serverName,
+                toolBlock.name,
+                toolBlock.input,
+              );
+              if (mcpResult.error) {
+                resultText = `Error: ${mcpResult.message}`;
+                isError = true;
+              } else {
+                resultText = extractToolResultText(mcpResult);
+              }
+            } catch (err) {
+              resultText = `Error calling tool: ${err.message}`;
+              isError = true;
+            }
+          }
+
+          // Notify renderer of tool result
+          if (win && !win.isDestroyed()) {
+            win.webContents.send(LLM_STREAM_TOOL_RESULT$1, {
+              requestId,
+              toolUseId: toolBlock.id,
+              toolName: toolBlock.name,
+              result: resultText,
+              isError,
+            });
+          }
+
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: toolBlock.id,
+            content: resultText,
+            is_error: isError,
+          });
+        }
+
+        // Append tool results as user message
+        currentMessages.push({
+          role: "user",
+          content: toolResults,
+        });
+
+        // Loop continues — next API call with tool results
+      }
+
+      // Exceeded max tool rounds
+      if (win && !win.isDestroyed()) {
+        win.webContents.send(LLM_STREAM_ERROR$1, {
+          requestId,
+          error: `Exceeded maximum tool-use rounds (${maxToolRounds}). The assistant may be stuck in a loop.`,
+          code: "MAX_TOOL_ROUNDS",
+        });
+      }
+    } catch (error) {
+      if (abortController.signal.aborted) {
+        // Request was cancelled — not an error
+        return;
+      }
+
+      console.error(`[llmController] Error in sendMessage:`, error);
+
+      const errorPayload = {
+        requestId,
+        error: error.message || "Unknown error",
+        code: error.status || error.code || "UNKNOWN",
+      };
+
+      // Handle rate limiting
+      if (error.status === 429) {
+        errorPayload.code = "RATE_LIMITED";
+        const retryAfter = error.headers?.["retry-after"];
+        if (retryAfter) {
+          errorPayload.retryAfter = parseInt(retryAfter, 10);
+        }
+      }
+
+      if (win && !win.isDestroyed()) {
+        win.webContents.send(LLM_STREAM_ERROR$1, errorPayload);
+      }
+    } finally {
+      activeRequests.delete(requestId);
+    }
+  },
+
+  /**
+   * abortRequest
+   * Cancel an in-flight LLM request.
+   *
+   * @param {BrowserWindow} win - the window (unused but kept for API consistency)
+   * @param {string} requestId - the request to cancel
+   * @returns {{ success: boolean }}
+   */
+  abortRequest: (win, requestId) => {
+    const controller = activeRequests.get(requestId);
+    if (controller) {
+      controller.abort();
+      activeRequests.delete(requestId);
+      return { success: true };
+    }
+    // Fallback to CLI controller
+    return cliController$1.abortRequest(requestId);
+  },
+};
+
+var llmController_1 = llmController$1;
+
 /**
  * clientFactories.js
  *
@@ -6392,7 +7155,7 @@ var controller = {
   searchIndex,
 };
 
-const { ipcRenderer: ipcRenderer$g } = require$$0;
+const { ipcRenderer: ipcRenderer$h } = require$$0;
 const {
   SECURE_STORE_ENCRYPTION_CHECK,
   SECURE_STORE_SET_DATA,
@@ -6404,10 +7167,10 @@ const {
  */
 const secureStoreApi$2 = {
   isEncryptionAvailable: () =>
-    ipcRenderer$g.invoke(SECURE_STORE_ENCRYPTION_CHECK, {}),
+    ipcRenderer$h.invoke(SECURE_STORE_ENCRYPTION_CHECK, {}),
   saveData: (key, value) =>
-    ipcRenderer$g.invoke(SECURE_STORE_SET_DATA, { key, value }),
-  getData: (key) => ipcRenderer$g.invoke(SECURE_STORE_GET_DATA, { key }),
+    ipcRenderer$h.invoke(SECURE_STORE_SET_DATA, { key, value }),
+  getData: (key) => ipcRenderer$h.invoke(SECURE_STORE_GET_DATA, { key }),
 };
 
 var secureStoreApi_1 = secureStoreApi$2;
@@ -6418,7 +7181,7 @@ var secureStoreApi_1 = secureStoreApi$2;
  * Handle the workspace configuration file
  */
 
-const { ipcRenderer: ipcRenderer$f } = require$$0;
+const { ipcRenderer: ipcRenderer$g } = require$$0;
 const {
   WORKSPACE_LIST,
   WORKSPACE_SAVE,
@@ -6435,7 +7198,7 @@ const workspaceApi$2 = {
    */
   listWorkspacesForApplication: (appId) => {
     console.log("listWorkspacesForApplication called with appId:", appId);
-    return ipcRenderer$f.invoke(WORKSPACE_LIST, { appId });
+    return ipcRenderer$g.invoke(WORKSPACE_LIST, { appId });
   },
 
   /**
@@ -6446,7 +7209,7 @@ const workspaceApi$2 = {
    * @returns
    */
   saveWorkspaceForApplication: (appId, data) =>
-    ipcRenderer$f.invoke(WORKSPACE_SAVE, { appId, data }),
+    ipcRenderer$g.invoke(WORKSPACE_SAVE, { appId, data }),
 
   /**
    * deleteWorkspaceForApplication
@@ -6456,7 +7219,7 @@ const workspaceApi$2 = {
    * @returns
    */
   deleteWorkspaceForApplication: (appId, workspaceId) =>
-    ipcRenderer$f.invoke(WORKSPACE_DELETE, { appId, workspaceId }),
+    ipcRenderer$g.invoke(WORKSPACE_DELETE, { appId, workspaceId }),
 };
 
 var workspaceApi_1 = workspaceApi$2;
@@ -6468,15 +7231,15 @@ var workspaceApi_1 = workspaceApi$2;
  */
 
 // ipcRenderer that must be used to invoke the events
-const { ipcRenderer: ipcRenderer$e } = require$$0;
+const { ipcRenderer: ipcRenderer$f } = require$$0;
 
 const { LAYOUT_LIST, LAYOUT_SAVE } = events$8;
 
 const layoutApi$2 = {
   listLayoutsForApplication: (appId) =>
-    ipcRenderer$e.invoke(LAYOUT_LIST, { appId }),
+    ipcRenderer$f.invoke(LAYOUT_LIST, { appId }),
   saveLayoutForApplication: (appId, data) =>
-    ipcRenderer$e.invoke(LAYOUT_SAVE, { appId, data }),
+    ipcRenderer$f.invoke(LAYOUT_SAVE, { appId, data }),
 };
 
 var layoutApi_1 = layoutApi$2;
@@ -6488,7 +7251,7 @@ var layoutApi_1 = layoutApi$2;
  */
 
 // ipcRenderer that must be used to invoke the events
-const { ipcRenderer: ipcRenderer$d } = require$$0;
+const { ipcRenderer: ipcRenderer$e } = require$$0;
 
 const {
   DATA_JSON_TO_CSV_FILE,
@@ -6507,7 +7270,7 @@ const {
 const dataApi$2 = {
   // convert a json array of objects to a csv string and save to file
   convertJsonToCsvFile: (appId, jsonObject, filename) =>
-    ipcRenderer$d.invoke(DATA_JSON_TO_CSV_FILE, {
+    ipcRenderer$e.invoke(DATA_JSON_TO_CSV_FILE, {
       appId,
       jsonObject,
       filename,
@@ -6515,10 +7278,10 @@ const dataApi$2 = {
 
   // convert a json array of objects to a csv string and return a string
   convertJsonToCsvString: (appId, jsonObject) =>
-    ipcRenderer$d.invoke(DATA_JSON_TO_CSV_STRING, { appId, jsonObject }),
+    ipcRenderer$e.invoke(DATA_JSON_TO_CSV_STRING, { appId, jsonObject }),
 
   parseXMLStream: (filepath, outpath, start) =>
-    ipcRenderer$d.invoke(PARSE_XML_STREAM, {
+    ipcRenderer$e.invoke(PARSE_XML_STREAM, {
       filepath,
       outpath,
       start,
@@ -6532,7 +7295,7 @@ const dataApi$2 = {
     headers = null,
     limit = null,
   ) => {
-    ipcRenderer$d.invoke(PARSE_CSV_STREAM, {
+    ipcRenderer$e.invoke(PARSE_CSV_STREAM, {
       filepath,
       outpath,
       delimiter,
@@ -6543,15 +7306,15 @@ const dataApi$2 = {
   },
 
   readLinesFromFile: (filepath, lineCount) => {
-    ipcRenderer$d.invoke(READ_LINES, { filepath, lineCount });
+    ipcRenderer$e.invoke(READ_LINES, { filepath, lineCount });
   },
 
   readJSONFromFile: (filepath, objectCount = null) => {
-    ipcRenderer$d.invoke(READ_JSON, { filepath, objectCount });
+    ipcRenderer$e.invoke(READ_JSON, { filepath, objectCount });
   },
 
   readDataFromURL: (url, toFilepath) => {
-    ipcRenderer$d.invoke(READ_DATA_URL, { url, toFilepath });
+    ipcRenderer$e.invoke(READ_DATA_URL, { url, toFilepath });
   },
 
   /*
@@ -6560,7 +7323,7 @@ const dataApi$2 = {
    * @param {object} returnEmpty the return empty object
    */
   saveData: (data, filename, append, returnEmpty, uuid) =>
-    ipcRenderer$d.invoke(DATA_SAVE_TO_FILE, {
+    ipcRenderer$e.invoke(DATA_SAVE_TO_FILE, {
       data,
       filename,
       append,
@@ -6572,14 +7335,14 @@ const dataApi$2 = {
    * @param {string} filename the filename to read (not path)
    */
   readData: (filename, returnEmpty = []) =>
-    ipcRenderer$d.invoke(DATA_READ_FROM_FILE, { filename, returnEmpty }),
+    ipcRenderer$e.invoke(DATA_READ_FROM_FILE, { filename, returnEmpty }),
 
   /**
    * transformFile
    * @returns
    */
   transformFile: (filepath, outFilepath, mappingFunctionBody, args) => {
-    ipcRenderer$d.invoke(TRANSFORM_FILE, {
+    ipcRenderer$e.invoke(TRANSFORM_FILE, {
       filepath,
       outFilepath,
       mappingFunctionBody,
@@ -6588,7 +7351,7 @@ const dataApi$2 = {
   },
 
   extractColorsFromImageURL: (url) => {
-    ipcRenderer$d.invoke(EXTRACT_COLORS_FROM_IMAGE, {
+    ipcRenderer$e.invoke(EXTRACT_COLORS_FROM_IMAGE, {
       url,
     });
   },
@@ -6603,7 +7366,7 @@ var dataApi_1 = dataApi$2;
  */
 
 // ipcRenderer that must be used to invoke the events
-const { ipcRenderer: ipcRenderer$c } = require$$0;
+const { ipcRenderer: ipcRenderer$d } = require$$0;
 
 const {
   SETTINGS_GET,
@@ -6614,14 +7377,14 @@ const {
 } = events$8;
 
 const settingsApi$2 = {
-  getSettingsForApplication: () => ipcRenderer$c.invoke(SETTINGS_GET, {}),
+  getSettingsForApplication: () => ipcRenderer$d.invoke(SETTINGS_GET, {}),
   saveSettingsForApplication: (data) =>
-    ipcRenderer$c.invoke(SETTINGS_SAVE, { data }),
-  getDataDirectory: () => ipcRenderer$c.invoke(SETTINGS_GET_DATA_DIR, {}),
+    ipcRenderer$d.invoke(SETTINGS_SAVE, { data }),
+  getDataDirectory: () => ipcRenderer$d.invoke(SETTINGS_GET_DATA_DIR, {}),
   setDataDirectory: (dataDirectory) =>
-    ipcRenderer$c.invoke(SETTINGS_SET_DATA_DIR, { dataDirectory }),
+    ipcRenderer$d.invoke(SETTINGS_SET_DATA_DIR, { dataDirectory }),
   migrateDataDirectory: (oldDirectory, newDirectory) =>
-    ipcRenderer$c.invoke(SETTINGS_MIGRATE_DATA_DIR, {
+    ipcRenderer$d.invoke(SETTINGS_MIGRATE_DATA_DIR, {
       oldDirectory,
       newDirectory,
     }),
@@ -6636,7 +7399,7 @@ var settingsApi_1 = settingsApi$2;
  */
 
 // ipcRenderer that must be used to invoke the events
-const { ipcRenderer: ipcRenderer$b } = require$$0;
+const { ipcRenderer: ipcRenderer$c } = require$$0;
 
 const { CHOOSE_FILE } = events$8;
 
@@ -6648,7 +7411,7 @@ const dialogApi$2 = {
    */
   chooseFile: (allowFile = true, extensions = ["*"]) => {
     console.log("dialog api choose file");
-    return ipcRenderer$b.invoke(CHOOSE_FILE, { allowFile, extensions });
+    return ipcRenderer$c.invoke(CHOOSE_FILE, { allowFile, extensions });
   },
 };
 
@@ -6667,7 +7430,7 @@ var dialogApi_1 = dialogApi$2;
  * mainApi.widgets.uninstall('Weather')
  */
 
-const { ipcRenderer: ipcRenderer$a } = require$$0;
+const { ipcRenderer: ipcRenderer$b } = require$$0;
 
 const widgetApi$2 = {
   /**
@@ -6676,7 +7439,7 @@ const widgetApi$2 = {
    */
   list: async () => {
     try {
-      return await ipcRenderer$a.invoke("widget:list");
+      return await ipcRenderer$b.invoke("widget:list");
     } catch (error) {
       console.error("[WidgetApi] Error listing widgets:", error);
       throw error;
@@ -6690,7 +7453,7 @@ const widgetApi$2 = {
    */
   get: async (widgetName) => {
     try {
-      return await ipcRenderer$a.invoke("widget:get", widgetName);
+      return await ipcRenderer$b.invoke("widget:get", widgetName);
     } catch (error) {
       console.error(`[WidgetApi] Error getting widget ${widgetName}:`, error);
       throw error;
@@ -6721,7 +7484,7 @@ const widgetApi$2 = {
       console.log(
         `[WidgetApi] Installing widget: ${widgetName} from ${downloadUrl}`,
       );
-      const config = await ipcRenderer$a.invoke(
+      const config = await ipcRenderer$b.invoke(
         "widget:install",
         widgetName,
         downloadUrl,
@@ -6761,7 +7524,7 @@ const widgetApi$2 = {
       console.log(
         `[WidgetApi] Installing local widget: ${widgetName} from ${localPath}`,
       );
-      const config = await ipcRenderer$a.invoke(
+      const config = await ipcRenderer$b.invoke(
         "widget:install-local",
         widgetName,
         localPath,
@@ -6792,7 +7555,7 @@ const widgetApi$2 = {
   loadFolder: async (folderPath) => {
     try {
       console.log(`[WidgetApi] Loading widgets from folder: ${folderPath}`);
-      const results = await ipcRenderer$a.invoke(
+      const results = await ipcRenderer$b.invoke(
         "widget:load-folder",
         folderPath,
       );
@@ -6816,7 +7579,7 @@ const widgetApi$2 = {
   uninstall: async (widgetName) => {
     try {
       console.log(`[WidgetApi] Uninstalling widget: ${widgetName}`);
-      const success = await ipcRenderer$a.invoke("widget:uninstall", widgetName);
+      const success = await ipcRenderer$b.invoke("widget:uninstall", widgetName);
       if (success) {
         console.log(`[WidgetApi] ✓ Widget ${widgetName} uninstalled`);
       } else {
@@ -6839,7 +7602,7 @@ const widgetApi$2 = {
    */
   getCachePath: async () => {
     try {
-      return await ipcRenderer$a.invoke("widget:cache-path");
+      return await ipcRenderer$b.invoke("widget:cache-path");
     } catch (error) {
       console.error("[WidgetApi] Error getting cache path:", error);
       throw error;
@@ -6853,7 +7616,7 @@ const widgetApi$2 = {
    */
   getStoragePath: async () => {
     try {
-      return await ipcRenderer$a.invoke("widget:storage-path");
+      return await ipcRenderer$b.invoke("widget:storage-path");
     } catch (error) {
       console.error("[WidgetApi] Error getting storage path:", error);
       throw error;
@@ -6870,7 +7633,7 @@ const widgetApi$2 = {
   setStoragePath: async (customPath) => {
     try {
       console.log(`[WidgetApi] Setting storage path to: ${customPath}`);
-      const result = await ipcRenderer$a.invoke(
+      const result = await ipcRenderer$b.invoke(
         "widget:set-storage-path",
         customPath,
       );
@@ -6892,7 +7655,7 @@ const widgetApi$2 = {
    */
   getComponentConfigs: async () => {
     try {
-      return await ipcRenderer$a.invoke("widget:get-component-configs");
+      return await ipcRenderer$b.invoke("widget:get-component-configs");
     } catch (error) {
       console.error("[WidgetApi] Error getting component configs:", error);
       return [];
@@ -6907,7 +7670,7 @@ const widgetApi$2 = {
    */
   readBundle: async (widgetName) => {
     try {
-      return await ipcRenderer$a.invoke("widget:read-bundle", widgetName);
+      return await ipcRenderer$b.invoke("widget:read-bundle", widgetName);
     } catch (error) {
       console.error(
         `[WidgetApi] Error reading bundle for ${widgetName}:`,
@@ -6924,7 +7687,7 @@ const widgetApi$2 = {
    */
   readAllBundles: async () => {
     try {
-      return await ipcRenderer$a.invoke("widget:read-all-bundles");
+      return await ipcRenderer$b.invoke("widget:read-all-bundles");
     } catch (error) {
       console.error("[WidgetApi] Error reading all bundles:", error);
       return [];
@@ -6944,7 +7707,7 @@ const widgetApi$2 = {
    * });
    */
   onInstalled: (callback) => {
-    ipcRenderer$a.on("widget:installed", (event, data) => {
+    ipcRenderer$b.on("widget:installed", (event, data) => {
       callback(data);
     });
   },
@@ -6962,7 +7725,7 @@ const widgetApi$2 = {
    * });
    */
   onLoaded: (callback) => {
-    ipcRenderer$a.on("widgets:loaded", (event, data) => {
+    ipcRenderer$b.on("widgets:loaded", (event, data) => {
       callback(data);
     });
   },
@@ -6973,7 +7736,7 @@ const widgetApi$2 = {
    * @param {Function} callback - The callback to remove
    */
   removeInstalledListener: (callback) => {
-    ipcRenderer$a.removeListener("widget:installed", callback);
+    ipcRenderer$b.removeListener("widget:installed", callback);
   },
 
   /**
@@ -6982,7 +7745,7 @@ const widgetApi$2 = {
    * @param {Function} callback - The callback to remove
    */
   removeLoadedListener: (callback) => {
-    ipcRenderer$a.removeListener("widgets:loaded", callback);
+    ipcRenderer$b.removeListener("widgets:loaded", callback);
   },
 };
 
@@ -6995,7 +7758,7 @@ var widgetApi_1 = widgetApi$2;
  * Communicates with main process via IPC to handle encryption and file storage
  */
 
-const { ipcRenderer: ipcRenderer$9 } = require$$0;
+const { ipcRenderer: ipcRenderer$a } = require$$0;
 const {
   PROVIDER_SAVE,
   PROVIDER_LIST,
@@ -7025,7 +7788,7 @@ const providerApi$2 = {
     providerClass = "credential",
     mcpConfig = null,
   ) =>
-    ipcRenderer$9.invoke(PROVIDER_SAVE, {
+    ipcRenderer$a.invoke(PROVIDER_SAVE, {
       appId,
       providerName,
       providerType,
@@ -7042,7 +7805,7 @@ const providerApi$2 = {
    * @param {String} appId - the appId specified in the dash initialization
    * @returns {Promise<Array>} Array of provider objects with name, type, credentials
    */
-  listProviders: (appId) => ipcRenderer$9.invoke(PROVIDER_LIST, { appId }),
+  listProviders: (appId) => ipcRenderer$a.invoke(PROVIDER_LIST, { appId }),
 
   /**
    * getProvider
@@ -7054,7 +7817,7 @@ const providerApi$2 = {
    * @returns {Promise<Object>} Provider object with name, type, credentials
    */
   getProvider: (appId, providerName) =>
-    ipcRenderer$9.invoke(PROVIDER_GET, { appId, providerName }),
+    ipcRenderer$a.invoke(PROVIDER_GET, { appId, providerName }),
 
   /**
    * deleteProvider
@@ -7066,7 +7829,7 @@ const providerApi$2 = {
    * @returns {Promise}
    */
   deleteProvider: (appId, providerName) =>
-    ipcRenderer$9.invoke(PROVIDER_DELETE, { appId, providerName }),
+    ipcRenderer$a.invoke(PROVIDER_DELETE, { appId, providerName }),
 
   /**
    * listProvidersForApplication
@@ -7076,14 +7839,14 @@ const providerApi$2 = {
    * @param {String} appId - the appId specified in the dash initialization
    */
   listProvidersForApplication: (appId) => {
-    ipcRenderer$9
+    ipcRenderer$a
       .invoke(PROVIDER_LIST, { appId })
       .then((result) => {
         // Emit the event for ElectronDashboardApi to listen to
-        ipcRenderer$9.send("PROVIDER_LIST_COMPLETE", result);
+        ipcRenderer$a.send("PROVIDER_LIST_COMPLETE", result);
       })
       .catch((error) => {
-        ipcRenderer$9.send("PROVIDER_LIST_ERROR", {
+        ipcRenderer$a.send("PROVIDER_LIST_ERROR", {
           error: error.message,
         });
       });
@@ -7100,7 +7863,7 @@ const providerApi$2 = {
     providerType,
     credentials,
   ) => {
-    ipcRenderer$9
+    ipcRenderer$a
       .invoke(PROVIDER_SAVE, {
         appId,
         providerName,
@@ -7108,10 +7871,10 @@ const providerApi$2 = {
         credentials,
       })
       .then((result) => {
-        ipcRenderer$9.send("PROVIDER_SAVE_COMPLETE", result);
+        ipcRenderer$a.send("PROVIDER_SAVE_COMPLETE", result);
       })
       .catch((error) => {
-        ipcRenderer$9.send("PROVIDER_SAVE_ERROR", {
+        ipcRenderer$a.send("PROVIDER_SAVE_ERROR", {
           error: error.message,
         });
       });
@@ -7123,13 +7886,13 @@ const providerApi$2 = {
    * Event-listener-based version for use with ElectronDashboardApi
    */
   getProviderForApplication: (appId, providerName) => {
-    ipcRenderer$9
+    ipcRenderer$a
       .invoke(PROVIDER_GET, { appId, providerName })
       .then((result) => {
-        ipcRenderer$9.send("PROVIDER_GET_COMPLETE", result);
+        ipcRenderer$a.send("PROVIDER_GET_COMPLETE", result);
       })
       .catch((error) => {
-        ipcRenderer$9.send("PROVIDER_GET_ERROR", {
+        ipcRenderer$a.send("PROVIDER_GET_ERROR", {
           error: error.message,
         });
       });
@@ -7141,13 +7904,13 @@ const providerApi$2 = {
    * Event-listener-based version for use with ElectronDashboardApi
    */
   deleteProviderForApplication: (appId, providerName) => {
-    ipcRenderer$9
+    ipcRenderer$a
       .invoke(PROVIDER_DELETE, { appId, providerName })
       .then((result) => {
-        ipcRenderer$9.send("PROVIDER_DELETE_COMPLETE", result);
+        ipcRenderer$a.send("PROVIDER_DELETE_COMPLETE", result);
       })
       .catch((error) => {
-        ipcRenderer$9.send("PROVIDER_DELETE_ERROR", {
+        ipcRenderer$a.send("PROVIDER_DELETE_ERROR", {
           error: error.message,
         });
       });
@@ -7163,7 +7926,7 @@ var providerApi_1 = providerApi$2;
  * Communicates with main process via IPC to manage MCP server lifecycle.
  */
 
-const { ipcRenderer: ipcRenderer$8 } = require$$0;
+const { ipcRenderer: ipcRenderer$9 } = require$$0;
 const {
   MCP_START_SERVER,
   MCP_STOP_SERVER,
@@ -7186,7 +7949,7 @@ const mcpApi$2 = {
    * @returns {Promise<{ success, serverName, tools, status } | { error, message }>}
    */
   startServer: (serverName, mcpConfig, credentials) =>
-    ipcRenderer$8.invoke(MCP_START_SERVER, {
+    ipcRenderer$9.invoke(MCP_START_SERVER, {
       serverName,
       mcpConfig,
       credentials,
@@ -7200,7 +7963,7 @@ const mcpApi$2 = {
    * @returns {Promise<{ success, serverName } | { error, message }>}
    */
   stopServer: (serverName) =>
-    ipcRenderer$8.invoke(MCP_STOP_SERVER, { serverName }),
+    ipcRenderer$9.invoke(MCP_STOP_SERVER, { serverName }),
 
   /**
    * listTools
@@ -7209,7 +7972,7 @@ const mcpApi$2 = {
    * @param {string} serverName the server name
    * @returns {Promise<{ tools } | { error, message }>}
    */
-  listTools: (serverName) => ipcRenderer$8.invoke(MCP_LIST_TOOLS, { serverName }),
+  listTools: (serverName) => ipcRenderer$9.invoke(MCP_LIST_TOOLS, { serverName }),
 
   /**
    * callTool
@@ -7222,7 +7985,7 @@ const mcpApi$2 = {
    * @returns {Promise<{ result } | { error, message }>}
    */
   callTool: (serverName, toolName, args, allowedTools = null) =>
-    ipcRenderer$8.invoke(MCP_CALL_TOOL, {
+    ipcRenderer$9.invoke(MCP_CALL_TOOL, {
       serverName,
       toolName,
       args,
@@ -7237,7 +8000,7 @@ const mcpApi$2 = {
    * @returns {Promise<{ resources } | { error, message }>}
    */
   listResources: (serverName) =>
-    ipcRenderer$8.invoke(MCP_LIST_RESOURCES, { serverName }),
+    ipcRenderer$9.invoke(MCP_LIST_RESOURCES, { serverName }),
 
   /**
    * readResource
@@ -7248,7 +8011,7 @@ const mcpApi$2 = {
    * @returns {Promise<{ resource } | { error, message }>}
    */
   readResource: (serverName, uri) =>
-    ipcRenderer$8.invoke(MCP_READ_RESOURCE, { serverName, uri }),
+    ipcRenderer$9.invoke(MCP_READ_RESOURCE, { serverName, uri }),
 
   /**
    * getServerStatus
@@ -7258,7 +8021,7 @@ const mcpApi$2 = {
    * @returns {Promise<{ status, tools, error }>}
    */
   getServerStatus: (serverName) =>
-    ipcRenderer$8.invoke(MCP_SERVER_STATUS, { serverName }),
+    ipcRenderer$9.invoke(MCP_SERVER_STATUS, { serverName }),
 
   /**
    * getCatalog
@@ -7266,7 +8029,7 @@ const mcpApi$2 = {
    *
    * @returns {Promise<{ catalog } | { error, message }>}
    */
-  getCatalog: () => ipcRenderer$8.invoke(MCP_GET_CATALOG),
+  getCatalog: () => ipcRenderer$9.invoke(MCP_GET_CATALOG),
 };
 
 var mcpApi_1 = mcpApi$2;
@@ -7284,7 +8047,7 @@ var mcpApi_1 = mcpApi$2;
  * mainApi.registry.checkUpdates([{ name: "weather-widgets", version: "1.0.0" }])
  */
 
-const { ipcRenderer: ipcRenderer$7 } = require$$0;
+const { ipcRenderer: ipcRenderer$8 } = require$$0;
 
 const registryApi$2 = {
   /**
@@ -7294,7 +8057,7 @@ const registryApi$2 = {
    */
   fetchIndex: async (forceRefresh = false) => {
     try {
-      return await ipcRenderer$7.invoke("registry:fetch-index", forceRefresh);
+      return await ipcRenderer$8.invoke("registry:fetch-index", forceRefresh);
     } catch (error) {
       console.error("[RegistryApi] Error fetching index:", error);
       throw error;
@@ -7309,7 +8072,7 @@ const registryApi$2 = {
    */
   search: async (query = "", filters = {}) => {
     try {
-      return await ipcRenderer$7.invoke("registry:search", query, filters);
+      return await ipcRenderer$8.invoke("registry:search", query, filters);
     } catch (error) {
       console.error("[RegistryApi] Error searching registry:", error);
       throw error;
@@ -7323,7 +8086,7 @@ const registryApi$2 = {
    */
   getPackage: async (packageName) => {
     try {
-      return await ipcRenderer$7.invoke("registry:get-package", packageName);
+      return await ipcRenderer$8.invoke("registry:get-package", packageName);
     } catch (error) {
       console.error(
         `[RegistryApi] Error getting package ${packageName}:`,
@@ -7340,7 +8103,7 @@ const registryApi$2 = {
    */
   checkUpdates: async (installedWidgets = []) => {
     try {
-      return await ipcRenderer$7.invoke(
+      return await ipcRenderer$8.invoke(
         "registry:check-updates",
         installedWidgets,
       );
@@ -7359,17 +8122,17 @@ var registryApi_1 = registryApi$2;
  * Handle the theme configuration file
  */
 
-const { ipcRenderer: ipcRenderer$6 } = require$$0;
+const { ipcRenderer: ipcRenderer$7 } = require$$0;
 
 const { THEME_LIST, THEME_SAVE, THEME_DELETE } = events$8;
 
 const themeApi$2 = {
   listThemesForApplication: (appId) =>
-    ipcRenderer$6.invoke(THEME_LIST, { appId }),
+    ipcRenderer$7.invoke(THEME_LIST, { appId }),
   saveThemeForApplication: (appId, themeName, themeObject) =>
-    ipcRenderer$6.invoke(THEME_SAVE, { appId, themeName, themeObject }),
+    ipcRenderer$7.invoke(THEME_SAVE, { appId, themeName, themeObject }),
   deleteThemeForApplication: (appId, themeKey) =>
-    ipcRenderer$6.invoke(THEME_DELETE, { appId, themeKey }),
+    ipcRenderer$7.invoke(THEME_DELETE, { appId, themeKey }),
 };
 
 var themeApi_1 = themeApi$2;
@@ -7381,7 +8144,7 @@ var themeApi_1 = themeApi$2;
  */
 
 // ipcRenderer that must be used to invoke the events
-const { ipcRenderer: ipcRenderer$5 } = require$$0;
+const { ipcRenderer: ipcRenderer$6 } = require$$0;
 
 const {
   ALGOLIA_LIST_INDICES,
@@ -7395,10 +8158,10 @@ const {
 
 const algoliaApi$2 = {
   listIndices: (application) =>
-    ipcRenderer$5.invoke(ALGOLIA_LIST_INDICES, application),
+    ipcRenderer$6.invoke(ALGOLIA_LIST_INDICES, application),
 
   browseObjects: (appId, apiKey, indexName) => {
-    ipcRenderer$5.invoke(ALGOLIA_BROWSE_OBJECTS, {
+    ipcRenderer$6.invoke(ALGOLIA_BROWSE_OBJECTS, {
       appId,
       apiKey,
       indexName,
@@ -7406,10 +8169,10 @@ const algoliaApi$2 = {
     });
   },
 
-  saveSynonyms: () => ipcRenderer$5.invoke(ALGOLIA_SAVE_SYNONYMS, {}),
+  saveSynonyms: () => ipcRenderer$6.invoke(ALGOLIA_SAVE_SYNONYMS, {}),
 
   getAnalyticsForQuery: (application, indexName, query) =>
-    ipcRenderer$5.invoke(ALGOLIA_ANALYTICS_FOR_QUERY, {
+    ipcRenderer$6.invoke(ALGOLIA_ANALYTICS_FOR_QUERY, {
       application,
       indexName,
       query,
@@ -7422,7 +8185,7 @@ const algoliaApi$2 = {
     dir,
     createIfNotExists = false,
   ) =>
-    ipcRenderer$5.invoke(ALGOLIA_PARTIAL_UPDATE_OBJECTS, {
+    ipcRenderer$6.invoke(ALGOLIA_PARTIAL_UPDATE_OBJECTS, {
       appId,
       apiKey,
       indexName,
@@ -7431,7 +8194,7 @@ const algoliaApi$2 = {
     }),
 
   createBatchesFromFile: (filepath, batchFilepath, batchSize) => {
-    ipcRenderer$5.invoke(ALGOLIA_CREATE_BATCH, {
+    ipcRenderer$6.invoke(ALGOLIA_CREATE_BATCH, {
       filepath,
       batchFilepath,
       batchSize,
@@ -7439,7 +8202,7 @@ const algoliaApi$2 = {
   },
 
   browseObjectsToFile: (appId, apiKey, indexName, toFilename, query = "") => {
-    ipcRenderer$5.invoke(ALGOLIA_BROWSE_OBJECTS, {
+    ipcRenderer$6.invoke(ALGOLIA_BROWSE_OBJECTS, {
       appId,
       apiKey,
       indexName,
@@ -7449,7 +8212,7 @@ const algoliaApi$2 = {
   },
 
   search: (appId, apiKey, indexName, query = "", options = {}) =>
-    ipcRenderer$5.invoke(ALGOLIA_SEARCH, {
+    ipcRenderer$6.invoke(ALGOLIA_SEARCH, {
       appId,
       apiKey,
       indexName,
@@ -7464,14 +8227,14 @@ var algoliaApi_1 = algoliaApi$2;
  * openAI
  */
 
-const { ipcRenderer: ipcRenderer$4 } = require$$0;
+const { ipcRenderer: ipcRenderer$5 } = require$$0;
 
 const { OPENAI_DESCRIBE_IMAGE } = openaiEvents$1;
 
 const openaiApi$2 = {
   // convert a json array of objects to a csv string and save to file
   describeImage: (imageUrl, apiKey, prompt = "What's in this image?") =>
-    ipcRenderer$4.invoke(OPENAI_DESCRIBE_IMAGE, { imageUrl, apiKey, prompt }),
+    ipcRenderer$5.invoke(OPENAI_DESCRIBE_IMAGE, { imageUrl, apiKey, prompt }),
 };
 
 var openaiApi_1 = openaiApi$2;
@@ -7482,14 +8245,14 @@ var openaiApi_1 = openaiApi$2;
  */
 
 // ipcRenderer that must be used to invoke the events
-const { ipcRenderer: ipcRenderer$3 } = require$$0;
+const { ipcRenderer: ipcRenderer$4 } = require$$0;
 
 const { MENU_ITEMS_SAVE, MENU_ITEMS_LIST } = events$8;
 
 const menuItemsApi$2 = {
   saveMenuItem: (appId, menuItem) =>
-    ipcRenderer$3.invoke(MENU_ITEMS_SAVE, { appId, menuItem }),
-  listMenuItems: (appId) => ipcRenderer$3.invoke(MENU_ITEMS_LIST, { appId }),
+    ipcRenderer$4.invoke(MENU_ITEMS_SAVE, { appId, menuItem }),
+  listMenuItems: (appId) => ipcRenderer$4.invoke(MENU_ITEMS_LIST, { appId }),
 };
 
 var menuItemsApi_1 = menuItemsApi$2;
@@ -7501,16 +8264,143 @@ var menuItemsApi_1 = menuItemsApi$2;
  */
 
 // ipcRenderer that must be used to invoke the events
-const { ipcRenderer: ipcRenderer$2 } = require$$0;
+const { ipcRenderer: ipcRenderer$3 } = require$$0;
 
 const pluginApi$2 = {
   install: (packageName, filepath) =>
-    ipcRenderer$2.invoke("plugin-install", { packageName, filepath }),
-  uninstall: (filepath) => ipcRenderer$2.invoke("plugin-uninstall", filepath),
+    ipcRenderer$3.invoke("plugin-install", { packageName, filepath }),
+  uninstall: (filepath) => ipcRenderer$3.invoke("plugin-uninstall", filepath),
 };
 
 var pluginApi_1 = pluginApi$2;
 
+/**
+ * llmApi.js
+ *
+ * Preload bridge for LLM chat operations.
+ * Communicates with main process via IPC for streaming chat,
+ * tool-use events, and request cancellation.
+ */
+
+const { ipcRenderer: ipcRenderer$2 } = require$$0;
+const {
+  LLM_SEND_MESSAGE,
+  LLM_ABORT_REQUEST,
+  LLM_LIST_CONNECTED_TOOLS,
+  LLM_CHECK_CLI_AVAILABLE,
+  LLM_CLEAR_CLI_SESSION,
+  LLM_STREAM_DELTA,
+  LLM_STREAM_TOOL_CALL,
+  LLM_STREAM_TOOL_RESULT,
+  LLM_STREAM_COMPLETE,
+  LLM_STREAM_ERROR,
+} = llmEvents$1;
+
+const llmApi$2 = {
+  /**
+   * sendMessage
+   * Start a streaming LLM request with optional tool-use.
+   *
+   * @param {string} requestId - unique ID for filtering stream events
+   * @param {object} params - { apiKey, model, messages, tools, toolServerMap, systemPrompt, maxToolRounds }
+   * @returns {Promise<void>}
+   */
+  sendMessage: (requestId, params) =>
+    ipcRenderer$2.invoke(LLM_SEND_MESSAGE, { requestId, ...params }),
+
+  /**
+   * abortRequest
+   * Cancel an in-flight LLM request.
+   *
+   * @param {string} requestId - the request to cancel
+   * @returns {Promise<{ success: boolean }>}
+   */
+  abortRequest: (requestId) =>
+    ipcRenderer$2.invoke(LLM_ABORT_REQUEST, { requestId }),
+
+  /**
+   * listConnectedTools
+   * Get all tools from all connected MCP servers.
+   *
+   * @returns {Promise<Array<{ serverName, tools, resources, status }>>}
+   */
+  listConnectedTools: () => ipcRenderer$2.invoke(LLM_LIST_CONNECTED_TOOLS),
+
+  /**
+   * checkCliAvailable
+   * Check if the Claude Code CLI is installed and accessible.
+   *
+   * @returns {Promise<{ available: boolean, path?: string }>}
+   */
+  checkCliAvailable: () => ipcRenderer$2.invoke(LLM_CHECK_CLI_AVAILABLE),
+
+  /**
+   * clearCliSession
+   * Clear the CLI conversation session for a widget (for "New Chat").
+   *
+   * @param {string} widgetUuid - the widget whose session to clear
+   * @returns {Promise<{ success: boolean }>}
+   */
+  clearCliSession: (widgetUuid) =>
+    ipcRenderer$2.invoke(LLM_CLEAR_CLI_SESSION, { widgetUuid }),
+
+  // --- Stream event listeners ---
+
+  /**
+   * onStreamDelta
+   * Listen for text chunks as they stream in.
+   */
+  onStreamDelta: (callback) => {
+    ipcRenderer$2.on(LLM_STREAM_DELTA, (_event, data) => callback(data));
+  },
+
+  /**
+   * onStreamToolCall
+   * Listen for tool call notifications.
+   */
+  onStreamToolCall: (callback) => {
+    ipcRenderer$2.on(LLM_STREAM_TOOL_CALL, (_event, data) => callback(data));
+  },
+
+  /**
+   * onStreamToolResult
+   * Listen for tool result notifications.
+   */
+  onStreamToolResult: (callback) => {
+    ipcRenderer$2.on(LLM_STREAM_TOOL_RESULT, (_event, data) => callback(data));
+  },
+
+  /**
+   * onStreamComplete
+   * Listen for stream completion (final response).
+   */
+  onStreamComplete: (callback) => {
+    ipcRenderer$2.on(LLM_STREAM_COMPLETE, (_event, data) => callback(data));
+  },
+
+  /**
+   * onStreamError
+   * Listen for stream errors.
+   */
+  onStreamError: (callback) => {
+    ipcRenderer$2.on(LLM_STREAM_ERROR, (_event, data) => callback(data));
+  },
+
+  /**
+   * removeAllStreamListeners
+   * Clean up all LLM stream listeners.
+   */
+  removeAllStreamListeners: () => {
+    ipcRenderer$2.removeAllListeners(LLM_STREAM_DELTA);
+    ipcRenderer$2.removeAllListeners(LLM_STREAM_TOOL_CALL);
+    ipcRenderer$2.removeAllListeners(LLM_STREAM_TOOL_RESULT);
+    ipcRenderer$2.removeAllListeners(LLM_STREAM_COMPLETE);
+    ipcRenderer$2.removeAllListeners(LLM_STREAM_ERROR);
+  },
+};
+
+var llmApi_1 = llmApi$2;
+
 /**
  * clientCacheApi.js
  *
@@ -8964,6 +9854,7 @@ const algoliaApi$1 = algoliaApi_1;
 const openaiApi$1 = openaiApi_1;
 const menuItemsApi$1 = menuItemsApi_1;
 const pluginApi$1 = pluginApi_1;
+const llmApi$1 = llmApi_1;
 const clientCacheApi$1 = clientCacheApi_1;
 
 // Events constants
@@ -9027,6 +9918,9 @@ function createMainApi$1(extensions = {}) {
 
     pathPlugins: "",
 
+    // LLM
+    llm: llmApi$1,
+
     // APIs previously in template
     algolia: algoliaApi$1,
     openai: openaiApi$1,
@@ -9076,6 +9970,8 @@ const algoliaController = algoliaController_1;
 const openaiController = openaiController_1;
 const menuItemsController = menuItemsController_1;
 const pluginController = pluginController_1;
+const llmController = llmController_1;
+const cliController = cliController_1;
 
 // --- Utils ---
 const clientCache = requireClientCache();
@@ -9101,6 +9997,7 @@ const algoliaApi = algoliaApi_1;
 const openaiApi = openaiApi_1;
 const menuItemsApi = menuItemsApi_1;
 const pluginApi = pluginApi_1;
+const llmApi = llmApi_1;
 const clientCacheApi = clientCacheApi_1;
 
 // --- Events ---
@@ -9130,6 +10027,8 @@ var electron = {
   openaiController,
   menuItemsController,
   pluginController,
+  llmController,
+  cliController,
 
   // Controller functions (flat) — spread for convenient destructuring
   ...controllers,
@@ -9150,6 +10049,7 @@ var electron = {
   openaiApi,
   menuItemsApi,
   pluginApi,
+  llmApi,
   clientCacheApi,
 
   // Events