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

package/dist/cjs/index.node.cjs

@@ -2,37 +2,51 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
+function __accessProp(key) {
+  return this[key];
+}
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
   if (entry)
     return entry;
   entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
 // index.ts
-var exports_typescript = {};
-__export(exports_typescript, {
+var exports_plugin_openrouter = {};
+__export(exports_plugin_openrouter, {
   shouldAutoCleanupImages: () => shouldAutoCleanupImages,
-  openrouterPlugin: () => openrouterPlugin,
+  openrouterPlugin: () => openrouterPlugin2,
   getSmallModel: () => getSmallModel,
   getSetting: () => getSetting,
+  getResponseHandlerModel: () => getResponseHandlerModel,
+  getNanoModel: () => getNanoModel,
+  getMegaModel: () => getMegaModel,
+  getMediumModel: () => getMediumModel,
   getLargeModel: () => getLargeModel,
   getImageModel: () => getImageModel,
   getImageGenerationModel: () => getImageGenerationModel,
@@ -40,7 +54,8 @@ __export(exports_typescript, {
   getEmbeddingDimensions: () => getEmbeddingDimensions,
   getBaseURL: () => getBaseURL,
   getApiKey: () => getApiKey,
-  default: () => openrouterPlugin,
+  getActionPlannerModel: () => getActionPlannerModel,
+  default: () => openrouterPlugin2,
   DEFAULT_SMALL_MODEL: () => DEFAULT_SMALL_MODEL,
   DEFAULT_LARGE_MODEL: () => DEFAULT_LARGE_MODEL,
   DEFAULT_IMAGE_MODEL: () => DEFAULT_IMAGE_MODEL,
@@ -49,10 +64,10 @@ __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_core8 = require("@elizaos/core");
+var import_core6 = require("@elizaos/core");
 
 // init.ts
 var import_core = require("@elizaos/core");
@@ -92,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;
 }
@@ -147,22 +177,30 @@ var import_core3 = require("@elizaos/core");
 
 // utils/events.ts
 var import_core2 = require("@elizaos/core");
-function emitModelUsageEvent(_runtime, modelType, prompt, usage) {
+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;
-  import_core2.logger.debug({
-    event: "model:usage",
-    modelType,
+  const model = modelName?.trim() || modelLabel?.trim() || String(modelType);
+  runtime.emitEvent(import_core2.EventType.MODEL_USED, {
+    runtime,
+    source: "openrouter",
     provider: "openrouter",
-    prompt: prompt.substring(0, 100),
-    usage: {
-      promptTokens: inputTokens,
-      completionTokens: outputTokens,
-      totalTokens
-    },
-    timestamp: Date.now()
+    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
@@ -247,7 +285,7 @@ async function handleTextEmbedding(runtime, params) {
         outputTokens: 0,
         totalTokens: data.usage.total_tokens
       };
-      emitModelUsageEvent(runtime, import_core3.ModelType.TEXT_EMBEDDING, text, usage);
+      emitModelUsageEvent(runtime, import_core3.ModelType.TEXT_EMBEDDING, text, usage, embeddingModelName);
     }
     return embedding;
   } catch (error) {
@@ -293,7 +331,7 @@ async function handleImageDescription(runtime, params) {
     };
     const response = await import_ai.generateText(generateParams);
     if (response.usage) {
-      emitModelUsageEvent(runtime, import_core4.ModelType.IMAGE_DESCRIPTION, prompt, response.usage);
+      emitModelUsageEvent(runtime, import_core4.ModelType.IMAGE_DESCRIPTION, prompt, response.usage, modelName);
     }
     return response.text;
   } catch (error) {
@@ -312,7 +350,7 @@ async function handleImageGeneration(runtime, params) {
     };
     const response = await import_ai.generateText(generateParams);
     if (response.usage) {
-      emitModelUsageEvent(runtime, import_core4.ModelType.IMAGE, params.prompt, response.usage);
+      emitModelUsageEvent(runtime, import_core4.ModelType.IMAGE, params.prompt, response.usage, modelName);
     }
     return {
       imageUrl: response.text,
@@ -325,57 +363,28 @@ async function handleImageGeneration(runtime, params) {
   }
 }
 
-// models/object.ts
-var import_core6 = require("@elizaos/core");
-var import_ai2 = require("ai");
-
-// utils/helpers.ts
+// models/text.ts
 var import_core5 = require("@elizaos/core");
-function handleObjectGenerationError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  import_core5.logger.error(`Error generating object: ${message}`);
-  return { error: message };
-}
-
-// models/object.ts
-async function generateObjectWithModel(runtime, modelType, params) {
-  const openrouter = createOpenRouterProvider(runtime);
-  const modelName = modelType === import_core6.ModelType.OBJECT_SMALL ? getSmallModel(runtime) : getLargeModel(runtime);
-  const temperature = params.temperature ?? 0.7;
-  try {
-    const model = openrouter.chat(modelName);
-    const { object, usage } = params.schema ? await import_ai2.generateObject({
-      model,
-      schema: import_ai2.jsonSchema(params.schema),
-      output: "object",
-      prompt: params.prompt,
-      temperature
-    }) : await import_ai2.generateObject({
-      model,
-      output: "no-schema",
-      prompt: params.prompt,
-      temperature
+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 } : {}
     });
-    if (usage) {
-      emitModelUsageEvent(runtime, modelType, params.prompt, usage);
-    }
-    return object;
-  } catch (error) {
-    return handleObjectGenerationError(error);
   }
+  return content;
 }
-async function handleObjectSmall(runtime, params) {
-  return generateObjectWithModel(runtime, import_core6.ModelType.OBJECT_SMALL, params);
-}
-async function handleObjectLarge(runtime, params) {
-  return generateObjectWithModel(runtime, import_core6.ModelType.OBJECT_LARGE, params);
-}
-
-// models/text.ts
-var import_core7 = require("@elizaos/core");
-var import_ai3 = require("ai");
-var RESPONSES_ROUTED_PREFIXES = ["openai/", "anthropic/"];
-var NO_SAMPLING_MODEL_PATTERNS = ["o1", "o3", "o4", "gpt-5", "gpt-5-mini"];
 function supportsSamplingParameters(modelName) {
   const lowerModelName = modelName.toLowerCase();
   if (RESPONSES_ROUTED_PREFIXES.some((prefix) => lowerModelName.startsWith(prefix))) {
@@ -383,74 +392,222 @@ function supportsSamplingParameters(modelName) {
   }
   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 = modelType === import_core7.ModelType.TEXT_SMALL ? getSmallModel(runtime) : getLargeModel(runtime);
-  const modelLabel = modelType === import_core7.ModelType.TEXT_SMALL ? "TEXT_SMALL" : "TEXT_LARGE";
+  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),
-    prompt,
-    system: runtime.character?.system ?? undefined,
+    ...promptOrMessages,
+    system: systemPrompt,
     ...supportsSampling ? {
       temperature,
       frequencyPenalty,
       presencePenalty,
       ...stopSequences ? { stopSequences } : {}
     } : {},
-    maxOutputTokens: resolvedMaxOutput
+    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 };
-}
-function handleStreamingGeneration(runtime, modelType, generateParams, prompt, _modelLabel) {
-  const streamResult = import_ai3.streamText(generateParams);
   return {
-    textStream: streamResult.textStream,
-    text: Promise.resolve(streamResult.text),
-    usage: Promise.resolve(streamResult.usage).then((usage) => {
-      if (usage) {
-        emitModelUsageEvent(runtime, modelType, prompt, usage);
-        const inputTokens = usage.inputTokens ?? 0;
-        const outputTokens = usage.outputTokens ?? 0;
-        return {
-          promptTokens: inputTokens,
-          completionTokens: outputTokens,
-          totalTokens: inputTokens + outputTokens
-        };
-      }
+    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: _modelName,
-    modelLabel,
-    prompt
-  } = buildGenerateParams(runtime, modelType, params);
+  const { generateParams, modelName, modelLabel, prompt, shouldReturnNativeResult } = buildGenerateParams(runtime, modelType, params);
   if (params.stream) {
-    return handleStreamingGeneration(runtime, modelType, generateParams, prompt, modelLabel);
+    return handleStreamingGeneration(runtime, modelType, generateParams, prompt, modelName, modelLabel, shouldReturnNativeResult);
   }
-  const response = await import_ai3.generateText(generateParams);
+  const response = await import_ai2.generateText(generateParams);
   if (response.usage) {
-    emitModelUsageEvent(runtime, modelType, prompt, 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_core7.ModelType.TEXT_SMALL, 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_core7.ModelType.TEXT_LARGE, 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
@@ -461,21 +618,43 @@ function getProcessEnv() {
   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,
@@ -485,27 +664,36 @@ var openrouterPlugin = {
     initializeOpenRouter(config, runtime);
   },
   models: {
-    [import_core8.ModelType.TEXT_SMALL]: async (runtime, params) => {
+    [TEXT_NANO_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextNano(runtime, params);
+    },
+    [import_core6.ModelType.TEXT_SMALL]: async (runtime, params) => {
       return handleTextSmall(runtime, params);
     },
-    [import_core8.ModelType.TEXT_LARGE]: async (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);
     },
-    [import_core8.ModelType.OBJECT_SMALL]: async (runtime, params) => {
-      return handleObjectSmall(runtime, params);
+    [TEXT_MEGA_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMega(runtime, params);
+    },
+    [RESPONSE_HANDLER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleResponseHandler(runtime, params);
     },
-    [import_core8.ModelType.OBJECT_LARGE]: async (runtime, params) => {
-      return handleObjectLarge(runtime, params);
+    [ACTION_PLANNER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleActionPlanner(runtime, params);
     },
-    [import_core8.ModelType.IMAGE_DESCRIPTION]: async (runtime, params) => {
+    [import_core6.ModelType.IMAGE_DESCRIPTION]: async (runtime, params) => {
       const description = await handleImageDescription(runtime, params);
       return { title: "", description };
     },
-    [import_core8.ModelType.IMAGE]: async (runtime, params) => {
+    [import_core6.ModelType.IMAGE]: async (runtime, params) => {
       const result = await handleImageGeneration(runtime, params);
       return [{ url: result.imageUrl }];
     },
-    [import_core8.ModelType.TEXT_EMBEDDING]: async (runtime, params) => {
+    [import_core6.ModelType.TEXT_EMBEDDING]: async (runtime, params) => {
       return handleTextEmbedding(runtime, params);
     }
   },
@@ -517,16 +705,17 @@ var openrouterPlugin = {
           name: "openrouter_test_text_small",
           fn: async (runtime) => {
             try {
-              const text = await runtime.useModel(import_core8.ModelType.TEXT_SMALL, {
+              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_core8.logger.log({ text }, "generated with test_text_small");
+              import_core6.logger.log({ text }, "generated with test_text_small");
             } catch (error) {
               const message = error instanceof Error ? error.message : String(error);
-              import_core8.logger.error(`Error in test_text_small: ${message}`);
+              import_core6.logger.error(`Error in test_text_small: ${message}`);
               throw error;
             }
           }
@@ -535,35 +724,41 @@ var openrouterPlugin = {
           name: "openrouter_test_text_large",
           fn: async (runtime) => {
             try {
-              const text = await runtime.useModel(import_core8.ModelType.TEXT_LARGE, {
+              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_core8.logger.log({ text }, "generated with test_text_large");
+              import_core6.logger.log({ text }, "generated with test_text_large");
             } catch (error) {
               const message = error instanceof Error ? error.message : String(error);
-              import_core8.logger.error(`Error in test_text_large: ${message}`);
+              import_core6.logger.error(`Error in test_text_large: ${message}`);
               throw error;
             }
           }
         },
         {
-          name: "openrouter_test_object_small",
+          name: "openrouter_test_structured_output_via_text_large",
           fn: async (runtime) => {
             try {
-              const result = await runtime.useModel(import_core8.ModelType.OBJECT_SMALL, {
+              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",
-                schema: { type: "object" }
+                responseSchema: {
+                  type: "object",
+                  properties: { message: { type: "string" } },
+                  required: ["message"]
+                }
               });
-              import_core8.logger.log({ result }, "Generated object with test_object_small");
-              if (!result || typeof result === "object" && "error" in result) {
-                throw new Error("Failed to generate object");
+              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_core8.logger.error(`Error in test_object_small: ${message}`);
+              import_core6.logger.error(`Error in test_structured_output_via_text_large: ${message}`);
               throw error;
             }
           }
@@ -572,13 +767,14 @@ var openrouterPlugin = {
           name: "openrouter_test_text_embedding",
           fn: async (runtime) => {
             try {
-              const embedding = await runtime.useModel(import_core8.ModelType.TEXT_EMBEDDING, {
+              const runModel = runtime.useModel.bind(runtime);
+              const embedding = await runModel(import_core6.ModelType.TEXT_EMBEDDING, {
                 text: "Hello, world!"
               });
-              import_core8.logger.log({ embedding }, "embedding");
+              import_core6.logger.log({ embedding }, "embedding");
             } catch (error) {
               const message = error instanceof Error ? error.message : String(error);
-              import_core8.logger.error(`Error in test_text_embedding: ${message}`);
+              import_core6.logger.error(`Error in test_text_embedding: ${message}`);
               throw error;
             }
           }
@@ -587,6 +783,10 @@ var openrouterPlugin = {
     }
   ]
 };
+var plugin_default = openrouterPlugin;
+
+// index.ts
+var openrouterPlugin2 = plugin_default;
 
-//# debugId=FFBB525AD797F5DB64756E2164756E21
+//# debugId=9F505D89FE343F3864756E2164756E21
 //# sourceMappingURL=index.node.cjs.map