@burtson-labs/bandit-engine 2.0.40 → 2.0.42

package/dist/index.js

@@ -4468,61 +4468,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}`;
+        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;
-        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
-        });
         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 = "";
@@ -4597,14 +4551,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();
@@ -4737,18 +4752,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
        */
@@ -9435,9 +9478,11 @@ var init_useVectorStore = __esm({
             setHasCompatibleProvider(false);
             return false;
           }
-          const isOllama = config.type === "ollama";
-          const isGatewayWithOllama = config.type === "gateway" && config.provider === "ollama";
-          const isCompatible = isOllama || isGatewayWithOllama;
+          const vectorCapableProviders = /* @__PURE__ */ new Set(["ollama", "bandit"]);
+          const isNativeOllama = config.type === "ollama";
+          const hasVectorCapableProvider = typeof config.provider === "string" && vectorCapableProviders.has(config.provider);
+          const isGatewayWithVectorSupport = config.type === "gateway" && hasVectorCapableProvider;
+          const isCompatible = isNativeOllama || isGatewayWithVectorSupport;
           setHasCompatibleProvider(isCompatible);
           return isCompatible;
         } catch (error) {
@@ -29268,26 +29313,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);
@@ -29315,27 +29341,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 = {
@@ -29447,9 +29453,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;
@@ -29483,6 +29490,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();
 
@@ -39186,11 +39236,16 @@ var ProviderTab = () => {
       const trimmed = sanitized.defaultModel.trim();
       sanitized.defaultModel = trimmed || void 0;
     }
+    if (typeof sanitized.apiKey === "string") {
+      const trimmedKey = sanitized.apiKey.trim();
+      sanitized.apiKey = trimmedKey || void 0;
+    }
     return sanitized;
   }, []);
   const [providerConfig, setProviderConfig] = (0, import_react53.useState)({
-    type: "ollama",
-    baseUrl: "http://localhost:11434"
+    type: "gateway",
+    gatewayUrl: packageSettings?.gatewayApiUrl || "",
+    provider: "bandit"
   });
   const [isProviderConfigOpen, setIsProviderConfigOpen] = (0, import_react53.useState)(false);
   const [snackbarMessage, setSnackbarMessage] = (0, import_react53.useState)("");
@@ -39326,7 +39381,7 @@ var ProviderTab = () => {
         setProviderConfig(applyDefaultModel({
           ...baseConfig,
           gatewayUrl: packageSettings?.gatewayApiUrl || "",
-          provider: "openai"
+          provider: "bandit"
         }));
         break;
       case "playground" /* PLAYGROUND */: