@openrouter/ai-sdk-provider 0.6.0 → 0.7.0

package/dist/index.mjs

@@ -33,6 +33,32 @@ var __objRest = (source, exclude) => {
 // src/openrouter-facade.ts
 import { loadApiKey, withoutTrailingSlash } from "@ai-sdk/provider-utils";
 
+// src/schemas/reasoning-details.ts
+import { z } from "zod";
+var ReasoningDetailSummarySchema = z.object({
+  type: z.literal("reasoning.summary" /* Summary */),
+  summary: z.string()
+});
+var ReasoningDetailEncryptedSchema = z.object({
+  type: z.literal("reasoning.encrypted" /* Encrypted */),
+  data: z.string()
+});
+var ReasoningDetailTextSchema = z.object({
+  type: z.literal("reasoning.text" /* Text */),
+  text: z.string().nullish(),
+  signature: z.string().nullish()
+});
+var ReasoningDetailUnionSchema = z.union([
+  ReasoningDetailSummarySchema,
+  ReasoningDetailEncryptedSchema,
+  ReasoningDetailTextSchema
+]);
+var ReasoningDetailsWithUnknownSchema = z.union([
+  ReasoningDetailUnionSchema,
+  z.unknown().transform(() => null)
+]);
+var ReasoningDetailArraySchema = z.array(ReasoningDetailsWithUnknownSchema).transform((d) => d.filter((d2) => !!d2));
+
 // src/openrouter-chat-language-model.ts
 import {
   InvalidResponseDataError,
@@ -46,7 +72,7 @@ import {
   isParsableJson,
   postJsonToApi
 } from "@ai-sdk/provider-utils";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/convert-to-openrouter-chat-messages.ts
 import { convertUint8ArrayToBase64 } from "@ai-sdk/provider-utils";
@@ -130,6 +156,8 @@ function convertToOpenRouterChatMessages(prompt) {
       }
       case "assistant": {
         let text = "";
+        let reasoning = "";
+        const reasoningDetails = [];
         const toolCalls = [];
         for (const part of content) {
           switch (part.type) {
@@ -148,10 +176,23 @@ function convertToOpenRouterChatMessages(prompt) {
               });
               break;
             }
+            case "reasoning": {
+              reasoning += part.text;
+              reasoningDetails.push({
+                type: "reasoning.text" /* Text */,
+                text: part.text,
+                signature: part.signature
+              });
+              break;
+            }
+            case "redacted-reasoning": {
+              reasoningDetails.push({
+                type: "reasoning.encrypted" /* Encrypted */,
+                data: part.data
+              });
+              break;
+            }
             case "file":
-            // TODO: Handle reasoning and redacted-reasoning
-            case "reasoning":
-            case "redacted-reasoning":
               break;
             default: {
               const _exhaustiveCheck = part;
@@ -163,6 +204,8 @@ function convertToOpenRouterChatMessages(prompt) {
           role: "assistant",
           content: text,
           tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
+          reasoning: reasoning || void 0,
+          reasoning_details: reasoningDetails.length > 0 ? reasoningDetails : void 0,
           cache_control: getCacheControl(providerMetadata)
         });
         break;
@@ -219,13 +262,13 @@ function mapOpenRouterFinishReason(finishReason) {
 
 // src/openrouter-error.ts
 import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
-import { z } from "zod";
-var OpenRouterErrorResponseSchema = z.object({
-  error: z.object({
-    message: z.string(),
-    type: z.string(),
-    param: z.any().nullable(),
-    code: z.string().nullable()
+import { z as z2 } from "zod";
+var OpenRouterErrorResponseSchema = z2.object({
+  error: z2.object({
+    message: z2.string(),
+    type: z2.string(),
+    param: z2.any().nullable(),
+    code: z2.string().nullable()
   })
 });
 var openrouterFailedResponseHandler = createJsonErrorResponseHandler({
@@ -372,13 +415,56 @@ var OpenRouterChatLanguageModel = class {
       };
     }
     const hasProviderMetadata = Object.keys(providerMetadata).length > 0;
+    const reasoningDetails = (_h = choice.message.reasoning_details) != null ? _h : [];
+    const reasoning = reasoningDetails.length > 0 ? reasoningDetails.map((detail) => {
+      var _a2;
+      switch (detail.type) {
+        case "reasoning.text" /* Text */: {
+          if (detail.text) {
+            return {
+              type: "text",
+              text: detail.text,
+              signature: (_a2 = detail.signature) != null ? _a2 : void 0
+            };
+          }
+          break;
+        }
+        case "reasoning.summary" /* Summary */: {
+          if (detail.summary) {
+            return {
+              type: "text",
+              text: detail.summary
+            };
+          }
+          break;
+        }
+        case "reasoning.encrypted" /* Encrypted */: {
+          if (detail.data) {
+            return {
+              type: "redacted",
+              data: detail.data
+            };
+          }
+          break;
+        }
+        default: {
+          detail;
+        }
+      }
+      return null;
+    }).filter((p) => p !== null) : choice.message.reasoning ? [
+      {
+        type: "text",
+        text: choice.message.reasoning
+      }
+    ] : [];
     return __spreadValues({
       response: {
         id: response.id,
         modelId: response.model
       },
-      text: (_h = choice.message.content) != null ? _h : void 0,
-      reasoning: (_i = choice.message.reasoning) != null ? _i : void 0,
+      text: (_i = choice.message.content) != null ? _i : void 0,
+      reasoning,
       toolCalls: (_j = choice.message.tool_calls) == null ? void 0 : _j.map((toolCall) => {
         var _a2;
         return {
@@ -497,11 +583,56 @@ var OpenRouterChatLanguageModel = class {
                 textDelta: delta.reasoning
               });
             }
+            if (delta.reasoning_details && delta.reasoning_details.length > 0) {
+              for (const detail of delta.reasoning_details) {
+                switch (detail.type) {
+                  case "reasoning.text" /* Text */: {
+                    if (detail.text) {
+                      controller.enqueue({
+                        type: "reasoning",
+                        textDelta: detail.text
+                      });
+                    }
+                    if (detail.signature) {
+                      controller.enqueue({
+                        type: "reasoning-signature",
+                        signature: detail.signature
+                      });
+                    }
+                    break;
+                  }
+                  case "reasoning.encrypted" /* Encrypted */: {
+                    if (detail.data) {
+                      controller.enqueue({
+                        type: "redacted-reasoning",
+                        data: detail.data
+                      });
+                    }
+                    break;
+                  }
+                  case "reasoning.summary" /* Summary */: {
+                    if (detail.summary) {
+                      controller.enqueue({
+                        type: "reasoning",
+                        textDelta: detail.summary
+                      });
+                    }
+                    break;
+                  }
+                  default: {
+                    detail;
+                    break;
+                  }
+                }
+              }
+            }
             const mappedLogprobs = mapOpenRouterChatLogProbsOutput(
               choice == null ? void 0 : choice.logprobs
             );
             if (mappedLogprobs == null ? void 0 : mappedLogprobs.length) {
-              if (logprobs === void 0) logprobs = [];
+              if (logprobs === void 0) {
+                logprobs = [];
+              }
               logprobs.push(...mappedLogprobs);
             }
             if (delta.tool_calls != null) {
@@ -624,95 +755,97 @@ var OpenRouterChatLanguageModel = class {
     };
   }
 };
-var OpenRouterChatCompletionBaseResponseSchema = z2.object({
-  id: z2.string().optional(),
-  model: z2.string().optional(),
-  usage: z2.object({
-    prompt_tokens: z2.number(),
-    prompt_tokens_details: z2.object({
-      cached_tokens: z2.number()
+var OpenRouterChatCompletionBaseResponseSchema = z3.object({
+  id: z3.string().optional(),
+  model: z3.string().optional(),
+  usage: z3.object({
+    prompt_tokens: z3.number(),
+    prompt_tokens_details: z3.object({
+      cached_tokens: z3.number()
     }).optional(),
-    completion_tokens: z2.number(),
-    completion_tokens_details: z2.object({
-      reasoning_tokens: z2.number()
+    completion_tokens: z3.number(),
+    completion_tokens_details: z3.object({
+      reasoning_tokens: z3.number()
     }).optional(),
-    total_tokens: z2.number(),
-    cost: z2.number().optional()
+    total_tokens: z3.number(),
+    cost: z3.number().optional()
   }).nullish()
 });
 var OpenRouterNonStreamChatCompletionResponseSchema = OpenRouterChatCompletionBaseResponseSchema.extend({
-  choices: z2.array(
-    z2.object({
-      message: z2.object({
-        role: z2.literal("assistant"),
-        content: z2.string().nullable().optional(),
-        reasoning: z2.string().nullable().optional(),
-        tool_calls: z2.array(
-          z2.object({
-            id: z2.string().optional().nullable(),
-            type: z2.literal("function"),
-            function: z2.object({
-              name: z2.string(),
-              arguments: z2.string()
+  choices: z3.array(
+    z3.object({
+      message: z3.object({
+        role: z3.literal("assistant"),
+        content: z3.string().nullable().optional(),
+        reasoning: z3.string().nullable().optional(),
+        reasoning_details: ReasoningDetailArraySchema.nullish(),
+        tool_calls: z3.array(
+          z3.object({
+            id: z3.string().optional().nullable(),
+            type: z3.literal("function"),
+            function: z3.object({
+              name: z3.string(),
+              arguments: z3.string()
             })
           })
         ).optional()
       }),
-      index: z2.number(),
-      logprobs: z2.object({
-        content: z2.array(
-          z2.object({
-            token: z2.string(),
-            logprob: z2.number(),
-            top_logprobs: z2.array(
-              z2.object({
-                token: z2.string(),
-                logprob: z2.number()
+      index: z3.number(),
+      logprobs: z3.object({
+        content: z3.array(
+          z3.object({
+            token: z3.string(),
+            logprob: z3.number(),
+            top_logprobs: z3.array(
+              z3.object({
+                token: z3.string(),
+                logprob: z3.number()
               })
             )
           })
         ).nullable()
       }).nullable().optional(),
-      finish_reason: z2.string().optional().nullable()
+      finish_reason: z3.string().optional().nullable()
     })
   )
 });
-var OpenRouterStreamChatCompletionChunkSchema = z2.union([
+var OpenRouterStreamChatCompletionChunkSchema = z3.union([
   OpenRouterChatCompletionBaseResponseSchema.extend({
-    choices: z2.array(
-      z2.object({
-        delta: z2.object({
-          role: z2.enum(["assistant"]).optional(),
-          content: z2.string().nullish(),
-          reasoning: z2.string().nullish().optional(),
-          tool_calls: z2.array(
-            z2.object({
-              index: z2.number(),
-              id: z2.string().nullish(),
-              type: z2.literal("function").optional(),
-              function: z2.object({
-                name: z2.string().nullish(),
-                arguments: z2.string().nullish()
+    choices: z3.array(
+      z3.object({
+        delta: z3.object({
+          role: z3.enum(["assistant"]).optional(),
+          content: z3.string().nullish(),
+          reasoning: z3.string().nullish().optional(),
+          reasoning_details: ReasoningDetailArraySchema.nullish(),
+          tool_calls: z3.array(
+            z3.object({
+              index: z3.number(),
+              id: z3.string().nullish(),
+              type: z3.literal("function").optional(),
+              function: z3.object({
+                name: z3.string().nullish(),
+                arguments: z3.string().nullish()
               })
             })
           ).nullish()
         }).nullish(),
-        logprobs: z2.object({
-          content: z2.array(
-            z2.object({
-              token: z2.string(),
-              logprob: z2.number(),
-              top_logprobs: z2.array(
-                z2.object({
-                  token: z2.string(),
-                  logprob: z2.number()
+        logprobs: z3.object({
+          content: z3.array(
+            z3.object({
+              token: z3.string(),
+              logprob: z3.number(),
+              top_logprobs: z3.array(
+                z3.object({
+                  token: z3.string(),
+                  logprob: z3.number()
                 })
               )
             })
           ).nullable()
         }).nullish(),
-        finish_reason: z2.string().nullable().optional(),
-        index: z2.number()
+        finish_reason: z3.string().nullable().optional(),
+        index: z3.number()
       })
     )
   }),
@@ -777,7 +910,7 @@ import {
   createJsonResponseHandler as createJsonResponseHandler2,
   postJsonToApi as postJsonToApi2
 } from "@ai-sdk/provider-utils";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/convert-to-openrouter-completion-prompt.ts
 import {
@@ -1110,7 +1243,9 @@ var OpenRouterCompletionLanguageModel = class {
               choice == null ? void 0 : choice.logprobs
             );
             if (mappedLogprobs == null ? void 0 : mappedLogprobs.length) {
-              if (logprobs === void 0) logprobs = [];
+              if (logprobs === void 0) {
+                logprobs = [];
+              }
               logprobs.push(...mappedLogprobs);
             }
           },
@@ -1130,26 +1265,27 @@ var OpenRouterCompletionLanguageModel = class {
     };
   }
 };
-var OpenRouterCompletionChunkSchema = z3.union([
-  z3.object({
-    id: z3.string().optional(),
-    model: z3.string().optional(),
-    choices: z3.array(
-      z3.object({
-        text: z3.string(),
-        reasoning: z3.string().nullish().optional(),
-        finish_reason: z3.string().nullish(),
-        index: z3.number(),
-        logprobs: z3.object({
-          tokens: z3.array(z3.string()),
-          token_logprobs: z3.array(z3.number()),
-          top_logprobs: z3.array(z3.record(z3.string(), z3.number())).nullable()
+var OpenRouterCompletionChunkSchema = z4.union([
+  z4.object({
+    id: z4.string().optional(),
+    model: z4.string().optional(),
+    choices: z4.array(
+      z4.object({
+        text: z4.string(),
+        reasoning: z4.string().nullish().optional(),
+        reasoning_details: ReasoningDetailArraySchema.nullish(),
+        finish_reason: z4.string().nullish(),
+        index: z4.number(),
+        logprobs: z4.object({
+          tokens: z4.array(z4.string()),
+          token_logprobs: z4.array(z4.number()),
+          top_logprobs: z4.array(z4.record(z4.string(), z4.number())).nullable()
         }).nullable().optional()
       })
     ),
-    usage: z3.object({
-      prompt_tokens: z3.number(),
-      completion_tokens: z3.number()
+    usage: z4.object({
+      prompt_tokens: z4.number(),
+      completion_tokens: z4.number()
     }).optional().nullable()
   }),
   OpenRouterErrorResponseSchema