@yourgpt/llm-sdk 2.1.9 → 2.1.10-alpha.0

package/dist/providers/xai/index.js

@@ -455,6 +455,7 @@ var OpenAIAdapter = class _OpenAIAdapter {
     if (baseUrl.includes("generativelanguage.googleapis.com")) return "google";
     if (baseUrl.includes("x.ai")) return "xai";
     if (baseUrl.includes("azure")) return "azure";
+    if (baseUrl.includes("openrouter.ai")) return "openrouter";
     return "openai";
   }
   async getClient() {
@@ -554,6 +555,256 @@ var OpenAIAdapter = class _OpenAIAdapter {
       rawResponse: response
     };
   }
+  /**
+   * OpenAI reasoning models on OpenRouter (o1/o3/o4/gpt-5 family) hide their
+   * reasoning content on the chat-completions endpoint. To surface reasoning
+   * SUMMARIES (not raw CoT, which OpenAI never exposes) we have to use the
+   * Responses API, which streams `response.reasoning_summary_text.delta` events.
+   *
+   * Match by prefix on the OpenRouter model id. Excludes openai/gpt-4o,
+   * openai/gpt-4.1, openai/chatgpt-* — those continue on chat-completions.
+   */
+  isOpenAIReasoningModelOnOpenRouter(activeModel) {
+    if (this.provider !== "openrouter") return false;
+    return activeModel.startsWith("openai/o1") || activeModel.startsWith("openai/o3") || activeModel.startsWith("openai/o4") || activeModel.startsWith("openai/gpt-5");
+  }
+  /**
+   * Convert ActionDefinition[] (the chat-completions tool shape used by the
+   * adapter) to the Responses API tool shape.
+   */
+  buildResponsesToolsFromActions(actions) {
+    if (!actions || actions.length === 0) return void 0;
+    const formatted = formatTools(actions);
+    return formatted.map((t) => ({
+      type: "function",
+      name: t.function.name,
+      description: t.function.description,
+      parameters: t.function.parameters
+    }));
+  }
+  /**
+   * Streaming Responses API path for OpenAI reasoning models on OpenRouter.
+   *
+   * Maps Responses API SSE events back to the same StreamEvent shapes the
+   * chat-completions path emits, so downstream consumers (processChunk.ts,
+   * frontend tool handlers, plan approval, specialist delegations) see
+   * identical events regardless of which path produced them.
+   *
+   *   response.reasoning_summary_text.delta  → thinking:start (once) + thinking:delta
+   *   response.output_text.delta             → message:delta
+   *   response.output_item.added (function_call) → action:start (queued buffer)
+   *   response.function_call_arguments.delta → action:args (progressive)
+   *   response.output_item.done (function_call) → final action:args + action:end
+   *   response.completed                     → message:end + done(usage)
+   *   response.error                         → error
+   */
+  async *streamWithResponsesAPI(request, activeModel, messageId) {
+    const client = await this.getClient();
+    const maxTokensValue = request.config?.maxTokens ?? this.config.maxTokens;
+    const payload = {
+      model: activeModel,
+      input: this.buildResponsesInput(request),
+      stream: true,
+      reasoning: {
+        effort: request.config?.reasoningEffort ?? "medium",
+        summary: "auto"
+      }
+    };
+    if (request.systemPrompt) payload.instructions = request.systemPrompt;
+    if (typeof maxTokensValue === "number")
+      payload.max_output_tokens = maxTokensValue;
+    const tools = this.buildResponsesToolsFromActions(request.actions);
+    if (tools && tools.length > 0) payload.tools = tools;
+    logProviderPayload(
+      "openai",
+      "responses-api request payload",
+      payload,
+      request.debug
+    );
+    let stream;
+    try {
+      stream = await client.responses.create(payload);
+    } catch (error) {
+      yield {
+        type: "error",
+        message: error instanceof Error ? error.message : "Unknown error",
+        code: "OPENAI_RESPONSES_ERROR"
+      };
+      return;
+    }
+    const toolBuffers = /* @__PURE__ */ new Map();
+    const itemIdToCallId = /* @__PURE__ */ new Map();
+    let usage;
+    let reasoningStarted = false;
+    let textStarted = false;
+    let finishEmitted = false;
+    const resolveCallId = (evt) => {
+      if (evt?.call_id) return evt.call_id;
+      if (evt?.item_id) return itemIdToCallId.get(evt.item_id) ?? evt.item_id;
+      if (evt?.item?.call_id) return evt.item.call_id;
+      if (evt?.item?.id) return evt.item.id;
+      return "";
+    };
+    try {
+      for await (const evt of stream) {
+        logProviderPayload(
+          "openai",
+          "responses-api stream chunk",
+          evt,
+          request.debug
+        );
+        if (request.signal?.aborted) break;
+        const t = evt?.type ?? "";
+        if (t === "response.reasoning_summary_text.delta") {
+          const delta = evt.delta ?? "";
+          if (!delta) continue;
+          if (!reasoningStarted) {
+            yield { type: "thinking:start" };
+            reasoningStarted = true;
+          }
+          yield { type: "thinking:delta", content: delta };
+          continue;
+        }
+        if (t === "response.reasoning_summary_text.done" || t === "response.reasoning.done") {
+          continue;
+        }
+        if (t === "response.output_text.delta") {
+          const text = evt.delta ?? "";
+          if (!text) continue;
+          if (reasoningStarted && !textStarted) {
+            yield { type: "thinking:end" };
+            textStarted = true;
+          }
+          yield { type: "message:delta", content: text };
+          continue;
+        }
+        if (t === "response.output_item.added") {
+          const item = evt.item;
+          if (item?.type === "function_call") {
+            const callId = item.call_id ?? item.id ?? "";
+            const itemId = item.id ?? callId;
+            if (callId) {
+              if (itemId && itemId !== callId) {
+                itemIdToCallId.set(itemId, callId);
+              }
+              if (!toolBuffers.has(callId)) {
+                toolBuffers.set(callId, {
+                  id: callId,
+                  name: item.name ?? "",
+                  arguments: item.arguments ?? "",
+                  emittedStart: false
+                });
+              }
+              const buf = toolBuffers.get(callId);
+              if (buf.name && !buf.emittedStart) {
+                yield { type: "action:start", id: buf.id, name: buf.name };
+                buf.emittedStart = true;
+              }
+            }
+          }
+          continue;
+        }
+        if (t === "response.function_call_arguments.delta") {
+          const callId = resolveCallId(evt);
+          const delta = evt.delta ?? "";
+          if (!callId || !delta) continue;
+          let buf = toolBuffers.get(callId);
+          if (!buf) {
+            buf = { id: callId, name: "", arguments: "", emittedStart: false };
+            toolBuffers.set(callId, buf);
+          }
+          buf.arguments += delta;
+          if (buf.emittedStart) {
+            yield {
+              type: "action:args",
+              id: buf.id,
+              args: buf.arguments
+            };
+          }
+          continue;
+        }
+        if (t === "response.output_item.done") {
+          const item = evt.item;
+          if (item?.type === "function_call") {
+            const callId = item.call_id ?? item.id ?? "";
+            const buf = toolBuffers.get(callId);
+            const name = buf?.name || item.name || "";
+            const argsStr = buf?.arguments || item.arguments || "{}";
+            if (callId && name) {
+              if (!buf?.emittedStart) {
+                yield { type: "action:start", id: callId, name };
+              }
+              yield {
+                type: "action:args",
+                id: callId,
+                args: argsStr
+              };
+              yield {
+                type: "action:end",
+                id: callId,
+                name
+              };
+            }
+            toolBuffers.delete(callId);
+          }
+          continue;
+        }
+        if (t === "response.completed") {
+          const u = evt.response?.usage;
+          if (u) {
+            usage = {
+              prompt_tokens: u.input_tokens ?? 0,
+              completion_tokens: u.output_tokens ?? 0,
+              total_tokens: u.total_tokens ?? (u.input_tokens ?? 0) + (u.output_tokens ?? 0)
+            };
+          }
+          for (const buf of toolBuffers.values()) {
+            if (!buf.id || !buf.name) continue;
+            if (!buf.emittedStart) {
+              yield { type: "action:start", id: buf.id, name: buf.name };
+            }
+            yield {
+              type: "action:args",
+              id: buf.id,
+              args: buf.arguments || "{}"
+            };
+            yield { type: "action:end", id: buf.id, name: buf.name };
+          }
+          toolBuffers.clear();
+          if (reasoningStarted && !textStarted) {
+            yield { type: "thinking:end" };
+          }
+          yield { type: "message:end" };
+          yield { type: "done", usage };
+          finishEmitted = true;
+          continue;
+        }
+        if (t === "response.error" || t === "error") {
+          const msg = evt.error?.message || evt.message || "Responses API error";
+          yield {
+            type: "error",
+            message: msg,
+            code: "OPENAI_RESPONSES_ERROR"
+          };
+          return;
+        }
+      }
+    } catch (error) {
+      yield {
+        type: "error",
+        message: error instanceof Error ? error.message : "Unknown error",
+        code: "OPENAI_RESPONSES_ERROR"
+      };
+      return;
+    }
+    if (!finishEmitted) {
+      if (reasoningStarted && !textStarted) {
+        yield { type: "thinking:end" };
+      }
+      yield { type: "message:end" };
+      yield { type: "done", usage };
+    }
+  }
   async completeWithResponses(request) {
     const client = await this.getClient();
     const openaiToolOptions = request.providerToolOptions?.openai;
@@ -687,16 +938,37 @@ var OpenAIAdapter = class _OpenAIAdapter {
           name: openaiToolOptions.toolChoice.name
         }
       } : openaiToolOptions?.toolChoice;
+      const isOpenRouter = this.provider === "openrouter";
+      const activeModel = request.config?.model || this.model;
+      const modelSlug = activeModel.replace("openai/", "");
+      const isOSeries = /^o[1-9]/.test(modelSlug);
+      const isOpenAIOnOpenRouter = isOpenRouter && activeModel.startsWith("openai/");
+      if (!this.config.disableThinking && this.isOpenAIReasoningModelOnOpenRouter(activeModel)) {
+        yield* this.streamWithResponsesAPI(request, activeModel, messageId);
+        return;
+      }
+      const maxTokensValue = request.config?.maxTokens ?? this.config.maxTokens;
       const payload = {
-        model: request.config?.model || this.model,
+        model: activeModel,
         messages,
         tools: tools.length > 0 ? tools : void 0,
         tool_choice: tools.length > 0 ? toolChoice : void 0,
         parallel_tool_calls: tools.length > 0 ? openaiToolOptions?.parallelToolCalls : void 0,
-        temperature: request.config?.temperature ?? this.config.temperature,
-        max_tokens: request.config?.maxTokens ?? this.config.maxTokens,
         stream: true,
-        stream_options: { include_usage: true }
+        stream_options: { include_usage: true },
+        // o-series: use max_completion_tokens + reasoning_effort, no temperature
+        // regular models: use max_tokens + temperature
+        ...isOSeries ? {
+          max_completion_tokens: maxTokensValue,
+          reasoning_effort: request.config?.reasoningEffort ?? "medium"
+        } : {
+          temperature: request.config?.temperature ?? this.config.temperature,
+          max_tokens: maxTokensValue
+        },
+        // Non-OpenAI OpenRouter models support OR's reasoning/include_reasoning params.
+        // When disableThinking=true we must explicitly send include_reasoning:false because
+        // models like Qwen3 and DeepSeek-R1 reason by default even without the reasoning param.
+        ...isOpenRouter && !isOpenAIOnOpenRouter ? this.config.disableThinking ? { include_reasoning: false } : { reasoning: { max_tokens: 8e3 }, include_reasoning: true } : {}
       };
       logProviderPayload("openai", "request payload", payload, request.debug);
       const stream = await client.chat.completions.create(payload);
@@ -704,6 +976,7 @@ var OpenAIAdapter = class _OpenAIAdapter {
       const collectedCitations = [];
       let citationIndex = 0;
       let usage;
+      let adapterReasoningStarted = false;
       for await (const chunk of stream) {
         logProviderPayload("openai", "stream chunk", chunk, request.debug);
         if (request.signal?.aborted) {
@@ -714,6 +987,22 @@ var OpenAIAdapter = class _OpenAIAdapter {
         if (delta?.content) {
           yield { type: "message:delta", content: delta.content };
         }
+        if (isOpenRouter) {
+          const rc = delta?.reasoning_content ?? delta?.reasoning ?? null;
+          if (rc) {
+            const rcText = typeof rc === "string" ? rc : Array.isArray(rc) && rc[0]?.text ? rc[0].text : "";
+            if (rcText) {
+              if (!adapterReasoningStarted) {
+                yield { type: "thinking:start" };
+                adapterReasoningStarted = true;
+              }
+              yield { type: "thinking:delta", content: rcText };
+            }
+          } else if (adapterReasoningStarted && (delta?.content || choice?.finish_reason)) {
+            yield { type: "thinking:end" };
+            adapterReasoningStarted = false;
+          }
+        }
         const annotations = delta?.annotations;
         if (annotations && annotations.length > 0) {
           for (const annotation of annotations) {
@@ -761,6 +1050,11 @@ var OpenAIAdapter = class _OpenAIAdapter {
               };
             } else if (currentToolCall && toolCall.function?.arguments) {
               currentToolCall.arguments += toolCall.function.arguments;
+              yield {
+                type: "action:args",
+                id: currentToolCall.id,
+                args: currentToolCall.arguments
+              };
             }
           }
         }
@@ -836,15 +1130,24 @@ var OpenAIAdapter = class _OpenAIAdapter {
         name: openaiToolOptions.toolChoice.name
       }
     } : openaiToolOptions?.toolChoice;
+    const activeModel2 = request.config?.model || this.model;
+    const modelSlug2 = activeModel2.replace("openai/", "");
+    const isOSeries2 = /^o[1-9]/.test(modelSlug2);
+    const maxTokensValue2 = request.config?.maxTokens ?? this.config.maxTokens;
     const payload = {
-      model: request.config?.model || this.model,
+      model: activeModel2,
       messages,
       tools: tools.length > 0 ? tools : void 0,
       tool_choice: tools.length > 0 ? toolChoice : void 0,
       parallel_tool_calls: tools.length > 0 ? openaiToolOptions?.parallelToolCalls : void 0,
-      temperature: request.config?.temperature ?? this.config.temperature,
-      max_tokens: request.config?.maxTokens ?? this.config.maxTokens,
-      stream: false
+      stream: false,
+      ...isOSeries2 ? {
+        max_completion_tokens: maxTokensValue2,
+        reasoning_effort: request.config?.reasoningEffort ?? "medium"
+      } : {
+        temperature: request.config?.temperature ?? this.config.temperature,
+        max_tokens: maxTokensValue2
+      }
     };
     logProviderPayload("openai", "request payload", payload, request.debug);
     const response = await client.chat.completions.create(payload);