@providerprotocol/ai 0.0.23 → 0.0.25

package/dist/openrouter/index.d.ts

@@ -1,4 +1,4 @@
-import { g as Provider } from '../provider-DR1yins0.js';
+import { g as Provider } from '../provider-x4RocsnK.js';
 
 /**
  * OpenRouter-specific types for the Unified Provider Protocol.
@@ -9,6 +9,47 @@ import { g as Provider } from '../provider-DR1yins0.js';
  *
  * @module types
  */
+/**
+ * Reasoning configuration for OpenRouter.
+ *
+ * Controls reasoning effort and whether to include reasoning tokens in responses.
+ *
+ * @see {@link https://openrouter.ai/docs/guides/best-practices/reasoning-tokens}
+ */
+interface OpenRouterReasoningConfig {
+    /**
+     * Reasoning effort level.
+     *
+     * Controls how much compute the model spends on reasoning:
+     * - `'xhigh'`: ~95% reasoning budget
+     * - `'high'`: ~80% reasoning budget
+     * - `'medium'`: ~50% reasoning budget (default)
+     * - `'low'`: ~20% reasoning budget
+     * - `'minimal'`: ~10% reasoning budget
+     * - `'none'`: No reasoning
+     */
+    effort?: 'xhigh' | 'high' | 'medium' | 'low' | 'minimal' | 'none';
+    /**
+     * Maximum tokens for reasoning.
+     *
+     * For Anthropic: minimum 1024, maximum 128000.
+     * For Gemini: Maps to thinkingBudget.
+     */
+    max_tokens?: number;
+    /**
+     * Whether to exclude reasoning from the response.
+     *
+     * When true, the model uses reasoning internally but doesn't include
+     * reasoning tokens in the response.
+     */
+    exclude?: boolean;
+    /**
+     * Whether reasoning is enabled.
+     *
+     * Defaults to true when the reasoning parameter is present.
+     */
+    enabled?: boolean;
+}
 /**
  * Parameters for OpenRouter's Chat Completions API.
  *
@@ -98,6 +139,24 @@ interface OpenRouterCompletionsParams {
         /** If true, returns the transformed request body sent to the provider */
         echo_upstream_body?: boolean;
     };
+    /**
+     * Reasoning configuration for thinking models.
+     *
+     * Controls how much reasoning effort the model uses and whether to include
+     * reasoning tokens in the response.
+     *
+     * @see {@link https://openrouter.ai/docs/guides/best-practices/reasoning-tokens}
+     */
+    reasoning?: OpenRouterReasoningConfig;
+    /**
+     * Legacy reasoning toggle (use `reasoning` instead).
+     *
+     * - `true`: Equivalent to `reasoning: {}`
+     * - `false`: Equivalent to `reasoning: { exclude: true }`
+     *
+     * @deprecated Use `reasoning` parameter instead
+     */
+    include_reasoning?: boolean;
 }
 /**
  * Image generation configuration for OpenRouter.

package/dist/openrouter/index.js

@@ -11,10 +11,10 @@ import {
   isAssistantMessage,
   isToolResultMessage,
   isUserMessage
-} from "../chunk-MF5ETY5O.js";
+} from "../chunk-6AZVUI6H.js";
 import {
   parseSSEStream
-} from "../chunk-NWS5IKNR.js";
+} from "../chunk-TOJCZMVU.js";
 import {
   resolveApiKey
 } from "../chunk-55X3W2MN.js";
@@ -175,7 +175,8 @@ function transformMessage(message) {
   }
   if (isAssistantMessage(message)) {
     const validContent = filterValidContent(message.content);
-    const textContent = validContent.filter((c) => c.type === "text").map((c) => c.text).join("");
+    const nonReasoningContent = validContent.filter((c) => c.type !== "reasoning");
+    const textContent = nonReasoningContent.filter((c) => c.type === "text").map((c) => c.text).join("");
     const assistantMessage = {
       role: "assistant",
       content: textContent || null
@@ -190,6 +191,10 @@ function transformMessage(message) {
         }
       }));
     }
+    const openrouterMeta = message.metadata?.openrouter;
+    if (openrouterMeta?.reasoning_details && openrouterMeta.reasoning_details.length > 0) {
+      assistantMessage.reasoning_details = openrouterMeta.reasoning_details;
+    }
     return assistantMessage;
   }
   if (isToolResultMessage(message)) {
@@ -261,10 +266,20 @@ function transformResponse(data) {
   if (!choice) {
     throw new Error("No choices in OpenRouter response");
   }
-  const content = [];
+  const reasoningContent = [];
+  const textContent = [];
   let structuredData;
+  if (choice.message.reasoning_details && choice.message.reasoning_details.length > 0) {
+    for (const detail of choice.message.reasoning_details) {
+      if (detail.type === "reasoning.text" && detail.text) {
+        reasoningContent.push({ type: "reasoning", text: detail.text });
+      } else if (detail.type === "reasoning.summary" && detail.summary) {
+        reasoningContent.push({ type: "reasoning", text: detail.summary });
+      }
+    }
+  }
   if (choice.message.content) {
-    content.push({ type: "text", text: choice.message.content });
+    textContent.push({ type: "text", text: choice.message.content });
     try {
       structuredData = JSON.parse(choice.message.content);
     } catch {
@@ -274,10 +289,11 @@ function transformResponse(data) {
     for (const image of choice.message.images) {
       const imageBlock = parseGeneratedImage(image.image_url.url);
       if (imageBlock) {
-        content.push(imageBlock);
+        textContent.push(imageBlock);
       }
     }
   }
+  const content = [...reasoningContent, ...textContent];
   const toolCalls = [];
   if (choice.message.tool_calls) {
     for (const call of choice.message.tool_calls) {
@@ -303,7 +319,9 @@ function transformResponse(data) {
         openrouter: {
           model: data.model,
           finish_reason: choice.finish_reason,
-          system_fingerprint: data.system_fingerprint
+          system_fingerprint: data.system_fingerprint,
+          // Store reasoning_details for multi-turn context preservation
+          reasoning_details: choice.message.reasoning_details
         }
       }
     }
@@ -357,6 +375,8 @@ function createStreamState() {
     id: "",
     model: "",
     text: "",
+    reasoning: "",
+    reasoningDetails: [],
     toolCalls: /* @__PURE__ */ new Map(),
     images: [],
     finishReason: null,
@@ -417,6 +437,26 @@ function transformStreamEvent(chunk, state) {
         state.images.push(image.image_url.url);
       }
     }
+    if (choice.delta.reasoning_details) {
+      for (const detail of choice.delta.reasoning_details) {
+        state.reasoningDetails.push(detail);
+        if (detail.type === "reasoning.text" && detail.text) {
+          state.reasoning += detail.text;
+          events.push({
+            type: StreamEventType.ReasoningDelta,
+            index: 0,
+            delta: { text: detail.text }
+          });
+        } else if (detail.type === "reasoning.summary" && detail.summary) {
+          state.reasoning += detail.summary;
+          events.push({
+            type: StreamEventType.ReasoningDelta,
+            index: 0,
+            delta: { text: detail.summary }
+          });
+        }
+      }
+    }
     if (choice.finish_reason) {
       state.finishReason = choice.finish_reason;
       events.push({ type: StreamEventType.MessageStop, index: 0, delta: {} });
@@ -430,10 +470,14 @@ function transformStreamEvent(chunk, state) {
   return events;
 }
 function buildResponseFromState(state) {
-  const content = [];
+  const reasoningContent = [];
+  const textContent = [];
   let structuredData;
+  if (state.reasoning) {
+    reasoningContent.push({ type: "reasoning", text: state.reasoning });
+  }
   if (state.text) {
-    content.push({ type: "text", text: state.text });
+    textContent.push({ type: "text", text: state.text });
     try {
       structuredData = JSON.parse(state.text);
     } catch {
@@ -442,9 +486,10 @@ function buildResponseFromState(state) {
   for (const imageUrl of state.images) {
     const imageBlock = parseGeneratedImage(imageUrl);
     if (imageBlock) {
-      content.push(imageBlock);
+      textContent.push(imageBlock);
     }
   }
+  const content = [...reasoningContent, ...textContent];
   const toolCalls = [];
   for (const [, toolCall] of state.toolCalls) {
     let args = {};
@@ -469,7 +514,9 @@ function buildResponseFromState(state) {
       metadata: {
         openrouter: {
           model: state.model,
-          finish_reason: state.finishReason
+          finish_reason: state.finishReason,
+          // Store reasoning_details for multi-turn context preservation
+          reasoning_details: state.reasoningDetails.length > 0 ? state.reasoningDetails : void 0
         }
       }
     }
@@ -829,6 +876,18 @@ function transformMessage2(message) {
     }
     const openrouterMeta = message.metadata?.openrouter;
     const functionCallItems = openrouterMeta?.functionCallItems;
+    if (openrouterMeta?.reasoningEncryptedContent) {
+      try {
+        const reasoningData = JSON.parse(openrouterMeta.reasoningEncryptedContent);
+        items.push({
+          type: "reasoning",
+          id: reasoningData.id,
+          summary: reasoningData.summary,
+          encrypted_content: reasoningData.encrypted_content
+        });
+      } catch {
+      }
+    }
     if (functionCallItems && functionCallItems.length > 0) {
       for (const fc of functionCallItems) {
         items.push({
@@ -912,17 +971,19 @@ function transformTool2(tool) {
   };
 }
 function transformResponse2(data) {
-  const content = [];
+  const reasoningContent = [];
+  const textContent = [];
   const toolCalls = [];
   const functionCallItems = [];
   let hadRefusal = false;
   let structuredData;
+  let reasoningEncryptedContent;
   for (const item of data.output) {
     if (item.type === "message") {
       const messageItem = item;
       for (const part of messageItem.content) {
         if (part.type === "output_text") {
-          content.push({ type: "text", text: part.text });
+          textContent.push({ type: "text", text: part.text });
           if (structuredData === void 0) {
             try {
               structuredData = JSON.parse(part.text);
@@ -930,7 +991,7 @@ function transformResponse2(data) {
             }
           }
         } else if (part.type === "refusal") {
-          content.push({ type: "text", text: part.refusal });
+          textContent.push({ type: "text", text: part.refusal });
           hadRefusal = true;
         }
       }
@@ -955,14 +1016,26 @@ function transformResponse2(data) {
     } else if (item.type === "image_generation_call") {
       const imageGen = item;
       if (imageGen.result) {
-        content.push({
+        textContent.push({
           type: "image",
           mimeType: "image/png",
           source: { type: "base64", data: imageGen.result }
         });
       }
+    } else if (item.type === "reasoning") {
+      const reasoningItem = item;
+      const reasoningText = reasoningItem.summary.filter((s) => s.type === "summary_text").map((s) => s.text).join("");
+      if (reasoningText) {
+        reasoningContent.push({ type: "reasoning", text: reasoningText });
+      }
+      reasoningEncryptedContent = JSON.stringify({
+        id: reasoningItem.id,
+        summary: reasoningItem.summary,
+        encrypted_content: reasoningItem.encrypted_content
+      });
     }
   }
+  const content = [...reasoningContent, ...textContent];
   const responseId = data.id || generateId();
   const message = new AssistantMessage(
     content,
@@ -975,7 +1048,9 @@ function transformResponse2(data) {
           status: data.status,
           // Store response_id for multi-turn tool calling
           response_id: responseId,
-          functionCallItems: functionCallItems.length > 0 ? functionCallItems : void 0
+          functionCallItems: functionCallItems.length > 0 ? functionCallItems : void 0,
+          // Store encrypted reasoning content for multi-turn context (stateless mode)
+          reasoningEncryptedContent
         }
       }
     }
@@ -1010,6 +1085,7 @@ function createStreamState2() {
     id: "",
     model: "",
     textByIndex: /* @__PURE__ */ new Map(),
+    reasoningByIndex: /* @__PURE__ */ new Map(),
     toolCalls: /* @__PURE__ */ new Map(),
     images: /* @__PURE__ */ new Map(),
     status: "in_progress",
@@ -1113,6 +1189,13 @@ function transformStreamEvent2(event, state) {
         if (imageGen.result) {
           state.images.set(event.output_index, imageGen.result);
         }
+      } else if (event.item.type === "reasoning") {
+        const reasoningItem = event.item;
+        state.reasoningEncryptedContent = JSON.stringify({
+          id: reasoningItem.id,
+          summary: reasoningItem.summary,
+          encrypted_content: reasoningItem.encrypted_content
+        });
       }
       events.push({
         type: StreamEventType.ContentBlockStop,
@@ -1193,13 +1276,16 @@ function transformStreamEvent2(event, state) {
       toolCall.arguments = event.arguments;
       break;
     }
-    case "response.reasoning.delta":
+    case "response.reasoning.delta": {
+      const currentReasoning = state.reasoningByIndex.get(0) ?? "";
+      state.reasoningByIndex.set(0, currentReasoning + event.delta);
       events.push({
         type: StreamEventType.ReasoningDelta,
         index: 0,
         delta: { text: event.delta }
       });
       break;
+    }
     case "error":
       break;
     default:
@@ -1208,11 +1294,17 @@ function transformStreamEvent2(event, state) {
   return events;
 }
 function buildResponseFromState2(state) {
-  const content = [];
+  const reasoningContent = [];
+  const textContent = [];
   let structuredData;
+  for (const [, reasoning] of state.reasoningByIndex) {
+    if (reasoning) {
+      reasoningContent.push({ type: "reasoning", text: reasoning });
+    }
+  }
   for (const [, text] of state.textByIndex) {
     if (text) {
-      content.push({ type: "text", text });
+      textContent.push({ type: "text", text });
       if (structuredData === void 0) {
         try {
           structuredData = JSON.parse(text);
@@ -1223,13 +1315,14 @@ function buildResponseFromState2(state) {
   }
   for (const [, imageData] of state.images) {
     if (imageData) {
-      content.push({
+      textContent.push({
         type: "image",
         mimeType: "image/png",
         source: { type: "base64", data: imageData }
       });
     }
   }
+  const content = [...reasoningContent, ...textContent];
   const toolCalls = [];
   const functionCallItems = [];
   for (const [, toolCall] of state.toolCalls) {
@@ -1269,7 +1362,9 @@ function buildResponseFromState2(state) {
           status: state.status,
           // Store response_id for multi-turn tool calling
           response_id: responseId,
-          functionCallItems: functionCallItems.length > 0 ? functionCallItems : void 0
+          functionCallItems: functionCallItems.length > 0 ? functionCallItems : void 0,
+          // Store encrypted reasoning content for multi-turn context (stateless mode)
+          reasoningEncryptedContent: state.reasoningEncryptedContent
         }
       }
     }