openfox 2.0.23 → 2.0.25

package/dist/{chunk-GI24G4OW.js → chunk-AYJTMZVU.js}

@@ -1,3 +1,10 @@
+import {
+  createContextStateMessage,
+  createSessionStateMessage
+} from "./chunk-F4PMNP7S.js";
+import {
+  getPendingQuestionsForSession
+} from "./chunk-EU3WWTFH.js";
 import {
   getEventStore,
   updateSessionMetadata
@@ -6,13 +13,6 @@ import {
   buildMessagesFromStoredEvents,
   foldPendingConfirmations
 } from "./chunk-6PLAWCHQ.js";
-import {
-  createContextStateMessage,
-  createSessionStateMessage
-} from "./chunk-F4PMNP7S.js";
-import {
-  getPendingQuestionsForSession
-} from "./chunk-EU3WWTFH.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -58,53 +58,6 @@ Example inputs and outputs:
 - "Add unit tests for the API" \u2192 "Add API unit tests"
 
 User message: {message}`;
-async function generateSessionName(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);
-    const messages = [
-      {
-        role: "user",
-        content: prompt
-      }
-    ];
-    const timeoutSignal = AbortSignal.timeout(6e4);
-    const composedSignal = signal ? AbortSignal.any([timeoutSignal, signal]) : timeoutSignal;
-    const response = await llmClient.complete({
-      messages,
-      tools: [],
-      signal: composedSignal,
-      // 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 || response.thinkingContent || "").trim();
-    if (name.length > 50) {
-      name = name.substring(0, 47) + "...";
-    }
-    if (!name || name.length < 3) {
-      return {
-        success: false,
-        error: "Generated name is too short or empty"
-      };
-    }
-    logger.debug("Session name generated successfully", { name });
-    return {
-      success: true,
-      name
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : "Unknown error generating session name";
-    logger.debug("Session name generation error", { error: errorMessage });
-    return {
-      success: false,
-      error: errorMessage
-    };
-  }
-}
 function needsNameGeneration(sessionTitle, messageCount) {
   if (messageCount > 1) {
     return false;
@@ -145,13 +98,80 @@ function applyGeneratedSessionName(sessionId, name, deps) {
     );
   }
 }
+function resolveSessionProvider(session, providerManager) {
+  const providers = providerManager.getProviders();
+  const effectiveModel = session.providerModel ?? providerManager.getCurrentModel();
+  if (!effectiveModel) return void 0;
+  const provider = session.providerId ? providers.find((p) => p.id === session.providerId) : providers.find((p) => p.isActive);
+  if (!provider) return void 0;
+  return {
+    baseUrl: provider.url,
+    ...provider.apiKey ? { apiKey: provider.apiKey } : {},
+    model: effectiveModel
+  };
+}
+async function generateSessionNameForSession(sessionId, userMessage, deps, signal) {
+  const { sessionManager, providerManager, broadcastForSession, eventStore } = deps;
+  const session = sessionManager.getSession(sessionId);
+  if (!session) return;
+  const messageCount = getSessionMessageCount(sessionId);
+  if (!needsNameGenerationCheck(sessionId, session.metadata.title, messageCount)) return;
+  const providerConfig = resolveSessionProvider(session, providerManager);
+  const modelSettings = providerConfig ? providerManager.getModelSettings(providerConfig.model, "non-thinking") : void 0;
+  const prompt = SESSION_NAME_PROMPT.replace("{message}", userMessage);
+  try {
+    let client;
+    if (deps.getLLMClient && providerConfig) {
+      client = deps.getLLMClient();
+      client.setModel(providerConfig.model);
+    } else if (providerConfig) {
+      const { createLLMClient } = await import("./client-725U6BTX.js");
+      client = createLLMClient({
+        llm: {
+          baseUrl: providerConfig.baseUrl,
+          model: providerConfig.model,
+          ...providerConfig.apiKey ? { apiKey: providerConfig.apiKey } : {}
+        }
+      });
+    } else if (deps.getLLMClient) {
+      client = deps.getLLMClient();
+    } else {
+      logger.debug("Session name generation skipped: no LLM client available", { sessionId });
+      return;
+    }
+    const timeoutSignal = AbortSignal.timeout(3e4);
+    const composedSignal = signal ? AbortSignal.any([timeoutSignal, signal]) : timeoutSignal;
+    const response = await client.complete({
+      messages: [{ role: "user", content: prompt }],
+      tools: [],
+      ...modelSettings ? { modelSettings } : {},
+      signal: composedSignal,
+      skipClientReasoningEffort: true
+    });
+    let name = (response.content || response.thinkingContent || "").trim();
+    if (name.length > 50) {
+      name = name.substring(0, 47) + "...";
+    }
+    if (name.length >= 3) {
+      applyGeneratedSessionName(sessionId, name, {
+        sessionManager,
+        eventStore,
+        broadcastForSession
+      });
+    } else {
+      logger.debug("Session name too short", { sessionId, name });
+    }
+  } catch (error) {
+    logger.error("Session name generation error", {
+      sessionId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
 
 export {
-  getSessionMessageCount,
   finalizeTurnCompletion,
   buildRunChatTurnParams,
-  generateSessionName,
-  needsNameGenerationCheck,
-  applyGeneratedSessionName
+  generateSessionNameForSession
 };
-//# sourceMappingURL=chunk-GI24G4OW.js.map
+//# sourceMappingURL=chunk-AYJTMZVU.js.map

package/dist/{chunk-YVF3BLQS.js → chunk-GZOYGODG.js}

@@ -1,17 +1,21 @@
 import {
-  buildModelsUrl,
   clearModelCache,
-  createLLMClient,
-  detectModel,
+  detectModel
+} from "./chunk-M3RB4IF6.js";
+import {
+  createLLMClient
+} from "./chunk-2ELCWCO3.js";
+import {
+  buildModelsUrl,
   ensureVersionPrefix,
   stripVersionPrefix
-} from "./chunk-XJ4SUDL7.js";
-import {
-  getModelProfile
-} from "./chunk-UUFEE7VR.js";
+} from "./chunk-HNCM3D7Y.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
+import {
+  getModelProfile
+} from "./chunk-V4IE7HJY.js";
 
 // src/server/provider-manager.ts
 function normalizeModelId(s) {
@@ -201,7 +205,7 @@ function createProviderManager(config) {
   const { providerId: activeProviderId, model: activeModel } = parseDefaultModelSelection(defaultModelSelection);
   if (activeProviderId && activeModel) {
     const activeProvider = providers.find((p) => p.id === activeProviderId);
-    if (activeProvider && activeProvider.apiKey) {
+    if (activeProvider) {
       llmClient = createLLMClient(createConfigForProvider(activeProvider, activeModel));
     }
   }
@@ -352,8 +356,7 @@ function createProviderManager(config) {
           llmClient = createLLMClient(providerConfig);
           logger.info("setProviders: recreated LLM client for new active provider", {
             providerId: newActiveProviderId,
-            url: activeProvider.url,
-            hasApiKey: !!activeProvider.apiKey
+            url: activeProvider.url
           });
         }
       }
@@ -473,17 +476,28 @@ function createProviderManager(config) {
       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 },
-        ...kwargs ? { chatTemplateKwargs: JSON.parse(kwargs) } : {},
-        ...mode === "thinking" && model.thinkingQueryParams ? { queryParams: JSON.parse(model.thinkingQueryParams) } : {},
-        ...mode === "non-thinking" && model.nonThinkingQueryParams ? { queryParams: JSON.parse(model.nonThinkingQueryParams) } : {}
-      };
+      const baseSettings = {};
+      if (model["temperature"] !== void 0) baseSettings["temperature"] = model["temperature"];
+      if (model["topP"] !== void 0) baseSettings["topP"] = model["topP"];
+      if (model["topK"] !== void 0) baseSettings["topK"] = model["topK"];
+      if (model["maxTokens"] !== void 0) baseSettings["maxTokens"] = model["maxTokens"];
+      if (model["supportsVision"] !== void 0) baseSettings["supportsVision"] = model["supportsVision"];
+      const rawQueryParams = mode === "thinking" ? model.thinkingQueryParams : model.nonThinkingQueryParams;
+      if (rawQueryParams) {
+        return { ...baseSettings, queryParams: JSON.parse(rawQueryParams) };
+      }
+      const modeEnabled = mode === "thinking" ? model.thinkingEnabled : model.nonThinkingEnabled;
+      if (modeEnabled) {
+        return {
+          ...baseSettings,
+          chatTemplateKwargs: mode === "thinking" ? { enable_thinking: true } : { enable_thinking: false }
+        };
+      }
+      const fallbackRawQP = mode === "thinking" ? model.nonThinkingQueryParams : model.thinkingQueryParams;
+      if (fallbackRawQP) {
+        return { ...baseSettings, queryParams: JSON.parse(fallbackRawQP) };
+      }
+      return void 0;
     },
     async refreshProviderModels(providerId) {
       const provider = providers.find((p) => p.id === providerId);
@@ -540,4 +554,4 @@ export {
   parseDefaultModelSelection,
   createProviderManager
 };
-//# sourceMappingURL=chunk-YVF3BLQS.js.map
+//# sourceMappingURL=chunk-GZOYGODG.js.map

package/dist/chunk-HNCM3D7Y.js

@@ -0,0 +1,28 @@
+// src/server/llm/url-utils.ts
+var VERSION_PREFIX_REGEX = /\/v\d+(\/|$)/;
+function hasVersionPrefix(url) {
+  return VERSION_PREFIX_REGEX.test(url);
+}
+function getVersionPrefix(url) {
+  const match = url.match(/\/v\d+/);
+  return match ? match[0] : null;
+}
+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`;
+}
+
+export {
+  hasVersionPrefix,
+  getVersionPrefix,
+  ensureVersionPrefix,
+  stripVersionPrefix,
+  buildModelsUrl
+};
+//# sourceMappingURL=chunk-HNCM3D7Y.js.map

package/dist/chunk-IEDE6VK4.js

@@ -0,0 +1,124 @@
+import {
+  logger
+} from "./chunk-K44MW7JJ.js";
+
+// src/server/llm/http-client.ts
+import { Agent, setGlobalDispatcher } from "undici";
+
+// 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
+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 bodyStr = JSON.stringify(params);
+    logger.debug("HTTP request to LLM", {
+      url,
+      body: bodyStr.slice(0, 2e3),
+      bodyKeys: Object.keys(params)
+    });
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: bodyStr,
+      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, returnRaw) {
+    const response = await this.fetchChatCompletion(params, options);
+    const rawText = await response.text();
+    try {
+      const data = JSON.parse(rawText);
+      if (returnRaw) {
+        return { ...data, raw: rawText };
+      }
+      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();
+  }
+};
+
+export {
+  SessionNotFoundError,
+  LLMError,
+  OpenAIHttpClient
+};
+//# sourceMappingURL=chunk-IEDE6VK4.js.map

package/dist/chunk-J2GP3J3X.js

@@ -0,0 +1,97 @@
+// src/server/llm/streaming.ts
+async function* streamWithSegments(client, request) {
+  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)) {
+      switch (event.type) {
+        case "text_delta":
+          if (firstTokenTime === null) {
+            firstTokenTime = performance.now();
+          }
+          flushThinking();
+          content += event.content;
+          currentTextSegment += event.content;
+          yield { type: "text_delta", content: event.content };
+          break;
+        case "thinking_delta":
+          if (firstTokenTime === null) {
+            firstTokenTime = performance.now();
+          }
+          flushText();
+          thinkingContent += event.content;
+          currentThinkingSegment += event.content;
+          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) {
+    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;
+  return {
+    content,
+    thinkingContent,
+    toolCalls,
+    response,
+    segments,
+    timing: {
+      ttft,
+      completionTime,
+      tps: completionTime > 0 ? completionTokens / completionTime : 0,
+      prefillTps: ttft > 0 ? promptTokens / ttft : 0
+    }
+  };
+}
+
+export {
+  streamWithSegments
+};
+//# sourceMappingURL=chunk-J2GP3J3X.js.map