@effect/ai-openrouter 4.0.0-beta.2 → 4.0.0-beta.20

package/src/OpenRouterError.ts

@@ -42,51 +42,43 @@ export type OpenRouterRateLimitMetadata = OpenRouterErrorMetadata & {
 }
 
 declare module "effect/unstable/ai/AiError" {
-  export interface RateLimitError {
-    readonly metadata: {
-      readonly openrouter?: OpenRouterRateLimitMetadata | null
-    }
+  export interface RateLimitErrorMetadata {
+    readonly openrouter?: OpenRouterRateLimitMetadata | null
   }
 
-  export interface QuotaExhaustedError {
-    readonly metadata: {
-      readonly openrouter?: OpenRouterErrorMetadata | null
-    }
+  export interface QuotaExhaustedErrorMetadata {
+    readonly openrouter?: OpenRouterErrorMetadata | null
   }
 
-  export interface AuthenticationError {
-    readonly metadata: {
-      readonly openrouter?: OpenRouterErrorMetadata | null
-    }
+  export interface AuthenticationErrorMetadata {
+    readonly openrouter?: OpenRouterErrorMetadata | null
   }
 
-  export interface ContentPolicyError {
-    readonly metadata: {
-      readonly openrouter?: OpenRouterErrorMetadata | null
-    }
+  export interface ContentPolicyErrorMetadata {
+    readonly openrouter?: OpenRouterErrorMetadata | null
   }
 
-  export interface InvalidRequestError {
-    readonly metadata: {
-      readonly openrouter?: OpenRouterErrorMetadata | null
-    }
+  export interface InvalidRequestErrorMetadata {
+    readonly openrouter?: OpenRouterErrorMetadata | null
   }
 
-  export interface InternalProviderError {
-    readonly metadata: {
-      readonly openrouter?: OpenRouterErrorMetadata | null
-    }
+  export interface InternalProviderErrorMetadata {
+    readonly openrouter?: OpenRouterErrorMetadata | null
   }
 
-  export interface InvalidOutputError {
-    readonly metadata: {
-      readonly openrouter?: OpenRouterErrorMetadata | null
-    }
+  export interface InvalidOutputErrorMetadata {
+    readonly openrouter?: OpenRouterErrorMetadata | null
   }
 
-  export interface UnknownError {
-    readonly metadata: {
-      readonly openrouter?: OpenRouterErrorMetadata | null
-    }
+  export interface StructuredOutputErrorMetadata {
+    readonly openrouter?: OpenRouterErrorMetadata | null
+  }
+
+  export interface UnsupportedSchemaErrorMetadata {
+    readonly openrouter?: OpenRouterErrorMetadata | null
+  }
+
+  export interface UnknownErrorMetadata {
+    readonly openrouter?: OpenRouterErrorMetadata | null
   }
 }

package/src/OpenRouterLanguageModel.ts

@@ -5,7 +5,7 @@
 import * as Arr from "effect/Array"
 import * as DateTime from "effect/DateTime"
 import * as Effect from "effect/Effect"
-import * as Base64 from "effect/encoding/Base64"
+import * as Encoding from "effect/Encoding"
 import { dual } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Predicate from "effect/Predicate"
@@ -233,7 +233,7 @@ export const model = (
   model: string,
   config?: Omit<typeof Config.Service, "model">
 ): AiModel.Model<"openai", LanguageModel.LanguageModel, OpenRouterClient> =>
-  AiModel.make("openai", layer({ model, config }))
+  AiModel.make("openai", model, layer({ model, config }))
 
 /**
  * Creates an OpenRouter language model service.
@@ -451,7 +451,7 @@ const prepareMessages = Effect.fnUntraced(
                       url: part.data instanceof URL
                         ? part.data.toString()
                         : part.data instanceof Uint8Array
-                        ? `data:${mediaType};base64,${Base64.encode(part.data)}`
+                        ? `data:${mediaType};base64,${Encoding.encodeBase64(part.data)}`
                         : part.data
                     },
                     ...(Predicate.isNotNull(partCacheControl) ? { cache_control: partCacheControl } : undefined)
@@ -470,7 +470,7 @@ const prepareMessages = Effect.fnUntraced(
                     file_data: part.data instanceof URL
                       ? part.data.toString()
                       : part.data instanceof Uint8Array
-                      ? `data:${part.mediaType};base64,${Base64.encode(part.data)}`
+                      ? `data:${part.mediaType};base64,${Encoding.encodeBase64(part.data)}`
                       : part.data
                   },
                   ...(Predicate.isNotNull(partCacheControl) ? { cache_control: partCacheControl } : undefined)
@@ -830,12 +830,12 @@ const makeStreamResponse = Effect.fnUntraced(
     let activeTextId: string | undefined = undefined
 
     let totalToolCalls = 0
-    const activeToolCalls: Array<{
+    const activeToolCalls: Record<number, {
       readonly id: string
       readonly type: "function"
       readonly name: string
       params: string
-    }> = []
+    }> = {}
 
     // Track reasoning details to preserve for multi-turn conversations
     const accumulatedReasoningDetails: DeepMutable<ReasoningDetails> = []
@@ -885,283 +885,275 @@ const makeStreamResponse = Effect.fnUntraced(
         }
 
         const choice = event.choices[0]
-        if (Predicate.isUndefined(choice)) {
-          return yield* AiError.make({
-            module: "OpenRouterLanguageModel",
-            method: "makeStreamResponse",
-            reason: new AiError.InvalidOutputError({
-              description: "Received response with empty choices"
-            })
-          })
-        }
-
-        if (Predicate.isNotNull(choice.finish_reason)) {
-          finishReason = resolveFinishReason(choice.finish_reason)
-        }
+        if (Predicate.isNotUndefined(choice)) {
+          if (Predicate.isNotNullish(choice.finish_reason)) {
+            finishReason = resolveFinishReason(choice.finish_reason)
+          }
 
-        const delta = choice.delta
-        if (Predicate.isNullish(delta)) {
-          return parts
-        }
+          const delta = choice.delta
+          if (Predicate.isNullish(delta)) {
+            return parts
+          }
 
-        const emitReasoning = Effect.fnUntraced(
-          function*(delta: string, metadata?: Response.ReasoningDeltaPart["metadata"] | undefined) {
-            if (!reasoningStarted) {
-              activeReasoningId = openRouterResponseId ?? (yield* idGenerator.generateId())
+          const emitReasoning = Effect.fnUntraced(
+            function*(delta: string, metadata?: Response.ReasoningDeltaPart["metadata"] | undefined) {
+              if (!reasoningStarted) {
+                activeReasoningId = openRouterResponseId ?? (yield* idGenerator.generateId())
+                parts.push({
+                  type: "reasoning-start",
+                  id: activeReasoningId,
+                  metadata
+                })
+                reasoningStarted = true
+              }
               parts.push({
-                type: "reasoning-start",
-                id: activeReasoningId,
+                type: "reasoning-delta",
+                id: activeReasoningId!,
+                delta,
                 metadata
               })
-              reasoningStarted = true
             }
-            parts.push({
-              type: "reasoning-delta",
-              id: activeReasoningId!,
-              delta,
-              metadata
-            })
-          }
-        )
+          )
 
-        const reasoningDetails = delta.reasoning_details
-        if (Predicate.isNotUndefined(reasoningDetails) && reasoningDetails.length > 0) {
-          // Accumulate reasoning_details to preserve for multi-turn conversations
-          // Merge consecutive reasoning.text items into a single entry
-          for (const detail of reasoningDetails) {
-            if (detail.type === "reasoning.text") {
-              const lastDetail = accumulatedReasoningDetails[accumulatedReasoningDetails.length - 1]
-              if (Predicate.isNotUndefined(lastDetail) && lastDetail.type === "reasoning.text") {
-                // Merge with the previous text detail
-                lastDetail.text = (lastDetail.text ?? "") + (detail.text ?? "")
-                lastDetail.signature = lastDetail.signature ?? detail.signature ?? null
-                lastDetail.format = lastDetail.format ?? detail.format ?? null
+          const reasoningDetails = delta.reasoning_details
+          if (Predicate.isNotUndefined(reasoningDetails) && reasoningDetails.length > 0) {
+            // Accumulate reasoning_details to preserve for multi-turn conversations
+            // Merge consecutive reasoning.text items into a single entry
+            for (const detail of reasoningDetails) {
+              if (detail.type === "reasoning.text") {
+                const lastDetail = accumulatedReasoningDetails[accumulatedReasoningDetails.length - 1]
+                if (Predicate.isNotUndefined(lastDetail) && lastDetail.type === "reasoning.text") {
+                  // Merge with the previous text detail
+                  lastDetail.text = (lastDetail.text ?? "") + (detail.text ?? "")
+                  lastDetail.signature = lastDetail.signature ?? detail.signature ?? null
+                  lastDetail.format = lastDetail.format ?? detail.format ?? null
+                } else {
+                  // Start a new text detail
+                  accumulatedReasoningDetails.push({ ...detail })
+                }
               } else {
-                // Start a new text detail
-                accumulatedReasoningDetails.push({ ...detail })
+                // Non-text details (encrypted, summary) are pushed as-is
+                accumulatedReasoningDetails.push(detail)
               }
-            } else {
-              // Non-text details (encrypted, summary) are pushed as-is
-              accumulatedReasoningDetails.push(detail)
             }
-          }
 
-          // Emit reasoning_details in providerMetadata for each delta chunk
-          // so users can accumulate them on their end before sending back
-          const metadata: Response.ReasoningDeltaPart["metadata"] = {
-            openrouter: {
-              reasoningDetails
+            // Emit reasoning_details in providerMetadata for each delta chunk
+            // so users can accumulate them on their end before sending back
+            const metadata: Response.ReasoningDeltaPart["metadata"] = {
+              openrouter: {
+                reasoningDetails
+              }
             }
-          }
-          for (const detail of reasoningDetails) {
-            switch (detail.type) {
-              case "reasoning.text": {
-                if (Predicate.isNotNullish(detail.text)) {
-                  yield* emitReasoning(detail.text, metadata)
+            for (const detail of reasoningDetails) {
+              switch (detail.type) {
+                case "reasoning.text": {
+                  if (Predicate.isNotNullish(detail.text)) {
+                    yield* emitReasoning(detail.text, metadata)
+                  }
+                  break
                 }
-                break
-              }
 
-              case "reasoning.summary": {
-                if (Predicate.isNotNullish(detail.summary)) {
-                  yield* emitReasoning(detail.summary, metadata)
+                case "reasoning.summary": {
+                  if (Predicate.isNotNullish(detail.summary)) {
+                    yield* emitReasoning(detail.summary, metadata)
+                  }
+                  break
                 }
-                break
-              }
 
-              case "reasoning.encrypted": {
-                if (Predicate.isNotNullish(detail.data)) {
-                  yield* emitReasoning("[REDACTED]", metadata)
+                case "reasoning.encrypted": {
+                  if (Predicate.isNotNullish(detail.data)) {
+                    yield* emitReasoning("[REDACTED]", metadata)
+                  }
+                  break
                 }
-                break
               }
             }
+          } else if (Predicate.isNotNullish(delta.reasoning)) {
+            yield* emitReasoning(delta.reasoning)
           }
-        } else if (Predicate.isNotNullish(delta.reasoning)) {
-          yield* emitReasoning(delta.reasoning)
-        }
 
-        const content = delta.content
-        if (Predicate.isNotNullish(content)) {
-          // If reasoning was previously active and now we're starting text content,
-          // we should end the reasoning first to maintain proper order
-          if (reasoningStarted && !textStarted) {
-            parts.push({
-              type: "reasoning-end",
-              id: activeReasoningId!,
-              // Include accumulated reasoning_details so the we can update the
-              // reasoning part's provider metadata with the correct signature.
-              // The signature typically arrives in the last reasoning delta,
-              // but reasoning-start only carries the first delta's metadata.
-              metadata: accumulatedReasoningDetails.length > 0
-                ? { openRouter: { reasoningDetails: accumulatedReasoningDetails } }
-                : undefined
-            })
-            reasoningStarted = false
-          }
+          const content = delta.content
+          if (Predicate.isNotNullish(content)) {
+            // If reasoning was previously active and now we're starting text content,
+            // we should end the reasoning first to maintain proper order
+            if (reasoningStarted && !textStarted) {
+              parts.push({
+                type: "reasoning-end",
+                id: activeReasoningId!,
+                // Include accumulated reasoning_details so the we can update the
+                // reasoning part's provider metadata with the correct signature.
+                // The signature typically arrives in the last reasoning delta,
+                // but reasoning-start only carries the first delta's metadata.
+                metadata: accumulatedReasoningDetails.length > 0
+                  ? { openRouter: { reasoningDetails: accumulatedReasoningDetails } }
+                  : undefined
+              })
+              reasoningStarted = false
+            }
+
+            if (!textStarted) {
+              activeTextId = openRouterResponseId ?? (yield* idGenerator.generateId())
+              parts.push({
+                type: "text-start",
+                id: activeTextId
+              })
+              textStarted = true
+            }
 
-          if (!textStarted) {
-            activeTextId = openRouterResponseId ?? (yield* idGenerator.generateId())
             parts.push({
-              type: "text-start",
-              id: activeTextId
+              type: "text-delta",
+              id: activeTextId!,
+              delta: content
             })
-            textStarted = true
           }
 
-          parts.push({
-            type: "text-delta",
-            id: activeTextId!,
-            delta: content
-          })
-        }
-
-        const annotations = delta.annotations
-        if (Predicate.isNotNullish(annotations)) {
-          for (const annotation of annotations) {
-            if (annotation.type === "url_citation") {
-              parts.push({
-                type: "source",
-                sourceType: "url",
-                id: annotation.url_citation.url,
-                url: annotation.url_citation.url,
-                title: annotation.url_citation.title ?? "",
-                metadata: {
-                  openrouter: {
-                    ...(Predicate.isNotUndefined(annotation.url_citation.content)
-                      ? { content: annotation.url_citation.content }
-                      : undefined),
-                    ...(Predicate.isNotUndefined(annotation.url_citation.start_index)
-                      ? { startIndex: annotation.url_citation.start_index }
-                      : undefined),
-                    ...(Predicate.isNotUndefined(annotation.url_citation.end_index)
-                      ? { startIndex: annotation.url_citation.end_index }
-                      : undefined)
+          const annotations = delta.annotations
+          if (Predicate.isNotNullish(annotations)) {
+            for (const annotation of annotations) {
+              if (annotation.type === "url_citation") {
+                parts.push({
+                  type: "source",
+                  sourceType: "url",
+                  id: annotation.url_citation.url,
+                  url: annotation.url_citation.url,
+                  title: annotation.url_citation.title ?? "",
+                  metadata: {
+                    openrouter: {
+                      ...(Predicate.isNotUndefined(annotation.url_citation.content)
+                        ? { content: annotation.url_citation.content }
+                        : undefined),
+                      ...(Predicate.isNotUndefined(annotation.url_citation.start_index)
+                        ? { startIndex: annotation.url_citation.start_index }
+                        : undefined),
+                      ...(Predicate.isNotUndefined(annotation.url_citation.end_index)
+                        ? { startIndex: annotation.url_citation.end_index }
+                        : undefined)
+                    }
                   }
-                }
-              })
-            } else if (annotation.type === "file") {
-              accumulatedFileAnnotations.push(annotation)
+                })
+              } else if (annotation.type === "file") {
+                accumulatedFileAnnotations.push(annotation)
+              }
             }
           }
-        }
 
-        const toolCalls = delta.tool_calls
-        if (Predicate.isNotNullish(toolCalls)) {
-          for (const toolCall of toolCalls) {
-            const index = toolCall.index ?? toolCalls.length - 1
-            let activeToolCall = activeToolCalls[index]
-
-            // Tool call start - OpenRouter returns all information except the
-            // tool call parameters in the first chunk
-            if (Predicate.isUndefined(activeToolCall)) {
-              if (toolCall.type !== "function") {
-                return yield* AiError.make({
-                  module: "OpenRouterLanguageModel",
-                  method: "makeStreamResponse",
-                  reason: new AiError.InvalidOutputError({
-                    description: "Received tool call delta that was not of type: 'function'"
+          const toolCalls = delta.tool_calls
+          if (Predicate.isNotNullish(toolCalls)) {
+            for (const toolCall of toolCalls) {
+              const index = toolCall.index ?? toolCalls.length - 1
+              let activeToolCall = activeToolCalls[index]
+
+              // Tool call start - OpenRouter returns all information except the
+              // tool call parameters in the first chunk
+              if (Predicate.isUndefined(activeToolCall)) {
+                if (toolCall.type !== "function") {
+                  return yield* AiError.make({
+                    module: "OpenRouterLanguageModel",
+                    method: "makeStreamResponse",
+                    reason: new AiError.InvalidOutputError({
+                      description: "Received tool call delta that was not of type: 'function'"
+                    })
                   })
-                })
-              }
+                }
 
-              if (Predicate.isUndefined(toolCall.id)) {
-                return yield* AiError.make({
-                  module: "OpenRouterLanguageModel",
-                  method: "makeStreamResponse",
-                  reason: new AiError.InvalidOutputError({
-                    description: "Received tool call delta without a tool call identifier"
+                if (Predicate.isNullish(toolCall.id)) {
+                  return yield* AiError.make({
+                    module: "OpenRouterLanguageModel",
+                    method: "makeStreamResponse",
+                    reason: new AiError.InvalidOutputError({
+                      description: "Received tool call delta without a tool call identifier"
+                    })
                   })
-                })
-              }
+                }
 
-              if (Predicate.isUndefined(toolCall.function?.name)) {
-                return yield* AiError.make({
-                  module: "OpenRouterLanguageModel",
-                  method: "makeStreamResponse",
-                  reason: new AiError.InvalidOutputError({
-                    description: "Received tool call delta without a tool call name"
+                if (Predicate.isNullish(toolCall.function?.name)) {
+                  return yield* AiError.make({
+                    module: "OpenRouterLanguageModel",
+                    method: "makeStreamResponse",
+                    reason: new AiError.InvalidOutputError({
+                      description: "Received tool call delta without a tool call name"
+                    })
                   })
-                })
-              }
+                }
 
-              activeToolCall = {
-                id: toolCall.id,
-                type: "function",
-                name: toolCall.function.name,
-                params: toolCall.function.arguments ?? ""
-              }
+                activeToolCall = {
+                  id: toolCall.id,
+                  type: "function",
+                  name: toolCall.function.name,
+                  params: toolCall.function.arguments ?? ""
+                }
 
-              activeToolCalls[index] = activeToolCall
+                activeToolCalls[index] = activeToolCall
 
-              parts.push({
-                type: "tool-params-start",
-                id: activeToolCall.id,
-                name: activeToolCall.name
-              })
+                parts.push({
+                  type: "tool-params-start",
+                  id: activeToolCall.id,
+                  name: activeToolCall.name
+                })
 
-              // Emit a tool call delta part if parameters were also sent
-              if (activeToolCall.params.length > 0) {
+                // Emit a tool call delta part if parameters were also sent
+                if (activeToolCall.params.length > 0) {
+                  parts.push({
+                    type: "tool-params-delta",
+                    id: activeToolCall.id,
+                    delta: activeToolCall.params
+                  })
+                }
+              } else {
+                // If an active tool call was found, update and emit the delta for
+                // the tool call's parameters
+                activeToolCall.params += toolCall.function?.arguments ?? ""
                 parts.push({
                   type: "tool-params-delta",
                   id: activeToolCall.id,
                   delta: activeToolCall.params
                 })
               }
-            } else {
-              // If an active tool call was found, update and emit the delta for
-              // the tool call's parameters
-              activeToolCall.params += toolCall.function?.arguments ?? ""
-              parts.push({
-                type: "tool-params-delta",
-                id: activeToolCall.id,
-                delta: activeToolCall.params
-              })
-            }
 
-            // Check if the tool call is complete
-            // @effect-diagnostics-next-line tryCatchInEffectGen:off
-            try {
-              const params = Tool.unsafeSecureJsonParse(activeToolCall.params)
+              // Check if the tool call is complete
+              // @effect-diagnostics-next-line tryCatchInEffectGen:off
+              try {
+                const params = Tool.unsafeSecureJsonParse(activeToolCall.params)
 
-              parts.push({
-                type: "tool-params-end",
-                id: activeToolCall.id
-              })
+                parts.push({
+                  type: "tool-params-end",
+                  id: activeToolCall.id
+                })
 
-              parts.push({
-                type: "tool-call",
-                id: activeToolCall.id,
-                name: activeToolCall.name,
-                params,
-                // Only attach reasoning_details to the first tool call to avoid
-                // duplicating thinking blocks for parallel tool calls (Claude)
-                metadata: reasoningDetailsAttachedToToolCall ? undefined : {
-                  openrouter: { reasoningDetails: accumulatedReasoningDetails }
-                }
-              })
+                parts.push({
+                  type: "tool-call",
+                  id: activeToolCall.id,
+                  name: activeToolCall.name,
+                  params,
+                  // Only attach reasoning_details to the first tool call to avoid
+                  // duplicating thinking blocks for parallel tool calls (Claude)
+                  metadata: reasoningDetailsAttachedToToolCall ? undefined : {
+                    openrouter: { reasoningDetails: accumulatedReasoningDetails }
+                  }
+                })
 
-              reasoningDetailsAttachedToToolCall = true
+                reasoningDetailsAttachedToToolCall = true
 
-              // Increment the total tool calls emitted by the stream and
-              // remove the active tool call
-              totalToolCalls += 1
-              delete activeToolCalls[toolCall.index]
-            } catch {
-              // Tool call incomplete, continue parsing
-              continue
+                // Increment the total tool calls emitted by the stream and
+                // remove the active tool call
+                totalToolCalls += 1
+                delete activeToolCalls[toolCall.index]
+              } catch {
+                // Tool call incomplete, continue parsing
+                continue
+              }
             }
           }
-        }
 
-        const images = delta.images
-        if (Predicate.isNotNullish(images)) {
-          for (const image of images) {
-            parts.push({
-              type: "file",
-              mediaType: getMediaType(image.image_url.url, "image/jpeg"),
-              data: getBase64FromDataUrl(image.image_url.url)
-            })
+          const images = delta.images
+          if (Predicate.isNotNullish(images)) {
+            for (const image of images) {
+              parts.push({
+                type: "file",
+                mediaType: getMediaType(image.image_url.url, "image/jpeg"),
+                data: getBase64FromDataUrl(image.image_url.url)
+              })
+            }
           }
         }
 
@@ -1180,7 +1172,7 @@ const makeStreamResponse = Effect.fnUntraced(
 
           // Forward any unsent tool calls if finish reason is 'tool-calls'
           if (finishReason === "tool-calls") {
-            for (const toolCall of activeToolCalls) {
+            for (const toolCall of Object.values(activeToolCalls)) {
               // Coerce invalid tool call parameters to an empty object
               let params: unknown
               // @effect-diagnostics-next-line tryCatchInEffectGen:off