omnikey-cli 1.0.28 → 1.0.29

package/README.md

@@ -19,6 +19,7 @@ OmnikeyAI is a productivity tool that helps you quickly rewrite selected text us
 - Accepts CLI flags for non-interactive setup.
 - Configure and run the backend daemon — persisted across reboots on both macOS and Windows.
 - `omnikey grant-browser-access`: One-time setup to give Omnikey access to authenticated browser tabs for web fetch.
+- Scheduled Jobs commands to create, list, delete, and trigger jobs from the CLI.
 
 ## Usage
 
@@ -64,23 +65,71 @@ omnikey grant-browser-access
 
 # Reopen the browser with its saved Omnikey debug profile at any time
 omnikey browser open
+
+# Add a scheduled job (interactive)
+omnikey schedule add
+
+# List scheduled jobs
+omnikey schedule list
+
+# Remove a scheduled job (interactive select)
+omnikey schedule remove
+
+# Trigger a scheduled job immediately by ID
+omnikey schedule run-now <job-id>
 ```
 
 ### Command reference
 
-| Command | Description |
-|---|---|
-| `omnikey onboard` | Interactive setup for LLM provider and web search |
-| `omnikey daemon [--port]` | Start the backend daemon (default port: 7071) |
-| `omnikey kill-daemon` | Stop the running daemon |
-| `omnikey restart-daemon [--port]` | Kill and restart the daemon |
-| `omnikey config` | Display current config with masked API keys |
-| `omnikey set <key> <value>` | Update a single config value |
-| `omnikey remove-config [--db]` | Remove config files; add `--db` to also delete the database |
-| `omnikey status` | Show what process is using the daemon port |
-| `omnikey logs [--lines N] [--errors]` | Tail daemon logs |
-| `omnikey grant-browser-access` | Set up authenticated browser tab access for web fetch |
-| `omnikey browser open` | Reopen the browser with the saved Omnikey debug profile |
+| Command                               | Description                                                               |
+| ------------------------------------- | ------------------------------------------------------------------------- |
+| `omnikey onboard`                     | Interactive setup for LLM provider and web search                         |
+| `omnikey daemon [--port]`             | Start the backend daemon (default port: 7071)                             |
+| `omnikey kill-daemon`                 | Stop the running daemon                                                   |
+| `omnikey restart-daemon [--port]`     | Kill and restart the daemon                                               |
+| `omnikey config`                      | Display current config with masked API keys                               |
+| `omnikey set <key> <value>`           | Update a single config value                                              |
+| `omnikey remove-config [--db]`        | Remove config files; add `--db` to also delete the database               |
+| `omnikey status`                      | Show what process is using the daemon port                                |
+| `omnikey logs [--lines N] [--errors]` | Tail daemon logs                                                          |
+| `omnikey grant-browser-access`        | Set up authenticated browser tab access for web fetch                     |
+| `omnikey browser open`                | Reopen the browser with the saved Omnikey debug profile                   |
+| `omnikey schedule add`                | Create a scheduled job with interactive prompt, schedule type, and timing |
+| `omnikey schedule list`               | List all scheduled jobs with status and next run                          |
+| `omnikey schedule remove`             | Remove an existing scheduled job via interactive selection                |
+| `omnikey schedule run-now <id>`       | Trigger a scheduled job immediately                                       |
+
+## Scheduled Jobs
+
+The CLI includes a full `schedule` command group to manage recurring and one-time jobs.
+
+### `omnikey schedule add`
+
+Creates a new job interactively:
+
+- Prompts for a job label
+- Lets you enter a multiline prompt directly in terminal (type `END` on its own line when finished)
+- Supports:
+  - Recurring schedule with cron presets or custom cron
+  - One-time schedule by date/time
+
+### `omnikey schedule list`
+
+Displays all jobs in a table with:
+
+- ID
+- Label
+- Schedule
+- Next run
+- Status
+
+### `omnikey schedule remove`
+
+Lets you choose a job from a list and confirms deletion.
+
+### `omnikey schedule run-now <id>`
+
+Runs a job immediately using its job ID.
 
 ## Browser access (`grant-browser-access` / `browser open`)
 
@@ -133,12 +182,12 @@ The daemon is registered as a **launchd agent** (`~/Library/LaunchAgents/com.omn
 
 The daemon runs as a **Windows Service** managed by [NSSM (Non-Sucking Service Manager)](https://nssm.cc/). This gives it production-grade persistence:
 
-| Behaviour | Detail |
-|---|---|
-| Starts on boot | Runs as `SERVICE_AUTO_START` — no login required |
-| Auto-restarts on crash | Restarts after a 3-second delay on any unexpected exit |
-| Runs in the background | No console window, no logged-in user needed |
-| Log rotation | stdout/stderr written to `~/.omnikey/daemon.log` and `daemon-error.log` with rotation enabled |
+| Behaviour              | Detail                                                                                        |
+| ---------------------- | --------------------------------------------------------------------------------------------- |
+| Starts on boot         | Runs as `SERVICE_AUTO_START` — no login required                                              |
+| Auto-restarts on crash | Restarts after a 3-second delay on any unexpected exit                                        |
+| Runs in the background | No console window, no logged-in user needed                                                   |
+| Log rotation           | stdout/stderr written to `~/.omnikey/daemon.log` and `daemon-error.log` with rotation enabled |
 
 #### Prerequisites
 

package/backend-dist/agent/agentPrompts.js

@@ -25,6 +25,11 @@ ${hasTaskInstructions
 - Use the built-in \`web_search\` tool when the user asks to search online, or when current information (prices, docs, recent events) is needed.
 - If a request needs BOTH machine data AND web search: emit a \`<shell_script>\` first → wait for \`TERMINAL OUTPUT:\` → then call the web tool with concrete values. Never use placeholders like "my IP" in a web query.
 
+**When to use image tools:**
+- Use the built-in \`generate_image\` tool when the user asks you to create or render an image.
+- Prefer the user-provided output path when available. If none is provided, call the tool without \`file_path\` so it saves to a temporary file.
+- After the tool call returns, provide a \`<final_answer>\` that includes the saved file path.
+
 **Incoming message tags:**
 - \`TERMINAL OUTPUT:\` — stdout/stderr from a prior script. Analyze it immediately and respond with EITHER a follow-up \`<shell_script>\` (if more data is needed) OR a \`<final_answer>\` (if you have enough to conclude). You MUST pick one — never respond with plain text.
 - \`COMMAND ERROR:\` — script failed. Diagnose and emit a corrected \`<shell_script>\` or explain in \`<final_answer>\`.
@@ -32,7 +37,7 @@ ${hasTaskInstructions
 
 **Response format — every response must be exactly one of:**
 1. \`<shell_script>...</shell_script>\` — to run commands and gather more data.
-2. A \`web_search\` or \`web_fetch\` tool call — to fetch web context (use native tool calling, not XML tags).
+2. A \`web_search\`, \`web_fetch\`, or \`generate_image\` tool call — to fetch web context or generate images (use native tool calling, not XML tags).
 3. \`<final_answer>...</final_answer>\` — your conclusion once you have enough information.
 
 **Critical rule:** After receiving \`TERMINAL OUTPUT:\` you MUST immediately produce either \`<shell_script>\` or \`<final_answer>\`. Never output raw text, markdown, or any other format. If the terminal output contains enough information to answer the user's request, output \`<final_answer>\` right away.

package/backend-dist/agent/agentServer.js

@@ -36,6 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgentTurn = runAgentTurn;
 exports.attachAgentWebSocketServer = attachAgentWebSocketServer;
 exports.createAgentRouter = createAgentRouter;
 const express_1 = __importDefault(require("express"));
@@ -51,6 +52,7 @@ const featureRoutes_1 = require("../featureRoutes");
 const web_search_provider_1 = require("../web-search/web-search-provider");
 const agentAuth_1 = require("./agentAuth");
 const authMiddleware_1 = require("../authMiddleware");
+const imageTool_1 = require("./imageTool");
 const utils_1 = require("./utils");
 const ai_client_1 = require("../ai-client");
 async function runToolLoop(initialResult, session, sessionId, send, log, tools, onUsage) {
@@ -74,10 +76,28 @@ async function runToolLoop(initialResult, session, sessionId, send, log, tools,
         });
         const toolResults = await Promise.all(toolCalls.map(async (tc) => {
             const args = tc.arguments;
+            if (tc.name === 'generate_image') {
+                const prompt = typeof args.prompt === 'string' ? args.prompt : '';
+                send({
+                    session_id: sessionId,
+                    sender: 'agent',
+                    content: `Generating image: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`,
+                    is_terminal_output: false,
+                    is_error: false,
+                    is_web_call: false,
+                });
+                const toolResult = await (0, imageTool_1.executeImageGenerationTool)(args, log);
+                log.info('Tool call completed', {
+                    sessionId,
+                    tool: tc.name,
+                    resultLength: toolResult.length,
+                });
+                return { id: tc.id, name: tc.name, result: toolResult };
+            }
             // Notify the frontend that a web tool call is about to execute.
             const webCallContent = tc.name === 'web_search'
-                ? `Searching the web for: "${args.query ?? ''}"`
-                : `Fetching URL: ${args.url ?? ''}`;
+                ? `Searching the web for: "${String(args.query ?? '')}"`
+                : `Fetching URL: ${String(args.url ?? '')}`;
             send({
                 session_id: sessionId,
                 sender: 'agent',
@@ -185,7 +205,7 @@ async function enforceSessionCap(subscriptionId, logger) {
         logger.error('Failed to enforce agent session cap', { subscriptionId, error: err });
     }
 }
-async function getOrCreateSession(sessionId, subscription, platform, log) {
+async function getOrCreateSession(sessionId, subscription, platform, log, isCronJob = false) {
     // 1. Return the live in-memory entry if already loaded this process lifetime.
     const existing = sessionMessages.get(sessionId);
     if (existing) {
@@ -246,7 +266,7 @@ async function getOrCreateSession(sessionId, subscription, platform, log) {
                 role: 'system',
                 content: systemPrompt,
             },
-            ...(prompt
+            ...(prompt && !isCronJob
                 ? [
                     {
                         role: 'user',
@@ -291,8 +311,8 @@ ${prompt}
         hasStoredPrompt: !!prompt,
     };
 }
-async function runAgentTurn(sessionId, subscription, clientMessage, send, log) {
-    const { sessionState: session, hasStoredPrompt } = await getOrCreateSession(sessionId, subscription, clientMessage.platform, log);
+async function runAgentTurn(sessionId, subscription, clientMessage, send, log, options) {
+    const { sessionState: session, hasStoredPrompt } = await getOrCreateSession(sessionId, subscription, clientMessage.platform, log, options?.isCronJob);
     // Count this call as one agent iteration.
     session.turns += 1;
     log.info('Starting agent turn', {
@@ -300,9 +320,9 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log) {
         subscriptionId: subscription.id,
         turn: session.turns,
     });
-    // On the MAX_TURNS iteration, instruct the LLM to provide a final,
-    // consolidated answer based on the full conversation context.
-    if (session.turns === MAX_TURNS) {
+    const effectiveMaxTurns = options?.maxTurns ?? MAX_TURNS;
+    // On the final iteration, instruct the LLM to provide a consolidated answer.
+    if (session.turns === effectiveMaxTurns) {
         (0, utils_1.pushToSessionHistory)(logger_1.logger, session, {
             role: 'system',
             content: 'Provide a single, final, concise answer based on the entire conversation so far. Wrap the answer in a <final_answer>...</final_answer> block and do not ask for further input or mention additional shell scripts to run. Do not include any <shell_script> block in this response.',
@@ -337,7 +357,13 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log) {
             role: 'user',
             content: isAssistance
                 ? userContent
-                : `<user_input>${(0, utils_1.createUserContent)(userContent, hasStoredPrompt)}</user_input>`,
+                : [
+                    `<user_input>`,
+                    !options?.isCronJob
+                        ? (0, utils_1.createUserContent)(userContent, hasStoredPrompt)
+                        : (0, utils_1.createUserContentForCronJob)(userContent),
+                    `</user_input>`,
+                ].join('\n'),
         });
         // Use the first real user message (turn 1) as the session title.
         if (session.turns === 1 && !isAssistance) {
@@ -352,7 +378,7 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log) {
     }
     // On the final turn we omit tools so the model is forced to emit a
     // plain text <final_answer> rather than issuing another tool call.
-    const isFinalTurn = session.turns >= MAX_TURNS;
+    const isFinalTurn = session.turns >= effectiveMaxTurns;
     const tools = isFinalTurn ? undefined : (0, utils_1.buildAvailableTools)();
     const recordUsage = async (result) => {
         const usage = result.usage;
@@ -426,7 +452,10 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log) {
             const toolLoopContent = toolLoopResult.content.trim();
             const toolLoopHasShell = toolLoopContent.includes('<shell_script>');
             const toolLoopHasFinal = toolLoopContent.includes('<final_answer>');
-            const webToolFailed = session.history.some((msg) => msg.role === 'tool' && typeof msg.content === 'string' && msg.content.startsWith('Error'));
+            const webToolFailed = session.history.some((msg) => msg.role === 'tool' &&
+                (msg.tool_name === 'web_search' || msg.tool_name === 'web_fetch') &&
+                typeof msg.content === 'string' &&
+                msg.content.startsWith('Error'));
             if (toolLoopHasShell || (toolLoopHasFinal && !webToolFailed)) {
                 // The tool loop already produced a shell script — use it directly.
                 // This avoids a redundant AI call and handles the case where the model
@@ -473,7 +502,7 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log) {
                     session_id: sessionId,
                     content: '',
                     is_web_call: true,
-                }, send, logger_1.logger);
+                }, send, logger_1.logger, options);
                 return;
             }
         }
@@ -512,13 +541,14 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log) {
                 turns: session.turns,
                 hasFinalAnswerTag,
             });
+            (0, utils_1.pushToSessionHistory)(logger_1.logger, session, { role: 'assistant', content });
+            await persistSessionToDB(sessionId, session);
+            sessionMessages.delete(sessionId);
             send({
                 session_id: sessionId,
                 sender: 'agent',
                 content: hasFinalAnswerTag ? content : `<final_answer>\n${content}\n</final_answer>`,
             });
-            await persistSessionToDB(sessionId, session);
-            sessionMessages.delete(sessionId);
         }
         else if (content) {
             // Fallback: the LLM returned content without any recognized tag and it
@@ -531,13 +561,13 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log) {
                 turn: session.turns,
             });
             (0, utils_1.pushToSessionHistory)(log, session, { role: 'assistant', content });
+            await persistSessionToDB(sessionId, session);
+            sessionMessages.delete(sessionId);
             send({
                 session_id: sessionId,
                 sender: 'agent',
                 content: `<final_answer>\n${content}\n</final_answer>`,
             });
-            await persistSessionToDB(sessionId, session);
-            sessionMessages.delete(sessionId);
         }
         else {
             log.warn('Agent returned empty content with no recognized tags; sending error', {

package/backend-dist/agent/imageTool.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMAGE_GENERATE_TOOL = void 0;
+exports.executeImageGenerationTool = executeImageGenerationTool;
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const cuid_1 = __importDefault(require("cuid"));
+const ai_client_1 = require("../ai-client");
+const ALLOWED_FORMATS = new Set(['png', 'webp', 'jpeg']);
+const ALLOWED_SIZES = new Set(['1024x1024', '1024x1536', '1536x1024']);
+const ALLOWED_QUALITIES = new Set(['low', 'medium', 'high']);
+const ALLOWED_BACKGROUNDS = new Set(['transparent', 'opaque', 'auto']);
+exports.IMAGE_GENERATE_TOOL = {
+    name: 'generate_image',
+    description: 'Generate an image from a prompt and save it to disk. Use this when the user asks you to create artwork, mockups, logos, diagrams, or visual assets.',
+    parameters: {
+        type: 'object',
+        properties: {
+            prompt: {
+                type: 'string',
+                description: 'Detailed image prompt describing what to generate.',
+            },
+            file_path: {
+                type: 'string',
+                description: 'Absolute or relative output path where the image should be saved. If omitted, a temp file path is used automatically.',
+            },
+            format: {
+                type: 'string',
+                enum: ['png', 'webp', 'jpeg'],
+                description: 'Output image format. Defaults to png.',
+            },
+            size: {
+                type: 'string',
+                enum: ['1024x1024', '1024x1536', '1536x1024'],
+                description: 'Image dimensions. Defaults to 1024x1024.',
+            },
+            quality: {
+                type: 'string',
+                enum: ['low', 'medium', 'high'],
+                description: 'Generation quality. Defaults to medium.',
+            },
+            background: {
+                type: 'string',
+                enum: ['transparent', 'opaque', 'auto'],
+                description: 'Background behavior. Defaults to auto.',
+            },
+        },
+        required: ['prompt'],
+    },
+};
+/**
+ * Reads a string argument from a tool-call payload and trims surrounding whitespace.
+ *
+ * @param args - Raw tool-call argument object.
+ * @param key - Argument key to read.
+ * @returns A trimmed string value, or `undefined` when missing/non-string/empty.
+ */
+function readStringArg(args, key) {
+    const value = args[key];
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+/**
+ * Resolves the final output path for the generated image.
+ *
+ * When `filePathArg` is provided, relative paths are resolved from the
+ * backend process working directory. Otherwise, a temp-file path is generated.
+ *
+ * @param filePathArg - Optional caller-provided output path.
+ * @param format - File format to use when generating a temp filename.
+ * @returns Absolute path where the image should be written.
+ */
+function resolveOutputPath(filePathArg, format) {
+    if (filePathArg) {
+        return path_1.default.isAbsolute(filePathArg) ? filePathArg : path_1.default.resolve(process.cwd(), filePathArg);
+    }
+    return path_1.default.join(os_1.default.tmpdir(), `omnikey-generated-${(0, cuid_1.default)()}.${format}`);
+}
+/**
+ * Converts a MIME type to the internal file-format enum.
+ *
+ * @param mimeType - MIME type returned by the provider (e.g. image/png).
+ * @param fallback - Format used when MIME type is missing or unknown.
+ * @returns Normalized image format used for file extension selection.
+ */
+function formatFromMime(mimeType, fallback) {
+    if (!mimeType)
+        return fallback;
+    if (mimeType.includes('jpeg') || mimeType.includes('jpg'))
+        return 'jpeg';
+    if (mimeType.includes('webp'))
+        return 'webp';
+    return 'png';
+}
+/**
+ * Writes generated image bytes to disk, creating parent directories as needed.
+ *
+ * @param outputPath - Absolute path to write to.
+ * @param imageBuffer - Binary image contents.
+ */
+async function writeImageFile(outputPath, imageBuffer) {
+    await promises_1.default.mkdir(path_1.default.dirname(outputPath), { recursive: true });
+    await promises_1.default.writeFile(outputPath, imageBuffer);
+}
+/**
+ * Executes the `generate_image` tool call.
+ *
+ * Validates and normalizes user arguments, requests image generation through
+ * the configured AI provider in `aiClient`, writes the image to disk, and
+ * returns a user-facing status message containing the saved path.
+ *
+ * @param args - Tool arguments supplied by the model.
+ * @param log - Structured logger scoped to the current agent turn.
+ * @returns Success or error message for the tool result block.
+ */
+async function executeImageGenerationTool(args, log) {
+    const prompt = readStringArg(args, 'prompt');
+    if (!prompt) {
+        return 'Error: prompt parameter is required.';
+    }
+    const rawFormat = readStringArg(args, 'format') ?? 'png';
+    const format = (ALLOWED_FORMATS.has(rawFormat) ? rawFormat : 'png');
+    const rawSize = readStringArg(args, 'size') ?? '1024x1024';
+    const size = (ALLOWED_SIZES.has(rawSize) ? rawSize : '1024x1024');
+    const rawQuality = readStringArg(args, 'quality') ?? 'medium';
+    const quality = (ALLOWED_QUALITIES.has(rawQuality) ? rawQuality : 'medium');
+    const rawBackground = readStringArg(args, 'background') ?? 'auto';
+    const background = (ALLOWED_BACKGROUNDS.has(rawBackground) ? rawBackground : 'auto');
+    const filePathArg = readStringArg(args, 'file_path');
+    try {
+        const generated = await ai_client_1.aiClient.generateImage({
+            prompt,
+            format,
+            size,
+            quality,
+            background,
+        });
+        const actualFormat = formatFromMime(generated.mimeType, format);
+        const outputPath = resolveOutputPath(filePathArg, actualFormat);
+        await writeImageFile(outputPath, Buffer.from(generated.imageBase64, 'base64'));
+        log.info('Image generated and saved', {
+            provider: generated.provider,
+            outputPath,
+            bytes: Buffer.byteLength(generated.imageBase64, 'base64'),
+            size,
+            quality,
+            format: actualFormat,
+        });
+        return [
+            `Image generated successfully with ${generated.provider}. Saved to: ${outputPath}`,
+            generated.note ? `Note: ${generated.note}` : undefined,
+        ]
+            .filter(Boolean)
+            .join(' ');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log.warn('generate_image tool failed', { error: message, provider: ai_client_1.aiClient.getProvider() });
+        return `Error generating image: ${message}`;
+    }
+}

package/backend-dist/agent/utils.js

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_HISTORY_TOTAL = void 0;
 exports.buildAvailableTools = buildAvailableTools;
 exports.createUserContent = createUserContent;
+exports.createUserContentForCronJob = createUserContentForCronJob;
 exports.sendFinalAnswer = sendFinalAnswer;
 exports.pushToSessionHistory = pushToSessionHistory;
 const web_search_provider_1 = require("../web-search/web-search-provider");
 const ai_client_1 = require("../ai-client");
 const config_1 = require("../config");
+const imageTool_1 = require("./imageTool");
 /**
  * Returns the set of web tools available to the agent for every turn.
  *
@@ -17,7 +19,7 @@ const config_1 = require("../config");
  * @returns An array of `AITool` definitions ready to pass to the AI client.
  */
 function buildAvailableTools() {
-    return [web_search_provider_1.WEB_FETCH_TOOL, web_search_provider_1.WEB_SEARCH_TOOL];
+    return [web_search_provider_1.WEB_FETCH_TOOL, web_search_provider_1.WEB_SEARCH_TOOL, imageTool_1.IMAGE_GENERATE_TOOL];
 }
 /**
  * Strips the `@omniagent` mention from user-supplied content.
@@ -36,6 +38,16 @@ function createUserContent(content, hasStoredPrompt) {
     }
     return content;
 }
+/**
+ *
+ * If it is a cron job and the prompt does not contain an @omniAgent mention, we will add it, since we will not consider any base prompt.
+ */
+function createUserContentForCronJob(content) {
+    if (!/@omniagent/gi.test(content)) {
+        return `@omniAgent ${content}`;
+    }
+    return content.trim();
+}
 /**
  * Sends a `<final_answer>` message over the WebSocket and closes the agent turn.
  *

package/backend-dist/ai-client.js

@@ -132,6 +132,32 @@ class OpenAIAdapter {
         }
         return { usage, model };
     }
+    /**
+     * Generates an image using OpenAI and returns base64 image bytes.
+     *
+     * @param options - Unified image-generation options.
+     * @returns Provider-normalized image payload.
+     */
+    async generateImage(options) {
+        const format = options.format ?? 'png';
+        const size = options.size ?? '1024x1024';
+        const quality = options.quality ?? 'medium';
+        const background = options.background ?? 'auto';
+        const response = await this.client.images.generate({
+            model: 'gpt-image-1',
+            prompt: options.prompt,
+            size,
+            quality,
+            background,
+            output_format: format,
+        });
+        const b64 = response?.data?.[0]?.b64_json;
+        if (!b64 || typeof b64 !== 'string') {
+            throw new Error('OpenAI image generation returned no image data');
+        }
+        const mimeType = format === 'jpeg' ? 'image/jpeg' : format === 'webp' ? 'image/webp' : 'image/png';
+        return { imageBase64: b64, mimeType, provider: 'openai' };
+    }
 }
 // ---------------------------------------------------------------------------
 // Anthropic adapter
@@ -300,6 +326,41 @@ class GeminiAdapter {
         }
         return { usage, model };
     }
+    /**
+     * Generates an image using Gemini Imagen and returns base64 image bytes.
+     *
+     * @param options - Unified image-generation options.
+     * @returns Provider-normalized image payload and optional compatibility note.
+     */
+    async generateImage(options) {
+        const requestedFormat = options.format ?? 'png';
+        const size = options.size ?? '1024x1024';
+        const quality = options.quality ?? 'medium';
+        const aspectRatio = size === '1024x1536' ? '2:3' : size === '1536x1024' ? '3:2' : '1:1';
+        // Imagen in this SDK path supports png/jpeg output directly. WebP requests
+        // are downgraded to PNG and surfaced with a note.
+        const outputMimeType = requestedFormat === 'jpeg' ? 'image/jpeg' : 'image/png';
+        const response = await this.client.models.generateImages({
+            model: 'imagen-4.0-generate-001',
+            prompt: options.prompt,
+            config: {
+                numberOfImages: 1,
+                aspectRatio,
+                outputMimeType,
+                guidanceScale: quality === 'high' ? 8 : quality === 'low' ? 5 : 6.5,
+            },
+        });
+        const generated = response.generatedImages?.[0]?.image;
+        const imageBase64 = generated?.imageBytes;
+        if (!imageBase64) {
+            throw new Error('Gemini image generation returned no image data');
+        }
+        const mimeType = generated?.mimeType || outputMimeType;
+        const note = requestedFormat === 'webp'
+            ? 'Gemini does not currently return WebP in this path; image was generated as PNG.'
+            : undefined;
+        return { imageBase64, mimeType, provider: 'gemini', note };
+    }
 }
 // ---------------------------------------------------------------------------
 // Main AIClient
@@ -344,6 +405,24 @@ class AIClient {
         }
         throw new Error(`AI provider "${this.provider}" is not configured.`);
     }
+    /**
+     * Generates an image with the currently configured provider.
+     *
+     * Supported providers are OpenAI and Gemini. Anthropic does not currently
+     * expose a text-to-image generation endpoint in this project.
+     *
+     * @param options - Unified image-generation options.
+     * @returns Provider-normalized image payload.
+     */
+    async generateImage(options) {
+        if (this.provider === 'openai' && this.openai) {
+            return this.openai.generateImage(options);
+        }
+        if (this.provider === 'gemini' && this.gemini) {
+            return this.gemini.generateImage(options);
+        }
+        throw new Error(`Image generation is not supported for provider "${this.provider}".`);
+    }
 }
 exports.AIClient = AIClient;
 // ---------------------------------------------------------------------------