@elizaos/plugin-openrouter 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/node/index.node.js

@@ -0,0 +1,1053 @@
+// plugin.ts
+import {
+  logger as logger5,
+  ModelType as ModelType5
+} from "@elizaos/core";
+
+// init.ts
+import { logger } from "@elizaos/core";
+
+// utils/config.ts
+var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+var DEFAULT_SMALL_MODEL = "google/gemini-2.5-flash-lite";
+var DEFAULT_LARGE_MODEL = "google/gemini-2.5-flash";
+var DEFAULT_IMAGE_MODEL = "x-ai/grok-2-vision-1212";
+var DEFAULT_IMAGE_GENERATION_MODEL = "google/gemini-2.5-flash-image-preview";
+var DEFAULT_EMBEDDING_MODEL = "openai/text-embedding-3-small";
+var DEFAULT_TRANSCRIPTION_MODEL = "openai/whisper-large-v3";
+var DEFAULT_EMBEDDING_DIMENSIONS = 1536;
+function getEnvValue(key) {
+  if (typeof process === "undefined" || !process.env) {
+    return;
+  }
+  const value = process.env[key];
+  return value === undefined ? undefined : String(value);
+}
+function getSetting(runtime, key, defaultValue) {
+  const value = runtime.getSetting(key);
+  if (value !== undefined && value !== null) {
+    return String(value);
+  }
+  return getEnvValue(key) ?? defaultValue;
+}
+function getBaseURL(runtime) {
+  const browserURL = getSetting(runtime, "OPENROUTER_BROWSER_BASE_URL");
+  if (typeof globalThis !== "undefined" && globalThis.document && browserURL) {
+    return browserURL;
+  }
+  return getSetting(runtime, "OPENROUTER_BASE_URL", DEFAULT_BASE_URL) || DEFAULT_BASE_URL;
+}
+function getApiKey(runtime) {
+  return getSetting(runtime, "OPENROUTER_API_KEY");
+}
+function getSmallModel(runtime) {
+  return getSetting(runtime, "OPENROUTER_SMALL_MODEL") ?? getSetting(runtime, "SMALL_MODEL", DEFAULT_SMALL_MODEL) ?? DEFAULT_SMALL_MODEL;
+}
+function getNanoModel(runtime) {
+  return getSetting(runtime, "OPENROUTER_NANO_MODEL") ?? getSetting(runtime, "NANO_MODEL") ?? getSmallModel(runtime);
+}
+function getMediumModel(runtime) {
+  return getSetting(runtime, "OPENROUTER_MEDIUM_MODEL") ?? getSetting(runtime, "MEDIUM_MODEL") ?? getSmallModel(runtime);
+}
+function getLargeModel(runtime) {
+  return getSetting(runtime, "OPENROUTER_LARGE_MODEL") ?? getSetting(runtime, "LARGE_MODEL", DEFAULT_LARGE_MODEL) ?? DEFAULT_LARGE_MODEL;
+}
+function getMegaModel(runtime) {
+  return getSetting(runtime, "OPENROUTER_MEGA_MODEL") ?? getSetting(runtime, "MEGA_MODEL") ?? getLargeModel(runtime);
+}
+function getResponseHandlerModel(runtime) {
+  return getSetting(runtime, "OPENROUTER_RESPONSE_HANDLER_MODEL") ?? getSetting(runtime, "OPENROUTER_SHOULD_RESPOND_MODEL") ?? getSetting(runtime, "RESPONSE_HANDLER_MODEL") ?? getSetting(runtime, "SHOULD_RESPOND_MODEL") ?? getNanoModel(runtime);
+}
+function getActionPlannerModel(runtime) {
+  return getSetting(runtime, "OPENROUTER_ACTION_PLANNER_MODEL") ?? getSetting(runtime, "OPENROUTER_PLANNER_MODEL") ?? getSetting(runtime, "ACTION_PLANNER_MODEL") ?? getSetting(runtime, "PLANNER_MODEL") ?? getMediumModel(runtime);
+}
+function getImageModel(runtime) {
+  return getSetting(runtime, "OPENROUTER_IMAGE_MODEL") ?? getSetting(runtime, "IMAGE_MODEL", DEFAULT_IMAGE_MODEL) ?? DEFAULT_IMAGE_MODEL;
+}
+function getImageGenerationModel(runtime) {
+  return getSetting(runtime, "OPENROUTER_IMAGE_GENERATION_MODEL") ?? getSetting(runtime, "IMAGE_GENERATION_MODEL", DEFAULT_IMAGE_GENERATION_MODEL) ?? DEFAULT_IMAGE_GENERATION_MODEL;
+}
+function getEmbeddingModel(runtime) {
+  return getSetting(runtime, "OPENROUTER_EMBEDDING_MODEL") ?? getSetting(runtime, "EMBEDDING_MODEL", DEFAULT_EMBEDDING_MODEL) ?? DEFAULT_EMBEDDING_MODEL;
+}
+function getTranscriptionModel(runtime) {
+  return getSetting(runtime, "OPENROUTER_TRANSCRIPTION_MODEL") ?? getSetting(runtime, "TRANSCRIPTION_MODEL", DEFAULT_TRANSCRIPTION_MODEL) ?? DEFAULT_TRANSCRIPTION_MODEL;
+}
+function getEmbeddingDimensions(runtime) {
+  const setting = getSetting(runtime, "OPENROUTER_EMBEDDING_DIMENSIONS") ?? getSetting(runtime, "EMBEDDING_DIMENSIONS");
+  return setting ? parseInt(setting, 10) : DEFAULT_EMBEDDING_DIMENSIONS;
+}
+function shouldAutoCleanupImages(runtime) {
+  const setting = getSetting(runtime, "OPENROUTER_AUTO_CLEANUP_IMAGES", "false");
+  return setting?.toLowerCase() === "true";
+}
+
+// init.ts
+globalThis.AI_SDK_LOG_WARNINGS ??= false;
+function initializeOpenRouter(_config, runtime) {
+  (async () => {
+    try {
+      const isBrowser = typeof globalThis !== "undefined" && globalThis.document;
+      if (isBrowser) {
+        return;
+      }
+      if (!getApiKey(runtime)) {
+        logger.warn("OPENROUTER_API_KEY is not set in environment - OpenRouter functionality will be limited");
+        return;
+      }
+      const baseURL = getBaseURL(runtime);
+      const response = await fetch(`${baseURL}/models`, {
+        headers: { Authorization: `Bearer ${getApiKey(runtime)}` }
+      });
+      if (!response.ok) {
+        logger.warn(`OpenRouter API key validation failed: ${response.statusText}`);
+      } else {
+        logger.log("OpenRouter API key validated successfully");
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.warn(`Error validating OpenRouter API key: ${message}`);
+    }
+  })();
+}
+
+// models/audio.ts
+import { logger as logger2, ModelType } from "@elizaos/core";
+
+// utils/events.ts
+import { EventType } from "@elizaos/core";
+function emitModelUsageEvent(runtime, modelType, _prompt, usage, modelName, modelLabel) {
+  const inputTokens = usage.inputTokens ?? usage.promptTokens ?? 0;
+  const outputTokens = usage.outputTokens ?? usage.completionTokens ?? 0;
+  const totalTokens = usage.totalTokens ?? inputTokens + outputTokens;
+  const model = modelName?.trim() || modelLabel?.trim() || String(modelType);
+  runtime.emitEvent(EventType.MODEL_USED, {
+    runtime,
+    source: "openrouter",
+    provider: "openrouter",
+    type: modelType,
+    model,
+    modelName: model,
+    modelLabel: modelLabel ?? String(modelType),
+    tokens: {
+      prompt: inputTokens,
+      completion: outputTokens,
+      total: totalTokens
+    }
+  });
+  return {
+    promptTokens: inputTokens,
+    completionTokens: outputTokens,
+    totalTokens
+  };
+}
+
+// models/audio.ts
+function isBlobOrFile(value) {
+  if (typeof Blob !== "undefined" && value instanceof Blob)
+    return true;
+  return typeof File !== "undefined" && value instanceof File;
+}
+function isBuffer(value) {
+  return typeof Buffer !== "undefined" && Buffer.isBuffer(value);
+}
+function isCoreTranscriptionParams(value) {
+  return typeof value === "object" && value !== null && "audioUrl" in value && typeof value.audioUrl === "string";
+}
+function isOpenRouterTranscriptionParams(value) {
+  return typeof value === "object" && value !== null && "audio" in value && (isBlobOrFile(value.audio) || isBuffer(value.audio));
+}
+function audioFormatFromMimeType(mimeType) {
+  if (!mimeType?.startsWith("audio/"))
+    return null;
+  const subtype = mimeType.slice("audio/".length).split(";")[0]?.trim();
+  if (!subtype)
+    return null;
+  if (subtype === "mpeg")
+    return "mp3";
+  if (subtype === "x-wav")
+    return "wav";
+  return subtype;
+}
+function audioFormatFromUrl(url) {
+  const pathname = new URL(url).pathname;
+  const match = pathname.match(/\.([a-z0-9]+)$/i);
+  return match?.[1]?.toLowerCase() ?? null;
+}
+function detectBufferFormat(buffer) {
+  if (buffer.length >= 12 && buffer.toString("ascii", 0, 4) === "RIFF") {
+    return "wav";
+  }
+  if (buffer.length >= 4 && buffer.toString("ascii", 0, 4) === "OggS") {
+    return "ogg";
+  }
+  if (buffer.length >= 4 && buffer.toString("ascii", 0, 4) === "fLaC") {
+    return "flac";
+  }
+  if (buffer.length >= 3 && buffer.toString("ascii", 0, 3) === "ID3") {
+    return "mp3";
+  }
+  if (buffer.length >= 2 && buffer[0] === 255 && ((buffer[1] ?? 0) & 224) === 224) {
+    return "mp3";
+  }
+  return "webm";
+}
+function validateAudioUrl(url) {
+  const parsed = new URL(url);
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("TRANSCRIPTION audioUrl must use http or https");
+  }
+  return parsed.toString();
+}
+async function fetchAudioFromUrl(url) {
+  const audioUrl = validateAudioUrl(url);
+  const response = await fetch(audioUrl);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch audio from URL: ${audioUrl}`);
+  }
+  const bytes = Buffer.from(await response.arrayBuffer());
+  return {
+    base64: bytes.toString("base64"),
+    format: audioFormatFromMimeType(response.headers.get("content-type") ?? undefined) ?? audioFormatFromUrl(audioUrl) ?? detectBufferFormat(bytes)
+  };
+}
+async function encodeAudio(input) {
+  if (isBuffer(input)) {
+    return {
+      base64: input.toString("base64"),
+      format: detectBufferFormat(input)
+    };
+  }
+  const bytes = Buffer.from(await input.arrayBuffer());
+  return {
+    base64: bytes.toString("base64"),
+    format: audioFormatFromMimeType(input.type) ?? (typeof File !== "undefined" && input instanceof File ? audioFormatFromUrl(`https://local/${input.name}`) : null) ?? detectBufferFormat(bytes)
+  };
+}
+async function normalizeTranscriptionInput(input) {
+  if (typeof input === "string") {
+    const audio = await fetchAudioFromUrl(input);
+    return { audio: { data: audio.base64, format: audio.format } };
+  }
+  if (isBlobOrFile(input) || isBuffer(input)) {
+    const audio = await encodeAudio(input);
+    return { audio: { data: audio.base64, format: audio.format } };
+  }
+  if (isCoreTranscriptionParams(input)) {
+    const audio = await fetchAudioFromUrl(input.audioUrl);
+    return { audio: { data: audio.base64, format: audio.format } };
+  }
+  if (isOpenRouterTranscriptionParams(input)) {
+    const audio = await encodeAudio(input.audio);
+    return {
+      audio: {
+        data: audio.base64,
+        format: input.format ?? audioFormatFromMimeType(input.mimeType) ?? audio.format
+      },
+      ...input.language ? { language: input.language } : {},
+      ...input.model ? { model: input.model } : {},
+      ...input.temperature !== undefined ? { temperature: input.temperature } : {}
+    };
+  }
+  throw new Error("TRANSCRIPTION expects Buffer, Blob, File, URL string, or TranscriptionParams");
+}
+async function handleTranscription(runtime, input) {
+  const apiKey = getApiKey(runtime);
+  if (!apiKey) {
+    throw new Error("OPENROUTER_API_KEY is not set");
+  }
+  const normalized = await normalizeTranscriptionInput(input);
+  const modelName = normalized.model ?? getTranscriptionModel(runtime);
+  const baseURL = getBaseURL(runtime);
+  logger2.debug(`[OpenRouter] Using TRANSCRIPTION model: ${modelName}`);
+  const response = await fetch(`${baseURL}/audio/transcriptions`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: modelName,
+      input_audio: normalized.audio,
+      ...normalized.language ? { language: normalized.language } : {},
+      ...normalized.temperature !== undefined ? { temperature: normalized.temperature } : {}
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "Unknown error");
+    throw new Error(`OpenRouter transcription failed: ${response.status} ${response.statusText} - ${errorText}`);
+  }
+  const result = await response.json();
+  if (typeof result.text !== "string") {
+    throw new Error("OpenRouter transcription response did not include text");
+  }
+  if (result.usage) {
+    emitModelUsageEvent(runtime, ModelType.TRANSCRIPTION, "audio transcription", {
+      inputTokens: result.usage.input_tokens ?? 0,
+      outputTokens: result.usage.output_tokens ?? 0,
+      totalTokens: result.usage.total_tokens ?? 0
+    }, modelName);
+  }
+  return result.text;
+}
+
+// models/embedding.ts
+import { logger as logger3, ModelType as ModelType2, VECTOR_DIMS } from "@elizaos/core";
+async function handleTextEmbedding(runtime, params) {
+  const embeddingModelName = getEmbeddingModel(runtime);
+  const embeddingDimension = Number.parseInt(getSetting(runtime, "OPENROUTER_EMBEDDING_DIMENSIONS") ?? getSetting(runtime, "EMBEDDING_DIMENSIONS") ?? "1536", 10);
+  if (!Object.values(VECTOR_DIMS).includes(embeddingDimension)) {
+    const errorMsg = `Invalid embedding dimension: ${embeddingDimension}. Must be one of: ${Object.values(VECTOR_DIMS).join(", ")}`;
+    logger3.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  if (params === null) {
+    const testVector = Array(embeddingDimension).fill(0);
+    testVector[0] = 0.1;
+    return testVector;
+  }
+  let text;
+  if (typeof params === "string") {
+    text = params;
+  } else if (typeof params === "object" && typeof params.text === "string") {
+    text = params.text;
+  } else {
+    const errorMsg = "Invalid input format for embedding";
+    logger3.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  if (!text.trim()) {
+    const errorMsg = "Empty text for embedding";
+    logger3.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  const maxChars = 8000 * 4;
+  if (text.length > maxChars) {
+    logger3.warn(`[OpenRouter] Embedding input too long (~${Math.ceil(text.length / 4)} tokens), truncating to ~8000 tokens`);
+    text = text.slice(0, maxChars);
+  }
+  const apiKey = getApiKey(runtime);
+  if (!apiKey) {
+    const errorMsg = "OPENROUTER_API_KEY is not set";
+    logger3.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  const baseURL = getBaseURL(runtime);
+  try {
+    const response = await fetch(`${baseURL}/embeddings`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        "HTTP-Referer": getSetting(runtime, "OPENROUTER_HTTP_REFERER") || "",
+        "X-Title": getSetting(runtime, "OPENROUTER_X_TITLE") || "ElizaOS"
+      },
+      body: JSON.stringify({
+        model: embeddingModelName,
+        input: text
+      })
+    });
+    if (!response.ok) {
+      logger3.error(`OpenRouter API error: ${response.status} - ${response.statusText}`);
+      throw new Error(`OpenRouter API error: ${response.status} - ${response.statusText}`);
+    }
+    const data = await response.json();
+    const embedding = data.data?.[0]?.embedding;
+    if (!embedding) {
+      logger3.error("API returned invalid structure");
+      throw new Error("API returned invalid structure");
+    }
+    if (!Array.isArray(embedding) || embedding.length !== embeddingDimension) {
+      const errorMsg = `Embedding length ${embedding.length} does not match configured dimension ${embeddingDimension}`;
+      logger3.error(errorMsg);
+      throw new Error(errorMsg);
+    }
+    if (data.usage) {
+      const usage = {
+        inputTokens: data.usage.prompt_tokens,
+        outputTokens: 0,
+        totalTokens: data.usage.total_tokens
+      };
+      emitModelUsageEvent(runtime, ModelType2.TEXT_EMBEDDING, text, usage, embeddingModelName);
+    }
+    return embedding;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger3.error(`Error generating embedding: ${message}`);
+    throw error instanceof Error ? error : new Error(message);
+  }
+}
+
+// models/image.ts
+import { logger as logger4, ModelType as ModelType3 } from "@elizaos/core";
+import { generateText } from "ai";
+
+// providers/openrouter.ts
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+function createOpenRouterProvider(runtime) {
+  const apiKey = getApiKey(runtime);
+  const isBrowser = typeof globalThis !== "undefined" && globalThis.document;
+  const baseURL = getBaseURL(runtime);
+  return createOpenRouter({
+    apiKey: isBrowser ? undefined : apiKey,
+    baseURL
+  });
+}
+// models/image.ts
+var DEFAULT_IMAGE_DESCRIPTION_PROMPT = `Analyze this image and respond with:
+Title: <short title>
+Description: <detailed description>`;
+function parseTitle(content) {
+  const titleMatch = content.match(/title[:\s]+(.+?)(?:\n|$)/i);
+  if (titleMatch?.[1]) {
+    return titleMatch[1].trim();
+  }
+  const firstLine = content.split(`
+`).map((line) => line.trim()).find((line) => line.length > 0);
+  return firstLine ? firstLine.slice(0, 100) : "Image Analysis";
+}
+function parseDescription(content) {
+  const withoutTitle = content.replace(/title[:\s]+(.+?)(?:\n|$)/i, "").trim();
+  const withoutDescriptionLabel = withoutTitle.replace(/^description[:\s]+/i, "").trim();
+  return withoutDescriptionLabel.length > 0 ? withoutDescriptionLabel : content.trim();
+}
+async function handleImageDescription(runtime, params) {
+  const openrouter = createOpenRouterProvider(runtime);
+  const modelName = getImageModel(runtime);
+  const imageUrl = typeof params === "string" ? params : params.imageUrl;
+  const prompt = typeof params === "string" ? DEFAULT_IMAGE_DESCRIPTION_PROMPT : params.prompt ?? DEFAULT_IMAGE_DESCRIPTION_PROMPT;
+  if (!imageUrl || imageUrl.trim().length === 0) {
+    throw new Error("[OpenRouter] IMAGE_DESCRIPTION requires a valid image URL.");
+  }
+  try {
+    const generateParams = {
+      model: openrouter.chat(modelName),
+      messages: [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: prompt },
+            { type: "image", image: imageUrl }
+          ]
+        }
+      ]
+    };
+    const response = await generateText(generateParams);
+    if (response.usage) {
+      emitModelUsageEvent(runtime, ModelType3.IMAGE_DESCRIPTION, prompt, response.usage, modelName);
+    }
+    return {
+      title: parseTitle(response.text),
+      description: parseDescription(response.text)
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger4.error(`Error describing image: ${message}`);
+    throw error instanceof Error ? error : new Error(message);
+  }
+}
+async function handleImageGeneration(runtime, params) {
+  const openrouter = createOpenRouterProvider(runtime);
+  const modelName = getImageGenerationModel(runtime);
+  const prompt = params.prompt?.trim();
+  if (!prompt) {
+    throw new Error("[OpenRouter] IMAGE generation requires a non-empty prompt.");
+  }
+  try {
+    const generateParams = {
+      model: openrouter.chat(modelName),
+      prompt: `Generate an image: ${prompt}`
+    };
+    const response = await generateText(generateParams);
+    if (response.usage) {
+      emitModelUsageEvent(runtime, ModelType3.IMAGE, params.prompt, response.usage, modelName);
+    }
+    return {
+      imageUrl: response.text,
+      caption: prompt
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger4.error(`Error generating image: ${message}`);
+    throw error instanceof Error ? error : new Error(message);
+  }
+}
+
+// models/text.ts
+import {
+  buildCanonicalSystemPrompt,
+  dropDuplicateLeadingSystemMessage,
+  ModelType as ModelType4,
+  resolveEffectiveSystemPrompt
+} from "@elizaos/core";
+import {
+  generateText as generateText2,
+  jsonSchema,
+  streamText
+} from "ai";
+var RESPONSES_ROUTED_PREFIXES = ["openai/", "anthropic/"];
+var NO_SAMPLING_MODEL_PATTERNS = ["o1", "o3", "o4", "gpt-5", "gpt-5-mini"];
+var TEXT_NANO_MODEL_TYPE = ModelType4.TEXT_NANO;
+var TEXT_MEDIUM_MODEL_TYPE = ModelType4.TEXT_MEDIUM;
+var TEXT_MEGA_MODEL_TYPE = ModelType4.TEXT_MEGA;
+var RESPONSE_HANDLER_MODEL_TYPE = ModelType4.RESPONSE_HANDLER;
+var ACTION_PLANNER_MODEL_TYPE = ModelType4.ACTION_PLANNER;
+function buildUserContent(params, options = { includePrompt: true }) {
+  const content = [];
+  if (options.includePrompt !== false && typeof params.prompt === "string" && params.prompt.length > 0) {
+    content.push({ type: "text", text: params.prompt });
+  }
+  for (const attachment of params.attachments ?? []) {
+    content.push({
+      type: "file",
+      data: attachment.data,
+      mediaType: attachment.mediaType,
+      ...attachment.filename ? { filename: attachment.filename } : {}
+    });
+  }
+  return content;
+}
+function appendUserContentToMessages(messages, extraContent) {
+  if (extraContent.length === 0) {
+    return messages;
+  }
+  const lastUserIndex = messages.findLastIndex((message) => message.role === "user");
+  if (lastUserIndex === -1) {
+    return [...messages, { role: "user", content: extraContent }];
+  }
+  const nextMessages = [...messages];
+  const userMessage = nextMessages[lastUserIndex];
+  if (!userMessage) {
+    return messages;
+  }
+  const existingContent = userMessage.content;
+  const content = [
+    ...typeof existingContent === "string" ? [{ type: "text", text: existingContent }] : Array.isArray(existingContent) ? existingContent : [],
+    ...extraContent
+  ];
+  nextMessages[lastUserIndex] = {
+    ...userMessage,
+    content
+  };
+  return nextMessages;
+}
+function textFromMessages(messages) {
+  if (!messages || messages.length === 0)
+    return "";
+  return messages.map((message) => {
+    const content = message.content;
+    if (typeof content === "string")
+      return content;
+    if (!Array.isArray(content))
+      return "";
+    return content.map((part) => part && typeof part === "object" && ("text" in part) && typeof part.text === "string" ? part.text : "").filter(Boolean).join(`
+`);
+  }).filter(Boolean).join(`
+`);
+}
+function supportsSamplingParameters(modelName) {
+  const lowerModelName = modelName.toLowerCase();
+  if (RESPONSES_ROUTED_PREFIXES.some((prefix) => lowerModelName.startsWith(prefix))) {
+    return false;
+  }
+  return !NO_SAMPLING_MODEL_PATTERNS.some((pattern) => lowerModelName.includes(pattern));
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function readToolSet(value) {
+  if (!value) {
+    return;
+  }
+  const isArr = Array.isArray(value);
+  const entries = isArr ? value.map((v, i) => [String(i), v]) : Object.entries(value);
+  const namedKeys = new Set;
+  for (const [, rawTool] of entries) {
+    if (isRecord(rawTool) && typeof rawTool.name === "string" && rawTool.name) {
+      namedKeys.add(rawTool.name);
+    }
+  }
+  const tools = {};
+  let sawNamedTool = false;
+  for (const [origKey, rawTool] of entries) {
+    if (!isRecord(rawTool)) {
+      continue;
+    }
+    const functionTool = isRecord(rawTool.function) ? rawTool.function : undefined;
+    const name = typeof rawTool.name === "string" && rawTool.name ? rawTool.name : typeof functionTool?.name === "string" && functionTool.name ? functionTool.name : undefined;
+    if (name) {
+      sawNamedTool = true;
+      const schema = isRecord(rawTool.parameters) ? rawTool.parameters : isRecord(functionTool?.parameters) ? functionTool.parameters : isRecord(rawTool.input_schema) ? rawTool.input_schema : { type: "object" };
+      const description = typeof rawTool.description === "string" ? rawTool.description : typeof functionTool?.description === "string" ? functionTool.description : undefined;
+      tools[name] = {
+        ...description ? { description } : {},
+        inputSchema: jsonSchema(schema)
+      };
+    } else if (!isArr && !namedKeys.has(origKey)) {
+      tools[origKey] = rawTool;
+    }
+  }
+  if (sawNamedTool) {
+    return Object.keys(tools).length > 0 ? tools : undefined;
+  }
+  return !isArr && isRecord(value) ? value : undefined;
+}
+function readToolChoice(value) {
+  if (!value) {
+    return;
+  }
+  if (typeof value === "string" && (value === "auto" || value === "none" || value === "required")) {
+    return value;
+  }
+  if (!isRecord(value)) {
+    return;
+  }
+  const choice = value;
+  if (choice.type === "tool" && typeof choice.name === "string") {
+    return { type: "tool", toolName: choice.name };
+  }
+  if (choice.type === "function" && isRecord(choice.function)) {
+    const name = choice.function.name;
+    return typeof name === "string" ? { type: "tool", toolName: name } : undefined;
+  }
+  return typeof choice.name === "string" ? { type: "tool", toolName: choice.name } : undefined;
+}
+function buildStructuredOutput(responseSchema) {
+  if (responseSchema && typeof responseSchema === "object" && "responseFormat" in responseSchema && "parseCompleteOutput" in responseSchema) {
+    return responseSchema;
+  }
+  const schemaOptions = responseSchema && typeof responseSchema === "object" && "schema" in responseSchema ? responseSchema : { schema: responseSchema };
+  return {
+    name: "object",
+    responseFormat: Promise.resolve({
+      type: "json",
+      schema: schemaOptions.schema,
+      ...schemaOptions.name ? { name: schemaOptions.name } : {},
+      ...schemaOptions.description ? { description: schemaOptions.description } : {}
+    }),
+    async parseCompleteOutput({ text }) {
+      return JSON.parse(text);
+    },
+    async parsePartialOutput() {
+      return;
+    },
+    createElementStreamTransform() {
+      return;
+    }
+  };
+}
+function usesNativeTextResult(params) {
+  return Boolean(params.messages || params.tools || params.toolChoice || params.responseSchema);
+}
+function getModelNameForType(runtime, modelType) {
+  switch (modelType) {
+    case TEXT_NANO_MODEL_TYPE:
+      return getNanoModel(runtime);
+    case TEXT_MEDIUM_MODEL_TYPE:
+      return getMediumModel(runtime);
+    case ModelType4.TEXT_SMALL:
+      return getSmallModel(runtime);
+    case ModelType4.TEXT_LARGE:
+      return getLargeModel(runtime);
+    case TEXT_MEGA_MODEL_TYPE:
+      return getMegaModel(runtime);
+    case RESPONSE_HANDLER_MODEL_TYPE:
+      return getResponseHandlerModel(runtime);
+    case ACTION_PLANNER_MODEL_TYPE:
+      return getActionPlannerModel(runtime);
+    default:
+      return getLargeModel(runtime);
+  }
+}
+function getModelLabelForType(modelType) {
+  switch (modelType) {
+    case TEXT_NANO_MODEL_TYPE:
+      return "TEXT_NANO";
+    case TEXT_MEDIUM_MODEL_TYPE:
+      return "TEXT_MEDIUM";
+    case ModelType4.TEXT_SMALL:
+      return "TEXT_SMALL";
+    case ModelType4.TEXT_LARGE:
+      return "TEXT_LARGE";
+    case TEXT_MEGA_MODEL_TYPE:
+      return "TEXT_MEGA";
+    case RESPONSE_HANDLER_MODEL_TYPE:
+      return "RESPONSE_HANDLER";
+    case ACTION_PLANNER_MODEL_TYPE:
+      return "ACTION_PLANNER";
+    default:
+      return String(modelType);
+  }
+}
+function buildGenerateParams(runtime, modelType, params) {
+  const paramsWithAttachments = params;
+  const prompt = typeof params.prompt === "string" ? params.prompt : undefined;
+  const usagePrompt = prompt ?? textFromMessages(paramsWithAttachments.messages);
+  const paramsWithMax = params;
+  const resolvedMaxOutput = params.omitMaxTokens ? undefined : paramsWithMax.maxOutputTokens ?? paramsWithMax.maxTokens ?? 8192;
+  const openrouter = createOpenRouterProvider(runtime);
+  const modelName = getModelNameForType(runtime, modelType);
+  const modelLabel = getModelLabelForType(modelType);
+  const supportsSampling = supportsSamplingParameters(modelName);
+  const stopSequences = Array.isArray(params.stopSequences) && params.stopSequences.length > 0 ? params.stopSequences : undefined;
+  const userContent = (paramsWithAttachments.attachments?.length ?? 0) > 0 ? buildUserContent(paramsWithAttachments) : undefined;
+  const attachmentContent = paramsWithAttachments.messages && (paramsWithAttachments.attachments?.length ?? 0) > 0 ? buildUserContent(paramsWithAttachments, { includePrompt: false }) : undefined;
+  const temperature = params.temperature ?? 0.7;
+  const frequencyPenalty = params.frequencyPenalty ?? 0.7;
+  const presencePenalty = params.presencePenalty ?? 0.7;
+  const systemPrompt = resolveEffectiveSystemPrompt({
+    params: paramsWithAttachments,
+    fallback: buildCanonicalSystemPrompt({ character: runtime.character })
+  });
+  const wireMessages = dropDuplicateLeadingSystemMessage(paramsWithAttachments.messages, systemPrompt);
+  const promptOrMessages = paramsWithAttachments.messages ? wireMessages && wireMessages.length > 0 ? {
+    messages: attachmentContent ? appendUserContentToMessages(wireMessages, attachmentContent) : wireMessages
+  } : userContent ? { messages: [{ role: "user", content: userContent }] } : prompt !== undefined ? { prompt } : (() => {
+    throw new Error("OpenRouter text generation requires prompt, messages, or attachments");
+  })() : userContent ? { messages: [{ role: "user", content: userContent }] } : prompt !== undefined ? { prompt } : (() => {
+    throw new Error("OpenRouter text generation requires prompt, messages, or attachments");
+  })();
+  const rawProviderOptions = paramsWithAttachments.providerOptions;
+  const { openrouter: rawOpenrouterOptions, ...restProviderOptions } = rawProviderOptions ?? {};
+  const openrouterOptions = {
+    ...rawOpenrouterOptions ?? {}
+  };
+  const mergedProviderOptions = {
+    ...restProviderOptions,
+    ...Object.keys(openrouterOptions).length > 0 ? { openrouter: openrouterOptions } : {}
+  };
+  const resolvedProviderOptions = Object.keys(mergedProviderOptions).length > 0 ? mergedProviderOptions : undefined;
+  const normalizedTools = readToolSet(paramsWithAttachments.tools);
+  const normalizedToolChoice = readToolChoice(paramsWithAttachments.toolChoice);
+  const generateParams = {
+    model: openrouter.chat(modelName),
+    ...promptOrMessages,
+    system: systemPrompt,
+    ...supportsSampling ? {
+      temperature,
+      frequencyPenalty,
+      presencePenalty,
+      ...stopSequences ? { stopSequences } : {}
+    } : {},
+    ...resolvedMaxOutput !== undefined ? { maxOutputTokens: resolvedMaxOutput } : {},
+    ...normalizedTools ? { tools: normalizedTools } : {},
+    ...normalizedToolChoice ? { toolChoice: normalizedToolChoice } : {},
+    ...paramsWithAttachments.responseSchema ? { output: buildStructuredOutput(paramsWithAttachments.responseSchema) } : {},
+    ...resolvedProviderOptions ? { providerOptions: resolvedProviderOptions } : {}
+  };
+  return {
+    generateParams,
+    modelName,
+    modelLabel,
+    prompt: usagePrompt,
+    shouldReturnNativeResult: usesNativeTextResult(paramsWithAttachments)
+  };
+}
+function handleStreamingGeneration(runtime, modelType, generateParams, prompt, modelName, modelLabel, shouldReturnNativeResult) {
+  const streamResult = streamText(generateParams);
+  const usagePromise = Promise.resolve(streamResult.usage).then((usage) => {
+    if (!usage) {
+      return;
+    }
+    return emitModelUsageEvent(runtime, modelType, prompt, usage, modelName, modelLabel);
+  });
+  const ignoreUsageError = () => {
+    return;
+  };
+  async function* textStreamWithUsage() {
+    let completed = false;
+    try {
+      for await (const chunk of streamResult.textStream) {
+        yield chunk;
+      }
+      completed = true;
+    } finally {
+      if (completed) {
+        await usagePromise.catch(ignoreUsageError);
+      }
+    }
+  }
+  return {
+    textStream: textStreamWithUsage(),
+    text: Promise.resolve(streamResult.text).then(async (text) => {
+      await usagePromise.catch(ignoreUsageError);
+      return text;
+    }),
+    ...shouldReturnNativeResult ? { toolCalls: Promise.resolve(streamResult.toolCalls) } : {},
+    usage: usagePromise,
+    finishReason: Promise.resolve(streamResult.finishReason)
+  };
+}
+function buildNativeTextResult(result) {
+  const inputTokens = result.usage?.inputTokens ?? result.usage?.promptTokens ?? 0;
+  const outputTokens = result.usage?.outputTokens ?? result.usage?.completionTokens ?? 0;
+  if (!result.usage) {
+    return {
+      text: result.text,
+      toolCalls: result.toolCalls ?? [],
+      finishReason: result.finishReason
+    };
+  }
+  const cacheRead = result.usage.cacheReadInputTokens ?? result.usage.cachedInputTokens;
+  const cacheCreation = result.usage.cacheCreationInputTokens;
+  const usage = {
+    promptTokens: inputTokens,
+    completionTokens: outputTokens,
+    totalTokens: result.usage.totalTokens ?? inputTokens + outputTokens,
+    ...typeof cacheRead === "number" ? { cacheReadInputTokens: cacheRead } : {},
+    ...typeof cacheCreation === "number" ? { cacheCreationInputTokens: cacheCreation } : {}
+  };
+  return {
+    text: result.text,
+    toolCalls: result.toolCalls ?? [],
+    finishReason: result.finishReason,
+    usage
+  };
+}
+async function generateTextWithModel(runtime, modelType, params) {
+  const { generateParams, modelName, modelLabel, prompt, shouldReturnNativeResult } = buildGenerateParams(runtime, modelType, params);
+  if (params.stream) {
+    return handleStreamingGeneration(runtime, modelType, generateParams, prompt, modelName, modelLabel, shouldReturnNativeResult);
+  }
+  const response = await generateText2(generateParams);
+  if (response.usage) {
+    emitModelUsageEvent(runtime, modelType, prompt, response.usage, modelName, modelLabel);
+  }
+  if (shouldReturnNativeResult) {
+    return buildNativeTextResult(response);
+  }
+  return response.text;
+}
+async function handleTextSmall(runtime, params) {
+  return generateTextWithModel(runtime, ModelType4.TEXT_SMALL, params);
+}
+async function handleTextNano(runtime, params) {
+  return generateTextWithModel(runtime, TEXT_NANO_MODEL_TYPE, params);
+}
+async function handleTextMedium(runtime, params) {
+  return generateTextWithModel(runtime, TEXT_MEDIUM_MODEL_TYPE, params);
+}
+async function handleTextLarge(runtime, params) {
+  return generateTextWithModel(runtime, ModelType4.TEXT_LARGE, params);
+}
+async function handleTextMega(runtime, params) {
+  return generateTextWithModel(runtime, TEXT_MEGA_MODEL_TYPE, params);
+}
+async function handleResponseHandler(runtime, params) {
+  return generateTextWithModel(runtime, RESPONSE_HANDLER_MODEL_TYPE, params);
+}
+async function handleActionPlanner(runtime, params) {
+  return generateTextWithModel(runtime, ACTION_PLANNER_MODEL_TYPE, params);
+}
+
+// plugin.ts
+function getProcessEnv() {
+  if (typeof process === "undefined" || !process.env) {
+    return {};
+  }
+  return process.env;
+}
+var env = getProcessEnv();
+var TEXT_NANO_MODEL_TYPE2 = ModelType5.TEXT_NANO;
+var TEXT_MEDIUM_MODEL_TYPE2 = ModelType5.TEXT_MEDIUM;
+var TEXT_MEGA_MODEL_TYPE2 = ModelType5.TEXT_MEGA;
+var RESPONSE_HANDLER_MODEL_TYPE2 = ModelType5.RESPONSE_HANDLER;
+var ACTION_PLANNER_MODEL_TYPE2 = ModelType5.ACTION_PLANNER;
+var openrouterPlugin = {
+  name: "openrouter",
+  description: "OpenRouter multi-model AI gateway plugin",
+  autoEnable: {
+    envKeys: ["OPENROUTER_API_KEY"]
+  },
+  config: {
+    OPENROUTER_API_KEY: env.OPENROUTER_API_KEY ?? null,
+    OPENROUTER_BASE_URL: env.OPENROUTER_BASE_URL ?? null,
+    OPENROUTER_NANO_MODEL: env.OPENROUTER_NANO_MODEL ?? null,
+    OPENROUTER_MEDIUM_MODEL: env.OPENROUTER_MEDIUM_MODEL ?? null,
+    OPENROUTER_SMALL_MODEL: env.OPENROUTER_SMALL_MODEL ?? null,
+    OPENROUTER_LARGE_MODEL: env.OPENROUTER_LARGE_MODEL ?? null,
+    OPENROUTER_MEGA_MODEL: env.OPENROUTER_MEGA_MODEL ?? null,
+    OPENROUTER_RESPONSE_HANDLER_MODEL: env.OPENROUTER_RESPONSE_HANDLER_MODEL ?? null,
+    OPENROUTER_SHOULD_RESPOND_MODEL: env.OPENROUTER_SHOULD_RESPOND_MODEL ?? null,
+    OPENROUTER_ACTION_PLANNER_MODEL: env.OPENROUTER_ACTION_PLANNER_MODEL ?? null,
+    OPENROUTER_PLANNER_MODEL: env.OPENROUTER_PLANNER_MODEL ?? null,
+    OPENROUTER_IMAGE_MODEL: env.OPENROUTER_IMAGE_MODEL ?? null,
+    OPENROUTER_IMAGE_GENERATION_MODEL: env.OPENROUTER_IMAGE_GENERATION_MODEL ?? null,
+    OPENROUTER_EMBEDDING_MODEL: env.OPENROUTER_EMBEDDING_MODEL ?? null,
+    OPENROUTER_TRANSCRIPTION_MODEL: env.OPENROUTER_TRANSCRIPTION_MODEL ?? null,
+    OPENROUTER_EMBEDDING_DIMENSIONS: env.OPENROUTER_EMBEDDING_DIMENSIONS ?? null,
+    OPENROUTER_AUTO_CLEANUP_IMAGES: env.OPENROUTER_AUTO_CLEANUP_IMAGES ?? null,
+    NANO_MODEL: env.NANO_MODEL ?? null,
+    MEDIUM_MODEL: env.MEDIUM_MODEL ?? null,
+    SMALL_MODEL: env.SMALL_MODEL ?? null,
+    LARGE_MODEL: env.LARGE_MODEL ?? null,
+    MEGA_MODEL: env.MEGA_MODEL ?? null,
+    RESPONSE_HANDLER_MODEL: env.RESPONSE_HANDLER_MODEL ?? null,
+    SHOULD_RESPOND_MODEL: env.SHOULD_RESPOND_MODEL ?? null,
+    ACTION_PLANNER_MODEL: env.ACTION_PLANNER_MODEL ?? null,
+    PLANNER_MODEL: env.PLANNER_MODEL ?? null,
+    IMAGE_MODEL: env.IMAGE_MODEL ?? null,
+    IMAGE_GENERATION_MODEL: env.IMAGE_GENERATION_MODEL ?? null,
+    EMBEDDING_MODEL: env.EMBEDDING_MODEL ?? null,
+    TRANSCRIPTION_MODEL: env.TRANSCRIPTION_MODEL ?? null,
+    EMBEDDING_DIMENSIONS: env.EMBEDDING_DIMENSIONS ?? null
+  },
+  async init(config, runtime) {
+    initializeOpenRouter(config, runtime);
+  },
+  models: {
+    [TEXT_NANO_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextNano(runtime, params);
+    },
+    [ModelType5.TEXT_SMALL]: async (runtime, params) => {
+      return handleTextSmall(runtime, params);
+    },
+    [TEXT_MEDIUM_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMedium(runtime, params);
+    },
+    [ModelType5.TEXT_LARGE]: async (runtime, params) => {
+      return handleTextLarge(runtime, params);
+    },
+    [TEXT_MEGA_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMega(runtime, params);
+    },
+    [RESPONSE_HANDLER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleResponseHandler(runtime, params);
+    },
+    [ACTION_PLANNER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleActionPlanner(runtime, params);
+    },
+    [ModelType5.IMAGE_DESCRIPTION]: async (runtime, params) => {
+      return handleImageDescription(runtime, params);
+    },
+    [ModelType5.IMAGE]: async (runtime, params) => {
+      const result = await handleImageGeneration(runtime, params);
+      return [{ url: result.imageUrl }];
+    },
+    [ModelType5.TEXT_EMBEDDING]: async (runtime, params) => {
+      return handleTextEmbedding(runtime, params);
+    },
+    [ModelType5.TRANSCRIPTION]: async (runtime, params) => {
+      return handleTranscription(runtime, params);
+    }
+  },
+  tests: [
+    {
+      name: "openrouter_plugin_tests",
+      tests: [
+        {
+          name: "openrouter_test_text_small",
+          fn: async (runtime) => {
+            try {
+              const runModel = runtime.useModel.bind(runtime);
+              const text = await runModel(ModelType5.TEXT_SMALL, {
+                prompt: "What is the nature of reality in 10 words?"
+              });
+              if (text.length === 0) {
+                throw new Error("Failed to generate text");
+              }
+              logger5.log({ text }, "generated with test_text_small");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              logger5.error(`Error in test_text_small: ${message}`);
+              throw error;
+            }
+          }
+        },
+        {
+          name: "openrouter_test_text_large",
+          fn: async (runtime) => {
+            try {
+              const runModel = runtime.useModel.bind(runtime);
+              const text = await runModel(ModelType5.TEXT_LARGE, {
+                prompt: "What is the nature of reality in 10 words?"
+              });
+              if (text.length === 0) {
+                throw new Error("Failed to generate text");
+              }
+              logger5.log({ text }, "generated with test_text_large");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              logger5.error(`Error in test_text_large: ${message}`);
+              throw error;
+            }
+          }
+        },
+        {
+          name: "openrouter_test_structured_output_via_text_large",
+          fn: async (runtime) => {
+            try {
+              const result = await runtime.useModel(ModelType5.TEXT_LARGE, {
+                prompt: "Create a simple JSON object with a message field saying hello",
+                responseSchema: {
+                  type: "object",
+                  properties: { message: { type: "string" } },
+                  required: ["message"]
+                }
+              });
+              logger5.log({ result }, "Generated structured output via TEXT_LARGE");
+              if (!result) {
+                throw new Error("Failed to generate structured output");
+              }
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              logger5.error(`Error in test_structured_output_via_text_large: ${message}`);
+              throw error;
+            }
+          }
+        },
+        {
+          name: "openrouter_test_text_embedding",
+          fn: async (runtime) => {
+            try {
+              const runModel = runtime.useModel.bind(runtime);
+              const embedding = await runModel(ModelType5.TEXT_EMBEDDING, {
+                text: "Hello, world!"
+              });
+              logger5.log({ embedding }, "embedding");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              logger5.error(`Error in test_text_embedding: ${message}`);
+              throw error;
+            }
+          }
+        }
+      ]
+    }
+  ]
+};
+var plugin_default = openrouterPlugin;
+
+// index.ts
+var openrouterPlugin2 = plugin_default;
+export {
+  shouldAutoCleanupImages,
+  openrouterPlugin2 as openrouterPlugin,
+  getTranscriptionModel,
+  getSmallModel,
+  getSetting,
+  getResponseHandlerModel,
+  getNanoModel,
+  getMegaModel,
+  getMediumModel,
+  getLargeModel,
+  getImageModel,
+  getImageGenerationModel,
+  getEmbeddingModel,
+  getEmbeddingDimensions,
+  getBaseURL,
+  getApiKey,
+  getActionPlannerModel,
+  openrouterPlugin2 as default,
+  DEFAULT_TRANSCRIPTION_MODEL,
+  DEFAULT_SMALL_MODEL,
+  DEFAULT_LARGE_MODEL,
+  DEFAULT_IMAGE_MODEL,
+  DEFAULT_IMAGE_GENERATION_MODEL,
+  DEFAULT_EMBEDDING_MODEL,
+  DEFAULT_EMBEDDING_DIMENSIONS,
+  DEFAULT_BASE_URL
+};
+
+//# debugId=6C3DF0FBFC9021DA64756E2164756E21
+//# sourceMappingURL=index.node.js.map