openfox 1.6.20 → 1.6.23

package/dist/{chunk-OVLFEBRR.js → chunk-D4ZLSV6P.js}

@@ -1,7 +1,6 @@
 import {
-  describeImageFromDataUrl,
-  ensureVisionFallbackConfigLoaded
-} from "./chunk-IN5EP4ZB.js";
+  describeImageFromDataUrl
+} from "./chunk-CJNQGEYG.js";
 import {
   logger
 } from "./chunk-PNBH3RAX.js";
@@ -167,134 +166,6 @@ function getBackendDisplayName(backend) {
   }
 }
 
-// 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 url.replace(/\/v1\/?$/, "");
-}
-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 = llmBaseUrl.includes("/v1") ? `${llmBaseUrl}/models` : `${llmBaseUrl}/v1/models`;
-  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 setLlmStatus(status) {
-  llmStatus = status;
-}
-function clearModelCache(url) {
-  if (url) {
-    modelCache.delete(getCacheKey(url));
-  } else {
-    modelCache.clear();
-  }
-  llmStatus = "unknown";
-}
-
-// 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/profiles.ts
 var DEFAULT_PROFILE = {
   name: "default",
@@ -493,6 +364,14 @@ function getModelProfile(modelName) {
 }
 
 // src/server/llm/client-pure.ts
+function buildModelParams(params) {
+  return {
+    ...params.temperature !== void 0 && { temperature: params.temperature },
+    ...params.topP !== void 0 && { topP: params.topP },
+    ...params.topK !== void 0 && { topK: params.topK },
+    ...params.maxTokens !== void 0 && { maxTokens: params.maxTokens }
+  };
+}
 function buildAttachmentContent(msgContent, attachments, modelSupportsVision) {
   const content = [];
   if (msgContent?.trim()) {
@@ -705,27 +584,32 @@ async function buildChatCompletionCreateParams(model, request, profile, capabili
     onVisionFallbackStart,
     onVisionFallbackDone
   );
+  const temperature = request.temperature ?? profile.temperature;
+  const maxTokens = request.maxTokens ?? profile.defaultMaxTokens;
+  const topP = profile.topP;
+  const topK = capabilities.supportsTopK ? profile.topK : void 0;
   const params = {
     model,
     messages: convertedMessages,
     ...request.tools ? { tools: convertTools(request.tools) } : {},
     ...request.toolChoice ? { tool_choice: request.toolChoice } : {},
-    temperature: request.temperature ?? profile.temperature,
-    max_tokens: request.maxTokens ?? profile.defaultMaxTokens,
-    top_p: profile.topP,
+    temperature,
+    max_tokens: maxTokens,
+    top_p: topP,
     stream: isStreaming,
     ...isStreaming ? { stream_options: { include_usage: true } } : {}
   };
-  if (capabilities.supportsTopK && profile.topK !== void 0) {
+  if (topK !== void 0) {
     ;
-    params["top_k"] = profile.topK;
+    params["top_k"] = topK;
   }
   const shouldDisableThinking = isStreaming ? disableThinking || request.disableThinking : disableThinking;
   if (capabilities.supportsChatTemplateKwargs && profile.supportsReasoning && shouldDisableThinking) {
     ;
     params["chat_template_kwargs"] = { enable_thinking: false };
   }
-  return params;
+  const modelParams = buildModelParams({ temperature, topP, topK, maxTokens });
+  return { params, modelParams };
 }
 async function buildCreateParamsFromInput(input, isStreaming) {
   const { model, request, profile, capabilities, disableThinking, visionFallbackEnabled = false, onVisionFallbackStart, onVisionFallbackDone } = input;
@@ -762,348 +646,129 @@ function extractThinking(content) {
   };
 }
 
-// src/server/llm/client.ts
-function createLLMClient(config, initialBackend = "unknown") {
-  const baseURL = config.llm.baseUrl.includes("/v1") ? config.llm.baseUrl : `${config.llm.baseUrl}/v1`;
-  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 disableThinking = config.llm.disableThinking ?? false;
-  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,
-        supportsReasoning: newProfile.supportsReasoning
-      });
-      model = newModel;
-      profile = newProfile;
-    },
-    async complete(request) {
-      logger.debug("LLM complete request", {
-        messageCount: request.messages.length,
-        hasTools: !!request.tools?.length,
-        profile: profile.name,
-        disableThinking
-      });
-      try {
-        const shouldDisableThinking = disableThinking || request.disableThinking === true;
-        await ensureVisionFallbackConfigLoaded();
-        const { isVisionFallbackEnabled } = await import("./vision-fallback-ADYRFFD4.js");
-        const paramsOptions = {
-          model,
-          request,
-          profile,
-          capabilities,
-          disableThinking: shouldDisableThinking,
-          visionFallbackEnabled: isVisionFallbackEnabled()
-        };
-        if (request.onVisionFallbackStart) {
-          paramsOptions.onVisionFallbackStart = request.onVisionFallbackStart;
-        }
-        if (request.onVisionFallbackDone) {
-          paramsOptions.onVisionFallbackDone = request.onVisionFallbackDone;
-        }
-        const createParams = await buildNonStreamingCreateParams(paramsOptions);
-        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;
-        let content = message.content ?? "";
-        let thinkingContent = "";
-        if (profile.supportsReasoning) {
-          if (capabilities.supportsReasoningField) {
-            thinkingContent = message.reasoning_content ?? message.reasoning ?? "";
-          } else {
-            const extracted = extractThinking(content);
-            content = extracted.content;
-            thinkingContent = extracted.thinkingContent ?? "";
-          }
-          if (profile.reasoningAsContent && thinkingContent.trim()) {
-            content = thinkingContent;
-            thinkingContent = "";
-          }
-        }
-        if (!content.trim() && thinkingContent.trim()) {
-          content = thinkingContent;
-          thinkingContent = "";
-        }
-        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: error.toString() });
-        throw new LLMError(
-          error instanceof Error ? error.message : "Unknown LLM error",
-          { originalError: error }
-        );
-      }
-    },
-    async *stream(request) {
-      logger.debug("LLM stream request", {
-        messageCount: request.messages.length,
-        hasTools: !!request.tools?.length,
-        profile: profile.name,
-        disableThinking,
-        idleTimeout
-      });
-      try {
-        await ensureVisionFallbackConfigLoaded();
-        const { isVisionFallbackEnabled } = await import("./vision-fallback-ADYRFFD4.js");
-        const shouldDisableThinking = disableThinking || request.disableThinking === true;
-        const createParams = await buildStreamingCreateParams({
-          model,
-          request,
-          profile,
-          capabilities,
-          disableThinking: shouldDisableThinking,
-          visionFallbackEnabled: isVisionFallbackEnabled(),
-          onVisionFallbackStart: request.onVisionFallbackStart,
-          onVisionFallbackDone: request.onVisionFallbackDone
-        });
-        const stream = await openai.chat.completions.create(createParams, {
-          signal: request.signal
-        });
-        let fullContent = "";
-        let fullThinking = "";
-        let inThinking = false;
-        let tagBuffer = "";
-        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);
-        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;
-            if (capabilities.supportsReasoningField) {
-              const reasoning = delta.reasoning_content ?? delta.reasoning;
-              if (reasoning) {
-                if (profile.supportsReasoning && !profile.reasoningAsContent) {
-                  fullThinking += reasoning;
-                  yield { type: "thinking_delta", content: reasoning };
-                } else {
-                  fullContent += reasoning;
-                  yield { type: "text_delta", content: reasoning };
-                }
-              }
-            }
-            if (delta.content) {
-              fullContent += delta.content;
-              if (!capabilities.supportsReasoningField && profile.supportsReasoning && !profile.reasoningAsContent) {
-                tagBuffer += delta.content;
-                while (tagBuffer.length > 0) {
-                  if (inThinking) {
-                    const closeIdx = tagBuffer.indexOf("</think>");
-                    if (closeIdx !== -1) {
-                      const thinkText = tagBuffer.slice(0, closeIdx);
-                      if (thinkText) {
-                        fullThinking += thinkText;
-                        yield { type: "thinking_delta", content: thinkText };
-                      }
-                      tagBuffer = tagBuffer.slice(closeIdx + "</think>".length);
-                      inThinking = false;
-                    } else if (tagBuffer.includes("</")) {
-                      const partialIdx = tagBuffer.lastIndexOf("</");
-                      const before = tagBuffer.slice(0, partialIdx);
-                      if (before) {
-                        fullThinking += before;
-                        yield { type: "thinking_delta", content: before };
-                      }
-                      tagBuffer = tagBuffer.slice(partialIdx);
-                      break;
-                    } else {
-                      fullThinking += tagBuffer;
-                      yield { type: "thinking_delta", content: tagBuffer };
-                      tagBuffer = "";
-                    }
-                  } else {
-                    const openIdx = tagBuffer.indexOf("<think>");
-                    if (openIdx !== -1) {
-                      const textBefore = tagBuffer.slice(0, openIdx);
-                      if (textBefore) {
-                        yield { type: "text_delta", content: textBefore };
-                      }
-                      tagBuffer = tagBuffer.slice(openIdx + "<think>".length);
-                      inThinking = true;
-                    } else if (tagBuffer.includes("<")) {
-                      const partialIdx = tagBuffer.lastIndexOf("<");
-                      const before = tagBuffer.slice(0, partialIdx);
-                      if (before) {
-                        yield { type: "text_delta", content: before };
-                      }
-                      tagBuffer = tagBuffer.slice(partialIdx);
-                      break;
-                    } else {
-                      yield { type: "text_delta", content: tagBuffer };
-                      tagBuffer = "";
-                    }
-                  }
-                }
-              } else {
-                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 } : {}
-                };
-              }
-            }
+// src/server/llm/streaming.ts
+var XML_TOOL_PATTERNS = ["<tool_call>", "<function=", "</tool_call>", "<parameter="];
+function hasXmlToolPattern(text) {
+  return XML_TOOL_PATTERNS.some((p) => text.includes(p));
+}
+async function* streamWithSegments(client, request) {
+  const xmlAbortController = new AbortController();
+  const combinedSignal = request.signal ? AbortSignal.any([request.signal, xmlAbortController.signal]) : xmlAbortController.signal;
+  let content = "";
+  let thinkingContent = "";
+  let response = null;
+  const segments = [];
+  let currentTextSegment = "";
+  let currentThinkingSegment = "";
+  const startTime = performance.now();
+  let firstTokenTime = null;
+  const flushText = () => {
+    if (currentTextSegment.trim()) {
+      segments.push({ type: "text", content: currentTextSegment });
+    }
+    currentTextSegment = "";
+  };
+  const flushThinking = () => {
+    if (currentThinkingSegment.trim()) {
+      segments.push({ type: "thinking", content: currentThinkingSegment });
+    }
+    currentThinkingSegment = "";
+  };
+  try {
+    for await (const event of client.stream({ ...request, signal: combinedSignal })) {
+      switch (event.type) {
+        case "text_delta":
+          if (firstTokenTime === null) {
+            firstTokenTime = performance.now();
           }
-        } finally {
-          clearInterval(idleTimer);
-        }
-        if (tagBuffer) {
-          if (inThinking) {
-            fullThinking += tagBuffer;
+          flushThinking();
+          content += event.content;
+          currentTextSegment += event.content;
+          if (hasXmlToolPattern(content)) {
+            xmlAbortController.abort();
+            yield { type: "xml_tool_abort" };
+            return null;
           }
-          tagBuffer = "";
-        }
-        let finalContent = fullContent.trim();
-        let finalThinking = fullThinking.trim();
-        if (!capabilities.supportsReasoningField && profile.supportsReasoning) {
-          const extracted = extractThinking(finalContent);
-          finalContent = extracted.content;
-          finalThinking = extracted.thinkingContent ?? "";
-        }
-        if (!finalContent && finalThinking) {
-          finalContent = finalThinking;
-          finalThinking = "";
-        }
-        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: "text_delta", content: event.content };
+          break;
+        case "thinking_delta":
+          if (firstTokenTime === null) {
+            firstTokenTime = performance.now();
           }
-        }
-        yield {
-          type: "done",
-          response: {
-            id: responseId,
-            content: finalContent,
-            ...finalThinking ? { thinkingContent: finalThinking } : {},
-            ...parsedToolCalls.length > 0 ? { toolCalls: parsedToolCalls } : {},
-            finishReason,
-            usage
+          flushText();
+          thinkingContent += event.content;
+          currentThinkingSegment += event.content;
+          if (hasXmlToolPattern(thinkingContent)) {
+            xmlAbortController.abort();
+            yield { type: "xml_tool_abort" };
+            return null;
           }
-        };
-      } catch (error) {
-        logger.error("LLM stream error", { error });
-        yield {
-          type: "error",
-          error: error instanceof Error ? error.message : "Unknown LLM error"
-        };
+          yield { type: "thinking_delta", content: event.content };
+          break;
+        case "tool_call_delta":
+          yield {
+            type: "tool_call_delta",
+            index: event.index,
+            ...event.id !== void 0 ? { id: event.id } : {},
+            ...event.name !== void 0 ? { name: event.name } : {},
+            ...event.arguments !== void 0 ? { arguments: event.arguments } : {}
+          };
+          break;
+        case "done":
+          flushThinking();
+          flushText();
+          response = event.response;
+          yield { type: "done", response: event.response };
+          break;
+        case "error":
+          yield { type: "error", error: event.error };
+          return null;
       }
     }
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return null;
+    }
+    yield { type: "error", error: error instanceof Error ? error.message : "Unknown error" };
+    return null;
+  }
+  if (!response) {
+    return null;
+  }
+  const toolCalls = response.toolCalls ?? [];
+  for (const tc of toolCalls) {
+    segments.push({ type: "tool_call", toolCallId: tc.id });
+  }
+  const endTime = performance.now();
+  const ttft = ((firstTokenTime ?? endTime) - startTime) / 1e3;
+  const completionTime = (endTime - (firstTokenTime ?? startTime)) / 1e3;
+  const { promptTokens, completionTokens } = response.usage;
+  const effectiveThinkingContent = thinkingContent || content === "" && response.reasoning_content || "";
+  return {
+    content,
+    thinkingContent: effectiveThinkingContent,
+    toolCalls,
+    response,
+    segments,
+    timing: {
+      ttft,
+      completionTime,
+      tps: completionTime > 0 ? completionTokens / completionTime : 0,
+      prefillTps: ttft > 0 ? promptTokens / ttft : 0
+    }
   };
 }
 
 export {
-  SessionNotFoundError,
   getModelProfile,
+  getBackendCapabilities,
   detectBackend,
   getBackendDisplayName,
-  createLLMClient,
-  detectModel,
-  getLlmStatus,
-  setLlmStatus,
-  clearModelCache
+  buildModelParams,
+  buildNonStreamingCreateParams,
+  buildStreamingCreateParams,
+  mapFinishReason,
+  extractThinking,
+  streamWithSegments
 };
-//# sourceMappingURL=chunk-OVLFEBRR.js.map
+//# sourceMappingURL=chunk-D4ZLSV6P.js.map