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

package/dist/cjs/index.node.cjs

@@ -1,3 +1,5 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -5,6 +7,28 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 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 ??= new WeakMap).get(from), desc;
   if (entry)
@@ -40,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_core6 = require("@elizaos/core");
 var import_genai3 = require("@google/genai");
 
 // init.ts
@@ -75,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";
 }
@@ -136,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,
@@ -159,21 +200,27 @@ 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);
   }
-  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()) {
-    import_core4.logger.warn("Empty text for embedding");
+    import_core3.logger.warn("Empty text for embedding");
     return Array(768).fill(0);
   }
+  const maxChars = 8192 * 4;
+  if (text.length > maxChars) {
+    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 {
     const response = await genAI.models.embedContent({
       model: embeddingModelName,
@@ -181,21 +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 crossFetch = typeof globalThis.fetch === "function" ? globalThis.fetch : fetch;
+var import_core4 = require("@elizaos/core");
 async function handleImageDescription(runtime, params) {
   const genAI = createGoogleGenAI(runtime);
   if (!genAI) {
@@ -204,7 +250,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.";
@@ -213,36 +259,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 import_core4.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 {
@@ -260,161 +322,328 @@ 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}`
     };
   }
 }
-// models/object.ts
-var import_core6 = require("@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
+var ElizaCore2 = __toESM(require("@elizaos/core"));
+var import_core5 = 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 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;
-  import_core6.logger.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) {
-    import_core6.logger.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 import_core5.resolveEffectiveSystemPrompt({
+    params,
+    fallback: import_core5.buildCanonicalSystemPrompt({ character: runtime.character })
+  });
 }
-async function handleObjectLarge(runtime, params) {
-  return generateObjectByModelType(runtime, params, "OBJECT_LARGE", getLargeModel);
+function resolveGooglePrompt(params, systemInstruction) {
+  return import_core5.renderChatMessagesForPrompt(params.messages, {
+    omitDuplicateSystem: systemInstruction
+  }) ?? params.prompt;
 }
-// models/text.ts
-var import_core7 = require("@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 import_core5.recordLlmCall(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);
-  import_core7.logger.log(`[TEXT_SMALL] Using model: ${modelName}`);
+  const modelName = getModelNameForType(runtime, TEXT_SMALL_MODEL_TYPE);
+  import_core5.logger.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, import_core7.ModelType.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) {
-    import_core7.logger.error(`[TEXT_SMALL] Error: ${error instanceof Error ? error.message : String(error)}`);
+    import_core5.logger.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);
-  import_core7.logger.log(`[TEXT_LARGE] Using model: ${modelName}`);
+  const modelName = getModelNameForType(runtime, TEXT_LARGE_MODEL_TYPE);
+  import_core5.logger.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, import_core7.ModelType.TEXT_LARGE, prompt, {
-      promptTokens,
-      completionTokens,
-      totalTokens: promptTokens + completionTokens
+  } catch (error) {
+    import_core5.logger.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);
+  import_core5.logger.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) {
-    import_core7.logger.error(`[TEXT_LARGE] Error: ${error instanceof Error ? error.message : String(error)}`);
+    import_core5.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 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",
@@ -432,22 +661,22 @@ var pluginTests = [
           for await (const model of modelList) {
             models.push(model);
           }
-          import_core8.logger.log(`Available models: ${models.length}`);
+          import_core6.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_core6.ModelType.TEXT_EMBEDDING, {
               text: "Hello, world!"
             });
-            import_core8.logger.log(`Embedding dimension: ${embedding.length}`);
+            import_core6.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_core6.logger.error(`Error in test_text_embedding: ${error instanceof Error ? error.message : String(error)}`);
             throw error;
           }
         }
@@ -456,15 +685,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_core6.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_core6.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_core6.logger.error(`Error in test_text_small: ${error instanceof Error ? error.message : String(error)}`);
             throw error;
           }
         }
@@ -473,15 +702,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_core6.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_core6.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_core6.logger.error(`Error in test_text_large: ${error instanceof Error ? error.message : String(error)}`);
             throw error;
           }
         }
@@ -490,20 +719,20 @@ 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_core6.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_core6.logger.log("Image description:", JSON.stringify(result));
             } else {
-              import_core8.logger.error(`Invalid image description result format: ${JSON.stringify(result)}`);
+              import_core6.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_core6.logger.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 = {
@@ -515,16 +744,16 @@ var pluginTests = [
               },
               required: ["name", "age", "hobbies"]
             };
-            const result = await runtime.useModel(import_core8.ModelType.OBJECT_SMALL, {
+            const result = await runtime.useModel(import_core6.ModelType.TEXT_LARGE, {
               prompt: "Generate a person profile with name, age, and hobbies.",
-              schema
+              responseSchema: schema
             });
-            import_core8.logger.log("Generated object:", JSON.stringify(result));
-            if (!result.name || !result.age || !result.hobbies) {
-              throw new Error("Generated object missing required fields");
+            import_core6.logger.log("Generated structured output:", JSON.stringify(result));
+            if (!result) {
+              throw new Error("Generated structured output is empty");
             }
           } catch (error) {
-            import_core8.logger.error(`Error in test_object_generation: ${error instanceof Error ? error.message : String(error)}`);
+            import_core6.logger.error(`Error in test_structured_output_via_text_large: ${error instanceof Error ? error.message : String(error)}`);
             throw error;
           }
         }
@@ -542,41 +771,70 @@ 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: {
-    [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) => {
-      return handleTextEmbedding(runtime, params);
+    [TEXT_MEGA_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMega(runtime, params);
     },
-    [import_core8.ModelType.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);
     },
-    [import_core8.ModelType.OBJECT_SMALL]: async (runtime, params) => {
-      return handleObjectSmall(runtime, params);
+    [TEXT_EMBEDDING_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextEmbedding(runtime, params);
     },
-    [import_core8.ModelType.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;
 
-//# debugId=68F8B79CE025517764756E2164756E21
+//# debugId=E1E56B528121F63364756E2164756E21