openfox 2.0.128 → 2.0.130

package/dist/{chunk-D5QVV3LT.js → chunk-DHDIKVRT.js}

@@ -1,9 +1,9 @@
 import {
   getModelProfile
-} from "./chunk-7ZMOP5LS.js";
+} from "./chunk-TS5WKTFB.js";
 import {
   getBackendCapabilities
-} from "./chunk-PBFGJFGC.js";
+} from "./chunk-UV6IH6HK.js";
 import {
   ensureVersionPrefix,
   stripVersionPrefix
@@ -14,16 +14,267 @@ import {
   getThinking,
   mapFinishReason,
   parseToolArguments
-} from "./chunk-KAZWU73N.js";
+} from "./chunk-EUOWCVU6.js";
 import {
   ChatHttpClient,
+  DONE,
   LLMError,
   OpenAIHttpClient
-} from "./chunk-ZFNBATE3.js";
+} from "./chunk-OXMOKQPW.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
 
+// src/server/llm/responses-routing.ts
+var OPENCODE_GO_RESPONSES_RULES = [
+  {
+    pattern: /^(gpt-5\.6-luna|grok-4\.6|muse-spark-1\.2-contributor)$/i,
+    protocol: "responses"
+  }
+];
+function basename(modelId) {
+  return modelId.split("/").pop() ?? modelId;
+}
+function matchesRules(modelId, rules) {
+  const name = basename(modelId);
+  for (const rule of rules) {
+    if (rule.pattern.test(modelId) || rule.pattern.test(name)) return rule.protocol;
+  }
+  return void 0;
+}
+function resolveApiProtocol(input) {
+  const { model, backend, profileApiProtocol, explicitApiProtocol } = input;
+  if (explicitApiProtocol) return explicitApiProtocol;
+  if (backend === "openai" && profileApiProtocol) return profileApiProtocol;
+  if (backend === "opencode-go") {
+    const matched = matchesRules(model, OPENCODE_GO_RESPONSES_RULES);
+    if (matched) return matched;
+  }
+  return "chat-completions";
+}
+
+// src/server/llm/responses-native.ts
+function messageToInputItem(message) {
+  if (message.role === "system" || message.role === "developer") return null;
+  if (message.role === "tool") {
+    return { type: "function_call_output", call_id: message.tool_call_id ?? "", output: message.content ?? "" };
+  }
+  if (message.role === "assistant" && message.tool_calls?.length) {
+    const items = [];
+    if (message.content) items.push({ role: "assistant", content: message.content });
+    for (const toolCall of message.tool_calls) {
+      items.push({
+        type: "function_call",
+        call_id: toolCall.id,
+        name: toolCall.function.name,
+        arguments: toolCall.function.arguments
+      });
+    }
+    return items.length === 1 ? items[0] : { __multi: items };
+  }
+  return { role: message.role, content: message.content ?? "" };
+}
+function flattenInput(items) {
+  return items.flatMap(
+    (item) => item["__multi"] !== void 0 ? item["__multi"] : [item]
+  );
+}
+function convertTools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.function.name,
+    description: tool.function.description,
+    parameters: tool.function.parameters
+  }));
+}
+function buildResponsesRequest(params) {
+  const systemMessages = params.messages.filter((m) => m.role === "system" || m.role === "developer");
+  const instructions = systemMessages.map((m) => typeof m.content === "string" ? m.content : "").join("\n\n");
+  const body = {
+    model: params.model,
+    input: flattenInput(
+      params.messages.map(messageToInputItem).filter((item) => item !== null)
+    ),
+    stream: Boolean(params.stream),
+    store: false
+  };
+  if (instructions) body.instructions = instructions;
+  if (params.tools?.length) body.tools = convertTools(params.tools);
+  if (params.tool_choice !== void 0) {
+    const choice = params.tool_choice;
+    body.tool_choice = choice === "auto" || choice === "none" ? choice : "auto";
+  }
+  const maxTokens = params.max_tokens ?? params.max_completion_tokens;
+  if (maxTokens !== void 0) body.max_output_tokens = maxTokens;
+  const effort = params.reasoning_effort;
+  if (effort && effort !== "none") {
+    body.reasoning = { effort };
+  }
+  return body;
+}
+function mapResponseStatus(status, incompleteReason) {
+  switch (status) {
+    case "incomplete":
+      return incompleteReason === "max_output_tokens" ? "length" : "stop";
+    case "failed":
+    case "cancelled":
+      return "content_filter";
+    default:
+      return "stop";
+  }
+}
+function parseResponsesResponse(data) {
+  let content = "";
+  let reasoning = "";
+  const toolCalls = [];
+  for (const item of data.output ?? []) {
+    if (item.type === "message") {
+      for (const block of item.content ?? []) {
+        if (block.type === "output_text" && block.text) content += block.text;
+      }
+    } else if (item.type === "reasoning") {
+      for (const block of item.summary ?? []) {
+        if (block.text) reasoning += block.text;
+      }
+    } else if (item.type === "function_call") {
+      toolCalls.push({
+        id: item.call_id ?? item.id ?? `call_${toolCalls.length}`,
+        type: "function",
+        function: { name: item.name ?? "", arguments: item.arguments ?? "{}" }
+      });
+    }
+  }
+  const promptTokens = data.usage?.input_tokens ?? 0;
+  const completionTokens = data.usage?.output_tokens ?? 0;
+  const message = { content };
+  if (reasoning) message["reasoning_content"] = reasoning;
+  if (toolCalls.length > 0) message["tool_calls"] = toolCalls;
+  return {
+    id: data.id ?? `resp_${Date.now()}`,
+    choices: [
+      {
+        finish_reason: toolCalls.length > 0 ? "tool_calls" : mapResponseStatus(data.status, data.incomplete_details?.reason),
+        message
+      }
+    ],
+    usage: {
+      prompt_tokens: promptTokens,
+      completion_tokens: completionTokens,
+      total_tokens: data.usage?.total_tokens ?? promptTokens + completionTokens
+    }
+  };
+}
+function parseResponsesEvent(event) {
+  const type = event["type"];
+  const responseId = typeof event["response_id"] === "string" ? event["response_id"] : "resp";
+  switch (type) {
+    case "response.output_text.delta":
+      return chunk(responseId, { content: String(event["delta"] ?? "") });
+    case "response.reasoning_summary_text.delta":
+      return chunk(responseId, { reasoning_content: String(event["delta"] ?? "") });
+    case "response.reasoning_text.delta":
+      return chunk(responseId, { reasoning_content: String(event["delta"] ?? "") });
+    case "response.output_item.added": {
+      const item = event["item"];
+      if (item?.type === "function_call") {
+        const callId = item.call_id ?? item.id;
+        const toolCall = {
+          index: 0,
+          ...callId ? { id: callId } : {},
+          function: { name: item.name ?? "", arguments: item.arguments ?? "" }
+        };
+        return chunk(responseId, { tool_calls: [toolCall] });
+      }
+      return null;
+    }
+    case "response.function_call_arguments.delta": {
+      const toolCall = { index: 0, function: { arguments: String(event["delta"] ?? "") } };
+      return chunk(responseId, { tool_calls: [toolCall] });
+    }
+    case "response.output_text.done":
+    case "response.reasoning_summary_text.done":
+    case "response.reasoning_text.done":
+    case "response.function_call_arguments.done":
+    case "response.output_item.done":
+    case "response.content_part.added":
+    case "response.content_part.done":
+      return null;
+    case "response.completed": {
+      const response = event["response"];
+      return finalChunk(responseId, response);
+    }
+    case "response.failed": {
+      const response = event["response"];
+      const message = response?.error?.message ?? "Responses API request failed";
+      logger.warn("Responses API stream failed", { message });
+      return finalChunk(responseId, response);
+    }
+    case "error": {
+      const message = event["message"] ?? "Responses API stream error";
+      logger.warn("Responses API stream error event", { message });
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+function chunk(id, delta) {
+  return { id, choices: [{ delta, finish_reason: null }] };
+}
+function finalChunk(id, response) {
+  const usage = response?.usage;
+  const c = {
+    id,
+    choices: [
+      {
+        delta: {},
+        finish_reason: mapResponseStatus(response?.status, response?.incomplete_details?.reason)
+      }
+    ]
+  };
+  if (usage) {
+    c.usage = {
+      prompt_tokens: usage.input_tokens ?? 0,
+      completion_tokens: usage.output_tokens ?? 0,
+      total_tokens: usage.total_tokens ?? (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0)
+    };
+  }
+  return c;
+}
+var OpenAIResponsesHttpClient = class extends ChatHttpClient {
+  baseURL;
+  apiKey;
+  constructor(options) {
+    super();
+    this.baseURL = options.baseURL;
+    this.apiKey = options.apiKey;
+  }
+  buildRequest(params) {
+    return {
+      url: `${this.baseURL}/responses`,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(buildResponsesRequest(params))
+    };
+  }
+  parseNonStreaming(data) {
+    return parseResponsesResponse(data);
+  }
+  parseStreamLine(trimmed) {
+    if (!trimmed.startsWith("data: ")) return null;
+    const data = trimmed.slice(6);
+    if (data === "[DONE]") return DONE;
+    try {
+      return parseResponsesEvent(JSON.parse(data));
+    } catch (error) {
+      logger.warn("Failed to parse Responses SSE event", { data, error });
+      return null;
+    }
+  }
+};
+
 // src/server/llm/ollama-native.ts
 function mapDoneReason(reason) {
   switch (reason) {
@@ -233,7 +484,15 @@ function createLLMClient(config, initialBackend = config.llm.backend ?? "unknown
   const ollamaHttpClient = new OllamaHttpClient({
     baseURL: stripVersionPrefix(baseURL)
   });
-  const httpFor = (b) => b === "ollama" ? ollamaHttpClient : httpClient;
+  const responsesHttpClient = new OpenAIResponsesHttpClient({
+    baseURL,
+    apiKey: config.llm.apiKey ?? "not-needed"
+  });
+  const httpFor = (b) => {
+    if (b === "ollama") return ollamaHttpClient;
+    if (currentApiProtocol() === "responses") return responsesHttpClient;
+    return httpClient;
+  };
   let model = config.llm.model;
   let profile = getModelProfile(model);
   let backend = initialBackend;
@@ -242,17 +501,20 @@ function createLLMClient(config, initialBackend = config.llm.backend ?? "unknown
   const thinkingField = config.llm.thinkingField;
   const sendReasoningInMessages = config.llm.sendReasoningInMessages;
   const idleTimeout = config.llm.idleTimeout ?? 12e4;
+  const currentApiProtocol = () => resolveApiProtocol({ model, backend, profileApiProtocol: profile.apiProtocol });
   function buildExtraParams(resolvedEffort) {
     return {
       ...resolvedEffort ? { reasoningEffort: resolvedEffort } : {},
       ...thinkingField ? { thinkingField } : {},
-      ...sendReasoningInMessages !== void 0 ? { sendReasoningInMessages } : {}
+      ...sendReasoningInMessages !== void 0 ? { sendReasoningInMessages } : {},
+      apiProtocol: currentApiProtocol()
     };
   }
   return {
     getModel() {
       return model;
     },
+    usesResponsesApi: () => currentApiProtocol() === "responses",
     getProfile() {
       return profile;
     },
@@ -381,25 +643,25 @@ function createLLMClient(config, initialBackend = config.llm.backend ?? "unknown
         const onAbort = () => clearInterval(idleTimer);
         request.signal?.addEventListener("abort", onAbort, { once: true });
         try {
-          for await (const chunk of stream) {
+          for await (const chunk2 of stream) {
             if (idleTimeoutController.signal.aborted) {
               throw new Error(`LLM stream idle timeout: no chunks received for ${idleTimeout}ms`);
             }
             lastChunkTime = Date.now();
-            if (!Array.isArray(chunk?.choices)) {
-              const streamError = chunk?.error;
+            if (!Array.isArray(chunk2?.choices)) {
+              const streamError = chunk2?.error;
               const errorMessage = typeof streamError === "string" ? streamError : streamError && typeof streamError === "object" && "message" in streamError && typeof streamError.message === "string" ? streamError.message : "Invalid LLM stream chunk: missing choices";
               throw new LLMError(errorMessage);
             }
-            responseId = chunk.id;
-            if (chunk.usage) {
+            responseId = chunk2.id;
+            if (chunk2.usage) {
               usage = {
-                promptTokens: chunk.usage.prompt_tokens ?? usage.promptTokens,
-                completionTokens: chunk.usage.completion_tokens ?? usage.completionTokens,
-                totalTokens: chunk.usage.total_tokens ?? usage.totalTokens
+                promptTokens: chunk2.usage.prompt_tokens ?? usage.promptTokens,
+                completionTokens: chunk2.usage.completion_tokens ?? usage.completionTokens,
+                totalTokens: chunk2.usage.total_tokens ?? usage.totalTokens
               };
             }
-            const choice = chunk.choices[0];
+            const choice = chunk2.choices[0];
             if (!choice) continue;
             if (choice.finish_reason) {
               finishReason = mapFinishReason(choice.finish_reason);
@@ -506,4 +768,4 @@ function createLLMClient(config, initialBackend = config.llm.backend ?? "unknown
 export {
   createLLMClient
 };
-//# sourceMappingURL=chunk-D5QVV3LT.js.map
+//# sourceMappingURL=chunk-DHDIKVRT.js.map