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

package/dist/index.mjs

@@ -297,6 +297,20 @@ async function streamText(params) {
               fullText += chunk.text;
               yield { type: "text-delta", text: chunk.text };
               break;
+            case "tool-call-start":
+              yield {
+                type: "tool-call-start",
+                toolCallId: chunk.toolCallId,
+                toolName: chunk.toolName
+              };
+              break;
+            case "tool-call-delta":
+              yield {
+                type: "tool-call-delta",
+                toolCallId: chunk.toolCallId,
+                argsText: chunk.argsText
+              };
+              break;
             case "tool-call":
               toolCalls.push(chunk.toolCall);
               yield {
@@ -1595,7 +1609,7 @@ var Runtime = class {
     const completionRequest = {
       messages,
       actions: allActions.length > 0 ? allActions : void 0,
-      systemPrompt: request.systemPrompt || this.config.systemPrompt,
+      systemPrompt: this.config.systemPrompt ?? request.systemPrompt,
       config: request.config,
       signal,
       webSearch: this.getWebSearchConfig(),
@@ -2159,7 +2173,7 @@ var Runtime = class {
         }
       }
     }
-    const systemPrompt = request.systemPrompt || this.config.systemPrompt || "";
+    const systemPrompt = this.config.systemPrompt ?? request.systemPrompt ?? "";
     let accumulatedText = "";
     const toolCalls = [];
     let currentToolCall = null;
@@ -2206,38 +2220,44 @@ var Runtime = class {
           break;
         case "action:args":
           if (currentToolCall) {
+            currentToolCall.args = event.args || currentToolCall.args;
             try {
-              const parsedArgs = JSON.parse(event.args || "{}");
+              const parsedArgs = JSON.parse(currentToolCall.args || "{}");
+              const existingIdx = toolCalls.findIndex(
+                (t) => t.id === currentToolCall.id
+              );
+              const entry = {
+                id: currentToolCall.id,
+                name: currentToolCall.name,
+                args: parsedArgs,
+                ...currentToolCall.extra_content ? { extra_content: currentToolCall.extra_content } : {}
+              };
+              if (existingIdx >= 0) {
+                toolCalls[existingIdx] = entry;
+              } else {
+                toolCalls.push(entry);
+              }
               if (debug) {
                 console.log(
                   `[Copilot SDK] Tool args for ${currentToolCall.name}:`,
                   parsedArgs
                 );
               }
-              toolCalls.push({
-                id: currentToolCall.id,
-                name: currentToolCall.name,
-                args: parsedArgs,
-                ...currentToolCall.extra_content ? { extra_content: currentToolCall.extra_content } : {}
-              });
-            } catch (e) {
-              console.error(
-                "[Copilot SDK] Failed to parse tool args:",
-                event.args,
-                e
-              );
-              toolCalls.push({
-                id: currentToolCall.id,
-                name: currentToolCall.name,
-                args: {},
-                ...currentToolCall.extra_content ? { extra_content: currentToolCall.extra_content } : {}
-              });
+            } catch {
+              if (!toolCalls.find((t) => t.id === currentToolCall.id)) {
+                toolCalls.push({
+                  id: currentToolCall.id,
+                  name: currentToolCall.name,
+                  args: {},
+                  ...currentToolCall.extra_content ? { extra_content: currentToolCall.extra_content } : {}
+                });
+              }
             }
-            currentToolCall = null;
           }
           yield event;
           break;
         case "action:end": {
+          currentToolCall = null;
           const toolName = event.name;
           const tool2 = toolName ? selectedToolMap.get(toolName) : void 0;
           if (tool2?.location === "server" && tool2.handler) {
@@ -2447,7 +2467,7 @@ var Runtime = class {
     const allTools = this.collectToolsForRequest(request);
     const nativeToolSearch = this.resolveNativeToolSearchForRequest(request);
     let toolSearchState = _toolSearchState;
-    const systemPrompt = request.systemPrompt || this.config.systemPrompt || "";
+    const systemPrompt = this.config.systemPrompt ?? request.systemPrompt ?? "";
     let iteration = 0;
     let conversationMessages = request.messages;
     while (iteration < maxIterations) {

package/dist/providers/anthropic/index.d.mts

@@ -1,7 +1,7 @@
-import { L as LanguageModel } from '../../types-CR8mi9I0.mjs';
-import { a as AnthropicProviderConfig, A as AIProvider } from '../../types-DRqxMIjF.mjs';
+import { L as LanguageModel } from '../../types-CMvvDo-E.mjs';
+import { a as AnthropicProviderConfig, A as AIProvider } from '../../types-CMMQ8s2O.mjs';
 import 'zod';
-import '../../base-D-U61JaB.mjs';
+import '../../base-DN1EfKnE.mjs';
 
 /**
  * Anthropic Provider - Modern Pattern

package/dist/providers/anthropic/index.d.ts

@@ -1,7 +1,7 @@
-import { L as LanguageModel } from '../../types-CR8mi9I0.js';
-import { a as AnthropicProviderConfig, A as AIProvider } from '../../types-BctsnC3g.js';
+import { L as LanguageModel } from '../../types-CMvvDo-E.js';
+import { a as AnthropicProviderConfig, A as AIProvider } from '../../types-DhktekQ3.js';
 import 'zod';
-import '../../base-iGi9Va6Z.js';
+import '../../base-DuUNxtVg.js';
 
 /**
  * Anthropic Provider - Modern Pattern

package/dist/providers/anthropic/index.js

@@ -197,6 +197,11 @@ function anthropic(modelId, options = {}) {
                 name: event.content_block.name,
                 input: ""
               };
+              yield {
+                type: "tool-call-start",
+                toolCallId: event.content_block.id,
+                toolName: event.content_block.name
+              };
             }
             break;
           case "content_block_delta":
@@ -204,6 +209,11 @@ function anthropic(modelId, options = {}) {
               yield { type: "text-delta", text: event.delta.text };
             } else if (event.delta?.type === "input_json_delta" && currentToolUse) {
               currentToolUse.input += event.delta.partial_json;
+              yield {
+                type: "tool-call-delta",
+                toolCallId: currentToolUse.id,
+                argsText: currentToolUse.input
+              };
             }
             break;
           case "content_block_stop":
@@ -1007,6 +1017,13 @@ var AnthropicAdapter = class {
               yield { type: "thinking:delta", content: event.delta.thinking };
             } else if (event.delta.type === "input_json_delta" && currentToolUse) {
               currentToolUse.input += event.delta.partial_json;
+              if (currentToolUse.name !== "web_search") {
+                yield {
+                  type: "action:args",
+                  id: currentToolUse.id,
+                  args: currentToolUse.input
+                };
+              }
             }
             break;
           case "content_block_stop":

package/dist/providers/anthropic/index.mjs

@@ -195,6 +195,11 @@ function anthropic(modelId, options = {}) {
                 name: event.content_block.name,
                 input: ""
               };
+              yield {
+                type: "tool-call-start",
+                toolCallId: event.content_block.id,
+                toolName: event.content_block.name
+              };
             }
             break;
           case "content_block_delta":
@@ -202,6 +207,11 @@ function anthropic(modelId, options = {}) {
               yield { type: "text-delta", text: event.delta.text };
             } else if (event.delta?.type === "input_json_delta" && currentToolUse) {
               currentToolUse.input += event.delta.partial_json;
+              yield {
+                type: "tool-call-delta",
+                toolCallId: currentToolUse.id,
+                argsText: currentToolUse.input
+              };
             }
             break;
           case "content_block_stop":
@@ -1005,6 +1015,13 @@ var AnthropicAdapter = class {
               yield { type: "thinking:delta", content: event.delta.thinking };
             } else if (event.delta.type === "input_json_delta" && currentToolUse) {
               currentToolUse.input += event.delta.partial_json;
+              if (currentToolUse.name !== "web_search") {
+                yield {
+                  type: "action:args",
+                  id: currentToolUse.id,
+                  args: currentToolUse.input
+                };
+              }
             }
             break;
           case "content_block_stop":

package/dist/providers/azure/index.d.mts

@@ -1,6 +1,6 @@
-import { b as AzureProviderConfig, A as AIProvider } from '../../types-DRqxMIjF.mjs';
-import '../../base-D-U61JaB.mjs';
-import '../../types-CR8mi9I0.mjs';
+import { b as AzureProviderConfig, A as AIProvider } from '../../types-CMMQ8s2O.mjs';
+import '../../base-DN1EfKnE.mjs';
+import '../../types-CMvvDo-E.mjs';
 import 'zod';
 
 /**

package/dist/providers/azure/index.d.ts

@@ -1,6 +1,6 @@
-import { b as AzureProviderConfig, A as AIProvider } from '../../types-BctsnC3g.js';
-import '../../base-iGi9Va6Z.js';
-import '../../types-CR8mi9I0.js';
+import { b as AzureProviderConfig, A as AIProvider } from '../../types-DhktekQ3.js';
+import '../../base-DuUNxtVg.js';
+import '../../types-CMvvDo-E.js';
 import 'zod';
 
 /**

package/dist/providers/fireworks/index.d.mts

@@ -1,4 +1,4 @@
-import { L as LanguageModel } from '../../types-CR8mi9I0.mjs';
+import { L as LanguageModel } from '../../types-CMvvDo-E.mjs';
 import 'zod';
 
 /**

package/dist/providers/fireworks/index.d.ts

@@ -1,4 +1,4 @@
-import { L as LanguageModel } from '../../types-CR8mi9I0.js';
+import { L as LanguageModel } from '../../types-CMvvDo-E.js';
 import 'zod';
 
 /**

package/dist/providers/google/index.d.mts

@@ -1,7 +1,7 @@
-import { L as LanguageModel } from '../../types-CR8mi9I0.mjs';
-import { G as GoogleProviderConfig, A as AIProvider } from '../../types-DRqxMIjF.mjs';
+import { L as LanguageModel } from '../../types-CMvvDo-E.mjs';
+import { G as GoogleProviderConfig, A as AIProvider } from '../../types-CMMQ8s2O.mjs';
 import 'zod';
-import '../../base-D-U61JaB.mjs';
+import '../../base-DN1EfKnE.mjs';
 
 /**
  * Google Provider - OpenAI-Compatible

package/dist/providers/google/index.d.ts

@@ -1,7 +1,7 @@
-import { L as LanguageModel } from '../../types-CR8mi9I0.js';
-import { G as GoogleProviderConfig, A as AIProvider } from '../../types-BctsnC3g.js';
+import { L as LanguageModel } from '../../types-CMvvDo-E.js';
+import { G as GoogleProviderConfig, A as AIProvider } from '../../types-DhktekQ3.js';
 import 'zod';
-import '../../base-iGi9Va6Z.js';
+import '../../base-DuUNxtVg.js';
 
 /**
  * Google Provider - OpenAI-Compatible

package/dist/providers/google/index.js

@@ -506,6 +506,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() {
@@ -605,6 +606,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;
@@ -738,16 +989,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);
@@ -755,6 +1027,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) {
@@ -765,6 +1038,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) {
@@ -812,6 +1101,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
+              };
             }
           }
         }
@@ -887,15 +1181,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);