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

package/dist/node/index.node.js

@@ -1,7 +1,7 @@
 // plugin.ts
 import {
-  logger as logger6,
-  ModelType as ModelType5
+  logger as logger4,
+  ModelType as ModelType4
 } from "@elizaos/core";
 
 // init.ts
@@ -42,9 +42,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;
 }
@@ -93,26 +108,34 @@ function initializeOpenRouter(_config, runtime) {
 }
 
 // models/embedding.ts
-import { logger as logger3, ModelType, VECTOR_DIMS } from "@elizaos/core";
+import { logger as logger2, ModelType, VECTOR_DIMS } from "@elizaos/core";
 
 // utils/events.ts
-import { logger as logger2 } from "@elizaos/core";
-function emitModelUsageEvent(_runtime, modelType, prompt, usage) {
+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;
-  logger2.debug({
-    event: "model:usage",
-    modelType,
+  const model = modelName?.trim() || modelLabel?.trim() || String(modelType);
+  runtime.emitEvent(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
@@ -121,7 +144,7 @@ async function handleTextEmbedding(runtime, params) {
   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);
+    logger2.error(errorMsg);
     throw new Error(errorMsg);
   }
   if (params === null) {
@@ -136,27 +159,27 @@ async function handleTextEmbedding(runtime, params) {
     text = params.text;
   } else {
     const errorMsg = "Invalid input format for embedding";
-    logger3.warn(errorMsg);
+    logger2.warn(errorMsg);
     const fallbackVector = Array(embeddingDimension).fill(0);
     fallbackVector[0] = 0.2;
     return fallbackVector;
   }
   if (!text.trim()) {
     const errorMsg = "Empty text for embedding";
-    logger3.warn(errorMsg);
+    logger2.warn(errorMsg);
     const fallbackVector = Array(embeddingDimension).fill(0);
     fallbackVector[0] = 0.3;
     return fallbackVector;
   }
   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`);
+    logger2.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);
+    logger2.error(errorMsg);
     throw new Error(errorMsg);
   }
   const baseURL = getBaseURL(runtime);
@@ -175,18 +198,18 @@ async function handleTextEmbedding(runtime, params) {
       })
     });
     if (!response.ok) {
-      logger3.error(`OpenRouter API error: ${response.status} - ${response.statusText}`);
+      logger2.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) {
-      logger3.error("API returned invalid structure");
+      logger2.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}`;
-      logger3.error(errorMsg);
+      logger2.error(errorMsg);
       const fallbackVector = Array(embeddingDimension).fill(0);
       fallbackVector[0] = 0.4;
       return fallbackVector;
@@ -197,18 +220,18 @@ async function handleTextEmbedding(runtime, params) {
         outputTokens: 0,
         totalTokens: data.usage.total_tokens
       };
-      emitModelUsageEvent(runtime, ModelType.TEXT_EMBEDDING, text, usage);
+      emitModelUsageEvent(runtime, ModelType.TEXT_EMBEDDING, text, usage, embeddingModelName);
     }
     return embedding;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    logger3.error(`Error generating embedding: ${message}`);
+    logger2.error(`Error generating embedding: ${message}`);
     throw error instanceof Error ? error : new Error(message);
   }
 }
 
 // models/image.ts
-import { logger as logger4, ModelType as ModelType2 } from "@elizaos/core";
+import { logger as logger3, ModelType as ModelType2 } from "@elizaos/core";
 import { generateText } from "ai";
 
 // providers/openrouter.ts
@@ -243,12 +266,12 @@ async function handleImageDescription(runtime, params) {
     };
     const response = await generateText(generateParams);
     if (response.usage) {
-      emitModelUsageEvent(runtime, ModelType2.IMAGE_DESCRIPTION, prompt, response.usage);
+      emitModelUsageEvent(runtime, ModelType2.IMAGE_DESCRIPTION, prompt, response.usage, modelName);
     }
     return response.text;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    logger4.error(`Error describing image: ${message}`);
+    logger3.error(`Error describing image: ${message}`);
     throw error instanceof Error ? error : new Error(message);
   }
 }
@@ -262,7 +285,7 @@ async function handleImageGeneration(runtime, params) {
     };
     const response = await generateText(generateParams);
     if (response.usage) {
-      emitModelUsageEvent(runtime, ModelType2.IMAGE, params.prompt, response.usage);
+      emitModelUsageEvent(runtime, ModelType2.IMAGE, params.prompt, response.usage, modelName);
     }
     return {
       imageUrl: response.text,
@@ -270,64 +293,41 @@ async function handleImageGeneration(runtime, params) {
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    logger4.error(`Error generating image: ${message}`);
+    logger3.error(`Error generating image: ${message}`);
     throw error instanceof Error ? error : new Error(message);
   }
 }
 
-// models/object.ts
+// models/text.ts
 import {
-  ModelType as ModelType3
+  buildCanonicalSystemPrompt,
+  dropDuplicateLeadingSystemMessage,
+  ModelType as ModelType3,
+  resolveEffectiveSystemPrompt
 } from "@elizaos/core";
-import { generateObject, jsonSchema } from "ai";
-
-// utils/helpers.ts
-import { logger as logger5 } from "@elizaos/core";
-function handleObjectGenerationError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  logger5.error(`Error generating object: ${message}`);
-  return { error: message };
-}
-
-// models/object.ts
-async function generateObjectWithModel(runtime, modelType, params) {
-  const openrouter = createOpenRouterProvider(runtime);
-  const modelName = modelType === ModelType3.OBJECT_SMALL ? getSmallModel(runtime) : getLargeModel(runtime);
-  const temperature = params.temperature ?? 0.7;
-  try {
-    const model = openrouter.chat(modelName);
-    const { object, usage } = params.schema ? await generateObject({
-      model,
-      schema: jsonSchema(params.schema),
-      output: "object",
-      prompt: params.prompt,
-      temperature
-    }) : await generateObject({
-      model,
-      output: "no-schema",
-      prompt: params.prompt,
-      temperature
+import {
+  generateText as generateText2,
+  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 = ModelType3.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE = ModelType3.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_MEGA_MODEL_TYPE = ModelType3.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE = ModelType3.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE = ModelType3.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, ModelType3.OBJECT_SMALL, params);
-}
-async function handleObjectLarge(runtime, params) {
-  return generateObjectWithModel(runtime, ModelType3.OBJECT_LARGE, params);
-}
-
-// models/text.ts
-import { ModelType as ModelType4 } from "@elizaos/core";
-import { generateText as generateText2, streamText } from "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))) {
@@ -335,74 +335,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 ModelType3.TEXT_SMALL:
+      return getSmallModel(runtime);
+    case ModelType3.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 ModelType3.TEXT_SMALL:
+      return "TEXT_SMALL";
+    case ModelType3.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 === ModelType4.TEXT_SMALL ? getSmallModel(runtime) : getLargeModel(runtime);
-  const modelLabel = modelType === ModelType4.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 = resolveEffectiveSystemPrompt({
+    params: paramsWithAttachments,
+    fallback: buildCanonicalSystemPrompt({ character: runtime.character })
+  });
+  const wireMessages = 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,
+    shouldReturnNativeResult: usesNativeTextResult(paramsWithAttachments)
   };
-  return { generateParams, modelName, modelLabel, prompt };
 }
-function handleStreamingGeneration(runtime, modelType, generateParams, prompt, _modelLabel) {
+function handleStreamingGeneration(runtime, modelType, generateParams, prompt, modelName, modelLabel, shouldReturnNativeResult) {
   const streamResult = 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
-        };
-      }
+  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 generateText2(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, ModelType4.TEXT_SMALL, params);
+  return generateTextWithModel(runtime, ModelType3.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);
+  return generateTextWithModel(runtime, ModelType3.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
@@ -413,21 +561,43 @@ function getProcessEnv() {
   return process.env;
 }
 var env = getProcessEnv();
+var TEXT_NANO_MODEL_TYPE2 = ModelType4.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE2 = ModelType4.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_MEGA_MODEL_TYPE2 = ModelType4.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE2 = ModelType4.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE2 = ModelType4.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,
@@ -437,27 +607,36 @@ var openrouterPlugin = {
     initializeOpenRouter(config, runtime);
   },
   models: {
-    [ModelType5.TEXT_SMALL]: async (runtime, params) => {
+    [TEXT_NANO_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextNano(runtime, params);
+    },
+    [ModelType4.TEXT_SMALL]: async (runtime, params) => {
       return handleTextSmall(runtime, params);
     },
-    [ModelType5.TEXT_LARGE]: async (runtime, params) => {
+    [TEXT_MEDIUM_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMedium(runtime, params);
+    },
+    [ModelType4.TEXT_LARGE]: async (runtime, params) => {
       return handleTextLarge(runtime, params);
     },
-    [ModelType5.OBJECT_SMALL]: async (runtime, params) => {
-      return handleObjectSmall(runtime, params);
+    [TEXT_MEGA_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMega(runtime, params);
     },
-    [ModelType5.OBJECT_LARGE]: async (runtime, params) => {
-      return handleObjectLarge(runtime, params);
+    [RESPONSE_HANDLER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleResponseHandler(runtime, params);
     },
-    [ModelType5.IMAGE_DESCRIPTION]: async (runtime, params) => {
+    [ACTION_PLANNER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleActionPlanner(runtime, params);
+    },
+    [ModelType4.IMAGE_DESCRIPTION]: async (runtime, params) => {
       const description = await handleImageDescription(runtime, params);
       return { title: "", description };
     },
-    [ModelType5.IMAGE]: async (runtime, params) => {
+    [ModelType4.IMAGE]: async (runtime, params) => {
       const result = await handleImageGeneration(runtime, params);
       return [{ url: result.imageUrl }];
     },
-    [ModelType5.TEXT_EMBEDDING]: async (runtime, params) => {
+    [ModelType4.TEXT_EMBEDDING]: async (runtime, params) => {
       return handleTextEmbedding(runtime, params);
     }
   },
@@ -469,16 +648,17 @@ var openrouterPlugin = {
           name: "openrouter_test_text_small",
           fn: async (runtime) => {
             try {
-              const text = await runtime.useModel(ModelType5.TEXT_SMALL, {
+              const runModel = runtime.useModel.bind(runtime);
+              const text = await runModel(ModelType4.TEXT_SMALL, {
                 prompt: "What is the nature of reality in 10 words?"
               });
               if (text.length === 0) {
                 throw new Error("Failed to generate text");
               }
-              logger6.log({ text }, "generated with test_text_small");
+              logger4.log({ text }, "generated with test_text_small");
             } catch (error) {
               const message = error instanceof Error ? error.message : String(error);
-              logger6.error(`Error in test_text_small: ${message}`);
+              logger4.error(`Error in test_text_small: ${message}`);
               throw error;
             }
           }
@@ -487,35 +667,41 @@ var openrouterPlugin = {
           name: "openrouter_test_text_large",
           fn: async (runtime) => {
             try {
-              const text = await runtime.useModel(ModelType5.TEXT_LARGE, {
+              const runModel = runtime.useModel.bind(runtime);
+              const text = await runModel(ModelType4.TEXT_LARGE, {
                 prompt: "What is the nature of reality in 10 words?"
               });
               if (text.length === 0) {
                 throw new Error("Failed to generate text");
               }
-              logger6.log({ text }, "generated with test_text_large");
+              logger4.log({ text }, "generated with test_text_large");
             } catch (error) {
               const message = error instanceof Error ? error.message : String(error);
-              logger6.error(`Error in test_text_large: ${message}`);
+              logger4.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(ModelType5.OBJECT_SMALL, {
+              const runModel = runtime.useModel.bind(runtime);
+              const result = await runModel(ModelType4.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"]
+                }
               });
-              logger6.log({ result }, "Generated object with test_object_small");
-              if (!result || typeof result === "object" && "error" in result) {
-                throw new Error("Failed to generate object");
+              logger4.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);
-              logger6.error(`Error in test_object_small: ${message}`);
+              logger4.error(`Error in test_structured_output_via_text_large: ${message}`);
               throw error;
             }
           }
@@ -524,13 +710,14 @@ var openrouterPlugin = {
           name: "openrouter_test_text_embedding",
           fn: async (runtime) => {
             try {
-              const embedding = await runtime.useModel(ModelType5.TEXT_EMBEDDING, {
+              const runModel = runtime.useModel.bind(runtime);
+              const embedding = await runModel(ModelType4.TEXT_EMBEDDING, {
                 text: "Hello, world!"
               });
-              logger6.log({ embedding }, "embedding");
+              logger4.log({ embedding }, "embedding");
             } catch (error) {
               const message = error instanceof Error ? error.message : String(error);
-              logger6.error(`Error in test_text_embedding: ${message}`);
+              logger4.error(`Error in test_text_embedding: ${message}`);
               throw error;
             }
           }
@@ -539,11 +726,19 @@ var openrouterPlugin = {
     }
   ]
 };
+var plugin_default = openrouterPlugin;
+
+// index.ts
+var openrouterPlugin2 = plugin_default;
 export {
   shouldAutoCleanupImages,
-  openrouterPlugin,
+  openrouterPlugin2 as openrouterPlugin,
   getSmallModel,
   getSetting,
+  getResponseHandlerModel,
+  getNanoModel,
+  getMegaModel,
+  getMediumModel,
   getLargeModel,
   getImageModel,
   getImageGenerationModel,
@@ -551,7 +746,8 @@ export {
   getEmbeddingDimensions,
   getBaseURL,
   getApiKey,
-  openrouterPlugin as default,
+  getActionPlannerModel,
+  openrouterPlugin2 as default,
   DEFAULT_SMALL_MODEL,
   DEFAULT_LARGE_MODEL,
   DEFAULT_IMAGE_MODEL,
@@ -561,5 +757,5 @@ export {
   DEFAULT_BASE_URL
 };
 
-//# debugId=332F2156B50672B464756E2164756E21
+//# debugId=778917F34416E3C764756E2164756E21
 //# sourceMappingURL=index.node.js.map