@elizaos/plugin-openrouter 2.0.0-alpha.9 → 2.0.0-beta.1

package/dist/cjs/index.node.cjs

@@ -37,12 +37,16 @@ var __export = (target, all) => {
 };
 
 // index.ts
-var exports_typescript = {};
-__export(exports_typescript, {
+var exports_plugin_openrouter = {};
+__export(exports_plugin_openrouter, {
   shouldAutoCleanupImages: () => shouldAutoCleanupImages,
-  openrouterPlugin: () => import_plugin.openrouterPlugin,
+  openrouterPlugin: () => openrouterPlugin2,
   getSmallModel: () => getSmallModel,
   getSetting: () => getSetting,
+  getResponseHandlerModel: () => getResponseHandlerModel,
+  getNanoModel: () => getNanoModel,
+  getMegaModel: () => getMegaModel,
+  getMediumModel: () => getMediumModel,
   getLargeModel: () => getLargeModel,
   getImageModel: () => getImageModel,
   getImageGenerationModel: () => getImageGenerationModel,
@@ -50,7 +54,8 @@ __export(exports_typescript, {
   getEmbeddingDimensions: () => getEmbeddingDimensions,
   getBaseURL: () => getBaseURL,
   getApiKey: () => getApiKey,
-  default: () => import_plugin.openrouterPlugin,
+  getActionPlannerModel: () => getActionPlannerModel,
+  default: () => openrouterPlugin2,
   DEFAULT_SMALL_MODEL: () => DEFAULT_SMALL_MODEL,
   DEFAULT_LARGE_MODEL: () => DEFAULT_LARGE_MODEL,
   DEFAULT_IMAGE_MODEL: () => DEFAULT_IMAGE_MODEL,
@@ -59,7 +64,13 @@ __export(exports_typescript, {
   DEFAULT_EMBEDDING_DIMENSIONS: () => DEFAULT_EMBEDDING_DIMENSIONS,
   DEFAULT_BASE_URL: () => DEFAULT_BASE_URL
 });
-module.exports = __toCommonJS(exports_typescript);
+module.exports = __toCommonJS(exports_plugin_openrouter);
+
+// plugin.ts
+var import_core6 = require("@elizaos/core");
+
+// init.ts
+var import_core = require("@elizaos/core");
 
 // utils/config.ts
 var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
@@ -96,9 +107,24 @@ function getApiKey(runtime) {
 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;
 }
@@ -117,5 +143,650 @@ function shouldAutoCleanupImages(runtime) {
   return setting?.toLowerCase() === "true";
 }
 
-//# debugId=8CB3E91DAB0E9DCD64756E2164756E21
+// 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)) {
+        import_core.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) {
+        import_core.logger.warn(`OpenRouter API key validation failed: ${response.statusText}`);
+      } else {
+        import_core.logger.log("OpenRouter API key validated successfully");
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      import_core.logger.warn(`Error validating OpenRouter API key: ${message}`);
+    }
+  })();
+}
+
+// models/embedding.ts
+var import_core3 = require("@elizaos/core");
+
+// utils/events.ts
+var import_core2 = require("@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(import_core2.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/embedding.ts
+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(import_core3.VECTOR_DIMS).includes(embeddingDimension)) {
+    const errorMsg = `Invalid embedding dimension: ${embeddingDimension}. Must be one of: ${Object.values(import_core3.VECTOR_DIMS).join(", ")}`;
+    import_core3.logger.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" && params.text) {
+    text = params.text;
+  } else {
+    const errorMsg = "Invalid input format for embedding";
+    import_core3.logger.warn(errorMsg);
+    const fallbackVector = Array(embeddingDimension).fill(0);
+    fallbackVector[0] = 0.2;
+    return fallbackVector;
+  }
+  if (!text.trim()) {
+    const errorMsg = "Empty text for embedding";
+    import_core3.logger.warn(errorMsg);
+    const fallbackVector = Array(embeddingDimension).fill(0);
+    fallbackVector[0] = 0.3;
+    return fallbackVector;
+  }
+  const maxChars = 8000 * 4;
+  if (text.length > maxChars) {
+    import_core3.logger.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";
+    import_core3.logger.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) {
+      import_core3.logger.error(`OpenRouter API error: ${response.status} - ${response.statusText}`);
+      throw new Error(`OpenRouter API error: ${response.status} - ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!data?.data?.[0]?.embedding) {
+      import_core3.logger.error("API returned invalid structure");
+      throw new Error("API returned invalid structure");
+    }
+    const embedding = data.data[0].embedding;
+    if (!Array.isArray(embedding) || embedding.length !== embeddingDimension) {
+      const errorMsg = `Embedding length ${embedding?.length ?? 0} does not match configured dimension ${embeddingDimension}`;
+      import_core3.logger.error(errorMsg);
+      const fallbackVector = Array(embeddingDimension).fill(0);
+      fallbackVector[0] = 0.4;
+      return fallbackVector;
+    }
+    if (data.usage) {
+      const usage = {
+        inputTokens: data.usage.prompt_tokens,
+        outputTokens: 0,
+        totalTokens: data.usage.total_tokens
+      };
+      emitModelUsageEvent(runtime, import_core3.ModelType.TEXT_EMBEDDING, text, usage, embeddingModelName);
+    }
+    return embedding;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    import_core3.logger.error(`Error generating embedding: ${message}`);
+    throw error instanceof Error ? error : new Error(message);
+  }
+}
+
+// models/image.ts
+var import_core4 = require("@elizaos/core");
+var import_ai = require("ai");
+
+// providers/openrouter.ts
+var import_ai_sdk_provider = require("@openrouter/ai-sdk-provider");
+function createOpenRouterProvider(runtime) {
+  const apiKey = getApiKey(runtime);
+  const isBrowser = typeof globalThis !== "undefined" && globalThis.document;
+  const baseURL = getBaseURL(runtime);
+  return import_ai_sdk_provider.createOpenRouter({
+    apiKey: isBrowser ? undefined : apiKey,
+    baseURL
+  });
+}
+// models/image.ts
+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" ? "Describe this image" : params.prompt || "Describe this image";
+  try {
+    const generateParams = {
+      model: openrouter.chat(modelName),
+      messages: [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: prompt },
+            { type: "image", image: imageUrl }
+          ]
+        }
+      ]
+    };
+    const response = await import_ai.generateText(generateParams);
+    if (response.usage) {
+      emitModelUsageEvent(runtime, import_core4.ModelType.IMAGE_DESCRIPTION, prompt, response.usage, modelName);
+    }
+    return response.text;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    import_core4.logger.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);
+  try {
+    const generateParams = {
+      model: openrouter.chat(modelName),
+      prompt: `Generate an image: ${params.prompt}`
+    };
+    const response = await import_ai.generateText(generateParams);
+    if (response.usage) {
+      emitModelUsageEvent(runtime, import_core4.ModelType.IMAGE, params.prompt, response.usage, modelName);
+    }
+    return {
+      imageUrl: response.text,
+      caption: params.prompt
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    import_core4.logger.error(`Error generating image: ${message}`);
+    throw error instanceof Error ? error : new Error(message);
+  }
+}
+
+// models/text.ts
+var import_core5 = require("@elizaos/core");
+var import_ai2 = require("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 = import_core5.ModelType.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE = import_core5.ModelType.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_MEGA_MODEL_TYPE = import_core5.ModelType.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE = import_core5.ModelType.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE = import_core5.ModelType.ACTION_PLANNER ?? "ACTION_PLANNER";
+function buildUserContent(params) {
+  const content = [{ 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 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 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 import_core5.ModelType.TEXT_SMALL:
+      return getSmallModel(runtime);
+    case import_core5.ModelType.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 import_core5.ModelType.TEXT_SMALL:
+      return "TEXT_SMALL";
+    case import_core5.ModelType.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 } = params;
+  const paramsWithMax = params;
+  const resolvedMaxOutput = 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 temperature = params.temperature ?? 0.7;
+  const frequencyPenalty = params.frequencyPenalty ?? 0.7;
+  const presencePenalty = params.presencePenalty ?? 0.7;
+  const systemPrompt = import_core5.resolveEffectiveSystemPrompt({
+    params: paramsWithAttachments,
+    fallback: import_core5.buildCanonicalSystemPrompt({ character: runtime.character })
+  });
+  const wireMessages = import_core5.dropDuplicateLeadingSystemMessage(paramsWithAttachments.messages, systemPrompt);
+  const promptOrMessages = paramsWithAttachments.messages ? wireMessages && wireMessages.length > 0 ? { messages: wireMessages } : userContent ? { messages: [{ role: "user", content: userContent }] } : { prompt } : userContent ? { messages: [{ role: "user", content: userContent }] } : { prompt };
+  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 generateParams = {
+    model: openrouter.chat(modelName),
+    ...promptOrMessages,
+    system: systemPrompt,
+    ...supportsSampling ? {
+      temperature,
+      frequencyPenalty,
+      presencePenalty,
+      ...stopSequences ? { stopSequences } : {}
+    } : {},
+    maxOutputTokens: resolvedMaxOutput,
+    ...paramsWithAttachments.tools ? { tools: paramsWithAttachments.tools } : {},
+    ...paramsWithAttachments.toolChoice ? { toolChoice: paramsWithAttachments.toolChoice } : {},
+    ...paramsWithAttachments.responseSchema ? { output: buildStructuredOutput(paramsWithAttachments.responseSchema) } : {},
+    ...resolvedProviderOptions ? { providerOptions: resolvedProviderOptions } : {}
+  };
+  return {
+    generateParams,
+    modelName,
+    modelLabel,
+    prompt,
+    shouldReturnNativeResult: usesNativeTextResult(paramsWithAttachments)
+  };
+}
+function handleStreamingGeneration(runtime, modelType, generateParams, prompt, modelName, modelLabel, shouldReturnNativeResult) {
+  const streamResult = import_ai2.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 import_ai2.generateText(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, import_core5.ModelType.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, import_core5.ModelType.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 = import_core6.ModelType.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE2 = import_core6.ModelType.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_MEGA_MODEL_TYPE2 = import_core6.ModelType.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE2 = import_core6.ModelType.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE2 = import_core6.ModelType.ACTION_PLANNER ?? "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_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,
+    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);
+    },
+    [import_core6.ModelType.TEXT_SMALL]: async (runtime, params) => {
+      return handleTextSmall(runtime, params);
+    },
+    [TEXT_MEDIUM_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMedium(runtime, params);
+    },
+    [import_core6.ModelType.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);
+    },
+    [import_core6.ModelType.IMAGE_DESCRIPTION]: async (runtime, params) => {
+      const description = await handleImageDescription(runtime, params);
+      return { title: "", description };
+    },
+    [import_core6.ModelType.IMAGE]: async (runtime, params) => {
+      const result = await handleImageGeneration(runtime, params);
+      return [{ url: result.imageUrl }];
+    },
+    [import_core6.ModelType.TEXT_EMBEDDING]: async (runtime, params) => {
+      return handleTextEmbedding(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(import_core6.ModelType.TEXT_SMALL, {
+                prompt: "What is the nature of reality in 10 words?"
+              });
+              if (text.length === 0) {
+                throw new Error("Failed to generate text");
+              }
+              import_core6.logger.log({ text }, "generated with test_text_small");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              import_core6.logger.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(import_core6.ModelType.TEXT_LARGE, {
+                prompt: "What is the nature of reality in 10 words?"
+              });
+              if (text.length === 0) {
+                throw new Error("Failed to generate text");
+              }
+              import_core6.logger.log({ text }, "generated with test_text_large");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              import_core6.logger.error(`Error in test_text_large: ${message}`);
+              throw error;
+            }
+          }
+        },
+        {
+          name: "openrouter_test_structured_output_via_text_large",
+          fn: async (runtime) => {
+            try {
+              const runModel = runtime.useModel.bind(runtime);
+              const result = await runModel(import_core6.ModelType.TEXT_LARGE, {
+                prompt: "Create a simple JSON object with a message field saying hello",
+                responseSchema: {
+                  type: "object",
+                  properties: { message: { type: "string" } },
+                  required: ["message"]
+                }
+              });
+              import_core6.logger.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);
+              import_core6.logger.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(import_core6.ModelType.TEXT_EMBEDDING, {
+                text: "Hello, world!"
+              });
+              import_core6.logger.log({ embedding }, "embedding");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              import_core6.logger.error(`Error in test_text_embedding: ${message}`);
+              throw error;
+            }
+          }
+        }
+      ]
+    }
+  ]
+};
+var plugin_default = openrouterPlugin;
+
+// index.ts
+var openrouterPlugin2 = plugin_default;
+
+//# debugId=9F505D89FE343F3864756E2164756E21
 //# sourceMappingURL=index.node.cjs.map