@elizaos/plugin-google-genai 2.0.0-alpha.9 → 2.0.0-beta.1

package/dist/node/index.node.js

@@ -1,5 +1,6 @@
 // index.ts
-import { logger as logger7, ModelType as ModelType3 } from "@elizaos/core";
+import * as ElizaCore3 from "@elizaos/core";
+import { logger as logger6, ModelType as ModelType4 } from "@elizaos/core";
 import { GoogleGenAI as GoogleGenAI3 } from "@google/genai";
 
 // init.ts
@@ -29,9 +30,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";
 }
@@ -90,12 +106,13 @@ function initializeGoogleGenAI(_config, runtime) {
 }
 
 // models/embedding.ts
-import { logger as logger3, ModelType } from "@elizaos/core";
+import * as ElizaCore from "@elizaos/core";
+import { logger as logger3 } from "@elizaos/core";
 
 // utils/events.ts
-import { EventType } from "@elizaos/core";
+var MODEL_USED_EVENT = "MODEL_USED";
 function emitModelUsageEvent(runtime, type, _prompt, usage) {
-  runtime.emitEvent(EventType.MODEL_USED, {
+  runtime.emitEvent(MODEL_USED_EVENT, {
     runtime,
     source: "plugin-google-genai",
     type,
@@ -113,6 +130,7 @@ 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) {
@@ -123,11 +141,16 @@ async function handleTextEmbedding(runtime, params) {
   if (params === null) {
     return Array(768).fill(0);
   }
-  const text = typeof params === "string" ? params : typeof params === "object" && params.text ? params.text : "";
+  let text = typeof params === "string" ? params : typeof params === "object" && params.text ? params.text : "";
   if (!text.trim()) {
     logger3.warn("Empty text for embedding");
     return Array(768).fill(0);
   }
+  const maxChars = 8192 * 4;
+  if (text.length > maxChars) {
+    logger3.warn(`[Google GenAI] Embedding input too long (~${Math.ceil(text.length / 4)} tokens), truncating to ~8192 tokens`);
+    text = text.slice(0, maxChars);
+  }
   try {
     const response = await genAI.models.embedContent({
       model: embeddingModelName,
@@ -135,7 +158,7 @@ async function handleTextEmbedding(runtime, params) {
     });
     const embedding = response.embeddings?.[0]?.values || [];
     const promptTokens = await countTokens(text);
-    emitModelUsageEvent(runtime, ModelType.TEXT_EMBEDDING, text, {
+    emitModelUsageEvent(runtime, TEXT_EMBEDDING_MODEL_TYPE, text, {
       promptTokens,
       completionTokens: 0,
       totalTokens: promptTokens
@@ -148,8 +171,7 @@ async function handleTextEmbedding(runtime, params) {
   }
 }
 // models/image.ts
-import { logger as logger4 } from "@elizaos/core";
-var crossFetch = typeof globalThis.fetch === "function" ? globalThis.fetch : fetch;
+import { logger as logger4, recordLlmCall } from "@elizaos/core";
 async function handleImageDescription(runtime, params) {
   const genAI = createGoogleGenAI(runtime);
   if (!genAI) {
@@ -167,36 +189,52 @@ async function handleImageDescription(runtime, params) {
     promptText = params.prompt || "Please analyze this image and provide a title and detailed description.";
   }
   try {
-    const imageResponse = await crossFetch(imageUrl);
+    const imageResponse = await fetch(imageUrl);
     if (!imageResponse.ok) {
       throw new Error(`Failed to fetch image: ${imageResponse.statusText}`);
     }
     const imageData = await imageResponse.arrayBuffer();
     const base64Image = Buffer.from(imageData).toString("base64");
     const contentType = imageResponse.headers.get("content-type") || "image/jpeg";
-    const response = await genAI.models.generateContent({
+    const details = {
       model: modelName,
-      contents: [
-        {
-          role: "user",
-          parts: [
-            { text: promptText },
-            {
-              inlineData: {
-                mimeType: contentType,
-                data: base64Image
+      systemPrompt: "",
+      userPrompt: promptText,
+      temperature: 0.7,
+      maxTokens: 8192,
+      purpose: "external_llm",
+      actionType: "google-genai.IMAGE_DESCRIPTION.generateContent"
+    };
+    const response = await recordLlmCall(runtime, details, async () => {
+      const result = await genAI.models.generateContent({
+        model: modelName,
+        contents: [
+          {
+            role: "user",
+            parts: [
+              { text: promptText },
+              {
+                inlineData: {
+                  mimeType: contentType,
+                  data: base64Image
+                }
               }
-            }
-          ]
+            ]
+          }
+        ],
+        config: {
+          temperature: 0.7,
+          topK: 40,
+          topP: 0.95,
+          maxOutputTokens: 8192,
+          safetySettings: getSafetySettings()
         }
-      ],
-      config: {
-        temperature: 0.7,
-        topK: 40,
-        topP: 0.95,
-        maxOutputTokens: 8192,
-        safetySettings: getSafetySettings()
-      }
+      });
+      const responseText2 = result.text || "";
+      details.response = responseText2;
+      details.promptTokens = await countTokens(promptText);
+      details.completionTokens = await countTokens(responseText2);
+      return result;
     });
     const responseText = response.text || "";
     try {
@@ -221,154 +259,327 @@ async function handleImageDescription(runtime, params) {
     };
   }
 }
-// models/object.ts
-import { logger as logger5 } from "@elizaos/core";
-async function generateObjectByModelType(runtime, params, modelType, getModelFn) {
-  const genAI = createGoogleGenAI(runtime);
-  if (!genAI) {
-    throw new Error("Google Generative AI client not initialized");
+// models/text.ts
+import * as ElizaCore2 from "@elizaos/core";
+import {
+  buildCanonicalSystemPrompt,
+  logger as logger5,
+  recordLlmCall as recordLlmCall2,
+  renderChatMessagesForPrompt,
+  resolveEffectiveSystemPrompt
+} from "@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 normalizeToolsForGoogle(tools) {
+  if (!tools)
+    return;
+  if (Array.isArray(tools) && tools.length > 0 && typeof tools[0] === "object" && tools[0] !== null && "functionDeclarations" in tools[0]) {
+    return tools;
   }
-  const modelName = getModelFn(runtime);
-  const temperature = params.temperature ?? 0.1;
-  logger5.info(`Using ${modelType} model: ${modelName}`);
-  try {
-    let enhancedPrompt = params.prompt;
-    if (params.schema) {
-      enhancedPrompt += `
-
-Please respond with a JSON object that follows this schema:
-${JSON.stringify(params.schema, null, 2)}`;
+  const flat = Array.isArray(tools) ? tools : Object.entries(tools).map(([name, value]) => ({ name, ...value }));
+  const declarations = [];
+  for (const tool of flat) {
+    const name = tool.name ?? tool.function?.name;
+    if (!name) {
+      throw new Error("[GoogleGenAI] Tool definition is missing a name.");
     }
-    const response = await genAI.models.generateContent({
-      model: modelName,
-      contents: enhancedPrompt,
-      config: {
-        temperature,
-        topK: 40,
-        topP: 0.95,
-        maxOutputTokens: 8192,
-        responseMimeType: "application/json",
-        safetySettings: getSafetySettings()
-      }
-    });
-    const text = response.text || "";
-    const promptTokens = await countTokens(enhancedPrompt);
-    const completionTokens = await countTokens(text);
-    emitModelUsageEvent(runtime, modelType, params.prompt, {
-      promptTokens,
-      completionTokens,
-      totalTokens: promptTokens + completionTokens
+    const description = tool.description ?? tool.function?.description;
+    const parameters = tool.parameters ?? tool.inputSchema ?? tool.function?.parameters ?? {
+      type: "object",
+      properties: {}
+    };
+    declarations.push({
+      name,
+      ...description ? { description } : {},
+      parameters
     });
-    try {
-      return JSON.parse(text);
-    } catch {
-      const jsonMatch = text.match(/\{[\s\S]*\}/);
-      if (jsonMatch) {
-        try {
-          return JSON.parse(jsonMatch[0]);
-        } catch {
-          throw new Error("Failed to parse JSON from response");
-        }
+  }
+  return declarations.length > 0 ? [{ functionDeclarations: declarations }] : undefined;
+}
+function normalizeToolConfigForGoogle(toolChoice) {
+  if (!toolChoice)
+    return;
+  if (toolChoice === "auto") {
+    return { functionCallingConfig: { mode: "AUTO" } };
+  }
+  if (toolChoice === "required") {
+    return { functionCallingConfig: { mode: "ANY" } };
+  }
+  if (toolChoice === "none") {
+    return { functionCallingConfig: { mode: "NONE" } };
+  }
+  let toolName;
+  if ("type" in toolChoice) {
+    toolName = toolChoice.type === "function" ? toolChoice.function.name : toolChoice.toolName ?? toolChoice.name;
+  } else {
+    toolName = toolChoice.name;
+  }
+  if (toolName) {
+    return {
+      functionCallingConfig: {
+        mode: "ANY",
+        allowedFunctionNames: [toolName]
       }
-      throw new Error("Failed to parse JSON from response");
+    };
+  }
+  return;
+}
+function resolveResponseJsonSchema(responseSchema) {
+  if (!responseSchema)
+    return;
+  if ("schema" in responseSchema && responseSchema.schema) {
+    return responseSchema.schema;
+  }
+  return responseSchema;
+}
+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;
     }
-  } catch (error) {
-    logger5.error(`[generateObject] Error: ${error instanceof Error ? error.message : String(error)}`);
-    throw error;
+    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;
 }
-async function handleObjectSmall(runtime, params) {
-  return generateObjectByModelType(runtime, params, "OBJECT_SMALL", getSmallModel);
+function resolveGoogleSystemInstruction(runtime, params) {
+  return resolveEffectiveSystemPrompt({
+    params,
+    fallback: buildCanonicalSystemPrompt({ character: runtime.character })
+  });
 }
-async function handleObjectLarge(runtime, params) {
-  return generateObjectByModelType(runtime, params, "OBJECT_LARGE", getLargeModel);
+function resolveGooglePrompt(params, systemInstruction) {
+  return renderChatMessagesForPrompt(params.messages, {
+    omitDuplicateSystem: systemInstruction
+  }) ?? params.prompt;
 }
-// models/text.ts
-import { logger as logger6, ModelType as ModelType2 } from "@elizaos/core";
-function promptForRequest(params) {
-  const segments = params.promptSegments;
-  if (!Array.isArray(segments) || segments.length === 0) {
-    return params.prompt;
+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);
   }
-  return [...segments].sort((a, b) => a.stable === b.stable ? 0 : a.stable ? -1 : 1).map((s) => s.content).join("");
+}
+function buildGoogleGenerationConfig(params, systemInstruction, temperature, maxTokens, stopSequences) {
+  const tools = normalizeToolsForGoogle(params.tools);
+  const toolConfig = normalizeToolConfigForGoogle(params.toolChoice);
+  const responseJsonSchema = resolveResponseJsonSchema(params.responseSchema);
+  const baseConfig = {
+    temperature,
+    topK: 40,
+    topP: 0.95,
+    maxOutputTokens: maxTokens,
+    stopSequences,
+    safetySettings: getSafetySettings(),
+    ...systemInstruction && { systemInstruction },
+    ...tools ? { tools } : {},
+    ...toolConfig ? { toolConfig } : {},
+    ...responseJsonSchema ? {
+      responseMimeType: "application/json",
+      responseJsonSchema
+    } : {}
+  };
+  return baseConfig;
+}
+function createLlmCallDetails(modelName, modelType, prompt, systemInstruction, temperature, maxTokens) {
+  return {
+    model: modelName,
+    systemPrompt: systemInstruction ?? "",
+    userPrompt: prompt,
+    temperature,
+    maxTokens,
+    purpose: "external_llm",
+    actionType: `google-genai.${modelType}.generateContent`
+  };
+}
+async function generateContentWithTrajectory(runtime, genAI, modelName, modelType, prompt, systemInstruction, temperature, maxTokens, request) {
+  const details = createLlmCallDetails(modelName, modelType, prompt, systemInstruction, temperature, maxTokens);
+  const response = await recordLlmCall2(runtime, details, async () => {
+    const result = await genAI.models.generateContent(request);
+    const text2 = result.text || "";
+    details.response = text2;
+    details.promptTokens = await countTokens(prompt);
+    details.completionTokens = await countTokens(text2);
+    return result;
+  });
+  const text = response.text || "";
+  const promptTokens = details.promptTokens ?? await countTokens(prompt);
+  const completionTokens = details.completionTokens ?? await countTokens(text);
+  emitModelUsageEvent(runtime, modelType, prompt, {
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens
+  });
+  return text;
 }
 async function handleTextSmall(runtime, params) {
-  const { stopSequences = [], maxTokens = 8192, temperature = 0.7 } = params;
-  const prompt = promptForRequest(params);
+  const {
+    stopSequences = [],
+    maxTokens = 8192,
+    temperature = 0.7,
+    attachments
+  } = params;
   const genAI = createGoogleGenAI(runtime);
   if (!genAI) {
     throw new Error("Google Generative AI client not initialized");
   }
-  const modelName = getSmallModel(runtime);
-  logger6.log(`[TEXT_SMALL] Using model: ${modelName}`);
+  const modelName = getModelNameForType(runtime, TEXT_SMALL_MODEL_TYPE);
+  logger5.log(`[TEXT_SMALL] Using model: ${modelName}`);
   try {
-    const systemInstruction = runtime.character.system || undefined;
-    const response = await genAI.models.generateContent({
+    const systemInstruction = resolveGoogleSystemInstruction(runtime, params);
+    const promptText = resolveGooglePrompt(params, systemInstruction);
+    return await generateContentWithTrajectory(runtime, genAI, modelName, TEXT_SMALL_MODEL_TYPE, promptText, systemInstruction, temperature, maxTokens, {
       model: modelName,
-      contents: 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, ModelType2.TEXT_SMALL, prompt, {
-      promptTokens,
-      completionTokens,
-      totalTokens: promptTokens + completionTokens
+      contents: (attachments?.length ?? 0) > 0 ? [
+        {
+          role: "user",
+          parts: buildPromptParts(promptText, attachments)
+        }
+      ] : promptText,
+      config: buildGoogleGenerationConfig(params, systemInstruction, temperature, maxTokens, stopSequences)
     });
-    return text;
   } catch (error) {
-    logger6.error(`[TEXT_SMALL] Error: ${error instanceof Error ? error.message : String(error)}`);
+    logger5.error(`[TEXT_SMALL] Error: ${error instanceof Error ? error.message : String(error)}`);
     throw error;
   }
 }
 async function handleTextLarge(runtime, params) {
-  const { stopSequences = [], maxTokens = 8192, temperature = 0.7 } = params;
-  const prompt = promptForRequest(params);
+  const {
+    stopSequences = [],
+    maxTokens = 8192,
+    temperature = 0.7,
+    attachments
+  } = params;
   const genAI = createGoogleGenAI(runtime);
   if (!genAI) {
     throw new Error("Google Generative AI client not initialized");
   }
-  const modelName = getLargeModel(runtime);
-  logger6.log(`[TEXT_LARGE] Using model: ${modelName}`);
+  const modelName = getModelNameForType(runtime, TEXT_LARGE_MODEL_TYPE);
+  logger5.log(`[TEXT_LARGE] Using model: ${modelName}`);
   try {
-    const systemInstruction = runtime.character.system || undefined;
-    const response = await genAI.models.generateContent({
+    const systemInstruction = resolveGoogleSystemInstruction(runtime, params);
+    const promptText = resolveGooglePrompt(params, systemInstruction);
+    return await generateContentWithTrajectory(runtime, genAI, modelName, TEXT_LARGE_MODEL_TYPE, promptText, systemInstruction, temperature, maxTokens, {
       model: modelName,
-      contents: prompt,
-      config: {
-        temperature,
-        topK: 40,
-        topP: 0.95,
-        maxOutputTokens: maxTokens,
-        stopSequences,
-        safetySettings: getSafetySettings(),
-        ...systemInstruction && { systemInstruction }
-      }
+      contents: (attachments?.length ?? 0) > 0 ? [
+        {
+          role: "user",
+          parts: buildPromptParts(promptText, attachments)
+        }
+      ] : promptText,
+      config: buildGoogleGenerationConfig(params, systemInstruction, temperature, maxTokens, stopSequences)
     });
-    const text = response.text || "";
-    const promptTokens = await countTokens(prompt);
-    const completionTokens = await countTokens(text);
-    emitModelUsageEvent(runtime, ModelType2.TEXT_LARGE, prompt, {
-      promptTokens,
-      completionTokens,
-      totalTokens: promptTokens + completionTokens
+  } catch (error) {
+    logger5.error(`[TEXT_LARGE] Error: ${error instanceof Error ? error.message : String(error)}`);
+    throw error;
+  }
+}
+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, params) {
+  const {
+    stopSequences = [],
+    maxTokens = 8192,
+    temperature = 0.7,
+    attachments
+  } = params;
+  const genAI = createGoogleGenAI(runtime);
+  if (!genAI) {
+    throw new Error("Google Generative AI client not initialized");
+  }
+  const modelName = getModelNameForType(runtime, modelType);
+  logger5.log(`[${modelType}] Using model: ${modelName}`);
+  try {
+    const systemInstruction = resolveGoogleSystemInstruction(runtime, params);
+    const promptText = resolveGooglePrompt(params, systemInstruction);
+    return await generateContentWithTrajectory(runtime, genAI, modelName, modelType, promptText, systemInstruction, temperature, maxTokens, {
+      model: modelName,
+      contents: (attachments?.length ?? 0) > 0 ? [
+        {
+          role: "user",
+          parts: buildPromptParts(promptText, attachments)
+        }
+      ] : promptText,
+      config: buildGoogleGenerationConfig(params, systemInstruction, temperature, maxTokens, stopSequences)
     });
-    return text;
   } catch (error) {
-    logger6.error(`[TEXT_LARGE] Error: ${error instanceof Error ? error.message : String(error)}`);
+    logger5.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 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",
@@ -386,22 +597,22 @@ var pluginTests = [
           for await (const model of modelList) {
             models.push(model);
           }
-          logger7.log(`Available models: ${models.length}`);
+          logger6.log(`Available models: ${models.length}`);
         }
       },
       {
         name: "google_test_text_embedding",
         fn: async (runtime) => {
           try {
-            const embedding = await runtime.useModel(ModelType3.TEXT_EMBEDDING, {
+            const embedding = await runtime.useModel(ModelType4.TEXT_EMBEDDING, {
               text: "Hello, world!"
             });
-            logger7.log(`Embedding dimension: ${embedding.length}`);
+            logger6.log(`Embedding dimension: ${embedding.length}`);
             if (embedding.length === 0) {
               throw new Error("Failed to generate embedding");
             }
           } catch (error) {
-            logger7.error(`Error in test_text_embedding: ${error instanceof Error ? error.message : String(error)}`);
+            logger6.error(`Error in test_text_embedding: ${error instanceof Error ? error.message : String(error)}`);
             throw error;
           }
         }
@@ -410,15 +621,15 @@ var pluginTests = [
         name: "google_test_text_small",
         fn: async (runtime) => {
           try {
-            const text = await runtime.useModel(ModelType3.TEXT_SMALL, {
+            const text = await runtime.useModel(ModelType4.TEXT_SMALL, {
               prompt: "What is the nature of reality in 10 words?"
             });
             if (text.length === 0) {
               throw new Error("Failed to generate text");
             }
-            logger7.log("Generated with TEXT_SMALL:", text);
+            logger6.log("Generated with TEXT_SMALL:", text);
           } catch (error) {
-            logger7.error(`Error in test_text_small: ${error instanceof Error ? error.message : String(error)}`);
+            logger6.error(`Error in test_text_small: ${error instanceof Error ? error.message : String(error)}`);
             throw error;
           }
         }
@@ -427,15 +638,15 @@ var pluginTests = [
         name: "google_test_text_large",
         fn: async (runtime) => {
           try {
-            const text = await runtime.useModel(ModelType3.TEXT_LARGE, {
+            const text = await runtime.useModel(ModelType4.TEXT_LARGE, {
               prompt: "Explain quantum mechanics in simple terms."
             });
             if (text.length === 0) {
               throw new Error("Failed to generate text");
             }
-            logger7.log("Generated with TEXT_LARGE:", `${text.substring(0, 100)}...`);
+            logger6.log("Generated with TEXT_LARGE:", `${text.substring(0, 100)}...`);
           } catch (error) {
-            logger7.error(`Error in test_text_large: ${error instanceof Error ? error.message : String(error)}`);
+            logger6.error(`Error in test_text_large: ${error instanceof Error ? error.message : String(error)}`);
             throw error;
           }
         }
@@ -444,20 +655,20 @@ var pluginTests = [
         name: "google_test_image_description",
         fn: async (runtime) => {
           try {
-            const result = await runtime.useModel(ModelType3.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) {
-              logger7.log("Image description:", JSON.stringify(result));
+            const result = await runtime.useModel(ModelType4.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) {
+              logger6.log("Image description:", JSON.stringify(result));
             } else {
-              logger7.error(`Invalid image description result format: ${JSON.stringify(result)}`);
+              logger6.error(`Invalid image description result format: ${JSON.stringify(result)}`);
             }
           } catch (error) {
-            logger7.error(`Error in test_image_description: ${error instanceof Error ? error.message : String(error)}`);
+            logger6.error(`Error in test_image_description: ${error instanceof Error ? error.message : String(error)}`);
             throw error;
           }
         }
       },
       {
-        name: "google_test_object_generation",
+        name: "google_test_structured_output_via_text_large",
         fn: async (runtime) => {
           try {
             const schema = {
@@ -469,16 +680,16 @@ var pluginTests = [
               },
               required: ["name", "age", "hobbies"]
             };
-            const result = await runtime.useModel(ModelType3.OBJECT_SMALL, {
+            const result = await runtime.useModel(ModelType4.TEXT_LARGE, {
               prompt: "Generate a person profile with name, age, and hobbies.",
-              schema
+              responseSchema: schema
             });
-            logger7.log("Generated object:", JSON.stringify(result));
-            if (!result.name || !result.age || !result.hobbies) {
-              throw new Error("Generated object missing required fields");
+            logger6.log("Generated structured output:", JSON.stringify(result));
+            if (!result) {
+              throw new Error("Generated structured output is empty");
             }
           } catch (error) {
-            logger7.error(`Error in test_object_generation: ${error instanceof Error ? error.message : String(error)}`);
+            logger6.error(`Error in test_structured_output_via_text_large: ${error instanceof Error ? error.message : String(error)}`);
             throw error;
           }
         }
@@ -496,45 +707,74 @@ var env = getProcessEnv();
 var googleGenAIPlugin = {
   name: "google-genai",
   description: "Google Generative AI plugin for Gemini models",
+  autoEnable: {
+    envKeys: ["GOOGLE_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"]
+  },
   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: {
-    [ModelType3.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);
     },
-    [ModelType3.TEXT_LARGE]: async (runtime, params) => {
+    [TEXT_LARGE_MODEL_TYPE2]: async (runtime, params) => {
       return handleTextLarge(runtime, params);
     },
-    [ModelType3.TEXT_EMBEDDING]: async (runtime, params) => {
-      return handleTextEmbedding(runtime, params);
+    [TEXT_MEGA_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMega(runtime, params);
     },
-    [ModelType3.IMAGE_DESCRIPTION]: async (runtime, params) => {
-      return handleImageDescription(runtime, params);
+    [RESPONSE_HANDLER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleResponseHandler(runtime, params);
+    },
+    [ACTION_PLANNER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleActionPlanner(runtime, params);
     },
-    [ModelType3.OBJECT_SMALL]: async (runtime, params) => {
-      return handleObjectSmall(runtime, params);
+    [TEXT_EMBEDDING_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextEmbedding(runtime, params);
     },
-    [ModelType3.OBJECT_LARGE]: async (runtime, params) => {
-      return handleObjectLarge(runtime, params);
+    [IMAGE_DESCRIPTION_MODEL_TYPE]: async (runtime, params) => {
+      return handleImageDescription(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;
 export {
   googleGenAIPlugin,
-  typescript_default as default
+  index_node_default as default
 };
 
-//# debugId=BC77F44E10C5670564756E2164756E21
+//# debugId=20AEB5819D569BEA64756E2164756E21