@elizaos/plugin-openrouter 1.3.1 → 1.5.13

package/dist/{index.js → node/index.node.js}

@@ -1,3 +1,22 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
 // src/index.ts
 import {
   ModelType as ModelType3
@@ -12,11 +31,11 @@ function getSetting(runtime, key, defaultValue) {
   return runtime.getSetting(key) ?? process.env[key] ?? defaultValue;
 }
 function getBaseURL(runtime) {
-  return getSetting(
-    runtime,
-    "OPENROUTER_BASE_URL",
-    "https://openrouter.ai/api/v1"
-  ) || "https://openrouter.ai/api/v1";
+  const browserURL = getSetting(runtime, "OPENROUTER_BROWSER_BASE_URL");
+  if (typeof globalThis !== "undefined" && globalThis.document && browserURL) {
+    return browserURL;
+  }
+  return getSetting(runtime, "OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1") || "https://openrouter.ai/api/v1";
 }
 function getApiKey(runtime) {
   return getSetting(runtime, "OPENROUTER_API_KEY");
@@ -25,11 +44,7 @@ function getSmallModel(runtime) {
   return getSetting(runtime, "OPENROUTER_SMALL_MODEL") ?? getSetting(runtime, "SMALL_MODEL", "google/gemini-2.0-flash-001") ?? "google/gemini-2.0-flash-001";
 }
 function getLargeModel(runtime) {
-  return getSetting(runtime, "OPENROUTER_LARGE_MODEL") ?? getSetting(
-    runtime,
-    "LARGE_MODEL",
-    "google/gemini-2.5-flash"
-  ) ?? "google/gemini-2.5-flash";
+  return getSetting(runtime, "OPENROUTER_LARGE_MODEL") ?? getSetting(runtime, "LARGE_MODEL", "google/gemini-2.5-flash") ?? "google/gemini-2.5-flash";
 }
 function getImageModel(runtime) {
   return getSetting(runtime, "OPENROUTER_IMAGE_MODEL") ?? getSetting(runtime, "IMAGE_MODEL", "x-ai/grok-2-vision-1212") ?? "x-ai/grok-2-vision-1212";
@@ -41,15 +56,26 @@ function shouldAutoCleanupImages(runtime) {
   const setting = getSetting(runtime, "OPENROUTER_AUTO_CLEANUP_IMAGES", "false");
   return setting?.toLowerCase() === "true";
 }
+function getToolExecutionMaxSteps(runtime) {
+  const setting = getSetting(runtime, "OPENROUTER_TOOL_EXECUTION_MAX_STEPS", "15");
+  const value = parseInt(setting || "15", 10);
+  if (Number.isNaN(value) || value < 1)
+    return 15;
+  if (value > 100)
+    return 100;
+  return value;
+}
 
 // src/init.ts
 function initializeOpenRouter(_config, runtime) {
   (async () => {
     try {
+      const isBrowser = typeof globalThis !== "undefined" && globalThis.document;
+      if (isBrowser) {
+        return;
+      }
       if (!getApiKey(runtime)) {
-        logger.warn(
-          "OPENROUTER_API_KEY is not set in environment - OpenRouter functionality will be limited"
-        );
+        logger.warn("OPENROUTER_API_KEY is not set in environment - OpenRouter functionality will be limited");
         return;
       }
       try {
@@ -58,73 +84,62 @@ function initializeOpenRouter(_config, runtime) {
           headers: { Authorization: `Bearer ${getApiKey(runtime)}` }
         });
         if (!response.ok) {
-          logger.warn(
-            `OpenRouter API key validation failed: ${response.statusText}`
-          );
-          logger.warn(
-            "OpenRouter functionality will be limited until a valid API key is provided"
-          );
+          logger.warn(`OpenRouter API key validation failed: ${response.statusText}`);
+          logger.warn("OpenRouter functionality will be limited until a valid API key is provided");
         } else {
           logger.log("OpenRouter API key validated successfully");
         }
       } catch (fetchError) {
         const message = fetchError instanceof Error ? fetchError.message : String(fetchError);
         logger.warn(`Error validating OpenRouter API key: ${message}`);
-        logger.warn(
-          "OpenRouter functionality will be limited until a valid API key is provided"
-        );
+        logger.warn("OpenRouter functionality will be limited until a valid API key is provided");
       }
     } catch (error) {
       const message = error?.errors?.map((e) => e.message).join(", ") || (error instanceof Error ? error.message : String(error));
-      logger.warn(
-        `OpenRouter plugin configuration issue: ${message} - You need to configure the OPENROUTER_API_KEY in your environment variables`
-      );
+      logger.warn(`OpenRouter plugin configuration issue: ${message} - You need to configure the OPENROUTER_API_KEY in your environment variables`);
     }
   })();
   return;
 }
 
 // src/models/text.ts
-import { logger as logger4, ModelType } from "@elizaos/core";
+import { logger as logger3, ModelType } from "@elizaos/core";
 import { generateText } from "ai";
 
 // src/providers/openrouter.ts
 import { createOpenRouter } from "@openrouter/ai-sdk-provider";
-import { logger as logger2 } from "@elizaos/core";
 function createOpenRouterProvider(runtime) {
   const apiKey = getApiKey(runtime);
-  if (!apiKey) {
-    logger2.error(
-      "OpenRouter API Key is missing when trying to create provider"
-    );
-    throw new Error("OpenRouter API Key is missing.");
-  }
+  const isBrowser = typeof globalThis !== "undefined" && globalThis.document;
+  const baseURL = getBaseURL(runtime);
   return createOpenRouter({
-    apiKey
-    // We might need to handle baseURL differently if required.
-    // The @ai-sdk/provider utils might handle OPENROUTER_BASE_URL env var.
+    apiKey: isBrowser ? undefined : apiKey,
+    baseURL
   });
 }
-
 // src/utils/events.ts
 import {
   EventType
 } from "@elizaos/core";
 function emitModelUsageEvent(runtime, type, prompt, usage) {
+  const truncatedPrompt = typeof prompt === "string" ? prompt.length > 200 ? `${prompt.slice(0, 200)}…` : prompt : "";
+  const inputTokens = Number(usage.inputTokens || 0);
+  const outputTokens = Number(usage.outputTokens || 0);
+  const totalTokens = Number(usage.totalTokens != null ? usage.totalTokens : inputTokens + outputTokens);
   runtime.emitEvent(EventType.MODEL_USED, {
     provider: "openrouter",
     type,
-    prompt,
+    prompt: truncatedPrompt,
     tokens: {
-      prompt: usage.promptTokens,
-      completion: usage.completionTokens,
-      total: usage.totalTokens
+      prompt: inputTokens,
+      completion: outputTokens,
+      total: totalTokens
     }
   });
 }
 
 // src/utils/helpers.ts
-import { logger as logger3 } from "@elizaos/core";
+import { logger as logger2 } from "@elizaos/core";
 import { JSONParseError } from "ai";
 function getJsonRepairFunction() {
   return async ({ text, error }) => {
@@ -137,15 +152,15 @@ function getJsonRepairFunction() {
       return null;
     } catch (jsonError) {
       const message = jsonError instanceof Error ? jsonError.message : String(jsonError);
-      logger3.warn(`Failed to repair JSON text: ${message}`);
+      logger2.warn(`Failed to repair JSON text: ${message}`);
       return null;
     }
   };
 }
 function handleEmptyToolResponse(modelType) {
-  logger3.warn(`[${modelType}] No text generated after tool execution`);
+  logger2.warn(`[${modelType}] No text generated after tool execution`);
   const fallbackText = "I executed the requested action. The tool completed successfully.";
-  logger3.warn(`[${modelType}] Using fallback response text`);
+  logger2.warn(`[${modelType}] Using fallback response text`);
   return fallbackText;
 }
 function parseImageDescriptionResponse(responseText) {
@@ -155,7 +170,7 @@ function parseImageDescriptionResponse(responseText) {
       return jsonResponse;
     }
   } catch (e) {
-    logger3.debug(`Parsing as JSON failed, processing as text: ${e}`);
+    logger2.debug(`Parsing as JSON failed, processing as text: ${e}`);
   }
   const titleMatch = responseText.match(/title[:\s]+(.+?)(?:\n|$)/i);
   const title = titleMatch?.[1]?.trim() || "Image Analysis";
@@ -164,7 +179,7 @@ function parseImageDescriptionResponse(responseText) {
 }
 async function handleObjectGenerationError(error) {
   if (error instanceof JSONParseError) {
-    logger3.error(`[generateObject] Failed to parse JSON: ${error.message}`);
+    logger2.error(`[generateObject] Failed to parse JSON: ${error.message}`);
     const repairFunction = getJsonRepairFunction();
     const repairedJsonString = await repairFunction({
       text: error.text,
@@ -173,47 +188,54 @@ async function handleObjectGenerationError(error) {
     if (repairedJsonString) {
       try {
         const repairedObject = JSON.parse(repairedJsonString);
-        logger3.log("[generateObject] Successfully repaired JSON.");
+        logger2.log("[generateObject] Successfully repaired JSON.");
         return repairedObject;
       } catch (repairParseError) {
         const message = repairParseError instanceof Error ? repairParseError.message : String(repairParseError);
-        logger3.error(
-          `[generateObject] Failed to parse repaired JSON: ${message}`
-        );
-        if (repairParseError instanceof Error) throw repairParseError;
+        logger2.error(`[generateObject] Failed to parse repaired JSON: ${message}`);
+        if (repairParseError instanceof Error)
+          throw repairParseError;
         throw Object.assign(new Error(message), { cause: repairParseError });
       }
     } else {
-      logger3.error("[generateObject] JSON repair failed.");
+      logger2.error("[generateObject] JSON repair failed.");
       throw error;
     }
   } else {
     const message = error instanceof Error ? error.message : String(error);
-    logger3.error(`[generateObject] Unknown error: ${message}`);
-    if (error instanceof Error) throw error;
+    logger2.error(`[generateObject] Unknown error: ${message}`);
+    if (error instanceof Error)
+      throw error;
     throw Object.assign(new Error(message), { cause: error });
   }
 }
 function isLikelyBase64(key, value) {
   const base64KeyPattern = /^(data|content|body|payload|encoded|b64|base64|document)$/i;
-  if (!base64KeyPattern.test(key)) return false;
-  if (value.length < 20 || value.length > 1024 * 1024) return false;
-  if (value.length % 4 !== 0) return false;
-  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(value)) return false;
+  if (!base64KeyPattern.test(key))
+    return false;
+  if (value.length < 20 || value.length > 1024 * 1024)
+    return false;
+  if (value.length % 4 !== 0)
+    return false;
+  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(value))
+    return false;
   return true;
 }
 function decodeBase64Fields(obj, depth = 0) {
-  if (depth > 5) return obj;
-  if (!obj || typeof obj !== "object") return obj;
-  if (Array.isArray(obj)) return obj.map((item) => decodeBase64Fields(item, depth + 1));
+  if (depth > 5)
+    return obj;
+  if (!obj || typeof obj !== "object")
+    return obj;
+  if (Array.isArray(obj))
+    return obj.map((item) => decodeBase64Fields(item, depth + 1));
   const decoded = {};
   for (const [key, value] of Object.entries(obj)) {
     if (typeof value === "string" && isLikelyBase64(key, value)) {
       try {
         decoded[key] = Buffer.from(value, "base64").toString("utf8");
-        logger3.debug(`[decodeBase64] Decoded field '${key}' (${value.length} chars)`);
+        logger2.debug(`[decodeBase64] Decoded field '${key}' (${value.length} chars)`);
       } catch (error) {
-        logger3.warn(`[decodeBase64] Failed to decode field '${key}': ${error}`);
+        logger2.warn(`[decodeBase64] Failed to decode field '${key}': ${error}`);
         decoded[key] = value;
       }
     } else if (value && typeof value === "object") {
@@ -231,31 +253,26 @@ async function generateTextWithModel(runtime, modelType, params) {
   const temperature = params.temperature ?? 0.7;
   const frequencyPenalty = params.frequencyPenalty ?? 0.7;
   const presencePenalty = params.presencePenalty ?? 0.7;
-  const maxResponseLength = params.maxTokens ?? 8192;
+  const resolvedMaxOutput = params.maxOutputTokens ?? params.maxTokens ?? 8192;
   const openrouter = createOpenRouterProvider(runtime);
   const modelName = modelType === ModelType.TEXT_SMALL ? getSmallModel(runtime) : getLargeModel(runtime);
   const modelLabel = modelType === ModelType.TEXT_SMALL ? "TEXT_SMALL" : "TEXT_LARGE";
-  logger4.log(
-    `[OpenRouter] Generating text with ${modelLabel} model: ${modelName}`
-  );
+  logger3.log(`[OpenRouter] Generating text with ${modelLabel} model: ${modelName}`);
   const generateParams = {
     model: openrouter.chat(modelName),
     prompt,
-    system: runtime.character.system ?? void 0,
+    system: runtime.character.system ?? undefined,
     temperature,
-    maxTokens: maxResponseLength,
     frequencyPenalty,
     presencePenalty,
     stopSequences
   };
+  generateParams.maxOutputTokens = resolvedMaxOutput;
   if (tools) {
     generateParams.tools = tools;
-    generateParams.maxSteps = 10;
-    generateParams.extra_body = {
-      provider: {
-        require_parameters: true
-      }
-    };
+    const maxSteps = getToolExecutionMaxSteps(runtime);
+    generateParams.maxSteps = maxSteps;
+    logger3.log(`[OpenRouter] Using maxSteps: ${maxSteps} for tool execution`);
   }
   if (toolChoice) {
     generateParams.toolChoice = toolChoice;
@@ -265,11 +282,14 @@ async function generateTextWithModel(runtime, modelType, params) {
   if (tools) {
     generateParams.onStepFinish = async (stepResult) => {
       if (stepResult.toolCalls && stepResult.toolCalls.length > 0) {
-        capturedToolCalls = [...capturedToolCalls, ...stepResult.toolCalls];
+        capturedToolCalls = [
+          ...capturedToolCalls,
+          ...stepResult.toolCalls
+        ];
       }
       if (stepResult.toolResults && stepResult.toolResults.length > 0) {
         const decodedToolResults = stepResult.toolResults.map((result) => ({
-          ...result,
+          toolCallId: result.toolCallId,
           result: decodeBase64Fields(result.result)
         }));
         capturedToolResults = [...capturedToolResults, ...decodedToolResults];
@@ -291,7 +311,6 @@ async function generateTextWithModel(runtime, modelType, params) {
       text: responseText,
       toolCalls: capturedToolCalls,
       toolResults: capturedToolResults,
-      // Include other useful properties
       usage: response.usage,
       finishReason: response.finishReason
     };
@@ -308,19 +327,20 @@ async function handleTextLarge(runtime, params) {
 // src/models/object.ts
 import {
   ModelType as ModelType2,
-  logger as logger5
+  logger as logger4
 } from "@elizaos/core";
 import { generateObject } from "ai";
 async function generateObjectWithModel(runtime, modelType, params) {
   const openrouter = createOpenRouterProvider(runtime);
   const modelName = modelType === ModelType2.OBJECT_SMALL ? getSmallModel(runtime) : getLargeModel(runtime);
   const modelLabel = modelType === ModelType2.OBJECT_SMALL ? "OBJECT_SMALL" : "OBJECT_LARGE";
-  logger5.log(`[OpenRouter] Using ${modelLabel} model: ${modelName}`);
+  logger4.log(`[OpenRouter] Using ${modelLabel} model: ${modelName}`);
   const temperature = params.temperature ?? 0.7;
   try {
     const { object, usage } = await generateObject({
       model: openrouter.chat(modelName),
-      output: "no-schema",
+      ...params.schema && { schema: params.schema },
+      output: params.schema ? "object" : "no-schema",
       prompt: params.prompt,
       temperature,
       experimental_repairText: getJsonRepairFunction()
@@ -342,18 +362,61 @@ async function handleObjectLarge(runtime, params) {
 
 // src/models/image.ts
 import {
-  logger as logger7
+  logger as logger6
 } from "@elizaos/core";
 import { generateText as generateText2 } from "ai";
 
 // src/utils/image-storage.ts
-import { existsSync, unlinkSync } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { logger as logger6, getGeneratedDir } from "@elizaos/core";
+import { logger as logger5, getGeneratedDir } from "@elizaos/core";
+function isBrowser() {
+  return typeof globalThis !== "undefined" && globalThis.document;
+}
+function sanitizeId(id) {
+  const src = (id ?? "").toString();
+  const normalized = src.normalize("NFKC");
+  let safe = normalized.replace(/[^a-zA-Z0-9_-]/g, "_");
+  safe = safe.replace(/_+/g, "_");
+  safe = safe.slice(0, 64);
+  safe = safe.replace(/^_+|_+$/g, "");
+  return safe || "agent";
+}
+function base64ToBytes(base64) {
+  const cleaned = base64.replace(/\s+/g, "");
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  const lookup = new Array(256).fill(-1);
+  for (let i = 0;i < chars.length; i++)
+    lookup[chars.charCodeAt(i)] = i;
+  const len = cleaned.length;
+  let pad = 0;
+  if (len >= 2 && cleaned[len - 1] === "=")
+    pad++;
+  if (len >= 2 && cleaned[len - 2] === "=")
+    pad++;
+  const outLen = (len * 3 >> 2) - pad;
+  const out = new Uint8Array(outLen);
+  let o = 0;
+  for (let i = 0;i < len; i += 4) {
+    const c0 = lookup[cleaned.charCodeAt(i)];
+    const c1 = lookup[cleaned.charCodeAt(i + 1)];
+    const c2 = lookup[cleaned.charCodeAt(i + 2)];
+    const c3 = lookup[cleaned.charCodeAt(i + 3)];
+    const n = c0 << 18 | c1 << 12 | (c2 & 63) << 6 | c3 & 63;
+    if (o < outLen)
+      out[o++] = n >> 16 & 255;
+    if (o < outLen)
+      out[o++] = n >> 8 & 255;
+    if (o < outLen)
+      out[o++] = n & 255;
+  }
+  return out;
+}
 async function saveBase64Image(base64Url, agentId, index = 0) {
+  if (isBrowser()) {
+    return null;
+  }
   const m = base64Url.match(/^data:(image\/[a-zA-Z0-9.+-]+);base64,([A-Za-z0-9+/=]+)$/);
-  if (!m) return null;
+  if (!m)
+    return null;
   const mime = m[1];
   const base64Data = m[2];
   const extMap = {
@@ -366,27 +429,41 @@ async function saveBase64Image(base64Url, agentId, index = 0) {
     "image/tiff": "tiff"
   };
   const extension = extMap[mime];
-  if (!extension) return null;
-  const baseDir = join(getGeneratedDir(), agentId);
+  if (!extension)
+    return null;
+  const { join } = await import("node:path");
+  const safeAgentId = sanitizeId(agentId);
+  const baseDir = join(getGeneratedDir(), safeAgentId);
+  const { existsSync } = await import("node:fs");
   if (!existsSync(baseDir)) {
+    const { mkdir } = await import("node:fs/promises");
     await mkdir(baseDir, { recursive: true });
   }
   const timestamp = Date.now();
   const filename = `image_${timestamp}_${index}.${extension}`;
   const filepath = join(baseDir, filename);
-  const buffer = Buffer.from(base64Data, "base64");
+  const buffer = base64ToBytes(base64Data);
+  const { writeFile } = await import("node:fs/promises");
   await writeFile(filepath, buffer);
-  logger6.info(`[OpenRouter] Saved generated image to ${filepath}`);
+  logger5.info(`[OpenRouter] Saved generated image to ${filepath}`);
   return filepath;
 }
 function deleteImage(filepath) {
+  if (isBrowser()) {
+    return;
+  }
   try {
-    if (existsSync(filepath)) {
-      unlinkSync(filepath);
-      logger6.debug(`[OpenRouter] Deleted image: ${filepath}`);
-    }
+    (async () => {
+      const { existsSync, unlinkSync } = await import("node:fs");
+      if (existsSync(filepath)) {
+        unlinkSync(filepath);
+        logger5.debug(`[OpenRouter] Deleted image: ${filepath}`);
+      }
+    })().catch((error) => {
+      logger5.warn(`[OpenRouter] Failed to delete image ${filepath}:`, String(error));
+    });
   } catch (error) {
-    logger6.warn(`[OpenRouter] Failed to delete image ${filepath}:`, String(error));
+    logger5.warn(`[OpenRouter] Failed to delete image ${filepath}:`, String(error));
   }
 }
 
@@ -395,8 +472,8 @@ async function handleImageDescription(runtime, params) {
   let imageUrl;
   let promptText;
   const modelName = getImageModel(runtime);
-  logger7.log(`[OpenRouter] Using IMAGE_DESCRIPTION model: ${modelName}`);
-  const maxTokens = 300;
+  logger6.log(`[OpenRouter] Using IMAGE_DESCRIPTION model: ${modelName}`);
+  const maxOutputTokens = 300;
   if (typeof params === "string") {
     imageUrl = params;
     promptText = "Please analyze this image and provide a title and detailed description.";
@@ -419,12 +496,12 @@ async function handleImageDescription(runtime, params) {
     const { text: responseText } = await generateText2({
       model,
       messages,
-      maxTokens
+      maxOutputTokens
     });
     return parseImageDescriptionResponse(responseText);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    logger7.error(`Error analyzing image: ${message}`);
+    logger6.error(`Error analyzing image: ${message}`);
     return {
       title: "Failed to analyze image",
       description: `Error: ${message}`
@@ -433,18 +510,15 @@ async function handleImageDescription(runtime, params) {
 }
 async function handleImageGeneration(runtime, params) {
   const modelName = getImageGenerationModel(runtime);
-  logger7.log(`[OpenRouter] Using IMAGE_GENERATION model: ${modelName}`);
+  logger6.log(`[OpenRouter] Using IMAGE_GENERATION model: ${modelName}`);
   const apiKey = getApiKey(runtime);
   try {
-    if (!apiKey) {
-      logger7.error("[OpenRouter] OpenRouter API key is missing");
-      return [];
-    }
     const baseUrl = getBaseURL(runtime);
+    const isBrowser2 = typeof globalThis !== "undefined" && globalThis.document;
     const response = await fetch(`${baseUrl}/chat/completions`, {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${apiKey}`,
+        ...isBrowser2 ? {} : { Authorization: `Bearer ${apiKey}` },
         "Content-Type": "application/json"
       },
       body: JSON.stringify({
@@ -457,8 +531,7 @@ async function handleImageGeneration(runtime, params) {
         ],
         modalities: ["image", "text"]
       }),
-      // 60 seconds timeout
-      signal: AbortSignal.timeout ? AbortSignal.timeout(6e4) : void 0
+      signal: AbortSignal.timeout ? AbortSignal.timeout(60000) : undefined
     });
     if (!response.ok) {
       const errorText = await response.text().catch(() => "");
@@ -472,16 +545,15 @@ async function handleImageGeneration(runtime, params) {
         const base64Url = image.image_url.url;
         const filepath = await saveBase64Image(base64Url, runtime.agentId, index);
         if (filepath) {
-          logger7.log(`[OpenRouter] Returning image with filepath: ${filepath}`);
+          logger6.log(`[OpenRouter] Returning image with filepath: ${filepath}`);
           images.push({
             url: filepath
-            // Use actual file path
           });
           savedPaths.push(filepath);
         } else if (!base64Url.startsWith("data:")) {
           images.push({ url: base64Url });
         } else {
-          logger7.warn(`[OpenRouter] Failed to save image ${index + 1}, skipping`);
+          logger6.warn(`[OpenRouter] Failed to save image ${index + 1}, skipping`);
         }
       }
     }
@@ -490,16 +562,16 @@ async function handleImageGeneration(runtime, params) {
         savedPaths.forEach((path) => {
           deleteImage(path);
         });
-      }, 3e4);
+      }, 30000);
     }
     if (images.length === 0) {
       throw new Error("No images generated in response");
     }
-    logger7.log(`[OpenRouter] Generated ${images.length} image(s)`);
+    logger6.log(`[OpenRouter] Generated ${images.length} image(s)`);
     return images;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    logger7.error(`[OpenRouter] Error generating image: ${message}`);
+    logger6.error(`[OpenRouter] Error generating image: ${message}`);
     return [];
   }
 }
@@ -545,9 +617,10 @@ var openrouterPlugin = {
     }
   }
 };
-var index_default = openrouterPlugin;
+var src_default = openrouterPlugin;
 export {
-  index_default as default,
-  openrouterPlugin
+  openrouterPlugin,
+  src_default as default
 };
-//# sourceMappingURL=index.js.map
+
+//# debugId=9A894E662DDC9ED364756E2164756E21