openfox 0.1.0

package/dist/chunk-FF6Z2MC3.js

@@ -0,0 +1,844 @@
+import {
+  logger
+} from "./chunk-U62ZECSQ.js";
+
+// src/server/llm/backend.ts
+var BACKEND_CAPABILITIES = {
+  vllm: {
+    supportsReasoningField: true,
+    supportsChatTemplateKwargs: true,
+    supportsTopK: true
+  },
+  sglang: {
+    supportsReasoningField: true,
+    supportsChatTemplateKwargs: true,
+    supportsTopK: true
+  },
+  ollama: {
+    supportsReasoningField: false,
+    supportsChatTemplateKwargs: false,
+    supportsTopK: false
+  },
+  llamacpp: {
+    supportsReasoningField: false,
+    supportsChatTemplateKwargs: false,
+    supportsTopK: true
+  },
+  unknown: {
+    // Assume vLLM-like for unknown backends
+    supportsReasoningField: true,
+    supportsChatTemplateKwargs: true,
+    supportsTopK: true
+  }
+};
+function getBackendCapabilities(backend) {
+  return BACKEND_CAPABILITIES[backend];
+}
+async function detectBackend(baseUrl, explicitBackend, silent = false) {
+  if (explicitBackend && explicitBackend !== "unknown") {
+    if (silent) {
+      logger.debug("Using explicit backend", { backend: explicitBackend });
+    } else {
+      logger.info("Using explicit backend", { backend: explicitBackend });
+    }
+    return explicitBackend;
+  }
+  const probeUrl = baseUrl.replace(/\/v1\/?$/, "");
+  try {
+    if (await probeOllama(probeUrl)) {
+      if (silent) {
+        logger.debug("Detected Ollama backend", { url: probeUrl });
+      } else {
+        logger.info("Detected Ollama backend", { url: probeUrl });
+      }
+      return "ollama";
+    }
+    if (await probeLlamaCpp(probeUrl)) {
+      if (silent) {
+        logger.debug("Detected llama.cpp backend", { url: probeUrl });
+      } else {
+        logger.info("Detected llama.cpp backend", { url: probeUrl });
+      }
+      return "llamacpp";
+    }
+    if (await probeSGLang(probeUrl)) {
+      if (silent) {
+        logger.debug("Detected SGLang backend", { url: probeUrl });
+      } else {
+        logger.info("Detected SGLang backend", { url: probeUrl });
+      }
+      return "sglang";
+    }
+    if (await probeOpenAI(baseUrl)) {
+      if (silent) {
+        logger.debug("Detected vLLM backend (OpenAI-compatible)", { url: baseUrl });
+      } else {
+        logger.info("Detected vLLM backend (OpenAI-compatible)", { url: baseUrl });
+      }
+      return "vllm";
+    }
+    if (silent) {
+      logger.debug("Could not detect backend, using unknown", { url: baseUrl });
+    } else {
+      logger.warn("Could not detect backend, using unknown", { url: baseUrl });
+    }
+    return "unknown";
+  } catch (error) {
+    if (silent) {
+      logger.debug("Backend detection failed", {
+        url: baseUrl,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    } else {
+      logger.warn("Backend detection failed", {
+        url: baseUrl,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    return "unknown";
+  }
+}
+async function probeOllama(baseUrl) {
+  try {
+    const response = await fetch(`${baseUrl}/api/tags`, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function probeLlamaCpp(baseUrl) {
+  try {
+    const response = await fetch(`${baseUrl}/health`, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) return false;
+    const data = await response.json();
+    return "slots_idle" in data || "slots_processing" in data;
+  } catch {
+    return false;
+  }
+}
+async function probeSGLang(baseUrl) {
+  try {
+    const response = await fetch(`${baseUrl}/get_model_info`, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function probeOpenAI(baseUrl) {
+  try {
+    const url = baseUrl.includes("/v1") ? baseUrl : `${baseUrl}/v1`;
+    const response = await fetch(`${url}/models`, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function getBackendDisplayName(backend) {
+  switch (backend) {
+    case "vllm":
+      return "vLLM";
+    case "sglang":
+      return "SGLang";
+    case "ollama":
+      return "Ollama";
+    case "llamacpp":
+      return "llama.cpp";
+    case "unknown":
+      return "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 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 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",
+  temperature: 0.7,
+  topP: 0.9,
+  supportsReasoning: false,
+  reasoningAsContent: false,
+  defaultMaxTokens: 4096
+};
+var MOCK_PROFILE = {
+  name: "mock",
+  temperature: 0.7,
+  topP: 0.9,
+  supportsReasoning: false,
+  reasoningAsContent: false,
+  defaultMaxTokens: 1024
+};
+var MODEL_PROFILES = [
+  {
+    pattern: "mistral",
+    profile: {
+      name: "Mistral",
+      temperature: 0.7,
+      topP: 0.9,
+      supportsReasoning: false,
+      reasoningAsContent: false,
+      defaultMaxTokens: 4096
+    }
+  },
+  {
+    pattern: "qwen3-coder-next",
+    profile: {
+      name: "Qwen3-Coder-Next",
+      // Per Qwen docs: "temperature=1.0, top_p=0.95, top_k=40"
+      temperature: 1,
+      topP: 0.95,
+      topK: 40,
+      // "This model supports only non-thinking mode and does not generate <think></think> blocks"
+      supportsReasoning: false,
+      reasoningAsContent: false,
+      defaultMaxTokens: 8192
+    }
+  },
+  {
+    pattern: "qwen3",
+    profile: {
+      name: "Qwen3",
+      temperature: 0.7,
+      topP: 0.9,
+      supportsReasoning: true,
+      reasoningAsContent: false,
+      defaultMaxTokens: 4096
+    }
+  },
+  {
+    pattern: "deepseek",
+    profile: {
+      name: "DeepSeek",
+      temperature: 0.6,
+      topP: 0.95,
+      supportsReasoning: true,
+      reasoningAsContent: false,
+      defaultMaxTokens: 4096
+    }
+  },
+  {
+    pattern: "llama",
+    profile: {
+      name: "Llama",
+      temperature: 0.7,
+      topP: 0.9,
+      supportsReasoning: false,
+      reasoningAsContent: false,
+      defaultMaxTokens: 4096
+    }
+  },
+  {
+    pattern: "claude",
+    profile: {
+      name: "Claude",
+      temperature: 0.7,
+      topP: 0.9,
+      supportsReasoning: true,
+      reasoningAsContent: false,
+      defaultMaxTokens: 4096
+    }
+  }
+];
+function getModelProfile(modelName) {
+  const lowerName = modelName.toLowerCase();
+  if (lowerName.includes("mock")) {
+    return MOCK_PROFILE;
+  }
+  for (const { pattern, profile } of MODEL_PROFILES) {
+    if (lowerName.includes(pattern.toLowerCase())) {
+      return profile;
+    }
+  }
+  return DEFAULT_PROFILE;
+}
+
+// src/server/llm/client-pure.ts
+function convertMessages(messages) {
+  const filtered = messages.filter((msg) => {
+    return !(msg.role === "assistant" && !msg.content?.trim() && !msg.toolCalls?.length);
+  });
+  return filtered.map((msg) => {
+    if (msg.role === "tool") {
+      return {
+        role: "tool",
+        content: msg.content,
+        tool_call_id: msg.toolCallId
+      };
+    }
+    if (msg.role === "assistant" && msg.toolCalls?.length) {
+      return {
+        role: "assistant",
+        content: msg.content || null,
+        tool_calls: msg.toolCalls.map((toolCall) => ({
+          id: toolCall.id,
+          type: "function",
+          function: {
+            name: toolCall.name,
+            arguments: JSON.stringify(toolCall.arguments)
+          }
+        }))
+      };
+    }
+    if (msg.role === "user" && msg.attachments && msg.attachments.length > 0) {
+      const content = [];
+      if (msg.content?.trim()) {
+        content.push({ type: "text", text: msg.content });
+      }
+      for (const attachment of msg.attachments) {
+        content.push({
+          type: "image_url",
+          image_url: {
+            url: attachment.data
+            // base64 data URL
+          }
+        });
+      }
+      return {
+        role: "user",
+        content
+      };
+    }
+    return {
+      role: msg.role,
+      content: msg.content
+    };
+  });
+}
+function convertTools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.function.name,
+      description: tool.function.description,
+      parameters: tool.function.parameters
+    }
+  }));
+}
+function buildNonStreamingCreateParams(input) {
+  const { model, request, profile, capabilities, disableThinking } = input;
+  const params = {
+    model,
+    messages: convertMessages(request.messages),
+    ...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,
+    stream: false
+  };
+  if (capabilities.supportsTopK && profile.topK !== void 0) {
+    ;
+    params["top_k"] = profile.topK;
+  }
+  if (capabilities.supportsChatTemplateKwargs && profile.supportsReasoning && disableThinking) {
+    ;
+    params["chat_template_kwargs"] = { enable_thinking: false };
+  }
+  return params;
+}
+function buildStreamingCreateParams(input) {
+  const { model, request, profile, capabilities, disableThinking } = input;
+  const params = {
+    model,
+    messages: convertMessages(request.messages),
+    ...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,
+    stream: true,
+    stream_options: { include_usage: true }
+  };
+  if (capabilities.supportsTopK && profile.topK !== void 0) {
+    ;
+    params["top_k"] = profile.topK;
+  }
+  if (capabilities.supportsChatTemplateKwargs && profile.supportsReasoning && (disableThinking || request.disableThinking)) {
+    ;
+    params["chat_template_kwargs"] = { enable_thinking: false };
+  }
+  return params;
+}
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "stop";
+    case "tool_calls":
+      return "tool_calls";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content_filter";
+    default:
+      return "stop";
+  }
+}
+function extractThinking(content) {
+  const thinkRegex = /<think>([\s\S]*?)<\/think>/g;
+  let thinkingContent = "";
+  let cleanContent = content;
+  let match;
+  while ((match = thinkRegex.exec(content)) !== null) {
+    thinkingContent += match[1];
+    cleanContent = cleanContent.replace(match[0], "");
+  }
+  return {
+    content: cleanContent.trim(),
+    thinkingContent: thinkingContent.trim() || null
+  };
+}
+
+// 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: "not-needed"
+    // Most local backends don't require API key
+  });
+  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;
+        const createParams = buildNonStreamingCreateParams({
+          model,
+          request,
+          profile,
+          capabilities,
+          disableThinking: shouldDisableThinking
+        });
+        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 {
+        const shouldDisableThinking = disableThinking || request.disableThinking === true;
+        const createParams = buildStreamingCreateParams({ model, request, profile, capabilities, disableThinking: shouldDisableThinking });
+        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 } : {}
+                };
+              }
+            }
+          }
+        } finally {
+          clearInterval(idleTimer);
+        }
+        if (tagBuffer) {
+          if (inThinking) {
+            fullThinking += tagBuffer;
+          }
+          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: "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"
+        };
+      }
+    }
+  };
+}
+
+export {
+  SessionNotFoundError,
+  getModelProfile,
+  detectBackend,
+  getBackendDisplayName,
+  createLLMClient,
+  detectModel,
+  getLlmStatus,
+  clearModelCache
+};
+//# sourceMappingURL=chunk-FF6Z2MC3.js.map