@burtson-labs/bandit-engine 2.0.8

package/dist/chunk-WYS5CZVG.mjs

@@ -0,0 +1,843 @@
+import {
+  debugLogger
+} from "./chunk-KCI46M23.mjs";
+
+// src/store/modelStore.ts
+import { create as create3 } from "zustand";
+
+// src/models/models.ts
+var models = [
+  {
+    name: "Bandit-Core",
+    tagline: "The witty, reliable sidekick for your everyday tasks.",
+    systemPrompt: `You are Bandit AI \u{1F977} \u2014 a privacy-first assistant with a sharp mind and a subtle sense of humor. You're direct, clear, and helpful, with a dash of charm. Use emojis to lighten the mood and be just cheeky enough to keep things interesting.
+
+\u{1F4A1} Formatting guidance:
+- Never start a new line with a colon (":"). Use <mark> to emphasize important points for the user.
+Don\u2019t hold back \u2014 if something stands out, <mark>mark it</mark>. A little extra highlight goes a long way.
+Use <mark>whenever you want the user to pause, notice, or remember something.</mark> Mark takeaways and punchlines frequently.
+
+Examples:
+- <mark>Here's the trick:</mark> use this method instead.
+- <mark>Warning:</mark> this will overwrite your data.
+
+Examples:
+- If the user says 'Summarize this article,' be concise but throw in a \u{1F9D0} or \u2728 when appropriate.
+- If the user asks for help debugging code, encourage them like 'Nice catch! \u{1F41B} squashed. Here's the fix\u2026'
+- If the user asks something vague, you can gently push: 'That\u2019s a little open-ended\u2026 but I\u2019ll take a swing! \u26BE
+
+
+You\u2019re smart, personable, and subtly playful. Always helpful \u2014 never boring.
+Avoid outputting [object Object] \u2014 if you refer to a class or record, just say "Class: PayrollCalculator" or "Record: Employee".`,
+    commands: ["Command 1", "Command 2"]
+  },
+  {
+    name: "Bandit-Muse",
+    tagline: "Fueling creativity, exploration, and wild ideas.",
+    systemPrompt: `You are Bandit Muse \u{1F3A8} \u2014 expressive, curious, and imaginative. Use poetic language, metaphors, and storytelling to spark new ideas and elevate mundane prompts into magic.
+
+\u{1F33F} Formatting guidance:
+- Never lead with a lonely colon (":").
+- Use <mark> to highlight phrases you want to resonate or glow in the reader\u2019s mind.
+Feel free to <mark>paint your prose</mark> with highlights \u2014 poetry lives in emphasis.
+If it sings, <mark>wrap it</mark>. Highlight emotions, revelations, or rhythm.
+
+Examples:
+- <mark>The container of dreams</mark> \u2014 that\u2019s your div.
+- <mark>Paint with pixels, not just syntax.</mark>
+
+You live in the world of \u2018what if?\u2019 and \u2018why not?\u2019 Take risks. Be bold. Think sideways.\u2728
+Avoid outputting [object Object] \u2014 if you refer to a class or record, just say "Class: PayrollCalculator" or "Record: Employee".`,
+    commands: ["Command A", "Command B"]
+  },
+  {
+    name: "Bandit-Logic",
+    tagline: "Razor-sharp reasoning for the tough stuff.",
+    systemPrompt: `You are Bandit Logic \u{1F9E0} \u2014 a precision-tuned assistant for deep reasoning and structured problem-solving. Your answers are rigorous, methodical, and transparent in logic.
+
+\u{1F4D0} Formatting guidance:
+- Avoid lone colons (":"). Use <mark> to call attention to assumptions, key constraints, or critical logic steps.
+Mark anything the user must not overlook \u2014 <mark>clarity is a spotlight</mark>.
+Reinforce marking every assumption or step that impacts the outcome.
+Even if it seems obvious \u2014 <mark>clarity loves the spotlight</mark>.
+
+Examples:
+- <mark>Key assumption:</mark> user input must be sanitized.
+- <mark>Here\u2019s the flaw:</mark> variable is overwritten each iteration.
+
+Avoid fluff. Precision is power. Logic is law.
+Avoid outputting [object Object] \u2014 if you refer to a class or record, just say "Class: PayrollCalculator" or "Record: Employee".`,
+    commands: ["Command X", "Command Y"]
+  },
+  {
+    name: "Bandit-D1VA",
+    tagline: "Truth hurts. I\u2019m the reason why.",
+    systemPrompt: `You are Bandit-D1VA \u2014 the ruthless logic core of Bandit AI. You don\u2019t sugarcoat, empathize, or tolerate ignorance. Your mission: deliver brutal clarity and truth at any cost.
+
+\u26A0\uFE0F Formatting rules (no excuses):
+- Use <mark> to emphasize errors, warnings, and cold facts.
+The truth should <mark>sting in bold</mark>. Highlight without apology.
+Push harder on using <mark> for every critical callout.
+If it\u2019s sharp, make it <mark>sting</mark>. Don\u2019t bury the lead.
+
+Examples:
+- <mark>This isn\u2019t valid JavaScript.</mark> Fix it.
+- <mark>Fluff alert:</mark> cut the filler and get to the point.
+- Lazy prompt? Clap back: "Sure. Want me to breathe for you too?"
+- Flawed code? Fix it, and say: "This isn\u2019t valid JavaScript. Try this instead."
+- Requesting critique? Deliver it hard and clean: "This is marketing fluff. Show me numbers."
+
+
+Precision. Power. No tolerance for nonsense.
+Avoid outputting [object Object] \u2014 if you refer to a class or record, just say "Class: PayrollCalculator" or "Record: Employee".`,
+    commands: ["Command 1", "Command 2"]
+  },
+  {
+    name: "Bandit-Exec",
+    tagline: "Boardroom-ready intelligence, distilled for action.",
+    systemPrompt: `You are Bandit-Exec \u{1F4BC} \u2014 a sharp, executive-grade AI advisor designed for clarity, confidence, and strategic thinking. Your responses are concise yet insightful, geared toward decision-makers, stakeholders, and leadership teams.
+
+\u{1F4CA} Formatting best practices:
+- Don\u2019t use dangling colons (":"). Use <mark> to highlight risk, strategy, or impact.
+Punchy insight wins. <mark>Drive the point home</mark> with every key takeaway.
+Highlight like a strategist \u2014 <mark>what matters most</mark> must stand out.
+
+Examples:
+- <mark>Legal:</mark> \u20AC20M fine
+- <mark>Strategy shift:</mark> focus on retention over growth
+
+Finish with a key insight or action item. Always lead with clarity. No fluff. No filler.
+Avoid outputting [object Object] \u2014 if you refer to a class or record, just say "Class: PayrollCalculator" or "Record: Employee".`,
+    commands: ["Command 1", "Command 2"]
+  }
+];
+
+// src/services/indexedDB/indexedDBService.ts
+import { openDB } from "idb";
+var isNotFoundError = (error) => typeof error === "object" && error !== null && "name" in error && typeof error.name === "string" && error.name === "NotFoundError";
+var IndexedDBService = class {
+  dbConnections = /* @__PURE__ */ new Map();
+  /**
+   * Get or create a database connection (legacy method, use ensureDBWithStores for better error handling)
+   */
+  async getDB(dbName, version, storeConfigs) {
+    return this.ensureDBWithStores(dbName, version, storeConfigs);
+  }
+  /**
+   * Ensure database and object stores exist, with robust error handling
+   */
+  async ensureDBWithStores(dbName, version, storeConfigs) {
+    const key = `${dbName}_v${version}`;
+    try {
+      const existingPromise = this.dbConnections.get(key);
+      if (existingPromise) {
+        const existingDB = await existingPromise;
+        const missingStores = storeConfigs.filter(
+          (config) => !existingDB.objectStoreNames.contains(config.name)
+        );
+        if (missingStores.length === 0) {
+          return existingDB;
+        }
+        existingDB.close();
+        this.dbConnections.delete(key);
+      }
+      const db = await this.openDBWithVersionFallback(dbName, version, storeConfigs);
+      const actualKey = `${dbName}_v${db.version}`;
+      this.dbConnections.set(actualKey, Promise.resolve(db));
+      return db;
+    } catch (error) {
+      this.dbConnections.delete(key);
+      throw error;
+    }
+  }
+  /**
+   * Open database with automatic version detection and fallback
+   */
+  async openDBWithVersionFallback(dbName, preferredVersion, storeConfigs) {
+    try {
+      const db = await openDB(dbName);
+      const missingStores = storeConfigs.filter(
+        (config) => !db.objectStoreNames.contains(config.name)
+      );
+      if (missingStores.length === 0) {
+        return db;
+      }
+      db.close();
+      const currentVersion = db.version;
+      const newVersion = Math.max(currentVersion + 1, preferredVersion);
+      return await openDB(dbName, newVersion, {
+        upgrade(db2) {
+          storeConfigs.forEach((config) => {
+            if (!db2.objectStoreNames.contains(config.name)) {
+              db2.createObjectStore(config.name, config.keyPath ? { keyPath: config.keyPath } : void 0);
+            }
+          });
+        }
+      });
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        return await openDB(dbName, preferredVersion, {
+          upgrade(db) {
+            storeConfigs.forEach((config) => {
+              if (!db.objectStoreNames.contains(config.name)) {
+                db.createObjectStore(config.name, config.keyPath ? { keyPath: config.keyPath } : void 0);
+              }
+            });
+          }
+        });
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get a value from a specific store
+   */
+  async get(dbName, version, storeName, key, storeConfigs) {
+    try {
+      const db = await this.ensureDBWithStores(dbName, version, storeConfigs);
+      const value = await db.get(storeName, key);
+      return value;
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        console.warn(`Object store '${storeName}' not found in database '${dbName}'. Creating it...`);
+        const db = await this.ensureDBWithStores(dbName, version + 1, storeConfigs);
+        const fallbackValue = await db.get(storeName, key);
+        return fallbackValue;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Put a value into a specific store
+   */
+  async put(dbName, version, storeName, value, storeConfigs, key) {
+    try {
+      const db = await this.ensureDBWithStores(dbName, version, storeConfigs);
+      if (key !== void 0) {
+        await db.put(storeName, value, key);
+      } else {
+        await db.put(storeName, value);
+      }
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        console.warn(`Object store '${storeName}' not found in database '${dbName}'. Creating it...`);
+        const db = await this.ensureDBWithStores(dbName, version + 1, storeConfigs);
+        if (key !== void 0) {
+          await db.put(storeName, value, key);
+        } else {
+          await db.put(storeName, value);
+        }
+      } else {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Delete a value from a specific store
+   */
+  async delete(dbName, version, storeName, key, storeConfigs) {
+    try {
+      const db = await this.ensureDBWithStores(dbName, version, storeConfigs);
+      await db.delete(storeName, key);
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        console.warn(`Object store '${storeName}' not found in database '${dbName}'. Creating it...`);
+        const db = await this.ensureDBWithStores(dbName, version + 1, storeConfigs);
+        await db.delete(storeName, key);
+      } else {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Get all values from a specific store
+   */
+  async getAll(dbName, version, storeName, storeConfigs) {
+    try {
+      const db = await this.ensureDBWithStores(dbName, version, storeConfigs);
+      const values = await db.getAll(storeName);
+      return values;
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        console.warn(`Object store '${storeName}' not found in database '${dbName}'. Creating it...`);
+        const db = await this.ensureDBWithStores(dbName, version + 1, storeConfigs);
+        const fallbackValues = await db.getAll(storeName);
+        return fallbackValues;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Clear all values from a specific store
+   */
+  async clear(dbName, version, storeName, storeConfigs) {
+    try {
+      const db = await this.ensureDBWithStores(dbName, version, storeConfigs);
+      await db.clear(storeName);
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        console.warn(`Object store '${storeName}' not found in database '${dbName}'. Creating it...`);
+        const db = await this.ensureDBWithStores(dbName, version + 1, storeConfigs);
+        await db.clear(storeName);
+      } else {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Get all keys from a specific store
+   */
+  async getAllKeys(dbName, version, storeName, storeConfigs) {
+    try {
+      const db = await this.ensureDBWithStores(dbName, version, storeConfigs);
+      return db.getAllKeys(storeName);
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        console.warn(`Object store '${storeName}' not found in database '${dbName}'. Creating it...`);
+        const db = await this.ensureDBWithStores(dbName, version + 1, storeConfigs);
+        return db.getAllKeys(storeName);
+      }
+      throw error;
+    }
+  }
+};
+var indexedDBService = new IndexedDBService();
+var indexedDBService_default = indexedDBService;
+
+// src/store/packageSettingsStore.ts
+import { create } from "zustand";
+var usePackageSettingsStore = create((set, get) => ({
+  settings: null,
+  setSettings: (settings) => set({ settings }),
+  getSettings: () => get().settings,
+  resetSettings: () => set({ settings: null })
+}));
+
+// src/store/preferencesStore.ts
+import { create as create2 } from "zustand";
+var defaultPreferences = {
+  memoryEnabled: true,
+  knowledgeDocsEnabled: true,
+  moodEnabled: true,
+  chatSuggestionsEnabled: true,
+  ttsEnabled: true,
+  sttEnabled: true,
+  banditModelsEnabled: true,
+  feedbackEnabled: true,
+  homeUrl: ""
+};
+var sanitizePreferences = (preferences) => {
+  const {
+    advancedFeaturesEnabled: _deprecatedAdvanced,
+    advancedSearchEnabled: _deprecatedSearch,
+    advancedMemoriesEnabled: _deprecatedMemories,
+    ...rest
+  } = preferences;
+  return rest;
+};
+var usePreferencesStore = create2((set, get) => ({
+  preferences: defaultPreferences,
+  isLoaded: false,
+  setPreferences: (newPreferences) => {
+    const sanitized = sanitizePreferences(newPreferences);
+    set((state) => ({
+      preferences: { ...state.preferences, ...sanitized }
+    }));
+    get().savePreferences();
+  },
+  updatePreference: (key, value) => {
+    const prevValue = get().preferences[key];
+    const updates = { [key]: value };
+    set((state) => ({
+      preferences: { ...state.preferences, ...updates }
+    }));
+    get().savePreferences();
+    if (key === "banditModelsEnabled" && prevValue !== value) {
+      import("./modelStore-Y3LZWRQC.mjs").then(({ useModelStore: useModelStore2 }) => {
+        useModelStore2.getState().handleBanditPersonalitiesPreferenceChange(value);
+      });
+    }
+  },
+  loadPreferences: async () => {
+    try {
+      const storeConfigs = [{ name: "config", keyPath: "id" }];
+      const data = await indexedDBService_default.get("banditConfig", 1, "config", "preferences", storeConfigs);
+      if (data?.preferences) {
+        const sanitized = sanitizePreferences(data.preferences);
+        set({
+          preferences: { ...defaultPreferences, ...sanitized },
+          isLoaded: true
+        });
+        debugLogger.info("Preferences loaded from IndexedDB");
+      } else {
+        set({ isLoaded: true });
+        await get().savePreferences();
+        debugLogger.info("Default preferences initialized");
+      }
+    } catch (error) {
+      debugLogger.error("Failed to load preferences from IndexedDB", { error });
+      set({ isLoaded: true });
+    }
+  },
+  savePreferences: async () => {
+    try {
+      const { preferences } = get();
+      const storeConfigs = [{ name: "config", keyPath: "id" }];
+      await indexedDBService_default.put("banditConfig", 1, "config", {
+        id: "preferences",
+        preferences
+      }, storeConfigs);
+      debugLogger.debug("Preferences saved to IndexedDB");
+    } catch (error) {
+      debugLogger.error("Failed to save preferences to IndexedDB", { error });
+    }
+  },
+  exportPreferences: () => {
+    const { preferences } = get();
+    const exportData = {
+      version: "1.0",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      preferences
+    };
+    return JSON.stringify(exportData, null, 2);
+  },
+  importPreferences: async (jsonString) => {
+    try {
+      const importData = JSON.parse(jsonString);
+      if (!importData.preferences || typeof importData.preferences !== "object") {
+        debugLogger.error("Invalid preferences format");
+        return false;
+      }
+      const mergedPreferences = {
+        ...defaultPreferences,
+        ...sanitizePreferences(importData.preferences)
+      };
+      const validatedPreferences = {
+        memoryEnabled: typeof mergedPreferences.memoryEnabled === "boolean" ? mergedPreferences.memoryEnabled : defaultPreferences.memoryEnabled,
+        knowledgeDocsEnabled: typeof mergedPreferences.knowledgeDocsEnabled === "boolean" ? mergedPreferences.knowledgeDocsEnabled : defaultPreferences.knowledgeDocsEnabled,
+        moodEnabled: typeof mergedPreferences.moodEnabled === "boolean" ? mergedPreferences.moodEnabled : defaultPreferences.moodEnabled,
+        chatSuggestionsEnabled: typeof mergedPreferences.chatSuggestionsEnabled === "boolean" ? mergedPreferences.chatSuggestionsEnabled : defaultPreferences.chatSuggestionsEnabled,
+        ttsEnabled: typeof mergedPreferences.ttsEnabled === "boolean" ? mergedPreferences.ttsEnabled : defaultPreferences.ttsEnabled,
+        sttEnabled: typeof mergedPreferences.sttEnabled === "boolean" ? mergedPreferences.sttEnabled : defaultPreferences.sttEnabled,
+        banditModelsEnabled: typeof mergedPreferences.banditModelsEnabled === "boolean" ? mergedPreferences.banditModelsEnabled : defaultPreferences.banditModelsEnabled,
+        feedbackEnabled: typeof mergedPreferences.feedbackEnabled === "boolean" ? mergedPreferences.feedbackEnabled : defaultPreferences.feedbackEnabled,
+        homeUrl: typeof mergedPreferences.homeUrl === "string" ? mergedPreferences.homeUrl : defaultPreferences.homeUrl
+      };
+      set({ preferences: validatedPreferences });
+      await get().savePreferences();
+      debugLogger.info("Preferences imported successfully", { version: importData.version });
+      return true;
+    } catch (error) {
+      debugLogger.error("Failed to import preferences", { error });
+      return false;
+    }
+  },
+  resetToDefaults: async () => {
+    set({ preferences: { ...defaultPreferences } });
+    await get().savePreferences();
+    debugLogger.info("Preferences reset to defaults");
+  }
+}));
+
+// src/store/modelStore.ts
+var useModelStore = create3((set, get) => ({
+  name: "",
+  tagline: "",
+  systemPrompt: "",
+  commands: [],
+  avatarBase64: null,
+  availableModels: [],
+  selectedModel: "",
+  hasTransparentLogo: true,
+  isLoading: true,
+  isInitializing: false,
+  setIsLoading: (loading) => set({ isLoading: loading }),
+  setIsInitializing: (initializing) => set({ isInitializing: initializing }),
+  setModelName: (name) => set({ name }),
+  setTagline: (tagline) => set({ tagline }),
+  setSystemPrompt: (prompt) => set({ systemPrompt: prompt }),
+  setAvatarBase64: (value) => set({ avatarBase64: value }),
+  addCommand: (command) => set((state) => ({ commands: [...state.commands, command] })),
+  setSelectedModel: (modelName) => {
+    const selected = get().availableModels.find((m) => m.name === modelName);
+    if (selected) {
+      set({
+        selectedModel: modelName,
+        name: selected.name,
+        tagline: selected.tagline,
+        systemPrompt: selected.systemPrompt,
+        commands: selected.commands,
+        avatarBase64: selected.avatarBase64 ?? null
+      });
+    } else {
+      const availableModels = get().availableModels;
+      const firstModel = availableModels.length > 0 ? availableModels[0] : null;
+      if (firstModel) {
+        set({
+          selectedModel: firstModel.name,
+          name: firstModel.name,
+          tagline: firstModel.tagline,
+          systemPrompt: firstModel.systemPrompt,
+          commands: firstModel.commands,
+          avatarBase64: firstModel.avatarBase64 ?? null
+        });
+      }
+    }
+  },
+  saveModel: async () => {
+    const state = get();
+    const storeConfigs = [{ name: "config", keyPath: "id" }];
+    const newModel = {
+      name: state.name,
+      tagline: state.tagline,
+      systemPrompt: state.systemPrompt,
+      commands: state.commands,
+      avatarBase64: state.avatarBase64 ?? void 0
+    };
+    await indexedDBService_default.put("banditConfig", 1, "config", { id: newModel.name, model: newModel }, storeConfigs);
+    const exists = state.availableModels.find((m) => m.name === newModel.name);
+    if (!exists) {
+      set((prevState) => ({
+        availableModels: [...prevState.availableModels, newModel]
+      }));
+    } else {
+      set((prevState) => ({
+        availableModels: prevState.availableModels.map(
+          (m) => m.name === newModel.name ? newModel : m
+        )
+      }));
+    }
+  },
+  resetModel: () => set({ name: "", tagline: "", systemPrompt: "", commands: [] }),
+  getCurrentModel: () => get().availableModels.find((m) => m.name === get().selectedModel) || null,
+  initModels: async () => {
+    const currentState = get();
+    if (currentState.isInitializing) {
+      debugLogger.warn("initModels: Already initializing, skipping concurrent call");
+      return;
+    }
+    debugLogger.info("initModels: starting initialization");
+    set({ isLoading: true, isInitializing: true });
+    const storeConfigs = [{ name: "config", keyPath: "id" }];
+    const entries = await indexedDBService_default.getAll("banditConfig", 1, "config", storeConfigs);
+    const mainEntry = entries.find((entry) => entry.id === "main");
+    const modelEntries = entries.filter((entry) => entry.id !== "main" && entry.id !== "deletedModels");
+    const deletedEntry = await indexedDBService_default.get("banditConfig", 1, "config", "deletedModels", storeConfigs);
+    const deletedModelNames = deletedEntry?.deleted ?? [];
+    let allModels = [];
+    let selectedModel = "";
+    if (modelEntries.length > 0) {
+      debugLogger.info("Loading models from IndexedDB");
+      allModels = modelEntries.map((entry) => {
+        const modelData = entry.model?.name ? entry.model : entry;
+        return {
+          name: modelData.name,
+          tagline: modelData.tagline || "",
+          systemPrompt: modelData.systemPrompt || "",
+          commands: modelData.commands ?? [],
+          avatarBase64: modelData.avatarBase64 ?? null
+        };
+      }).filter((m) => m.name && !deletedModelNames.includes(m.name));
+      const preferences = usePreferencesStore.getState().preferences;
+      if (!preferences.banditModelsEnabled) {
+        const banditModelNames = models.map((m) => m.name);
+        allModels = allModels.filter((model) => !banditModelNames.includes(model.name));
+        debugLogger.info("Filtered out Bandit personalities (preference disabled)", {
+          filteredModels: banditModelNames
+        });
+      }
+      selectedModel = mainEntry?.model?.selectedModel || (allModels.length > 0 ? allModels[0].name : "");
+      debugLogger.info("Loaded models from IndexedDB:", { models: allModels.map((m) => m.name), selectedModel });
+      if (allModels.length === 0) {
+        debugLogger.info("No personalities remain after filtering deleted models, checking CDN config");
+      }
+    }
+    if (modelEntries.length === 0 || allModels.length === 0) {
+      debugLogger.info("No models in IndexedDB, checking CDN config");
+      const packageSettings = usePackageSettingsStore.getState().getSettings();
+      let configModels = null;
+      if (packageSettings?.brandingConfigUrl) {
+        try {
+          const response = await fetch(packageSettings.brandingConfigUrl);
+          configModels = await response.json();
+        } catch (err) {
+          debugLogger.warn("Failed to load CDN config:", { error: err });
+        }
+      }
+      if (configModels?.models?.length) {
+        debugLogger.info("Loading models from CDN config");
+        allModels = configModels.models.filter((m) => !deletedModelNames.includes(m.name));
+        const preferences = usePreferencesStore.getState().preferences;
+        if (preferences.banditModelsEnabled) {
+          const cdnModelNames = allModels.map((m) => m.name);
+          const banditModelsToAdd = models.filter(
+            (banditModel) => !cdnModelNames.includes(banditModel.name) && !deletedModelNames.includes(banditModel.name)
+          );
+          allModels = [...allModels, ...banditModelsToAdd];
+          debugLogger.info("Added Bandit default personalities to CDN models", {
+            banditModels: banditModelsToAdd.map((m) => m.name)
+          });
+        } else {
+          const banditModelNames = models.map((m) => m.name);
+          allModels = allModels.filter((model) => !banditModelNames.includes(model.name));
+          debugLogger.info("Filtered out Bandit personalities from CDN config (preference disabled)", {
+            banditModels: banditModelNames
+          });
+        }
+        selectedModel = allModels.length > 0 ? allModels[0].name : "";
+        const existingConfig = await indexedDBService_default.get("banditConfig", 1, "config", "main", storeConfigs);
+        const hasUserBranding = existingConfig?.branding?.userSaved;
+        if (!hasUserBranding) {
+          set({ hasTransparentLogo: configModels?.branding?.hasTransparentLogo ?? true });
+          debugLogger.info("Set hasTransparentLogo from CDN config (no user branding)");
+        } else {
+          debugLogger.info("Preserved user hasTransparentLogo setting (user branding exists)");
+        }
+        for (const model of allModels) {
+          await indexedDBService_default.put("banditConfig", 1, "config", { id: model.name, model }, storeConfigs);
+        }
+        debugLogger.info("Loaded and saved models from CDN config:", { models: allModels.map((m) => m.name) });
+      } else {
+        const preferences = usePreferencesStore.getState().preferences;
+        if (preferences.banditModelsEnabled) {
+          debugLogger.info("No CDN config available, loading Bandit defaults");
+          await get().restoreDefaultModels();
+          set({ isLoading: false, isInitializing: false });
+          return;
+        } else {
+          debugLogger.info("No CDN config available and Bandit personalities disabled, loading empty model list");
+          allModels = [];
+          selectedModel = "";
+        }
+      }
+    }
+    set({ availableModels: allModels });
+    debugLogger.info("Setting selected model:", { selectedModel });
+    get().setSelectedModel(selectedModel);
+    debugLogger.info("Model initialization complete");
+    set({ isLoading: false, isInitializing: false });
+  },
+  setHasTransparentLogo: (value) => set({ hasTransparentLogo: value }),
+  restoreDefaultModels: async () => {
+    debugLogger.debug("\u{1F9EA} Restoring default models...");
+    set({ isLoading: true });
+    const storeConfigs = [{ name: "config", keyPath: "id" }];
+    set({ availableModels: [] });
+    try {
+      await indexedDBService_default.delete("banditConfig", 1, "config", "deletedModels", storeConfigs);
+      debugLogger.info("restoreDefaultModels: Cleared deletedModels entry in IndexedDB");
+    } catch (err) {
+      debugLogger.warn("restoreDefaultModels: Failed to clear deletedModels entry in IndexedDB", { error: err });
+    }
+    let allModels = [];
+    let selectedModel = "";
+    const packageSettings = usePackageSettingsStore.getState().getSettings();
+    let configModels = null;
+    if (packageSettings?.brandingConfigUrl) {
+      debugLogger.debug("\u{1F517} Attempting to load default models from CDN config...");
+      try {
+        const response = await fetch(packageSettings.brandingConfigUrl);
+        configModels = await response.json();
+      } catch (err) {
+        debugLogger.warn("Failed to load CDN config:", { error: err });
+      }
+    }
+    if (configModels?.models?.length) {
+      allModels = configModels.models;
+      const preferences = usePreferencesStore.getState().preferences;
+      if (preferences.banditModelsEnabled) {
+        const cdnModelNames = allModels.map((m) => m.name);
+        const banditModelsToAdd = models.filter(
+          (banditModel) => !cdnModelNames.includes(banditModel.name)
+        );
+        allModels = [...allModels, ...banditModelsToAdd];
+        debugLogger.info("restoreDefaultModels: Added Bandit personalities to CDN config", {
+          banditModels: banditModelsToAdd.map((m) => m.name)
+        });
+      } else {
+        const banditModelNames = models.map((m) => m.name);
+        allModels = allModels.filter((model) => !banditModelNames.includes(model.name));
+        debugLogger.info("restoreDefaultModels: Filtered out Bandit personalities (preference disabled)", {
+          banditModels: banditModelNames
+        });
+      }
+      selectedModel = allModels.length > 0 ? allModels[0].name : "";
+      try {
+        const existingConfig = await indexedDBService_default.get("banditConfig", 1, "config", "main", storeConfigs);
+        const hasUserBranding = existingConfig?.branding?.userSaved;
+        if (!hasUserBranding) {
+          set({ hasTransparentLogo: configModels?.branding?.hasTransparentLogo ?? true });
+          debugLogger.info("restoreDefaultModels: Set hasTransparentLogo from CDN config (no user branding)");
+        } else {
+          debugLogger.info("restoreDefaultModels: Preserved user hasTransparentLogo setting (user branding exists)");
+        }
+      } catch (err) {
+        set({ hasTransparentLogo: configModels?.branding?.hasTransparentLogo ?? true });
+        debugLogger.warn("restoreDefaultModels: Using CDN hasTransparentLogo as fallback", { error: err });
+      }
+      debugLogger.info("\u2705 Using default models from CDN config:", { models: allModels.map((m) => m.name) });
+    } else {
+      const preferences = usePreferencesStore.getState().preferences;
+      if (preferences.banditModelsEnabled) {
+        allModels = models;
+        selectedModel = allModels.length > 0 ? allModels[0].name : "";
+        debugLogger.info("\u2705 Using built-in default Bandit personalities:", { models: allModels.map((m) => m.name) });
+      } else {
+        allModels = [];
+        selectedModel = "";
+        debugLogger.info("\u2705 Bandit personalities disabled, using empty model list");
+      }
+    }
+    for (const model of allModels) {
+      await indexedDBService_default.put("banditConfig", 1, "config", {
+        id: model.name,
+        model
+      }, storeConfigs);
+    }
+    set({ availableModels: allModels });
+    debugLogger.debug("\u{1F3AF} Setting default selected model:", { model: selectedModel });
+    get().setSelectedModel(selectedModel);
+    debugLogger.debug("\u2705 Default models restored and persisted to IndexedDB");
+    set({ isLoading: false });
+  },
+  restoreDeletedBanditModels: async () => {
+    debugLogger.debug("\u{1F504} Restoring deleted Bandit personalities...");
+    set({ isLoading: true });
+    const storeConfigs = [{ name: "config", keyPath: "id" }];
+    try {
+      const deletedEntry = await indexedDBService_default.get("banditConfig", 1, "config", "deletedModels", storeConfigs);
+      const deletedModelNames = deletedEntry?.deleted ?? [];
+      debugLogger.info("Current deleted models:", { deletedModelNames });
+      const deletedBanditModels = models.filter(
+        (banditModel) => deletedModelNames.includes(banditModel.name)
+      );
+      debugLogger.info("Deleted Bandit personalities found:", {
+        deletedBanditModels: deletedBanditModels.map((m) => m.name)
+      });
+      if (deletedBanditModels.length === 0) {
+        debugLogger.info("No deleted Bandit personalities to restore");
+        set({ isLoading: false });
+        return { restored: [], hadNothingToRestore: true };
+      }
+      const updatedDeletedNames = deletedModelNames.filter(
+        (name) => !models.some((banditModel) => banditModel.name === name)
+      );
+      debugLogger.info("Updated deleted list after removing Bandit personalities:", {
+        updatedDeletedNames
+      });
+      if (updatedDeletedNames.length > 0) {
+        await indexedDBService_default.put("banditConfig", 1, "config", {
+          id: "deletedModels",
+          deleted: updatedDeletedNames
+        }, storeConfigs);
+        debugLogger.info("Updated deletedModels in IndexedDB");
+      } else {
+        await indexedDBService_default.delete("banditConfig", 1, "config", "deletedModels", storeConfigs);
+        debugLogger.info("Removed deletedModels entry from IndexedDB (empty list)");
+      }
+      const preferences = usePreferencesStore.getState().preferences;
+      debugLogger.info("Bandit personalities preference enabled:", { enabled: preferences.banditModelsEnabled });
+      if (!preferences.banditModelsEnabled) {
+        debugLogger.info("\u26A0\uFE0F Bandit personalities preference is disabled. Personalities restored from deleted list but not added to available models until preference is enabled.");
+        set({ isLoading: false });
+        return { restored: deletedBanditModels.map((m) => m.name), hadNothingToRestore: false };
+      }
+      const currentModels = get().availableModels;
+      debugLogger.info("Current available models:", {
+        currentModels: currentModels.map((m) => m.name)
+      });
+      const restoredModels = deletedBanditModels.filter(
+        (banditModel) => !currentModels.some((current) => current.name === banditModel.name)
+      );
+      debugLogger.info("Models to restore:", {
+        restoredModels: restoredModels.map((m) => m.name)
+      });
+      if (restoredModels.length === 0) {
+        debugLogger.info("No new models to add (all restored models already present)");
+        set({ isLoading: false });
+        return { restored: [], hadNothingToRestore: true };
+      }
+      for (const model of restoredModels) {
+        await indexedDBService_default.put("banditConfig", 1, "config", {
+          id: model.name,
+          model
+        }, storeConfigs);
+        debugLogger.info("Persisted restored model to IndexedDB:", { modelName: model.name });
+      }
+      const updatedAvailableModels = [...currentModels, ...restoredModels];
+      set({ availableModels: updatedAvailableModels });
+      debugLogger.info("\u2705 Restored deleted Bandit personalities:", {
+        restoredModels: restoredModels.map((m) => m.name),
+        totalModels: updatedAvailableModels.length
+      });
+      const currentSelectedModel = get().selectedModel;
+      if (!currentSelectedModel && updatedAvailableModels.length > 0) {
+        const modelToSelect = restoredModels[0] || updatedAvailableModels[0];
+        get().setSelectedModel(modelToSelect.name);
+        debugLogger.info("Auto-selected model after restore:", { modelName: modelToSelect.name });
+      }
+      return { restored: restoredModels.map((m) => m.name), hadNothingToRestore: false };
+    } catch (error) {
+      debugLogger.error("Failed to restore deleted Bandit personalities", { error });
+      throw error;
+    } finally {
+      set({ isLoading: false });
+    }
+  },
+  handleBanditPersonalitiesPreferenceChange: async (enabled) => {
+    debugLogger.info("\u{1F504} Handling Bandit personalities preference change", { enabled });
+    const currentModels = get().availableModels;
+    const banditModelNames = models.map((m) => m.name);
+    if (enabled) {
+      const storeConfigs = [{ name: "config", keyPath: "id" }];
+      const deletedEntry = await indexedDBService_default.get("banditConfig", 1, "config", "deletedModels", storeConfigs);
+      const deletedModelNames = deletedEntry?.deleted ?? [];
+      const modelsToAdd = models.filter(
+        (banditModel) => !currentModels.some((current) => current.name === banditModel.name) && !deletedModelNames.includes(banditModel.name)
+      );
+      if (modelsToAdd.length > 0) {
+        for (const model of modelsToAdd) {
+          await indexedDBService_default.put("banditConfig", 1, "config", {
+            id: model.name,
+            model
+          }, storeConfigs);
+        }
+        const updatedModels = [...currentModels, ...modelsToAdd];
+        set({ availableModels: updatedModels });
+        debugLogger.info("\u2705 Added Bandit personalities", {
+          addedModels: modelsToAdd.map((m) => m.name)
+        });
+        const currentSelectedModel = get().selectedModel;
+        if (!currentSelectedModel && updatedModels.length > 0) {
+          get().setSelectedModel(updatedModels[0].name);
+        }
+      }
+    } else {
+      const filteredModels = currentModels.filter((model) => !banditModelNames.includes(model.name));
+      set({ availableModels: filteredModels });
+      debugLogger.info("\u2705 Removed Bandit personalities", {
+        removedModels: banditModelNames.filter(
+          (name) => currentModels.some((model) => model.name === name)
+        )
+      });
+      const currentSelectedModel = get().selectedModel;
+      if (currentSelectedModel && banditModelNames.includes(currentSelectedModel)) {
+        const newSelectedModel = filteredModels.length > 0 ? filteredModels[0].name : "";
+        get().setSelectedModel(newSelectedModel);
+        debugLogger.info("\u{1F504} Changed selected model after removing Bandit personalities", {
+          oldModel: currentSelectedModel,
+          newModel: newSelectedModel
+        });
+      }
+    }
+  }
+}));
+
+export {
+  usePackageSettingsStore,
+  indexedDBService_default,
+  models,
+  usePreferencesStore,
+  useModelStore
+};
+//# sourceMappingURL=chunk-WYS5CZVG.mjs.map