ak-gemini 2.1.5 → 2.3.0

package/index.cjs

@@ -35,6 +35,7 @@ __export(index_exports, {
   Embedding: () => Embedding,
   HarmBlockThreshold: () => import_genai2.HarmBlockThreshold,
   HarmCategory: () => import_genai2.HarmCategory,
+  ImageGenerator: () => ImageGenerator,
   Message: () => message_default,
   RagAgent: () => rag_agent_default,
   ThinkingLevel: () => import_genai2.ThinkingLevel,
@@ -322,29 +323,46 @@ var DEFAULT_THINKING_CONFIG = {
 };
 var DEFAULT_MAX_OUTPUT_TOKENS = 5e4;
 var THINKING_SUPPORTED_MODELS = [
-  /^gemini-3-flash(-preview)?$/,
-  /^gemini-3-pro(-preview|-image-preview)?$/,
+  /^gemini-3(\.\d+)?-pro(-preview)?$/,
+  /^gemini-3(\.\d+)?-flash(-preview)?$/,
+  /^gemini-3(\.\d+)?-flash-lite(-preview)?$/,
   /^gemini-2\.5-pro/,
   /^gemini-2\.5-flash(-preview)?$/,
   /^gemini-2\.5-flash-lite(-preview)?$/,
   /^gemini-2\.0-flash$/
 ];
 var MODEL_PRICING = {
-  "gemini-2.5-flash": { input: 0.15, output: 0.6 },
-  "gemini-2.5-flash-lite": { input: 0.02, output: 0.1 },
-  "gemini-2.5-pro": { input: 2.5, output: 10 },
-  "gemini-3-pro": { input: 2, output: 12 },
-  "gemini-3-pro-preview": { input: 2, output: 12 },
+  // Gemini 3.x stable
+  "gemini-3.5-flash": { input: 1.5, output: 9 },
+  "gemini-3.1-flash-lite": { input: 0.25, output: 1.5 },
+  // Gemini 3.x preview
+  "gemini-3.1-pro-preview": { input: 2, output: 12 },
+  // ≤200k tier
+  "gemini-3-flash-preview": { input: 0.5, output: 3 },
+  "gemini-3.1-flash-lite-preview": { input: 0.25, output: 1.5 },
+  "gemini-3.1-flash-image-preview": { input: 0.5, output: 3 },
+  // text-only; image-output is $60/M
+  "gemini-3-pro-image-preview": { input: 2, output: 12 },
+  // text-only; image-output is $120/M
+  // Gemini 2.5 stable
+  "gemini-2.5-flash": { input: 0.3, output: 2.5 },
+  "gemini-2.5-flash-lite": { input: 0.1, output: 0.4 },
+  "gemini-2.5-pro": { input: 1.25, output: 10 },
+  // ≤200k tier
+  "gemini-2.5-flash-image": { input: 0.3, output: 0 },
+  // image-output is ~$0.039/image (1290 tokens)
+  // Deprecated but kept for back-compat (shut down June 2026)
   "gemini-2.0-flash": { input: 0.1, output: 0.4 },
   "gemini-2.0-flash-lite": { input: 0.02, output: 0.1 },
-  "gemini-embedding-001": { input: 6e-3, output: 0 }
+  // Embeddings
+  "gemini-embedding-001": { input: 0.15, output: 0 }
 };
 var BaseGemini = class {
   /**
    * @param {BaseGeminiOptions} [options={}]
    */
   constructor(options = {}) {
-    this.modelName = options.modelName || "gemini-2.5-flash";
+    this.modelName = options.modelName || "gemini-3-flash-preview";
     if (options.systemPrompt !== void 0) {
       this.systemPrompt = options.systemPrompt;
     } else {
@@ -369,6 +387,8 @@ var BaseGemini = class {
     this.enableGrounding = options.enableGrounding || false;
     this.groundingConfig = options.groundingConfig || {};
     this.cachedContent = options.cachedContent || null;
+    this.serviceTier = options.serviceTier || null;
+    this.includeServerSideToolInvocations = options.includeServerSideToolInvocations ?? false;
     this.chatConfig = {
       temperature: 0.7,
       topP: 0.95,
@@ -376,6 +396,8 @@ var BaseGemini = class {
       safetySettings: DEFAULT_SAFETY_SETTINGS,
       ...options.chatConfig
     };
+    if (this.serviceTier) this.chatConfig["serviceTier"] = this.serviceTier;
+    if (this.includeServerSideToolInvocations) this.chatConfig["includeServerSideToolInvocations"] = true;
     if (this.systemPrompt) {
       this.chatConfig.systemInstruction = this.systemPrompt;
     } else if (this.systemPrompt === null && options.systemPrompt === void 0) {
@@ -573,6 +595,7 @@ ${contextText}
    * @protected
    */
   _captureMetadata(response) {
+    const modelStatus = response?.modelStatus || null;
     this.lastResponseMetadata = {
       modelVersion: response.modelVersion || null,
       requestedModel: this.modelName,
@@ -580,8 +603,13 @@ ${contextText}
       responseTokens: response.usageMetadata?.candidatesTokenCount || 0,
       totalTokens: response.usageMetadata?.totalTokenCount || 0,
       timestamp: Date.now(),
-      groundingMetadata: response.candidates?.[0]?.groundingMetadata || null
+      groundingMetadata: response.candidates?.[0]?.groundingMetadata || null,
+      modelStatus
     };
+    if (modelStatus === "DEPRECATED" && !this._deprecationWarned) {
+      logger_default.warn(`Model "${this.modelName}" is marked DEPRECATED by Google. Plan migration.`);
+      this._deprecationWarned = true;
+    }
   }
   /**
    * Returns structured usage data from the last API call for billing verification.
@@ -601,7 +629,8 @@ ${contextText}
       modelVersion: meta.modelVersion,
       requestedModel: meta.requestedModel,
       timestamp: meta.timestamp,
-      groundingMetadata: meta.groundingMetadata || null
+      groundingMetadata: meta.groundingMetadata || null,
+      modelStatus: meta.modelStatus || null
     };
   }
   // ── Token Estimation ─────────────────────────────────────────────────────
@@ -1626,7 +1655,55 @@ var import_node_path = require("node:path");
 var import_node_crypto = require("node:crypto");
 var MAX_OUTPUT_CHARS = 5e4;
 var MAX_FILE_TREE_LINES = 500;
-var IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "coverage", ".next", "build", "__pycache__"]);
+var IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "coverage", ".next", "build", "__pycache__", ".venv"]);
+var LANG_CONFIG = {
+  javascript: {
+    toolDescExecute: "Execute a given piece of JavaScript code in a Node.js child process. Use this when you already have code to run \u2014 e.g., running code from a previous write_code call, re-running a snippet, or executing code the user provided. Use console.log() for output.",
+    toolDescWriteAndRun: "Write a fresh solution from scratch and execute it in one step. Use this when you need to figure out the code AND run it \u2014 the autonomous, end-to-end tool for solving problems with code.",
+    codeParamDesc: "JavaScript code to execute. Use console.log() for output. Use import syntax (ES modules).",
+    codeRules: `- Your code runs in a Node.js child process with access to all built-in modules
+- IMPORTANT: Your code runs as an ES module (.mjs). Use import syntax, NOT require():
+  - import fs from 'fs';
+  - import path from 'path';
+  - import { execSync } from 'child_process';
+- Use console.log() to produce output \u2014 that's how results are returned to you
+- Write efficient scripts that do multiple things per execution when possible
+- For parallel async operations, use Promise.all()
+- Handle errors in your scripts with try/catch so you get useful error messages
+- Top-level await is supported`,
+    commentsEnabled: `- Add a JSDoc @fileoverview comment at the top of each script explaining what it does
+- Add brief JSDoc @param comments for any functions you define`,
+    commentsDisabled: `- Do NOT write any comments in your code \u2014 save tokens. The code should be self-explanatory.`,
+    packageLabel: "Available Packages",
+    packageIntro: "These npm packages are installed and can be imported",
+    bashExamples: "ls, grep, curl, git, npm, cat",
+    codeBlockLang: "javascript",
+    execToolSummary: "Run a given piece of JavaScript code. Use when you already have code to run \u2014 e.g., from a previous write_code call, re-running a snippet, or executing user-provided code.",
+    writeRunToolSummary: "Write a fresh solution from scratch and execute it in one step. The autonomous, end-to-end tool for solving problems with code."
+  },
+  python: {
+    toolDescExecute: "Execute a given piece of Python code in a child process. Use this when you already have code to run \u2014 e.g., running code from a previous write_code call, re-running a snippet, or executing code the user provided. Use print() for output.",
+    toolDescWriteAndRun: "Write a fresh Python solution from scratch and execute it in one step. Use this when you need to figure out the code AND run it \u2014 the autonomous, end-to-end tool for solving problems with code.",
+    codeParamDesc: "Python code to execute. Use print() for output.",
+    codeRules: `- Your code runs in a Python 3 child process
+- Use print() to produce output \u2014 that's how results are returned to you
+- Use standard Python imports (import os, import json, from pathlib import Path, etc.)
+- Write efficient scripts; prefer list comprehensions and built-in functions
+- For async operations, use asyncio
+- Handle errors with try/except so you get useful error messages
+- A virtual environment is active \u2014 you can install packages using run_bash with: pip install <package>
+- Installed packages persist across executions in this session`,
+    commentsEnabled: `- Add a module-level docstring at the top of each script explaining what it does
+- Add brief docstrings for any functions you define`,
+    commentsDisabled: `- Do NOT write any comments in your code \u2014 save tokens. The code should be self-explanatory.`,
+    packageLabel: "Available Packages",
+    packageIntro: "These Python packages are available for import",
+    bashExamples: "ls, grep, curl, git, pip, cat",
+    codeBlockLang: "python",
+    execToolSummary: "Run a given piece of Python code. Use when you already have code to run \u2014 e.g., from a previous write_code call, re-running a snippet, or executing user-provided code.",
+    writeRunToolSummary: "Write a fresh Python solution from scratch and execute it in one step. The autonomous, end-to-end tool for solving problems with code."
+  }
+};
 var EXECUTING_TOOLS = /* @__PURE__ */ new Set(["execute_code", "write_and_run_code", "run_bash"]);
 var CodeAgent = class extends base_default {
   /**
@@ -1638,6 +1715,8 @@ var CodeAgent = class extends base_default {
     }
     super(options);
     this.workingDirectory = options.workingDirectory || process.cwd();
+    this.language = options.language || "javascript";
+    this.pythonPath = options.pythonPath || null;
     this.maxRounds = options.maxRounds || 10;
     this.timeout = options.timeout || 3e4;
     this.onBeforeExecution = options.onBeforeExecution || null;
@@ -1649,6 +1728,9 @@ var CodeAgent = class extends base_default {
     this.maxRetries = options.maxRetries ?? 3;
     this.skills = options.skills || [];
     this.envOverview = options.envOverview || "";
+    this._pythonBinary = null;
+    this._venvPath = null;
+    this._venvEnv = null;
     this.customTools = (options.tools || []).map((t) => ({
       name: t.name,
       description: t.description,
@@ -1677,6 +1759,7 @@ var CodeAgent = class extends base_default {
    * @returns {{ functionDeclarations: Array<Object> }}
    */
   _buildToolDefinitions() {
+    const lang = LANG_CONFIG[this.language] || LANG_CONFIG.javascript;
     const declarations = [
       {
         name: "write_code",
@@ -1693,11 +1776,11 @@ var CodeAgent = class extends base_default {
       },
       {
         name: "execute_code",
-        description: "Execute a given piece of JavaScript code in a Node.js child process. Use this when you already have code to run \u2014 e.g., running code from a previous write_code call, re-running a snippet, or executing code the user provided. Use console.log() for output.",
+        description: lang.toolDescExecute,
         parametersJsonSchema: {
           type: "object",
           properties: {
-            code: { type: "string", description: "JavaScript code to execute. Use console.log() for output. Use import syntax (ES modules)." },
+            code: { type: "string", description: lang.codeParamDesc },
             purpose: { type: "string", description: 'A short 2-4 word slug describing what this script does (e.g., "read-config", "parse-logs").' }
           },
           required: ["code"]
@@ -1705,11 +1788,11 @@ var CodeAgent = class extends base_default {
       },
       {
         name: "write_and_run_code",
-        description: "Write a fresh solution from scratch and execute it in one step. Use this when you need to figure out the code AND run it \u2014 the autonomous, end-to-end tool for solving problems with code.",
+        description: lang.toolDescWriteAndRun,
         parametersJsonSchema: {
           type: "object",
           properties: {
-            code: { type: "string", description: "JavaScript code to write and execute. Use console.log() for output. Use import syntax (ES modules)." },
+            code: { type: "string", description: lang.codeParamDesc },
             purpose: { type: "string", description: 'A short 2-4 word slug describing what this script does (e.g., "fetch-api-data", "generate-report").' }
           },
           required: ["code"]
@@ -1731,7 +1814,7 @@ var CodeAgent = class extends base_default {
       },
       {
         name: "run_bash",
-        description: "Execute a shell command in the working directory. Use this for file operations, git commands, installing packages, or any shell task. Prefer this over execute_code for simple shell operations.",
+        description: `Execute a shell command in the working directory. Use this for file operations, git commands, installing packages, or any shell task (e.g., ${lang.bashExamples}). Prefer this over execute_code for simple shell operations.`,
         parametersJsonSchema: {
           type: "object",
           properties: {
@@ -1770,6 +1853,10 @@ var CodeAgent = class extends base_default {
     if (this.skills.length > 0 && (this._skillRegistry.size === 0 || force)) {
       await this._loadSkills();
     }
+    if (this.language === "python" && (!this._pythonBinary || force)) {
+      await this._resolvePython();
+      await this._setupVenv();
+    }
     this.chatConfig.tools = [this._buildToolDefinitions()];
     if (!this._contextGathered || force) {
       await this._gatherCodebaseContext();
@@ -1797,6 +1884,70 @@ var CodeAgent = class extends base_default {
       }
     }
   }
+  // ── Python Resolution ───────────────────────────────────────────────────
+  /**
+   * Resolve the Python 3 binary path.
+   * @private
+   */
+  async _resolvePython() {
+    const tryBinary = (bin) => new Promise((resolve2) => {
+      (0, import_node_child_process.execFile)(bin, ["--version"], { timeout: 5e3 }, (err, stdout, stderr) => {
+        if (err) return resolve2(null);
+        const output = (stdout || "") + (stderr || "");
+        if (output.includes("Python 3.")) return resolve2(bin);
+        resolve2(null);
+      });
+    });
+    if (this.pythonPath) {
+      const result = await tryBinary(this.pythonPath);
+      if (result) {
+        this._pythonBinary = result;
+        return;
+      }
+      throw new Error(`CodeAgent: pythonPath "${this.pythonPath}" is not a valid Python 3 binary.`);
+    }
+    const python3 = await tryBinary("python3");
+    if (python3) {
+      this._pythonBinary = python3;
+      return;
+    }
+    const python = await tryBinary("python");
+    if (python) {
+      this._pythonBinary = python;
+      return;
+    }
+    throw new Error('CodeAgent: language is "python" but python3 was not found on PATH. Install Python 3 or provide the pythonPath option.');
+  }
+  /**
+   * Create a virtual environment for Python execution.
+   * @private
+   */
+  async _setupVenv() {
+    await (0, import_promises2.mkdir)(this.writeDir, { recursive: true });
+    this._venvPath = (0, import_node_path.join)(this.writeDir, ".venv");
+    const isWin = process.platform === "win32";
+    const venvBin = isWin ? (0, import_node_path.join)(this._venvPath, "Scripts") : (0, import_node_path.join)(this._venvPath, "bin");
+    const venvPython = (0, import_node_path.join)(venvBin, isWin ? "python.exe" : "python");
+    try {
+      await (0, import_promises2.readFile)(venvPython);
+    } catch {
+      logger_default.debug(`Creating Python venv at ${this._venvPath}`);
+      await new Promise((resolve2, reject) => {
+        (0, import_node_child_process.execFile)(this._pythonBinary, ["-m", "venv", this._venvPath], {
+          timeout: 3e4
+        }, (err) => {
+          if (err) return reject(new Error(`CodeAgent: failed to create venv: ${err.message}`));
+          resolve2();
+        });
+      });
+    }
+    const env = Object.assign({}, process.env);
+    env.VIRTUAL_ENV = this._venvPath;
+    env.PATH = venvBin + (isWin ? ";" : ":") + (process.env.PATH || "");
+    this._venvEnv = env;
+    this._pythonBinary = venvPython;
+    logger_default.debug(`Python venv ready at ${this._venvPath}`);
+  }
   // ── Context Gathering ────────────────────────────────────────────────────
   /**
    * @private
@@ -1815,15 +1966,35 @@ var CodeAgent = class extends base_default {
       fileTree = `${truncated}
 ... (${lines.length - MAX_FILE_TREE_LINES} more files)`;
     }
-    let npmPackages = [];
-    try {
-      const pkgPath = (0, import_node_path.join)(this.workingDirectory, "package.json");
-      const pkg = JSON.parse(await (0, import_promises2.readFile)(pkgPath, "utf-8"));
-      npmPackages = [
-        ...Object.keys(pkg.dependencies || {}),
-        ...Object.keys(pkg.devDependencies || {})
-      ];
-    } catch {
+    let packages = [];
+    if (this.language === "python") {
+      try {
+        const reqPath = (0, import_node_path.join)(this.workingDirectory, "requirements.txt");
+        const content = await (0, import_promises2.readFile)(reqPath, "utf-8");
+        packages = content.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#") && !l.startsWith("-")).map((l) => l.split(/[>=<!\[;\s]/)[0]);
+      } catch {
+      }
+      if (packages.length === 0) {
+        try {
+          const ppPath = (0, import_node_path.join)(this.workingDirectory, "pyproject.toml");
+          const content = await (0, import_promises2.readFile)(ppPath, "utf-8");
+          const depMatch = content.match(/dependencies\s*=\s*\[([\s\S]*?)\]/);
+          if (depMatch) {
+            packages = (depMatch[1].match(/"([^"]+)"/g) || []).map((s) => s.replace(/"/g, "").split(/[>=<!\[;\s]/)[0]);
+          }
+        } catch {
+        }
+      }
+    } else {
+      try {
+        const pkgPath = (0, import_node_path.join)(this.workingDirectory, "package.json");
+        const pkg = JSON.parse(await (0, import_promises2.readFile)(pkgPath, "utf-8"));
+        packages = [
+          ...Object.keys(pkg.dependencies || {}),
+          ...Object.keys(pkg.devDependencies || {})
+        ];
+      } catch {
+      }
     }
     const importantFileContents = [];
     if (this.importantFiles.length > 0) {
@@ -1843,7 +2014,7 @@ var CodeAgent = class extends base_default {
         }
       }
     }
-    this._codebaseContext = { fileTree, npmPackages, importantFileContents };
+    this._codebaseContext = { fileTree, npmPackages: packages, packages, importantFileContents };
     this._contextGathered = true;
   }
   /**
@@ -1901,7 +2072,8 @@ var CodeAgent = class extends base_default {
    * @private
    */
   _buildSystemPrompt() {
-    const { fileTree, npmPackages, importantFileContents } = this._codebaseContext || { fileTree: "", npmPackages: [], importantFileContents: [] };
+    const { fileTree, packages, importantFileContents } = this._codebaseContext || { fileTree: "", packages: [], importantFileContents: [] };
+    const lang = LANG_CONFIG[this.language] || LANG_CONFIG.javascript;
     let prompt = `You are a coding agent working in ${this.workingDirectory}.
 
 ## Available Tools
@@ -1910,16 +2082,16 @@ var CodeAgent = class extends base_default {
 Output code without executing it. Use when showing, proposing, or presenting code to the user.
 
 ### execute_code
-Run a given piece of JavaScript code. Use when you already have code to run \u2014 e.g., from a previous write_code call, re-running a snippet, or executing user-provided code.
+${lang.execToolSummary}
 
 ### write_and_run_code
-Write a fresh solution from scratch and execute it in one step. The autonomous, end-to-end tool for solving problems with code.
+${lang.writeRunToolSummary}
 
 ### fix_code
 Fix broken code by providing original and fixed versions. Set execute=true to verify the fix works.
 
 ### run_bash
-Run shell commands directly (e.g., ls, grep, curl, git, npm, cat). Prefer this over execute_code for simple shell operations.`;
+Run shell commands directly (e.g., ${lang.bashExamples}). Prefer this over execute_code for simple shell operations.`;
     if (this._skillRegistry.size > 0) {
       prompt += `
 
@@ -1931,24 +2103,14 @@ Load a skill by name to get detailed instructions and templates. Available skill
 ## Code Execution Rules
 These rules apply when using execute_code, write_and_run_code, or fix_code (with execute=true):
 - Always provide a short descriptive \`purpose\` parameter (2-4 word slug like "read-config")
-- Your code runs in a Node.js child process with access to all built-in modules
-- IMPORTANT: Your code runs as an ES module (.mjs). Use import syntax, NOT require():
-  - import fs from 'fs';
-  - import path from 'path';
-  - import { execSync } from 'child_process';
-- Use console.log() to produce output \u2014 that's how results are returned to you
-- Write efficient scripts that do multiple things per execution when possible
-- For parallel async operations, use Promise.all()
-- Handle errors in your scripts with try/catch so you get useful error messages
-- Top-level await is supported
+${lang.codeRules}
 - The working directory is: ${this.workingDirectory}`;
     if (this.comments) {
       prompt += `
-- Add a JSDoc @fileoverview comment at the top of each script explaining what it does
-- Add brief JSDoc @param comments for any functions you define`;
+${lang.commentsEnabled}`;
     } else {
       prompt += `
-- Do NOT write any comments in your code \u2014 save tokens. The code should be self-explanatory.`;
+${lang.commentsDisabled}`;
     }
     if (fileTree) {
       prompt += `
@@ -1958,11 +2120,11 @@ These rules apply when using execute_code, write_and_run_code, or fix_code (with
 ${fileTree}
 \`\`\``;
     }
-    if (npmPackages.length > 0) {
+    if (packages && packages.length > 0) {
       prompt += `
 
-## Available Packages
-These npm packages are installed and can be imported: ${npmPackages.join(", ")}`;
+## ${lang.packageLabel}
+${lang.packageIntro}: ${packages.join(", ")}`;
     }
     if (importantFileContents && importantFileContents.length > 0) {
       prompt += `
@@ -1972,7 +2134,7 @@ These npm packages are installed and can be imported: ${npmPackages.join(", ")}`
         prompt += `
 
 ### ${filePath}
-\`\`\`javascript
+\`\`\`${lang.codeBlockLang}
 ${content}
 \`\`\``;
       }
@@ -2018,14 +2180,17 @@ ${this.envOverview}`;
     }
     await (0, import_promises2.mkdir)(this.writeDir, { recursive: true });
     const slug = this._slugify(purpose);
-    const tempFile = (0, import_node_path.join)(this.writeDir, `agent-${slug}-${Date.now()}.mjs`);
+    const ext = this.language === "python" ? ".py" : ".mjs";
+    const tempFile = (0, import_node_path.join)(this.writeDir, `agent-${slug}-${Date.now()}${ext}`);
     try {
       await (0, import_promises2.writeFile)(tempFile, code, "utf-8");
+      const binary = this.language === "python" ? this._pythonBinary : "node";
+      const execEnv = this.language === "python" && this._venvEnv ? this._venvEnv : process.env;
       const result = await new Promise((resolve2) => {
-        const child = (0, import_node_child_process.execFile)("node", [tempFile], {
+        const child = (0, import_node_child_process.execFile)(binary, [tempFile], {
           cwd: this.workingDirectory,
           timeout: this.timeout,
-          env: process.env,
+          env: execEnv,
           maxBuffer: 10 * 1024 * 1024
         }, (err, stdout, stderr) => {
           this._activeProcess = null;
@@ -2096,11 +2261,12 @@ ${this.envOverview}`;
         logger_default.warn(`onBeforeExecution callback error: ${e.message}`);
       }
     }
+    const execEnv = this.language === "python" && this._venvEnv ? this._venvEnv : process.env;
     const result = await new Promise((resolve2) => {
       const child = (0, import_node_child_process.execFile)("bash", ["-c", command], {
         cwd: this.workingDirectory,
         timeout: this.timeout,
-        env: process.env,
+        env: execEnv,
         maxBuffer: 10 * 1024 * 1024
       }, (err, stdout, stderr) => {
         this._activeProcess = null;
@@ -2480,8 +2646,9 @@ ${this.envOverview}`;
    * @returns {Array<{fileName: string, purpose: string|null, script: string, filePath: string|null, tool: string}>}
    */
   dump() {
+    const ext = this.language === "python" ? ".py" : ".mjs";
     return this._allExecutions.map((exec, i) => ({
-      fileName: exec.purpose ? `agent-${exec.purpose}.mjs` : `script-${i + 1}.mjs`,
+      fileName: exec.purpose ? `agent-${exec.purpose}${ext}` : `script-${i + 1}${ext}`,
       purpose: exec.purpose || null,
       script: exec.code,
       filePath: exec.filePath || null,
@@ -2897,9 +3064,155 @@ var Embedding = class extends base_default {
   }
 };
 
+// image-generator.js
+var import_node_fs = require("node:fs");
+var DEFAULT_IMAGE_MODEL = "gemini-3.1-flash-image-preview";
+var ImageGenerator = class extends base_default {
+  /**
+   * @param {import('./types.d.ts').ImageGeneratorOptions} [options={}]
+   */
+  constructor(options = {}) {
+    if (options.modelName === void 0) {
+      options = { ...options, modelName: DEFAULT_IMAGE_MODEL };
+    }
+    if (options.systemPrompt === void 0) {
+      options = { ...options, systemPrompt: null };
+    }
+    super(options);
+    this.aspectRatio = options.aspectRatio || null;
+    this.imageSize = options.imageSize || null;
+    this.personGeneration = options.personGeneration || null;
+    this.includeText = options.includeText ?? false;
+    logger_default.debug(`ImageGenerator created with model: ${this.modelName}`);
+  }
+  /**
+   * Validate API connection only; no chat session (stateless).
+   * @param {boolean} [force=false]
+   */
+  async init(force = false) {
+    if (this._initialized && !force) return;
+    logger_default.debug(`Initializing ${this.constructor.name} with model: ${this.modelName}...`);
+    try {
+      await this.genAIClient.models.list();
+      logger_default.debug(`${this.constructor.name}: API connection successful.`);
+    } catch (e) {
+      throw new Error(`${this.constructor.name} initialization failed: ${e.message}`);
+    }
+    this._initialized = true;
+  }
+  /**
+   * Build a FRESH config — Gemini image models reject safetySettings/temp/topK/topP/thinkingConfig.
+   * Do NOT spread this.chatConfig.
+   * @private
+   */
+  _buildConfig(overrides = {}) {
+    const includeText = overrides.includeText ?? this.includeText;
+    const config = { responseModalities: includeText ? ["IMAGE", "TEXT"] : ["IMAGE"] };
+    const imageConfig = {};
+    const aspectRatio = overrides.aspectRatio || this.aspectRatio;
+    const imageSize = overrides.imageSize || this.imageSize;
+    const personGeneration = overrides.personGeneration || this.personGeneration;
+    if (aspectRatio) imageConfig.aspectRatio = aspectRatio;
+    if (imageSize) imageConfig.imageSize = imageSize;
+    if (personGeneration) imageConfig.personGeneration = personGeneration;
+    if (Object.keys(imageConfig).length > 0) config.imageConfig = imageConfig;
+    return config;
+  }
+  /**
+   * Generate one or more images from a text prompt.
+   * Optionally accepts `inputImages` for image editing / multi-image composition.
+   *
+   * @param {string} prompt
+   * @param {import('./types.d.ts').ImageGenerateOptions} [opts={}]
+   * @returns {Promise<import('./types.d.ts').ImageGenerationResult>}
+   */
+  async generate(prompt, opts = {}) {
+    if (!this._initialized) await this.init();
+    const parts = [{ text: prompt }];
+    if (Array.isArray(opts.inputImages)) {
+      for (const img of opts.inputImages) {
+        parts.push({ inlineData: { data: img.data, mimeType: img.mimeType } });
+      }
+    }
+    const result = await this._withRetry(() => this.genAIClient.models.generateContent({
+      model: this.modelName,
+      contents: [{ role: "user", parts }],
+      config: this._buildConfig(opts)
+    }));
+    this._captureMetadata(result);
+    this._cumulativeUsage = {
+      promptTokens: this.lastResponseMetadata.promptTokens,
+      responseTokens: this.lastResponseMetadata.responseTokens,
+      totalTokens: this.lastResponseMetadata.totalTokens,
+      attempts: 1
+    };
+    const images = [];
+    let text = "";
+    const responseParts = result.candidates?.[0]?.content?.parts || [];
+    for (const part of responseParts) {
+      if (part.inlineData?.data) {
+        images.push({
+          data: part.inlineData.data,
+          mimeType: part.inlineData.mimeType || "image/png"
+        });
+      } else if (part.text) {
+        text += part.text;
+      }
+    }
+    if (images.length === 0) {
+      logger_default.warn("ImageGenerator: no images returned. Check prompt or safety filters.");
+    }
+    return { images, text: text || null, usage: this.getLastUsage() };
+  }
+  /**
+   * Convenience: write one or all images to disk.
+   * If multiple images, suffixes with `_N` before extension.
+   * @param {import('./types.d.ts').ImageGenerationResult} result
+   * @param {string} filePath
+   * @returns {string[]} Written file paths
+   */
+  save(result, filePath) {
+    if (!result?.images?.length) {
+      logger_default.warn("ImageGenerator.save(): no images to save.");
+      return [];
+    }
+    const paths = [];
+    const dot = filePath.lastIndexOf(".");
+    const base = dot >= 0 ? filePath.slice(0, dot) : filePath;
+    const ext = dot >= 0 ? filePath.slice(dot) : ".png";
+    result.images.forEach((img, i) => {
+      const out = result.images.length === 1 ? filePath : `${base}_${i}${ext}`;
+      (0, import_node_fs.writeFileSync)(out, Buffer.from(img.data, "base64"));
+      paths.push(out);
+    });
+    return paths;
+  }
+  // ── No-ops (image gen is stateless) ──
+  /** @returns {any[]} Always returns empty array */
+  getHistory() {
+    return [];
+  }
+  /** No-op for ImageGenerator */
+  async clearHistory() {
+  }
+  /** No-op for ImageGenerator */
+  async seed() {
+    logger_default.warn("ImageGenerator.seed() is a no-op \u2014 image generation does not support few-shot.");
+    return [];
+  }
+  /**
+   * @param {any} _nextPayload
+   * @throws {Error} ImageGenerator does not support token estimation
+   * @returns {Promise<{ inputTokens: number }>}
+   */
+  async estimate(_nextPayload) {
+    throw new Error("ImageGenerator does not support token estimation. Use generate() directly.");
+  }
+};
+
 // index.js
 var import_genai2 = require("@google/genai");
-var index_default = { Transformer: transformer_default, Chat: chat_default, Message: message_default, ToolAgent: tool_agent_default, CodeAgent: code_agent_default, RagAgent: rag_agent_default, Embedding };
+var index_default = { Transformer: transformer_default, Chat: chat_default, Message: message_default, ToolAgent: tool_agent_default, CodeAgent: code_agent_default, RagAgent: rag_agent_default, Embedding, ImageGenerator };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BaseGemini,
@@ -2908,6 +3221,7 @@ var index_default = { Transformer: transformer_default, Chat: chat_default, Mess
   Embedding,
   HarmBlockThreshold,
   HarmCategory,
+  ImageGenerator,
   Message,
   RagAgent,
   ThinkingLevel,

package/index.js

@@ -27,6 +27,7 @@ export { default as ToolAgent } from './tool-agent.js';
 export { default as CodeAgent } from './code-agent.js';
 export { default as RagAgent } from './rag-agent.js';
 export { default as Embedding } from './embedding.js';
+export { default as ImageGenerator } from './image-generator.js';
 export { default as BaseGemini } from './base.js';
 export { default as log } from './logger.js';
 export { ThinkingLevel, HarmCategory, HarmBlockThreshold } from '@google/genai';
@@ -41,5 +42,6 @@ import ToolAgent from './tool-agent.js';
 import CodeAgent from './code-agent.js';
 import RagAgent from './rag-agent.js';
 import Embedding from './embedding.js';
+import ImageGenerator from './image-generator.js';
 
-export default { Transformer, Chat, Message, ToolAgent, CodeAgent, RagAgent, Embedding };
+export default { Transformer, Chat, Message, ToolAgent, CodeAgent, RagAgent, Embedding, ImageGenerator };