openfox 2.0.0-beta.14 → 2.0.0-beta.16

package/dist/{ask-BRLFZKEW.js → ask-5SSOA6SZ.js}

@@ -7,7 +7,6 @@ import {
   hasPendingQuestion,
   provideAnswer
 } from "./chunk-BJYPTN5S.js";
-import "./chunk-7D4SUZUM.js";
 export {
   AskUserInterrupt,
   askUserTool,
@@ -17,4 +16,4 @@ export {
   hasPendingQuestion,
   provideAnswer
 };
-//# sourceMappingURL=ask-BRLFZKEW.js.map
+//# sourceMappingURL=ask-5SSOA6SZ.js.map

package/dist/{auth-OGGBJFJQ.js → auth-56SIRACI.js}

@@ -1,7 +1,6 @@
 import {
   getAuthConfigPath
 } from "./chunk-CQGTEGKL.js";
-import "./chunk-7D4SUZUM.js";
 
 // src/cli/auth.ts
 import { readFile, writeFile, mkdir, access } from "fs/promises";
@@ -48,4 +47,4 @@ export {
   saveAuthConfig,
   verifyPassword
 };
-//# sourceMappingURL=auth-OGGBJFJQ.js.map
+//# sourceMappingURL=auth-56SIRACI.js.map

package/dist/{branch.api-TCWNJXYA.js → branch.api-PWFW26KC.js}

@@ -1,7 +1,6 @@
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
-import "./chunk-7D4SUZUM.js";
 
 // src/server/branch.api.ts
 import { spawn } from "child_process";
@@ -46,4 +45,4 @@ function getGitBranch(cwd) {
 export {
   getCurrentBranch
 };
-//# sourceMappingURL=branch.api-TCWNJXYA.js.map
+//# sourceMappingURL=branch.api-PWFW26KC.js.map

package/dist/{chat-handler-ZFQIJIJT.js → chat-handler-7QLHIQOM.js}

@@ -8,8 +8,8 @@ import {
 } from "./chunk-OKLV3ZNN.js";
 import {
   runChatTurn
-} from "./chunk-RUWSVV7U.js";
-import "./chunk-IONKVOSF.js";
+} from "./chunk-D2QILH47.js";
+import "./chunk-W52UQCER.js";
 import "./chunk-DL6ZILAF.js";
 import "./chunk-PBGOZMVY.js";
 import "./chunk-VRGRAQDG.js";
@@ -32,7 +32,6 @@ import "./chunk-LXX2CPM5.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
-import "./chunk-7D4SUZUM.js";
 
 // src/server/session/chat-handler.ts
 var activeAgents = /* @__PURE__ */ new Map();
@@ -162,4 +161,4 @@ export {
   startChatSession,
   stopSessionExecution
 };
-//# sourceMappingURL=chat-handler-ZFQIJIJT.js.map
+//# sourceMappingURL=chat-handler-7QLHIQOM.js.map

package/dist/chunk-4F3C6X4M.js

@@ -0,0 +1,381 @@
+import {
+  buildModelsUrl,
+  buildNonStreamingCreateParams,
+  buildStreamingCreateParams,
+  ensureVersionPrefix,
+  getBackendCapabilities,
+  getModelProfile,
+  getThinking,
+  mapFinishReason,
+  stripVersionPrefix
+} from "./chunk-LXX2CPM5.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/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";
+}
+
+export {
+  SessionNotFoundError,
+  createLLMClient,
+  detectModel,
+  getLlmStatus,
+  clearModelCache
+};
+//# sourceMappingURL=chunk-4F3C6X4M.js.map

package/dist/{chunk-BZJAO4VY.js → chunk-6CVDQJDV.js}

@@ -2,7 +2,7 @@ import {
   clearModelCache,
   createLLMClient,
   detectModel
-} from "./chunk-QD6U3BDD.js";
+} from "./chunk-4F3C6X4M.js";
 import {
   buildModelsUrl,
   detectBackend,
@@ -542,4 +542,4 @@ export {
   parseDefaultModelSelection,
   createProviderManager
 };
-//# sourceMappingURL=chunk-BZJAO4VY.js.map
+//# sourceMappingURL=chunk-6CVDQJDV.js.map