@openrouter/ai-sdk-provider 0.6.0 → 0.7.0-alpha.0

package/dist/internal/index.d.ts

@@ -56,8 +56,8 @@ type OpenRouterUsageAccounting = {
     cost?: number;
 };
 
-type OpenRouterChatModelId = string;
-type OpenRouterChatSettings = {
+type OpenRouterCompletionModelId = string;
+type OpenRouterCompletionSettings = {
     /**
   Modify the likelihood of specified tokens appearing in the completion.
   
@@ -71,7 +71,7 @@ type OpenRouterChatSettings = {
   
   As an example, you can pass {"50256": -100} to prevent the <|endoftext|>
   token from being generated.
-  */
+     */
     logitBias?: Record<number, number>;
     /**
   Return the log probabilities of the tokens. Including logprobs will increase
@@ -83,20 +83,15 @@ type OpenRouterChatSettings = {
   
   Setting to a number will return the log probabilities of the top n
   tokens that were generated.
-  */
+     */
     logprobs?: boolean | number;
     /**
-  Whether to enable parallel function calling during tool use. Default to true.
+  The suffix that comes after a completion of inserted text.
      */
-    parallelToolCalls?: boolean;
-    /**
-  A unique identifier representing your end-user, which can help OpenRouter to
-  monitor and detect abuse. Learn more.
-  */
-    user?: string;
+    suffix?: string;
 } & OpenRouterSharedSettings;
 
-type OpenRouterChatConfig = {
+type OpenRouterCompletionConfig = {
     provider: string;
     compatibility: 'strict' | 'compatible';
     headers: () => Record<string, string | undefined>;
@@ -107,21 +102,21 @@ type OpenRouterChatConfig = {
     fetch?: typeof fetch;
     extraBody?: Record<string, unknown>;
 };
-declare class OpenRouterChatLanguageModel implements LanguageModelV1 {
+declare class OpenRouterCompletionLanguageModel implements LanguageModelV1 {
     readonly specificationVersion = "v1";
-    readonly defaultObjectGenerationMode = "tool";
-    readonly modelId: OpenRouterChatModelId;
-    readonly settings: OpenRouterChatSettings;
+    readonly defaultObjectGenerationMode: undefined;
+    readonly modelId: OpenRouterCompletionModelId;
+    readonly settings: OpenRouterCompletionSettings;
     private readonly config;
-    constructor(modelId: OpenRouterChatModelId, settings: OpenRouterChatSettings, config: OpenRouterChatConfig);
+    constructor(modelId: OpenRouterCompletionModelId, settings: OpenRouterCompletionSettings, config: OpenRouterCompletionConfig);
     get provider(): string;
     private getArgs;
     doGenerate(options: Parameters<LanguageModelV1['doGenerate']>[0]): Promise<Awaited<ReturnType<LanguageModelV1['doGenerate']>>>;
     doStream(options: Parameters<LanguageModelV1['doStream']>[0]): Promise<Awaited<ReturnType<LanguageModelV1['doStream']>>>;
 }
 
-type OpenRouterCompletionModelId = string;
-type OpenRouterCompletionSettings = {
+type OpenRouterChatModelId = string;
+type OpenRouterChatSettings = {
     /**
   Modify the likelihood of specified tokens appearing in the completion.
   
@@ -135,7 +130,7 @@ type OpenRouterCompletionSettings = {
   
   As an example, you can pass {"50256": -100} to prevent the <|endoftext|>
   token from being generated.
-     */
+  */
     logitBias?: Record<number, number>;
     /**
   Return the log probabilities of the tokens. Including logprobs will increase
@@ -147,15 +142,20 @@ type OpenRouterCompletionSettings = {
   
   Setting to a number will return the log probabilities of the top n
   tokens that were generated.
-     */
+  */
     logprobs?: boolean | number;
     /**
-  The suffix that comes after a completion of inserted text.
+  Whether to enable parallel function calling during tool use. Default to true.
      */
-    suffix?: string;
+    parallelToolCalls?: boolean;
+    /**
+  A unique identifier representing your end-user, which can help OpenRouter to
+  monitor and detect abuse. Learn more.
+  */
+    user?: string;
 } & OpenRouterSharedSettings;
 
-type OpenRouterCompletionConfig = {
+type OpenRouterChatConfig = {
     provider: string;
     compatibility: 'strict' | 'compatible';
     headers: () => Record<string, string | undefined>;
@@ -166,17 +166,19 @@ type OpenRouterCompletionConfig = {
     fetch?: typeof fetch;
     extraBody?: Record<string, unknown>;
 };
-declare class OpenRouterCompletionLanguageModel implements LanguageModelV1 {
+type DoGenerateOutput = Awaited<ReturnType<LanguageModelV1['doGenerate']>>;
+type DoStreamOutput = Awaited<ReturnType<LanguageModelV1['doStream']>>;
+declare class OpenRouterChatLanguageModel implements LanguageModelV1 {
     readonly specificationVersion = "v1";
-    readonly defaultObjectGenerationMode: undefined;
-    readonly modelId: OpenRouterCompletionModelId;
-    readonly settings: OpenRouterCompletionSettings;
+    readonly defaultObjectGenerationMode = "tool";
+    readonly modelId: OpenRouterChatModelId;
+    readonly settings: OpenRouterChatSettings;
     private readonly config;
-    constructor(modelId: OpenRouterCompletionModelId, settings: OpenRouterCompletionSettings, config: OpenRouterCompletionConfig);
+    constructor(modelId: OpenRouterChatModelId, settings: OpenRouterChatSettings, config: OpenRouterChatConfig);
     get provider(): string;
     private getArgs;
-    doGenerate(options: Parameters<LanguageModelV1['doGenerate']>[0]): Promise<Awaited<ReturnType<LanguageModelV1['doGenerate']>>>;
-    doStream(options: Parameters<LanguageModelV1['doStream']>[0]): Promise<Awaited<ReturnType<LanguageModelV1['doStream']>>>;
+    doGenerate(options: Parameters<LanguageModelV1['doGenerate']>[0]): Promise<DoGenerateOutput>;
+    doStream(options: Parameters<LanguageModelV1['doStream']>[0]): Promise<DoStreamOutput>;
 }
 
 export { OpenRouterChatLanguageModel, type OpenRouterChatModelId, type OpenRouterChatSettings, OpenRouterCompletionLanguageModel, type OpenRouterCompletionModelId, type OpenRouterCompletionSettings, type OpenRouterLanguageModel, type OpenRouterProviderOptions, type OpenRouterSharedSettings, type OpenRouterUsageAccounting };

package/dist/internal/index.js

@@ -54,10 +54,36 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/schemas/reasoning-details.ts
+var import_zod = require("zod");
+var ReasoningDetailSummarySchema = import_zod.z.object({
+  type: import_zod.z.literal("reasoning.summary" /* Summary */),
+  summary: import_zod.z.string()
+});
+var ReasoningDetailEncryptedSchema = import_zod.z.object({
+  type: import_zod.z.literal("reasoning.encrypted" /* Encrypted */),
+  data: import_zod.z.string()
+});
+var ReasoningDetailTextSchema = import_zod.z.object({
+  type: import_zod.z.literal("reasoning.text" /* Text */),
+  text: import_zod.z.string().nullish(),
+  signature: import_zod.z.string().nullish()
+});
+var ReasoningDetailUnionSchema = import_zod.z.union([
+  ReasoningDetailSummarySchema,
+  ReasoningDetailEncryptedSchema,
+  ReasoningDetailTextSchema
+]);
+var ReasoningDetailsWithUnknownSchema = import_zod.z.union([
+  ReasoningDetailUnionSchema,
+  import_zod.z.unknown().transform(() => null)
+]);
+var ReasoningDetailArraySchema = import_zod.z.array(ReasoningDetailsWithUnknownSchema).transform((d) => d.filter((d2) => !!d2));
+
 // src/openrouter-chat-language-model.ts
 var import_provider = require("@ai-sdk/provider");
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/convert-to-openrouter-chat-messages.ts
 var import_provider_utils = require("@ai-sdk/provider-utils");
@@ -141,6 +167,8 @@ function convertToOpenRouterChatMessages(prompt) {
       }
       case "assistant": {
         let text = "";
+        let reasoning = "";
+        const reasoningDetails = [];
         const toolCalls = [];
         for (const part of content) {
           switch (part.type) {
@@ -159,10 +187,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;
@@ -174,6 +215,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;
@@ -230,13 +273,13 @@ function mapOpenRouterFinishReason(finishReason) {
 
 // src/openrouter-error.ts
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_zod = require("zod");
-var OpenRouterErrorResponseSchema = import_zod.z.object({
-  error: import_zod.z.object({
-    message: import_zod.z.string(),
-    type: import_zod.z.string(),
-    param: import_zod.z.any().nullable(),
-    code: import_zod.z.string().nullable()
+var import_zod2 = require("zod");
+var OpenRouterErrorResponseSchema = import_zod2.z.object({
+  error: import_zod2.z.object({
+    message: import_zod2.z.string(),
+    type: import_zod2.z.string(),
+    param: import_zod2.z.any().nullable(),
+    code: import_zod2.z.string().nullable()
   })
 });
 var openrouterFailedResponseHandler = (0, import_provider_utils2.createJsonErrorResponseHandler)({
@@ -383,13 +426,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 {
@@ -508,11 +594,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) {
@@ -635,95 +766,97 @@ var OpenRouterChatLanguageModel = class {
     };
   }
 };
-var OpenRouterChatCompletionBaseResponseSchema = import_zod2.z.object({
-  id: import_zod2.z.string().optional(),
-  model: import_zod2.z.string().optional(),
-  usage: import_zod2.z.object({
-    prompt_tokens: import_zod2.z.number(),
-    prompt_tokens_details: import_zod2.z.object({
-      cached_tokens: import_zod2.z.number()
+var OpenRouterChatCompletionBaseResponseSchema = import_zod3.z.object({
+  id: import_zod3.z.string().optional(),
+  model: import_zod3.z.string().optional(),
+  usage: import_zod3.z.object({
+    prompt_tokens: import_zod3.z.number(),
+    prompt_tokens_details: import_zod3.z.object({
+      cached_tokens: import_zod3.z.number()
     }).optional(),
-    completion_tokens: import_zod2.z.number(),
-    completion_tokens_details: import_zod2.z.object({
-      reasoning_tokens: import_zod2.z.number()
+    completion_tokens: import_zod3.z.number(),
+    completion_tokens_details: import_zod3.z.object({
+      reasoning_tokens: import_zod3.z.number()
     }).optional(),
-    total_tokens: import_zod2.z.number(),
-    cost: import_zod2.z.number().optional()
+    total_tokens: import_zod3.z.number(),
+    cost: import_zod3.z.number().optional()
   }).nullish()
 });
 var OpenRouterNonStreamChatCompletionResponseSchema = OpenRouterChatCompletionBaseResponseSchema.extend({
-  choices: import_zod2.z.array(
-    import_zod2.z.object({
-      message: import_zod2.z.object({
-        role: import_zod2.z.literal("assistant"),
-        content: import_zod2.z.string().nullable().optional(),
-        reasoning: import_zod2.z.string().nullable().optional(),
-        tool_calls: import_zod2.z.array(
-          import_zod2.z.object({
-            id: import_zod2.z.string().optional().nullable(),
-            type: import_zod2.z.literal("function"),
-            function: import_zod2.z.object({
-              name: import_zod2.z.string(),
-              arguments: import_zod2.z.string()
+  choices: import_zod3.z.array(
+    import_zod3.z.object({
+      message: import_zod3.z.object({
+        role: import_zod3.z.literal("assistant"),
+        content: import_zod3.z.string().nullable().optional(),
+        reasoning: import_zod3.z.string().nullable().optional(),
+        reasoning_details: ReasoningDetailArraySchema.nullish(),
+        tool_calls: import_zod3.z.array(
+          import_zod3.z.object({
+            id: import_zod3.z.string().optional().nullable(),
+            type: import_zod3.z.literal("function"),
+            function: import_zod3.z.object({
+              name: import_zod3.z.string(),
+              arguments: import_zod3.z.string()
             })
           })
         ).optional()
       }),
-      index: import_zod2.z.number(),
-      logprobs: import_zod2.z.object({
-        content: import_zod2.z.array(
-          import_zod2.z.object({
-            token: import_zod2.z.string(),
-            logprob: import_zod2.z.number(),
-            top_logprobs: import_zod2.z.array(
-              import_zod2.z.object({
-                token: import_zod2.z.string(),
-                logprob: import_zod2.z.number()
+      index: import_zod3.z.number(),
+      logprobs: import_zod3.z.object({
+        content: import_zod3.z.array(
+          import_zod3.z.object({
+            token: import_zod3.z.string(),
+            logprob: import_zod3.z.number(),
+            top_logprobs: import_zod3.z.array(
+              import_zod3.z.object({
+                token: import_zod3.z.string(),
+                logprob: import_zod3.z.number()
               })
             )
           })
         ).nullable()
       }).nullable().optional(),
-      finish_reason: import_zod2.z.string().optional().nullable()
+      finish_reason: import_zod3.z.string().optional().nullable()
     })
   )
 });
-var OpenRouterStreamChatCompletionChunkSchema = import_zod2.z.union([
+var OpenRouterStreamChatCompletionChunkSchema = import_zod3.z.union([
   OpenRouterChatCompletionBaseResponseSchema.extend({
-    choices: import_zod2.z.array(
-      import_zod2.z.object({
-        delta: import_zod2.z.object({
-          role: import_zod2.z.enum(["assistant"]).optional(),
-          content: import_zod2.z.string().nullish(),
-          reasoning: import_zod2.z.string().nullish().optional(),
-          tool_calls: import_zod2.z.array(
-            import_zod2.z.object({
-              index: import_zod2.z.number(),
-              id: import_zod2.z.string().nullish(),
-              type: import_zod2.z.literal("function").optional(),
-              function: import_zod2.z.object({
-                name: import_zod2.z.string().nullish(),
-                arguments: import_zod2.z.string().nullish()
+    choices: import_zod3.z.array(
+      import_zod3.z.object({
+        delta: import_zod3.z.object({
+          role: import_zod3.z.enum(["assistant"]).optional(),
+          content: import_zod3.z.string().nullish(),
+          reasoning: import_zod3.z.string().nullish().optional(),
+          reasoning_details: ReasoningDetailArraySchema.nullish(),
+          tool_calls: import_zod3.z.array(
+            import_zod3.z.object({
+              index: import_zod3.z.number(),
+              id: import_zod3.z.string().nullish(),
+              type: import_zod3.z.literal("function").optional(),
+              function: import_zod3.z.object({
+                name: import_zod3.z.string().nullish(),
+                arguments: import_zod3.z.string().nullish()
               })
             })
           ).nullish()
         }).nullish(),
-        logprobs: import_zod2.z.object({
-          content: import_zod2.z.array(
-            import_zod2.z.object({
-              token: import_zod2.z.string(),
-              logprob: import_zod2.z.number(),
-              top_logprobs: import_zod2.z.array(
-                import_zod2.z.object({
-                  token: import_zod2.z.string(),
-                  logprob: import_zod2.z.number()
+        logprobs: import_zod3.z.object({
+          content: import_zod3.z.array(
+            import_zod3.z.object({
+              token: import_zod3.z.string(),
+              logprob: import_zod3.z.number(),
+              top_logprobs: import_zod3.z.array(
+                import_zod3.z.object({
+                  token: import_zod3.z.string(),
+                  logprob: import_zod3.z.number()
                 })
               )
             })
           ).nullable()
         }).nullish(),
-        finish_reason: import_zod2.z.string().nullable().optional(),
-        index: import_zod2.z.number()
+        finish_reason: import_zod3.z.string().nullable().optional(),
+        index: import_zod3.z.number()
       })
     )
   }),
@@ -783,7 +916,7 @@ function prepareToolsAndToolChoice(mode) {
 // src/openrouter-completion-language-model.ts
 var import_provider3 = require("@ai-sdk/provider");
 var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // src/convert-to-openrouter-completion-prompt.ts
 var import_provider2 = require("@ai-sdk/provider");
@@ -1113,7 +1246,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);
             }
           },
@@ -1133,26 +1268,27 @@ var OpenRouterCompletionLanguageModel = class {
     };
   }
 };
-var OpenRouterCompletionChunkSchema = import_zod3.z.union([
-  import_zod3.z.object({
-    id: import_zod3.z.string().optional(),
-    model: import_zod3.z.string().optional(),
-    choices: import_zod3.z.array(
-      import_zod3.z.object({
-        text: import_zod3.z.string(),
-        reasoning: import_zod3.z.string().nullish().optional(),
-        finish_reason: import_zod3.z.string().nullish(),
-        index: import_zod3.z.number(),
-        logprobs: import_zod3.z.object({
-          tokens: import_zod3.z.array(import_zod3.z.string()),
-          token_logprobs: import_zod3.z.array(import_zod3.z.number()),
-          top_logprobs: import_zod3.z.array(import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number())).nullable()
+var OpenRouterCompletionChunkSchema = import_zod4.z.union([
+  import_zod4.z.object({
+    id: import_zod4.z.string().optional(),
+    model: import_zod4.z.string().optional(),
+    choices: import_zod4.z.array(
+      import_zod4.z.object({
+        text: import_zod4.z.string(),
+        reasoning: import_zod4.z.string().nullish().optional(),
+        reasoning_details: ReasoningDetailArraySchema.nullish(),
+        finish_reason: import_zod4.z.string().nullish(),
+        index: import_zod4.z.number(),
+        logprobs: import_zod4.z.object({
+          tokens: import_zod4.z.array(import_zod4.z.string()),
+          token_logprobs: import_zod4.z.array(import_zod4.z.number()),
+          top_logprobs: import_zod4.z.array(import_zod4.z.record(import_zod4.z.string(), import_zod4.z.number())).nullable()
         }).nullable().optional()
       })
     ),
-    usage: import_zod3.z.object({
-      prompt_tokens: import_zod3.z.number(),
-      completion_tokens: import_zod3.z.number()
+    usage: import_zod4.z.object({
+      prompt_tokens: import_zod4.z.number(),
+      completion_tokens: import_zod4.z.number()
     }).optional().nullable()
   }),
   OpenRouterErrorResponseSchema