openfox 2.0.0-beta.16 → 2.0.0-beta.17

package/dist/{chat-handler-7QLHIQOM.js → chat-handler-LJMW4OK3.js}

@@ -5,18 +5,18 @@ import {
   generateSessionName,
   getSessionMessageCount,
   needsNameGenerationCheck
-} from "./chunk-OKLV3ZNN.js";
+} from "./chunk-CK6LGE7G.js";
 import {
   runChatTurn
-} from "./chunk-D2QILH47.js";
-import "./chunk-W52UQCER.js";
+} from "./chunk-LEDG5WAN.js";
+import "./chunk-32GQUDLN.js";
 import "./chunk-DL6ZILAF.js";
 import "./chunk-PBGOZMVY.js";
 import "./chunk-VRGRAQDG.js";
 import "./chunk-XAMAYRDA.js";
 import {
   getEventStore
-} from "./chunk-DHAKJSE7.js";
+} from "./chunk-XEK3KII6.js";
 import "./chunk-ITWVFGFV.js";
 import {
   createChatMessageMessage,
@@ -28,7 +28,7 @@ import "./chunk-RFNEDBVO.js";
 import "./chunk-FBGWG4N6.js";
 import "./chunk-BVHFMAVN.js";
 import "./chunk-CQGTEGKL.js";
-import "./chunk-LXX2CPM5.js";
+import "./chunk-FFEAEPJB.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -161,4 +161,4 @@ export {
   startChatSession,
   stopSessionExecution
 };
-//# sourceMappingURL=chat-handler-7QLHIQOM.js.map
+//# sourceMappingURL=chat-handler-LJMW4OK3.js.map

package/dist/{chunk-W52UQCER.js → chunk-32GQUDLN.js}

@@ -22,7 +22,7 @@ import {
   getCurrentWindowMessageOptions,
   getEventStore,
   getRuntimeConfig
-} from "./chunk-DHAKJSE7.js";
+} from "./chunk-XEK3KII6.js";
 import {
   buildContextMessagesFromEventHistory,
   foldContextState,
@@ -57,7 +57,7 @@ import {
   getModelProfile,
   modelSupportsVision,
   streamWithSegments
-} from "./chunk-LXX2CPM5.js";
+} from "./chunk-FFEAEPJB.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -3280,7 +3280,7 @@ async function describeImageFromDataUrl(dataUrl, visionModel, options) {
 import { createHash as createHash2 } from "crypto";
 async function loadVisionModelFromGlobalConfig() {
   try {
-    const { loadGlobalConfig, getVisionFallback } = await import("./config-B6HYTLT4.js");
+    const { loadGlobalConfig, getVisionFallback } = await import("./config-BU66P4KX.js");
     const runtimeConfig = getRuntimeConfig();
     const mode = runtimeConfig.mode ?? "production";
     const globalConfig = await loadGlobalConfig(mode);
@@ -3733,7 +3733,7 @@ var callSubAgentTool = {
       };
     }
     try {
-      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-VJMWGBUO.js");
+      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-BOE5T3KC.js");
       const toolRegistry = getToolRegistryForAgent2(agentDef);
       const turnMetrics = new TurnMetrics();
       const result = await executeSubAgent({
@@ -4785,4 +4785,4 @@ export {
   getToolRegistryForAgent,
   createToolRegistry
 };
-//# sourceMappingURL=chunk-W52UQCER.js.map
+//# sourceMappingURL=chunk-32GQUDLN.js.map

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

@@ -1,19 +1,389 @@
 import {
-  clearModelCache,
-  createLLMClient,
-  detectModel
-} from "./chunk-4F3C6X4M.js";
-import {
-  buildModelsUrl,
-  detectBackend,
-  ensureVersionPrefix,
+  buildNonStreamingCreateParams,
+  buildStreamingCreateParams,
+  getBackendCapabilities,
   getModelProfile,
-  stripVersionPrefix
-} from "./chunk-LXX2CPM5.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, "");
@@ -276,12 +646,7 @@ function createProviderManager(config) {
           });
           providers = providers.map((p) => p.id === providerId ? { ...p, models: userModels } : p);
         }
-        if (provider.backend === "auto") {
-          const detected = await detectBackend(provider.url);
-          newClient.setBackend(detected);
-        } else {
-          newClient.setBackend(provider.backend);
-        }
+        newClient.setBackend(provider.backend);
         if (targetModel === "auto") {
           const detected = await detectModel(provider.url);
           if (detected) {
@@ -537,9 +902,15 @@ function createProviderManager(config) {
 }
 
 export {
+  SessionNotFoundError,
+  ensureVersionPrefix,
+  buildModelsUrl,
+  createLLMClient,
+  detectModel,
+  getLlmStatus,
   fetchAvailableModelsFromBackend,
   fetchModelsWithContext,
   parseDefaultModelSelection,
   createProviderManager
 };
-//# sourceMappingURL=chunk-6CVDQJDV.js.map
+//# sourceMappingURL=chunk-7ZMMDZU7.js.map

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

@@ -1,7 +1,7 @@
 import {
   getEventStore,
   updateSessionMetadata
-} from "./chunk-DHAKJSE7.js";
+} from "./chunk-XEK3KII6.js";
 import {
   buildMessagesFromStoredEvents,
   foldPendingConfirmations
@@ -147,4 +147,4 @@ export {
   needsNameGenerationCheck,
   applyGeneratedSessionName
 };
-//# sourceMappingURL=chunk-OKLV3ZNN.js.map
+//# sourceMappingURL=chunk-CK6LGE7G.js.map

package/dist/{chunk-LXX2CPM5.js → chunk-FFEAEPJB.js}

@@ -1,7 +1,3 @@
-import {
-  logger
-} from "./chunk-K44MW7JJ.js";
-
 // src/server/llm/profiles.ts
 var DEFAULT_PROFILE = {
   name: "default",
@@ -172,22 +168,6 @@ function modelSupportsVision(modelName) {
   return getModelProfile(modelName).supportsVision;
 }
 
-// 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/backend.ts
 var BACKEND_CAPABILITIES = {
   vllm: {
@@ -211,7 +191,6 @@ var BACKEND_CAPABILITIES = {
     supportsTopK: true
   },
   unknown: {
-    // Assume vLLM-like for unknown backends
     supportsChatTemplateKwargs: true,
     supportsTopK: true
   }
@@ -219,113 +198,6 @@ var BACKEND_CAPABILITIES = {
 function getBackendCapabilities(backend) {
   return BACKEND_CAPABILITIES[backend];
 }
-async function detectBackend(baseUrl, explicitBackend, silent = false) {
-  if (explicitBackend && explicitBackend !== "unknown") {
-    if (silent) {
-      logger.debug("Using explicit backend", { backend: explicitBackend });
-    } else {
-      logger.info("Using explicit backend", { backend: explicitBackend });
-    }
-    return explicitBackend;
-  }
-  const probeUrl = stripVersionPrefix(baseUrl);
-  try {
-    if (await probeOllama(probeUrl)) {
-      if (silent) {
-        logger.debug("Detected Ollama backend", { url: probeUrl });
-      } else {
-        logger.info("Detected Ollama backend", { url: probeUrl });
-      }
-      return "ollama";
-    }
-    if (await probeLlamaCpp(probeUrl)) {
-      if (silent) {
-        logger.debug("Detected llama.cpp backend", { url: probeUrl });
-      } else {
-        logger.info("Detected llama.cpp backend", { url: probeUrl });
-      }
-      return "llamacpp";
-    }
-    if (await probeSGLang(probeUrl)) {
-      if (silent) {
-        logger.debug("Detected SGLang backend", { url: probeUrl });
-      } else {
-        logger.info("Detected SGLang backend", { url: probeUrl });
-      }
-      return "sglang";
-    }
-    if (await probeOpenAI(baseUrl)) {
-      if (silent) {
-        logger.debug("Detected vLLM backend (OpenAI-compatible)", { url: baseUrl });
-      } else {
-        logger.info("Detected vLLM backend (OpenAI-compatible)", { url: baseUrl });
-      }
-      return "vllm";
-    }
-    if (silent) {
-      logger.debug("Could not detect backend, using unknown", { url: baseUrl });
-    } else {
-      logger.warn("Could not detect backend, using unknown", { url: baseUrl });
-    }
-    return "unknown";
-  } catch (error) {
-    if (silent) {
-      logger.debug("Backend detection failed", {
-        url: baseUrl,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    } else {
-      logger.warn("Backend detection failed", {
-        url: baseUrl,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-    return "unknown";
-  }
-}
-async function probeOllama(baseUrl) {
-  try {
-    const response = await fetch(`${baseUrl}/api/tags`, {
-      signal: AbortSignal.timeout(5e3)
-    });
-    return response.ok;
-  } catch {
-    return false;
-  }
-}
-async function probeLlamaCpp(baseUrl) {
-  try {
-    const response = await fetch(`${baseUrl}/health`, {
-      signal: AbortSignal.timeout(5e3)
-    });
-    if (!response.ok) return false;
-    const data = await response.json();
-    return "slots_idle" in data || "slots_processing" in data;
-  } catch {
-    return false;
-  }
-}
-async function probeSGLang(baseUrl) {
-  try {
-    const response = await fetch(`${baseUrl}/get_model_info`, {
-      signal: AbortSignal.timeout(5e3)
-    });
-    return response.ok;
-  } catch {
-    return false;
-  }
-}
-async function probeOpenAI(baseUrl) {
-  try {
-    const url = ensureVersionPrefix(baseUrl);
-    const response = await fetch(`${url}/models`, {
-      signal: AbortSignal.timeout(5e3)
-    });
-    return response.ok;
-  } catch {
-    return false;
-  }
-}
 function getBackendDisplayName(backend) {
   switch (backend) {
     case "vllm":
@@ -616,11 +488,7 @@ async function* streamWithSegments(client, request) {
 export {
   getModelProfile,
   modelSupportsVision,
-  ensureVersionPrefix,
-  stripVersionPrefix,
-  buildModelsUrl,
   getBackendCapabilities,
-  detectBackend,
   getBackendDisplayName,
   buildModelParams,
   getThinking,
@@ -629,4 +497,4 @@ export {
   mapFinishReason,
   streamWithSegments
 };
-//# sourceMappingURL=chunk-LXX2CPM5.js.map
+//# sourceMappingURL=chunk-FFEAEPJB.js.map