ima2-gen 2.0.0 → 2.0.1

package/lib/agyImageAdapter.js

@@ -0,0 +1,232 @@
+import { spawn } from "node:child_process";
+import { readFile, rm, stat, writeFile, mkdir } from "node:fs/promises";
+import { extname, join, resolve } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { randomBytes } from "node:crypto";
+import { logEvent } from "./logger.js";
+import { detectImageMimeFromB64 } from "./refs.js";
+const AGY_TIMEOUT_MS = 360_000;
+const AGY_OUTPUT_RESOLUTION = "1024x1024";
+const AGY_MAX_OUTPUT_BYTES = 1024 * 1024;
+function agyError(message, status, code) {
+    const err = new Error(message);
+    err.status = status;
+    err.code = code;
+    return err;
+}
+function buildAgyPrompt(userPrompt, referencePaths) {
+    const imagePathsJson = referencePaths.length > 0
+        ? JSON.stringify(referencePaths)
+        : "[]";
+    return [
+        "Please generate one image by calling the tool default_api:generate_image once.",
+        "After the tool finishes, print one machine-readable result line so ima2-gen can copy the artifact.",
+        "",
+        "Tool parameters:",
+        `  Prompt: ${JSON.stringify(userPrompt)}`,
+        '  ImageName: "ima2_generated"',
+        `  ImagePaths: ${imagePathsJson}`,
+        '  toolSummary: "ima2 pipeline generation"',
+        '  toolAction: "Generating ima2 image"',
+        "",
+        `Reference count: ${referencePaths.length}. The output resolution is fixed at ${AGY_OUTPUT_RESOLUTION}.`,
+        "If generation succeeds, print: RESULT|<absolute_artifact_path>|<file_extension>",
+        "If generation fails, print: ERROR|<concise error message>",
+    ].join("\n");
+}
+function parseAgyOutput(stdout) {
+    const lines = stdout.trim().split("\n").filter((l) => l.trim().length > 0);
+    const resultLine = lines.find((l) => l.startsWith("RESULT|"));
+    if (resultLine) {
+        const parts = resultLine.split("|");
+        if (parts.length >= 3) {
+            return { artifactPath: parts[1], ext: parts[2] };
+        }
+        throw agyError(`Malformed RESULT line: ${resultLine}`, 502, "AGY_MALFORMED_RESULT");
+    }
+    const errorLine = lines.find((l) => l.startsWith("ERROR|"));
+    if (errorLine) {
+        const msg = errorLine.slice("ERROR|".length).trim() || "Unknown agy error";
+        const lower = msg.toLowerCase();
+        if (lower.includes("resource exhausted") || lower.includes("exhausted your capacity") || lower.includes("quota will reset")) {
+            throw agyError(`Agy generation failed: ${msg}`, 429, "AGY_QUOTA_EXHAUSTED");
+        }
+        throw agyError(`Agy generation failed: ${msg}`, 502, "AGY_GENERATION_FAILED");
+    }
+    const fullLower = stdout.toLowerCase();
+    if (fullLower.includes("resource exhausted") || fullLower.includes("exhausted your capacity")) {
+        throw agyError(`Agy quota exhausted: ${stdout.trim().slice(0, 200)}`, 429, "AGY_QUOTA_EXHAUSTED");
+    }
+    const savedPathLine = lines.find((l) => l.startsWith("SAVED_PATH="));
+    if (savedPathLine) {
+        const p = savedPathLine.slice("SAVED_PATH=".length).trim();
+        const ext = p.split(".").pop() || "png";
+        return { artifactPath: p, ext };
+    }
+    const normalizedStdout = stdout.replace(/\\/g, "/");
+    const pathMatch = normalizedStdout.match(/\/[^\s"']+\/(brain|artifacts)\/[^\s"']+\.(png|jpg|jpeg|webp)/i);
+    if (pathMatch) {
+        const artifactPath = process.platform === "win32" ? pathMatch[0].replace(/\//g, "\\") : pathMatch[0];
+        const ext = extname(artifactPath).slice(1) || "png";
+        return { artifactPath, ext };
+    }
+    throw agyError(`Could not parse artifact path from agy output (${stdout.length} chars): ${stdout.slice(0, 200)}`, 502, "AGY_PARSE_FAILED");
+}
+function spawnAgy(prompt, signal) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("agy", ["-p", "-"], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: {
+                PATH: process.env.PATH,
+                HOME: process.env.HOME,
+                USERPROFILE: process.env.USERPROFILE,
+                TMPDIR: process.env.TMPDIR,
+                TEMP: process.env.TEMP,
+                LANG: process.env.LANG,
+                GEMINI_API_KEY: process.env.GEMINI_API_KEY,
+            },
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                child.kill("SIGTERM");
+                reject(agyError("Agy generation timed out", 504, "AGY_TIMEOUT"));
+            }
+        }, AGY_TIMEOUT_MS);
+        child.stdout.on("data", (chunk) => { if (stdout.length < AGY_MAX_OUTPUT_BYTES)
+            stdout += chunk.toString(); });
+        child.stderr.on("data", (chunk) => { if (stderr.length < AGY_MAX_OUTPUT_BYTES)
+            stderr += chunk.toString(); });
+        child.on("error", (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(agyError(`Agy process error: ${err.message}`, 502, "AGY_PROCESS_ERROR"));
+        });
+        child.on("close", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (code !== 0 && !stdout.trim()) {
+                reject(agyError(`Agy exited with code ${code}: ${stderr.slice(0, 200)}`, 502, "AGY_PROCESS_ERROR"));
+                return;
+            }
+            resolve({ stdout, stderr });
+        });
+        if (signal) {
+            const onAbort = () => {
+                if (!settled) {
+                    settled = true;
+                    clearTimeout(timer);
+                    child.kill("SIGTERM");
+                    reject(agyError("Generation canceled", 499, "GENERATION_CANCELED"));
+                }
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+            child.on("close", () => signal.removeEventListener("abort", onAbort));
+        }
+        if (signal?.aborted) {
+            settled = true;
+            clearTimeout(timer);
+            child.kill("SIGTERM");
+            return reject(agyError("Generation canceled", 499, "GENERATION_CANCELED"));
+        }
+        child.stdin.on("error", () => { });
+        child.stdin.write(prompt);
+        child.stdin.end();
+    });
+}
+const MIME_TO_EXT = {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/webp": "webp",
+};
+async function writeRefsToTempFiles(refs) {
+    if (refs.length === 0)
+        return { paths: [], cleanup: async () => { } };
+    const dir = join(tmpdir(), `ima2-agy-refs-${randomBytes(6).toString("hex")}`);
+    await mkdir(dir, { recursive: true });
+    const paths = [];
+    for (let i = 0; i < refs.length; i++) {
+        const ref = refs[i];
+        const mime = ref.detectedMime || ref.declaredMime || detectImageMimeFromB64(ref.b64) || "image/png";
+        const ext = MIME_TO_EXT[mime] || "png";
+        const p = join(dir, `ref_${i}.${ext}`);
+        await writeFile(p, Buffer.from(ref.b64, "base64"));
+        paths.push(p);
+    }
+    return {
+        paths,
+        cleanup: async () => {
+            await rm(dir, { recursive: true, force: true }).catch(() => { });
+        },
+    };
+}
+export async function generateViaAgy(prompt, options = {}) {
+    const refDetails = (options.references || []).slice(0, 3);
+    const { paths: refPaths, cleanup } = await writeRefsToTempFiles(refDetails);
+    const agyPrompt = buildAgyPrompt(prompt, refPaths);
+    logEvent("agy", "generate:start", {
+        requestId: options.requestId,
+        promptChars: prompt.length,
+        agyPromptChars: agyPrompt.length,
+        refs: refPaths.length,
+    });
+    try {
+        const { stdout, stderr } = await spawnAgy(agyPrompt, options.signal);
+        if (stderr && stderr.trim().length > 0) {
+            logEvent("agy", "generate:stderr", {
+                requestId: options.requestId,
+                stderrChars: stderr.length,
+                stderrPreview: stderr.slice(0, 200),
+            });
+        }
+        const { artifactPath } = parseAgyOutput(stdout);
+        // Validate artifact path is within allowed directories
+        const resolvedPath = resolve(artifactPath);
+        const allowedPrefixes = [
+            join(homedir(), ".gemini"),
+            join(homedir(), ".cache"),
+            tmpdir(),
+        ];
+        const normalizedResolved = resolvedPath.replace(/\\/g, "/");
+        const isSafePath = allowedPrefixes.some((prefix) => {
+            const normalizedPrefix = prefix.replace(/\\/g, "/");
+            return normalizedResolved.startsWith(normalizedPrefix + "/") || normalizedResolved === normalizedPrefix;
+        });
+        if (!isSafePath) {
+            throw agyError(`Agy artifact path outside allowed directories: ${resolvedPath}`, 502, "AGY_PATH_REJECTED");
+        }
+        try {
+            await stat(resolvedPath);
+        }
+        catch {
+            throw agyError(`Agy artifact not found at parsed path: ${resolvedPath}`, 502, "AGY_ARTIFACT_NOT_FOUND");
+        }
+        const buffer = await readFile(resolvedPath);
+        const b64 = buffer.toString("base64");
+        const mime = detectImageMimeFromB64(b64) || "image/png";
+        logEvent("agy", "generate:done", {
+            requestId: options.requestId,
+            artifactPath,
+            b64Len: b64.length,
+            mime,
+            fileBytes: buffer.length,
+        });
+        return {
+            b64,
+            revisedPrompt: prompt,
+            usage: { agy_artifact_bytes: buffer.length },
+            webSearchCalls: 0,
+            mime,
+        };
+    }
+    finally {
+        await cleanup();
+    }
+}

package/lib/capabilities.js

@@ -3,7 +3,7 @@ import { KEY_TO_ENV, WRITABLE_CONFIG_KEYS } from "./configKeys.js";
 import { DEFAULT_IMAGE_QUALITY, VALID_IMAGE_QUALITIES } from "./oauthNormalize.js";
 const MAX_GENERATED_IMAGES = 8;
 const VALID_MODES = ["auto", "direct"];
-const VALID_PROVIDERS = ["auto", "oauth", "api", "grok"];
+const VALID_PROVIDERS = ["auto", "oauth", "api", "grok", "grok-api", "agy", "gemini-api"];
 const AGENT_COMMANDS = [
     "skill",
     "capabilities",
@@ -55,6 +55,7 @@ export function buildIma2Capabilities({ appConfig = runtimeConfigDefault, packag
                 supported: toArray(appConfig.imageModels.valid),
                 unsupported: toArray(appConfig.imageModels.unsupported),
                 grokSupported: ["grok-imagine-image", "grok-imagine-image-quality"],
+                geminiSupported: ["nano-banana-2", "nano-banana-pro"],
             },
             videoModels: {
                 supported: ["grok-imagine-video", "grok-imagine-video-1.5-preview"],

package/lib/configKeys.js

@@ -52,7 +52,7 @@ export const KEY_TO_ENV = {
     "history.defaultPageSize": "IMA2_HISTORY_PAGE_SIZE",
 };
 const REDACT_PATTERN = /token|secret|apikey|password/i;
-const ALWAYS_REDACT = new Set(["provider", "apiKey", "oauth.token", "oauth.refreshToken"]);
+const ALWAYS_REDACT = new Set(["provider", "apiKey", "oauth.token", "oauth.refreshToken", "vertexServiceAccountJson"]);
 export function isSensitiveConfigKey(key) {
     return ALWAYS_REDACT.has(key) || REDACT_PATTERN.test(key);
 }

package/lib/geminiApiImageAdapter.js

@@ -0,0 +1,183 @@
+import { logEvent } from "./logger.js";
+import { detectImageMimeFromB64 } from "./refs.js";
+import { getVertexAccessToken, getVertexProjectId, isVertexInitialized } from "./vertexAuth.js";
+const MODEL_ID_MAP = {
+    "nano-banana-2": "gemini-3.1-flash-image",
+    "nano-banana-pro": "gemini-3-pro-image",
+};
+const GEMINI_TIMEOUT_MS = 120_000;
+function parseGeminiImageParams(size) {
+    if (!size || size === "auto" || size === "1024x1024")
+        return { aspectRatio: 1, imageSize: 0 };
+    const match = size.match(/^(\d+)x(\d+)$/);
+    if (!match)
+        return { aspectRatio: 1, imageSize: 0 };
+    const w = Number(match[1]);
+    const h = Number(match[2]);
+    const ratio = w / h;
+    const ratioMap = [
+        [1, 1], [2, 2 / 3], [3, 3 / 2], [4, 3 / 4], [5, 4 / 3],
+        [6, 4 / 5], [7, 5 / 4], [8, 9 / 16], [9, 16 / 9], [10, 21 / 9],
+        [11, 1 / 8], [12, 8], [13, 1 / 4], [14, 4],
+    ];
+    let bestEnum = 1;
+    let bestDist = Infinity;
+    for (const [enumVal, val] of ratioMap) {
+        const dist = Math.abs(ratio - val);
+        if (dist < bestDist) {
+            bestDist = dist;
+            bestEnum = enumVal;
+        }
+    }
+    const maxDim = Math.max(w, h);
+    const imageSize = maxDim <= 512 ? 1 : maxDim <= 1024 ? 2 : maxDim <= 2048 ? 3 : 4;
+    return { aspectRatio: bestEnum, imageSize };
+}
+function geminiApiError(message, status, code) {
+    const err = new Error(message);
+    err.status = status;
+    err.code = code;
+    return err;
+}
+function resolveGeminiModelId(model) {
+    return MODEL_ID_MAP[model] || model;
+}
+function buildContents(prompt, references) {
+    const parts = [];
+    // Add reference images first (if any)
+    for (const ref of references.slice(0, 3)) {
+        const mime = ref.declaredMime || ref.detectedMime || detectImageMimeFromB64(ref.b64) || "image/png";
+        parts.push({
+            inlineData: {
+                mimeType: mime,
+                data: ref.b64,
+            },
+        });
+    }
+    // Add text prompt
+    parts.push({ text: prompt });
+    return [{ role: "user", parts }];
+}
+export async function generateViaGeminiApi(prompt, ctx, options = {}) {
+    const apiKey = ctx.geminiApiKey;
+    const vertexReady = ctx.hasVertexKey && isVertexInitialized();
+    const authMode = ctx.geminiAuthMode;
+    const useVertex = authMode === "vertex" ? vertexReady : (!apiKey && vertexReady);
+    if (!apiKey && !useVertex) {
+        throw geminiApiError("Gemini API key or Vertex AI credentials not configured", 401, "GEMINI_API_KEY_MISSING");
+    }
+    const model = options.model || "nano-banana-2";
+    const apiModelId = resolveGeminiModelId(model);
+    const references = (options.references || []).slice(0, 3);
+    let url;
+    let authHeaders;
+    if (useVertex) {
+        const token = await getVertexAccessToken();
+        const projectId = getVertexProjectId();
+        url = `https://aiplatform.googleapis.com/v1/projects/${projectId}/locations/global/publishers/google/models/${apiModelId}:generateContent`;
+        authHeaders = { "Content-Type": "application/json", "Authorization": `Bearer ${token}` };
+    }
+    else {
+        url = `https://generativelanguage.googleapis.com/v1beta/models/${apiModelId}:generateContent`;
+        authHeaders = { "Content-Type": "application/json", "x-goog-api-key": apiKey };
+    }
+    const imageParams = parseGeminiImageParams(options.size);
+    // NOTE: Vertex (aiplatform.googleapis.com) rejects the response_format field that the
+    // direct Gemini API accepts, so the Vertex path can only request modalities — output
+    // defaults to 1K/1:1 regardless of requested size. Direct API path honors aspect/size.
+    const generationConfig = useVertex
+        ? { responseModalities: ["TEXT", "IMAGE"] }
+        : {
+            response_modalities: ["TEXT", "IMAGE"],
+            response_format: {
+                image: {
+                    aspect_ratio: imageParams.aspectRatio,
+                    image_size: imageParams.imageSize,
+                },
+            },
+        };
+    const configKey = useVertex ? "generationConfig" : "generation_config";
+    const body = { contents: buildContents(prompt, references), [configKey]: generationConfig };
+    logEvent("gemini-api", "generate:start", {
+        requestId: options.requestId,
+        model,
+        apiModelId,
+        promptChars: prompt.length,
+        refs: references.length,
+    });
+    const timeoutSignal = AbortSignal.timeout(GEMINI_TIMEOUT_MS);
+    const combinedSignal = options.signal
+        ? AbortSignal.any([options.signal, timeoutSignal])
+        : timeoutSignal;
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: authHeaders,
+            body: JSON.stringify(body),
+            signal: combinedSignal,
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            if (res.status === 429) {
+                throw geminiApiError(`Gemini API rate limited: ${text.slice(0, 200)}`, 429, "GEMINI_API_RATE_LIMITED");
+            }
+            if (res.status === 400 || res.status === 403) {
+                throw geminiApiError(`Gemini API error: ${text.slice(0, 200)}`, res.status, "GEMINI_API_BAD_REQUEST");
+            }
+            throw geminiApiError(`Gemini API error (${res.status}): ${text.slice(0, 200)}`, 502, "GEMINI_API_UPSTREAM_ERROR");
+        }
+        const json = await res.json();
+        // Extract image from candidates[0].content.parts[]
+        const parts = json?.candidates?.[0]?.content?.parts || [];
+        let b64 = null;
+        let textResponse = "";
+        let mime = "image/png";
+        for (const part of parts) {
+            if (part.inlineData?.data) {
+                b64 = part.inlineData.data;
+                mime = part.inlineData.mimeType || "image/png";
+            }
+            if (part.text) {
+                textResponse += part.text;
+            }
+        }
+        if (!b64) {
+            // Check for safety block
+            const finishReason = json?.candidates?.[0]?.finishReason;
+            if (finishReason === "SAFETY") {
+                throw geminiApiError("Gemini API: generation blocked by safety filter", 400, "GEMINI_API_SAFETY_BLOCKED");
+            }
+            throw geminiApiError(`Gemini API: no image in response (finishReason: ${finishReason || "unknown"})`, 502, "GEMINI_API_NO_IMAGE");
+        }
+        const usageMetadata = json?.usageMetadata || {};
+        logEvent("gemini-api", "generate:done", {
+            requestId: options.requestId,
+            model,
+            b64Len: b64.length,
+            mime,
+            textResponseLen: textResponse.length,
+        });
+        return {
+            b64,
+            revisedPrompt: textResponse || prompt,
+            usage: {
+                promptTokens: usageMetadata.promptTokenCount || 0,
+                candidatesTokens: usageMetadata.candidatesTokenCount || 0,
+                totalTokens: usageMetadata.totalTokenCount || 0,
+            },
+            webSearchCalls: 0,
+            mime,
+        };
+    }
+    catch (e) {
+        if (e.name === "AbortError") {
+            if (options.signal?.aborted) {
+                throw geminiApiError("Generation canceled", 499, "GENERATION_CANCELED");
+            }
+            throw geminiApiError("Gemini API generation timed out", 504, "GENERATION_TIMEOUT");
+        }
+        if (e.code && e.status)
+            throw e;
+        throw geminiApiError(`Gemini API request failed: ${e.message}`, 502, "GEMINI_API_NETWORK_FAILED");
+    }
+}

package/lib/grokImageAdapter.js

@@ -2,7 +2,14 @@ import { logEvent } from "./logger.js";
 import { mapSizeToGrokImageParams } from "./grokSizeMapper.js";
 import { detectImageMimeFromB64 } from "./refs.js";
 import { getGrokProxyUrl } from "./grokRuntime.js";
-function getGrokEndpoint(ctx, path = "/v1/images/generations") {
+function getGrokEndpoint(ctx, path = "/v1/images/generations", directApiKey) {
+    if (directApiKey) {
+        const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+        return {
+            url: `https://api.x.ai${normalizedPath}`,
+            headers: { "Content-Type": "application/json", Authorization: `Bearer ${directApiKey}` },
+        };
+    }
     return {
         url: getGrokProxyUrl(ctx, path),
         headers: { "Content-Type": "application/json", Authorization: "Bearer dummy" },
@@ -63,8 +70,8 @@ function extractResponsesText(response) {
     }
     return chunks.join("\n\n").trim();
 }
-export async function postGrokImages(ctx, payload, signal, path = "/v1/images/generations") {
-    const { url, headers } = getGrokEndpoint(ctx, path);
+export async function postGrokImages(ctx, payload, signal, path = "/v1/images/generations", directApiKey) {
+    const { url, headers } = getGrokEndpoint(ctx, path, directApiKey);
     const timeoutMs = getGrokTimeout(ctx);
     const { combinedSignal, timer } = withTimeoutSignal(signal, timeoutMs);
     try {
@@ -244,7 +251,7 @@ export function buildGrokSearchPayload(prompt, plannerModel = "grok-4.3") {
 export async function searchGrokVisualContext(prompt, ctx, options = {}) {
     const planner = getPlannerConfig(ctx);
     const payload = buildGrokSearchPayload(prompt, planner.model);
-    const { url, headers } = getGrokEndpoint(ctx, "/v1/responses");
+    const { url, headers } = getGrokEndpoint(ctx, "/v1/responses", options.directApiKey);
     const { combinedSignal, timer } = withTimeoutSignal(options.signal, planner.timeoutMs);
     logEvent("grok", "search:start", { requestId: options.requestId, plannerModel: planner.model, promptChars: prompt.length });
     try {
@@ -305,9 +312,9 @@ export async function planGrokImage(prompt, ctx, options = {}) {
     const imageModel = options.model || ctx.config.grokProvider?.defaultImageModel || "grok-imagine-image";
     const planner = getPlannerConfig(ctx);
     const sizeParams = mapSizeToGrokImageParams(options.size);
-    const search = await searchGrokVisualContext(prompt, ctx, { signal: options.signal, requestId: options.requestId });
+    const search = await searchGrokVisualContext(prompt, ctx, { signal: options.signal, requestId: options.requestId, directApiKey: options.directApiKey });
     const payload = buildGrokPlannerPayload(prompt, imageModel, options.size, sizeParams, planner.model, search.summary, options.references || options.referenceCount || 0);
-    const { url, headers } = getGrokEndpoint(ctx, "/v1/chat/completions");
+    const { url, headers } = getGrokEndpoint(ctx, "/v1/chat/completions", options.directApiKey);
     const { combinedSignal, timer } = withTimeoutSignal(options.signal, planner.timeoutMs);
     logEvent("grok", "planner:start", { requestId: options.requestId, plannerModel: planner.model, imageModel, size: options.size });
     try {
@@ -356,7 +363,7 @@ export async function generateViaGrok(prompt, ctx, options = {}) {
     const references = options.references || [];
     const plan = options.plannedPrompt
         ? { prompt: options.plannedPrompt, model, webSearchCalls: options.webSearchCalls ?? 1 }
-        : await planGrokImage(prompt, ctx, { ...options, referenceCount: references.length });
+        : await planGrokImage(prompt, ctx, { ...options, referenceCount: references.length, directApiKey: options.directApiKey });
     const hasReferences = references.length > 0;
     const payload = hasReferences
         ? imageEditPayload(model, plan.prompt, references, options.size)
@@ -370,7 +377,7 @@ export async function generateViaGrok(prompt, ctx, options = {}) {
         size: options.size,
         refs: references.length,
     });
-    const result = await postGrokImages(ctx, payload, options.signal, endpoint);
+    const result = await postGrokImages(ctx, payload, options.signal, endpoint, options.directApiKey);
     if (!result.data?.[0]?.b64_json) {
         throw grokError("Grok returned empty image data", 502, "GROK_EMPTY_RESPONSE");
     }
@@ -390,7 +397,7 @@ export async function editViaGrok(prompt, imageB64, ctx, options = {}) {
     const imageUrl = imageB64.startsWith("data:") ? imageB64 : `data:${detectedInputMime};base64,${imageB64}`;
     const payload = { model, prompt, n: 1, response_format: "b64_json", image: { type: "image_url", url: imageUrl }, ...mapSizeToGrokImageParams(options.size) };
     logEvent("grok", "edit:start", { requestId: options.requestId, model, promptChars: prompt.length });
-    const result = await postGrokImages(ctx, payload, options.signal, "/v1/images/edits");
+    const result = await postGrokImages(ctx, payload, options.signal, "/v1/images/edits", options.directApiKey);
     if (!result.data?.[0]?.b64_json) {
         throw grokError("Grok edit returned empty image data", 502, "GROK_EMPTY_RESPONSE");
     }

package/lib/grokMultimodeAdapter.js

@@ -19,6 +19,7 @@ export async function generateMultimodeViaGrok(prompt, ctx, options = {}) {
             signal: options.signal,
             requestId: options.requestId,
             references,
+            directApiKey: options.directApiKey,
         });
         totalWebSearchCalls += plan.webSearchCalls;
         const endpoint = references.length > 0 ? "/v1/images/edits" : "/v1/images/generations";
@@ -33,7 +34,7 @@ export async function generateMultimodeViaGrok(prompt, ctx, options = {}) {
                 refs: references.length,
                 promptChars: plan.prompt.length,
             });
-            const result = await postGrokImages(ctx, payload, options.signal, endpoint);
+            const result = await postGrokImages(ctx, payload, options.signal, endpoint, options.directApiKey);
             if (result.data?.[0]?.b64_json) {
                 const img = { b64: result.data[0].b64_json, mime: result.data[0].mime_type, revisedPrompt: plan.prompt };
                 images.push(img);

package/lib/grokRuntime.js

@@ -16,3 +16,6 @@ export function getGrokProxyUrl(ctx = {}, path = "/v1") {
     const normalizedPath = path.startsWith("/") ? path : `/${path}`;
     return `${getGrokProxyBaseUrl(ctx)}${normalizedPath}`;
 }
+export function getGrokDirectBaseUrl() {
+    return "https://api.x.ai";
+}

package/lib/grokSizeMapper.js

@@ -37,7 +37,7 @@ function parseSize(size) {
 }
 function aspectValue(aspect) {
     const [w, h] = aspect.split(":").map(Number);
-    return w / h;
+    return Number.isFinite(h) && h !== 0 ? w / h : 1;
 }
 function closestAspect(w, h) {
     const target = w / h;
@@ -50,6 +50,18 @@ function closestAspect(w, h) {
 export function mapSizeToGrokImageParams(size) {
     if (!size || size === "auto")
         return { aspect_ratio: "auto" };
+    // Native format from GrokSizePicker: "grok:<aspect_ratio>:<resolution>"
+    if (size.startsWith("grok:")) {
+        const parts = size.split(":");
+        if (parts.length < 3)
+            return { aspect_ratio: "auto" };
+        const res = parts[parts.length - 1];
+        const aspect = parts.slice(1, -1).join(":");
+        return {
+            aspect_ratio: SUPPORTED_ASPECTS.includes(aspect) ? aspect : "auto",
+            resolution: res === "2k" ? "2k" : "1k",
+        };
+    }
     const preset = PRESET_MAP[size];
     if (preset)
         return preset;

package/lib/grokVideoAdapter.js

@@ -20,7 +20,14 @@ function videoConfig(ctx) {
         plannerTimeoutMs: g.plannerTimeoutMs || 60_000,
     };
 }
-function videoEndpoint(ctx, path) {
+function videoEndpoint(ctx, path, directApiKey) {
+    if (directApiKey) {
+        const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+        return {
+            url: `https://api.x.ai${normalizedPath}`,
+            headers: { "Content-Type": "application/json", Authorization: `Bearer ${directApiKey}` },
+        };
+    }
     return {
         url: getGrokProxyUrl(ctx, path),
         headers: { "Content-Type": "application/json", Authorization: "Bearer dummy" },
@@ -148,7 +155,7 @@ export async function planGrokVideo(prompt, ctx, options = {}) {
     const duration = options.duration ?? 5;
     const resolution = options.resolution || "480p";
     const aspectRatio = options.aspectRatio || "auto";
-    const search = await searchGrokVisualContext(prompt, ctx, { signal: options.signal, requestId: options.requestId });
+    const search = await searchGrokVisualContext(prompt, ctx, { signal: options.signal, requestId: options.requestId, directApiKey: options.directApiKey });
     const referenceImageUrls = (options.referenceImages ?? []).map((img) => sourceImageUrl(img, undefined));
     const payload = buildGrokVideoPlannerPayload(prompt, {
         model: cfg.model,
@@ -162,7 +169,7 @@ export async function planGrokVideo(prompt, ctx, options = {}) {
         referenceImageUrls,
         continuityLineage: options.continuityLineage,
     });
-    const { url, headers } = videoEndpoint(ctx, "/v1/chat/completions");
+    const { url, headers } = videoEndpoint(ctx, "/v1/chat/completions", options.directApiKey);
     const { combinedSignal, timer } = withTimeoutSignal(options.signal, cfg.plannerTimeoutMs);
     logEvent("grok", "video:planner:start", { requestId: options.requestId, mode, duration, resolution });
     try {
@@ -212,7 +219,7 @@ export function buildVideoGenerationPayload(plan, opts) {
 }
 export async function startVideoRequest(ctx, payload, options) {
     const cfg = videoConfig(ctx);
-    const { url, headers } = videoEndpoint(ctx, "/v1/videos/generations");
+    const { url, headers } = videoEndpoint(ctx, "/v1/videos/generations", options.directApiKey);
     const { combinedSignal, timer } = withTimeoutSignal(options.signal, cfg.startTimeoutMs);
     try {
         const res = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload), signal: combinedSignal });
@@ -251,9 +258,9 @@ export function normalizeVideoPoll(data) {
         failedCode: data?.error?.code,
     };
 }
-export async function pollVideoOnce(ctx, requestId, signal) {
+export async function pollVideoOnce(ctx, requestId, signal, directApiKey) {
     const cfg = videoConfig(ctx);
-    const { url, headers } = videoEndpoint(ctx, `/v1/videos/${requestId}`);
+    const { url, headers } = videoEndpoint(ctx, `/v1/videos/${requestId}`, directApiKey);
     const { combinedSignal, timer } = withTimeoutSignal(signal, cfg.startTimeoutMs);
     try {
         const res = await fetch(url, { method: "GET", headers, signal: combinedSignal });
@@ -293,7 +300,7 @@ export async function pollVideoUntilDone(ctx, requestId, options) {
     for (;;) {
         if (Date.now() > deadline)
             throw grokError("Grok video poll budget exceeded", 504, "GROK_VIDEO_TIMEOUT");
-        const poll = await pollVideoOnce(ctx, requestId, options.signal);
+        const poll = await pollVideoOnce(ctx, requestId, options.signal, options.directApiKey);
         if (poll.status === "done")
             return poll;
         if (poll.status === "failed" || poll.status === "expired")