openfox 2.0.61 → 2.0.63

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

package/dist/{chunk-AA4G4DGK.js → chunk-W4PUAODY.js}

@@ -1,12 +1,15 @@
 import {
+  appendCompactionPrompt
+} from "./chunk-OESYKZCM.js";
+import {
+  applyDynamicContext,
+  computeSessionHash,
   injectWorkflowKickoffIfNeeded,
   runAgentTurn,
   runChatTurn
-} from "./chunk-ZHSCXD75.js";
+} from "./chunk-IVJYQZSN.js";
 import {
-  applyDynamicContext,
   checkAborted,
-  computeSessionHash,
   deleteItemFromDir,
   devServerManager,
   executeSubAgent,
@@ -16,11 +19,20 @@ import {
   loadAllAgentsDefault,
   saveItemToDir,
   spawnShellProcess
-} from "./chunk-KX4C5Q5J.js";
+} from "./chunk-5OPZLQDV.js";
+import {
+  TurnMetrics,
+  createMessageStartEvent
+} from "./chunk-X5YCWKNS.js";
 import {
   getPlatformShell,
   onProcessEvent
 } from "./chunk-BGTEIA2S.js";
+import {
+  getCurrentContextWindowId,
+  getEventStore,
+  getRuntimeConfig
+} from "./chunk-AIJE3RYH.js";
 import {
   createChatErrorMessage,
   createChatMessageMessage,
@@ -38,24 +50,6 @@ import {
 import {
   provideAnswer
 } from "./chunk-EU3WWTFH.js";
-import {
-  appendCompactionPrompt
-} from "./chunk-GJU35MDV.js";
-import {
-  TurnMetrics,
-  createMessageStartEvent
-} from "./chunk-6VDCH5ML.js";
-import {
-  getCurrentContextWindowId,
-  getEventStore,
-  getRuntimeConfig
-} from "./chunk-AIJE3RYH.js";
-import {
-  createLLMClient
-} from "./chunk-JKLPWTUN.js";
-import {
-  ensureVersionPrefix
-} from "./chunk-HNCM3D7Y.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -1385,7 +1379,7 @@ function processQueueAndRestartTurn(sessionManager, sessionId, drainFn, queueMod
 var activeAgents = /* @__PURE__ */ new Map();
 var abortedSessions = /* @__PURE__ */ new Set();
 var MAX_SEND_QUEUE_SIZE = 1e3;
-function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvider, sessionManager, providerManager) {
+function createWebSocketServer(httpServer, _config, getLLMClient, getActiveProvider, sessionManager, providerManager) {
   const wss = new WebSocketServer({ server: httpServer });
   const clients = /* @__PURE__ */ new Map();
   moduleClients = clients;
@@ -1395,7 +1389,9 @@ function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvid
     if (!session?.providerId || !session?.providerModel || !providerManager) {
       return getLLMClient();
     }
-    const cacheKey = `${session.providerId}:${session.providerModel}`;
+    const resolvedModel = providerManager.resolveModel(session.providerId, session.providerModel);
+    const effectiveModel = resolvedModel ?? session.providerModel;
+    const cacheKey = `${session.providerId}:${effectiveModel}`;
     const cached = sessionLLMClients.get(sessionId);
     if (cached && cached.key === cacheKey) {
       return cached.client;
@@ -1410,26 +1406,20 @@ function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvid
       sessionLLMClients.delete(sessionId);
       return getLLMClient();
     }
-    const modelConfig = provider.models.find((m) => m.id === session.providerModel);
-    const reasoningEffort = modelConfig?.thinkingEnabled && modelConfig?.thinkingLevel ? modelConfig.thinkingLevel : void 0;
-    const baseUrl = ensureVersionPrefix(provider.url);
-    const sessionConfig = {
-      ...config,
-      llm: {
-        ...config.llm,
-        baseUrl,
-        model: session.providerModel,
-        ...provider.apiKey && { apiKey: provider.apiKey },
-        ...provider.thinkingField && { thinkingField: provider.thinkingField },
-        ...reasoningEffort && { reasoningEffort }
-      }
-    };
-    const client = createLLMClient(sessionConfig);
-    if (provider.backend !== "unknown") {
-      client.setBackend(provider.backend);
+    const client = providerManager.createClient(session.providerId, effectiveModel);
+    if (!client) {
+      logger.warn("Could not create session provider client, falling back to global", {
+        sessionId,
+        providerId: session.providerId,
+        model: session.providerModel
+      });
+      return getLLMClient();
+    }
+    const concreteModel = client.getModel();
+    if (session.providerModel !== concreteModel) {
+      sessionManager.setSessionProvider(sessionId, session.providerId, concreteModel);
     }
-    client.setModel(session.providerModel);
-    sessionLLMClients.set(sessionId, { key: cacheKey, client });
+    sessionLLMClients.set(sessionId, { key: `${session.providerId}:${concreteModel}`, client });
     return client;
   }
   function getSessionStatsIdentity(sessionId) {
@@ -2102,4 +2092,4 @@ export {
   signalMcpReady,
   createWebSocketServer
 };
-//# sourceMappingURL=chunk-AA4G4DGK.js.map
+//# sourceMappingURL=chunk-W4PUAODY.js.map

package/dist/{chunk-43UFGATL.js → chunk-WGAAQASA.js}

@@ -38,15 +38,37 @@ var modelConfigSchema = z.object({
 }).passthrough();
 var providerSchema = z.object({
   id: z.string(),
-  name: z.string(),
-  url: z.string(),
-  backend: backendSchema,
+  preset: z.string().optional(),
+  name: z.string().optional(),
+  url: z.string().optional(),
+  backend: backendSchema.optional(),
   apiKey: z.string().optional(),
-  models: z.array(modelConfigSchema).default([]),
-  isActive: z.boolean(),
-  createdAt: z.string(),
-  isLocal: z.boolean().optional()
-});
+  models: z.array(modelConfigSchema).optional(),
+  isActive: z.boolean().optional(),
+  createdAt: z.string().optional(),
+  isLocal: z.boolean().optional(),
+  thinkingField: z.string().optional(),
+  authAdapter: z.string().optional(),
+  transportAdapter: z.string().optional(),
+  credentialRef: z.string().optional()
+}).transform(
+  (provider) => ({
+    id: provider.id,
+    ...provider.preset ? { preset: provider.preset } : {},
+    name: provider.name ?? provider.id,
+    url: provider.url ?? "",
+    backend: provider.backend ?? "unknown",
+    ...provider.apiKey ? { apiKey: provider.apiKey } : {},
+    models: provider.models ?? [],
+    isActive: provider.isActive ?? false,
+    createdAt: provider.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    ...provider.isLocal !== void 0 ? { isLocal: provider.isLocal } : {},
+    ...provider.thinkingField ? { thinkingField: provider.thinkingField } : {},
+    ...provider.authAdapter ? { authAdapter: provider.authAdapter } : {},
+    ...provider.transportAdapter ? { transportAdapter: provider.transportAdapter } : {},
+    ...provider.credentialRef ? { credentialRef: provider.credentialRef } : {}
+  })
+);
 var serverSchema = z.object({
   port: z.number().default(10369),
   host: z.string().default("127.0.0.1"),
@@ -291,4 +313,4 @@ export {
   removeProvider,
   activateProvider
 };
-//# sourceMappingURL=chunk-43UFGATL.js.map
+//# sourceMappingURL=chunk-WGAAQASA.js.map