@elizaos/plugin-google-genai 2.0.0-alpha.4 → 2.0.0-alpha.537

package/dist/cjs/index.node.cjs

@@ -1,28 +1,62 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 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 __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  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: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
 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)
     });
 };
 
@@ -30,12 +64,13 @@ var __export = (target, all) => {
 var exports_index_node = {};
 __export(exports_index_node, {
   googleGenAIPlugin: () => googleGenAIPlugin,
-  default: () => typescript_default
+  default: () => index_node_default
 });
 module.exports = __toCommonJS(exports_index_node);
 
 // index.ts
-var import_core8 = require("@elizaos/core");
+var ElizaCore3 = __toESM(require("@elizaos/core"));
+var import_core7 = require("@elizaos/core");
 var import_genai3 = require("@google/genai");
 
 // init.ts
@@ -65,9 +100,24 @@ function getApiKey(runtime) {
 function getSmallModel(runtime) {
   return getSetting(runtime, "GOOGLE_SMALL_MODEL") ?? getSetting(runtime, "SMALL_MODEL", "gemini-2.0-flash-001") ?? "gemini-2.0-flash-001";
 }
+function getNanoModel(runtime) {
+  return getSetting(runtime, "GOOGLE_NANO_MODEL") ?? getSetting(runtime, "NANO_MODEL") ?? getSmallModel(runtime);
+}
+function getMediumModel(runtime) {
+  return getSetting(runtime, "GOOGLE_MEDIUM_MODEL") ?? getSetting(runtime, "MEDIUM_MODEL") ?? getSmallModel(runtime);
+}
 function getLargeModel(runtime) {
   return getSetting(runtime, "GOOGLE_LARGE_MODEL") ?? getSetting(runtime, "LARGE_MODEL", "gemini-2.5-pro-preview-03-25") ?? "gemini-2.5-pro-preview-03-25";
 }
+function getMegaModel(runtime) {
+  return getSetting(runtime, "GOOGLE_MEGA_MODEL") ?? getSetting(runtime, "MEGA_MODEL") ?? getLargeModel(runtime);
+}
+function getResponseHandlerModel(runtime) {
+  return getSetting(runtime, "GOOGLE_RESPONSE_HANDLER_MODEL") ?? getSetting(runtime, "GOOGLE_SHOULD_RESPOND_MODEL") ?? getSetting(runtime, "RESPONSE_HANDLER_MODEL") ?? getSetting(runtime, "SHOULD_RESPOND_MODEL") ?? getNanoModel(runtime);
+}
+function getActionPlannerModel(runtime) {
+  return getSetting(runtime, "GOOGLE_ACTION_PLANNER_MODEL") ?? getSetting(runtime, "GOOGLE_PLANNER_MODEL") ?? getSetting(runtime, "ACTION_PLANNER_MODEL") ?? getSetting(runtime, "PLANNER_MODEL") ?? getMediumModel(runtime);
+}
 function getImageModel(runtime) {
   return getSetting(runtime, "GOOGLE_IMAGE_MODEL") ?? getSetting(runtime, "IMAGE_MODEL", "gemini-2.5-pro-preview-03-25") ?? "gemini-2.5-pro-preview-03-25";
 }
@@ -126,12 +176,13 @@ function initializeGoogleGenAI(_config, runtime) {
 }
 
 // models/embedding.ts
-var import_core4 = require("@elizaos/core");
+var ElizaCore = __toESM(require("@elizaos/core"));
+var import_core3 = require("@elizaos/core");
 
 // utils/events.ts
-var import_core3 = require("@elizaos/core");
+var MODEL_USED_EVENT = "MODEL_USED";
 function emitModelUsageEvent(runtime, type, _prompt, usage) {
-  runtime.emitEvent(import_core3.EventType.MODEL_USED, {
+  runtime.emitEvent(MODEL_USED_EVENT, {
     runtime,
     source: "plugin-google-genai",
     type,
@@ -149,24 +200,25 @@ async function countTokens(text) {
 }
 
 // models/embedding.ts
+var TEXT_EMBEDDING_MODEL_TYPE = ElizaCore.ModelType?.TEXT_EMBEDDING ?? "TEXT_EMBEDDING";
 async function handleTextEmbedding(runtime, params) {
   const genAI = createGoogleGenAI(runtime);
   if (!genAI) {
     throw new Error("Google Generative AI client not initialized");
   }
   const embeddingModelName = getEmbeddingModel(runtime);
-  import_core4.logger.debug(`[TEXT_EMBEDDING] Using model: ${embeddingModelName}`);
+  import_core3.logger.debug(`[TEXT_EMBEDDING] Using model: ${embeddingModelName}`);
   if (params === null) {
     return Array(768).fill(0);
   }
   let text = typeof params === "string" ? params : typeof params === "object" && params.text ? params.text : "";
   if (!text.trim()) {
-    import_core4.logger.warn("Empty text for embedding");
+    import_core3.logger.warn("Empty text for embedding");
     return Array(768).fill(0);
   }
-  const maxChars = import_core4.MAX_EMBEDDING_TOKENS * 4;
+  const maxChars = 8192 * 4;
   if (text.length > maxChars) {
-    import_core4.logger.warn(`[Google GenAI] Embedding input too long (~${Math.ceil(text.length / 4)} tokens), truncating to ~${import_core4.MAX_EMBEDDING_TOKENS} tokens`);
+    import_core3.logger.warn(`[Google GenAI] Embedding input too long (~${Math.ceil(text.length / 4)} tokens), truncating to ~8192 tokens`);
     text = text.slice(0, maxChars);
   }
   try {
@@ -176,20 +228,20 @@ async function handleTextEmbedding(runtime, params) {
     });
     const embedding = response.embeddings?.[0]?.values || [];
     const promptTokens = await countTokens(text);
-    emitModelUsageEvent(runtime, import_core4.ModelType.TEXT_EMBEDDING, text, {
+    emitModelUsageEvent(runtime, TEXT_EMBEDDING_MODEL_TYPE, text, {
       promptTokens,
       completionTokens: 0,
       totalTokens: promptTokens
     });
-    import_core4.logger.log(`Got embedding with length ${embedding.length}`);
+    import_core3.logger.log(`Got embedding with length ${embedding.length}`);
     return embedding;
   } catch (error) {
-    import_core4.logger.error(`Error generating embedding: ${error instanceof Error ? error.message : String(error)}`);
+    import_core3.logger.error(`Error generating embedding: ${error instanceof Error ? error.message : String(error)}`);
     return Array(768).fill(0);
   }
 }
 // models/image.ts
-var import_core5 = require("@elizaos/core");
+var import_core4 = require("@elizaos/core");
 var crossFetch = typeof globalThis.fetch === "function" ? globalThis.fetch : fetch;
 async function handleImageDescription(runtime, params) {
   const genAI = createGoogleGenAI(runtime);
@@ -199,7 +251,7 @@ async function handleImageDescription(runtime, params) {
   let imageUrl;
   let promptText;
   const modelName = getImageModel(runtime);
-  import_core5.logger.log(`[IMAGE_DESCRIPTION] Using model: ${modelName}`);
+  import_core4.logger.log(`[IMAGE_DESCRIPTION] Using model: ${modelName}`);
   if (typeof params === "string") {
     imageUrl = params;
     promptText = "Please analyze this image and provide a title and detailed description.";
@@ -255,7 +307,7 @@ async function handleImageDescription(runtime, params) {
     return { title, description };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    import_core5.logger.error(`Error analyzing image: ${message}`);
+    import_core4.logger.error(`Error analyzing image: ${message}`);
     return {
       title: "Failed to analyze image",
       description: `Error: ${message}`
@@ -263,7 +315,7 @@ async function handleImageDescription(runtime, params) {
   }
 }
 // models/object.ts
-var import_core6 = require("@elizaos/core");
+var import_core5 = require("@elizaos/core");
 async function generateObjectByModelType(runtime, params, modelType, getModelFn) {
   const genAI = createGoogleGenAI(runtime);
   if (!genAI) {
@@ -271,7 +323,7 @@ async function generateObjectByModelType(runtime, params, modelType, getModelFn)
   }
   const modelName = getModelFn(runtime);
   const temperature = params.temperature ?? 0.1;
-  import_core6.logger.info(`Using ${modelType} model: ${modelName}`);
+  import_core5.logger.info(`Using ${modelType} model: ${modelName}`);
   try {
     let enhancedPrompt = params.prompt;
     if (params.schema) {
@@ -314,7 +366,7 @@ ${JSON.stringify(params.schema, null, 2)}`;
       throw new Error("Failed to parse JSON from response");
     }
   } catch (error) {
-    import_core6.logger.error(`[generateObject] Error: ${error instanceof Error ? error.message : String(error)}`);
+    import_core5.logger.error(`[generateObject] Error: ${error instanceof Error ? error.message : String(error)}`);
     throw error;
   }
 }
@@ -325,19 +377,136 @@ async function handleObjectLarge(runtime, params) {
   return generateObjectByModelType(runtime, params, "OBJECT_LARGE", getLargeModel);
 }
 // models/text.ts
-var import_core7 = require("@elizaos/core");
-async function handleTextSmall(runtime, { prompt, stopSequences = [], maxTokens = 8192, temperature = 0.7 }) {
+var ElizaCore2 = __toESM(require("@elizaos/core"));
+var import_core6 = require("@elizaos/core");
+var CORE_MODEL_TYPES = ElizaCore2.ModelType ?? {};
+var TEXT_NANO_MODEL_TYPE = CORE_MODEL_TYPES.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE = CORE_MODEL_TYPES.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_SMALL_MODEL_TYPE = CORE_MODEL_TYPES.TEXT_SMALL ?? "TEXT_SMALL";
+var TEXT_LARGE_MODEL_TYPE = CORE_MODEL_TYPES.TEXT_LARGE ?? "TEXT_LARGE";
+var TEXT_MEGA_MODEL_TYPE = CORE_MODEL_TYPES.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE = CORE_MODEL_TYPES.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE = CORE_MODEL_TYPES.ACTION_PLANNER ?? "ACTION_PLANNER";
+function buildPromptParts(prompt, attachments) {
+  const parts = [{ text: prompt }];
+  for (const attachment of attachments ?? []) {
+    if (attachment.data instanceof URL) {
+      parts.push({
+        fileData: {
+          mimeType: attachment.mediaType,
+          fileUri: attachment.data.toString()
+        }
+      });
+      continue;
+    }
+    if (typeof attachment.data === "string" && /^https?:\/\//i.test(attachment.data)) {
+      parts.push({
+        fileData: {
+          mimeType: attachment.mediaType,
+          fileUri: attachment.data
+        }
+      });
+      continue;
+    }
+    if (typeof attachment.data === "string") {
+      const dataUrlMatch = attachment.data.match(/^data:([^;,]+);base64,(.+)$/i);
+      parts.push({
+        inlineData: {
+          mimeType: dataUrlMatch?.[1] ?? attachment.mediaType,
+          data: dataUrlMatch?.[2] ?? attachment.data
+        }
+      });
+      continue;
+    }
+    parts.push({
+      inlineData: {
+        mimeType: attachment.mediaType,
+        data: Buffer.from(attachment.data).toString("base64")
+      }
+    });
+  }
+  return parts;
+}
+function getModelNameForType(runtime, modelType) {
+  switch (modelType) {
+    case TEXT_NANO_MODEL_TYPE:
+      return getNanoModel(runtime);
+    case TEXT_MEDIUM_MODEL_TYPE:
+      return getMediumModel(runtime);
+    case TEXT_SMALL_MODEL_TYPE:
+      return getSmallModel(runtime);
+    case TEXT_LARGE_MODEL_TYPE:
+      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);
+  }
+}
+async function handleTextSmall(runtime, {
+  prompt,
+  stopSequences = [],
+  maxTokens = 8192,
+  temperature = 0.7,
+  attachments
+}) {
+  const genAI = createGoogleGenAI(runtime);
+  if (!genAI) {
+    throw new Error("Google Generative AI client not initialized");
+  }
+  const modelName = getModelNameForType(runtime, TEXT_SMALL_MODEL_TYPE);
+  import_core6.logger.log(`[TEXT_SMALL] Using model: ${modelName}`);
+  try {
+    const systemInstruction = runtime.character.system || undefined;
+    const response = await genAI.models.generateContent({
+      model: modelName,
+      contents: (attachments?.length ?? 0) > 0 ? [{ role: "user", parts: buildPromptParts(prompt, attachments) }] : prompt,
+      config: {
+        temperature,
+        topK: 40,
+        topP: 0.95,
+        maxOutputTokens: maxTokens,
+        stopSequences,
+        safetySettings: getSafetySettings(),
+        ...systemInstruction && { systemInstruction }
+      }
+    });
+    const text = response.text || "";
+    const promptTokens = await countTokens(prompt);
+    const completionTokens = await countTokens(text);
+    emitModelUsageEvent(runtime, TEXT_SMALL_MODEL_TYPE, prompt, {
+      promptTokens,
+      completionTokens,
+      totalTokens: promptTokens + completionTokens
+    });
+    return text;
+  } catch (error) {
+    import_core6.logger.error(`[TEXT_SMALL] Error: ${error instanceof Error ? error.message : String(error)}`);
+    throw error;
+  }
+}
+async function handleTextLarge(runtime, {
+  prompt,
+  stopSequences = [],
+  maxTokens = 8192,
+  temperature = 0.7,
+  attachments
+}) {
   const genAI = createGoogleGenAI(runtime);
   if (!genAI) {
     throw new Error("Google Generative AI client not initialized");
   }
-  const modelName = getSmallModel(runtime);
-  import_core7.logger.log(`[TEXT_SMALL] Using model: ${modelName}`);
+  const modelName = getModelNameForType(runtime, TEXT_LARGE_MODEL_TYPE);
+  import_core6.logger.log(`[TEXT_LARGE] Using model: ${modelName}`);
   try {
     const systemInstruction = runtime.character.system || undefined;
     const response = await genAI.models.generateContent({
       model: modelName,
-      contents: prompt,
+      contents: (attachments?.length ?? 0) > 0 ? [{ role: "user", parts: buildPromptParts(prompt, attachments) }] : prompt,
       config: {
         temperature,
         topK: 40,
@@ -351,29 +520,50 @@ async function handleTextSmall(runtime, { prompt, stopSequences = [], maxTokens
     const text = response.text || "";
     const promptTokens = await countTokens(prompt);
     const completionTokens = await countTokens(text);
-    emitModelUsageEvent(runtime, import_core7.ModelType.TEXT_SMALL, prompt, {
+    emitModelUsageEvent(runtime, TEXT_LARGE_MODEL_TYPE, prompt, {
       promptTokens,
       completionTokens,
       totalTokens: promptTokens + completionTokens
     });
     return text;
   } catch (error) {
-    import_core7.logger.error(`[TEXT_SMALL] Error: ${error instanceof Error ? error.message : String(error)}`);
+    import_core6.logger.error(`[TEXT_LARGE] Error: ${error instanceof Error ? error.message : String(error)}`);
     throw error;
   }
 }
-async function handleTextLarge(runtime, { prompt, stopSequences = [], maxTokens = 8192, temperature = 0.7 }) {
+async function handleTextNano(runtime, params) {
+  return handleTextWithType(runtime, TEXT_NANO_MODEL_TYPE, params);
+}
+async function handleTextMedium(runtime, params) {
+  return handleTextWithType(runtime, TEXT_MEDIUM_MODEL_TYPE, params);
+}
+async function handleTextMega(runtime, params) {
+  return handleTextWithType(runtime, TEXT_MEGA_MODEL_TYPE, params);
+}
+async function handleResponseHandler(runtime, params) {
+  return handleTextWithType(runtime, RESPONSE_HANDLER_MODEL_TYPE, params);
+}
+async function handleActionPlanner(runtime, params) {
+  return handleTextWithType(runtime, ACTION_PLANNER_MODEL_TYPE, params);
+}
+async function handleTextWithType(runtime, modelType, {
+  prompt,
+  stopSequences = [],
+  maxTokens = 8192,
+  temperature = 0.7,
+  attachments
+}) {
   const genAI = createGoogleGenAI(runtime);
   if (!genAI) {
     throw new Error("Google Generative AI client not initialized");
   }
-  const modelName = getLargeModel(runtime);
-  import_core7.logger.log(`[TEXT_LARGE] Using model: ${modelName}`);
+  const modelName = getModelNameForType(runtime, modelType);
+  import_core6.logger.log(`[${modelType}] Using model: ${modelName}`);
   try {
     const systemInstruction = runtime.character.system || undefined;
     const response = await genAI.models.generateContent({
       model: modelName,
-      contents: prompt,
+      contents: (attachments?.length ?? 0) > 0 ? [{ role: "user", parts: buildPromptParts(prompt, attachments) }] : prompt,
       config: {
         temperature,
         topK: 40,
@@ -387,18 +577,30 @@ async function handleTextLarge(runtime, { prompt, stopSequences = [], maxTokens
     const text = response.text || "";
     const promptTokens = await countTokens(prompt);
     const completionTokens = await countTokens(text);
-    emitModelUsageEvent(runtime, import_core7.ModelType.TEXT_LARGE, prompt, {
+    emitModelUsageEvent(runtime, modelType, prompt, {
       promptTokens,
       completionTokens,
       totalTokens: promptTokens + completionTokens
     });
     return text;
   } catch (error) {
-    import_core7.logger.error(`[TEXT_LARGE] Error: ${error instanceof Error ? error.message : String(error)}`);
+    import_core6.logger.error(`[${modelType}] Error: ${error instanceof Error ? error.message : String(error)}`);
     throw error;
   }
 }
 // index.ts
+var CORE_MODEL_TYPES2 = ElizaCore3.ModelType ?? {};
+var TEXT_NANO_MODEL_TYPE2 = CORE_MODEL_TYPES2.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE2 = CORE_MODEL_TYPES2.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_SMALL_MODEL_TYPE2 = CORE_MODEL_TYPES2.TEXT_SMALL ?? "TEXT_SMALL";
+var TEXT_LARGE_MODEL_TYPE2 = CORE_MODEL_TYPES2.TEXT_LARGE ?? "TEXT_LARGE";
+var TEXT_EMBEDDING_MODEL_TYPE2 = CORE_MODEL_TYPES2.TEXT_EMBEDDING ?? "TEXT_EMBEDDING";
+var IMAGE_DESCRIPTION_MODEL_TYPE = CORE_MODEL_TYPES2.IMAGE_DESCRIPTION ?? "IMAGE_DESCRIPTION";
+var OBJECT_SMALL_MODEL_TYPE = CORE_MODEL_TYPES2.OBJECT_SMALL ?? "OBJECT_SMALL";
+var OBJECT_LARGE_MODEL_TYPE = CORE_MODEL_TYPES2.OBJECT_LARGE ?? "OBJECT_LARGE";
+var TEXT_MEGA_MODEL_TYPE2 = CORE_MODEL_TYPES2.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE2 = CORE_MODEL_TYPES2.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE2 = CORE_MODEL_TYPES2.ACTION_PLANNER ?? "ACTION_PLANNER";
 var pluginTests = [
   {
     name: "google_genai_plugin_tests",
@@ -416,22 +618,22 @@ var pluginTests = [
           for await (const model of modelList) {
             models.push(model);
           }
-          import_core8.logger.log(`Available models: ${models.length}`);
+          import_core7.logger.log(`Available models: ${models.length}`);
         }
       },
       {
         name: "google_test_text_embedding",
         fn: async (runtime) => {
           try {
-            const embedding = await runtime.useModel(import_core8.ModelType.TEXT_EMBEDDING, {
+            const embedding = await runtime.useModel(import_core7.ModelType.TEXT_EMBEDDING, {
               text: "Hello, world!"
             });
-            import_core8.logger.log(`Embedding dimension: ${embedding.length}`);
+            import_core7.logger.log(`Embedding dimension: ${embedding.length}`);
             if (embedding.length === 0) {
               throw new Error("Failed to generate embedding");
             }
           } catch (error) {
-            import_core8.logger.error(`Error in test_text_embedding: ${error instanceof Error ? error.message : String(error)}`);
+            import_core7.logger.error(`Error in test_text_embedding: ${error instanceof Error ? error.message : String(error)}`);
             throw error;
           }
         }
@@ -440,15 +642,15 @@ var pluginTests = [
         name: "google_test_text_small",
         fn: async (runtime) => {
           try {
-            const text = await runtime.useModel(import_core8.ModelType.TEXT_SMALL, {
+            const text = await runtime.useModel(import_core7.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("Generated with TEXT_SMALL:", text);
+            import_core7.logger.log("Generated with TEXT_SMALL:", text);
           } catch (error) {
-            import_core8.logger.error(`Error in test_text_small: ${error instanceof Error ? error.message : String(error)}`);
+            import_core7.logger.error(`Error in test_text_small: ${error instanceof Error ? error.message : String(error)}`);
             throw error;
           }
         }
@@ -457,15 +659,15 @@ var pluginTests = [
         name: "google_test_text_large",
         fn: async (runtime) => {
           try {
-            const text = await runtime.useModel(import_core8.ModelType.TEXT_LARGE, {
+            const text = await runtime.useModel(import_core7.ModelType.TEXT_LARGE, {
               prompt: "Explain quantum mechanics in simple terms."
             });
             if (text.length === 0) {
               throw new Error("Failed to generate text");
             }
-            import_core8.logger.log("Generated with TEXT_LARGE:", `${text.substring(0, 100)}...`);
+            import_core7.logger.log("Generated with TEXT_LARGE:", `${text.substring(0, 100)}...`);
           } catch (error) {
-            import_core8.logger.error(`Error in test_text_large: ${error instanceof Error ? error.message : String(error)}`);
+            import_core7.logger.error(`Error in test_text_large: ${error instanceof Error ? error.message : String(error)}`);
             throw error;
           }
         }
@@ -474,14 +676,14 @@ var pluginTests = [
         name: "google_test_image_description",
         fn: async (runtime) => {
           try {
-            const result = await runtime.useModel(import_core8.ModelType.IMAGE_DESCRIPTION, "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1c/Vitalik_Buterin_TechCrunch_London_2015_%28cropped%29.jpg/537px-Vitalik_Buterin_TechCrunch_London_2015_%28cropped%29.jpg");
-            if (result && typeof result === "object" && "title" in result && "description" in result) {
-              import_core8.logger.log("Image description:", JSON.stringify(result));
+            const result = await runtime.useModel(import_core7.ModelType.IMAGE_DESCRIPTION, "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1c/Vitalik_Buterin_TechCrunch_London_2015_%28cropped%29.jpg/537px-Vitalik_Buterin_TechCrunch_London_2015_%28cropped%29.jpg");
+            if (result != null && typeof result === "object" && "title" in result && "description" in result) {
+              import_core7.logger.log("Image description:", JSON.stringify(result));
             } else {
-              import_core8.logger.error(`Invalid image description result format: ${JSON.stringify(result)}`);
+              import_core7.logger.error(`Invalid image description result format: ${JSON.stringify(result)}`);
             }
           } catch (error) {
-            import_core8.logger.error(`Error in test_image_description: ${error instanceof Error ? error.message : String(error)}`);
+            import_core7.logger.error(`Error in test_image_description: ${error instanceof Error ? error.message : String(error)}`);
             throw error;
           }
         }
@@ -499,16 +701,16 @@ var pluginTests = [
               },
               required: ["name", "age", "hobbies"]
             };
-            const result = await runtime.useModel(import_core8.ModelType.OBJECT_SMALL, {
+            const result = await runtime.useModel(import_core7.ModelType.OBJECT_SMALL, {
               prompt: "Generate a person profile with name, age, and hobbies.",
               schema
             });
-            import_core8.logger.log("Generated object:", JSON.stringify(result));
-            if (!result.name || !result.age || !result.hobbies) {
+            import_core7.logger.log("Generated object:", JSON.stringify(result));
+            if (!result?.name || !result?.age || !result?.hobbies) {
               throw new Error("Generated object missing required fields");
             }
           } catch (error) {
-            import_core8.logger.error(`Error in test_object_generation: ${error instanceof Error ? error.message : String(error)}`);
+            import_core7.logger.error(`Error in test_object_generation: ${error instanceof Error ? error.message : String(error)}`);
             throw error;
           }
         }
@@ -528,39 +730,71 @@ var googleGenAIPlugin = {
   description: "Google Generative AI plugin for Gemini models",
   config: {
     GOOGLE_GENERATIVE_AI_API_KEY: env.GOOGLE_GENERATIVE_AI_API_KEY ?? null,
+    GOOGLE_NANO_MODEL: env.GOOGLE_NANO_MODEL ?? null,
+    GOOGLE_MEDIUM_MODEL: env.GOOGLE_MEDIUM_MODEL ?? null,
     GOOGLE_SMALL_MODEL: env.GOOGLE_SMALL_MODEL ?? null,
     GOOGLE_LARGE_MODEL: env.GOOGLE_LARGE_MODEL ?? null,
+    GOOGLE_MEGA_MODEL: env.GOOGLE_MEGA_MODEL ?? null,
+    GOOGLE_RESPONSE_HANDLER_MODEL: env.GOOGLE_RESPONSE_HANDLER_MODEL ?? null,
+    GOOGLE_SHOULD_RESPOND_MODEL: env.GOOGLE_SHOULD_RESPOND_MODEL ?? null,
+    GOOGLE_ACTION_PLANNER_MODEL: env.GOOGLE_ACTION_PLANNER_MODEL ?? null,
+    GOOGLE_PLANNER_MODEL: env.GOOGLE_PLANNER_MODEL ?? null,
     GOOGLE_IMAGE_MODEL: env.GOOGLE_IMAGE_MODEL ?? null,
     GOOGLE_EMBEDDING_MODEL: env.GOOGLE_EMBEDDING_MODEL ?? 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
   },
   async init(config, runtime) {
     initializeGoogleGenAI(config, runtime);
   },
   models: {
-    [import_core8.ModelType.TEXT_SMALL]: async (runtime, params) => {
+    [TEXT_NANO_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextNano(runtime, params);
+    },
+    [TEXT_MEDIUM_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMedium(runtime, params);
+    },
+    [TEXT_SMALL_MODEL_TYPE2]: async (runtime, params) => {
       return handleTextSmall(runtime, params);
     },
-    [import_core8.ModelType.TEXT_LARGE]: async (runtime, params) => {
+    [TEXT_LARGE_MODEL_TYPE2]: async (runtime, params) => {
       return handleTextLarge(runtime, params);
     },
-    [import_core8.ModelType.TEXT_EMBEDDING]: async (runtime, params) => {
+    [TEXT_MEGA_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMega(runtime, params);
+    },
+    [RESPONSE_HANDLER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleResponseHandler(runtime, params);
+    },
+    [ACTION_PLANNER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleActionPlanner(runtime, params);
+    },
+    [TEXT_EMBEDDING_MODEL_TYPE2]: async (runtime, params) => {
       return handleTextEmbedding(runtime, params);
     },
-    [import_core8.ModelType.IMAGE_DESCRIPTION]: async (runtime, params) => {
+    [IMAGE_DESCRIPTION_MODEL_TYPE]: async (runtime, params) => {
       return handleImageDescription(runtime, params);
     },
-    [import_core8.ModelType.OBJECT_SMALL]: async (runtime, params) => {
+    [OBJECT_SMALL_MODEL_TYPE]: async (runtime, params) => {
       return handleObjectSmall(runtime, params);
     },
-    [import_core8.ModelType.OBJECT_LARGE]: async (runtime, params) => {
+    [OBJECT_LARGE_MODEL_TYPE]: async (runtime, params) => {
       return handleObjectLarge(runtime, params);
     }
   },
   tests: pluginTests
 };
-var typescript_default = googleGenAIPlugin;
+var plugin_google_genai_default = googleGenAIPlugin;
+
+// index.node.ts
+var index_node_default = plugin_google_genai_default;
 
-//# debugId=6202952FEAB7816664756E2164756E21
+//# debugId=43A781C1488C22D064756E2164756E21