@bike4mind/cli 0.2.37 → 0.2.38-add-notebook-project-fixes.20160

package/dist/{chunk-XIB66EG7.js → chunk-XBAC2O32.js}

@@ -4,7 +4,7 @@ import {
   getOpenWeatherKey,
   getSerperKey,
   getWolframAlphaKey
-} from "./chunk-NJQYWIDJ.js";
+} from "./chunk-J3YSVA6W.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -16,14 +16,14 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-5YLGNW2B.js";
+} from "./chunk-QCDYXXSD.js";
 import {
   Logger
 } from "./chunk-PFBYGCOW.js";
 import {
   ConfigStore,
   logger
-} from "./chunk-H7RVLAQD.js";
+} from "./chunk-HJVFUXVX.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -80,7 +80,7 @@ import {
   getMcpProviderMetadata,
   getViewById,
   resolveNavigationIntents
-} from "./chunk-EY65E4W4.js";
+} from "./chunk-OCFOJXLA.js";
 
 // src/utils/fileSearch.ts
 import * as fs from "fs";
@@ -1846,7 +1846,8 @@ ${options.context}` : this.getSystemPrompt()
             temperature,
             abortSignal: options.signal,
             tool_choice: this.context.toolChoice,
-            executeTools: false
+            executeTools: false,
+            thinking: this.context.thinking
           },
           async (texts, completionInfo) => {
             for (const text of texts) {
@@ -2146,34 +2147,20 @@ Remember: You are an autonomous AGENT. Act independently and solve problems proa
     }
   }
   /**
-   * Build and append tool call/result messages for the conversation history
+   * Build and append tool call/result messages for the conversation history.
+   * Delegates to the backend's pushToolMessages so each provider formats
+   * messages according to its own API requirements.
    */
   appendToolMessages(messages, toolUse, observation, thinkingBlocks) {
     const params = this.parseToolArguments(toolUse.arguments);
-    const msgToolCallId = `${toolUse.name}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    const assistantContent = [
-      ...thinkingBlocks,
-      {
-        type: "tool_use",
-        id: msgToolCallId,
-        name: toolUse.name,
-        input: params
-      }
-    ];
-    messages.push({
-      role: "assistant",
-      content: assistantContent
-    });
-    messages.push({
-      role: "user",
-      content: [
-        {
-          type: "tool_result",
-          tool_use_id: msgToolCallId,
-          content: observation
-        }
-      ]
-    });
+    const toolId = toolUse.id || `${toolUse.name}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const parameters = typeof toolUse.arguments === "string" ? toolUse.arguments : JSON.stringify(params);
+    this.context.llm.pushToolMessages(
+      messages,
+      { id: toolId, name: toolUse.name, parameters },
+      observation,
+      thinkingBlocks
+    );
   }
 };
 
@@ -8745,7 +8732,7 @@ var knowledgeBaseSearchTool = {
     toolFn: async (value) => {
       const params = value;
       const { query, tags, file_type, max_results = 5 } = params;
-      context.logger.log("\u{1F4DA} Knowledge Base Search: Starting search for query:", query);
+      context.logger.log("\u{1F4DA} Knowledge Base Search: userId:", context.userId, "query:", query, "tags:", tags);
       if (!context.db.fabfiles) {
         context.logger.error("\u274C Knowledge Base Search: fabfiles repository not available");
         return "Knowledge base search is not available at this time.";
@@ -8771,7 +8758,7 @@ var knowledgeBaseSearchTool = {
           userGroups: context.user.groups || []
           // Pass user's groups for org-level sharing
         });
-        context.logger.log("\u{1F4DA} Knowledge Base Search: Found", searchResults.data.length, "results");
+        context.logger.log("\u{1F4DA} Knowledge Base Search: Found", searchResults.data.length, "of", searchResults.total, "results. Files:", searchResults.data.map((f) => f.fileName));
         return formatSearchResults(searchResults.data);
       } catch (error) {
         context.logger.error("\u274C Knowledge Base Search: Error during search:", error);
@@ -8791,7 +8778,7 @@ var knowledgeBaseSearchTool = {
           tags: {
             type: "array",
             items: { type: "string" },
-            description: 'Optional: filter results by tag names. Supports partial matching. For optimization docs, use tags like "opti:family:scheduling", "opti:QUBO", "opti:solver:highs", etc. Any matching tag qualifies the file.'
+            description: 'Optional: filter results by tag names. Supports partial matching. For optimization docs, use tags like "opti:family:scheduling", "opti:QUBO", "opti:solver:highs". For IonQ sales intelligence, use tags like "ionq:vertical:pharma", "ionq:competitor:ibm", "ionq:type:product-specs", "ionq:stage:discovery", "ionq:offering:forte". Any matching tag qualifies the file.'
           },
           file_type: {
             type: "string",
@@ -8904,7 +8891,7 @@ Chunks: ${chunks.length} | Characters: ${charLabel}
           tags: {
             type: "array",
             items: { type: "string" },
-            description: 'Filter documents by tags. For optimization docs, use tags like "opti:family:scheduling", "opti:solver:highs", etc.'
+            description: 'Filter documents by tags. For optimization docs, use tags like "opti:family:scheduling", "opti:solver:highs". For IonQ sales intelligence, use tags like "ionq:vertical:pharma", "ionq:competitor:ibm", "ionq:content:product-specs", "ionq:offering:forte".'
           },
           query: {
             type: "string",
@@ -13280,6 +13267,61 @@ var generateMcpTools = async (mcpData) => {
   Logger.debug(`\u{1F527} generateMcpTools: Generated ${result.length} tool implementations for ${mcpData.serverName}`);
   return result;
 };
+var generateMcpToolsFromCache = (serverName, cachedTools, callTool) => {
+  const normalizedServerName = serverName.toLowerCase();
+  const result = cachedTools.map((item) => {
+    const { name: originalToolName, ...rest } = item;
+    const namespacedToolName = `${normalizedServerName}__${originalToolName}`;
+    const providerMetadata = getMcpProviderMetadata(normalizedServerName);
+    const fallbackDescription = providerMetadata?.defaultToolDescriptions?.[originalToolName] ?? "";
+    const parameters = normalizeToolParameters(rest);
+    const optionTools = {
+      toolFn: async (args) => {
+        Logger.debug(`Calling ${originalToolName} tool via ${serverName}`, args);
+        try {
+          const toolResult = await callTool(originalToolName, args);
+          const contentBlocks = toolResult?.content;
+          if (Array.isArray(contentBlocks) && contentBlocks.length > 0) {
+            const normalized = contentBlocks.map((entry) => {
+              if (entry && typeof entry === "object" && "text" in entry) {
+                return entry.text;
+              }
+              return JSON.stringify(entry);
+            }).join("\n");
+            Logger.debug(`[Tool Result] ${originalToolName}:`, normalized);
+            return normalized;
+          }
+          const serialized = typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult);
+          Logger.debug(`[Tool Result] Unexpected format for ${originalToolName}, returning serialized output`);
+          return serialized;
+        } catch (error) {
+          if (normalizedServerName === "atlassian") {
+            const errorName = error instanceof Error ? error.name : "";
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const isTokenError = errorName === "AtlassianReconnectRequiredError" || errorMessage.includes("401") || errorMessage.includes("403") || errorMessage.includes("unauthorized") || errorMessage.includes("expired");
+            if (isTokenError) {
+              console.warn(`Atlassian token may be expired for tool ${originalToolName}, error:`, errorMessage);
+              return ATLASSIAN_RECONNECT_MESSAGE;
+            }
+          }
+          throw error;
+        }
+      },
+      toolSchema: {
+        name: namespacedToolName,
+        description: rest.description || fallbackDescription,
+        parameters
+      }
+    };
+    return {
+      name: namespacedToolName,
+      ...optionTools,
+      _isMcpTool: true
+    };
+  });
+  Logger.debug(`\u{1F527} generateMcpToolsFromCache: Generated ${result.length} tool implementations for ${serverName} (from cache)`);
+  return result;
+};
 
 // ../../b4m-core/packages/services/dist/src/llm/agents/ServerSubagentOrchestrator.js
 var SUBAGENT_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -13382,7 +13424,6 @@ var GithubManagerAgent = (config) => ({
   name: "github_manager",
   description: "GitHub operations (issues, pull requests, code search, branches, workflows, reviews). ALWAYS delegate GitHub requests to this agent \u2014 you do not have direct access to these tools",
   model: config?.model ?? ChatModels.CLAUDE_4_6_SONNET_BEDROCK,
-  fallbackModels: [ChatModels.GPT4_1, ChatModels.GPT4_1_MINI],
   defaultThoroughness: config?.defaultThoroughness ?? "medium",
   maxIterations: { quick: 3, medium: 8, very_thorough: 15 },
   allowedTools: [...config?.extraAllowedTools ?? []],
@@ -15238,6 +15279,12 @@ function substituteArguments(template, args) {
   return result;
 }
 
+// src/utils/mcpAdapter.ts
+import { createHash } from "crypto";
+import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join as join3, dirname as dirname2 } from "path";
+
 // ../../b4m-core/packages/mcp/dist/src/client.js
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
@@ -15251,15 +15298,17 @@ var MCPClient = class {
   customCommand;
   customArgs;
   suppressStderr;
+  onStderrLine;
   tools = [];
   serverName;
-  constructor({ envVariables, name, selectedRepositories, command, args, suppressStderr = false }) {
+  constructor({ envVariables, name, selectedRepositories, command, args, suppressStderr = false, onStderrLine }) {
     this.mcp = new Client2({ name: "mcp-client-cli", version: "1.0.0" });
     this.envVariables = [...envVariables];
     this.serverName = name;
     this.customCommand = command;
     this.customArgs = args;
     this.suppressStderr = suppressStderr;
+    this.onStderrLine = onStderrLine;
     if (name === "github" && selectedRepositories) {
       const reposJson = JSON.stringify(selectedRepositories);
       this.envVariables.push({
@@ -15305,6 +15354,7 @@ var MCPClient = class {
         args = [serverScriptPath];
         console.log(`[MCP] Using server: ${this.serverName} at ${serverScriptPath}`);
       }
+      const stderrMode = this.suppressStderr ? "ignore" : this.onStderrLine ? "pipe" : void 0;
       const transportConfig = {
         command,
         args,
@@ -15312,14 +15362,16 @@ var MCPClient = class {
           ...Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== void 0)),
           ...envVarsObject
         },
-        // Suppress stderr in CLI context to prevent MCP server startup logs from breaking layout
-        ...this.suppressStderr && { stderr: "ignore" }
+        ...stderrMode && { stderr: stderrMode }
       };
       this.transport = new StdioClientTransport(transportConfig);
       this.transport.onerror = (error) => {
         console.error(`[MCP] Transport error for ${this.serverName}:`, error);
       };
       await this.mcp.connect(this.transport);
+      if (this.onStderrLine && this.transport.stderr) {
+        this.readStderr(this.transport.stderr);
+      }
       await new Promise((resolve3) => setTimeout(resolve3, 100));
       const toolsResult = await this.mcp.listTools();
       this.tools = toolsResult.tools.map((tool) => {
@@ -15341,6 +15393,30 @@ var MCPClient = class {
       throw e;
     }
   }
+  /**
+   * Read lines from the child process stderr stream and dispatch to the callback.
+   * Uses Node.js stream events; errors are silently caught (stream closes on disconnect).
+   */
+  readStderr(stream) {
+    let buffer = "";
+    stream.setEncoding("utf8");
+    stream.on("data", (chunk) => {
+      buffer += chunk;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed)
+          this.onStderrLine?.(trimmed);
+      }
+    });
+    stream.on("end", () => {
+      if (buffer.trim())
+        this.onStderrLine?.(buffer.trim());
+    });
+    stream.on("error", () => {
+    });
+  }
   async callTool(toolName, toolArgs) {
     try {
       const args = toolArgs && typeof toolArgs === "object" ? toolArgs : void 0;
@@ -15376,14 +15452,30 @@ var MCPClient = class {
 };
 
 // src/utils/mcpAdapter.ts
+var CACHE_VERSION = 1;
+var CACHE_FILE = join3(homedir4(), ".bike4mind", "mcp-schema-cache.json");
 var McpManager = class {
   constructor(config) {
     this.servers = /* @__PURE__ */ new Map();
     this.connectionStates = /* @__PURE__ */ new Map();
+    /** Per-server deferred promise resolved once the background connection is ready */
+    this.connectionReady = /* @__PURE__ */ new Map();
+    /**
+     * Serializes background cache saves so concurrent writes don't race.
+     * JSON.stringify is evaluated at run-time, always capturing the latest cache state.
+     */
+    this.backgroundSaveQueue = Promise.resolve();
     this.config = config;
   }
+  /** Subscribe to background connection state changes for live UI updates. */
+  setOnStateChange(callback) {
+    this.onStateChange = callback;
+  }
   /**
-   * Initialize and connect to all enabled MCP servers
+   * Initialize MCP servers with schema caching.
+   *
+   * - Cache hit  → tools registered immediately from cache; server connected in background
+   * - Cache miss → server connected eagerly (blocks); result cached for next run
    */
   async initialize() {
     const enabledServers = this.config.mcpServers.filter((s) => s.enabled);
@@ -15392,47 +15484,96 @@ var McpManager = class {
       return;
     }
     logger.debug(`\u{1F4E1} Initializing ${enabledServers.length} MCP server(s)...`);
-    const results = await Promise.allSettled(enabledServers.map((serverConfig) => this.connectServer(serverConfig)));
-    const successful = results.filter((r) => r.status === "fulfilled").length;
-    const failed = results.filter((r) => r.status === "rejected").length;
-    if (successful > 0) {
-      logger.debug(`\u2705 Connected to ${successful} MCP server(s)`);
+    const cache = await this.loadCache();
+    const configuredNames = new Set(this.config.mcpServers.map((s) => s.name));
+    let pruned = false;
+    for (const name of Object.keys(cache.servers)) {
+      if (!configuredNames.has(name)) {
+        delete cache.servers[name];
+        pruned = true;
+      }
+    }
+    const eagerConnections = [];
+    for (const serverConfig of enabledServers) {
+      const configHash = this.hashServerConfig(serverConfig);
+      const cachedEntry = cache.servers[serverConfig.name];
+      if (cachedEntry && cachedEntry.configHash === configHash) {
+        this.registerFromCache(serverConfig, cachedEntry);
+        this.connectBackground(serverConfig, cache);
+      } else {
+        eagerConnections.push(this.connectEager(serverConfig, cache));
+      }
+    }
+    if (eagerConnections.length > 0) {
+      await Promise.allSettled(eagerConnections);
+      await this.saveCache(cache);
+    } else if (pruned) {
+      await this.saveCache(cache);
     }
-    if (failed > 0) {
-      logger.debug(`\u26A0\uFE0F  Failed to connect to ${failed} MCP server(s)`);
+    const connected = [...this.connectionStates.values()].filter((s) => s === "connected").length;
+    const pending = [...this.connectionStates.values()].filter((s) => s === "connecting").length;
+    if (connected > 0 || pending > 0) {
+      logger.debug(`\u2705 ${connected} MCP server(s) ready${pending > 0 ? `, ${pending} connecting in background` : ""}`);
     }
   }
+  // ─── Private: connection strategies ────────────────────────────────────────
+  /**
+   * Register tool stubs from cache immediately. callTool lazily awaits the
+   * background connection before forwarding to the real client.
+   */
+  registerFromCache(serverConfig, entry) {
+    this.connectionStates.set(serverConfig.name, "connecting");
+    let resolveReady;
+    let rejectReady;
+    const promise = new Promise((res, rej) => {
+      resolveReady = res;
+      rejectReady = rej;
+    });
+    promise.catch(() => {
+    });
+    this.connectionReady.set(serverConfig.name, { resolve: resolveReady, reject: rejectReady, promise });
+    const callTool = async (name, args) => {
+      await promise;
+      return this.servers.get(serverConfig.name).client.callTool(name, args);
+    };
+    const tools = generateMcpToolsFromCache(serverConfig.name, entry.tools, callTool);
+    this.servers.set(serverConfig.name, { name: serverConfig.name, client: null, tools });
+    logger.debug(`\u{1F4CB} ${entry.tools.length} tools for ${serverConfig.name} loaded from cache`);
+  }
+  /**
+   * Spawn the server process in the background. Resolves the per-server
+   * deferred promise when ready so pending callTool invocations can proceed.
+   */
+  connectBackground(serverConfig, cache) {
+    this.doConnect(serverConfig).then(({ client }) => {
+      const instance = this.servers.get(serverConfig.name);
+      if (instance) {
+        instance.client = client;
+      }
+      this.connectionStates.set(serverConfig.name, "connected");
+      this.connectionReady.get(serverConfig.name)?.resolve();
+      this.onStateChange?.();
+      logger.debug(`\u2705 Background connection to ${serverConfig.name} established`);
+      this.writeCacheEntry(cache, serverConfig, client.tools);
+      this.scheduleBackgroundSave(cache);
+    }).catch((err) => {
+      this.connectionStates.set(serverConfig.name, "failed");
+      this.connectionReady.get(serverConfig.name)?.reject(err);
+      this.onStateChange?.();
+      logger.debug(`\u274C Background connection to ${serverConfig.name} failed: ${err}`);
+    });
+  }
   /**
-   * Connect to a single MCP server
+   * Connect eagerly (blocks initialize). Populates servers map and updates cache.
    */
-  async connectServer(serverConfig) {
+  async connectEager(serverConfig, cache) {
     this.connectionStates.set(serverConfig.name, "connecting");
+    logger.debug(`\u{1F504} Connecting to ${serverConfig.name}...`);
     try {
-      logger.debug(`\u{1F504} Connecting to ${serverConfig.name}...`);
-      const envVariables = Object.entries(serverConfig.env).map(([key, value]) => ({
-        key,
-        value
-      }));
-      const client = new MCPClient({
-        envVariables,
-        name: serverConfig.name,
-        command: serverConfig.command,
-        args: serverConfig.args,
-        suppressStderr: true
-      });
-      await client.connectToServer();
-      const mcpData = {
-        serverName: serverConfig.name,
-        getTools: async () => client.tools,
-        callTool: async (name, args) => client.callTool(name, args)
-      };
-      const tools = await generateMcpTools(mcpData);
-      this.servers.set(serverConfig.name, {
-        name: serverConfig.name,
-        client,
-        tools
-      });
+      const { client, tools } = await this.doConnect(serverConfig);
+      this.servers.set(serverConfig.name, { name: serverConfig.name, client, tools });
       this.connectionStates.set(serverConfig.name, "connected");
+      this.writeCacheEntry(cache, serverConfig, client.tools);
       logger.debug(`\u2705 Connected to ${serverConfig.name} (${tools.length} tools)`);
     } catch (error) {
       this.connectionStates.set(serverConfig.name, "failed");
@@ -15440,8 +15581,82 @@ var McpManager = class {
     }
   }
   /**
-   * Get all tools from all connected MCP servers
+   * Shared: spawn and handshake with an MCP server process.
    */
+  async doConnect(serverConfig) {
+    const envVariables = Object.entries(serverConfig.env).map(([key, value]) => ({ key, value }));
+    const client = new MCPClient({
+      envVariables,
+      name: serverConfig.name,
+      command: serverConfig.command,
+      args: serverConfig.args,
+      suppressStderr: true
+    });
+    await client.connectToServer();
+    const mcpData = {
+      serverName: serverConfig.name,
+      getTools: async () => client.tools,
+      // any: generateMcpTools accepts a loose duck-type; MCPClient.callTool return type
+      // doesn't match the internal interface exactly, but runtime behaviour is correct.
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      callTool: async (name, args) => client.callTool(name, args)
+    };
+    const tools = await generateMcpTools(mcpData);
+    return { client, tools };
+  }
+  // ─── Private: cache helpers ──────────────────────────────────────────────────
+  async loadCache() {
+    try {
+      const raw = await readFile2(CACHE_FILE, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed.version === CACHE_VERSION) {
+        return parsed;
+      }
+    } catch {
+    }
+    return { version: CACHE_VERSION, servers: {} };
+  }
+  async saveCache(cache) {
+    try {
+      await mkdir(dirname2(CACHE_FILE), { recursive: true });
+      await writeFile(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
+    } catch (error) {
+      logger.debug(`\u26A0\uFE0F  Failed to save MCP schema cache: ${error}`);
+    }
+  }
+  /**
+   * Enqueue a background cache save. Saves are serialized so concurrent background
+   * connections can't interleave writes and lose each other's entries. JSON.stringify
+   * is evaluated when the queued write runs, so it always captures the latest state.
+   */
+  scheduleBackgroundSave(cache) {
+    this.backgroundSaveQueue = this.backgroundSaveQueue.then(() => this.saveCache(cache)).catch(() => {
+    });
+  }
+  writeCacheEntry(cache, serverConfig, rawTools) {
+    cache.servers[serverConfig.name] = {
+      configHash: this.hashServerConfig(serverConfig),
+      tools: rawTools.map((t) => {
+        const tool = t;
+        return {
+          name: t.name,
+          description: tool.description,
+          // Normalize both MCP SDK casing variants to input_schema for storage
+          input_schema: tool.inputSchema ?? tool.input_schema
+        };
+      }),
+      cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  hashServerConfig(serverConfig) {
+    const key = JSON.stringify({
+      command: serverConfig.command,
+      args: serverConfig.args,
+      env: serverConfig.env
+    });
+    return createHash("sha256").update(key).digest("hex").slice(0, 16);
+  }
+  // ─── Public API ───────────────────────────────────────────────────────────────
   getTools() {
     const allTools = [];
     for (const server of this.servers.values()) {
@@ -15449,24 +15664,17 @@ var McpManager = class {
     }
     return allTools;
   }
-  /**
-   * Get tool count by server
-   */
   getToolCount() {
     return Array.from(this.servers.values()).map((server) => ({
       serverName: server.name,
       count: server.tools.length
     }));
   }
-  /**
-   * Disconnect from all MCP servers
-   */
   async disconnect() {
-    if (this.servers.size === 0) {
-      return;
-    }
+    if (this.servers.size === 0) return;
     logger.debug(`\u{1F50C} Disconnecting from ${this.servers.size} MCP server(s)...`);
     const disconnectPromises = Array.from(this.servers.values()).map(async (server) => {
+      if (!server.client) return;
       try {
         await server.client.disconnect();
         logger.debug(`\u2705 Disconnected from ${server.name}`);
@@ -15476,27 +15684,17 @@ var McpManager = class {
     });
     await Promise.allSettled(disconnectPromises);
     this.servers.clear();
+    this.connectionReady.clear();
   }
-  /**
-   * Check if any MCP servers are connected
-   */
   hasServers() {
     return this.servers.size > 0;
   }
-  /**
-   * Get list of connected server names
-   */
   getServerNames() {
     return Array.from(this.servers.keys());
   }
-  /**
-   * Get connection state for a server
-   */
   getConnectionState(serverName) {
     const serverConfig = this.config.mcpServers.find((s) => s.name === serverName);
-    if (!serverConfig?.enabled) {
-      return "disabled";
-    }
+    if (!serverConfig?.enabled) return "disabled";
     return this.connectionStates.get(serverName) || "connecting";
   }
 };
@@ -15904,6 +16102,9 @@ var ServerLlmBackend = class {
       });
     });
   }
+  pushToolMessages(_messages, _tool, _result) {
+    throw new Error("ServerLlmBackend does not support pushToolMessages \u2014 tools are executed server-side");
+  }
   /**
    * Get available models from server
    * Fetches from /api/models and filters for CLI-compatible models
@@ -16123,6 +16324,9 @@ var WebSocketLlmBackend = class {
       });
     });
   }
+  pushToolMessages(_messages, _tool, _result) {
+    throw new Error("WebSocketLlmBackend does not support pushToolMessages \u2014 tools are executed server-side");
+  }
   /**
    * Get available models from server (REST call, not streaming).
    * Delegates to ApiClient -- same as ServerLlmBackend.

package/dist/commands/doctorCommand.js

@@ -3,7 +3,7 @@ import {
   fetchLatestVersion,
   forceCheckForUpdate,
   package_default
-} from "../chunk-FACWWYF7.js";
+} from "../chunk-F4TQZA4G.js";
 
 // src/commands/doctorCommand.ts
 import { execSync } from "child_process";