@burtson-labs/bandit-engine 2.0.39 → 2.0.41

package/dist/modals/chat-modal/chat-modal.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;
 };
@@ -1550,57 +1550,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 = "";
@@ -1675,14 +1633,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();
@@ -1697,12 +1716,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) {
@@ -1809,18 +1834,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
        */
@@ -2300,6 +2353,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({
@@ -2313,6 +2472,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;
@@ -2354,6 +2514,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;
@@ -2368,6 +2531,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") {
@@ -2377,7 +2550,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 = [
@@ -2386,11 +2559,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"
                   }
                 });
@@ -2399,6 +2572,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
+              });
             }
           }
         }
@@ -2907,6 +3085,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({
@@ -2920,6 +3336,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) {
@@ -2933,6 +3350,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 */:
@@ -2947,6 +3366,7 @@ var init_ai_provider_factory = __esm({
           "openai" /* OPENAI */,
           "azure-openai" /* AZURE_OPENAI */,
           "xai" /* XAI */,
+          "bandit" /* BANDIT */,
           "gateway" /* GATEWAY */,
           "playground" /* PLAYGROUND */
         ];
@@ -2964,6 +3384,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 */:
@@ -4452,7 +4874,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();
 
@@ -4611,19 +5033,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();
@@ -4651,8 +5073,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) {
@@ -4662,7 +5084,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();
@@ -6986,13 +7408,17 @@ var useConversationStore = (0, import_zustand9.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() });
         }
@@ -7073,6 +7499,24 @@ var useConversationStore = (0, import_zustand9.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);
@@ -10790,12 +11234,12 @@ var voiceService = VoiceService.getInstance();
 init_debugLogger();
 
 // src/services/tts/streaming-tts.ts
-var import_rxjs16 = require("rxjs");
+var import_rxjs17 = require("rxjs");
 init_debugLogger();
 init_packageSettingsStore();
 
 // src/services/tts/tts-client.ts
-var import_rxjs15 = require("rxjs");
+var import_rxjs16 = require("rxjs");
 init_packageSettingsStore();
 init_debugLogger();
 var getOrAppendAuthHeader = (existing = {}) => {
@@ -10818,8 +11262,8 @@ var StreamingTTSClient = class _StreamingTTSClient {
   // Store event handler references for proper cleanup
   audioHandlers = /* @__PURE__ */ new Map();
   // State management
-  stateSubject = new import_rxjs16.BehaviorSubject("IDLE" /* IDLE */);
-  progressSubject = new import_rxjs16.Subject();
+  stateSubject = new import_rxjs17.BehaviorSubject("IDLE" /* IDLE */);
+  progressSubject = new import_rxjs17.Subject();
   constructor() {
   }
   static getInstance() {
@@ -10850,7 +11294,7 @@ var StreamingTTSClient = class _StreamingTTSClient {
    * Speak text with simple streaming
    */
   speakStream(text, voice, options = {}) {
-    return new import_rxjs16.Observable((subscriber) => {
+    return new import_rxjs17.Observable((subscriber) => {
       this.performSimpleStreaming(text, voice, options, subscriber);
     });
   }
@@ -14275,7 +14719,7 @@ var MemoryModal = ({ open, onClose }) => {
 var memory_modal_default = MemoryModal;
 
 // src/modals/chat-modal/chat-drawer.tsx
-var import_rxjs17 = require("rxjs");
+var import_rxjs18 = require("rxjs");
 init_debugLogger();
 var import_jsx_runtime10 = require("react/jsx-runtime");
 var AIQueriesDrawer = ({ drawerOpen, onClose, onClearComplete, onNavigateToMain }) => {
@@ -14303,7 +14747,7 @@ var AIQueriesDrawer = ({ drawerOpen, onClose, onClearComplete, onNavigateToMain
   const [memoryModalOpen, setMemoryModalOpen] = (0, import_react15.useState)(false);
   const [contextMode, setContextMode] = (0, import_react15.useState)("local");
   const [expandedSections, setExpandedSections] = (0, import_react15.useState)(/* @__PURE__ */ new Set(["history", "voice"]));
-  const [audioSub, setAudioSub] = (0, import_react15.useState)(new import_rxjs17.Subscription());
+  const [audioSub, setAudioSub] = (0, import_react15.useState)(new import_rxjs18.Subscription());
   const [isContextSwitching, setIsContextSwitching] = (0, import_react15.useState)(false);
   const [isDrawerLoading, setIsDrawerLoading] = (0, import_react15.useState)(false);
   (0, import_react15.useEffect)(() => {
@@ -19727,7 +20171,7 @@ var predefinedThemes = {
 var themeMap_default = themeMap;
 
 // src/modals/chat-modal/chat-modal.tsx
-var import_rxjs18 = require("rxjs");
+var import_rxjs19 = require("rxjs");
 var import_jsx_runtime15 = require("react/jsx-runtime");
 var FULL_SCREEN_THRESHOLD = 100;
 var MIN_WINDOWED_HEIGHT = 400;
@@ -19796,7 +20240,7 @@ var ChatModal = ({
   const [modalLogo, setModalLogo] = (0, import_react22.useState)("https://cdn.burtson.ai/logos/bandit-ai-logo.png");
   const [modelAnchorEl, setModelAnchorEl] = (0, import_react22.useState)(null);
   const [voiceAnchorEl, setVoiceAnchorEl] = (0, import_react22.useState)(null);
-  const [audioSub, setAudioSub] = (0, import_react22.useState)(new import_rxjs18.Subscription());
+  const [audioSub, setAudioSub] = (0, import_react22.useState)(new import_rxjs19.Subscription());
   const [selectedTheme, setSelectedTheme] = (0, import_react22.useState)(null);
   const [themeLoading, setThemeLoading] = (0, import_react22.useState)(true);
   const [autoFullscreenTriggered, setAutoFullscreenTriggered] = (0, import_react22.useState)(false);