openfox 2.0.13 → 2.0.14

package/dist/{chat-handler-6NUNVXIU.js → chat-handler-ITXCBFJK.js}

@@ -8,13 +8,13 @@ import {
 } from "./chunk-TIKQWNYK.js";
 import {
   runChatTurn
-} from "./chunk-EZJUU54W.js";
-import "./chunk-2VDLXCLO.js";
+} from "./chunk-7GJ6XYAF.js";
+import "./chunk-4ZTQO5JP.js";
+import "./chunk-XAMAYRDA.js";
 import "./chunk-L7TDUIQY.js";
 import "./chunk-DL6ZILAF.js";
 import "./chunk-PBGOZMVY.js";
 import "./chunk-VRGRAQDG.js";
-import "./chunk-XAMAYRDA.js";
 import {
   getEventStore
 } from "./chunk-SYG2ENUQ.js";
@@ -162,4 +162,4 @@ export {
   startChatSession,
   stopSessionExecution
 };
-//# sourceMappingURL=chat-handler-6NUNVXIU.js.map
+//# sourceMappingURL=chat-handler-ITXCBFJK.js.map

package/dist/{chunk-A52FXWJX.js → chunk-3SGGOBCL.js}

@@ -1,389 +1,18 @@
 import {
-  buildNonStreamingCreateParams,
-  buildStreamingCreateParams,
-  getBackendCapabilities,
-  getModelProfile,
-  getThinking,
-  mapFinishReason
+  buildModelsUrl,
+  clearModelCache,
+  createLLMClient,
+  detectModel,
+  ensureVersionPrefix,
+  stripVersionPrefix
+} from "./chunk-PQ56PX7L.js";
+import {
+  getModelProfile
 } from "./chunk-Z4SWOUWC.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, "");
@@ -906,15 +535,9 @@ function createProviderManager(config) {
 }
 
 export {
-  SessionNotFoundError,
-  ensureVersionPrefix,
-  buildModelsUrl,
-  createLLMClient,
-  detectModel,
-  getLlmStatus,
   fetchAvailableModelsFromBackend,
   fetchModelsWithContext,
   parseDefaultModelSelection,
   createProviderManager
 };
-//# sourceMappingURL=chunk-A52FXWJX.js.map
+//# sourceMappingURL=chunk-3SGGOBCL.js.map