@burtson-labs/bandit-engine 2.1.7 → 2.1.8

package/dist/chunk-2THUYNVU.mjs

@@ -0,0 +1,1203 @@
+import {
+  useVoiceStore
+} from "./chunk-LC64VSDS.mjs";
+import {
+  Refresh,
+  Settings
+} from "./chunk-K4AO466X.mjs";
+import {
+  ManagementCard,
+  ManagementEmptyState
+} from "./chunk-LY3O7UWA.mjs";
+import {
+  AIProviderFactory,
+  GatewayService,
+  useAIProviderStore
+} from "./chunk-DHXSFFLX.mjs";
+import {
+  indexedDBService_default
+} from "./chunk-KPT7NNNK.mjs";
+import {
+  usePackageSettingsStore
+} from "./chunk-K7SQWDNF.mjs";
+import {
+  authenticationService
+} from "./chunk-S3DWWUBD.mjs";
+import {
+  debugLogger
+} from "./chunk-NI7BKLC7.mjs";
+
+// src/hooks/useGatewayQueries.ts
+import { useMemo } from "react";
+import { lastValueFrom } from "rxjs";
+import { useQuery } from "@tanstack/react-query";
+var useGatewayClient = () => {
+  const settings = usePackageSettingsStore((state) => state.settings);
+  const gatewayUrl = settings?.gatewayApiUrl;
+  const feedbackEmail = settings?.feedbackEmail;
+  const service = useMemo(() => {
+    if (!gatewayUrl) {
+      return null;
+    }
+    return new GatewayService(
+      gatewayUrl,
+      () => authenticationService.getToken(),
+      feedbackEmail
+    );
+  }, [gatewayUrl, feedbackEmail]);
+  return { service, gatewayUrl };
+};
+var useGatewayHealth = (options) => {
+  const { service, gatewayUrl } = useGatewayClient();
+  const enabled = Boolean(service && gatewayUrl) && (options?.enabled ?? true);
+  return useQuery({
+    ...options,
+    queryKey: ["gateway", "health", gatewayUrl],
+    queryFn: async () => {
+      if (!service) {
+        throw new Error("Gateway service is not configured");
+      }
+      return lastValueFrom(service.getHealth());
+    },
+    enabled
+  });
+};
+var useGatewayModels = (options) => {
+  const { service, gatewayUrl } = useGatewayClient();
+  const enabled = Boolean(service && gatewayUrl) && (options?.enabled ?? true);
+  return useQuery({
+    ...options,
+    queryKey: ["gateway", "models", gatewayUrl],
+    queryFn: async () => {
+      if (!service) {
+        throw new Error("Gateway service is not configured");
+      }
+      return lastValueFrom(service.listModels());
+    },
+    enabled
+  });
+};
+var useGatewayMemory = (options) => {
+  const { service, gatewayUrl } = useGatewayClient();
+  const enabled = Boolean(service && gatewayUrl) && (options?.enabled ?? true);
+  return useQuery({
+    ...options,
+    queryKey: ["gateway", "memory", gatewayUrl],
+    queryFn: async () => {
+      if (!service) {
+        throw new Error("Gateway service is not configured");
+      }
+      return lastValueFrom(service.getMemory());
+    },
+    enabled
+  });
+};
+
+// src/management/components/ServiceStatusCard.tsx
+import { useCallback } from "react";
+import { Box, Chip, IconButton, Tooltip, Typography } from "@mui/material";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var spinSx = {
+  animation: "spin 1s linear infinite",
+  "@keyframes spin": {
+    "0%": { transform: "rotate(0deg)" },
+    "100%": { transform: "rotate(360deg)" }
+  }
+};
+var ServiceStatusCard = ({
+  packageSettings
+}) => {
+  const isTTSSTTAvailable = useVoiceStore((state) => state.isServiceAvailable);
+  const gatewayConfigured = Boolean(packageSettings?.gatewayApiUrl);
+  const {
+    data: gatewayHealth,
+    error: gatewayHealthError,
+    isLoading: gatewayHealthLoading,
+    isFetching: gatewayHealthFetching,
+    refetch: refetchGatewayHealth
+  } = useGatewayHealth({
+    enabled: gatewayConfigured,
+    refetchOnWindowFocus: false,
+    staleTime: 6e4
+  });
+  const isGatewayLoading = gatewayHealthLoading || gatewayHealthFetching;
+  const gatewayChipLabel = gatewayConfigured ? isGatewayLoading ? "Checking\u2026" : gatewayHealthError ? "Offline" : gatewayHealth ? gatewayHealth.status?.toLowerCase() === "healthy" ? "Online" : "Offline" : "Unknown" : "Not configured";
+  const gatewayChipColor = (() => {
+    if (!gatewayConfigured) return "default";
+    if (gatewayHealthError) return "error";
+    if (isGatewayLoading) return "default";
+    if (!gatewayHealth) return "warning";
+    return gatewayHealth.status?.toLowerCase() === "healthy" ? "success" : "error";
+  })();
+  const handleGatewayStatusRefresh = useCallback(() => {
+    if (!gatewayConfigured) return;
+    refetchGatewayHealth();
+  }, [gatewayConfigured, refetchGatewayHealth]);
+  const voiceChip = /* @__PURE__ */ jsx(
+    Chip,
+    {
+      label: isTTSSTTAvailable ? "Available" : packageSettings?.gatewayApiUrl ? "Unavailable" : "Not configured",
+      color: isTTSSTTAvailable ? "success" : packageSettings?.gatewayApiUrl ? "warning" : "default",
+      size: "small"
+    }
+  );
+  const row = (label, chip) => /* @__PURE__ */ jsxs(
+    Box,
+    {
+      sx: {
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "space-between",
+        flexWrap: "wrap",
+        gap: 1
+      },
+      children: [
+        /* @__PURE__ */ jsx(Box, { sx: { display: "flex", alignItems: "center", gap: 1 }, children: label }),
+        chip
+      ]
+    }
+  );
+  return /* @__PURE__ */ jsx(
+    ManagementCard,
+    {
+      title: "Service status",
+      description: "The services this deployment is configured with. Your administrator enables or configures them.",
+      children: /* @__PURE__ */ jsxs(Box, { sx: { display: "flex", flexDirection: "column", gap: 1.5 }, children: [
+        row(
+          /* @__PURE__ */ jsx(Typography, { variant: "body2", sx: { fontWeight: 600 }, children: "Text-to-speech (TTS)" }),
+          voiceChip
+        ),
+        row(
+          /* @__PURE__ */ jsx(Typography, { variant: "body2", sx: { fontWeight: 600 }, children: "Speech-to-text (STT)" }),
+          voiceChip
+        ),
+        row(
+          /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Typography, { variant: "body2", sx: { fontWeight: 600 }, children: "Gateway/MCP" }),
+            gatewayConfigured && /* @__PURE__ */ jsx(Tooltip, { title: "Refresh gateway status", placement: "top", children: /* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(
+              IconButton,
+              {
+                size: "small",
+                onClick: handleGatewayStatusRefresh,
+                disabled: isGatewayLoading,
+                "aria-label": "Refresh gateway status",
+                sx: { width: { xs: 44, sm: 28 }, height: { xs: 44, sm: 28 } },
+                children: /* @__PURE__ */ jsx(
+                  Refresh,
+                  {
+                    fontSize: "small",
+                    sx: isGatewayLoading ? spinSx : void 0
+                  }
+                )
+              }
+            ) }) })
+          ] }),
+          /* @__PURE__ */ jsx(Chip, { label: gatewayChipLabel, color: gatewayChipColor, size: "small" })
+        ),
+        gatewayConfigured && gatewayHealthError && /* @__PURE__ */ jsxs(Box, { sx: { display: "flex", flexDirection: "column", gap: 0.75 }, children: [
+          /* @__PURE__ */ jsx(Typography, { variant: "caption", color: "error", children: "Couldn't reach the gateway. Use refresh to check again." }),
+          gatewayHealthError.message && /* @__PURE__ */ jsx(Typography, { variant: "caption", color: "text.secondary", children: gatewayHealthError.message })
+        ] })
+      ] })
+    }
+  );
+};
+
+// src/management/components/ProviderTab.tsx
+import { useState, useEffect, useCallback as useCallback2, useRef } from "react";
+import {
+  Box as Box2,
+  Typography as Typography2,
+  Paper,
+  Button,
+  TextField,
+  MenuItem,
+  Chip as Chip2,
+  Snackbar,
+  Alert,
+  CircularProgress,
+  Stack
+} from "@mui/material";
+
+// src/services/ai-provider-init.service.ts
+var sessionTokenFactory = (label) => () => {
+  const token = authenticationService.getToken();
+  debugLogger.info(`AIProviderInit: ${label}`, { hasToken: !!token });
+  return token;
+};
+var AIProviderInitService = class _AIProviderInitService {
+  static instance;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_AIProviderInitService.instance) {
+      _AIProviderInitService.instance = new _AIProviderInitService();
+    }
+    return _AIProviderInitService.instance;
+  }
+  /**
+   * Initialize AI provider from package settings
+   * Provides backward compatibility with existing Ollama settings
+   */
+  async initializeFromSettings() {
+    const settings = usePackageSettingsStore.getState().settings;
+    if (!settings) {
+      debugLogger.warn("No package settings found, cannot initialize AI provider");
+      return;
+    }
+    let providerConfig;
+    debugLogger.info("AI Provider Init: Starting initialization", {
+      hasSettings: !!settings,
+      hasAiProvider: !!settings.aiProvider,
+      ollamaUrl: settings.ollamaUrl
+    });
+    const isPlaygroundEnvironment = settings.playgroundMode === true || settings.aiProvider?.type === "playground" /* PLAYGROUND */ || (settings.gatewayApiUrl?.toLowerCase()?.startsWith("playground://") ?? false) || typeof window !== "undefined" && window.location.pathname.includes("/playground");
+    if (isPlaygroundEnvironment) {
+      debugLogger.info(
+        "AI Provider Init: Playground environment detected, bypassing saved provider config"
+      );
+    } else {
+      try {
+        const savedConfig = await indexedDBService_default.get(
+          "banditConfig",
+          1,
+          "config",
+          "aiProvider",
+          [{ name: "config", keyPath: "id" }]
+        );
+        if (savedConfig) {
+          debugLogger.info("AI Provider Init: Found saved config in IndexedDB", {
+            type: savedConfig.type
+          });
+          const { id: _id, ...configWithoutId } = savedConfig;
+          providerConfig = { ...configWithoutId };
+          if (providerConfig.type === "anthropic" /* ANTHROPIC */) {
+            providerConfig = this.convertAnthropicConfig(
+              providerConfig,
+              settings?.gatewayApiUrl
+            );
+          }
+          providerConfig = this.ensureTokenFactory(providerConfig);
+          try {
+            const { createProvider } = useAIProviderStore.getState();
+            createProvider(providerConfig);
+            const provider = useAIProviderStore.getState().provider;
+            if (provider) {
+              try {
+                await provider.validateServiceAvailability({ timeoutMs: 5e3 });
+                debugLogger.info(
+                  `AI Provider initialized and validated from IndexedDB: ${providerConfig.type}`
+                );
+              } catch (validationError) {
+                debugLogger.warn(`AI Provider created but validation failed`, {
+                  error: validationError
+                });
+              }
+            }
+            return;
+          } catch (error) {
+            debugLogger.error(
+              "Failed to initialize saved provider config, falling back to package settings",
+              { error }
+            );
+          }
+        }
+        debugLogger.info(
+          "AI Provider Init: No saved config found, using package settings"
+        );
+      } catch (error) {
+        debugLogger.warn(
+          "AI Provider Init: Failed to load from IndexedDB, using package settings",
+          { error }
+        );
+      }
+    }
+    if (settings.aiProvider) {
+      providerConfig = { ...settings.aiProvider };
+      if (providerConfig.type === "anthropic" /* ANTHROPIC */) {
+        providerConfig = this.convertAnthropicConfig(
+          providerConfig,
+          settings.gatewayApiUrl
+        );
+      }
+      providerConfig = this.ensureTokenFactory(providerConfig);
+      debugLogger.info("Using explicit AI provider config", providerConfig);
+    } else {
+      providerConfig = {
+        type: "ollama" /* OLLAMA */,
+        baseUrl: settings.ollamaUrl,
+        tokenFactory: sessionTokenFactory("Token factory called")
+      };
+      debugLogger.info("Using legacy Ollama config", providerConfig);
+    }
+    try {
+      const { createProvider } = useAIProviderStore.getState();
+      createProvider(providerConfig);
+      const provider = useAIProviderStore.getState().provider;
+      if (provider) {
+        try {
+          await provider.validateServiceAvailability({ timeoutMs: 5e3 });
+          debugLogger.info(
+            `AI Provider initialized and validated: ${providerConfig.type}`
+          );
+        } catch (validationError) {
+          debugLogger.warn(`AI Provider created but validation failed:`, {
+            error: validationError
+          });
+        }
+      }
+    } catch (error) {
+      debugLogger.error("Failed to initialize AI provider:", { error });
+      if (providerConfig.type !== "ollama" /* OLLAMA */) {
+        try {
+          const fallbackConfig = {
+            type: "ollama" /* OLLAMA */,
+            baseUrl: settings.ollamaUrl || "http://localhost:11434",
+            tokenFactory: sessionTokenFactory("Fallback tokenFactory")
+          };
+          const { createProvider } = useAIProviderStore.getState();
+          createProvider(fallbackConfig);
+          debugLogger.info("Fallback to Ollama provider successful");
+        } catch (fallbackError) {
+          debugLogger.error("Failed to initialize fallback Ollama provider:", {
+            error: fallbackError
+          });
+        }
+      } else {
+        try {
+          const localFallbackConfig = {
+            type: "ollama" /* OLLAMA */,
+            baseUrl: "http://localhost:11434",
+            tokenFactory: sessionTokenFactory("Local fallback tokenFactory")
+          };
+          const { createProvider } = useAIProviderStore.getState();
+          createProvider(localFallbackConfig);
+          debugLogger.info("Fallback to localhost Ollama provider successful");
+        } catch (localFallbackError) {
+          debugLogger.error("All provider initialization attempts failed:", {
+            error: localFallbackError
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Switch to a different AI provider
+   */
+  switchProvider(config) {
+    try {
+      const normalizedConfig = this.ensureTokenFactory({ ...config });
+      const { switchProvider } = useAIProviderStore.getState();
+      switchProvider(normalizedConfig);
+      debugLogger.info(`Switched to AI provider: ${normalizedConfig.type}`);
+    } catch (error) {
+      debugLogger.error("Failed to switch AI provider:", { error });
+      throw error;
+    }
+  }
+  /**
+   * Get the current provider type
+   */
+  getCurrentProviderType() {
+    const provider = useAIProviderStore.getState().provider;
+    return provider ? provider.getProviderType() : null;
+  }
+  /**
+   * Check if a provider is initialized
+   */
+  isProviderInitialized() {
+    return useAIProviderStore.getState().provider !== null;
+  }
+  convertAnthropicConfig(config, gatewayUrl) {
+    if (config.type !== "anthropic" /* ANTHROPIC */) {
+      return config;
+    }
+    const defaultModel = typeof config.defaultModel === "string" && config.defaultModel.trim() ? config.defaultModel.trim() : "claude-3-5-sonnet-latest";
+    const normalized = {
+      type: "gateway" /* GATEWAY */,
+      gatewayUrl: gatewayUrl || config.gatewayUrl || "",
+      provider: "anthropic",
+      defaultModel,
+      tokenFactory: config.tokenFactory
+    };
+    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 = sessionTokenFactory("Token factory resolved auth token");
+    }
+    return config;
+  }
+};
+var aiProviderInitService = AIProviderInitService.getInstance();
+
+// src/management/components/ProviderTab.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var ProviderTab = () => {
+  const { provider: currentProvider, config: currentProviderConfig } = useAIProviderStore();
+  const { settings: packageSettings } = usePackageSettingsStore();
+  const getSuggestedModel = useCallback2(
+    (type) => {
+      const configuredDefault = packageSettings?.defaultModel?.trim();
+      if (configuredDefault) {
+        return configuredDefault;
+      }
+      switch (type) {
+        case "openai" /* OPENAI */:
+          return "gpt-4o-mini";
+        case "xai" /* XAI */:
+          return "grok-beta";
+        case "bandit" /* BANDIT */:
+          return "bandit-core-1";
+        default:
+          return "";
+      }
+    },
+    [packageSettings?.defaultModel]
+  );
+  const applyDefaultModel = useCallback2(
+    (config) => {
+      const normalized = { ...config };
+      const trimmed = typeof normalized.defaultModel === "string" ? normalized.defaultModel.trim() : void 0;
+      const requiresModel = normalized.type === "openai" /* OPENAI */ || normalized.type === "xai" /* XAI */ || normalized.type === "bandit" /* BANDIT */;
+      if (trimmed) {
+        normalized.defaultModel = trimmed;
+        return normalized;
+      }
+      if (!requiresModel) {
+        delete normalized.defaultModel;
+        return normalized;
+      }
+      const suggestion = getSuggestedModel(normalized.type);
+      if (suggestion) {
+        normalized.defaultModel = suggestion;
+      } else {
+        delete normalized.defaultModel;
+      }
+      return normalized;
+    },
+    [getSuggestedModel]
+  );
+  const sanitizeConfigForSave = useCallback2(
+    (config) => {
+      const sanitized = { ...config };
+      if (typeof sanitized.defaultModel === "string") {
+        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] = useState({
+    type: "gateway",
+    gatewayUrl: packageSettings?.gatewayApiUrl || "",
+    provider: "bandit"
+  });
+  const [saveResult, setSaveResult] = useState({ state: "idle" });
+  const [testResult, setTestResult] = useState({ state: "idle" });
+  const providerTypeRef = useRef(null);
+  const formRef = useRef(null);
+  const revealProviderForm = () => {
+    formRef.current?.scrollIntoView({ behavior: "smooth", block: "start" });
+    providerTypeRef.current?.focus();
+  };
+  const [snackbarMessage, setSnackbarMessage] = useState("");
+  const [showSnackbar, setShowSnackbar] = useState(false);
+  const [snackbarSeverity, setSnackbarSeverity] = useState(
+    "success"
+  );
+  const saveProviderConfigToDB = async (config) => {
+    try {
+      const { tokenFactory: _tokenFactory, ...persistableConfig } = config;
+      const serializableConfig = {
+        ...persistableConfig,
+        id: "aiProvider"
+      };
+      await indexedDBService_default.put(
+        "banditConfig",
+        1,
+        "config",
+        serializableConfig,
+        [{ name: "config", keyPath: "id" }]
+      );
+      debugLogger.info("Provider configuration saved to IndexedDB", {
+        type: config.type
+      });
+    } catch (error) {
+      debugLogger.error("Failed to save provider config to IndexedDB:", { error });
+      throw error;
+    }
+  };
+  const loadProviderConfigFromDB = async () => {
+    try {
+      const config = await indexedDBService_default.get(
+        "banditConfig",
+        1,
+        "config",
+        "aiProvider",
+        [{ name: "config", keyPath: "id" }]
+      );
+      if (config) {
+        debugLogger.info("Provider configuration loaded from IndexedDB", {
+          type: config.type
+        });
+        const { id: _id, ...configWithoutId } = config;
+        return configWithoutId;
+      }
+    } catch (error) {
+      debugLogger.error("Failed to load provider config from IndexedDB:", { error });
+    }
+    return null;
+  };
+  const convertAnthropicConfig = useCallback2(
+    (config) => {
+      if (!config) return null;
+      if (config.type !== "anthropic" /* ANTHROPIC */) {
+        return config;
+      }
+      const gatewayUrl = config.gatewayUrl || packageSettings?.gatewayApiUrl || "";
+      const defaultModel = typeof config.defaultModel === "string" && config.defaultModel.trim() ? config.defaultModel.trim() : "claude-3-5-sonnet-latest";
+      const converted = {
+        type: "gateway" /* GATEWAY */,
+        gatewayUrl,
+        provider: "anthropic",
+        defaultModel,
+        tokenFactory: config.tokenFactory
+      };
+      return converted;
+    },
+    [packageSettings?.gatewayApiUrl]
+  );
+  useEffect(() => {
+    const initializeProviderConfig = async () => {
+      const savedConfig = await loadProviderConfigFromDB();
+      if (savedConfig) {
+        const normalized = convertAnthropicConfig(savedConfig) || savedConfig;
+        setProviderConfig(applyDefaultModel(normalized));
+      } else if (currentProviderConfig) {
+        const normalized = convertAnthropicConfig(currentProviderConfig) || currentProviderConfig;
+        setProviderConfig(applyDefaultModel(normalized));
+      } else if (packageSettings?.aiProvider) {
+        const normalized = convertAnthropicConfig(packageSettings.aiProvider) || packageSettings.aiProvider;
+        setProviderConfig(applyDefaultModel(normalized));
+      }
+    };
+    initializeProviderConfig();
+  }, [applyDefaultModel, convertAnthropicConfig, currentProviderConfig, packageSettings]);
+  const showMessage = (message, severity) => {
+    setSnackbarMessage(message);
+    setSnackbarSeverity(severity);
+    setShowSnackbar(true);
+  };
+  const handleProviderTypeChange = (type) => {
+    setSaveResult({ state: "idle" });
+    setTestResult({ state: "idle" });
+    const baseConfig = { type };
+    switch (type) {
+      case "ollama" /* OLLAMA */:
+        setProviderConfig(
+          applyDefaultModel({
+            ...baseConfig,
+            baseUrl: "http://localhost:11434"
+          })
+        );
+        break;
+      case "openai" /* OPENAI */:
+        setProviderConfig(
+          applyDefaultModel({
+            ...baseConfig,
+            baseUrl: "https://api.openai.com/v1",
+            apiKey: ""
+          })
+        );
+        break;
+      case "azure-openai" /* AZURE_OPENAI */:
+        setProviderConfig(
+          applyDefaultModel({
+            ...baseConfig,
+            baseUrl: "",
+            apiKey: "",
+            apiVersion: "2024-02-01",
+            deploymentName: ""
+          })
+        );
+        break;
+      case "anthropic" /* ANTHROPIC */:
+        showMessage(
+          "Anthropic is only available via the Gateway provider. Please configure Gateway and choose Anthropic as the backend.",
+          "error"
+        );
+        setProviderConfig(
+          applyDefaultModel({
+            type: "gateway" /* GATEWAY */,
+            gatewayUrl: packageSettings?.gatewayApiUrl || "",
+            provider: "anthropic",
+            defaultModel: "claude-3-5-sonnet-latest"
+          })
+        );
+        break;
+      case "xai" /* XAI */:
+        setProviderConfig(
+          applyDefaultModel({
+            ...baseConfig,
+            baseUrl: "https://api.x.ai/v1",
+            apiKey: ""
+          })
+        );
+        break;
+      case "bandit" /* BANDIT */:
+        setProviderConfig(
+          applyDefaultModel({
+            ...baseConfig,
+            baseUrl: "https://api.burtson.ai",
+            apiKey: "",
+            defaultModel: "bandit-core-1"
+          })
+        );
+        break;
+      case "gateway" /* GATEWAY */:
+        setProviderConfig(
+          applyDefaultModel({
+            ...baseConfig,
+            gatewayUrl: packageSettings?.gatewayApiUrl || "",
+            provider: "bandit"
+          })
+        );
+        break;
+      case "playground" /* PLAYGROUND */:
+        setProviderConfig(
+          applyDefaultModel({
+            ...baseConfig
+          })
+        );
+        break;
+    }
+  };
+  const handleSaveProviderConfig = async () => {
+    setSaveResult({ state: "pending" });
+    try {
+      const normalizedConfigIntermediate = sanitizeConfigForSave(providerConfig);
+      const normalizedConfig = convertAnthropicConfig(normalizedConfigIntermediate) || normalizedConfigIntermediate;
+      const requiresModel = normalizedConfig.type === "openai" /* OPENAI */ || normalizedConfig.type === "xai" /* XAI */ || normalizedConfig.type === "bandit" /* BANDIT */;
+      if (requiresModel && !normalizedConfig.defaultModel) {
+        setSaveResult({
+          state: "error",
+          message: "Not saved. Enter a default model ID for this provider."
+        });
+        return;
+      }
+      const isValid = AIProviderFactory.validateConfig(normalizedConfig);
+      if (!isValid) {
+        setSaveResult({
+          state: "error",
+          message: "Not saved. Some required fields are missing or invalid."
+        });
+        return;
+      }
+      await saveProviderConfigToDB(normalizedConfig);
+      await aiProviderInitService.switchProvider(normalizedConfig);
+      if (packageSettings) {
+        const updatedSettings = {
+          ...packageSettings,
+          aiProvider: normalizedConfig
+        };
+        if (normalizedConfig.defaultModel) {
+          updatedSettings.defaultModel = normalizedConfig.defaultModel;
+        }
+        usePackageSettingsStore.setState({ settings: updatedSettings });
+      }
+      setProviderConfig(applyDefaultModel(normalizedConfig));
+      setSaveResult({ state: "success", message: "Saved. Chat now uses this provider." });
+      debugLogger.info("Provider configuration saved and switched", {
+        type: normalizedConfig.type
+      });
+    } catch (error) {
+      debugLogger.error("Failed to save provider configuration:", { error });
+      setSaveResult({
+        state: "error",
+        message: `Couldn't save or switch provider: ${error instanceof Error ? error.message : "unknown error"}`
+      });
+    }
+  };
+  const handleTestProviderConnection = async () => {
+    setTestResult({ state: "pending" });
+    try {
+      const testConfig = sanitizeConfigForSave(providerConfig);
+      const normalizedTestConfig = convertAnthropicConfig(testConfig) || testConfig;
+      const testProvider = AIProviderFactory.createProvider(normalizedTestConfig);
+      const result = await testProvider.validateServiceAvailability({ timeoutMs: 1e4 });
+      if (result.isAvailable) {
+        setTestResult({
+          state: "success",
+          message: "Connected. The provider responded."
+        });
+      } else {
+        setTestResult({
+          state: "error",
+          message: "Couldn't reach the provider. Check the URL and key."
+        });
+      }
+    } catch (error) {
+      debugLogger.error("Provider connection test failed:", { error });
+      setTestResult({
+        state: "error",
+        message: `Connection test failed${error instanceof Error && error.message ? `: ${error.message}` : "."}`
+      });
+    }
+  };
+  const resultColor = (state) => state === "success" ? "success.main" : state === "error" ? "error.main" : "text.secondary";
+  return /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsxs2(Box2, { children: [
+      currentProvider ? /* @__PURE__ */ jsxs2(
+        Paper,
+        {
+          variant: "outlined",
+          sx: { p: { xs: 1.5, sm: 1.75 }, mb: { xs: 1.5, md: 1.75 } },
+          children: [
+            /* @__PURE__ */ jsx2(
+              Typography2,
+              {
+                variant: "overline",
+                sx: {
+                  fontWeight: 700,
+                  color: "text.secondary",
+                  letterSpacing: 0.6,
+                  display: "block",
+                  mb: 1
+                },
+                children: "Current provider"
+              }
+            ),
+            /* @__PURE__ */ jsxs2(
+              Box2,
+              {
+                sx: {
+                  display: "flex",
+                  alignItems: "center",
+                  gap: 1.5,
+                  flexWrap: "wrap",
+                  minWidth: 0
+                },
+                children: [
+                  /* @__PURE__ */ jsx2(
+                    Chip2,
+                    {
+                      label: currentProvider.getProviderType().toUpperCase(),
+                      color: "primary",
+                      variant: "outlined",
+                      size: "small"
+                    }
+                  ),
+                  /* @__PURE__ */ jsx2(
+                    Typography2,
+                    {
+                      variant: "body2",
+                      color: "text.secondary",
+                      sx: { wordBreak: "break-all", minWidth: 0 },
+                      children: currentProviderConfig?.baseUrl || currentProviderConfig?.gatewayUrl || "No URL configured"
+                    }
+                  )
+                ]
+              }
+            )
+          ]
+        }
+      ) : /* @__PURE__ */ jsx2(Box2, { sx: { mb: { xs: 1.5, md: 1.75 } }, children: /* @__PURE__ */ jsx2(
+        ManagementEmptyState,
+        {
+          compact: true,
+          icon: /* @__PURE__ */ jsx2(Settings, {}),
+          title: "No provider configured",
+          description: "A provider is the model service Bandit sends chat requests to, such as the Bandit gateway, Ollama or OpenAI. Chat won't answer until one is saved.",
+          action: /* @__PURE__ */ jsx2(Button, { variant: "contained", onClick: revealProviderForm, children: "Configure a provider" })
+        }
+      ) }),
+      /* @__PURE__ */ jsxs2(
+        Paper,
+        {
+          ref: formRef,
+          variant: "outlined",
+          sx: {
+            p: { xs: 1.5, sm: 1.75 },
+            mb: { xs: 1.5, md: 1.75 },
+            scrollMarginTop: 16
+          },
+          children: [
+            /* @__PURE__ */ jsx2(
+              Typography2,
+              {
+                variant: "overline",
+                sx: {
+                  fontWeight: 700,
+                  color: "text.secondary",
+                  letterSpacing: 0.6,
+                  display: "block"
+                },
+                children: "Provider configuration"
+              }
+            ),
+            /* @__PURE__ */ jsx2(Typography2, { variant: "body2", color: "text.secondary", sx: { mb: 2 }, children: "Changes here apply only when you select Save and switch provider." }),
+            /* @__PURE__ */ jsxs2(Box2, { children: [
+              /* @__PURE__ */ jsxs2(
+                TextField,
+                {
+                  label: "Provider type",
+                  select: true,
+                  inputRef: providerTypeRef,
+                  value: providerConfig.type,
+                  onChange: (e) => handleProviderTypeChange(e.target.value),
+                  fullWidth: true,
+                  sx: { mb: 3 },
+                  children: [
+                    /* @__PURE__ */ jsx2(MenuItem, { value: "gateway", children: "Gateway (Recommended)" }),
+                    /* @__PURE__ */ jsx2(MenuItem, { value: "ollama", children: "Ollama" }),
+                    /* @__PURE__ */ jsx2(MenuItem, { value: "openai", children: "OpenAI" }),
+                    /* @__PURE__ */ jsx2(MenuItem, { value: "azure-openai", children: "Azure OpenAI" }),
+                    /* @__PURE__ */ jsx2(MenuItem, { value: "bandit", children: "Bandit AI" }),
+                    /* @__PURE__ */ jsx2(MenuItem, { value: "xai", children: "xAI" }),
+                    /* @__PURE__ */ jsx2(MenuItem, { value: "playground", children: "Playground (Mock Demo)" })
+                  ]
+                }
+              ),
+              providerConfig.type === "gateway" && /* @__PURE__ */ jsxs2(Box2, { children: [
+                /* @__PURE__ */ jsx2(
+                  TextField,
+                  {
+                    label: "Gateway URL",
+                    value: providerConfig.gatewayUrl || "",
+                    onChange: (e) => setProviderConfig({ ...providerConfig, gatewayUrl: e.target.value }),
+                    fullWidth: true,
+                    sx: { mb: 2 },
+                    placeholder: "https://your-gateway-api.com"
+                  }
+                ),
+                /* @__PURE__ */ jsxs2(
+                  TextField,
+                  {
+                    label: "Backend provider",
+                    select: true,
+                    value: providerConfig.provider || "openai",
+                    onChange: (e) => setProviderConfig({
+                      ...providerConfig,
+                      provider: e.target.value
+                    }),
+                    fullWidth: true,
+                    sx: { mb: 2 },
+                    children: [
+                      /* @__PURE__ */ jsx2(MenuItem, { value: "openai", children: "OpenAI" }),
+                      /* @__PURE__ */ jsx2(MenuItem, { value: "azure-openai", children: "Azure OpenAI" }),
+                      /* @__PURE__ */ jsx2(MenuItem, { value: "anthropic", children: "Anthropic" }),
+                      /* @__PURE__ */ jsx2(MenuItem, { value: "ollama", children: "Ollama" }),
+                      /* @__PURE__ */ jsx2(MenuItem, { value: "bandit", children: "Bandit AI" }),
+                      /* @__PURE__ */ jsx2(MenuItem, { value: "xai", children: "xAI" })
+                    ]
+                  }
+                )
+              ] }),
+              providerConfig.type === "ollama" && /* @__PURE__ */ jsx2(
+                TextField,
+                {
+                  label: "Ollama URL",
+                  value: providerConfig.baseUrl || "",
+                  onChange: (e) => setProviderConfig({ ...providerConfig, baseUrl: e.target.value }),
+                  fullWidth: true,
+                  placeholder: "http://localhost:11434"
+                }
+              ),
+              providerConfig.type === "bandit" && /* @__PURE__ */ jsxs2(Box2, { children: [
+                /* @__PURE__ */ jsx2(
+                  TextField,
+                  {
+                    label: "API base URL",
+                    value: providerConfig.baseUrl || "",
+                    onChange: (e) => setProviderConfig((prev) => ({
+                      ...prev,
+                      baseUrl: e.target.value
+                    })),
+                    fullWidth: true,
+                    sx: { mb: 2 },
+                    placeholder: "https://api.burtson.ai",
+                    helperText: "Defaults to https://api.burtson.ai"
+                  }
+                ),
+                /* @__PURE__ */ jsx2(
+                  TextField,
+                  {
+                    label: "API key",
+                    type: "password",
+                    value: providerConfig.apiKey || "",
+                    onChange: (e) => setProviderConfig((prev) => ({
+                      ...prev,
+                      apiKey: e.target.value
+                    })),
+                    fullWidth: true,
+                    sx: { mb: 2 },
+                    placeholder: "bai_..."
+                  }
+                ),
+                /* @__PURE__ */ jsx2(
+                  TextField,
+                  {
+                    label: "Default model ID",
+                    value: providerConfig.defaultModel || "",
+                    onChange: (e) => setProviderConfig((prev) => ({
+                      ...prev,
+                      defaultModel: e.target.value
+                    })),
+                    fullWidth: true,
+                    placeholder: "bandit-core-1",
+                    helperText: "Example: bandit-core-1 (Bandit Core canonical alias)."
+                  }
+                )
+              ] }),
+              providerConfig.type === "openai" && /* @__PURE__ */ jsxs2(Box2, { children: [
+                /* @__PURE__ */ jsx2(
+                  TextField,
+                  {
+                    label: "API base URL",
+                    value: providerConfig.baseUrl || "",
+                    onChange: (e) => setProviderConfig((prev) => ({
+                      ...prev,
+                      baseUrl: e.target.value
+                    })),
+                    fullWidth: true,
+                    sx: { mb: 2 },
+                    placeholder: "https://api.openai.com/v1"
+                  }
+                ),
+                /* @__PURE__ */ jsx2(
+                  TextField,
+                  {
+                    label: "API key",
+                    type: "password",
+                    value: providerConfig.apiKey || "",
+                    onChange: (e) => setProviderConfig((prev) => ({
+                      ...prev,
+                      apiKey: e.target.value
+                    })),
+                    fullWidth: true,
+                    sx: { mb: 2 },
+                    placeholder: "sk-..."
+                  }
+                ),
+                /* @__PURE__ */ jsx2(
+                  TextField,
+                  {
+                    label: "Default model ID",
+                    value: providerConfig.defaultModel || "",
+                    onChange: (e) => setProviderConfig((prev) => ({
+                      ...prev,
+                      defaultModel: e.target.value
+                    })),
+                    fullWidth: true,
+                    placeholder: "gpt-4o-mini",
+                    helperText: "Example: gpt-4o-mini, gpt-4.1, gpt-3.5-turbo"
+                  }
+                )
+              ] }),
+              providerConfig.type === "azure-openai" && /* @__PURE__ */ jsxs2(Box2, { children: [
+                /* @__PURE__ */ jsx2(
+                  TextField,
+                  {
+                    label: "Azure endpoint",
+                    value: providerConfig.baseUrl || "",
+                    onChange: (e) => setProviderConfig({ ...providerConfig, baseUrl: e.target.value }),
+                    fullWidth: true,
+                    sx: { mb: 2 },
+                    placeholder: "https://your-resource.openai.azure.com"
+                  }
+                ),
+                /* @__PURE__ */ jsx2(
+                  TextField,
+                  {
+                    label: "API key",
+                    type: "password",
+                    value: providerConfig.apiKey || "",
+                    onChange: (e) => setProviderConfig({ ...providerConfig, apiKey: e.target.value }),
+                    fullWidth: true,
+                    sx: { mb: 2 }
+                  }
+                ),
+                /* @__PURE__ */ jsx2(
+                  TextField,
+                  {
+                    label: "API version",
+                    value: providerConfig.apiVersion || "",
+                    onChange: (e) => setProviderConfig({ ...providerConfig, apiVersion: e.target.value }),
+                    fullWidth: true,
+                    sx: { mb: 2 },
+                    placeholder: "2024-02-01"
+                  }
+                ),
+                /* @__PURE__ */ jsx2(
+                  TextField,
+                  {
+                    label: "Deployment name",
+                    value: providerConfig.deploymentName || "",
+                    onChange: (e) => setProviderConfig({
+                      ...providerConfig,
+                      deploymentName: e.target.value
+                    }),
+                    fullWidth: true,
+                    placeholder: "gpt-4"
+                  }
+                )
+              ] }),
+              providerConfig.type === "xai" && /* @__PURE__ */ jsxs2(Box2, { children: [
+                /* @__PURE__ */ jsx2(
+                  TextField,
+                  {
+                    label: "API base URL",
+                    value: providerConfig.baseUrl || "",
+                    onChange: (e) => setProviderConfig((prev) => ({
+                      ...prev,
+                      baseUrl: e.target.value
+                    })),
+                    fullWidth: true,
+                    sx: { mb: 2 },
+                    placeholder: "https://api.x.ai/v1"
+                  }
+                ),
+                /* @__PURE__ */ jsx2(
+                  TextField,
+                  {
+                    label: "API key",
+                    type: "password",
+                    value: providerConfig.apiKey || "",
+                    onChange: (e) => setProviderConfig((prev) => ({
+                      ...prev,
+                      apiKey: e.target.value
+                    })),
+                    fullWidth: true,
+                    sx: { mb: 2 },
+                    placeholder: "xai-..."
+                  }
+                ),
+                /* @__PURE__ */ jsx2(
+                  TextField,
+                  {
+                    label: "Default model ID",
+                    value: providerConfig.defaultModel || "",
+                    onChange: (e) => setProviderConfig((prev) => ({
+                      ...prev,
+                      defaultModel: e.target.value
+                    })),
+                    fullWidth: true,
+                    placeholder: "grok-beta",
+                    helperText: "Example: grok-beta, grok-2, grok-vision-beta"
+                  }
+                )
+              ] }),
+              providerConfig.type === "anthropic" && /* @__PURE__ */ jsx2(Alert, { severity: "warning", sx: { mt: 2 }, children: "Anthropic is only supported through the Bandit Gateway provider. Please switch to Gateway and select Anthropic as the backend service." }),
+              /* @__PURE__ */ jsxs2(Box2, { sx: { display: "flex", flexWrap: "wrap", gap: 1.5, mt: 3 }, children: [
+                /* @__PURE__ */ jsx2(
+                  Button,
+                  {
+                    variant: "outlined",
+                    onClick: handleTestProviderConnection,
+                    disabled: !providerConfig.type || testResult.state === "pending",
+                    startIcon: testResult.state === "pending" ? /* @__PURE__ */ jsx2(CircularProgress, { size: 14, color: "inherit" }) : void 0,
+                    children: testResult.state === "pending" ? "Testing\u2026" : "Test connection"
+                  }
+                ),
+                /* @__PURE__ */ jsx2(
+                  Button,
+                  {
+                    variant: "contained",
+                    onClick: handleSaveProviderConfig,
+                    disabled: !providerConfig.type || saveResult.state === "pending",
+                    startIcon: saveResult.state === "pending" ? /* @__PURE__ */ jsx2(CircularProgress, { size: 14, color: "inherit" }) : void 0,
+                    children: saveResult.state === "pending" ? "Saving\u2026" : "Save & switch provider"
+                  }
+                )
+              ] }),
+              (testResult.state === "success" || testResult.state === "error" || saveResult.state === "success" || saveResult.state === "error") && /* @__PURE__ */ jsxs2(Stack, { spacing: 0.5, sx: { mt: 1.5 }, role: "status", "aria-live": "polite", children: [
+                (testResult.state === "success" || testResult.state === "error") && /* @__PURE__ */ jsx2(
+                  Typography2,
+                  {
+                    variant: "body2",
+                    sx: { color: resultColor(testResult.state) },
+                    "data-testid": "provider-test-result",
+                    children: testResult.message
+                  }
+                ),
+                (saveResult.state === "success" || saveResult.state === "error") && /* @__PURE__ */ jsx2(
+                  Typography2,
+                  {
+                    variant: "body2",
+                    sx: { color: resultColor(saveResult.state) },
+                    "data-testid": "provider-save-result",
+                    children: saveResult.message
+                  }
+                )
+              ] })
+            ] })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        Typography2,
+        {
+          variant: "caption",
+          color: "text.secondary",
+          sx: { display: "block", mt: 0.5, lineHeight: 1.5 },
+          children: "Gateway is recommended for production. It routes requests through your backend, keeps API keys server-side, and adds rate limiting and monitoring."
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx2(
+      Snackbar,
+      {
+        open: showSnackbar,
+        autoHideDuration: 6e3,
+        onClose: () => setShowSnackbar(false),
+        anchorOrigin: { vertical: "bottom", horizontal: "left" },
+        children: /* @__PURE__ */ jsx2(
+          Alert,
+          {
+            onClose: () => setShowSnackbar(false),
+            severity: snackbarSeverity,
+            variant: "filled",
+            sx: { width: "100%" },
+            children: snackbarMessage
+          }
+        )
+      }
+    )
+  ] });
+};
+
+export {
+  aiProviderInitService,
+  useGatewayHealth,
+  useGatewayModels,
+  useGatewayMemory,
+  ServiceStatusCard,
+  ProviderTab
+};
+//# sourceMappingURL=chunk-2THUYNVU.mjs.map