@burtson-labs/bandit-engine 2.0.39 → 2.0.41

package/dist/{chunk-QU5S5QQP.mjs → chunk-54ZQ3FSN.mjs}

@@ -1015,7 +1015,7 @@ var AnthropicProvider = class {
 };
 
 // src/services/ai-provider/providers/gateway.provider.ts
-import { map as map11 } from "rxjs";
+import { map as map12 } from "rxjs";
 
 // src/services/gateway/gateway.service.ts
 import axios, { AxiosHeaders } from "axios";
@@ -1163,57 +1163,15 @@ var GatewayService = class {
    */
   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 Observable6((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 = "";
@@ -1288,14 +1246,75 @@ var GatewayService = class {
           }).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();
@@ -1310,12 +1329,18 @@ var GatewayService = class {
   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 Observable6((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) {
@@ -1422,18 +1447,46 @@ var GatewayService = class {
     );
   }
   _getHeaders() {
-    const token = this._tokenFactory();
+    const rawToken = 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 (!rawToken) {
       debugLogger.warn("GatewayService: No token found, skipping Authorization header");
+      return headers;
+    }
+    const token = rawToken.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
    */
@@ -1879,6 +1932,104 @@ var OllamaGatewayService = class {
   }
 };
 
+// src/services/gateway/bandit-gateway.service.ts
+import { map as map11 } from "rxjs/operators";
+var normalizeBanditModel = (model) => {
+  if (typeof model !== "string" || model.trim() === "") {
+    return "bandit-core-1";
+  }
+  const normalized = model.replace(/^bandit:/, "").trim();
+  return normalized === "" ? "bandit-core-1" : normalized;
+};
+var 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;
+};
+var 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) : "" };
+});
+var 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(
+      map11((health) => ({
+        ...health,
+        bandit_status: health.providers.find((p) => p.name === "bandit")?.status || "unavailable"
+      }))
+    );
+  }
+};
+
 // src/services/ai-provider/providers/gateway.provider.ts
 var GatewayProvider = class {
   config;
@@ -1921,6 +2072,9 @@ var GatewayProvider = class {
       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;
@@ -1935,6 +2089,16 @@ var GatewayProvider = class {
       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") {
@@ -1944,7 +2108,7 @@ var GatewayProvider = class {
             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 = [
@@ -1953,11 +2117,11 @@ var GatewayProvider = class {
               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"
               }
             });
@@ -1966,6 +2130,11 @@ var GatewayProvider = class {
             ...messages[lastUserMessageIndex],
             content: contentArray
           };
+          debugLogger.debug("Gateway provider injected image attachments", {
+            provider: this.config.provider,
+            imageCount: request.images.length,
+            messageIndex: lastUserMessageIndex
+          });
         }
       }
     }
@@ -1994,7 +2163,7 @@ var GatewayProvider = class {
       }))
     });
     return this.gatewayService.chat(gatewayRequest).pipe(
-      map11((response) => ({
+      map12((response) => ({
         message: {
           content: response.choices?.[0]?.message?.content || response.choices?.[0]?.delta?.content || "",
           role: "assistant"
@@ -2017,7 +2186,7 @@ var GatewayProvider = class {
       stream: request.stream
     });
     return this.gatewayService.generate(gatewayRequest).pipe(
-      map11((response) => ({
+      map12((response) => ({
         response: response.response || "",
         done: response.done || false
       }))
@@ -2027,7 +2196,7 @@ var GatewayProvider = class {
     debugLogger.debug("Gateway provider listing models", { provider: this.config.provider });
     if (this.config.provider) {
       return this.gatewayService.listModelsByProvider(this.config.provider).pipe(
-        map11((models) => models.map((model) => ({
+        map12((models) => models.map((model) => ({
           name: model.id || model.name,
           size: model.size,
           details: model.details,
@@ -2037,7 +2206,7 @@ var GatewayProvider = class {
       );
     } else {
       return this.gatewayService.listModels().pipe(
-        map11((models) => models.map((model) => ({
+        map12((models) => models.map((model) => ({
           name: model.id || model.name,
           size: model.size,
           details: model.details,
@@ -2068,7 +2237,7 @@ var GatewayProvider = class {
    */
   getHealth() {
     return this.gatewayService.getHealth().pipe(
-      map11((health) => ({
+      map12((health) => ({
         ...health,
         backend_provider: this.config.provider,
         backend_provider_status: health.providers.find((p) => p.name === this.config.provider)?.status || "unavailable"
@@ -2256,7 +2425,7 @@ var PlaygroundProvider = class {
 };
 
 // src/services/ai-provider/providers/xai.provider.ts
-import { Observable as Observable9, from as from6, switchMap as switchMap5, map as map12, throwError as throwError5 } from "rxjs";
+import { Observable as Observable9, from as from6, switchMap as switchMap5, map as map13, throwError as throwError5 } from "rxjs";
 var XAIProvider = class {
   config;
   baseUrl;
@@ -2287,7 +2456,7 @@ var XAIProvider = class {
       options: request.options
     };
     return this.chat(chatRequest).pipe(
-      map12((response) => ({
+      map13((response) => ({
         response: response.message.content,
         done: response.done
       }))
@@ -2304,7 +2473,7 @@ var XAIProvider = class {
         }
         return from6(response.json());
       }),
-      map12(
+      map13(
         (data) => data.data.map((model) => ({
           name: model.id,
           details: {
@@ -2439,7 +2608,237 @@ var XAIProvider = class {
         }
         return from6(response.json());
       }),
-      map12((data) => ({
+      map13((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/providers/bandit-ai.provider.ts
+import { Observable as Observable10, from as from7, switchMap as switchMap6, map as map14, throwError as throwError6 } from "rxjs";
+var DEFAULT_BANDIT_BASE = "https://api.burtson.ai";
+var 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}`;
+};
+var 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;
+};
+var 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(
+      map14((response) => ({
+        response: response.message.content,
+        done: response.done
+      }))
+    );
+  }
+  listModels() {
+    const url = `${this.baseUrl}/models`;
+    return from7(fetch(url, { headers: this.getHeaders() })).pipe(
+      switchMap6((response) => {
+        if (!response.ok) {
+          debugLogger.error("BanditAI listModels failed", { status: response.status, url });
+          return throwError6(() => new Error(`Failed to list Bandit models: ${response.status}`));
+        }
+        return from7(response.json());
+      }),
+      map14(
+        (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 Observable10((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 from7(fetch(url, {
+      method: "POST",
+      headers: {
+        ...this.getHeaders(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    })).pipe(
+      switchMap6((response) => {
+        if (!response.ok) {
+          return throwError6(() => new Error(`BanditAI request failed: ${response.status}`));
+        }
+        return from7(response.json());
+      }),
+      map14((data) => ({
         message: {
           content: data.choices?.[0]?.message?.content ?? "",
           role: "assistant"
@@ -2471,6 +2870,8 @@ var AIProviderFactory = class {
         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 */:
@@ -2485,6 +2886,7 @@ var AIProviderFactory = class {
       "openai" /* OPENAI */,
       "azure-openai" /* AZURE_OPENAI */,
       "xai" /* XAI */,
+      "bandit" /* BANDIT */,
       "gateway" /* GATEWAY */,
       "playground" /* PLAYGROUND */
     ];
@@ -2502,6 +2904,8 @@ var AIProviderFactory = class {
         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 */:
@@ -2543,4 +2947,4 @@ export {
   AIProviderFactory,
   useAIProviderStore
 };
-//# sourceMappingURL=chunk-QU5S5QQP.mjs.map
+//# sourceMappingURL=chunk-54ZQ3FSN.mjs.map