openfox 2.0.24 → 2.0.25

package/dist/auto-config-FZFXOEEG.js

@@ -0,0 +1,169 @@
+import {
+  ensureVersionPrefix
+} from "./chunk-HNCM3D7Y.js";
+import {
+  logger
+} from "./chunk-K44MW7JJ.js";
+
+// src/server/providers/auto-config.ts
+var NON_THINKING_COMBOS = [
+  {},
+  { reasoning_effort: "none" },
+  { chat_template_kwargs: { enable_thinking: false } },
+  { thinking: { type: "disabled" } },
+  { reasoning_effort: "none", chat_template_kwargs: { enable_thinking: false } }
+];
+var THINKING_COMBOS = [
+  { reasoning_effort: "high" },
+  { chat_template_kwargs: { enable_thinking: true } },
+  { thinking: { type: "enabled" } },
+  { reasoning_effort: "high", thinking: { type: "enabled" } }
+];
+async function detectModelInfo(baseUrl, apiKey, backend, modelId) {
+  if (backend === "unknown") {
+    const known = {
+      "deepseek-v4-flash": { ctx: 1e6, vision: false },
+      "deepseek-v4-pro": { ctx: 1e6, vision: false },
+      "glm-5.2": { ctx: 1e6, vision: false },
+      "glm-5.1": { ctx: 1e6, vision: false },
+      "glm-5": { ctx: 1e6, vision: false },
+      "glm-5-turbo": { ctx: 1e6, vision: false },
+      "glm-4.7": { ctx: 128e3, vision: false },
+      "glm-4.6": { ctx: 128e3, vision: false },
+      "glm-4.5": { ctx: 128e3, vision: false },
+      "glm-4-32b-0414-128k": { ctx: 128e3, vision: false }
+    };
+    const knownVal = known[modelId];
+    if (knownVal) return { contextWindow: knownVal.ctx, source: "hardcoded", supportsVision: knownVal.vision };
+  }
+  try {
+    if (backend === "ollama") {
+      return await detectOllamaInfo(baseUrl, modelId);
+    }
+    if (backend === "llamacpp") {
+      return await detectLlamacppInfo(baseUrl);
+    }
+    return await detectVllmInfo(baseUrl, apiKey, modelId);
+  } catch {
+    return { contextWindow: 2e5, source: "default", supportsVision: false };
+  }
+}
+async function detectVllmInfo(baseUrl, apiKey, modelId) {
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+  const response = await fetch(`${ensureVersionPrefix(baseUrl)}/models`, { headers, signal: AbortSignal.timeout(5e3) });
+  if (!response.ok) throw new Error(`HTTP ${response.status}`);
+  const data = await response.json();
+  const model = data.data?.find((m) => m.id === modelId);
+  if (model?.max_model_len) {
+    return { contextWindow: model.max_model_len, source: "backend", supportsVision: false };
+  }
+  throw new Error("No context window in response");
+}
+async function detectLlamacppInfo(baseUrl) {
+  const response = await fetch(`${baseUrl}/props`, { signal: AbortSignal.timeout(5e3) });
+  if (!response.ok) throw new Error(`HTTP ${response.status}`);
+  const data = await response.json();
+  const nCtx = data.default_generation_settings?.n_ctx;
+  const supportsVision = data.modalities?.vision ?? false;
+  if (nCtx) {
+    return { contextWindow: nCtx, source: "backend", supportsVision };
+  }
+  throw new Error("No n_ctx in props");
+}
+async function detectOllamaInfo(baseUrl, modelId) {
+  const response = await fetch(`${baseUrl}/api/show`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ name: modelId }),
+    signal: AbortSignal.timeout(5e3)
+  });
+  if (!response.ok) throw new Error(`HTTP ${response.status}`);
+  const data = await response.json();
+  const mi = data.model_info ?? {};
+  const ctxKey = Object.keys(mi).find((k) => k.endsWith(".context_length") || k === "context_length");
+  const ctxLen = ctxKey ? Number(mi[ctxKey]) : void 0;
+  const supportsVision = !!mi["vision_start_token_id"] || Object.keys(mi).some((k) => k.includes(".vision."));
+  if (ctxLen && !isNaN(ctxLen)) {
+    return { contextWindow: ctxLen, source: "backend", supportsVision };
+  }
+  throw new Error("No context_length in model_info");
+}
+async function probeCombo(baseUrl, apiKey, model, combo, signal) {
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+  const body = {
+    model,
+    messages: [{ role: "user", content: "say hi in one word" }],
+    max_tokens: 50,
+    ...combo
+  };
+  const start = Date.now();
+  try {
+    const response = await fetch(`${ensureVersionPrefix(baseUrl)}/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal
+    });
+    const durationMs = Date.now() - start;
+    if (!response.ok) {
+      return { combo, httpCode: response.status, hasContent: false, durationMs };
+    }
+    const data = await response.json();
+    const message = data.choices?.[0]?.message ?? {};
+    const hasContent = !!(message["content"] || message["reasoning"] || message["reasoning_content"] || message["thinking"]);
+    return { combo, httpCode: response.status, hasContent, durationMs };
+  } catch {
+    const durationMs = Date.now() - start;
+    return { combo, httpCode: 0, hasContent: false, durationMs };
+  }
+}
+async function probeCombos(baseUrl, apiKey, model, combos) {
+  const timeout = AbortSignal.timeout(15e3);
+  const results = await Promise.allSettled(combos.map((combo) => probeCombo(baseUrl, apiKey, model, combo, timeout)));
+  const successful = results.filter(
+    (r) => r.status === "fulfilled" && r.value.httpCode === 200 && r.value.hasContent
+  ).map((r) => r.value).sort((a, b) => a.durationMs - b.durationMs);
+  if (successful.length > 0) {
+    const winner = successful[0];
+    logger.debug("Auto-config: found working combo", {
+      model,
+      combo: winner.combo,
+      durationMs: winner.durationMs
+    });
+    return winner.combo;
+  }
+  logger.debug("Auto-config: no working combo found", { model });
+  return null;
+}
+async function autoConfig(input) {
+  const { url, apiKey, backend, models } = input;
+  const baseUrl = url.replace(/\/+$/, "");
+  const results = [];
+  for (const model of models) {
+    logger.info("Auto-config probing model", { model: model.id, backend });
+    const {
+      contextWindow,
+      source: contextSource,
+      supportsVision
+    } = await detectModelInfo(baseUrl, apiKey, backend, model.id);
+    const [thinkingConfig, nonThinkingConfig] = await Promise.all([
+      probeCombos(baseUrl, apiKey, model.id, THINKING_COMBOS),
+      probeCombos(baseUrl, apiKey, model.id, NON_THINKING_COMBOS)
+    ]);
+    results.push({
+      id: model.id,
+      contextWindow,
+      contextSource,
+      supportsVision,
+      thinkingConfig,
+      nonThinkingConfig
+    });
+  }
+  return { models: results };
+}
+export {
+  autoConfig
+};
+//# sourceMappingURL=auto-config-FZFXOEEG.js.map

package/dist/backend-AGXWAU7A.js

@@ -0,0 +1,9 @@
+import {
+  getBackendCapabilities,
+  getBackendDisplayName
+} from "./chunk-Z4FMBCJO.js";
+export {
+  getBackendCapabilities,
+  getBackendDisplayName
+};
+//# sourceMappingURL=backend-AGXWAU7A.js.map

package/dist/{chat-handler-4ATHDLH4.js → chat-handler-XH3QUXIC.js}

@@ -1,25 +1,16 @@
 import {
-  applyGeneratedSessionName,
   buildRunChatTurnParams,
   finalizeTurnCompletion,
-  generateSessionName,
-  getSessionMessageCount,
-  needsNameGenerationCheck
-} from "./chunk-GI24G4OW.js";
+  generateSessionNameForSession
+} from "./chunk-AYJTMZVU.js";
 import {
   runChatTurn
-} from "./chunk-QK6TYNUN.js";
-import "./chunk-MDRNKI7D.js";
-import "./chunk-O4TED6AJ.js";
-import "./chunk-YUHODMKY.js";
+} from "./chunk-64NCACBV.js";
+import "./chunk-WCPFR6ZP.js";
 import "./chunk-DL6ZILAF.js";
 import "./chunk-PBGOZMVY.js";
 import "./chunk-VRGRAQDG.js";
 import "./chunk-NWO6GRYE.js";
-import {
-  getEventStore
-} from "./chunk-YBWY4DKY.js";
-import "./chunk-6PLAWCHQ.js";
 import {
   createChatMessageMessage,
   createPhaseChangedMessage,
@@ -27,19 +18,26 @@ import {
 } from "./chunk-F4PMNP7S.js";
 import "./chunk-EU3WWTFH.js";
 import "./chunk-RFNEDBVO.js";
+import "./chunk-O4TED6AJ.js";
+import "./chunk-YGSBVKFU.js";
+import {
+  getEventStore
+} from "./chunk-YBWY4DKY.js";
+import "./chunk-6PLAWCHQ.js";
 import "./chunk-FBGWG4N6.js";
+import "./chunk-J2GP3J3X.js";
+import "./chunk-Z4FMBCJO.js";
+import "./chunk-ZJ4FP6RS.js";
+import "./chunk-K44MW7JJ.js";
 import "./chunk-YD6NDTKF.js";
 import "./chunk-SNQT7LNU.js";
 import "./chunk-CQGTEGKL.js";
-import "./chunk-UUFEE7VR.js";
-import {
-  logger
-} from "./chunk-K44MW7JJ.js";
+import "./chunk-V4IE7HJY.js";
 
 // src/server/session/chat-handler.ts
 var activeAgents = /* @__PURE__ */ new Map();
 async function startChatSession(sessionId, content, deps, options) {
-  const { sessionManager, llmClient, broadcastForSession } = deps;
+  const { sessionManager, broadcastForSession } = deps;
   const session = sessionManager.getSession(sessionId);
   if (!session) {
     throw new Error("Session not found");
@@ -69,34 +67,17 @@ async function startChatSession(sessionId, content, deps, options) {
       ...options?.isSystemGenerated && { isSystemGenerated: options.isSystemGenerated }
     });
     broadcastForSession(sessionId, createChatMessageMessage(userMessage));
-    const messageCount = getSessionMessageCount(sessionId);
-    const currentSession = sessionManager.getSession(sessionId);
-    if (currentSession && needsNameGenerationCheck(sessionId, currentSession.metadata.title, messageCount)) {
-      generateSessionName({
-        userMessage: content,
-        llmClient,
-        signal: controller.signal
-      }).then((result) => {
-        logger.debug("Session name generation result", {
-          sessionId,
-          success: result.success,
-          name: result.name,
-          error: result.error
-        });
-        if (result.success && result.name) {
-          applyGeneratedSessionName(sessionId, result.name, {
-            sessionManager,
-            eventStore,
-            broadcastForSession
-          });
-        }
-      }).catch((error) => {
-        logger.error("Session name generation failed", {
-          sessionId,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      });
-    }
+    generateSessionNameForSession(
+      sessionId,
+      content,
+      {
+        sessionManager,
+        providerManager: deps.providerManager,
+        broadcastForSession,
+        eventStore
+      },
+      controller.signal
+    );
     startTurnWithCompletionChain(sessionId, controller, deps);
   } catch (error) {
     if (activeAgents.get(sessionId) === controller) {
@@ -164,4 +145,4 @@ export {
   startChatSession,
   stopSessionExecution
 };
-//# sourceMappingURL=chat-handler-4ATHDLH4.js.map
+//# sourceMappingURL=chat-handler-XH3QUXIC.js.map

package/dist/{chunk-XJ4SUDL7.js → chunk-2ELCWCO3.js}

@@ -1,132 +1,25 @@
+import {
+  getBackendCapabilities
+} from "./chunk-Z4FMBCJO.js";
+import {
+  ensureVersionPrefix
+} from "./chunk-HNCM3D7Y.js";
 import {
   buildNonStreamingCreateParams,
   buildStreamingCreateParams,
-  getBackendCapabilities,
-  getModelProfile,
   getThinking,
   mapFinishReason
-} from "./chunk-UUFEE7VR.js";
+} from "./chunk-ZJ4FP6RS.js";
+import {
+  LLMError,
+  OpenAIHttpClient
+} from "./chunk-IEDE6VK4.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
-
-// 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/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/http-client.ts
-import { Agent, setGlobalDispatcher } from "undici";
-var agent = new Agent({ allowH2: true });
-setGlobalDispatcher(agent);
-var OpenAIHttpClient = class {
-  baseURL;
-  apiKey;
-  constructor(options) {
-    this.baseURL = options.baseURL;
-    this.apiKey = options.apiKey;
-  }
-  async fetchChatCompletion(params, options) {
-    const url = `${this.baseURL}/chat/completions`;
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${this.apiKey}`
-    };
-    const response = await fetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(params),
-      signal: options?.signal ?? null
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new LLMError(`HTTP ${response.status}: ${errorText}`);
-    }
-    return response;
-  }
-  async createChatCompletion(params, options) {
-    const response = await this.fetchChatCompletion(params, options);
-    try {
-      const data = await response.json();
-      return data;
-    } catch (error) {
-      throw new LLMError(`Failed to parse response: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  }
-  createChatCompletionStream(params, options) {
-    const responsePromise = this.fetchChatCompletion(params, options);
-    async function* generate() {
-      const response = await responsePromise;
-      if (!response.body) {
-        throw new LLMError("No response body for streaming");
-      }
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed) continue;
-            if (trimmed.startsWith("data: ")) {
-              const data = trimmed.slice(6);
-              if (data === "[DONE]") {
-                return;
-              }
-              try {
-                const chunk = JSON.parse(data);
-                yield chunk;
-              } catch (error) {
-                logger.warn("Failed to parse SSE chunk", { data, error });
-              }
-            }
-          }
-        }
-      } finally {
-        reader.releaseLock();
-      }
-    }
-    return generate();
-  }
-};
+import {
+  getModelProfile
+} from "./chunk-V4IE7HJY.js";
 
 // src/server/llm/client.ts
 function createLLMClient(config, initialBackend = "unknown") {
@@ -176,7 +69,7 @@ function createLLMClient(config, initialBackend = "unknown") {
         reasoningEffort: request.reasoningEffort ?? reasoningEffort
       });
       try {
-        const resolvedEffort = request.reasoningEffort ?? reasoningEffort;
+        const resolvedEffort = request.skipClientReasoningEffort ? void 0 : request.reasoningEffort ?? reasoningEffort;
         const { params: createParams } = await buildNonStreamingCreateParams({
           model,
           request,
@@ -185,10 +78,14 @@ function createLLMClient(config, initialBackend = "unknown") {
           ...resolvedEffort ? { reasoningEffort: resolvedEffort } : {},
           ...thinkingField ? { thinkingField } : {}
         });
-        const response = await httpClient.createChatCompletion(createParams, {
-          signal: request.signal
-        });
-        const choice = response.choices[0];
+        const httpResponse = await httpClient.createChatCompletion(
+          createParams,
+          {
+            signal: request.signal
+          },
+          request.returnRaw
+        );
+        const choice = httpResponse.choices[0];
         if (!choice) {
           throw new LLMError("No completion choice returned");
         }
@@ -201,16 +98,17 @@ function createLLMClient(config, initialBackend = "unknown") {
           arguments: JSON.parse(tc.function.arguments)
         }));
         return {
-          id: response.id,
+          id: httpResponse.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
-          }
+            promptTokens: httpResponse.usage?.prompt_tokens ?? 0,
+            completionTokens: httpResponse.usage?.completion_tokens ?? 0,
+            totalTokens: httpResponse.usage?.total_tokens ?? 0
+          },
+          ...httpResponse.raw ? { raw: httpResponse.raw } : {}
         };
       } catch (error) {
         logger.error("LLM complete error", { error: String(error) });
@@ -220,7 +118,7 @@ function createLLMClient(config, initialBackend = "unknown") {
       }
     },
     async *stream(request) {
-      const resolvedEffort = request.reasoningEffort ?? reasoningEffort;
+      const resolvedEffort = request.skipClientReasoningEffort ? void 0 : request.reasoningEffort ?? reasoningEffort;
       logger.debug("LLM stream request", {
         messageCount: request.messages.length,
         hasTools: !!request.tools?.length,
@@ -358,114 +256,7 @@ function createLLMClient(config, initialBackend = "unknown") {
   };
 }
 
-// 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";
-}
-
 export {
-  SessionNotFoundError,
-  ensureVersionPrefix,
-  stripVersionPrefix,
-  buildModelsUrl,
-  createLLMClient,
-  detectModel,
-  getLlmStatus,
-  clearModelCache
+  createLLMClient
 };
-//# sourceMappingURL=chunk-XJ4SUDL7.js.map
+//# sourceMappingURL=chunk-2ELCWCO3.js.map

package/dist/{chunk-QK6TYNUN.js → chunk-64NCACBV.js}

@@ -14,7 +14,7 @@ import {
   loadAllAgentsDefault,
   processEventsForConversation,
   runTopLevelAgentLoop
-} from "./chunk-MDRNKI7D.js";
+} from "./chunk-WCPFR6ZP.js";
 import {
   TurnMetrics,
   WORKFLOW_KICKOFF_PROMPT,
@@ -22,7 +22,7 @@ import {
   buildAgentSmallReminder,
   createChatDoneEvent,
   createMessageStartEvent
-} from "./chunk-YUHODMKY.js";
+} from "./chunk-YGSBVKFU.js";
 import {
   getCurrentContextWindowId,
   getCurrentWindowMessageOptions,
@@ -32,12 +32,12 @@ import {
 import {
   buildSnapshotFromSessionState
 } from "./chunk-6PLAWCHQ.js";
-import {
-  getGlobalConfigDir
-} from "./chunk-CQGTEGKL.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
+import {
+  getGlobalConfigDir
+} from "./chunk-CQGTEGKL.js";
 
 // src/server/chat/orchestrator.ts
 async function buildRetryPatterns() {
@@ -320,4 +320,4 @@ export {
   runAgentTurn,
   injectWorkflowKickoffIfNeeded
 };
-//# sourceMappingURL=chunk-QK6TYNUN.js.map
+//# sourceMappingURL=chunk-64NCACBV.js.map