@burtson-labs/bandit-engine 2.0.39 → 2.0.41

package/dist/chat-provider.js

@@ -12,11 +12,11 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from7, except, desc) => {
-  if (from7 && typeof from7 === "object" || typeof from7 === "function") {
-    for (let key of __getOwnPropNames(from7))
+var __copyProps = (to, from8, except, desc) => {
+  if (from8 && typeof from8 === "object" || typeof from8 === "function") {
+    for (let key of __getOwnPropNames(from8))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from7[key], enumerable: !(desc = __getOwnPropDesc(from7, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from8[key], enumerable: !(desc = __getOwnPropDesc(from8, key)) || desc.enumerable });
   }
   return to;
 };
@@ -2222,57 +2222,15 @@ var init_gateway_service = __esm({
        */
       chat(request) {
         const endpoint = request.provider === "ollama" ? `/api/${request.provider}/chat` : request.provider ? `/api/${request.provider}/chat/completions` : "/api/chat/completions";
-        const url = `${this._baseUrl}${endpoint}`;
-        debugLogger.debug(`Gateway chat request to ${url} with provider: ${request.provider || "default"}`, {
-          model: request.model,
-          messageCount: request.messages.length,
-          hasImages: !!(request.images && request.images.length > 0),
-          imageCount: request.images?.length || 0
-        });
-        const requestBody = { ...request, stream: request.stream !== false };
+        const fallbackEndpoint = request.provider === "bandit" ? "/completions" : null;
+        const normalizedModel = request.provider === "bandit" ? (() => {
+          const trimmed = (request.model ?? "").replace(/^bandit:/, "").trim();
+          return trimmed !== "" ? trimmed : "bandit-core-1";
+        })() : request.model;
+        const requestBody = { ...request, model: normalizedModel, stream: request.stream !== false };
         return new import_rxjs6.Observable((observer) => {
           const controller = new AbortController();
-          const task = fetch(url, {
-            method: "POST",
-            headers: this._getHeaders(),
-            body: JSON.stringify(requestBody),
-            signal: controller.signal
-          });
-          task.then(async (response) => {
-            debugLogger.debug(`Gateway chat response status: ${response.status} for provider: ${request.provider || "default"}`);
-            if (!response.ok) {
-              let errorText = "";
-              let errorData = null;
-              try {
-                errorText = await response.text();
-                debugLogger.error("GatewayService chat error response body", {
-                  status: response.status,
-                  statusText: response.statusText,
-                  url: response.url,
-                  body: errorText
-                });
-              } catch (readError) {
-                debugLogger.error("GatewayService chat failed to read error response body", { error: readError });
-                errorText = `Request failed with status ${response.status}`;
-              }
-              try {
-                errorData = JSON.parse(errorText);
-                debugLogger.error("GatewayService chat parsed error payload", errorData);
-              } catch (parseError) {
-                debugLogger.error("GatewayService chat error payload was not valid JSON");
-                errorData = { message: errorText };
-              }
-              const error = this._createHttpError(
-                `POST ${url} failed: ${response.status} ${response.statusText ?? ""}`,
-                {
-                  status: response.status,
-                  statusText: response.statusText ?? "",
-                  data: errorData,
-                  url
-                }
-              );
-              throw error;
-            }
+          const handleStreamingResponse = async (response) => {
             const reader = response.body?.getReader();
             const decoder = new TextDecoder();
             let buffer = "";
@@ -2347,14 +2305,75 @@ var init_gateway_service = __esm({
               }).catch((err) => observer.error(err));
             };
             read();
-          }).catch((err) => {
-            debugLogger.error("GatewayService chat fetch error", {
-              error: err,
-              url,
-              provider: request.provider
+          };
+          const sendRequest = (targetEndpoint, allowFallback) => {
+            const url = `${this._baseUrl}${targetEndpoint}`;
+            debugLogger.debug(`Gateway chat request to ${url} with provider: ${request.provider || "default"}`, {
+              model: normalizedModel,
+              messageCount: request.messages.length,
+              hasImages: !!(request.images && request.images.length > 0),
+              imageCount: request.images?.length || 0
             });
-            observer.error(err);
-          });
+            fetch(url, {
+              method: "POST",
+              headers: this._getHeaders(),
+              body: JSON.stringify(requestBody),
+              signal: controller.signal
+            }).then(async (response) => {
+              debugLogger.debug(`Gateway chat response status: ${response.status} for provider: ${request.provider || "default"}`);
+              if (response.status === 404 && allowFallback && fallbackEndpoint) {
+                debugLogger.warn("GatewayService chat endpoint returned 404, attempting fallback route", {
+                  provider: request.provider,
+                  attemptedEndpoint: targetEndpoint,
+                  fallbackEndpoint
+                });
+                sendRequest(fallbackEndpoint, false);
+                return;
+              }
+              if (!response.ok) {
+                let errorText = "";
+                let errorData = null;
+                try {
+                  errorText = await response.text();
+                  debugLogger.error("GatewayService chat error response body", {
+                    status: response.status,
+                    statusText: response.statusText,
+                    url: response.url,
+                    body: errorText
+                  });
+                } catch (readError) {
+                  debugLogger.error("GatewayService chat failed to read error response body", { error: readError });
+                  errorText = `Request failed with status ${response.status}`;
+                }
+                try {
+                  errorData = JSON.parse(errorText);
+                  debugLogger.error("GatewayService chat parsed error payload", errorData);
+                } catch (parseError) {
+                  debugLogger.error("GatewayService chat error payload was not valid JSON");
+                  errorData = { message: errorText };
+                }
+                const error = this._createHttpError(
+                  `POST ${url} failed: ${response.status} ${response.statusText ?? ""}`,
+                  {
+                    status: response.status,
+                    statusText: response.statusText ?? "",
+                    data: errorData,
+                    url
+                  }
+                );
+                throw error;
+              }
+              await handleStreamingResponse(response);
+            }).catch((err) => {
+              debugLogger.error("GatewayService chat fetch error", {
+                error: err,
+                url,
+                provider: request.provider
+              });
+              observer.error(err);
+            });
+          };
+          sendRequest(endpoint, true);
           return () => {
             try {
               controller.abort();
@@ -2369,12 +2388,18 @@ var init_gateway_service = __esm({
       generate(request) {
         const endpoint = request.provider ? `/api/${request.provider}/generate` : "/api/generate";
         const url = `${this._baseUrl}${endpoint}`;
-        debugLogger.debug(`Gateway generate request to ${url} with provider: ${request.provider || "default"}`);
+        const normalizedModel = request.provider === "bandit" ? (() => {
+          const trimmed = (request.model ?? "").replace(/^bandit:/, "").trim();
+          return trimmed !== "" ? trimmed : "bandit-core-1";
+        })() : request.model;
+        debugLogger.debug(`Gateway generate request to ${url} with provider: ${request.provider || "default"}`, {
+          model: normalizedModel
+        });
         return new import_rxjs6.Observable((observer) => {
           const task = fetch(url, {
             method: "POST",
             headers: this._getHeaders(),
-            body: JSON.stringify({ ...request, stream: request.stream !== false })
+            body: JSON.stringify({ ...request, model: normalizedModel, stream: request.stream !== false })
           });
           task.then(async (response) => {
             if (!response.ok) {
@@ -2481,18 +2506,46 @@ var init_gateway_service = __esm({
         );
       }
       _getHeaders() {
-        const token = this._tokenFactory();
+        const rawToken2 = this._tokenFactory();
         const headers = {
           "Content-Type": "application/json"
         };
-        if (token && token.trim() !== "") {
-          headers["Authorization"] = `Bearer ${token}`;
-          debugLogger.debug("Authorization header set with token");
-        } else {
+        if (!rawToken2) {
           debugLogger.warn("GatewayService: No token found, skipping Authorization header");
+          return headers;
+        }
+        const token = rawToken2.trim();
+        if (token === "") {
+          debugLogger.warn("GatewayService: Token factory returned empty string");
+          return headers;
+        }
+        if (/^(Bearer|ApiKey)\s+/i.test(token)) {
+          headers["Authorization"] = token;
+          debugLogger.debug("GatewayService: Authorization header set with explicit scheme");
+          return headers;
+        }
+        if (this._isLikelyBanditApiKey(token)) {
+          headers["Authorization"] = `ApiKey ${token}`;
+          headers["X-Burtson-Api-Key"] = token;
+          debugLogger.debug("GatewayService: Authorization header set using API key");
+          return headers;
         }
+        if (this._isLikelyJwt(token)) {
+          headers["Authorization"] = `Bearer ${token}`;
+          debugLogger.debug("GatewayService: Authorization header set using bearer token");
+          return headers;
+        }
+        headers["Authorization"] = `Bearer ${token}`;
+        debugLogger.debug("GatewayService: Authorization header defaulted to bearer scheme");
         return headers;
       }
+      _isLikelyJwt(token) {
+        const segments = token.split(".");
+        return segments.length === 3 && segments.every((segment) => segment.length > 0);
+      }
+      _isLikelyBanditApiKey(value) {
+        return /^bai_[a-z0-9]{10,}$/i.test(value);
+      }
       /**
        * Submit feedback to the gateway API
        */
@@ -2972,6 +3025,112 @@ var init_ollama_gateway_service = __esm({
   }
 });
 
+// src/services/gateway/bandit-gateway.service.ts
+var import_operators5, normalizeBanditModel, isGatewayMessageContent, normalizeBanditMessages, BanditAIGatewayService;
+var init_bandit_gateway_service = __esm({
+  "src/services/gateway/bandit-gateway.service.ts"() {
+    "use strict";
+    init_gateway_service();
+    import_operators5 = require("rxjs/operators");
+    init_debugLogger();
+    normalizeBanditModel = (model) => {
+      if (typeof model !== "string" || model.trim() === "") {
+        return "bandit-core-1";
+      }
+      const normalized = model.replace(/^bandit:/, "").trim();
+      return normalized === "" ? "bandit-core-1" : normalized;
+    };
+    isGatewayMessageContent = (value) => {
+      if (!value || typeof value !== "object") return false;
+      const candidate = value;
+      if (candidate.type !== "text" && candidate.type !== "image_url") {
+        return false;
+      }
+      if (candidate.type === "text") {
+        return typeof candidate.text === "string";
+      }
+      if (candidate.type === "image_url") {
+        return !!candidate.image_url && typeof candidate.image_url.url === "string";
+      }
+      return false;
+    };
+    normalizeBanditMessages = (messages) => messages.map((message) => {
+      const content = message.content;
+      if (typeof content === "string") {
+        return { role: message.role, content };
+      }
+      if (Array.isArray(content)) {
+        const filtered = content.filter(isGatewayMessageContent);
+        if (filtered.length === 0) {
+          return { role: message.role, content: JSON.stringify(content) };
+        }
+        return {
+          role: message.role,
+          content: filtered
+        };
+      }
+      return { role: message.role, content: content != null ? String(content) : "" };
+    });
+    BanditAIGatewayService = class {
+      _gatewayService;
+      constructor(gatewayUrl, tokenFactory) {
+        this._gatewayService = new GatewayService(gatewayUrl, tokenFactory);
+        debugLogger.info("BanditAIGatewayService initialized", { gatewayUrl });
+      }
+      async validateServiceAvailability(args) {
+        return this._gatewayService.validateServiceAvailability(args);
+      }
+      chat(request) {
+        const model = normalizeBanditModel(request.model);
+        const messages = normalizeBanditMessages(request.messages);
+        const gatewayRequest = {
+          ...request,
+          messages,
+          model,
+          provider: "bandit",
+          stream: request.stream
+        };
+        debugLogger.debug("Bandit Gateway chat request", {
+          model,
+          messageCount: request.messages.length,
+          stream: request.stream
+        });
+        return this._gatewayService.chat(gatewayRequest);
+      }
+      complete(prompt, options) {
+        const model = normalizeBanditModel(options.model);
+        const gatewayRequest = {
+          model,
+          prompt,
+          temperature: options.temperature,
+          max_tokens: options.max_tokens,
+          stream: options.stream,
+          stop: options.stop,
+          provider: "bandit"
+        };
+        debugLogger.debug("Bandit Gateway generate request", {
+          model,
+          promptLength: prompt.length,
+          stream: options.stream
+        });
+        return this._gatewayService.generate(gatewayRequest);
+      }
+      listModels() {
+        debugLogger.debug("Fetching Bandit models through gateway");
+        return this._gatewayService.listModelsByProvider("bandit");
+      }
+      getHealth() {
+        return this._gatewayService.getHealth().pipe(
+          (0, import_operators5.map)((health) => ({
+            ...health,
+            bandit_status: health.providers.find((p) => p.name === "bandit")?.status || "unavailable"
+          }))
+        );
+      }
+    };
+  }
+});
+
 // src/services/ai-provider/providers/gateway.provider.ts
 var import_rxjs7, GatewayProvider;
 var init_gateway_provider = __esm({
@@ -2985,6 +3144,7 @@ var init_gateway_provider = __esm({
     init_azure_openai_gateway_service();
     init_anthropic_gateway_service();
     init_ollama_gateway_service();
+    init_bandit_gateway_service();
     GatewayProvider = class {
       config;
       gatewayService;
@@ -3026,6 +3186,9 @@ var init_gateway_provider = __esm({
           case "anthropic":
             this.providerSpecificService = new AnthropicGatewayService(gatewayUrl, tokenFactory);
             break;
+          case "bandit":
+            this.providerSpecificService = new BanditAIGatewayService(gatewayUrl, tokenFactory);
+            break;
           case "ollama":
             this.providerSpecificService = new OllamaGatewayService(gatewayUrl, tokenFactory);
             break;
@@ -3040,6 +3203,16 @@ var init_gateway_provider = __esm({
           role: msg.role,
           content: msg.content
         }));
+        const normalizeImageUrl2 = (value) => {
+          if (!value) {
+            return value;
+          }
+          const trimmed = value.trim();
+          if (/^data:/i.test(trimmed) || /^https?:\/\//i.test(trimmed)) {
+            return trimmed;
+          }
+          return `data:image/jpeg;base64,${trimmed}`;
+        };
         if (request.images && request.images.length > 0) {
           const lastUserMessageIndex = messages.map((m) => m.role).lastIndexOf("user");
           if (this.config.provider === "ollama") {
@@ -3049,7 +3222,7 @@ var init_gateway_provider = __esm({
                 images: request.images
               };
             }
-          } else if (["openai", "azure-openai", "anthropic"].includes(this.config.provider || "")) {
+          } else if (["openai", "azure-openai", "anthropic", "bandit"].includes(this.config.provider || "")) {
             if (lastUserMessageIndex !== -1) {
               const currentMessage = messages[lastUserMessageIndex];
               const contentArray = [
@@ -3058,11 +3231,11 @@ var init_gateway_provider = __esm({
                   text: currentMessage.content
                 }
               ];
-              request.images.forEach((base64Image) => {
+              request.images.forEach((imageRef) => {
                 contentArray.push({
                   type: "image_url",
                   image_url: {
-                    url: base64Image.startsWith("data:") ? base64Image : `data:image/jpeg;base64,${base64Image}`,
+                    url: normalizeImageUrl2(imageRef),
                     detail: "auto"
                   }
                 });
@@ -3071,6 +3244,11 @@ var init_gateway_provider = __esm({
                 ...messages[lastUserMessageIndex],
                 content: contentArray
               };
+              debugLogger.debug("Gateway provider injected image attachments", {
+                provider: this.config.provider,
+                imageCount: request.images.length,
+                messageIndex: lastUserMessageIndex
+              });
             }
           }
         }
@@ -3579,6 +3757,244 @@ var init_xai_provider = __esm({
   }
 });
 
+// src/services/ai-provider/providers/bandit-ai.provider.ts
+var import_rxjs10, DEFAULT_BANDIT_BASE, normalizeImageUrl, injectImagesIntoMessages, BanditAIProvider;
+var init_bandit_ai_provider = __esm({
+  "src/services/ai-provider/providers/bandit-ai.provider.ts"() {
+    "use strict";
+    import_rxjs10 = require("rxjs");
+    init_common_types();
+    init_debugLogger();
+    DEFAULT_BANDIT_BASE = "https://api.burtson.ai";
+    normalizeImageUrl = (value) => {
+      if (!value) {
+        return null;
+      }
+      const trimmed = value.trim();
+      if (!trimmed) {
+        return null;
+      }
+      if (/^data:/i.test(trimmed) || /^https?:\/\//i.test(trimmed)) {
+        return trimmed;
+      }
+      return `data:image/jpeg;base64,${trimmed}`;
+    };
+    injectImagesIntoMessages = (messages, images) => {
+      const normalized = messages.map((message) => ({
+        role: message.role,
+        content: message.content
+      }));
+      if (!images || images.length === 0) {
+        return normalized;
+      }
+      const normalizedImages = images.map(normalizeImageUrl).filter((url) => Boolean(url));
+      if (normalizedImages.length === 0) {
+        return normalized;
+      }
+      const lastUserIndex = normalized.map((msg) => msg.role).lastIndexOf("user");
+      if (lastUserIndex === -1) {
+        return normalized;
+      }
+      const target = normalized[lastUserIndex];
+      const baseContent = typeof target.content === "string" && target.content.trim().length > 0 ? [
+        {
+          type: "text",
+          text: target.content
+        }
+      ] : [];
+      const imageContent = normalizedImages.map((url) => ({
+        type: "image_url",
+        image_url: { url, detail: "auto" }
+      }));
+      normalized[lastUserIndex] = {
+        role: target.role,
+        content: [...baseContent, ...imageContent]
+      };
+      return normalized;
+    };
+    BanditAIProvider = class {
+      config;
+      baseUrl;
+      constructor(config) {
+        this.config = config;
+        this.baseUrl = (config.baseUrl || DEFAULT_BANDIT_BASE).replace(/\/$/, "");
+      }
+      chat(request) {
+        const url = `${this.baseUrl}/chat/completions`;
+        const messages = injectImagesIntoMessages(request.messages, request.images);
+        const payload = {
+          model: request.model,
+          messages,
+          stream: Boolean(request.stream),
+          temperature: request.temperature,
+          max_tokens: request.maxTokens
+        };
+        if (request.stream) {
+          return this.streamChatRequest(url, payload);
+        }
+        return this.nonStreamChatRequest(url, payload);
+      }
+      generate(request) {
+        const chatRequest = {
+          model: request.model,
+          messages: [{ role: "user", content: request.prompt }],
+          stream: request.stream,
+          options: request.options
+        };
+        return this.chat(chatRequest).pipe(
+          (0, import_rxjs10.map)((response) => ({
+            response: response.message.content,
+            done: response.done
+          }))
+        );
+      }
+      listModels() {
+        const url = `${this.baseUrl}/models`;
+        return (0, import_rxjs10.from)(fetch(url, { headers: this.getHeaders() })).pipe(
+          (0, import_rxjs10.switchMap)((response) => {
+            if (!response.ok) {
+              debugLogger.error("BanditAI listModels failed", { status: response.status, url });
+              return (0, import_rxjs10.throwError)(() => new Error(`Failed to list Bandit models: ${response.status}`));
+            }
+            return (0, import_rxjs10.from)(response.json());
+          }),
+          (0, import_rxjs10.map)(
+            (data) => data.data.map((model) => ({
+              name: model.id,
+              details: {
+                format: "bandit",
+                family: model.object
+              }
+            }))
+          )
+        );
+      }
+      async validateServiceAvailability(args) {
+        const attempt = async (url) => {
+          try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), args.timeoutMs);
+            const response = await fetch(`${url}/models`, {
+              headers: this.getHeaders(),
+              signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            return response.ok;
+          } catch (error) {
+            debugLogger.warn("BanditAI availability check failed", { url, error });
+            return false;
+          }
+        };
+        const primary = await attempt(this.baseUrl);
+        if (primary) {
+          return { url: this.baseUrl, isAvailable: true };
+        }
+        if (args.fallbackUrl) {
+          const fallback = args.fallbackUrl.replace(/\/$/, "");
+          if (await attempt(fallback)) {
+            this.baseUrl = fallback;
+            return { url: fallback, isAvailable: true };
+          }
+        }
+        return { url: this.baseUrl, isAvailable: false };
+      }
+      getProviderType() {
+        return "bandit" /* BANDIT */;
+      }
+      getConfig() {
+        return this.config;
+      }
+      streamChatRequest(url, payload) {
+        return new import_rxjs10.Observable((observer) => {
+          const task = fetch(url, {
+            method: "POST",
+            headers: {
+              ...this.getHeaders(),
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify(payload)
+          });
+          task.then((response) => {
+            if (!response.ok) {
+              observer.error(new Error(`BanditAI request failed: ${response.status}`));
+              return;
+            }
+            const reader = response.body?.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            const read = () => {
+              reader?.read().then(({ done, value }) => {
+                if (done) {
+                  observer.next({ message: { content: "", role: "assistant" }, done: true });
+                  observer.complete();
+                  return;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const rawLine of lines) {
+                  const line = rawLine.trim();
+                  if (!line.startsWith("data: ")) {
+                    continue;
+                  }
+                  const data = line.slice(6).trim();
+                  if (data === "[DONE]") {
+                    observer.next({ message: { content: "", role: "assistant" }, done: true });
+                    observer.complete();
+                    return;
+                  }
+                  try {
+                    const parsed = JSON.parse(data);
+                    const content = parsed.choices?.[0]?.delta?.content ?? "";
+                    if (content) {
+                      observer.next({ message: { content, role: "assistant" }, done: false });
+                    }
+                  } catch (error) {
+                    debugLogger.error("BanditAI stream chunk parse failure", { data, error });
+                  }
+                }
+                read();
+              }).catch((err) => observer.error(err));
+            };
+            read();
+          }).catch((err) => observer.error(err));
+        });
+      }
+      nonStreamChatRequest(url, payload) {
+        return (0, import_rxjs10.from)(fetch(url, {
+          method: "POST",
+          headers: {
+            ...this.getHeaders(),
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(payload)
+        })).pipe(
+          (0, import_rxjs10.switchMap)((response) => {
+            if (!response.ok) {
+              return (0, import_rxjs10.throwError)(() => new Error(`BanditAI request failed: ${response.status}`));
+            }
+            return (0, import_rxjs10.from)(response.json());
+          }),
+          (0, import_rxjs10.map)((data) => ({
+            message: {
+              content: data.choices?.[0]?.message?.content ?? "",
+              role: "assistant"
+            },
+            done: true
+          }))
+        );
+      }
+      getHeaders() {
+        const headers = {};
+        if (this.config.apiKey) {
+          headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+        }
+        return headers;
+      }
+    };
+  }
+});
+
 // src/services/ai-provider/ai-provider.factory.ts
 var AIProviderFactory;
 var init_ai_provider_factory = __esm({
@@ -3592,6 +4008,7 @@ var init_ai_provider_factory = __esm({
     init_gateway_provider();
     init_playground_provider();
     init_xai_provider();
+    init_bandit_ai_provider();
     AIProviderFactory = class {
       static createProvider(config) {
         switch (config.type) {
@@ -3605,6 +4022,8 @@ var init_ai_provider_factory = __esm({
             return new AnthropicProvider(config);
           case "xai" /* XAI */:
             return new XAIProvider(config);
+          case "bandit" /* BANDIT */:
+            return new BanditAIProvider(config);
           case "gateway" /* GATEWAY */:
             return new GatewayProvider(config);
           case "playground" /* PLAYGROUND */:
@@ -3619,6 +4038,7 @@ var init_ai_provider_factory = __esm({
           "openai" /* OPENAI */,
           "azure-openai" /* AZURE_OPENAI */,
           "xai" /* XAI */,
+          "bandit" /* BANDIT */,
           "gateway" /* GATEWAY */,
           "playground" /* PLAYGROUND */
         ];
@@ -3636,6 +4056,8 @@ var init_ai_provider_factory = __esm({
             return !!config.apiKey;
           case "xai" /* XAI */:
             return !!config.apiKey;
+          case "bandit" /* BANDIT */:
+            return !!config.apiKey;
           case "gateway" /* GATEWAY */:
             return !!(config.gatewayUrl && config.provider);
           case "playground" /* PLAYGROUND */:
@@ -4427,13 +4849,17 @@ var useConversationStore = (0, import_zustand6.create)((set, get) => ({
       const updatedConversations = conversations.map((c) => {
         if (c.id === currentId && c.history.length > 0) {
           const updatedHistory = [...c.history];
+          const existingImages = updatedHistory[updatedHistory.length - 1].images;
+          const nextImages = Array.isArray(images) && images.length > 0 ? [...images] : Array.isArray(existingImages) && existingImages.length > 0 ? [...existingImages] : existingImages;
           updatedHistory[updatedHistory.length - 1] = {
             ...updatedHistory[updatedHistory.length - 1],
             answer,
             memoryUpdated,
-            images: images ?? updatedHistory[updatedHistory.length - 1].images,
+            images: nextImages,
             sourceFiles: sourceFiles ?? updatedHistory[updatedHistory.length - 1].sourceFiles,
-            cancelled: cancelled ?? updatedHistory[updatedHistory.length - 1].cancelled
+            cancelled: cancelled ?? updatedHistory[updatedHistory.length - 1].cancelled,
+            placeholder: false,
+            rawQuestion: void 0
           };
           return normalizeConversation({ ...c, history: updatedHistory, updatedAt: /* @__PURE__ */ new Date() });
         }
@@ -4514,6 +4940,24 @@ var useConversationStore = (0, import_zustand6.create)((set, get) => ({
             });
             continue;
           }
+          if (Array.isArray(existing.history) && Array.isArray(conversation.history)) {
+            const mergedHistory = conversation.history.map((incomingEntry, index) => {
+              const existingEntry = existing.history[index];
+              if (!existingEntry) {
+                return incomingEntry;
+              }
+              const mergedImagesSource = Array.isArray(incomingEntry.images) && incomingEntry.images.length > 0 ? incomingEntry.images : existingEntry.images;
+              const mergedImages = Array.isArray(mergedImagesSource) && mergedImagesSource.length > 0 ? [...mergedImagesSource] : mergedImagesSource;
+              return {
+                ...existingEntry,
+                ...incomingEntry,
+                images: mergedImages,
+                placeholder: incomingEntry.placeholder ?? existingEntry.placeholder,
+                rawQuestion: incomingEntry.rawQuestion ?? existingEntry.rawQuestion
+              };
+            });
+            conversation.history = mergedHistory;
+          }
         }
         next.set(conversation.id, conversation);
         toPersist.push(conversation);
@@ -6086,7 +6530,7 @@ var import_mammoth = __toESM(require("mammoth"));
 var pdfjsLib = __toESM(require("pdfjs-dist/legacy/build/pdf"));
 
 // src/services/prompts/conversationStarters.ts
-var import_rxjs10 = require("rxjs");
+var import_rxjs11 = require("rxjs");
 init_aiProviderStore();
 init_packageSettingsStore();
 
@@ -6244,19 +6688,19 @@ var NotificationService = class {
 var notificationService = new NotificationService();
 
 // src/services/prompts/moodDetection.ts
-var import_rxjs11 = require("rxjs");
+var import_rxjs12 = require("rxjs");
 init_aiProviderStore();
 init_packageSettingsStore();
 init_debugLogger();
 
 // src/services/prompts/detectUserInterestAndExcitement.ts
-var import_rxjs12 = require("rxjs");
+var import_rxjs13 = require("rxjs");
 init_aiProviderStore();
 init_packageSettingsStore();
 init_debugLogger();
 
 // src/services/prompts/documentSummarization.ts
-var import_rxjs13 = require("rxjs");
+var import_rxjs14 = require("rxjs");
 init_aiProviderStore();
 init_packageSettingsStore();
 init_debugLogger();
@@ -6284,8 +6728,8 @@ ${content.slice(0, 4e3)}
       stream: false,
       options: { temperature: 0.3, num_predict: 100 }
     });
-    const summary$ = data$.pipe((0, import_rxjs13.map)((d) => d.response.trim()));
-    const summary = await (0, import_rxjs13.lastValueFrom)(summary$);
+    const summary$ = data$.pipe((0, import_rxjs14.map)((d) => d.response.trim()));
+    const summary = await (0, import_rxjs14.lastValueFrom)(summary$);
     debugLogger.ragDebug("summarizeDocument result", { name, summary });
     return summary || `Document summary for ${name}`;
   } catch (error) {
@@ -6295,7 +6739,7 @@ ${content.slice(0, 4e3)}
 };
 
 // src/services/prompts/documentRelevance.ts
-var import_rxjs14 = require("rxjs");
+var import_rxjs15 = require("rxjs");
 init_aiProviderStore();
 init_packageSettingsStore();
 init_debugLogger();
@@ -9363,26 +9807,7 @@ var AIProviderInitService = class _AIProviderInitService {
           if (providerConfig.type === "anthropic" /* ANTHROPIC */) {
             providerConfig = this.convertAnthropicConfig(providerConfig, settings?.gatewayApiUrl);
           }
-          if ((providerConfig.type === "ollama" /* OLLAMA */ || providerConfig.type === "gateway" /* GATEWAY */) && !providerConfig.tokenFactory) {
-            providerConfig.tokenFactory = () => {
-              let token = authenticationService.getToken();
-              if (!token) {
-                token = localStorage.getItem("authToken");
-              }
-              if (!token) {
-                try {
-                  const { useAuthenticationStore: useAuthenticationStore2 } = require("../../store/authenticationStore");
-                  const authStore = useAuthenticationStore2.getState();
-                  token = authStore.token;
-                } catch (e) {
-                }
-              }
-              debugLogger.info("AI Provider Init: IndexedDB config token factory", {
-                hasToken: !!token
-              });
-              return token;
-            };
-          }
+          providerConfig = this.ensureTokenFactory(providerConfig);
           try {
             const { createProvider } = useAIProviderStore.getState();
             createProvider(providerConfig);
@@ -9410,27 +9835,7 @@ var AIProviderInitService = class _AIProviderInitService {
       if (providerConfig.type === "anthropic" /* ANTHROPIC */) {
         providerConfig = this.convertAnthropicConfig(providerConfig, settings.gatewayApiUrl);
       }
-      if (providerConfig.type === "ollama" /* OLLAMA */ && !providerConfig.tokenFactory) {
-        providerConfig.tokenFactory = () => {
-          let token = authenticationService.getToken();
-          if (!token) {
-            token = localStorage.getItem("authToken");
-          }
-          if (!token) {
-            try {
-              const { useAuthenticationStore: useAuthenticationStore2 } = require("../../store/authenticationStore");
-              const authStore = useAuthenticationStore2.getState();
-              token = authStore.token;
-            } catch (e) {
-            }
-          }
-          debugLogger.info("AIProviderInit: Explicit config tokenFactory", {
-            hasToken: !!token,
-            localStorage: !!localStorage.getItem("authToken")
-          });
-          return token;
-        };
-      }
+      providerConfig = this.ensureTokenFactory(providerConfig);
       debugLogger.info("Using explicit AI provider config", providerConfig);
     } else {
       providerConfig = {
@@ -9542,9 +9947,10 @@ var AIProviderInitService = class _AIProviderInitService {
    */
   switchProvider(config) {
     try {
+      const normalizedConfig = this.ensureTokenFactory({ ...config });
       const { switchProvider } = useAIProviderStore.getState();
-      switchProvider(config);
-      debugLogger.info(`Switched to AI provider: ${config.type}`);
+      switchProvider(normalizedConfig);
+      debugLogger.info(`Switched to AI provider: ${normalizedConfig.type}`);
     } catch (error) {
       debugLogger.error("Failed to switch AI provider:", { error });
       throw error;
@@ -9578,6 +9984,49 @@ var AIProviderInitService = class _AIProviderInitService {
     debugLogger.info("AI Provider Init: Converted direct Anthropic provider to gateway configuration");
     return normalized;
   }
+  /**
+   * Ensure providers that require auth have a token factory configured.
+   * Handles both UI auth tokens and API key scenarios.
+   */
+  ensureTokenFactory(config) {
+    if (config.type === "ollama" /* OLLAMA */ || config.type === "gateway" /* GATEWAY */) {
+      const existingFactory = config.tokenFactory;
+      if (existingFactory) {
+        return config;
+      }
+      if (typeof config.apiKey === "string" && config.apiKey.trim() !== "") {
+        const key = config.apiKey.trim();
+        config.tokenFactory = () => key;
+        debugLogger.info("AIProviderInit: Using API key for token factory", {
+          type: config.type,
+          hasKey: true
+        });
+        return config;
+      }
+      config.tokenFactory = () => {
+        let token = authenticationService.getToken();
+        if (!token && typeof localStorage !== "undefined") {
+          try {
+            token = localStorage.getItem("authToken");
+          } catch {
+          }
+        }
+        if (!token) {
+          try {
+            const { useAuthenticationStore: useAuthenticationStore2 } = require("../../store/authenticationStore");
+            const authStore = useAuthenticationStore2.getState();
+            token = authStore.token;
+          } catch {
+          }
+        }
+        debugLogger.info("AIProviderInit: Token factory resolved auth token", {
+          hasToken: !!token
+        });
+        return token;
+      };
+    }
+    return config;
+  }
 };
 var aiProviderInitService = AIProviderInitService.getInstance();