openfox 0.2.4 → 1.0.1

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