openfox 2.0.0-beta.9 → 2.0.0

package/dist/{chunk-DMH6JVPF.js → chunk-7ZMMDZU7.js}

@@ -1,19 +1,389 @@
 import {
-  clearModelCache,
-  createLLMClient,
-  detectModel
-} from "./chunk-UKTPL5ZG.js";
-import {
-  buildModelsUrl,
-  detectBackend,
-  ensureVersionPrefix,
+  buildNonStreamingCreateParams,
+  buildStreamingCreateParams,
+  getBackendCapabilities,
   getModelProfile,
-  stripVersionPrefix
-} from "./chunk-VIIRNJDT.js";
+  getThinking,
+  mapFinishReason
+} from "./chunk-FFEAEPJB.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
 
+// src/server/llm/client.ts
+import OpenAI from "openai";
+
+// src/server/utils/errors.ts
+var OpenFoxError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "OpenFoxError";
+  }
+};
+var SessionNotFoundError = class extends OpenFoxError {
+  constructor(sessionId) {
+    super(`Session not found: ${sessionId}`, "SESSION_NOT_FOUND", { sessionId });
+    this.name = "SessionNotFoundError";
+  }
+};
+var LLMError = class extends OpenFoxError {
+  constructor(message, details) {
+    super(message, "LLM_ERROR", details);
+    this.name = "LLMError";
+  }
+};
+
+// src/server/llm/url-utils.ts
+var VERSION_PREFIX_REGEX = /\/v\d+(\/|$)/;
+function hasVersionPrefix(url) {
+  return VERSION_PREFIX_REGEX.test(url);
+}
+function ensureVersionPrefix(url, defaultVersion = "/v1") {
+  if (hasVersionPrefix(url)) return url;
+  return `${url.replace(/\/+$/, "")}${defaultVersion}`;
+}
+function stripVersionPrefix(url) {
+  return url.replace(/\/v\d+\/?$/, "");
+}
+function buildModelsUrl(baseUrl) {
+  return `${ensureVersionPrefix(baseUrl)}/models`;
+}
+
+// src/server/llm/client.ts
+import { Agent, setGlobalDispatcher } from "undici";
+var agent = new Agent({ allowH2: true });
+setGlobalDispatcher(agent);
+function createLLMClient(config, initialBackend = "unknown") {
+  const baseURL = ensureVersionPrefix(config.llm.baseUrl);
+  const openai = new OpenAI({
+    baseURL,
+    apiKey: config.llm.apiKey ?? "not-needed"
+  });
+  let model = config.llm.model;
+  let profile = getModelProfile(model);
+  let backend = initialBackend;
+  let capabilities = getBackendCapabilities(backend);
+  const reasoningEffort = config.llm.reasoningEffort;
+  const thinkingField = config.llm.thinkingField;
+  const idleTimeout = config.llm.idleTimeout ?? 3e4;
+  return {
+    getModel() {
+      return model;
+    },
+    getProfile() {
+      return profile;
+    },
+    getBackend() {
+      return backend;
+    },
+    setBackend(newBackend) {
+      logger.debug("Setting LLM backend", { from: backend, to: newBackend });
+      backend = newBackend;
+      capabilities = getBackendCapabilities(newBackend);
+    },
+    setModel(newModel) {
+      const newProfile = getModelProfile(newModel);
+      logger.debug("Switching model", {
+        from: model,
+        to: newModel,
+        profile: newProfile.name,
+        temperature: newProfile.temperature
+      });
+      model = newModel;
+      profile = newProfile;
+    },
+    async complete(request) {
+      logger.debug("LLM complete request", {
+        messageCount: request.messages.length,
+        hasTools: !!request.tools?.length,
+        profile: profile.name,
+        reasoningEffort: request.reasoningEffort ?? reasoningEffort
+      });
+      try {
+        const resolvedEffort = request.reasoningEffort ?? reasoningEffort;
+        const { params: createParams } = await buildNonStreamingCreateParams({
+          model,
+          request,
+          profile,
+          capabilities,
+          ...resolvedEffort ? { reasoningEffort: resolvedEffort } : {},
+          ...thinkingField ? { thinkingField } : {}
+        });
+        const response = await openai.chat.completions.create(createParams, {
+          signal: request.signal
+        });
+        const choice = response.choices[0];
+        if (!choice) {
+          throw new LLMError("No completion choice returned");
+        }
+        const message = choice.message;
+        const content = message.content ?? "";
+        const thinkingContent = getThinking(message, thinkingField) ?? "";
+        const toolCalls = message.tool_calls?.map((tc) => ({
+          id: tc.id,
+          name: tc.function.name,
+          arguments: JSON.parse(tc.function.arguments)
+        }));
+        return {
+          id: response.id,
+          content,
+          ...thinkingContent ? { thinkingContent } : {},
+          ...toolCalls && toolCalls.length > 0 ? { toolCalls } : {},
+          finishReason: mapFinishReason(choice.finish_reason),
+          usage: {
+            promptTokens: response.usage?.prompt_tokens ?? 0,
+            completionTokens: response.usage?.completion_tokens ?? 0,
+            totalTokens: response.usage?.total_tokens ?? 0
+          }
+        };
+      } catch (error) {
+        logger.error("LLM complete error", { error: String(error) });
+        throw new LLMError(error instanceof Error ? error.message : "Unknown LLM error", {
+          originalError: error instanceof Error ? error : void 0
+        });
+      }
+    },
+    async *stream(request) {
+      const resolvedEffort = request.reasoningEffort ?? reasoningEffort;
+      logger.debug("LLM stream request", {
+        messageCount: request.messages.length,
+        hasTools: !!request.tools?.length,
+        profile: profile.name,
+        reasoningEffort: resolvedEffort,
+        idleTimeout
+      });
+      try {
+        const createParams = await buildStreamingCreateParams({
+          model,
+          request,
+          profile,
+          capabilities,
+          ...resolvedEffort ? { reasoningEffort: resolvedEffort } : {},
+          ...thinkingField ? { thinkingField } : {}
+        });
+        const { params: streamingParams } = createParams;
+        const stream = await openai.chat.completions.create(streamingParams, {
+          signal: request.signal
+        });
+        let fullContent = "";
+        let fullThinking = "";
+        const toolCalls = /* @__PURE__ */ new Map();
+        let finishReason = "stop";
+        let usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+        let responseId = "";
+        let lastChunkTime = Date.now();
+        const idleTimeoutController = new AbortController();
+        const idleTimer = setInterval(() => {
+          const idleDuration = Date.now() - lastChunkTime;
+          if (idleDuration > idleTimeout) {
+            logger.warn("LLM stream idle timeout triggered", { idleDuration, idleTimeout });
+            idleTimeoutController.abort();
+          }
+        }, 100);
+        const onAbort = () => clearInterval(idleTimer);
+        request.signal?.addEventListener("abort", onAbort, { once: true });
+        try {
+          for await (const chunk of stream) {
+            if (idleTimeoutController.signal.aborted) {
+              throw new Error(`LLM stream idle timeout: no chunks received for ${idleTimeout}ms`);
+            }
+            lastChunkTime = Date.now();
+            responseId = chunk.id;
+            if (chunk.usage) {
+              usage = {
+                promptTokens: chunk.usage.prompt_tokens,
+                completionTokens: chunk.usage.completion_tokens,
+                totalTokens: chunk.usage.total_tokens
+              };
+            }
+            const choice = chunk.choices[0];
+            if (!choice) continue;
+            if (choice.finish_reason) {
+              finishReason = mapFinishReason(choice.finish_reason);
+            }
+            const delta = choice.delta;
+            const reasoning = getThinking(delta, thinkingField);
+            if (reasoning) {
+              fullThinking += reasoning;
+              yield { type: "thinking_delta", content: reasoning };
+            }
+            if (delta.content) {
+              fullContent += delta.content;
+              yield { type: "text_delta", content: delta.content };
+            }
+            if (delta.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                const existing = toolCalls.get(tc.index);
+                if (!existing) {
+                  toolCalls.set(tc.index, {
+                    id: tc.id ?? "",
+                    name: tc.function?.name ?? "",
+                    arguments: tc.function?.arguments ?? ""
+                  });
+                } else {
+                  if (tc.id) existing.id = tc.id;
+                  if (tc.function?.name) existing.name += tc.function.name;
+                  if (tc.function?.arguments) existing.arguments += tc.function.arguments;
+                }
+                yield {
+                  type: "tool_call_delta",
+                  index: tc.index,
+                  ...tc.id ? { id: tc.id } : {},
+                  ...tc.function?.name ? { name: tc.function.name } : {},
+                  ...tc.function?.arguments ? { arguments: tc.function.arguments } : {}
+                };
+              }
+            }
+          }
+        } finally {
+          clearInterval(idleTimer);
+          request.signal?.removeEventListener("abort", onAbort);
+        }
+        const finalContent = fullContent.trim();
+        const finalThinking = fullThinking.trim();
+        const parsedToolCalls = [];
+        for (const [, tc] of toolCalls) {
+          try {
+            parsedToolCalls.push({
+              id: tc.id,
+              name: tc.name,
+              arguments: JSON.parse(tc.arguments)
+            });
+          } catch (error) {
+            logger.warn("Failed to parse tool call arguments", { name: tc.name, arguments: tc.arguments });
+            parsedToolCalls.push({
+              id: tc.id,
+              name: tc.name,
+              arguments: {},
+              parseError: error instanceof Error ? error.message : "Unknown JSON parse error",
+              rawArguments: tc.arguments
+            });
+          }
+        }
+        yield {
+          type: "done",
+          response: {
+            id: responseId,
+            content: finalContent,
+            ...finalThinking ? { thinkingContent: finalThinking } : {},
+            ...parsedToolCalls.length > 0 ? { toolCalls: parsedToolCalls } : {},
+            finishReason,
+            usage
+          }
+        };
+      } catch (error) {
+        logger.error("LLM stream error", { error });
+        yield {
+          type: "error",
+          error: error instanceof Error ? error.message : "Unknown LLM error"
+        };
+      }
+    }
+  };
+}
+
+// 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) {
   return s.toLowerCase().replace(/[-_\s:.]+/g, "");
@@ -163,6 +533,7 @@ function parseDefaultModelSelection(selection) {
 }
 function createProviderManager(config) {
   let providers = [...config.providers ?? []];
+  providers = providers.map((p) => ({ ...p, models: p.models.map((m) => enrichWithProfileDefaults(m)) }));
   let defaultModelSelection = config.defaultModelSelection;
   let llmClient = createLLMClient(config);
   const providerStatus = /* @__PURE__ */ new Map();
@@ -175,7 +546,16 @@ function createProviderManager(config) {
   for (const p of providers) {
     providerStatus.set(p.id, "unknown");
   }
+  function resolveModelThinkingConfig(provider, modelId) {
+    const modelConfig = provider.models.find((m) => m.id === modelId);
+    if (!modelConfig) return {};
+    if (modelConfig.thinkingEnabled && modelConfig.thinkingLevel) {
+      return { reasoningEffort: modelConfig.thinkingLevel };
+    }
+    return {};
+  }
   function createConfigForProvider(provider, model) {
+    const modelThinking = resolveModelThinkingConfig(provider, model);
     return {
       ...config,
       llm: {
@@ -183,7 +563,9 @@ function createProviderManager(config) {
         baseUrl: ensureVersionPrefix(provider.url),
         model,
         backend: provider.backend,
-        ...provider.apiKey && { apiKey: provider.apiKey }
+        ...provider.apiKey && { apiKey: provider.apiKey },
+        ...provider.thinkingField && { thinkingField: provider.thinkingField },
+        ...modelThinking.reasoningEffort && { reasoningEffort: modelThinking.reasoningEffort }
       }
     };
   }
@@ -238,11 +620,16 @@ function createProviderManager(config) {
       const providerConfig = createConfigForProvider(provider, targetModel);
       const newClient = createLLMClient(providerConfig);
       try {
-        const url = stripVersionPrefix(provider.url);
-        clearModelCache(url);
+        const cacheUrl = stripVersionPrefix(provider.url);
+        clearModelCache(cacheUrl);
         const backend = provider.backend;
-        logger.info("activateProvider fetching models", { providerId, providerName: provider.name, url, backend });
-        const modelsWithContext = await fetchModelsWithContext(url, provider.apiKey, backend);
+        logger.info("activateProvider fetching models", {
+          providerId,
+          providerName: provider.name,
+          url: provider.url,
+          backend
+        });
+        const modelsWithContext = await fetchModelsWithContext(provider.url, provider.apiKey, backend);
         const userModels = provider.models.filter((m) => m.source === "user");
         logger.debug("activateProvider", {
           providerId,
@@ -259,14 +646,9 @@ function createProviderManager(config) {
           });
           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);
-        }
+        newClient.setBackend(provider.backend);
         if (targetModel === "auto") {
-          const detected = await detectModel(url);
+          const detected = await detectModel(provider.url);
           if (detected) {
             newClient.setModel(detected);
           }
@@ -336,7 +718,7 @@ function createProviderManager(config) {
       const newActiveProviderId = this.getActiveProviderId();
       if (newActiveProviderId && newActiveProviderId !== wasActiveProviderId) {
         const activeProvider = providers.find((p) => p.id === newActiveProviderId);
-        if (activeProvider) {
+        if (activeProvider && activeProvider.apiKey) {
           const providerConfig = createConfigForProvider(activeProvider, this.getCurrentModel() ?? "auto");
           llmClient = createLLMClient(providerConfig);
           logger.info("setProviders: recreated LLM client for new active provider", {
@@ -358,9 +740,8 @@ function createProviderManager(config) {
       if (provider.models && provider.models.length > 0) {
         return provider.models;
       }
-      const url = stripVersionPrefix(provider.url);
       const backend = provider.backend;
-      return fetchModelsWithContext(url, provider.apiKey, backend);
+      return fetchModelsWithContext(provider.url, provider.apiKey, backend);
     },
     async setDefaultModelSelection(providerId, model) {
       const provider = providers.find((p) => p.id === providerId);
@@ -440,7 +821,12 @@ function createProviderManager(config) {
         ...finalTopP !== void 0 && { topP: finalTopP },
         ...finalTopK !== void 0 && { topK: finalTopK },
         ...finalMaxTokens !== void 0 && { maxTokens: finalMaxTokens },
-        ...finalSupportsVision !== void 0 && { supportsVision: finalSupportsVision }
+        ...finalSupportsVision !== void 0 && { supportsVision: finalSupportsVision },
+        ...settings.thinkingEnabled !== void 0 ? { thinkingEnabled: settings.thinkingEnabled } : existingModel?.thinkingEnabled !== void 0 ? { thinkingEnabled: existingModel.thinkingEnabled } : {},
+        ...settings.thinkingLevel !== void 0 ? { thinkingLevel: settings.thinkingLevel } : existingModel?.thinkingLevel !== void 0 ? { thinkingLevel: existingModel.thinkingLevel } : {},
+        ...settings.nonThinkingEnabled !== void 0 ? { nonThinkingEnabled: settings.nonThinkingEnabled } : existingModel?.nonThinkingEnabled !== void 0 ? { nonThinkingEnabled: existingModel.nonThinkingEnabled } : {},
+        ...settings.thinkingExtraKwargs !== void 0 ? { thinkingExtraKwargs: settings.thinkingExtraKwargs } : existingModel?.thinkingExtraKwargs !== void 0 ? { thinkingExtraKwargs: existingModel.thinkingExtraKwargs } : {},
+        ...settings.nonThinkingExtraKwargs !== void 0 ? { nonThinkingExtraKwargs: settings.nonThinkingExtraKwargs } : existingModel?.nonThinkingExtraKwargs !== void 0 ? { nonThinkingExtraKwargs: existingModel.nonThinkingExtraKwargs } : {}
       });
       if (existingModel) {
         providers = providers.map(
@@ -452,16 +838,18 @@ function createProviderManager(config) {
       logger.info("Model settings updated", { providerId, modelId, final: updatedModel });
       return { success: true, model: updatedModel };
     },
-    getModelSettings(modelId) {
+    getModelSettings(modelId, mode = "thinking") {
       const provider = providers.find((p) => p.models.some((m) => m.id === modelId));
       const model = provider?.models.find((m) => m.id === modelId);
       if (!model) return void 0;
+      const kwargs = mode === "non-thinking" ? model.nonThinkingEnabled ? model.nonThinkingExtraKwargs : model.thinkingExtraKwargs : model.thinkingEnabled ? model.thinkingExtraKwargs : model.nonThinkingExtraKwargs;
       return {
         ...model.temperature !== void 0 && { temperature: model.temperature },
         ...model.topP !== void 0 && { topP: model.topP },
         ...model.topK !== void 0 && { topK: model.topK },
         ...model.maxTokens !== void 0 && { maxTokens: model.maxTokens },
-        ...model.supportsVision !== void 0 && { supportsVision: model.supportsVision }
+        ...model.supportsVision !== void 0 && { supportsVision: model.supportsVision },
+        ...kwargs ? { chatTemplateKwargs: JSON.parse(kwargs) } : {}
       };
     },
     async refreshProviderModels(providerId) {
@@ -469,10 +857,14 @@ function createProviderManager(config) {
       if (!provider) {
         return { success: false, error: "Provider not found" };
       }
-      const url = stripVersionPrefix(provider.url);
       const backend = provider.backend;
-      logger.info("refreshProviderModels fetching models", { providerId, providerName: provider.name, url, backend });
-      const modelsWithContext = await fetchModelsWithContext(url, provider.apiKey, backend);
+      logger.info("refreshProviderModels fetching models", {
+        providerId,
+        providerName: provider.name,
+        url: provider.url,
+        backend
+      });
+      const modelsWithContext = await fetchModelsWithContext(provider.url, provider.apiKey, backend);
       const userModels = provider.models.filter((m) => m.source === "user");
       logger.info("refreshProviderModels", {
         providerId,
@@ -510,8 +902,15 @@ function createProviderManager(config) {
 }
 
 export {
+  SessionNotFoundError,
+  ensureVersionPrefix,
+  buildModelsUrl,
+  createLLMClient,
+  detectModel,
+  getLlmStatus,
   fetchAvailableModelsFromBackend,
+  fetchModelsWithContext,
   parseDefaultModelSelection,
   createProviderManager
 };
-//# sourceMappingURL=chunk-DMH6JVPF.js.map
+//# sourceMappingURL=chunk-7ZMMDZU7.js.map

package/dist/{chunk-CDDMHSZF.js → chunk-CK6LGE7G.js}

@@ -1,11 +1,11 @@
 import {
   getEventStore,
   updateSessionMetadata
-} from "./chunk-NPHYEUYE.js";
+} from "./chunk-XEK3KII6.js";
 import {
   buildMessagesFromStoredEvents,
   foldPendingConfirmations
-} from "./chunk-XJEOP6XU.js";
+} from "./chunk-ITWVFGFV.js";
 import {
   createContextStateMessage,
   createSessionStateMessage
@@ -56,7 +56,7 @@ Example inputs and outputs:
 
 User message: {message}`;
 async function generateSessionName(options) {
-  const { userMessage, llmClient, signal } = options;
+  const { userMessage, llmClient, signal, modelSettings, nonThinkingEnabled } = options;
   try {
     logger.debug("Generating session name", { messagePreview: userMessage.slice(0, 50) });
     const prompt = SESSION_NAME_PROMPT.replace("{message}", userMessage);
@@ -72,9 +72,13 @@ async function generateSessionName(options) {
       messages,
       tools: [],
       signal: composedSignal,
-      disableThinking: true
+      // Default to non-thinking (reasoningEffort: 'none') when not explicitly configured
+      // to prevent thinking output in session names. Only skip when user explicitly
+      // set nonThinkingEnabled to false.
+      ...nonThinkingEnabled !== false ? { reasoningEffort: "none" } : {},
+      ...modelSettings ? { modelSettings } : {}
     });
-    let name = response.content.trim();
+    let name = (response.content || response.thinkingContent || "").trim();
     if (name.length > 50) {
       name = name.substring(0, 47) + "...";
     }
@@ -143,4 +147,4 @@ export {
   needsNameGenerationCheck,
   applyGeneratedSessionName
 };
-//# sourceMappingURL=chunk-CDDMHSZF.js.map
+//# sourceMappingURL=chunk-CK6LGE7G.js.map