@openrouter/ai-sdk-provider 0.4.1 → 0.4.3

package/README.md

@@ -107,3 +107,39 @@ There are 3 ways to pass extra body to OpenRouter:
      messages: [{ role: 'user', content: 'Hello' }],
    });
    ```
+
+## Anthropic Prompt Caching
+
+You can include Anthropic-specific options directly in your messages when using functions like `streamText`. The OpenRouter provider will automatically convert these messages to the correct format internally.
+
+### Basic Usage
+
+```typescript
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { streamText } from 'ai';
+
+const openrouter = createOpenRouter({ apiKey: 'your-api-key' });
+const model = openrouter('anthropic/<supported-caching-model>');
+
+await streamText({
+  model,
+  messages: [
+    {
+      role: 'system',
+      content: 'You are a helpful assistant.',
+      // Add provider options at the message level
+      providerMetadata: {
+        openrouter: {
+          // cache_control also works
+          // cache_control: { type: 'ephemeral' }
+          cacheControl: { type: 'ephemeral' },
+        },
+      },
+    },
+    {
+      role: 'user',
+      content: 'Hello, how are you?',
+    },
+  ],
+});
+```

package/dist/index.js

@@ -66,39 +66,61 @@ var import_zod2 = require("zod");
 // src/convert-to-openrouter-chat-messages.ts
 var import_provider_utils = require("@ai-sdk/provider-utils");
 function convertToOpenRouterChatMessages(prompt) {
-  var _a;
+  var _a, _b, _c;
   const messages = [];
-  for (const { role, content } of prompt) {
+  function getCacheControl(providerMetadata) {
+    var _a2;
+    const anthropic = providerMetadata == null ? void 0 : providerMetadata.anthropic;
+    const cacheControlValue = (_a2 = anthropic == null ? void 0 : anthropic.cacheControl) != null ? _a2 : anthropic == null ? void 0 : anthropic.cache_control;
+    return cacheControlValue;
+  }
+  for (const { role, content, providerMetadata } of prompt) {
     switch (role) {
       case "system": {
-        messages.push({ role: "system", content });
+        messages.push({
+          role: "system",
+          content,
+          cache_control: getCacheControl(providerMetadata)
+        });
         break;
       }
       case "user": {
         if (content.length === 1 && ((_a = content[0]) == null ? void 0 : _a.type) === "text") {
-          messages.push({ role: "user", content: content[0].text });
+          messages.push({
+            role: "user",
+            content: content[0].text,
+            cache_control: (_b = getCacheControl(providerMetadata)) != null ? _b : getCacheControl(content[0].providerMetadata)
+          });
           break;
         }
+        const messageCacheControl = getCacheControl(providerMetadata);
         const contentParts = content.map(
           (part) => {
-            var _a2;
+            var _a2, _b2, _c2;
             switch (part.type) {
               case "text":
                 return {
                   type: "text",
-                  text: part.text
+                  text: part.text,
+                  // For text parts, only use part-specific cache control
+                  cache_control: getCacheControl(part.providerMetadata)
                 };
               case "image":
                 return {
                   type: "image_url",
                   image_url: {
-                    url: part.image instanceof URL ? part.image.toString() : `data:${(_a2 = part.mimeType) != null ? _a2 : "image/jpeg"};base64,${(0, import_provider_utils.convertUint8ArrayToBase64)(part.image)}`
-                  }
+                    url: part.image instanceof URL ? part.image.toString() : `data:${(_a2 = part.mimeType) != null ? _a2 : "image/jpeg"};base64,${(0, import_provider_utils.convertUint8ArrayToBase64)(
+                      part.image
+                    )}`
+                  },
+                  // For image parts, use part-specific or message-level cache control
+                  cache_control: (_b2 = getCacheControl(part.providerMetadata)) != null ? _b2 : messageCacheControl
                 };
               case "file":
                 return {
                   type: "text",
-                  text: part.data instanceof URL ? part.data.toString() : part.data
+                  text: part.data instanceof URL ? part.data.toString() : part.data,
+                  cache_control: (_c2 = getCacheControl(part.providerMetadata)) != null ? _c2 : messageCacheControl
                 };
               default: {
                 const _exhaustiveCheck = part;
@@ -148,7 +170,8 @@ function convertToOpenRouterChatMessages(prompt) {
         messages.push({
           role: "assistant",
           content: text,
-          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+          tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
+          cache_control: getCacheControl(providerMetadata)
         });
         break;
       }
@@ -157,7 +180,8 @@ function convertToOpenRouterChatMessages(prompt) {
           messages.push({
             role: "tool",
             tool_call_id: toolResponse.toolCallId,
-            content: JSON.stringify(toolResponse.result)
+            content: JSON.stringify(toolResponse.result),
+            cache_control: (_c = getCacheControl(providerMetadata)) != null ? _c : getCacheControl(toolResponse.providerMetadata)
           });
         }
         break;
@@ -204,7 +228,7 @@ function mapOpenRouterFinishReason(finishReason) {
 // src/openrouter-error.ts
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
 var import_zod = require("zod");
-var openAIErrorDataSchema = import_zod.z.object({
+var OpenRouterErrorResponseSchema = import_zod.z.object({
   error: import_zod.z.object({
     message: import_zod.z.string(),
     type: import_zod.z.string(),
@@ -213,7 +237,7 @@ var openAIErrorDataSchema = import_zod.z.object({
   })
 });
 var openrouterFailedResponseHandler = (0, import_provider_utils2.createJsonErrorResponseHandler)({
-  errorSchema: openAIErrorDataSchema,
+  errorSchema: OpenRouterErrorResponseSchema,
   errorToMessage: (data) => data.error.message
 });
 
@@ -309,7 +333,7 @@ var OpenRouterChatLanguageModel = class {
     }
   }
   async doGenerate(options) {
-    var _b, _c, _d;
+    var _b, _c, _d, _e, _f, _g, _h;
     const args = this.getArgs(options);
     const { responseHeaders, value: response } = await (0, import_provider_utils3.postJsonToApi)({
       url: this.config.url({
@@ -320,17 +344,21 @@ var OpenRouterChatLanguageModel = class {
       body: args,
       failedResponseHandler: openrouterFailedResponseHandler,
       successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
-        openAIChatResponseSchema
+        OpenRouterNonStreamChatCompletionResponseSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
     const _a = args, { messages: rawPrompt } = _a, rawSettings = __objRest(_a, ["messages"]);
     const choice = response.choices[0];
-    if (choice == null) {
+    if (!choice) {
       throw new Error("No choice in response");
     }
     return {
+      response: {
+        id: response.id,
+        modelId: response.model
+      },
       text: (_b = choice.message.content) != null ? _b : void 0,
       reasoning: (_c = choice.message.reasoning) != null ? _c : void 0,
       toolCalls: (_d = choice.message.tool_calls) == null ? void 0 : _d.map((toolCall) => {
@@ -344,8 +372,8 @@ var OpenRouterChatLanguageModel = class {
       }),
       finishReason: mapOpenRouterFinishReason(choice.finish_reason),
       usage: {
-        promptTokens: response.usage.prompt_tokens,
-        completionTokens: response.usage.completion_tokens
+        promptTokens: (_f = (_e = response.usage) == null ? void 0 : _e.prompt_tokens) != null ? _f : 0,
+        completionTokens: (_h = (_g = response.usage) == null ? void 0 : _g.completion_tokens) != null ? _h : 0
       },
       rawCall: { rawPrompt, rawSettings },
       rawResponse: { headers: responseHeaders },
@@ -368,7 +396,7 @@ var OpenRouterChatLanguageModel = class {
       }),
       failedResponseHandler: openrouterFailedResponseHandler,
       successfulResponseHandler: (0, import_provider_utils3.createEventSourceResponseHandler)(
-        openrouterChatChunkSchema
+        OpenRouterStreamChatCompletionChunkSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
@@ -403,6 +431,12 @@ var OpenRouterChatLanguageModel = class {
                 id: value.id
               });
             }
+            if (value.model) {
+              controller.enqueue({
+                type: "response-metadata",
+                modelId: value.model
+              });
+            }
             if (value.usage != null) {
               usage = {
                 promptTokens: value.usage.prompt_tokens,
@@ -530,7 +564,16 @@ var OpenRouterChatLanguageModel = class {
     };
   }
 };
-var openAIChatResponseSchema = import_zod2.z.object({
+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(),
+    completion_tokens: import_zod2.z.number(),
+    total_tokens: import_zod2.z.number()
+  }).nullish()
+});
+var OpenRouterNonStreamChatCompletionResponseSchema = OpenRouterChatCompletionBaseResponseSchema.extend({
   choices: import_zod2.z.array(
     import_zod2.z.object({
       message: import_zod2.z.object({
@@ -565,15 +608,10 @@ var openAIChatResponseSchema = import_zod2.z.object({
       }).nullable().optional(),
       finish_reason: import_zod2.z.string().optional().nullable()
     })
-  ),
-  usage: import_zod2.z.object({
-    prompt_tokens: import_zod2.z.number(),
-    completion_tokens: import_zod2.z.number()
-  })
+  )
 });
-var openrouterChatChunkSchema = import_zod2.z.union([
-  import_zod2.z.object({
-    id: import_zod2.z.string().optional(),
+var OpenRouterStreamChatCompletionChunkSchema = import_zod2.z.union([
+  OpenRouterChatCompletionBaseResponseSchema.extend({
     choices: import_zod2.z.array(
       import_zod2.z.object({
         delta: import_zod2.z.object({
@@ -609,13 +647,9 @@ var openrouterChatChunkSchema = import_zod2.z.union([
         finish_reason: import_zod2.z.string().nullable().optional(),
         index: import_zod2.z.number()
       })
-    ),
-    usage: import_zod2.z.object({
-      prompt_tokens: import_zod2.z.number(),
-      completion_tokens: import_zod2.z.number()
-    }).nullish()
+    )
   }),
-  openAIErrorDataSchema
+  OpenRouterErrorResponseSchema
 ]);
 function prepareToolsAndToolChoice(mode) {
   var _a;
@@ -893,6 +927,7 @@ var OpenRouterCompletionLanguageModel = class {
     }
   }
   async doGenerate(options) {
+    var _b, _c, _d, _e, _f;
     const args = this.getArgs(options);
     const { responseHeaders, value: response } = await (0, import_provider_utils4.postJsonToApi)({
       url: this.config.url({
@@ -903,22 +938,29 @@ var OpenRouterCompletionLanguageModel = class {
       body: args,
       failedResponseHandler: openrouterFailedResponseHandler,
       successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
-        openAICompletionResponseSchema
+        OpenRouterCompletionChunkSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
     const _a = args, { prompt: rawPrompt } = _a, rawSettings = __objRest(_a, ["prompt"]);
+    if ("error" in response) {
+      throw new Error(`${response.error.message}`);
+    }
     const choice = response.choices[0];
     if (!choice) {
       throw new Error("No choice in OpenRouter completion response");
     }
     return {
-      text: choice.text,
+      response: {
+        id: response.id,
+        modelId: response.model
+      },
+      text: (_b = choice.text) != null ? _b : "",
       reasoning: choice.reasoning || void 0,
       usage: {
-        promptTokens: response.usage.prompt_tokens,
-        completionTokens: response.usage.completion_tokens
+        promptTokens: (_d = (_c = response.usage) == null ? void 0 : _c.prompt_tokens) != null ? _d : 0,
+        completionTokens: (_f = (_e = response.usage) == null ? void 0 : _e.completion_tokens) != null ? _f : 0
       },
       finishReason: mapOpenRouterFinishReason(choice.finish_reason),
       logprobs: mapOpenRouterCompletionLogProbs(choice.logprobs),
@@ -942,7 +984,7 @@ var OpenRouterCompletionLanguageModel = class {
       }),
       failedResponseHandler: openrouterFailedResponseHandler,
       successfulResponseHandler: (0, import_provider_utils4.createEventSourceResponseHandler)(
-        openrouterCompletionChunkSchema
+        OpenRouterCompletionChunkSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
@@ -1009,29 +1051,14 @@ var OpenRouterCompletionLanguageModel = class {
     };
   }
 };
-var openAICompletionResponseSchema = import_zod3.z.object({
-  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(),
-      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()
-      }).nullable().optional()
-    })
-  ),
-  usage: import_zod3.z.object({
-    prompt_tokens: import_zod3.z.number(),
-    completion_tokens: import_zod3.z.number()
-  })
-});
-var openrouterCompletionChunkSchema = import_zod3.z.union([
+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({
@@ -1046,7 +1073,7 @@ var openrouterCompletionChunkSchema = import_zod3.z.union([
       completion_tokens: import_zod3.z.number()
     }).optional().nullable()
   }),
-  openAIErrorDataSchema
+  OpenRouterErrorResponseSchema
 ]);
 
 // src/openrouter-facade.ts