@elizaos/plugin-google-genai 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/node/index.node.js

@@ -0,0 +1,795 @@
+// index.ts
+import { logger as logger6, ModelType as ModelType3 } from "@elizaos/core";
+import { GoogleGenAI as GoogleGenAI3 } from "@google/genai";
+
+// init.ts
+import { logger as logger2 } from "@elizaos/core";
+import { GoogleGenAI as GoogleGenAI2 } from "@google/genai";
+
+// utils/config.ts
+import { logger } from "@elizaos/core";
+import { GoogleGenAI, HarmBlockThreshold, HarmCategory } from "@google/genai";
+function getEnvValue(key) {
+  if (typeof process === "undefined") {
+    return;
+  }
+  const value = process.env[key];
+  return normalizeSettingValue(value);
+}
+function normalizeSettingValue(value) {
+  if (value === undefined || value === null) {
+    return;
+  }
+  const trimmed = String(value).trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+function getSetting(runtime, key, defaultValue) {
+  const runtimeValue = normalizeSettingValue(runtime.getSetting(key));
+  if (runtimeValue !== undefined) {
+    return runtimeValue;
+  }
+  return getEnvValue(key) ?? defaultValue;
+}
+function getApiKey(runtime) {
+  return getSetting(runtime, "GOOGLE_GENERATIVE_AI_API_KEY");
+}
+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";
+}
+function getEmbeddingModel(runtime) {
+  return getSetting(runtime, "GOOGLE_EMBEDDING_MODEL", "text-embedding-004") ?? "text-embedding-004";
+}
+function createGoogleGenAI(runtime) {
+  const apiKey = getApiKey(runtime);
+  if (!apiKey) {
+    logger.error("Google Generative AI API Key is missing");
+    return null;
+  }
+  return new GoogleGenAI({ apiKey });
+}
+function getSafetySettings() {
+  return [
+    {
+      category: HarmCategory.HARM_CATEGORY_HARASSMENT,
+      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE
+    },
+    {
+      category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE
+    },
+    {
+      category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE
+    },
+    {
+      category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE
+    }
+  ];
+}
+
+// init.ts
+function initializeGoogleGenAI(_config, runtime) {
+  (async () => {
+    try {
+      const apiKey = getApiKey(runtime);
+      if (!apiKey) {
+        logger2.warn("GOOGLE_GENERATIVE_AI_API_KEY is not set");
+        return;
+      }
+      const genAI = new GoogleGenAI2({ apiKey });
+      const modelList = await genAI.models.list();
+      const models = [];
+      for await (const model of modelList) {
+        models.push(model);
+      }
+      logger2.log(`Google AI API key validated. Available models: ${models.length}`);
+    } catch (error) {
+      logger2.warn(`Google AI configuration error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  })();
+}
+
+// models/embedding.ts
+import * as ElizaCore from "@elizaos/core";
+import { logger as logger3 } from "@elizaos/core";
+
+// utils/events.ts
+var MODEL_USED_EVENT = "MODEL_USED";
+function emitModelUsageEvent(runtime, type, _prompt, usage) {
+  runtime.emitEvent(MODEL_USED_EVENT, {
+    runtime,
+    source: "plugin-google-genai",
+    type,
+    tokens: {
+      prompt: usage.promptTokens,
+      completion: usage.completionTokens,
+      total: usage.totalTokens
+    }
+  });
+}
+
+// utils/tokenization.ts
+async function countTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+
+// models/embedding.ts
+var TEXT_EMBEDDING_MODEL_TYPE = ElizaCore.ModelType?.TEXT_EMBEDDING ?? "TEXT_EMBEDDING";
+function createInitProbeVector() {
+  const vector = Array(768).fill(0);
+  vector[0] = 0.1;
+  return vector;
+}
+function extractText(params) {
+  if (params === null) {
+    return null;
+  }
+  if (typeof params === "string") {
+    return params;
+  }
+  if (typeof params === "object" && typeof params.text === "string") {
+    return params.text;
+  }
+  throw new Error("Invalid input format for embedding: expected string or { text: string }");
+}
+async function handleTextEmbedding(runtime, params) {
+  if (params === null) {
+    return createInitProbeVector();
+  }
+  let text = extractText(params);
+  if (text === null) {
+    return createInitProbeVector();
+  }
+  if (!text.trim()) {
+    throw new Error("Cannot generate embedding for empty text");
+  }
+  const genAI = createGoogleGenAI(runtime);
+  if (!genAI) {
+    throw new Error("Google Generative AI client not initialized");
+  }
+  const embeddingModelName = getEmbeddingModel(runtime);
+  logger3.debug(`[TEXT_EMBEDDING] Using model: ${embeddingModelName}`);
+  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,
+      contents: text
+    });
+    const embedding = response.embeddings?.[0]?.values || [];
+    if (embedding.length === 0) {
+      throw new Error("Google GenAI API returned no embedding");
+    }
+    const promptTokens = await countTokens(text);
+    emitModelUsageEvent(runtime, TEXT_EMBEDDING_MODEL_TYPE, text, {
+      promptTokens,
+      completionTokens: 0,
+      totalTokens: promptTokens
+    });
+    logger3.log(`Got embedding with length ${embedding.length}`);
+    return embedding;
+  } catch (error) {
+    logger3.error(`Error generating embedding: ${error instanceof Error ? error.message : String(error)}`);
+    throw error instanceof Error ? error : new Error(String(error));
+  }
+}
+// models/image.ts
+import { logger as logger4, recordLlmCall } from "@elizaos/core";
+async function handleImageDescription(runtime, params) {
+  const genAI = createGoogleGenAI(runtime);
+  if (!genAI) {
+    throw new Error("Google Generative AI client not initialized");
+  }
+  let imageUrl;
+  let promptText;
+  const modelName = getImageModel(runtime);
+  logger4.log(`[IMAGE_DESCRIPTION] Using model: ${modelName}`);
+  if (typeof params === "string") {
+    imageUrl = params;
+    promptText = "Please analyze this image and provide a title and detailed description.";
+  } else {
+    imageUrl = params.imageUrl;
+    promptText = params.prompt || "Please analyze this image and provide a title and detailed description.";
+  }
+  try {
+    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 details = {
+      model: modelName,
+      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()
+        }
+      });
+      const responseText2 = result.text || "";
+      details.response = responseText2;
+      details.promptTokens = await countTokens(promptText);
+      details.completionTokens = await countTokens(responseText2);
+      return result;
+    });
+    const responseText = response.text || "";
+    try {
+      const jsonResponse = JSON.parse(responseText);
+      if (typeof jsonResponse.title === "string" && typeof jsonResponse.description === "string") {
+        return {
+          title: jsonResponse.title,
+          description: jsonResponse.description
+        };
+      }
+    } catch {}
+    const titleMatch = responseText.match(/title[:\s]+(.+?)(?:\n|$)/i);
+    const title = titleMatch?.[1]?.trim() || "Image Analysis";
+    const description = titleMatch ? responseText.replace(/title[:\s]+(.+?)(?:\n|$)/i, "").trim() : responseText.trim();
+    return { title, description };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger4.error(`Error analyzing image: ${message}`);
+    return {
+      title: "Failed to analyze image",
+      description: `Error: ${message}`
+    };
+  }
+}
+// models/text.ts
+import {
+  buildCanonicalSystemPrompt,
+  logger as logger5,
+  ModelType as ModelType2,
+  recordLlmCall as recordLlmCall2,
+  renderChatMessagesForPrompt,
+  resolveEffectiveSystemPrompt
+} from "@elizaos/core";
+var TEXT_NANO_MODEL_TYPE = ModelType2.TEXT_NANO;
+var TEXT_MEDIUM_MODEL_TYPE = ModelType2.TEXT_MEDIUM;
+var TEXT_SMALL_MODEL_TYPE = ModelType2.TEXT_SMALL;
+var TEXT_LARGE_MODEL_TYPE = ModelType2.TEXT_LARGE;
+var TEXT_MEGA_MODEL_TYPE = ModelType2.TEXT_MEGA;
+var RESPONSE_HANDLER_MODEL_TYPE = ModelType2.RESPONSE_HANDLER;
+var ACTION_PLANNER_MODEL_TYPE = ModelType2.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 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 description = tool.description ?? tool.function?.description;
+    const parameters = tool.parameters ?? tool.inputSchema ?? tool.function?.parameters ?? {
+      type: "object",
+      properties: {}
+    };
+    declarations.push({
+      name,
+      ...description ? { description } : {},
+      parameters
+    });
+  }
+  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]
+      }
+    };
+  }
+  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;
+    }
+    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 resolveGoogleSystemInstruction(runtime, params) {
+  return resolveEffectiveSystemPrompt({
+    params,
+    fallback: buildCanonicalSystemPrompt({ character: runtime.character })
+  });
+}
+function resolveGooglePrompt(params, systemInstruction) {
+  return renderChatMessagesForPrompt(params.messages, {
+    omitDuplicateSystem: systemInstruction
+  }) ?? 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);
+  }
+}
+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,
+    stopSequences,
+    safetySettings: getSafetySettings(),
+    ...typeof maxTokens === "number" ? { maxOutputTokens: maxTokens } : {},
+    ...systemInstruction && { systemInstruction },
+    ...tools ? { tools } : {},
+    ...toolConfig ? { toolConfig } : {},
+    ...responseJsonSchema ? {
+      responseMimeType: "application/json",
+      responseJsonSchema
+    } : {}
+  };
+  return baseConfig;
+}
+function createLlmCallDetails(modelName, modelType, prompt, systemInstruction, temperature, maxTokens, maxTokensOmitted) {
+  return {
+    model: modelName,
+    systemPrompt: systemInstruction ?? "",
+    userPrompt: prompt,
+    temperature,
+    maxTokens: maxTokens ?? 0,
+    maxTokensOmitted: maxTokensOmitted ? true : undefined,
+    purpose: "external_llm",
+    actionType: `google-genai.${modelType}.generateContent`
+  };
+}
+async function generateContentWithTrajectory(runtime, genAI, modelName, modelType, prompt, systemInstruction, temperature, maxTokens, maxTokensOmitted, request) {
+  const details = createLlmCallDetails(modelName, modelType, prompt, systemInstruction, temperature, maxTokens, maxTokensOmitted);
+  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 = [], temperature = 0.7, attachments } = params;
+  const maxTokens = params.omitMaxTokens ? undefined : params.maxTokens ?? 8192;
+  const genAI = createGoogleGenAI(runtime);
+  if (!genAI) {
+    throw new Error("Google Generative AI client not initialized");
+  }
+  const modelName = getModelNameForType(runtime, TEXT_SMALL_MODEL_TYPE);
+  logger5.log(`[TEXT_SMALL] Using model: ${modelName}`);
+  try {
+    const systemInstruction = resolveGoogleSystemInstruction(runtime, params);
+    const promptText = resolveGooglePrompt(params, systemInstruction);
+    return await generateContentWithTrajectory(runtime, genAI, modelName, TEXT_SMALL_MODEL_TYPE, promptText, systemInstruction, temperature, maxTokens, params.omitMaxTokens, {
+      model: modelName,
+      contents: (attachments?.length ?? 0) > 0 ? [
+        {
+          role: "user",
+          parts: buildPromptParts(promptText, attachments)
+        }
+      ] : promptText,
+      config: buildGoogleGenerationConfig(params, systemInstruction, temperature, maxTokens, stopSequences)
+    });
+  } catch (error) {
+    logger5.error(`[TEXT_SMALL] Error: ${error instanceof Error ? error.message : String(error)}`);
+    throw error;
+  }
+}
+async function handleTextLarge(runtime, params) {
+  const { stopSequences = [], temperature = 0.7, attachments } = params;
+  const maxTokens = params.omitMaxTokens ? undefined : params.maxTokens ?? 8192;
+  const genAI = createGoogleGenAI(runtime);
+  if (!genAI) {
+    throw new Error("Google Generative AI client not initialized");
+  }
+  const modelName = getModelNameForType(runtime, TEXT_LARGE_MODEL_TYPE);
+  logger5.log(`[TEXT_LARGE] Using model: ${modelName}`);
+  try {
+    const systemInstruction = resolveGoogleSystemInstruction(runtime, params);
+    const promptText = resolveGooglePrompt(params, systemInstruction);
+    return await generateContentWithTrajectory(runtime, genAI, modelName, TEXT_LARGE_MODEL_TYPE, promptText, systemInstruction, temperature, maxTokens, params.omitMaxTokens, {
+      model: modelName,
+      contents: (attachments?.length ?? 0) > 0 ? [
+        {
+          role: "user",
+          parts: buildPromptParts(promptText, attachments)
+        }
+      ] : promptText,
+      config: buildGoogleGenerationConfig(params, systemInstruction, temperature, maxTokens, stopSequences)
+    });
+  } 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 = [], temperature = 0.7, attachments } = params;
+  const maxTokens = params.omitMaxTokens ? undefined : params.maxTokens ?? 8192;
+  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, params.omitMaxTokens, {
+      model: modelName,
+      contents: (attachments?.length ?? 0) > 0 ? [
+        {
+          role: "user",
+          parts: buildPromptParts(promptText, attachments)
+        }
+      ] : promptText,
+      config: buildGoogleGenerationConfig(params, systemInstruction, temperature, maxTokens, stopSequences)
+    });
+  } catch (error) {
+    logger5.error(`[${modelType}] Error: ${error instanceof Error ? error.message : String(error)}`);
+    throw error;
+  }
+}
+// index.ts
+var TEXT_NANO_MODEL_TYPE2 = ModelType3.TEXT_NANO;
+var TEXT_MEDIUM_MODEL_TYPE2 = ModelType3.TEXT_MEDIUM;
+var TEXT_SMALL_MODEL_TYPE2 = ModelType3.TEXT_SMALL;
+var TEXT_LARGE_MODEL_TYPE2 = ModelType3.TEXT_LARGE;
+var TEXT_EMBEDDING_MODEL_TYPE2 = ModelType3.TEXT_EMBEDDING;
+var IMAGE_DESCRIPTION_MODEL_TYPE = ModelType3.IMAGE_DESCRIPTION;
+var TEXT_MEGA_MODEL_TYPE2 = ModelType3.TEXT_MEGA;
+var RESPONSE_HANDLER_MODEL_TYPE2 = ModelType3.RESPONSE_HANDLER;
+var ACTION_PLANNER_MODEL_TYPE2 = ModelType3.ACTION_PLANNER;
+var pluginTests = [
+  {
+    name: "google_genai_plugin_tests",
+    tests: [
+      {
+        name: "google_test_api_key_validation",
+        fn: async (runtime) => {
+          const apiKey = getApiKey(runtime);
+          if (!apiKey) {
+            throw new Error("GOOGLE_GENERATIVE_AI_API_KEY not set");
+          }
+          const genAI = new GoogleGenAI3({ apiKey });
+          const modelList = await genAI.models.list();
+          const models = [];
+          for await (const model of modelList) {
+            models.push(model);
+          }
+          logger6.log(`Available models: ${models.length}`);
+        }
+      },
+      {
+        name: "google_test_text_embedding",
+        fn: async (runtime) => {
+          try {
+            const embedding = await runtime.useModel(ModelType3.TEXT_EMBEDDING, {
+              text: "Hello, world!"
+            });
+            logger6.log(`Embedding dimension: ${embedding.length}`);
+            if (embedding.length === 0) {
+              throw new Error("Failed to generate embedding");
+            }
+          } catch (error) {
+            logger6.error(`Error in test_text_embedding: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+          }
+        }
+      },
+      {
+        name: "google_test_text_small",
+        fn: async (runtime) => {
+          try {
+            const text = await runtime.useModel(ModelType3.TEXT_SMALL, {
+              prompt: "What is the nature of reality in 10 words?"
+            });
+            if (text.length === 0) {
+              throw new Error("Failed to generate text");
+            }
+            logger6.log("Generated with TEXT_SMALL:", text);
+          } catch (error) {
+            logger6.error(`Error in test_text_small: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+          }
+        }
+      },
+      {
+        name: "google_test_text_large",
+        fn: async (runtime) => {
+          try {
+            const text = await runtime.useModel(ModelType3.TEXT_LARGE, {
+              prompt: "Explain quantum mechanics in simple terms."
+            });
+            if (text.length === 0) {
+              throw new Error("Failed to generate text");
+            }
+            logger6.log("Generated with TEXT_LARGE:", `${text.substring(0, 100)}...`);
+          } catch (error) {
+            logger6.error(`Error in test_text_large: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+          }
+        }
+      },
+      {
+        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 != null && typeof result === "object" && "title" in result && "description" in result) {
+              logger6.log("Image description:", JSON.stringify(result));
+            } else {
+              logger6.error(`Invalid image description result format: ${JSON.stringify(result)}`);
+            }
+          } catch (error) {
+            logger6.error(`Error in test_image_description: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+          }
+        }
+      },
+      {
+        name: "google_test_structured_output_via_text_large",
+        fn: async (runtime) => {
+          try {
+            const schema = {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                age: { type: "number" },
+                hobbies: { type: "array", items: { type: "string" } }
+              },
+              required: ["name", "age", "hobbies"]
+            };
+            const result = await runtime.useModel(ModelType3.TEXT_LARGE, {
+              prompt: "Generate a person profile with name, age, and hobbies.",
+              responseSchema: schema
+            });
+            logger6.log("Generated structured output:", JSON.stringify(result));
+            if (!result) {
+              throw new Error("Generated structured output is empty");
+            }
+          } catch (error) {
+            logger6.error(`Error in test_structured_output_via_text_large: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+          }
+        }
+      }
+    ]
+  }
+];
+function getProcessEnv() {
+  if (typeof process === "undefined") {
+    return {};
+  }
+  return process.env;
+}
+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: {
+    [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);
+    },
+    [TEXT_LARGE_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextLarge(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);
+    },
+    [IMAGE_DESCRIPTION_MODEL_TYPE]: async (runtime, params) => {
+      return handleImageDescription(runtime, params);
+    }
+  },
+  tests: pluginTests
+};
+var plugin_google_genai_default = googleGenAIPlugin;
+
+// index.node.ts
+var index_node_default = plugin_google_genai_default;
+export {
+  googleGenAIPlugin,
+  index_node_default as default
+};
+
+//# debugId=1AF6D4C9F5965CAB64756E2164756E21