@elizaos/plugin-openrouter 1.5.14 → 1.5.17

package/dist/cjs/index.node.cjs

@@ -48,7 +48,7 @@ __export(exports_index_node, {
 module.exports = __toCommonJS(exports_index_node);
 
 // src/index.ts
-var import_core8 = require("@elizaos/core");
+var import_core9 = require("@elizaos/core");
 
 // src/init.ts
 var import_core = require("@elizaos/core");
@@ -56,7 +56,11 @@ var import_undici = require("undici");
 
 // src/utils/config.ts
 function getSetting(runtime, key, defaultValue) {
-  return runtime.getSetting(key) ?? process.env[key] ?? defaultValue;
+  const value = runtime.getSetting(key);
+  if (value !== undefined && value !== null) {
+    return String(value);
+  }
+  return process.env[key] ?? defaultValue;
 }
 function getBaseURL(runtime) {
   const browserURL = getSetting(runtime, "OPENROUTER_BROWSER_BASE_URL");
@@ -80,19 +84,13 @@ function getImageModel(runtime) {
 function getImageGenerationModel(runtime) {
   return getSetting(runtime, "OPENROUTER_IMAGE_GENERATION_MODEL") ?? getSetting(runtime, "IMAGE_GENERATION_MODEL", "google/gemini-2.5-flash-image-preview") ?? "google/gemini-2.5-flash-image-preview";
 }
+function getEmbeddingModel(runtime) {
+  return getSetting(runtime, "OPENROUTER_EMBEDDING_MODEL") ?? getSetting(runtime, "EMBEDDING_MODEL", "openai/text-embedding-3-small") ?? "openai/text-embedding-3-small";
+}
 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) {
@@ -131,8 +129,8 @@ function initializeOpenRouter(_config, runtime) {
 }
 
 // src/models/text.ts
-var import_core4 = require("@elizaos/core");
-var import_ai2 = require("ai");
+var import_core3 = require("@elizaos/core");
+var import_ai = require("ai");
 
 // src/providers/openrouter.ts
 var import_ai_sdk_provider = require("@openrouter/ai-sdk-provider");
@@ -153,6 +151,8 @@ function emitModelUsageEvent(runtime, type, prompt, usage) {
   const outputTokens = Number(usage.outputTokens || 0);
   const totalTokens = Number(usage.totalTokens != null ? usage.totalTokens : inputTokens + outputTokens);
   runtime.emitEvent(import_core2.EventType.MODEL_USED, {
+    runtime,
+    source: "openrouter",
     provider: "openrouter",
     type,
     prompt: truncatedPrompt,
@@ -164,13 +164,80 @@ function emitModelUsageEvent(runtime, type, prompt, usage) {
   });
 }
 
+// src/models/text.ts
+function buildGenerateParams(runtime, modelType, params) {
+  const { prompt, stopSequences = [] } = params;
+  const temperature = params.temperature ?? 0.7;
+  const frequencyPenalty = params.frequencyPenalty ?? 0.7;
+  const presencePenalty = params.presencePenalty ?? 0.7;
+  const resolvedMaxOutput = params.maxOutputTokens ?? params.maxTokens ?? 8192;
+  const openrouter = createOpenRouterProvider(runtime);
+  const modelName = modelType === import_core3.ModelType.TEXT_SMALL ? getSmallModel(runtime) : getLargeModel(runtime);
+  const modelLabel = modelType === import_core3.ModelType.TEXT_SMALL ? "TEXT_SMALL" : "TEXT_LARGE";
+  const generateParams = {
+    model: openrouter.chat(modelName),
+    prompt,
+    system: runtime.character.system ?? undefined,
+    temperature,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences
+  };
+  generateParams.maxOutputTokens = resolvedMaxOutput;
+  return { generateParams, modelName, modelLabel, prompt };
+}
+function handleStreamingGeneration(runtime, modelType, generateParams, prompt, modelLabel) {
+  import_core3.logger.debug(`[OpenRouter] Streaming text with ${modelLabel} model`);
+  const streamResult = import_ai.streamText(generateParams);
+  return {
+    textStream: streamResult.textStream,
+    text: streamResult.text,
+    usage: 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
+        };
+      }
+      return;
+    }),
+    finishReason: streamResult.finishReason
+  };
+}
+async function generateTextWithModel(runtime, modelType, params) {
+  const { generateParams, modelName, modelLabel, prompt } = buildGenerateParams(runtime, modelType, params);
+  import_core3.logger.debug(`[OpenRouter] Generating text with ${modelLabel} model: ${modelName}`);
+  if (params.stream) {
+    return handleStreamingGeneration(runtime, modelType, generateParams, prompt, modelLabel);
+  }
+  const response = await import_ai.generateText(generateParams);
+  if (response.usage) {
+    emitModelUsageEvent(runtime, modelType, prompt, response.usage);
+  }
+  return response.text;
+}
+async function handleTextSmall(runtime, params) {
+  return generateTextWithModel(runtime, import_core3.ModelType.TEXT_SMALL, params);
+}
+async function handleTextLarge(runtime, params) {
+  return generateTextWithModel(runtime, import_core3.ModelType.TEXT_LARGE, params);
+}
+
+// src/models/object.ts
+var import_core5 = require("@elizaos/core");
+var import_ai3 = require("ai");
+
 // src/utils/helpers.ts
-var import_core3 = require("@elizaos/core");
-var import_ai = require("ai");
+var import_core4 = require("@elizaos/core");
+var import_ai2 = require("ai");
 function getJsonRepairFunction() {
   return async ({ text, error }) => {
     try {
-      if (error instanceof import_ai.JSONParseError) {
+      if (error instanceof import_ai2.JSONParseError) {
         const cleanedText = text.replace(/```json\n|\n```|```/g, "");
         JSON.parse(cleanedText);
         return cleanedText;
@@ -178,17 +245,11 @@ function getJsonRepairFunction() {
       return null;
     } catch (jsonError) {
       const message = jsonError instanceof Error ? jsonError.message : String(jsonError);
-      import_core3.logger.warn(`Failed to repair JSON text: ${message}`);
+      import_core4.logger.warn(`Failed to repair JSON text: ${message}`);
       return null;
     }
   };
 }
-function handleEmptyToolResponse(modelType) {
-  import_core3.logger.warn(`[${modelType}] No text generated after tool execution`);
-  const fallbackText = "I executed the requested action. The tool completed successfully.";
-  import_core3.logger.warn(`[${modelType}] Using fallback response text`);
-  return fallbackText;
-}
 function parseImageDescriptionResponse(responseText) {
   try {
     const jsonResponse = JSON.parse(responseText);
@@ -196,7 +257,7 @@ function parseImageDescriptionResponse(responseText) {
       return jsonResponse;
     }
   } catch (e) {
-    import_core3.logger.debug(`Parsing as JSON failed, processing as text: ${e}`);
+    import_core4.logger.debug(`Parsing as JSON failed, processing as text: ${e}`);
   }
   const titleMatch = responseText.match(/title[:\s]+(.+?)(?:\n|$)/i);
   const title = titleMatch?.[1]?.trim() || "Image Analysis";
@@ -204,8 +265,8 @@ function parseImageDescriptionResponse(responseText) {
   return { title, description };
 }
 async function handleObjectGenerationError(error) {
-  if (error instanceof import_ai.JSONParseError) {
-    import_core3.logger.error(`[generateObject] Failed to parse JSON: ${error.message}`);
+  if (error instanceof import_ai2.JSONParseError) {
+    import_core4.logger.error(`[generateObject] Failed to parse JSON: ${error.message}`);
     const repairFunction = getJsonRepairFunction();
     const repairedJsonString = await repairFunction({
       text: error.text,
@@ -214,148 +275,29 @@ async function handleObjectGenerationError(error) {
     if (repairedJsonString) {
       try {
         const repairedObject = JSON.parse(repairedJsonString);
-        import_core3.logger.log("[generateObject] Successfully repaired JSON.");
+        import_core4.logger.log("[generateObject] Successfully repaired JSON.");
         return repairedObject;
       } catch (repairParseError) {
         const message = repairParseError instanceof Error ? repairParseError.message : String(repairParseError);
-        import_core3.logger.error(`[generateObject] Failed to parse repaired JSON: ${message}`);
+        import_core4.logger.error(`[generateObject] Failed to parse repaired JSON: ${message}`);
         if (repairParseError instanceof Error)
           throw repairParseError;
         throw Object.assign(new Error(message), { cause: repairParseError });
       }
     } else {
-      import_core3.logger.error("[generateObject] JSON repair failed.");
+      import_core4.logger.error("[generateObject] JSON repair failed.");
       throw error;
     }
   } else {
     const message = error instanceof Error ? error.message : String(error);
-    import_core3.logger.error(`[generateObject] Unknown error: ${message}`);
+    import_core4.logger.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;
-  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));
-  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");
-        import_core3.logger.debug(`[decodeBase64] Decoded field '${key}' (${value.length} chars)`);
-      } catch (error) {
-        import_core3.logger.warn(`[decodeBase64] Failed to decode field '${key}': ${error}`);
-        decoded[key] = value;
-      }
-    } else if (value && typeof value === "object") {
-      decoded[key] = decodeBase64Fields(value, depth + 1);
-    } else {
-      decoded[key] = value;
-    }
-  }
-  return decoded;
-}
-
-// src/models/text.ts
-async function generateTextWithModel(runtime, modelType, params) {
-  const { prompt, stopSequences = [], tools, toolChoice } = params;
-  const temperature = params.temperature ?? 0.7;
-  const frequencyPenalty = params.frequencyPenalty ?? 0.7;
-  const presencePenalty = params.presencePenalty ?? 0.7;
-  const resolvedMaxOutput = params.maxOutputTokens ?? params.maxTokens ?? 8192;
-  const openrouter = createOpenRouterProvider(runtime);
-  const modelName = modelType === import_core4.ModelType.TEXT_SMALL ? getSmallModel(runtime) : getLargeModel(runtime);
-  const modelLabel = modelType === import_core4.ModelType.TEXT_SMALL ? "TEXT_SMALL" : "TEXT_LARGE";
-  import_core4.logger.debug(`[OpenRouter] Generating text with ${modelLabel} model: ${modelName}`);
-  const generateParams = {
-    model: openrouter.chat(modelName),
-    prompt,
-    system: runtime.character.system ?? undefined,
-    temperature,
-    frequencyPenalty,
-    presencePenalty,
-    stopSequences
-  };
-  generateParams.maxOutputTokens = resolvedMaxOutput;
-  if (tools) {
-    generateParams.tools = tools;
-    const maxSteps = getToolExecutionMaxSteps(runtime);
-    generateParams.stopWhen = import_ai2.stepCountIs(maxSteps);
-    import_core4.logger.debug(`[OpenRouter] Using maxSteps: ${maxSteps} for tool execution`);
-  }
-  if (toolChoice) {
-    generateParams.toolChoice = toolChoice;
-  }
-  let capturedToolResults = [];
-  let capturedToolCalls = [];
-  if (tools) {
-    generateParams.onStepFinish = async (stepResult) => {
-      if (stepResult.toolCalls && stepResult.toolCalls.length > 0) {
-        capturedToolCalls = [
-          ...capturedToolCalls,
-          ...stepResult.toolCalls
-        ];
-      }
-      if (stepResult.content && Array.isArray(stepResult.content)) {
-        const toolResultsFromContent = stepResult.content.filter((content) => content.type === "tool-result" && content.output).map((content) => ({
-          toolCallId: content.toolCallId,
-          result: decodeBase64Fields(content.output)
-        }));
-        if (toolResultsFromContent.length > 0) {
-          capturedToolResults = [...capturedToolResults, ...toolResultsFromContent];
-        }
-      }
-    };
-  }
-  const response = await import_ai2.generateText(generateParams);
-  let responseText;
-  if (tools && (!response.text || response.text.trim() === "" || response.text === "Tools executed successfully.")) {
-    responseText = handleEmptyToolResponse(modelLabel);
-  } else {
-    responseText = response.text;
-  }
-  if (response.usage) {
-    emitModelUsageEvent(runtime, modelType, prompt, response.usage);
-  }
-  if (tools && response.steps && response.steps.length > 0) {
-    return {
-      text: responseText,
-      toolCalls: capturedToolCalls,
-      toolResults: capturedToolResults,
-      steps: response.steps,
-      usage: response.usage,
-      finishReason: response.finishReason
-    };
-  }
-  return responseText;
-}
-async function handleTextSmall(runtime, params) {
-  return generateTextWithModel(runtime, import_core4.ModelType.TEXT_SMALL, params);
-}
-async function handleTextLarge(runtime, params) {
-  return generateTextWithModel(runtime, import_core4.ModelType.TEXT_LARGE, params);
-}
 
 // src/models/object.ts
-var import_core5 = require("@elizaos/core");
-var import_ai3 = require("ai");
 async function generateObjectWithModel(runtime, modelType, params) {
   const openrouter = createOpenRouterProvider(runtime);
   const modelName = modelType === import_core5.ModelType.OBJECT_SMALL ? getSmallModel(runtime) : getLargeModel(runtime);
@@ -365,7 +307,7 @@ async function generateObjectWithModel(runtime, modelType, params) {
   try {
     const { object, usage } = await import_ai3.generateObject({
       model: openrouter.chat(modelName),
-      ...params.schema && { schema: params.schema },
+      ...params.schema && { schema: import_ai3.jsonSchema(params.schema) },
       output: params.schema ? "object" : "no-schema",
       prompt: params.prompt,
       temperature,
@@ -600,6 +542,96 @@ async function handleImageGeneration(runtime, params) {
   }
 }
 
+// src/models/embedding.ts
+var import_core8 = require("@elizaos/core");
+async function handleTextEmbedding(runtime, params) {
+  const embeddingModelName = getEmbeddingModel(runtime);
+  const embeddingDimension = Number.parseInt(getSetting(runtime, "OPENROUTER_EMBEDDING_DIMENSIONS") ?? getSetting(runtime, "EMBEDDING_DIMENSIONS") ?? "1536", 10);
+  if (!Object.values(import_core8.VECTOR_DIMS).includes(embeddingDimension)) {
+    const errorMsg = `Invalid embedding dimension: ${embeddingDimension}. Must be one of: ${Object.values(import_core8.VECTOR_DIMS).join(", ")}`;
+    import_core8.logger.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  if (params === null) {
+    import_core8.logger.debug("Creating test embedding for initialization");
+    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_core8.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_core8.logger.warn(errorMsg);
+    const fallbackVector = Array(embeddingDimension).fill(0);
+    fallbackVector[0] = 0.3;
+    return fallbackVector;
+  }
+  const apiKey = getApiKey(runtime);
+  if (!apiKey) {
+    const errorMsg = "OPENROUTER_API_KEY is not set";
+    import_core8.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_core8.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_core8.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_core8.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_core8.ModelType.TEXT_EMBEDDING, text, usage);
+    }
+    import_core8.logger.log(`Got valid embedding with length ${embedding.length}`);
+    return embedding;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    import_core8.logger.error(`Error generating embedding: ${message}`);
+    throw error instanceof Error ? error : new Error(message);
+  }
+}
+
 // src/index.ts
 var openrouterPlugin = {
   name: "openrouter",
@@ -611,36 +643,163 @@ var openrouterPlugin = {
     OPENROUTER_LARGE_MODEL: process.env.OPENROUTER_LARGE_MODEL,
     OPENROUTER_IMAGE_MODEL: process.env.OPENROUTER_IMAGE_MODEL,
     OPENROUTER_IMAGE_GENERATION_MODEL: process.env.OPENROUTER_IMAGE_GENERATION_MODEL,
+    OPENROUTER_EMBEDDING_MODEL: process.env.OPENROUTER_EMBEDDING_MODEL,
+    OPENROUTER_EMBEDDING_DIMENSIONS: process.env.OPENROUTER_EMBEDDING_DIMENSIONS,
     OPENROUTER_AUTO_CLEANUP_IMAGES: process.env.OPENROUTER_AUTO_CLEANUP_IMAGES,
     SMALL_MODEL: process.env.SMALL_MODEL,
     LARGE_MODEL: process.env.LARGE_MODEL,
     IMAGE_MODEL: process.env.IMAGE_MODEL,
-    IMAGE_GENERATION_MODEL: process.env.IMAGE_GENERATION_MODEL
+    IMAGE_GENERATION_MODEL: process.env.IMAGE_GENERATION_MODEL,
+    EMBEDDING_MODEL: process.env.EMBEDDING_MODEL,
+    EMBEDDING_DIMENSIONS: process.env.EMBEDDING_DIMENSIONS
   },
   async init(config, runtime) {
     initializeOpenRouter(config, runtime);
   },
   models: {
-    [import_core8.ModelType.TEXT_SMALL]: async (runtime, params) => {
+    [import_core9.ModelType.TEXT_SMALL]: async (runtime, params) => {
       return handleTextSmall(runtime, params);
     },
-    [import_core8.ModelType.TEXT_LARGE]: async (runtime, params) => {
+    [import_core9.ModelType.TEXT_LARGE]: async (runtime, params) => {
       return handleTextLarge(runtime, params);
     },
-    [import_core8.ModelType.OBJECT_SMALL]: async (runtime, params) => {
+    [import_core9.ModelType.OBJECT_SMALL]: async (runtime, params) => {
       return handleObjectSmall(runtime, params);
     },
-    [import_core8.ModelType.OBJECT_LARGE]: async (runtime, params) => {
+    [import_core9.ModelType.OBJECT_LARGE]: async (runtime, params) => {
       return handleObjectLarge(runtime, params);
     },
-    [import_core8.ModelType.IMAGE_DESCRIPTION]: async (runtime, params) => {
+    [import_core9.ModelType.IMAGE_DESCRIPTION]: async (runtime, params) => {
       return handleImageDescription(runtime, params);
     },
-    [import_core8.ModelType.IMAGE]: async (runtime, params) => {
+    [import_core9.ModelType.IMAGE]: async (runtime, params) => {
       return handleImageGeneration(runtime, params);
+    },
+    [import_core9.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 text = await runtime.useModel(import_core9.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_core9.logger.log({ text }, "generated with test_text_small");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              import_core9.logger.error(`Error in test_text_small: ${message}`);
+              throw error;
+            }
+          }
+        },
+        {
+          name: "openrouter_test_text_large",
+          fn: async (runtime) => {
+            try {
+              const text = await runtime.useModel(import_core9.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_core9.logger.log({ text }, "generated with test_text_large");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              import_core9.logger.error(`Error in test_text_large: ${message}`);
+              throw error;
+            }
+          }
+        },
+        {
+          name: "openrouter_test_text_generation_large",
+          fn: async (runtime) => {
+            try {
+              const result = await runtime.useModel(import_core9.ModelType.TEXT_LARGE, {
+                prompt: "Say hello in 5 words."
+              });
+              if (!result || result.length === 0) {
+                throw new Error("Text generation returned empty result");
+              }
+              import_core9.logger.log({ result }, "Text generation test completed");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              import_core9.logger.error(`Error in openrouter_test_text_generation_large: ${message}`);
+              throw error;
+            }
+          }
+        },
+        {
+          name: "openrouter_test_streaming",
+          fn: async (runtime) => {
+            try {
+              const chunks = [];
+              const result = await runtime.useModel(import_core9.ModelType.TEXT_LARGE, {
+                prompt: "Count from 1 to 5.",
+                onStreamChunk: (chunk) => {
+                  chunks.push(chunk);
+                }
+              });
+              if (!result || result.length === 0) {
+                throw new Error("Streaming returned empty result");
+              }
+              if (chunks.length === 0) {
+                throw new Error("No streaming chunks received");
+              }
+              import_core9.logger.log({ chunks: chunks.length, result: result.substring(0, 50) }, "Streaming test completed");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              import_core9.logger.error(`Error in openrouter_test_streaming: ${message}`);
+              throw error;
+            }
+          }
+        },
+        {
+          name: "openrouter_test_object_small",
+          fn: async (runtime) => {
+            try {
+              const result = await runtime.useModel(import_core9.ModelType.OBJECT_SMALL, {
+                prompt: "Create a simple JSON object with a message field saying hello",
+                schema: { type: "object" }
+              });
+              import_core9.logger.log({ result }, "Generated object with test_object_small");
+              if (!result || typeof result === "object" && "error" in result) {
+                throw new Error("Failed to generate object");
+              }
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              import_core9.logger.error(`Error in test_object_small: ${message}`);
+              throw error;
+            }
+          }
+        },
+        {
+          name: "openrouter_test_text_embedding",
+          fn: async (runtime) => {
+            try {
+              const embedding = await runtime.useModel(import_core9.ModelType.TEXT_EMBEDDING, {
+                text: "Hello, world!"
+              });
+              import_core9.logger.log({ embedding }, "embedding");
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              import_core9.logger.error(`Error in test_text_embedding: ${message}`);
+              throw error;
+            }
+          }
+        }
+      ]
+    }
+  ]
 };
 var src_default = openrouterPlugin;
 
-//# debugId=CE876441FA57CD5464756E2164756E21
+//# debugId=65CA0E3B77F6CA5664756E2164756E21