@burtson-labs/bandit-engine 2.0.160 → 2.0.161

package/dist/chat-provider.js

@@ -619,6 +619,8 @@ var init_preferencesStore = __esm({
     usePreferencesStore = (0, import_zustand4.create)((set, get) => ({
       preferences: defaultPreferences,
       isLoaded: false,
+      saveState: "idle",
+      lastSavedAt: null,
       setPreferences: (newPreferences) => {
         const sanitized = sanitizePreferences(newPreferences);
         set((state) => ({
@@ -661,6 +663,7 @@ var init_preferencesStore = __esm({
         }
       },
       savePreferences: async () => {
+        set({ saveState: "saving" });
         try {
           const { preferences } = get();
           const storeConfigs6 = [{ name: "config", keyPath: "id" }];
@@ -669,8 +672,10 @@ var init_preferencesStore = __esm({
             preferences
           }, storeConfigs6);
           debugLogger.debug("Preferences saved to IndexedDB");
+          set({ saveState: "saved", lastSavedAt: Date.now() });
         } catch (error) {
           debugLogger.error("Failed to save preferences to IndexedDB", { error });
+          set({ saveState: "error" });
         }
       },
       exportPreferences: () => {
@@ -6674,6 +6679,16 @@ var discoverMcpTools = async (id) => parse(await fetch(`${gatewayBase()}/mcp/ser
 
 // src/store/mcpToolsStore.ts
 var sanitizeMcpToolName = (raw) => raw.replace(/[^a-zA-Z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").slice(0, 60);
+var STORE_CONFIGS = [{ name: "config", keyPath: "id" }];
+var readChoices = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const out = {};
+  for (const [id, on] of Object.entries(value)) {
+    if (typeof on === "boolean") out[id] = on;
+  }
+  return out;
+};
+var withChoice = (tool, choices) => Object.prototype.hasOwnProperty.call(choices, tool.id) && tool.enabled !== choices[tool.id] ? { ...tool, enabled: choices[tool.id] } : tool;
 var healthCheckTool = {
   id: "health-check",
   name: "check_gateway_health",
@@ -6787,130 +6802,199 @@ var createFileTool = {
   isBuiltIn: true
 };
 var defaultTools = [healthCheckTool, webSearchTool, webFetchTool, imageGenerationTool, createFileTool];
-var useMCPToolsStore = (0, import_zustand11.create)((set, get) => ({
-  tools: defaultTools,
-  isLoaded: false,
-  addTool: (toolData) => {
-    const newTool = {
-      ...toolData,
-      id: `tool-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
-    };
-    set((state) => ({
-      tools: [...state.tools, newTool]
-    }));
-    get().saveTools();
-  },
-  updateTool: (id, updates) => {
-    set((state) => ({
-      tools: state.tools.map(
-        (tool) => tool.id === id ? { ...tool, ...updates } : tool
-      )
-    }));
-    get().saveTools();
-  },
-  deleteTool: (id) => {
-    set((state) => ({
-      tools: state.tools.filter((tool) => tool.id !== id || tool.isBuiltIn)
-    }));
-    get().saveTools();
-  },
-  toggleTool: (id) => {
-    set((state) => ({
-      tools: state.tools.map(
-        (tool) => tool.id === id ? { ...tool, enabled: !tool.enabled } : tool
-      )
-    }));
-    get().saveTools();
-  },
-  getEnabledTools: () => {
-    return get().tools.filter((tool) => tool.enabled);
-  },
-  loadTools: async () => {
-    try {
-      const storeConfigs6 = [{ name: "config", keyPath: "id" }];
-      const data = await indexedDBService_default.get("banditConfig", 1, "config", "mcpTools", storeConfigs6);
-      if (data?.tools && Array.isArray(data.tools)) {
-        const savedTools = data.tools;
-        const builtInIds = defaultTools.map((t) => t.id);
-        const customTools = savedTools.filter(
-          (tool) => !tool.isBuiltIn && !builtInIds.includes(tool.id)
-        );
-        set({
-          tools: [...defaultTools, ...customTools],
-          isLoaded: true
-        });
-        debugLogger.info("MCP tools loaded from IndexedDB", {
-          totalTools: defaultTools.length + customTools.length,
-          builtInTools: defaultTools.length,
-          customTools: customTools.length
-        });
-      } else {
-        set({ isLoaded: true });
-        await get().saveTools();
-        debugLogger.info("Default MCP tools initialized");
-      }
-    } catch (error) {
-      debugLogger.error("Failed to load MCP tools from IndexedDB", { error });
-      set({ isLoaded: true });
-    }
-  },
-  saveTools: async () => {
+var useMCPToolsStore = (0, import_zustand11.create)((set, get) => {
+  const persist = async () => {
+    const { tools, choices } = get();
+    const customTools = tools.filter((tool) => !tool.isBuiltIn && !tool.mcpServerId);
+    await indexedDBService_default.put("banditConfig", 1, "config", {
+      id: "mcpTools",
+      tools: customTools,
+      choices
+    }, STORE_CONFIGS);
+    debugLogger.debug("MCP tools saved to IndexedDB", { toolCount: customTools.length, choices: Object.keys(choices).length });
+  };
+  const persistQuietly = async () => {
     try {
-      const { tools } = get();
-      const storeConfigs6 = [{ name: "config", keyPath: "id" }];
-      const customTools = tools.filter((tool) => !tool.isBuiltIn && !tool.mcpServerId);
-      await indexedDBService_default.put("banditConfig", 1, "config", {
-        id: "mcpTools",
-        tools: customTools
-      }, storeConfigs6);
-      debugLogger.debug("MCP tools saved to IndexedDB", { toolCount: customTools.length });
+      await persist();
     } catch (error) {
       debugLogger.error("Failed to save MCP tools to IndexedDB", { error });
     }
-  },
-  // Discover the user's connected MCP servers' tools from the gateway and merge
-  // them into the tool list (so the model can call them). Replaces any prior
-  // MCP-server tools; best-effort — a single unreachable server is skipped.
-  loadMcpServerTools: async () => {
-    let servers;
-    try {
-      servers = await listMcpServers();
-    } catch (error) {
-      debugLogger.warn("Could not list MCP servers", { error: String(error) });
-      return;
-    }
-    const collected = [];
-    for (const server of servers.filter((s) => s.enabled)) {
+  };
+  return {
+    tools: defaultTools,
+    isLoaded: false,
+    choices: {},
+    saveState: "idle",
+    lastSavedAt: null,
+    addTool: (toolData) => {
+      const newTool = {
+        ...toolData,
+        id: `tool-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
+      };
+      set((state) => ({
+        tools: [...state.tools, newTool]
+      }));
+      get().saveTools();
+    },
+    updateTool: (id, updates) => {
+      set((state) => ({
+        tools: state.tools.map(
+          (tool) => tool.id === id ? { ...tool, ...updates } : tool
+        )
+      }));
+      get().saveTools();
+    },
+    deleteTool: (id) => {
+      set((state) => ({
+        tools: state.tools.filter((tool) => tool.id !== id || tool.isBuiltIn)
+      }));
+      get().saveTools();
+    },
+    toggleTool: async (id) => {
+      const tool = get().tools.find((t) => t.id === id);
+      if (!tool) return false;
+      const enabled = !tool.enabled;
+      set((state) => ({
+        tools: state.tools.map((t) => t.id === id ? { ...t, enabled } : t),
+        choices: { ...state.choices, [id]: enabled }
+      }));
+      return get().saveTools();
+    },
+    getEnabledTools: () => {
+      return get().tools.filter((tool) => tool.enabled);
+    },
+    loadTools: async () => {
+      try {
+        const data = await indexedDBService_default.get("banditConfig", 1, "config", "mcpTools", STORE_CONFIGS);
+        if (data?.tools && Array.isArray(data.tools)) {
+          const choices = { ...readChoices(data.choices), ...get().choices };
+          const savedTools = data.tools;
+          const builtInIds = defaultTools.map((t) => t.id);
+          const customTools = savedTools.filter(
+            (tool) => !tool.isBuiltIn && !builtInIds.includes(tool.id)
+          );
+          const discovered = get().tools.filter((t) => t.mcpServerId);
+          set({
+            tools: [...defaultTools, ...customTools, ...discovered].map((t) => withChoice(t, choices)),
+            choices,
+            isLoaded: true
+          });
+          debugLogger.info("MCP tools loaded from IndexedDB", {
+            totalTools: defaultTools.length + customTools.length,
+            builtInTools: defaultTools.length,
+            customTools: customTools.length,
+            choices: Object.keys(choices).length
+          });
+        } else {
+          set({ isLoaded: true });
+          await persistQuietly();
+          debugLogger.info("Default MCP tools initialized");
+        }
+      } catch (error) {
+        debugLogger.error("Failed to load MCP tools from IndexedDB", { error });
+        set({ isLoaded: true });
+      }
+    },
+    saveTools: async () => {
+      set({ saveState: "saving" });
       try {
-        const { tools } = await discoverMcpTools(server.id);
-        for (const t of tools) {
-          const fnName = sanitizeMcpToolName(`mcp_${server.name}_${t.name}`);
-          const schema = t.inputSchema && typeof t.inputSchema === "object" && t.inputSchema.type === "object" ? t.inputSchema : { type: "object", properties: {}, required: [] };
-          collected.push({
-            id: `mcp-${server.id}-${t.name}`,
-            name: fnName,
-            description: t.description || `${t.name} (via ${server.name})`,
-            enabled: true,
+        await persist();
+        set({ saveState: "saved", lastSavedAt: Date.now() });
+        return true;
+      } catch (error) {
+        debugLogger.error("Failed to save MCP tools to IndexedDB", { error });
+        set({ saveState: "error" });
+        return false;
+      }
+    },
+    syncControllerTools: (controllerTools) => {
+      const { choices } = get();
+      const next = [...get().tools];
+      let changed = false;
+      for (const ct of controllerTools) {
+        const functionName = (ct.id || ct.name).replace(/[^a-zA-Z0-9_]/g, "_");
+        const index = [
+          next.findIndex((lt) => lt.function.name === functionName),
+          next.findIndex((lt) => lt.function.name === ct.id),
+          next.findIndex((lt) => lt.id === ct.id)
+        ].find((i) => i >= 0) ?? -1;
+        if (index < 0) {
+          next.push({
+            id: `tool-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            name: functionName,
+            description: ct.description,
+            enabled: ct.isEnabled,
             type: "function",
             function: {
-              name: fnName,
-              description: t.description || `${t.name} \u2014 provided by the ${server.name} MCP server.`,
-              parameters: schema
+              name: ct.id,
+              // the controller id maps back to the tool
+              description: ct.description,
+              parameters: { type: "object", properties: {}, required: [] }
             },
-            mcpServerId: server.id,
-            mcpToolName: t.name
+            endpoint: `/mcp/${ct.id}`,
+            method: "GET",
+            isBuiltIn: false
           });
+          changed = true;
+          continue;
+        }
+        const local = next[index];
+        const enabled = Object.prototype.hasOwnProperty.call(choices, local.id) ? choices[local.id] : ct.isEnabled;
+        if (local.enabled !== enabled) {
+          next[index] = { ...local, enabled };
+          changed = true;
         }
+      }
+      if (!changed) return;
+      set({ tools: next });
+      void persistQuietly();
+    },
+    // Discover the user's connected MCP servers' tools from the gateway and merge
+    // them into the tool list (so the model can call them). Replaces any prior
+    // MCP-server tools; best-effort — a single unreachable server is skipped.
+    loadMcpServerTools: async () => {
+      let servers;
+      try {
+        servers = await listMcpServers();
       } catch (error) {
-        debugLogger.warn("Failed to discover tools for MCP server", { server: server.name, error: String(error) });
+        debugLogger.warn("Could not list MCP servers", { error: String(error) });
+        return;
       }
+      const collected = [];
+      for (const server of servers.filter((s) => s.enabled)) {
+        try {
+          const { tools } = await discoverMcpTools(server.id);
+          for (const t of tools) {
+            const fnName = sanitizeMcpToolName(`mcp_${server.name}_${t.name}`);
+            const schema = t.inputSchema && typeof t.inputSchema === "object" && t.inputSchema.type === "object" ? t.inputSchema : { type: "object", properties: {}, required: [] };
+            const id = `mcp-${server.id}-${t.name}`;
+            const { choices } = get();
+            collected.push({
+              id,
+              name: fnName,
+              description: t.description || `${t.name} (via ${server.name})`,
+              enabled: Object.prototype.hasOwnProperty.call(choices, id) ? choices[id] : true,
+              type: "function",
+              function: {
+                name: fnName,
+                description: t.description || `${t.name} \u2014 provided by the ${server.name} MCP server.`,
+                parameters: schema
+              },
+              mcpServerId: server.id,
+              mcpToolName: t.name
+            });
+          }
+        } catch (error) {
+          debugLogger.warn("Failed to discover tools for MCP server", { server: server.name, error: String(error) });
+        }
+      }
+      set((state) => ({
+        tools: [...state.tools.filter((t) => !t.mcpServerId), ...collected]
+      }));
+      debugLogger.info("MCP server tools loaded", { count: collected.length });
     }
-    set((state) => ({
-      tools: [...state.tools.filter((t) => !t.mcpServerId), ...collected]
-    }));
-    debugLogger.info("MCP server tools loaded", { count: collected.length });
-  }
-}));
+  };
+});
 
 // src/chat/hooks/useKnowledgeStore.tsx
 var import_react4 = require("react");