@effect/ai-openrouter 0.8.3 → 4.0.0-beta.0

package/dist/esm/OpenRouterLanguageModel.js

@@ -1,814 +0,0 @@
-/**
- * @since 1.0.0
- */
-import * as AiError from "@effect/ai/AiError";
-import * as LanguageModel from "@effect/ai/LanguageModel";
-import * as AiModel from "@effect/ai/Model";
-import { addGenAIAnnotations } from "@effect/ai/Telemetry";
-import * as Tool from "@effect/ai/Tool";
-import * as Arr from "effect/Array";
-import * as Context from "effect/Context";
-import * as DateTime from "effect/DateTime";
-import * as Effect from "effect/Effect";
-import * as Encoding from "effect/Encoding";
-import { dual } from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as Predicate from "effect/Predicate";
-import * as Stream from "effect/Stream";
-import * as InternalUtilities from "./internal/utilities.js";
-import { OpenRouterClient } from "./OpenRouterClient.js";
-// =============================================================================
-// Configuration
-// =============================================================================
-/**
- * @since 1.0.0
- * @category Context
- */
-export class Config extends /*#__PURE__*/Context.Tag("@effect/ai-openrouter/OpenRouterLanguageModel/Config")() {
-  /**
-   * @since 1.0.0
-   */
-  static getOrUndefined = /*#__PURE__*/Effect.map(/*#__PURE__*/Effect.context(), context => context.unsafeMap.get(Config.key));
-}
-// =============================================================================
-// OpenRouter Language Model
-// =============================================================================
-/**
- * @since 1.0.0
- * @category Ai Models
- */
-export const model = (model, config) => AiModel.make("openrouter", layer({
-  model,
-  config
-}));
-/**
- * @since 1.0.0
- * @category Constructors
- */
-export const make = /*#__PURE__*/Effect.fnUntraced(function* (options) {
-  const client = yield* OpenRouterClient;
-  const makeRequest = Effect.fnUntraced(function* (providerOptions) {
-    const context = yield* Effect.context();
-    const config = {
-      model: options.model,
-      ...options.config,
-      ...context.unsafeMap.get(Config.key)
-    };
-    const messages = yield* prepareMessages(providerOptions);
-    const {
-      toolChoice,
-      tools
-    } = yield* prepareTools(providerOptions);
-    const responseFormat = providerOptions.responseFormat;
-    const request = {
-      ...config,
-      messages,
-      tools,
-      tool_choice: toolChoice,
-      response_format: responseFormat.type === "text" ? undefined : {
-        type: "json_schema",
-        json_schema: {
-          name: responseFormat.objectName,
-          description: Tool.getDescriptionFromSchemaAst(responseFormat.schema.ast) ?? "Respond with a JSON object",
-          schema: Tool.getJsonSchemaFromSchemaAst(responseFormat.schema.ast),
-          strict: true
-        }
-      }
-    };
-    return request;
-  });
-  return yield* LanguageModel.make({
-    generateText: Effect.fnUntraced(function* (options) {
-      const request = yield* makeRequest(options);
-      annotateRequest(options.span, request);
-      const rawResponse = yield* client.createChatCompletion(request);
-      annotateResponse(options.span, rawResponse);
-      return yield* makeResponse(rawResponse);
-    }),
-    streamText: Effect.fnUntraced(function* (options) {
-      const request = yield* makeRequest(options);
-      annotateRequest(options.span, request);
-      return client.createChatCompletionStream(request);
-    }, (effect, options) => effect.pipe(Effect.flatMap(stream => makeStreamResponse(stream)), Stream.unwrap, Stream.map(response => {
-      annotateStreamResponse(options.span, response);
-      return response;
-    })))
-  });
-});
-/**
- * @since 1.0.0
- * @category Layers
- */
-export const layer = options => Layer.effect(LanguageModel.LanguageModel, make({
-  model: options.model,
-  config: options.config
-}));
-/**
- * @since 1.0.0
- * @category Configuration
- */
-export const withConfigOverride = /*#__PURE__*/dual(2, (self, overrides) => Effect.flatMap(Config.getOrUndefined, config => Effect.provideService(self, Config, {
-  ...config,
-  ...overrides
-})));
-// =============================================================================
-// Prompt Conversion
-// =============================================================================
-const prepareMessages = /*#__PURE__*/Effect.fnUntraced(function* (options) {
-  const messages = [];
-  for (const message of options.prompt.content) {
-    switch (message.role) {
-      case "system":
-        {
-          messages.push({
-            role: "system",
-            content: message.content,
-            cache_control: getCacheControl(message)
-          });
-          break;
-        }
-      case "user":
-        {
-          if (message.content.length === 1 && message.content[0].type === "text") {
-            const part = message.content[0];
-            const cacheControl = getCacheControl(message) ?? getCacheControl(part);
-            messages.push({
-              role: "user",
-              content: Predicate.isNotUndefined(cacheControl) ? [{
-                type: "text",
-                text: part.text,
-                cache_control: cacheControl
-              }] : part.text
-            });
-          } else {
-            const content = [];
-            const messageCacheControl = getCacheControl(message);
-            for (const part of message.content) {
-              const partCacheControl = getCacheControl(part);
-              const cacheControl = partCacheControl ?? messageCacheControl;
-              switch (part.type) {
-                case "text":
-                  {
-                    content.push({
-                      type: "text",
-                      text: part.text,
-                      cache_control: cacheControl
-                    });
-                    break;
-                  }
-                case "file":
-                  {
-                    if (part.mediaType.startsWith("image/")) {
-                      const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
-                      content.push({
-                        type: "image_url",
-                        image_url: {
-                          url: part.data instanceof URL ? part.data.toString() : part.data instanceof Uint8Array ? `data:${mediaType};base64,${Encoding.encodeBase64(part.data)}` : part.data
-                        },
-                        cache_control: cacheControl
-                      });
-                    } else {
-                      const options = part.options.openrouter;
-                      const fileName = options?.fileName ?? part.fileName ?? "";
-                      content.push({
-                        type: "file",
-                        file: {
-                          filename: fileName,
-                          file_data: part.data instanceof URL ? part.data.toString() : part.data instanceof Uint8Array ? `data:${part.mediaType};base64,${Encoding.encodeBase64(part.data)}` : part.data
-                        },
-                        cache_control: part.data instanceof URL ? cacheControl : undefined
-                      });
-                    }
-                    break;
-                  }
-              }
-            }
-            messages.push({
-              role: "user",
-              content
-            });
-          }
-          break;
-        }
-      case "assistant":
-        {
-          let text = "";
-          let reasoning = "";
-          const reasoningDetails = [];
-          const toolCalls = [];
-          const cacheControl = getCacheControl(message);
-          for (const part of message.content) {
-            switch (part.type) {
-              case "text":
-                {
-                  text += part.text;
-                  break;
-                }
-              case "reasoning":
-                {
-                  reasoning += part.text;
-                  reasoningDetails.push({
-                    type: "reasoning.text",
-                    text: part.text
-                  });
-                  break;
-                }
-              case "tool-call":
-                {
-                  toolCalls.push({
-                    id: part.id,
-                    type: "function",
-                    function: {
-                      name: part.name,
-                      arguments: JSON.stringify(part.params)
-                    }
-                  });
-                  break;
-                }
-            }
-          }
-          messages.push({
-            role: "assistant",
-            content: text,
-            tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
-            reasoning: reasoning.length > 0 ? reasoning : undefined,
-            reasoning_details: reasoningDetails.length > 0 ? reasoningDetails : undefined,
-            cache_control: cacheControl
-          });
-          break;
-        }
-      case "tool":
-        {
-          const cacheControl = getCacheControl(message);
-          for (const part of message.content) {
-            messages.push({
-              role: "tool",
-              tool_call_id: part.id,
-              content: JSON.stringify(part.result),
-              cache_control: cacheControl
-            });
-          }
-          break;
-        }
-    }
-  }
-  return messages;
-});
-// =============================================================================
-// Tool Conversion
-// =============================================================================
-const prepareTools = /*#__PURE__*/Effect.fnUntraced(function* (options) {
-  if (options.tools.length === 0) {
-    return {
-      tools: undefined,
-      toolChoice: undefined
-    };
-  }
-  const hasProviderDefinedTools = options.tools.some(tool => Tool.isProviderDefined(tool));
-  if (hasProviderDefinedTools) {
-    return yield* new AiError.MalformedInput({
-      module: "OpenRouterLanguageModel",
-      method: "prepareTools",
-      description: "Provider-defined tools are unsupported by the OpenRouter " + "provider integration at this time"
-    });
-  }
-  let tools = [];
-  let toolChoice = undefined;
-  for (const tool of options.tools) {
-    tools.push({
-      type: "function",
-      function: {
-        name: tool.name,
-        description: Tool.getDescription(tool),
-        parameters: Tool.getJsonSchema(tool),
-        strict: true
-      }
-    });
-  }
-  if (options.toolChoice === "none") {
-    toolChoice = "none";
-  } else if (options.toolChoice === "auto") {
-    toolChoice = "auto";
-  } else if (options.toolChoice === "required") {
-    toolChoice = "required";
-  } else if ("tool" in options.toolChoice) {
-    toolChoice = {
-      type: "function",
-      function: {
-        name: options.toolChoice.tool
-      }
-    };
-  } else {
-    const allowedTools = new Set(options.toolChoice.oneOf);
-    tools = tools.filter(tool => allowedTools.has(tool.function.name));
-    toolChoice = options.toolChoice.mode === "auto" ? "auto" : "required";
-  }
-  return {
-    tools,
-    toolChoice
-  };
-});
-// =============================================================================
-// Response Conversion
-// =============================================================================
-const makeResponse = /*#__PURE__*/Effect.fnUntraced(function* (response) {
-  const choice = response.choices[0];
-  if (Predicate.isUndefined(choice)) {
-    return yield* new AiError.MalformedOutput({
-      module: "OpenRouterLanguageModel",
-      method: "makeResponse",
-      description: "Received response with no valid choices"
-    });
-  }
-  const parts = [];
-  const message = choice.message;
-  const createdAt = new Date(response.created * 1000);
-  parts.push({
-    type: "response-metadata",
-    id: response.id,
-    modelId: response.model,
-    timestamp: DateTime.formatIso(DateTime.unsafeFromDate(createdAt))
-  });
-  if (Predicate.isNotNullable(message.reasoning) && message.reasoning.length > 0) {
-    parts.push({
-      type: "reasoning",
-      text: message.reasoning
-    });
-  }
-  if (Predicate.isNotNullable(message.reasoning_details) && message.reasoning_details.length > 0) {
-    for (const detail of message.reasoning_details) {
-      switch (detail.type) {
-        case "reasoning.summary":
-          {
-            if (Predicate.isNotUndefined(detail.summary) && detail.summary.length > 0) {
-              parts.push({
-                type: "reasoning",
-                text: detail.summary
-              });
-            }
-            break;
-          }
-        case "reasoning.encrypted":
-          {
-            if (Predicate.isNotUndefined(detail.data) && detail.data.length > 0) {
-              parts.push({
-                type: "reasoning",
-                text: "",
-                metadata: {
-                  openrouter: {
-                    type: "encrypted_reasoning",
-                    format: detail.format,
-                    redactedData: detail.data
-                  }
-                }
-              });
-            }
-            break;
-          }
-        case "reasoning.text":
-          {
-            if (Predicate.isNotUndefined(detail.text) && detail.text.length > 0) {
-              parts.push({
-                type: "reasoning",
-                text: detail.text,
-                metadata: {
-                  openrouter: {
-                    type: "reasoning",
-                    signature: detail.signature
-                  }
-                }
-              });
-            }
-            break;
-          }
-      }
-    }
-  }
-  if (Predicate.isNotNullable(message.content) && message.content.length > 0) {
-    parts.push({
-      type: "text",
-      text: message.content
-    });
-  }
-  if (Predicate.isNotNullable(message.tool_calls)) {
-    for (const toolCall of message.tool_calls) {
-      const toolName = toolCall.function.name;
-      const toolParams = toolCall.function.arguments;
-      const params = yield* Effect.try({
-        try: () => Tool.unsafeSecureJsonParse(toolParams),
-        catch: cause => new AiError.MalformedOutput({
-          module: "OpenRouterLanguageModel",
-          method: "makeResponse",
-          description: "Failed to securely parse tool call parameters " + `for tool '${toolName}':\nParameters: ${toolParams}`,
-          cause
-        })
-      });
-      parts.push({
-        type: "tool-call",
-        id: toolCall.id,
-        name: toolName,
-        params
-      });
-    }
-  }
-  if (Predicate.isNotNullable(message.annotations)) {
-    for (const annotation of message.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: {
-              content: annotation.url_citation.content
-            }
-          }
-        });
-      }
-    }
-  }
-  if (Predicate.isNotNullable(message.images)) {
-    for (const image of message.images) {
-      parts.push({
-        type: "file",
-        mediaType: getMediaType(image.image_url.url) ?? "image/jpeg",
-        data: getBase64FromDataUrl(image.image_url.url)
-      });
-    }
-  }
-  parts.push({
-    type: "finish",
-    reason: InternalUtilities.resolveFinishReason(choice.finish_reason),
-    usage: {
-      inputTokens: response.usage?.prompt_tokens,
-      outputTokens: response.usage?.completion_tokens,
-      totalTokens: response.usage?.total_tokens,
-      reasoningTokens: response.usage?.completion_tokens_details?.reasoning_tokens,
-      cachedInputTokens: response.usage?.prompt_tokens_details?.cached_tokens
-    },
-    metadata: {
-      openrouter: {
-        provider: response.provider,
-        usage: {
-          cost: response.usage?.cost,
-          promptTokensDetails: response.usage?.prompt_tokens_details,
-          completionTokensDetails: response.usage?.completion_tokens_details,
-          costDetails: response.usage?.cost_details
-        }
-      }
-    }
-  });
-  return parts;
-});
-const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* (stream) {
-  let idCounter = 0;
-  let activeTextId = undefined;
-  let activeReasoningId = undefined;
-  let finishReason = "unknown";
-  let responseMetadataEmitted = false;
-  const activeToolCalls = {};
-  return stream.pipe(Stream.mapEffect(Effect.fnUntraced(function* (event) {
-    const parts = [];
-    if ("error" in event) {
-      parts.push({
-        type: "error",
-        error: event.error
-      });
-      return parts;
-    }
-    // Response Metadata
-    if (Predicate.isNotUndefined(event.id) && !responseMetadataEmitted) {
-      parts.push({
-        type: "response-metadata",
-        id: event.id,
-        modelId: event.model,
-        timestamp: DateTime.formatIso(yield* DateTime.now)
-      });
-      responseMetadataEmitted = true;
-    }
-    const choice = event.choices[0];
-    if (Predicate.isUndefined(choice)) {
-      return yield* new AiError.MalformedOutput({
-        module: "OpenRouterLanguageModel",
-        method: "makeResponse",
-        description: "Received response with no valid choices"
-      });
-    }
-    const delta = choice.delta;
-    if (Predicate.isUndefined(delta)) {
-      return parts;
-    }
-    // Reasoning Parts
-    const emitReasoningPart = (delta, metadata = undefined) => {
-      // End in-progress text part if present before starting reasoning
-      if (Predicate.isNotUndefined(activeTextId)) {
-        parts.push({
-          type: "text-end",
-          id: activeTextId
-        });
-        activeTextId = undefined;
-      }
-      // Start a new reasoning part if necessary
-      if (Predicate.isUndefined(activeReasoningId)) {
-        activeReasoningId = (idCounter++).toString();
-        parts.push({
-          type: "reasoning-start",
-          id: activeReasoningId,
-          metadata: {
-            openrouter: metadata
-          }
-        });
-      }
-      // Emit the reasoning delta
-      parts.push({
-        type: "reasoning-delta",
-        id: activeReasoningId,
-        delta,
-        metadata: {
-          openrouter: metadata
-        }
-      });
-    };
-    if (Predicate.isNotNullable(delta.reasoning_details) && delta.reasoning_details.length > 0) {
-      for (const detail of delta.reasoning_details) {
-        switch (detail.type) {
-          case "reasoning.summary":
-            {
-              if (Predicate.isNotUndefined(detail.summary) && detail.summary.length > 0) {
-                emitReasoningPart(detail.summary);
-              }
-              break;
-            }
-          case "reasoning.encrypted":
-            {
-              if (Predicate.isNotUndefined(detail.data) && detail.data.length > 0) {
-                emitReasoningPart("", {
-                  type: "encrypted_reasoning",
-                  format: detail.format,
-                  redactedData: detail.data
-                });
-              }
-              break;
-            }
-          case "reasoning.text":
-            {
-              if (Predicate.isNotUndefined(detail.text) && detail.text.length > 0) {
-                emitReasoningPart(detail.text, {
-                  type: "reasoning",
-                  signature: detail.signature
-                });
-              }
-              break;
-            }
-        }
-      }
-    } else if (Predicate.isNotNullable(delta.reasoning) && delta.reasoning.length > 0) {
-      emitReasoningPart(delta.reasoning);
-    }
-    // Text Parts
-    if (Predicate.isNotNullable(delta.content) && delta.content.length > 0) {
-      // End in-progress reasoning part if present before starting text
-      if (Predicate.isNotUndefined(activeReasoningId)) {
-        parts.push({
-          type: "reasoning-end",
-          id: activeReasoningId
-        });
-        activeReasoningId = undefined;
-      }
-      // Start a new text part if necessary
-      if (Predicate.isUndefined(activeTextId)) {
-        activeTextId = (idCounter++).toString();
-        parts.push({
-          type: "text-start",
-          id: activeTextId
-        });
-      }
-      // Emit the text delta
-      parts.push({
-        type: "text-delta",
-        id: activeTextId,
-        delta: delta.content
-      });
-    }
-    // Source Parts
-    if (Predicate.isNotNullable(delta.annotations)) {
-      for (const annotation of delta.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: {
-                content: annotation.url_citation.content
-              }
-            }
-          });
-        }
-      }
-    }
-    // Tool Call Parts
-    if (Predicate.isNotNullable(delta.tool_calls) && delta.tool_calls.length > 0) {
-      for (const toolCall of delta.tool_calls) {
-        // Get the active tool call, if present
-        let activeToolCall = activeToolCalls[toolCall.index];
-        // If no active tool call was found, start a new active tool call
-        if (Predicate.isUndefined(activeToolCall)) {
-          // The tool call id and function name always come back with the
-          // first tool call delta
-          activeToolCall = {
-            index: toolCall.index,
-            id: toolCall.id,
-            name: toolCall.function.name,
-            params: toolCall.function.arguments ?? ""
-          };
-          activeToolCalls[toolCall.index] = activeToolCall;
-          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) {
-            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
-        try {
-          const params = Tool.unsafeSecureJsonParse(activeToolCall.params);
-          parts.push({
-            type: "tool-params-end",
-            id: activeToolCall.id
-          });
-          parts.push({
-            type: "tool-call",
-            id: activeToolCall.id,
-            name: activeToolCall.name,
-            params
-          });
-          delete activeToolCalls[toolCall.index];
-        } catch {
-          // Tool call incomplete, continue parsing
-          continue;
-        }
-      }
-    }
-    // File Parts
-    if (Predicate.isNotNullable(delta.images)) {
-      for (const image of delta.images) {
-        parts.push({
-          type: "file",
-          mediaType: getMediaType(image.image_url.url) ?? "image/jpeg",
-          data: getBase64FromDataUrl(image.image_url.url)
-        });
-      }
-    }
-    // Finish Parts
-    if (Predicate.isNotNullable(choice.finish_reason)) {
-      finishReason = InternalUtilities.resolveFinishReason(choice.finish_reason);
-    }
-    // Usage is only emitted by the last part of the stream, so we need to
-    // handle flushing any remaining text / reasoning / tool calls
-    if (Predicate.isNotUndefined(event.usage)) {
-      // Complete any remaining tool calls if the finish reason is tool-calls
-      if (finishReason === "tool-calls") {
-        for (const toolCall of Object.values(activeToolCalls)) {
-          // Coerce invalid tool call parameters to an empty object
-          const params = yield* Effect.try(() => Tool.unsafeSecureJsonParse(toolCall.params)).pipe(Effect.catchAll(() => Effect.succeed({})));
-          parts.push({
-            type: "tool-params-end",
-            id: toolCall.id
-          });
-          parts.push({
-            type: "tool-call",
-            id: toolCall.id,
-            name: toolCall.name,
-            params
-          });
-          delete activeToolCalls[toolCall.index];
-        }
-      }
-      // Flush remaining reasoning parts
-      if (Predicate.isNotUndefined(activeReasoningId)) {
-        parts.push({
-          type: "reasoning-end",
-          id: activeReasoningId
-        });
-        activeReasoningId = undefined;
-      }
-      // Flush remaining text parts
-      if (Predicate.isNotUndefined(activeTextId)) {
-        parts.push({
-          type: "text-end",
-          id: activeTextId
-        });
-        activeTextId = undefined;
-      }
-      parts.push({
-        type: "finish",
-        reason: finishReason,
-        usage: {
-          inputTokens: event.usage?.prompt_tokens,
-          outputTokens: event.usage?.completion_tokens,
-          totalTokens: event.usage?.total_tokens,
-          reasoningTokens: event.usage?.completion_tokens_details?.reasoning_tokens,
-          cachedInputTokens: event.usage?.prompt_tokens_details?.cached_tokens
-        },
-        metadata: {
-          openrouter: {
-            provider: event.provider,
-            usage: {
-              cost: event.usage?.cost,
-              promptTokensDetails: event.usage?.prompt_tokens_details,
-              completionTokensDetails: event.usage?.completion_tokens_details,
-              costDetails: event.usage?.cost_details
-            }
-          }
-        }
-      });
-    }
-    return parts;
-  })), Stream.flattenIterables);
-});
-// =============================================================================
-// Telemetry
-// =============================================================================
-const annotateRequest = (span, request) => {
-  addGenAIAnnotations(span, {
-    system: "openrouter",
-    operation: {
-      name: "chat"
-    },
-    request: {
-      model: request.model,
-      temperature: request.temperature,
-      topP: request.top_p,
-      maxTokens: request.max_tokens,
-      stopSequences: Arr.ensure(request.stop).filter(Predicate.isNotNullable)
-    }
-  });
-};
-const annotateResponse = (span, response) => {
-  addGenAIAnnotations(span, {
-    response: {
-      id: response.id,
-      model: response.model,
-      finishReasons: response.choices.map(choice => choice.finish_reason).filter(Predicate.isNotNullable)
-    },
-    usage: {
-      inputTokens: response.usage?.prompt_tokens,
-      outputTokens: response.usage?.completion_tokens
-    }
-  });
-};
-const annotateStreamResponse = (span, part) => {
-  if (part.type === "response-metadata") {
-    addGenAIAnnotations(span, {
-      response: {
-        id: part.id,
-        model: part.modelId
-      }
-    });
-  }
-  if (part.type === "finish") {
-    addGenAIAnnotations(span, {
-      response: {
-        finishReasons: [part.reason]
-      },
-      usage: {
-        inputTokens: part.usage.inputTokens,
-        outputTokens: part.usage.outputTokens
-      }
-    });
-  }
-};
-// =============================================================================
-// Utilities
-// =============================================================================
-const getCacheControl = part => part.options.openrouter?.cacheControl;
-const getMediaType = dataUrl => {
-  const match = dataUrl.match(/^data:([^;]+)/);
-  return match ? match[1] : undefined;
-};
-const getBase64FromDataUrl = dataUrl => {
-  const match = dataUrl.match(/^data:[^;]*;base64,(.+)$/);
-  return match ? match[1] : dataUrl;
-};
-//# sourceMappingURL=OpenRouterLanguageModel.js.map