openfox 2.0.24 → 2.0.26

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-C4HZJNUN.js}

@@ -1,25 +1,16 @@
 import {
-  applyGeneratedSessionName,
   buildRunChatTurnParams,
   finalizeTurnCompletion,
-  generateSessionName,
-  getSessionMessageCount,
-  needsNameGenerationCheck
-} from "./chunk-GI24G4OW.js";
+  generateSessionNameForSession
+} from "./chunk-VI236SOY.js";
 import {
   runChatTurn
-} from "./chunk-QK6TYNUN.js";
-import "./chunk-MDRNKI7D.js";
-import "./chunk-O4TED6AJ.js";
-import "./chunk-YUHODMKY.js";
+} from "./chunk-7H4PYZMT.js";
+import "./chunk-K454WU7A.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-C4HZJNUN.js.map

package/dist/{chunk-QK6TYNUN.js → chunk-7H4PYZMT.js}

@@ -14,7 +14,7 @@ import {
   loadAllAgentsDefault,
   processEventsForConversation,
   runTopLevelAgentLoop
-} from "./chunk-MDRNKI7D.js";
+} from "./chunk-K454WU7A.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-7H4PYZMT.js.map

package/dist/{chunk-RYHCYZQ7.js → chunk-DW55I7SI.js}

@@ -1,11 +1,8 @@
-import {
-  appendCompactionPrompt
-} from "./chunk-CDIYCGCO.js";
 import {
   injectWorkflowKickoffIfNeeded,
   runAgentTurn,
   runChatTurn
-} from "./chunk-QK6TYNUN.js";
+} from "./chunk-7H4PYZMT.js";
 import {
   applyDynamicContext,
   checkAborted,
@@ -22,20 +19,11 @@ import {
   loadAllAgentsDefault,
   saveItemToDir,
   spawnShellProcess
-} from "./chunk-MDRNKI7D.js";
-import {
-  TurnMetrics,
-  createMessageStartEvent
-} from "./chunk-YUHODMKY.js";
+} from "./chunk-K454WU7A.js";
 import {
   getPlatformShell,
   onProcessEvent
 } from "./chunk-PBGOZMVY.js";
-import {
-  getCurrentContextWindowId,
-  getEventStore,
-  getRuntimeConfig
-} from "./chunk-YBWY4DKY.js";
 import {
   createChatErrorMessage,
   createChatMessageMessage,
@@ -53,6 +41,27 @@ import {
 import {
   provideAnswer
 } from "./chunk-EU3WWTFH.js";
+import {
+  appendCompactionPrompt
+} from "./chunk-WEXW7ZXJ.js";
+import {
+  TurnMetrics,
+  createMessageStartEvent
+} from "./chunk-YGSBVKFU.js";
+import {
+  getCurrentContextWindowId,
+  getEventStore,
+  getRuntimeConfig
+} from "./chunk-YBWY4DKY.js";
+import {
+  createLLMClient
+} from "./chunk-QYP6MOB5.js";
+import {
+  ensureVersionPrefix
+} from "./chunk-HNCM3D7Y.js";
+import {
+  logger
+} from "./chunk-K44MW7JJ.js";
 import {
   computeSessionStats
 } from "./chunk-VUQCQXXJ.js";
@@ -62,13 +71,6 @@ import {
 import {
   getGlobalConfigDir
 } from "./chunk-CQGTEGKL.js";
-import {
-  createLLMClient,
-  ensureVersionPrefix
-} from "./chunk-XJ4SUDL7.js";
-import {
-  logger
-} from "./chunk-K44MW7JJ.js";
 
 // src/server/ws/server.ts
 import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
@@ -1775,7 +1777,7 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
             const runtimeConfig = getRuntimeConfig();
             const configDir = getGlobalConfigDir(runtimeConfig.mode ?? "production");
             const skills = await getEnabledSkillMetadata(configDir, runtimeConfig.workdir);
-            const { createToolRegistry } = await import("./tools-7CKTYL2G.js");
+            const { createToolRegistry } = await import("./tools-4KGLCQJL.js");
             const allTools = createToolRegistry().definitions;
             const toolFingerprint = getToolFingerprint(allTools);
             const currentHash = computeDynamicContextHash(instructionContent, skills, toolFingerprint);
@@ -1848,7 +1850,7 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
           const runtimeConfig = getRuntimeConfig();
           const configDir = getGlobalConfigDir(runtimeConfig.mode ?? "production");
           const skills = await getEnabledSkillMetadata(configDir, runtimeConfig.workdir);
-          const { createToolRegistry } = await import("./tools-7CKTYL2G.js");
+          const { createToolRegistry } = await import("./tools-4KGLCQJL.js");
           const allTools = createToolRegistry().definitions;
           const toolFingerprint = getToolFingerprint(allTools);
           const currentHash = computeDynamicContextHash(instructionContent, skills, toolFingerprint);
@@ -2069,4 +2071,4 @@ export {
   signalMcpReady,
   createWebSocketServer
 };
-//# sourceMappingURL=chunk-RYHCYZQ7.js.map
+//# sourceMappingURL=chunk-DW55I7SI.js.map

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

@@ -1,17 +1,21 @@
 import {
-  buildModelsUrl,
   clearModelCache,
-  createLLMClient,
-  detectModel,
+  detectModel
+} from "./chunk-M3RB4IF6.js";
+import {
+  createLLMClient
+} from "./chunk-QYP6MOB5.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-GBUP7UDI.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