openfox 0.2.3 → 1.0.0

package/dist/chunk-M2C5GEQR.js

@@ -0,0 +1,137 @@
+import {
+  logger
+} from "./chunk-PNBH3RAX.js";
+
+// src/server/llm/vision-fallback.ts
+var DEFAULT_CONFIG = {
+  enabled: false,
+  url: "http://localhost:11434",
+  model: "qwen3-vl:2b",
+  timeout: 12e4
+};
+var config = { ...DEFAULT_CONFIG };
+var configLoaded = false;
+var descriptionCache = /* @__PURE__ */ new Map();
+function clearDescriptionCache() {
+  descriptionCache.clear();
+}
+function setVisionFallbackConfig(newConfig) {
+  config = { ...config, ...newConfig };
+  configLoaded = true;
+  logger.debug("Vision fallback config updated", { config });
+}
+function getVisionFallbackConfig() {
+  return { ...config };
+}
+function isVisionFallbackEnabled() {
+  return config.enabled;
+}
+async function ensureVisionFallbackConfigLoaded() {
+  if (configLoaded) return;
+  try {
+    const { loadGlobalConfig, getVisionFallback } = await import("./config-GIFCEJDU.js");
+    const { getRuntimeConfig } = await import("./runtime-config-2XJJIMSC.js");
+    const runtimeConfig = getRuntimeConfig();
+    const mode = runtimeConfig.mode ?? "production";
+    const globalConfig = await loadGlobalConfig(mode);
+    const fallback = getVisionFallback(globalConfig);
+    config = {
+      enabled: fallback.enabled ?? false,
+      url: fallback.url ?? "http://localhost:11434",
+      model: fallback.model ?? "qwen3-vl:2b",
+      timeout: (fallback.timeout ?? 120) * 1e3
+    };
+    configLoaded = true;
+    logger.debug("Vision fallback config loaded from global config", { config });
+  } catch (error) {
+    logger.warn("Failed to load vision fallback config from global config", { error: error instanceof Error ? error.message : String(error) });
+  }
+}
+var IMAGE_PROMPT = `Describe this image in detail. Focus on:
+- What the image shows (UI, diagram, photo, etc.)
+- Any text visible in the image
+- Layout and visual structure
+- Key elements and their relationships
+
+Provide a concise but comprehensive description.`;
+async function describeImage(base64Data, options) {
+  await ensureVisionFallbackConfigLoaded();
+  if (!config.enabled) {
+    return "[Image - vision fallback not enabled]";
+  }
+  const cacheKey = `${base64Data.slice(0, 100)}:${options?.context ?? ""}`;
+  const cached = descriptionCache.get(cacheKey);
+  if (cached) {
+    logger.debug("Using cached image description");
+    return cached;
+  }
+  const timeout = options?.timeout ?? config.timeout;
+  try {
+    const url = `${config.url}/api/chat`;
+    const requestBody = {
+      model: config.model,
+      messages: [
+        {
+          role: "user",
+          content: options?.context ? `${IMAGE_PROMPT}
+
+Context: ${options.context}` : IMAGE_PROMPT,
+          images: [base64Data]
+        }
+      ],
+      stream: false,
+      think: false
+    };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestBody),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      logger.error("Vision fallback API error", { status: response.status, error: errorText });
+      return `[Image description failed: HTTP ${response.status}]`;
+    }
+    const data = await response.json();
+    const description = data.message?.content?.trim();
+    if (!description) {
+      logger.warn("Vision fallback returned empty description");
+      return "[Image - could not describe]";
+    }
+    descriptionCache.set(cacheKey, description);
+    logger.debug("Cached image description", { cacheKey: cacheKey.slice(0, 20) });
+    return description;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    logger.error("Vision fallback error", { error: message });
+    if (message.includes("abort")) {
+      return "[Image description timed out]";
+    }
+    return `[Image description failed: ${message}]`;
+  }
+}
+async function describeImageFromDataUrl(dataUrl, options) {
+  const base64Match = dataUrl.match(/^data:image\/[^;]+;base64,(.+)$/);
+  if (!base64Match || !base64Match[1]) {
+    return "[Invalid image data URL]";
+  }
+  return describeImage(base64Match[1], options);
+}
+
+export {
+  descriptionCache,
+  clearDescriptionCache,
+  setVisionFallbackConfig,
+  getVisionFallbackConfig,
+  isVisionFallbackEnabled,
+  ensureVisionFallbackConfigLoaded,
+  describeImage,
+  describeImageFromDataUrl
+};
+//# sourceMappingURL=chunk-M2C5GEQR.js.map

package/dist/{chunk-U62ZECSQ.js → chunk-PNBH3RAX.js}

@@ -8,7 +8,7 @@ var LEVELS = {
 var currentLevel = "info";
 function setLogLevel(level, mode) {
   if (mode && !level) {
-    currentLevel = mode === "development" ? "debug" : "warn";
+    currentLevel = mode === "development" ? "debug" : mode === "test" ? "error" : "warn";
   } else {
     currentLevel = level ?? "info";
   }
@@ -51,4 +51,4 @@ export {
   setLogLevel,
   logger
 };
-//# sourceMappingURL=chunk-U62ZECSQ.js.map
+//# sourceMappingURL=chunk-PNBH3RAX.js.map

package/dist/chunk-QDEKU5RL.js

@@ -0,0 +1,75 @@
+import {
+  logger
+} from "./chunk-PNBH3RAX.js";
+
+// src/server/session/name-generator.ts
+var SESSION_NAME_PROMPT = `Generate a concise, descriptive session name (max 50 characters) based on the user's message.
+Return ONLY the name, nothing else.
+
+Example inputs and outputs:
+- "How do I set up React?" \u2192 "React setup"
+- "Fix the authentication bug" \u2192 "Fix authentication bug"
+- "Add unit tests for the API" \u2192 "Add API unit tests"
+
+User message: {message}`;
+async function generateSessionName(options) {
+  const { userMessage, llmClient, signal } = options;
+  try {
+    logger.debug("Generating session name", { messagePreview: userMessage.slice(0, 50) });
+    const prompt = SESSION_NAME_PROMPT.replace("{message}", userMessage);
+    const messages = [
+      {
+        role: "user",
+        content: prompt
+      }
+    ];
+    const timeoutSignal = AbortSignal.timeout(6e4);
+    const composedSignal = signal ? AbortSignal.any([timeoutSignal, signal]) : timeoutSignal;
+    const response = await llmClient.complete({
+      messages,
+      tools: [],
+      signal: composedSignal,
+      disableThinking: true
+    });
+    let name = response.content.trim();
+    if (name.length > 50) {
+      name = name.substring(0, 47) + "...";
+    }
+    if (!name || name.length < 3) {
+      return {
+        success: false,
+        error: "Generated name is too short or empty"
+      };
+    }
+    logger.debug("Session name generated successfully", { name });
+    return {
+      success: true,
+      name
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error generating session name";
+    logger.debug("Session name generation error", { error: errorMessage });
+    return {
+      success: false,
+      error: errorMessage
+    };
+  }
+}
+function needsNameGeneration(sessionTitle, messageCount) {
+  if (messageCount > 1) {
+    return false;
+  }
+  if (!sessionTitle || sessionTitle.trim() === "") {
+    return true;
+  }
+  if (/^Session \d+$/.test(sessionTitle)) {
+    return true;
+  }
+  return false;
+}
+
+export {
+  generateSessionName,
+  needsNameGeneration
+};
+//# sourceMappingURL=chunk-QDEKU5RL.js.map

package/dist/chunk-QYP5HQV4.js

@@ -0,0 +1,438 @@
+import {
+  clearModelCache,
+  createLLMClient,
+  detectBackend,
+  detectModel
+} from "./chunk-U6BUT37A.js";
+import {
+  logger
+} from "./chunk-PNBH3RAX.js";
+
+// src/server/provider-manager.ts
+async function fetchAvailableModelsFromBackend(baseUrl, apiKey) {
+  const url = baseUrl.includes("/v1") ? `${baseUrl}/models` : `${baseUrl}/v1/models`;
+  try {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (apiKey) {
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    const response = await fetch(url, {
+      method: "GET",
+      headers,
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      logger.debug("Failed to fetch models", { url, status: response.status });
+      return [];
+    }
+    const data = await response.json();
+    if (data.data && Array.isArray(data.data)) {
+      return data.data.map((m) => m.id).filter(Boolean);
+    }
+    return [];
+  } catch (error) {
+    logger.debug("Error fetching models from backend", { url, error: error instanceof Error ? error.message : String(error) });
+    return [];
+  }
+}
+async function fetchModelsWithContext(baseUrl, apiKey, backend) {
+  if (backend === "ollama") {
+    return fetchOllamaModelsWithContext(baseUrl, apiKey);
+  }
+  const url = baseUrl.includes("/v1") ? `${baseUrl}/models` : `${baseUrl}/v1/models`;
+  try {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (apiKey) {
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    const response = await fetch(url, {
+      method: "GET",
+      headers,
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      logger.debug("Failed to fetch models with context", { url, status: response.status });
+      return [];
+    }
+    const data = await response.json();
+    if (data.data && Array.isArray(data.data)) {
+      return data.data.map((m) => ({
+        id: m.id,
+        contextWindow: m.max_model_len ?? 2e5,
+        source: m.max_model_len ? "backend" : "default"
+      }));
+    }
+    return [];
+  } catch (error) {
+    logger.debug("Error fetching models with context", { url, error: error instanceof Error ? error.message : String(error) });
+    return [];
+  }
+}
+async function fetchOllamaModelsWithContext(baseUrl, apiKey) {
+  const tagsUrl = `${baseUrl}/api/tags`;
+  try {
+    const tagsResponse = await fetch(tagsUrl, {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!tagsResponse.ok) {
+      logger.debug("Failed to fetch Ollama tags", { url: tagsUrl });
+      return [];
+    }
+    const tagsData = await tagsResponse.json();
+    if (!tagsData.models || !Array.isArray(tagsData.models)) {
+      return [];
+    }
+    const modelsWithContext = [];
+    for (const model of tagsData.models) {
+      try {
+        const showUrl = `${baseUrl}/api/show`;
+        const showResponse = await fetch(showUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ name: model.name, verbose: true }),
+          signal: AbortSignal.timeout(5e3)
+        });
+        if (showResponse.ok) {
+          const showData = await showResponse.json();
+          const contextLength = showData.model_info?.llama?.context_length ?? showData.model_info?.context_length ?? 2e5;
+          modelsWithContext.push({
+            id: model.name,
+            contextWindow: contextLength,
+            source: contextLength !== 2e5 ? "backend" : "default"
+          });
+        } else {
+          modelsWithContext.push({
+            id: model.name,
+            contextWindow: 2e5,
+            source: "default"
+          });
+        }
+      } catch (error) {
+        logger.debug("Failed to fetch Ollama model context", {
+          model: model.name,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        modelsWithContext.push({
+          id: model.name,
+          contextWindow: 2e5,
+          source: "default"
+        });
+      }
+    }
+    return modelsWithContext;
+  } catch (error) {
+    logger.debug("Error fetching Ollama models", { url: baseUrl, error: error instanceof Error ? error.message : String(error) });
+    return [];
+  }
+}
+function parseDefaultModelSelection(selection) {
+  if (!selection) return { providerId: void 0, model: void 0 };
+  const slashIndex = selection.indexOf("/");
+  if (slashIndex === -1) return { providerId: selection, model: "auto" };
+  return {
+    providerId: selection.substring(0, slashIndex),
+    model: selection.substring(slashIndex + 1)
+  };
+}
+function createProviderManager(config) {
+  let providers = [...config.providers ?? []];
+  const { providerId: initialProviderId, model: initialModel } = parseDefaultModelSelection(config.defaultModelSelection);
+  let defaultModelSelection = config.defaultModelSelection;
+  let llmClient = createLLMClient(config);
+  const providerStatus = /* @__PURE__ */ new Map();
+  logger.debug("ProviderManager created", { providers: providers.map((p) => ({ id: p.id, models: p.models.map((m) => ({ id: m.id, contextWindow: m.contextWindow, source: m.source })) })) });
+  for (const p of providers) {
+    providerStatus.set(p.id, "unknown");
+  }
+  function createConfigForProvider(provider, model) {
+    return {
+      ...config,
+      llm: {
+        ...config.llm,
+        baseUrl: provider.url.includes("/v1") ? provider.url : `${provider.url}/v1`,
+        model,
+        backend: provider.backend
+      }
+    };
+  }
+  return {
+    getProviders() {
+      return [...providers];
+    },
+    getActiveProvider() {
+      const { providerId } = parseDefaultModelSelection(defaultModelSelection);
+      if (!providerId) return void 0;
+      return providers.find((p) => p.id === providerId);
+    },
+    getActiveProviderId() {
+      const { providerId } = parseDefaultModelSelection(defaultModelSelection);
+      return providerId;
+    },
+    getCurrentModel() {
+      const { model } = parseDefaultModelSelection(defaultModelSelection);
+      return model;
+    },
+    getLLMClient() {
+      return llmClient;
+    },
+    async activateProvider(providerId, options) {
+      const provider = providers.find((p) => p.id === providerId);
+      if (!provider) {
+        return { success: false, error: "Provider not found" };
+      }
+      const currentModel = parseDefaultModelSelection(defaultModelSelection).model ?? "auto";
+      const targetModel = options?.model ?? currentModel;
+      const isModelSwitch = providerId === parseDefaultModelSelection(defaultModelSelection).providerId && options?.model && options.model !== currentModel;
+      if (providerId === parseDefaultModelSelection(defaultModelSelection).providerId && !isModelSwitch) {
+        return { success: true };
+      }
+      logger.info("Switching provider", {
+        from: parseDefaultModelSelection(defaultModelSelection).providerId,
+        to: providerId,
+        providerName: provider.name,
+        url: provider.url,
+        model: targetModel
+      });
+      const providerConfig = createConfigForProvider(provider, targetModel);
+      const newClient = createLLMClient(providerConfig);
+      try {
+        const url = provider.url.includes("/v1") ? provider.url.replace("/v1", "") : provider.url;
+        clearModelCache(url);
+        const backend = provider.backend;
+        const modelsWithContext = await fetchModelsWithContext(url, provider.apiKey, backend);
+        const normalize = (s) => s.toLowerCase().replace(/[-_\s:.]+/g, "");
+        const userModels = provider.models.filter((m) => m.source === "user");
+        logger.debug("activateProvider", { providerId, backendModelsCount: modelsWithContext.length, userModelsCount: userModels.length, userModels: userModels.map((m) => ({ id: m.id, contextWindow: m.contextWindow })) });
+        if (modelsWithContext.length > 0) {
+          const updatedModels = modelsWithContext.map((m) => {
+            let existingModel = provider.models.find((pm) => pm.id === m.id);
+            if (!existingModel) {
+              const normalizedId = normalize(m.id);
+              existingModel = provider.models.find((pm) => {
+                if (pm.source !== "user") return false;
+                return normalize(pm.id) === normalizedId;
+              });
+            }
+            if (existingModel && existingModel.source === "user") {
+              return { ...existingModel, id: m.id };
+            }
+            return m;
+          });
+          for (const userModel of userModels) {
+            const normalizedUserId = normalize(userModel.id);
+            const matchedInUpdated = updatedModels.some((m) => {
+              const normalizedBackendId = normalize(m.id);
+              return normalizedBackendId === normalizedUserId;
+            });
+            if (!matchedInUpdated) {
+              updatedModels.push(userModel);
+            }
+          }
+          providers = providers.map((p) => p.id === providerId ? { ...p, models: updatedModels } : p);
+        } else if (userModels.length > 0) {
+          logger.debug("Backend unavailable during provider switch, preserving user models", { providerId, userModelsCount: userModels.length });
+          providers = providers.map((p) => p.id === providerId ? { ...p, models: userModels } : p);
+        }
+        if (provider.backend === "auto") {
+          const detected = await detectBackend(url);
+          newClient.setBackend(detected);
+        } else {
+          newClient.setBackend(provider.backend);
+        }
+        if (targetModel === "auto") {
+          const detected = await detectModel(url);
+          if (detected) {
+            newClient.setModel(detected);
+          }
+        } else {
+          newClient.setModel(targetModel);
+        }
+        providerStatus.set(providerId, "connected");
+      } catch (err) {
+        logger.warn("Could not connect to provider", {
+          providerId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        providerStatus.set(providerId, "disconnected");
+      }
+      providers = providers.map((p) => ({
+        ...p,
+        isActive: p.id === providerId
+      }));
+      defaultModelSelection = `${providerId}/${targetModel}`;
+      llmClient = newClient;
+      logger.info("Provider activated", {
+        providerId,
+        providerName: provider.name,
+        model: llmClient.getModel(),
+        backend: llmClient.getBackend()
+      });
+      return { success: true };
+    },
+    addProvider(providerData) {
+      const id = crypto.randomUUID();
+      const provider = {
+        ...providerData,
+        id,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (providerData.isActive || providers.length === 0) {
+        providers = providers.map((p) => ({ ...p, isActive: false }));
+        provider.isActive = true;
+        defaultModelSelection = `${id}/auto`;
+      }
+      providers.push(provider);
+      providerStatus.set(id, "unknown");
+      return provider;
+    },
+    removeProvider(providerId) {
+      const index = providers.findIndex((p) => p.id === providerId);
+      if (index === -1) return false;
+      const wasActive = providers[index]?.isActive;
+      providers.splice(index, 1);
+      providerStatus.delete(providerId);
+      if (wasActive && providers.length > 0) {
+        providers[0].isActive = true;
+        defaultModelSelection = `${providers[0].id}/auto`;
+      } else if (providers.length === 0) {
+        defaultModelSelection = void 0;
+      }
+      return true;
+    },
+    setProviders(newProviders, newDefaultModelSelection) {
+      providers = [...newProviders];
+      defaultModelSelection = newDefaultModelSelection;
+      providerStatus.clear();
+      for (const p of providers) {
+        providerStatus.set(p.id, "unknown");
+      }
+    },
+    getProviderStatus(providerId) {
+      return providerStatus.get(providerId) ?? "unknown";
+    },
+    async getProviderModels(providerId) {
+      const provider = providers.find((p) => p.id === providerId);
+      if (!provider) {
+        return [];
+      }
+      if (provider.models && provider.models.length > 0) {
+        return provider.models;
+      }
+      const url = provider.url.includes("/v1") ? provider.url.replace("/v1", "") : provider.url;
+      const backend = provider.backend;
+      return fetchModelsWithContext(url, provider.apiKey, backend);
+    },
+    async setDefaultModelSelection(providerId, model) {
+      const provider = providers.find((p) => p.id === providerId);
+      if (!provider) {
+        return { success: false, error: "Provider not found" };
+      }
+      logger.info("Setting default model selection", { providerId, model, providerName: provider.name });
+      defaultModelSelection = `${providerId}/${model}`;
+      providers = providers.map((p) => ({ ...p, isActive: p.id === providerId }));
+      const currentProviderId = parseDefaultModelSelection(defaultModelSelection).providerId;
+      if (currentProviderId === providerId) {
+        llmClient.setModel(model);
+        logger.info("Model updated", { providerId, model });
+      }
+      return { success: true };
+    },
+    getCurrentModelContext() {
+      const { providerId, model } = parseDefaultModelSelection(defaultModelSelection);
+      if (!providerId || !model) return config.context.maxTokens;
+      const provider = providers.find((p) => p.id === providerId);
+      if (!provider) return config.context.maxTokens;
+      const modelConfig = provider.models.find((m) => m.id === model);
+      return modelConfig?.contextWindow ?? config.context.maxTokens;
+    },
+    async updateModelContext(providerId, modelId, contextWindow) {
+      const provider = providers.find((p) => p.id === providerId);
+      if (!provider) {
+        return { success: false, error: "Provider not found" };
+      }
+      const modelIndex = provider.models.findIndex((m) => m.id === modelId);
+      if (modelIndex === -1) {
+        providers = providers.map(
+          (p) => p.id === providerId ? { ...p, models: [...p.models, { id: modelId, contextWindow, source: "user" }] } : p
+        );
+      } else {
+        providers = providers.map(
+          (p) => p.id === providerId ? { ...p, models: p.models.map((m, i) => i === modelIndex ? { ...m, contextWindow, source: "user" } : m) } : p
+        );
+      }
+      logger.info("Model context updated", { providerId, modelId, contextWindow });
+      return { success: true };
+    },
+    async refreshProviderModels(providerId) {
+      const provider = providers.find((p) => p.id === providerId);
+      if (!provider) {
+        return { success: false, error: "Provider not found" };
+      }
+      const url = provider.url.includes("/v1") ? provider.url.replace("/v1", "") : provider.url;
+      const backend = provider.backend;
+      const modelsWithContext = await fetchModelsWithContext(url, provider.apiKey, backend);
+      const normalize = (s) => s.toLowerCase().replace(/[-_\s:.]+/g, "");
+      const userModels = provider.models.filter((m) => m.source === "user");
+      const allModelsBefore = provider.models.map((m) => ({ id: m.id, contextWindow: m.contextWindow, source: m.source }));
+      logger.info("refreshProviderModels", { providerId, userModelsCount: userModels.length, backendModelsCount: modelsWithContext.length, userModels: userModels.map((m) => ({ id: m.id, contextWindow: m.contextWindow, source: m.source })), allModelsBefore, backendModels: modelsWithContext });
+      if (modelsWithContext.length === 0) {
+        if (userModels.length > 0) {
+          logger.debug("Backend unavailable, preserving user models", { providerId, userModels: userModels.map((m) => ({ id: m.id, contextWindow: m.contextWindow })) });
+          providers = providers.map((p) => p.id === providerId ? { ...p, models: userModels } : p);
+          const preservedProvider = providers.find((p) => p.id === providerId);
+          logger.debug("After preservation", { providerId, models: preservedProvider?.models.map((m) => ({ id: m.id, contextWindow: m.contextWindow, source: m.source })) });
+          return { success: true };
+        }
+        return { success: false, error: "No models returned from backend" };
+      }
+      const updatedModels = modelsWithContext.map((m) => {
+        let existingModel = provider.models.find((pm) => pm.id === m.id);
+        if (!existingModel) {
+          const normalizedId = normalize(m.id);
+          existingModel = provider.models.find((pm) => {
+            if (pm.source !== "user") return false;
+            return normalize(pm.id) === normalizedId;
+          });
+        }
+        if (existingModel && existingModel.source === "user") {
+          return { ...existingModel, id: m.id };
+        }
+        return m;
+      });
+      for (const userModel of userModels) {
+        const normalizedUserId = normalize(userModel.id);
+        const matchedInUpdated = updatedModels.some((m) => {
+          const normalizedBackendId = normalize(m.id);
+          return normalizedBackendId === normalizedUserId;
+        });
+        logger.debug("User model match check", { userModelId: userModel.id, normalizedUserId, matchedInUpdated, updatedModelsIds: updatedModels.map((m) => m.id) });
+        if (!matchedInUpdated) {
+          updatedModels.push(userModel);
+        }
+      }
+      providers = providers.map((p) => p.id === providerId ? { ...p, models: updatedModels } : p);
+      const { providerId: currentProviderId, model: currentModel } = parseDefaultModelSelection(defaultModelSelection);
+      if (currentProviderId === providerId && currentModel) {
+        const normalizedCurrentModel = normalize(currentModel);
+        const matchedModel = updatedModels.find((m) => normalize(m.id) === normalizedCurrentModel);
+        if (matchedModel && matchedModel.id !== currentModel) {
+          defaultModelSelection = `${providerId}/${matchedModel.id}`;
+          logger.debug("Updated defaultModelSelection after fuzzy match", { from: currentModel, to: matchedModel.id });
+        }
+      }
+      logger.info("Provider models refreshed", { providerId, modelCount: updatedModels.length });
+      return { success: true };
+    }
+  };
+}
+
+export {
+  fetchAvailableModelsFromBackend,
+  parseDefaultModelSelection,
+  createProviderManager
+};
+//# sourceMappingURL=chunk-QYP5HQV4.js.map