openfox 2.0.62 → 2.0.64

package/dist/{chunk-3WL5YCP6.js → chunk-O3G6X5CT.js}

@@ -39,7 +39,7 @@ Options:
 }
 async function runNetworkSetup(mode) {
   const { loadAuthConfig, saveAuthConfig, encryptPassword } = await import("./auth-YY5PJYSC.js");
-  const { saveGlobalConfig } = await import("./config-GMQUPNBY.js");
+  const { saveGlobalConfig } = await import("./config-EUMVEFHU.js");
   const { getAuthKeyPath } = await import("./paths-F27V3S4I.js");
   const existingAuth = await loadAuthConfig(mode);
   if (existingAuth) {
@@ -106,7 +106,7 @@ async function runNetworkSetup(mode) {
   console.log("\u2713 Configuration saved!\n");
 }
 async function runConfig(mode) {
-  const { loadGlobalConfig, getActiveProvider, getDefaultModel } = await import("./config-GMQUPNBY.js");
+  const { loadGlobalConfig, getActiveProvider, getDefaultModel } = await import("./config-EUMVEFHU.js");
   const { getGlobalConfigPath } = await import("./paths-F27V3S4I.js");
   const config = await loadGlobalConfig(mode);
   const configPath = getGlobalConfigPath(mode);
@@ -164,7 +164,7 @@ async function runCli(options) {
       break;
     }
     case "provider": {
-      const { runProviderCommand } = await import("./provider-LBYBC5AG.js");
+      const { runProviderCommand } = await import("./provider-GYOW4OWQ.js");
       const [, subcommand] = positionals;
       await runProviderCommand(mode, subcommand);
       break;
@@ -203,12 +203,12 @@ async function runCli(options) {
       break;
     }
     default: {
-      const { configFileExists } = await import("./config-GMQUPNBY.js");
+      const { configFileExists } = await import("./config-EUMVEFHU.js");
       const configExists = await configFileExists(mode);
       if (!configExists) {
         await runNetworkSetup(mode);
       }
-      const { runServe } = await import("./serve-CNA5NKOR.js");
+      const { runServe } = await import("./serve-54KALE6R.js");
       const serveOptions = { mode };
       if (values.port) serveOptions.port = parseInt(values.port);
       if (values["no-browser"] === true) serveOptions.openBrowser = false;
@@ -220,4 +220,4 @@ async function runCli(options) {
 export {
   runCli
 };
-//# sourceMappingURL=chunk-3WL5YCP6.js.map
+//# sourceMappingURL=chunk-O3G6X5CT.js.map

package/dist/{chunk-GJU35MDV.js → chunk-OESYKZCM.js}

@@ -1,7 +1,7 @@
 import {
   COMPACTION_PROMPT,
   createMessageStartEvent
-} from "./chunk-6VDCH5ML.js";
+} from "./chunk-X5YCWKNS.js";
 import {
   getCurrentWindowMessageOptions
 } from "./chunk-AIJE3RYH.js";
@@ -31,4 +31,4 @@ export {
   shouldCompact,
   getCompactionTarget
 };
-//# sourceMappingURL=chunk-GJU35MDV.js.map
+//# sourceMappingURL=chunk-OESYKZCM.js.map

package/dist/{chunk-JKLPWTUN.js → chunk-QBYQ7KDX.js}

@@ -1,3 +1,6 @@
+import {
+  getModelProfile
+} from "./chunk-V4IE7HJY.js";
 import {
   getBackendCapabilities
 } from "./chunk-YHEQTVFV.js";
@@ -17,9 +20,6 @@ import {
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
-import {
-  getModelProfile
-} from "./chunk-V4IE7HJY.js";
 
 // src/server/llm/client.ts
 function createLLMClient(config, initialBackend = "unknown") {
@@ -162,6 +162,11 @@ function createLLMClient(config, initialBackend = "unknown") {
               throw new Error(`LLM stream idle timeout: no chunks received for ${idleTimeout}ms`);
             }
             lastChunkTime = Date.now();
+            if (!Array.isArray(chunk?.choices)) {
+              const streamError = chunk?.error;
+              const errorMessage = typeof streamError === "string" ? streamError : streamError && typeof streamError === "object" && "message" in streamError && typeof streamError.message === "string" ? streamError.message : "Invalid LLM stream chunk: missing choices";
+              throw new LLMError(errorMessage);
+            }
             responseId = chunk.id;
             if (chunk.usage) {
               usage = {
@@ -259,4 +264,4 @@ function createLLMClient(config, initialBackend = "unknown") {
 export {
   createLLMClient
 };
-//# sourceMappingURL=chunk-JKLPWTUN.js.map
+//# sourceMappingURL=chunk-QBYQ7KDX.js.map

package/dist/{chunk-NVPVDDQZ.js → chunk-QJ5FH5DP.js}

@@ -1,10 +1,3 @@
-import {
-  createContextStateMessage,
-  createSessionStateMessage
-} from "./chunk-F4PMNP7S.js";
-import {
-  getPendingQuestionsForSession
-} from "./chunk-EU3WWTFH.js";
 import {
   getEventStore,
   getRuntimeConfig,
@@ -14,6 +7,13 @@ import {
   buildMessagesFromStoredEvents,
   foldPendingConfirmations
 } from "./chunk-TMUBLQFC.js";
+import {
+  createContextStateMessage,
+  createSessionStateMessage
+} from "./chunk-F4PMNP7S.js";
+import {
+  getPendingQuestionsForSession
+} from "./chunk-EU3WWTFH.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -127,11 +127,15 @@ async function generateSessionNameForSession(sessionId, userMessage, deps, signa
   const prompt = SESSION_NAME_PROMPT.replace("{message}", userMessage);
   try {
     let client;
-    if (deps.getLLMClient && providerConfig) {
+    if (providerConfig && deps.getLLMClientForProvider) {
+      const providerClient = deps.getLLMClientForProvider(providerConfig.providerId, providerConfig.model);
+      if (!providerClient) return;
+      client = providerClient;
+    } else if (deps.getLLMClient && providerConfig) {
       client = deps.getLLMClient();
       client.setModel(providerConfig.model);
     } else if (providerConfig) {
-      const { createLLMClient } = await import("./client-KRFGMNGN.js");
+      const { createLLMClient } = await import("./client-LAKW7TA5.js");
       client = createLLMClient({
         llm: {
           baseUrl: providerConfig.baseUrl,
@@ -180,4 +184,4 @@ export {
   buildRunChatTurnParams,
   generateSessionNameForSession
 };
-//# sourceMappingURL=chunk-NVPVDDQZ.js.map
+//# sourceMappingURL=chunk-QJ5FH5DP.js.map

package/dist/{chunk-H774GQJW.js → chunk-RYIREJAW.js}

@@ -1,9 +1,12 @@
-import {
-  clearModelCache
-} from "./chunk-M3RB4IF6.js";
 import {
   createLLMClient
-} from "./chunk-JKLPWTUN.js";
+} from "./chunk-QBYQ7KDX.js";
+import {
+  getModelProfile
+} from "./chunk-V4IE7HJY.js";
+import {
+  getBackendCapabilities
+} from "./chunk-YHEQTVFV.js";
 import {
   buildModelsUrl,
   ensureVersionPrefix,
@@ -12,9 +15,150 @@ import {
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
-import {
-  getModelProfile
-} from "./chunk-V4IE7HJY.js";
+
+// src/server/providers/adapters/transport-client.ts
+function createTransportLLMClient(provider, modelId, transport) {
+  let model = modelId;
+  let backend = provider.backend;
+  const profileFor = (id) => {
+    const base = getModelProfile(id);
+    const configured = provider.models.find((item) => item.id === id);
+    return {
+      ...base,
+      ...configured?.defaultTemperature !== void 0 && { temperature: configured.defaultTemperature },
+      ...configured?.defaultTopP !== void 0 && { topP: configured.defaultTopP },
+      ...configured?.defaultTopK !== void 0 && { topK: configured.defaultTopK },
+      ...configured?.defaultMaxTokens !== void 0 && { defaultMaxTokens: configured.defaultMaxTokens },
+      ...configured?.supportsVision !== void 0 && { supportsVision: configured.supportsVision }
+    };
+  };
+  let profile = profileFor(model);
+  void getBackendCapabilities(backend);
+  const context = () => {
+    const configured = provider.models.find((item) => item.id === model);
+    return {
+      providerId: provider.id,
+      model: configured?.apiModelId ?? model,
+      catalogModel: model,
+      ...configured?.requestBody && { requestBody: configured.requestBody },
+      ...provider.credentialRef && { credentialRef: provider.credentialRef }
+    };
+  };
+  return {
+    getModel: () => model,
+    setModel(next) {
+      model = next;
+      profile = profileFor(next);
+    },
+    getProfile: () => profile,
+    getBackend: () => backend,
+    setBackend(next) {
+      backend = next;
+    },
+    complete: (request) => transport.complete(request, context()),
+    stream: (request) => transport.stream(request, context())
+  };
+}
+
+// src/server/llm/models.ts
+var modelCache = /* @__PURE__ */ new Map();
+var llmStatus = "unknown";
+var lastActiveUrl = null;
+var CACHE_TTL_MS = 3e4;
+function getCacheKey(url) {
+  return stripVersionPrefix(url);
+}
+async function detectModel(llmBaseUrl, retries = 3, silent = false) {
+  const cacheKey = getCacheKey(llmBaseUrl);
+  const now = Date.now();
+  const cached = modelCache.get(cacheKey);
+  if (cached && now - cached.timestamp < CACHE_TTL_MS) {
+    lastActiveUrl = cacheKey;
+    llmStatus = "connected";
+    return cached.model;
+  }
+  const url = buildModelsUrl(llmBaseUrl);
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      if (silent) {
+        logger.debug("Fetching models from LLM server", { url, attempt });
+      }
+      const response = await fetch(url, {
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!response.ok) {
+        if (silent) {
+          logger.debug("Failed to fetch models from LLM server", { status: response.status, attempt });
+        } else {
+          logger.warn("Failed to fetch models from LLM server", { status: response.status, attempt });
+        }
+        if (attempt < retries) {
+          await new Promise((r) => setTimeout(r, 1e3 * attempt));
+          continue;
+        }
+        llmStatus = "disconnected";
+        return cached?.model ?? null;
+      }
+      const data = await response.json();
+      if (data.data && data.data.length > 0) {
+        const modelData = data.data[0];
+        const modelId = modelData.id;
+        modelCache.set(cacheKey, {
+          model: modelId,
+          modelInfo: modelData,
+          timestamp: now
+        });
+        lastActiveUrl = cacheKey;
+        llmStatus = "connected";
+        if (silent) {
+          logger.debug("Detected LLM model", {
+            model: modelId,
+            maxLen: modelData.max_model_len,
+            root: modelData.root
+          });
+        } else {
+          logger.info("Detected LLM model", {
+            model: modelId,
+            maxLen: modelData.max_model_len,
+            root: modelData.root
+          });
+        }
+        return modelId;
+      }
+      if (silent) {
+        logger.debug("LLM server returned empty models list");
+      } else {
+        logger.warn("LLM server returned empty models list");
+      }
+      llmStatus = "disconnected";
+      return null;
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      if (silent) {
+        logger.debug("Could not detect model from LLM server", { error: errMsg, attempt });
+      } else {
+        logger.warn("Could not detect model from LLM server", { error: errMsg, attempt });
+      }
+      if (attempt < retries) {
+        await new Promise((r) => setTimeout(r, 1e3 * attempt));
+        continue;
+      }
+    }
+  }
+  llmStatus = "disconnected";
+  return cached?.model ?? null;
+}
+function getLlmStatus() {
+  return llmStatus;
+}
+function clearModelCache(url) {
+  if (url) {
+    modelCache.delete(getCacheKey(url));
+  } else {
+    modelCache.clear();
+  }
+  llmStatus = "unknown";
+}
 
 // src/server/provider-manager.ts
 function normalizeModelId(s) {
@@ -54,19 +198,21 @@ function enrichWithProfileDefaults(model) {
     defaultMaxTokens: profile.defaultMaxTokens
   };
 }
-function mergeModelsWithUserOverrides(backendModels, userModels) {
+function mergeModelsWithUserOverrides(backendModels, userModels, preserveMissingUserModels = true) {
   const normalizedUserIdMap = new Map(userModels.map((m) => [normalizeModelId(m.id), m]));
   const updatedModels = backendModels.map((backendModel) => {
     const existingUserModel = normalizedUserIdMap.get(normalizeModelId(backendModel.id));
     if (existingUserModel) {
-      return enrichWithProfileDefaults({ ...existingUserModel, id: backendModel.id });
+      return enrichWithProfileDefaults({ ...backendModel, ...existingUserModel, id: backendModel.id });
     }
     return enrichWithProfileDefaults(backendModel);
   });
-  const normalizedBackendIds = new Set(backendModels.map((m) => normalizeModelId(m.id)));
-  for (const userModel of userModels) {
-    if (!normalizedBackendIds.has(normalizeModelId(userModel.id))) {
-      updatedModels.push(enrichWithProfileDefaults(userModel));
+  if (preserveMissingUserModels) {
+    const normalizedBackendIds = new Set(backendModels.map((m) => normalizeModelId(m.id)));
+    for (const userModel of userModels) {
+      if (!normalizedBackendIds.has(normalizeModelId(userModel.id))) {
+        updatedModels.push(enrichWithProfileDefaults(userModel));
+      }
     }
   }
   return updatedModels;
@@ -214,7 +360,7 @@ function parseDefaultModelSelection(selection) {
     model: selection.substring(slashIndex + 1)
   };
 }
-function createProviderManager(config) {
+function createProviderManager(config, options = {}) {
   let providers = [...config.providers ?? []];
   providers = providers.map((p) => ({ ...p, models: p.models.map((m) => enrichWithProfileDefaults(m)) }));
   let defaultModelSelection = config.defaultModelSelection;
@@ -252,14 +398,56 @@ function createProviderManager(config) {
       }
     };
   }
+  function resolveTransportAdapter(provider) {
+    if (provider.transportAdapter) return provider.transportAdapter;
+    return void 0;
+  }
+  function resolveProviderModel(provider, requestedModel) {
+    if (requestedModel && requestedModel !== "auto") return requestedModel;
+    const activeSelection = parseDefaultModelSelection(defaultModelSelection);
+    if (activeSelection.providerId === provider.id) {
+      const activeClientModel = llmClient.getModel();
+      if (activeClientModel && activeClientModel !== "auto" && provider.models.some((m) => m.id === activeClientModel)) {
+        return activeClientModel;
+      }
+      if (activeSelection.model && activeSelection.model !== "auto" && provider.models.some((m) => m.id === activeSelection.model)) {
+        return activeSelection.model;
+      }
+    }
+    return provider.models.find((m) => m.selected)?.id ?? provider.models[0]?.id ?? requestedModel ?? "auto";
+  }
+  function createClientForProvider(provider, model) {
+    const resolvedModel = resolveProviderModel(provider, model);
+    const transport = options.adapters?.getTransport(resolveTransportAdapter(provider));
+    return transport ? createTransportLLMClient(provider, resolvedModel, transport) : createLLMClient(createConfigForProvider(provider, resolvedModel));
+  }
+  async function fetchProviderModels(provider) {
+    const transport = options.adapters?.getTransport(resolveTransportAdapter(provider));
+    if (transport) {
+      return transport.listModels({
+        providerId: provider.id,
+        ...provider.credentialRef && { credentialRef: provider.credentialRef }
+      });
+    }
+    const backend = provider.backend;
+    return fetchModelsWithContext(provider.url, provider.apiKey, backend);
+  }
   const { providerId: activeProviderId, model: activeModel } = parseDefaultModelSelection(defaultModelSelection);
   if (activeProviderId && activeModel) {
     const activeProvider = providers.find((p) => p.id === activeProviderId);
     if (activeProvider) {
-      llmClient = createLLMClient(createConfigForProvider(activeProvider, activeModel));
+      llmClient = createClientForProvider(activeProvider, activeModel);
     }
   }
   return {
+    createClient(providerId, model) {
+      const provider = providers.find((p) => p.id === providerId);
+      return provider ? createClientForProvider(provider, model) : void 0;
+    },
+    resolveModel(providerId, model) {
+      const provider = providers.find((p) => p.id === providerId);
+      return provider ? resolveProviderModel(provider, model) : void 0;
+    },
     getProviders() {
       return providers.map((p) => ({
         ...p,
@@ -282,18 +470,16 @@ function createProviderManager(config) {
     getLLMClient() {
       return llmClient;
     },
-    async activateProvider(providerId, options) {
+    async activateProvider(providerId, options2) {
       const provider = providers.find((p) => p.id === providerId);
       if (!provider) {
         return { success: false, error: "Provider not found" };
       }
       const currentModel = parseDefaultModelSelection(defaultModelSelection).model;
-      let targetModel = options?.model ?? currentModel;
-      if (!targetModel || targetModel === "auto") {
-        targetModel = provider.models?.[0]?.id ?? "auto";
-      }
-      const isModelSwitch = providerId === parseDefaultModelSelection(defaultModelSelection).providerId && options?.model && options.model !== currentModel;
-      if (providerId === parseDefaultModelSelection(defaultModelSelection).providerId && !isModelSwitch) {
+      const targetModel = resolveProviderModel(provider, options2?.model ?? currentModel);
+      const isModelSwitch = providerId === parseDefaultModelSelection(defaultModelSelection).providerId && options2?.model && options2.model !== currentModel;
+      if (providerId === parseDefaultModelSelection(defaultModelSelection).providerId && !isModelSwitch && llmClient.getModel() === targetModel) {
+        if (currentModel !== targetModel) defaultModelSelection = `${providerId}/${targetModel}`;
         return { success: true };
       }
       logger.info("Switching provider", {
@@ -303,8 +489,7 @@ function createProviderManager(config) {
         url: provider.url,
         model: targetModel
       });
-      const providerConfig = createConfigForProvider(provider, targetModel);
-      const newClient = createLLMClient(providerConfig);
+      const newClient = createClientForProvider(provider, targetModel);
       try {
         const cacheUrl = stripVersionPrefix(provider.url);
         clearModelCache(cacheUrl);
@@ -315,7 +500,7 @@ function createProviderManager(config) {
           url: provider.url,
           backend
         });
-        const modelsWithContext = await fetchModelsWithContext(provider.url, provider.apiKey, backend);
+        const modelsWithContext = await fetchProviderModels(provider);
         const userModels = provider.models.filter((m) => m.source === "user");
         logger.debug("activateProvider", {
           providerId,
@@ -323,7 +508,11 @@ function createProviderManager(config) {
           userModelsCount: userModels.length
         });
         if (modelsWithContext.length > 0) {
-          const updatedModels = mergeModelsWithUserOverrides(modelsWithContext, userModels);
+          const updatedModels = mergeModelsWithUserOverrides(
+            modelsWithContext,
+            userModels,
+            !resolveTransportAdapter(provider)
+          );
           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", {
@@ -389,22 +578,22 @@ function createProviderManager(config) {
       return true;
     },
     setProviders(newProviders, newDefaultModelSelection) {
-      const wasActiveProviderId = this.getActiveProviderId();
       providers = [...newProviders];
       defaultModelSelection = newDefaultModelSelection;
       providerStatus.clear();
       for (const p of providers) {
         providerStatus.set(p.id, "unknown");
       }
-      const newActiveProviderId = this.getActiveProviderId();
-      if (newActiveProviderId && newActiveProviderId !== wasActiveProviderId) {
-        const activeProvider = providers.find((p) => p.id === newActiveProviderId);
+      const activeProviderId2 = this.getActiveProviderId();
+      if (activeProviderId2) {
+        const activeProvider = providers.find((p) => p.id === activeProviderId2);
         if (activeProvider) {
-          const providerConfig = createConfigForProvider(activeProvider, this.getCurrentModel() ?? "auto");
-          llmClient = createLLMClient(providerConfig);
-          logger.info("setProviders: recreated LLM client for new active provider", {
-            providerId: newActiveProviderId,
-            url: activeProvider.url
+          llmClient = createClientForProvider(activeProvider, this.getCurrentModel());
+          logger.info("setProviders: recreated LLM client for active provider", {
+            providerId: activeProviderId2,
+            url: activeProvider.url,
+            hasCredential: Boolean(activeProvider.credentialRef),
+            transportAdapter: resolveTransportAdapter(activeProvider)
           });
         }
       }
@@ -420,8 +609,7 @@ function createProviderManager(config) {
       if (provider.models && provider.models.length > 0) {
         return provider.models;
       }
-      const backend = provider.backend;
-      return fetchModelsWithContext(provider.url, provider.apiKey, backend);
+      return fetchProviderModels(provider);
     },
     async setDefaultModelSelection(providerId, model) {
       const provider = providers.find((p) => p.id === providerId);
@@ -559,7 +747,7 @@ function createProviderManager(config) {
         url: provider.url,
         backend
       });
-      const modelsWithContext = await fetchModelsWithContext(provider.url, provider.apiKey, backend);
+      const modelsWithContext = await fetchProviderModels(provider);
       const userModels = provider.models.filter((m) => m.source === "user");
       logger.info("refreshProviderModels", {
         providerId,
@@ -579,7 +767,11 @@ function createProviderManager(config) {
         return { success: false, error: "No models returned from backend" };
       }
       providerStatus.set(providerId, "connected");
-      const updatedModels = mergeModelsWithUserOverrides(modelsWithContext, userModels);
+      const updatedModels = mergeModelsWithUserOverrides(
+        modelsWithContext,
+        userModels,
+        !resolveTransportAdapter(provider)
+      );
       providers = providers.map((p) => p.id === providerId ? { ...p, models: updatedModels } : p);
       const { providerId: currentProviderId, model: currentModel } = parseDefaultModelSelection(defaultModelSelection);
       if (currentProviderId === providerId && currentModel) {
@@ -597,9 +789,11 @@ function createProviderManager(config) {
 }
 
 export {
+  detectModel,
+  getLlmStatus,
   fetchAvailableModelsFromBackend,
   fetchModelsWithContext,
   parseDefaultModelSelection,
   createProviderManager
 };
-//# sourceMappingURL=chunk-H774GQJW.js.map
+//# sourceMappingURL=chunk-RYIREJAW.js.map