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

package/dist/providers/openrouter/index.mjs

@@ -5,6 +5,9 @@ var DEFAULT_MODEL_CONFIG = {
   jsonMode: true,
   maxTokens: 128e3
 };
+function isOpenAIReasoningModel(modelId) {
+  return modelId.startsWith("openai/o1") || modelId.startsWith("openai/o3") || modelId.startsWith("openai/o4") || modelId.startsWith("openai/gpt-5");
+}
 function openrouter(modelId, options = {}) {
   const apiKey = options.apiKey ?? process.env.OPENROUTER_API_KEY;
   const baseURL = options.baseURL ?? "https://openrouter.ai/api/v1";
@@ -36,7 +39,7 @@ function openrouter(modelId, options = {}) {
       supportsTools: modelConfig.tools,
       supportsStreaming: true,
       supportsJsonMode: modelConfig.jsonMode,
-      supportsThinking: false,
+      supportsThinking: true,
       supportsPDF: false,
       maxTokens: modelConfig.maxTokens,
       supportedImageTypes: modelConfig.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : []
@@ -79,6 +82,11 @@ function openrouter(modelId, options = {}) {
       };
     },
     async *doStream(params) {
+      if (!options.disableThinking && isOpenAIReasoningModel(modelId)) {
+        const client3 = await getClient();
+        yield* doStreamResponsesAPI(client3, modelId, params);
+        return;
+      }
       const client2 = await getClient();
       const messages = formatMessagesForOpenRouter(params.messages);
       const requestBody = {
@@ -86,7 +94,8 @@ function openrouter(modelId, options = {}) {
         messages,
         temperature: params.temperature,
         max_tokens: params.maxTokens,
-        stream: true
+        stream: true,
+        ...!options.disableThinking ? { reasoning: { max_tokens: 8e3 }, include_reasoning: true } : {}
       };
       if (params.tools) {
         requestBody.tools = params.tools;
@@ -98,6 +107,7 @@ function openrouter(modelId, options = {}) {
       let currentToolCall = null;
       let totalPromptTokens = 0;
       let totalCompletionTokens = 0;
+      let orReasoningStarted = false;
       for await (const chunk of stream) {
         if (params.signal?.aborted) {
           yield { type: "error", error: new Error("Aborted") };
@@ -108,6 +118,20 @@ function openrouter(modelId, options = {}) {
         if (delta?.content) {
           yield { type: "text-delta", text: delta.content };
         }
+        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 (!orReasoningStarted) {
+              yield { type: "thinking:start" };
+              orReasoningStarted = true;
+            }
+            yield { type: "thinking:delta", content: rcText };
+          }
+        } else if (orReasoningStarted && (delta?.content || choice?.finish_reason)) {
+          yield { type: "thinking:end" };
+          orReasoningStarted = false;
+        }
         if (delta?.tool_calls) {
           for (const tc of delta.tool_calls) {
             if (tc.id) {
@@ -226,6 +250,268 @@ function formatMessagesForOpenRouter(messages) {
     }
   });
 }
+function formatMessagesForResponsesAPI(messages) {
+  const out = [];
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      out.push({
+        type: "message",
+        role: "system",
+        content: [
+          {
+            type: "input_text",
+            text: typeof msg.content === "string" ? msg.content : ""
+          }
+        ]
+      });
+      continue;
+    }
+    if (msg.role === "user") {
+      const parts = [];
+      if (typeof msg.content === "string") {
+        parts.push({ type: "input_text", text: msg.content });
+      } else {
+        for (const part of msg.content) {
+          if (part.type === "text") {
+            parts.push({ type: "input_text", text: part.text });
+          } else if (part.type === "image") {
+            const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
+            const url = imageData.startsWith("data:") ? imageData : `data:${part.mimeType ?? "image/png"};base64,${imageData}`;
+            parts.push({ type: "input_image", image_url: url });
+          }
+        }
+      }
+      out.push({ type: "message", role: "user", content: parts });
+      continue;
+    }
+    if (msg.role === "assistant") {
+      if (msg.toolCalls && msg.toolCalls.length > 0) {
+        for (const tc of msg.toolCalls) {
+          out.push({
+            type: "function_call",
+            call_id: tc.id,
+            name: tc.name,
+            arguments: JSON.stringify(tc.args ?? {})
+          });
+        }
+        if (typeof msg.content === "string" && msg.content.length > 0) {
+          out.push({
+            type: "message",
+            role: "assistant",
+            content: [{ type: "output_text", text: msg.content }]
+          });
+        }
+      } else {
+        const text = typeof msg.content === "string" ? msg.content : "";
+        out.push({
+          type: "message",
+          role: "assistant",
+          content: [{ type: "output_text", text }]
+        });
+      }
+      continue;
+    }
+    if (msg.role === "tool") {
+      out.push({
+        type: "function_call_output",
+        call_id: msg.toolCallId,
+        output: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+      });
+      continue;
+    }
+  }
+  return out;
+}
+function formatToolsForResponsesAPI(tools) {
+  if (!tools || tools.length === 0) return void 0;
+  return tools.map((t) => {
+    if (t?.name && t?.parameters && t?.type === "function") return t;
+    const fn = t?.function ?? t;
+    return {
+      type: "function",
+      name: fn.name,
+      description: fn.description,
+      parameters: fn.parameters ?? { type: "object", properties: {} }
+    };
+  });
+}
+async function* doStreamResponsesAPI(client, modelId, params) {
+  const systemTexts = [];
+  const nonSystem = [];
+  for (const m of params.messages) {
+    if (m.role === "system" && typeof m.content === "string") {
+      systemTexts.push(m.content);
+    } else {
+      nonSystem.push(m);
+    }
+  }
+  const instructions = systemTexts.join("\n\n") || void 0;
+  const input = formatMessagesForResponsesAPI(nonSystem);
+  const requestBody = {
+    model: modelId,
+    input,
+    stream: true,
+    reasoning: { effort: "medium", summary: "auto" }
+  };
+  if (instructions) requestBody.instructions = instructions;
+  if (typeof params.maxTokens === "number")
+    requestBody.max_output_tokens = params.maxTokens;
+  if (typeof params.temperature === "number")
+    requestBody.temperature = params.temperature;
+  const tools = formatToolsForResponsesAPI(params.tools);
+  if (tools) requestBody.tools = tools;
+  let stream;
+  try {
+    stream = await client.responses.create(requestBody);
+  } catch (err) {
+    yield {
+      type: "error",
+      error: err instanceof Error ? err : new Error(String(err))
+    };
+    return;
+  }
+  const toolCalls = /* @__PURE__ */ new Map();
+  let reasoningStarted = false;
+  let textStarted = false;
+  let totalPromptTokens = 0;
+  let totalCompletionTokens = 0;
+  let finishEmitted = false;
+  for await (const evt of stream) {
+    if (params.signal?.aborted) {
+      yield { type: "error", error: new Error("Aborted") };
+      return;
+    }
+    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: "text-delta", text };
+      continue;
+    }
+    if (t === "response.output_item.added") {
+      const item = evt.item;
+      if (item?.type === "function_call") {
+        const id = item.call_id ?? item.id ?? "";
+        if (id) {
+          toolCalls.set(id, {
+            id,
+            name: item.name ?? "",
+            arguments: item.arguments ?? ""
+          });
+        }
+      }
+      continue;
+    }
+    if (t === "response.function_call_arguments.delta") {
+      const id = evt.call_id ?? evt.item_id ?? "";
+      const delta = evt.delta ?? "";
+      if (!id || !delta) continue;
+      const existing = toolCalls.get(id);
+      if (existing) {
+        existing.arguments += delta;
+      } else {
+        toolCalls.set(id, { id, name: "", arguments: delta });
+      }
+      continue;
+    }
+    if (t === "response.output_item.done") {
+      const item = evt.item;
+      if (item?.type === "function_call") {
+        const id = item.call_id ?? item.id ?? "";
+        const tc = toolCalls.get(id);
+        const name = tc?.name || item.name || "";
+        const argsStr = tc?.arguments || item.arguments || "{}";
+        let args = {};
+        try {
+          args = JSON.parse(argsStr || "{}");
+        } catch {
+          args = {};
+        }
+        if (id && name) {
+          yield {
+            type: "tool-call",
+            toolCall: { id, name, args }
+          };
+        }
+        toolCalls.delete(id);
+      }
+      continue;
+    }
+    if (t === "response.completed") {
+      const usage = evt.response?.usage;
+      if (usage) {
+        totalPromptTokens = usage.input_tokens ?? 0;
+        totalCompletionTokens = usage.output_tokens ?? 0;
+      }
+      for (const tc of toolCalls.values()) {
+        let args = {};
+        try {
+          args = JSON.parse(tc.arguments || "{}");
+        } catch {
+          args = {};
+        }
+        if (tc.id && tc.name) {
+          yield {
+            type: "tool-call",
+            toolCall: { id: tc.id, name: tc.name, args }
+          };
+        }
+      }
+      toolCalls.clear();
+      if (reasoningStarted && !textStarted) {
+        yield { type: "thinking:end" };
+      }
+      const finishReason = toolCalls.size > 0 ? "tool-calls" : "stop";
+      yield {
+        type: "finish",
+        finishReason,
+        usage: {
+          promptTokens: totalPromptTokens,
+          completionTokens: totalCompletionTokens,
+          totalTokens: totalPromptTokens + totalCompletionTokens
+        }
+      };
+      finishEmitted = true;
+      continue;
+    }
+    if (t === "response.error" || t === "error") {
+      const msg = evt.error?.message || evt.message || "Responses API error";
+      yield { type: "error", error: new Error(msg) };
+      return;
+    }
+  }
+  if (!finishEmitted) {
+    if (reasoningStarted && !textStarted) {
+      yield { type: "thinking:end" };
+    }
+    yield {
+      type: "finish",
+      finishReason: "stop",
+      usage: {
+        promptTokens: totalPromptTokens,
+        completionTokens: totalCompletionTokens,
+        totalTokens: totalPromptTokens + totalCompletionTokens
+      }
+    };
+  }
+}
 async function fetchOpenRouterModels(apiKey) {
   const headers = {
     "Content-Type": "application/json"
@@ -471,6 +757,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() {
@@ -570,6 +857,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;
@@ -703,16 +1240,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);
@@ -720,6 +1278,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) {
@@ -730,6 +1289,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) {
@@ -777,6 +1352,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
+              };
             }
           }
         }
@@ -852,15 +1432,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);
@@ -943,7 +1532,8 @@ function createOpenRouter(config = {}) {
     return createOpenAIAdapter({
       apiKey,
       model: modelId,
-      baseUrl
+      baseUrl,
+      disableThinking: config.disableThinking
     });
   };
   const getCapabilities = (modelId) => {