ima2-gen 2.0.15 → 2.0.16

package/lib/nodeGeneration.js

@@ -0,0 +1,440 @@
+import { mkdir } from "fs/promises";
+import { newNodeId, saveNode, loadAssetB64, } from "./nodeStore.js";
+import { startJob, finishJob, registerJobAbortController, isJobCanceled, isStartJobFailure, INFLIGHT_RETRY_AFTER_SECONDS } from "./inflight.js";
+import { isGenerationCanceledError, makeGenerationCanceledError, throwIfJobCanceled, } from "./generationCancel.js";
+import { detectImageMimeFromB64, summarizeReferencePayload } from "./refs.js";
+import { classifyUpstreamError } from "./errorClassify.js";
+import { normalizeOAuthParams } from "./oauthNormalize.js";
+import { resolveProviderOptions } from "./providerOptions.js";
+import { generateViaResponses, editViaResponses } from "./responsesImageAdapter.js";
+import { generateViaGrok } from "./grokImageAdapter.js";
+import { generateViaAgy } from "./agyImageAdapter.js";
+import { generateViaGeminiApi } from "./geminiApiImageAdapter.js";
+import { isNonRetryableGenerationError, normalizeGenerationFailure } from "./generationErrors.js";
+import { logEvent, logError } from "./logger.js";
+import { errInfo } from "./errInfo.js";
+import { requireRuntimeContext } from "./runtimeContext.js";
+import { imageFormatFromMime, writeSse, dataUrlFromB64 } from "./routeHelpers.js";
+import { validateNodeInputs } from "./nodeValidation.js";
+import { publish } from "./eventBus.js";
+import { publishJobEvent } from "./ssePublish.js";
+import { asUpstream, wantsSse, writeNodeError, loadParentNodeB64, toGrokReferences, nodeErrorDetails, } from "./nodeHelpers.js";
+import { normalizeBodyRequestId, validateGenerationPrompt } from "./generationInputValidation.js";
+export async function runNodeGeneration(req, res, ctx) {
+    const body = (req.body ?? {});
+    const promptError = validateGenerationPrompt(body.prompt);
+    if (promptError)
+        return res.status(400).json(promptError);
+    const asyncMode = body.async === true;
+    const streamResponse = !asyncMode && wantsSse(req);
+    const parentNodeId = (typeof body.parentNodeId === "string" ? body.parentNodeId : null);
+    const requestId = normalizeBodyRequestId(body.requestId, req.id);
+    const sessionId = typeof body.sessionId === "string" ? body.sessionId : null;
+    const clientNodeId = typeof body.clientNodeId === "string" ? body.clientNodeId : null;
+    let finishMeta = {};
+    let finishStatus = "completed";
+    let finishHttpStatus;
+    let finishErrorCode;
+    let finishCanceled = false;
+    let jobOwned = false;
+    const cancelController = new AbortController();
+    const referencePayload = summarizeReferencePayload(body.references);
+    try {
+        const { prompt: rawPrompt, quality: rawQuality = "medium", size = "1024x1024", format = "png", moderation = "low", references = [], externalSrc = null, mode: promptMode = "auto", contextMode: rawContextMode = "parent-plus-refs", searchMode: rawSearchMode = "on", model: rawModel, reasoningEffort: rawReasoningEffort, } = body;
+        const { provider = "oauth" } = body;
+        const { quality, warnings: qualityWarnings } = normalizeOAuthParams({ provider, quality: rawQuality });
+        const normalizedPromptMode = promptMode === "direct" ? "direct" : "auto";
+        const contextMode = ["parent-plus-refs", "parent-only", "ancestry"].includes(rawContextMode)
+            ? rawContextMode
+            : "parent-plus-refs";
+        const searchMode = ["off", "auto", "on"].includes(rawSearchMode) ? rawSearchMode : "on";
+        const providerOptions = resolveProviderOptions(ctx, {
+            provider,
+            rawModel,
+            rawReasoningEffort,
+            rawSize: size,
+            rawWebSearchEnabled: body.webSearchEnabled,
+            searchMode,
+        });
+        if (providerOptions.error) {
+            finishStatus = "error";
+            finishHttpStatus = providerOptions.status;
+            finishErrorCode = providerOptions.code;
+            return res.status(providerOptions.status).json({
+                error: { code: providerOptions.code, message: providerOptions.error },
+                parentNodeId,
+            });
+        }
+        const imageModel = providerOptions.model;
+        const reasoningEffort = providerOptions.reasoningEffort;
+        const effectiveSize = providerOptions.size;
+        const webSearchEnabled = providerOptions.webSearchEnabled;
+        const activeProvider = providerOptions.provider;
+        const effectiveImageModel = (activeProvider === "grok" || activeProvider === "grok-api") && quality === "high"
+            ? "grok-imagine-image-quality"
+            : imageModel;
+        if (contextMode === "ancestry") {
+            finishStatus = "error";
+            finishHttpStatus = 400;
+            finishErrorCode = "CONTEXT_MODE_UNSUPPORTED";
+            return res.status(400).json({
+                error: { code: "CONTEXT_MODE_UNSUPPORTED", message: "Ancestry context is not supported yet." },
+                parentNodeId,
+            });
+        }
+        const validation = validateNodeInputs(ctx, rawPrompt, references, moderation);
+        if (validation.error) {
+            finishStatus = "error";
+            finishHttpStatus = 400;
+            finishErrorCode = validation.error.code;
+            return res.status(400).json({
+                error: validation.error,
+                ...(validation.code ? { code: validation.code } : {}),
+                parentNodeId,
+            });
+        }
+        const prompt = validation.prompt;
+        const refCheck = validation.refCheck;
+        const startTime = Date.now();
+        let parentB64 = null;
+        if (parentNodeId) {
+            parentB64 = await loadParentNodeB64(ctx, parentNodeId);
+        }
+        else if (typeof externalSrc === "string" && externalSrc.length > 0) {
+            parentB64 = await loadAssetB64(ctx.rootDir, externalSrc, ctx.config.storage.generatedDir);
+        }
+        const operation = parentB64 ? "edit" : "generate";
+        const referenceDiagnostics = refCheck.referenceDiagnostics || [];
+        const generateReferenceDiagnostics = operation === "generate" ? referenceDiagnostics : [];
+        const referenceMismatchCount = generateReferenceDiagnostics.filter((ref) => ref.warnings?.includes("mime_mismatch")).length;
+        const refsForRequest = contextMode === "parent-only" ? [] : (refCheck.refDetails || refCheck.refs);
+        const parentImagePresent = !!parentB64;
+        const inputImageCount = (parentImagePresent ? 1 : 0) + refsForRequest.length;
+        if ((activeProvider === "grok" || activeProvider === "agy" || activeProvider === "grok-api" || activeProvider === "gemini-api") && inputImageCount > 3) {
+            finishStatus = "error";
+            finishHttpStatus = 400;
+            const code = activeProvider === "agy" ? "AGY_REF_TOO_MANY" : "GROK_REF_TOO_MANY";
+            return res.status(400).json({
+                error: {
+                    code,
+                    message: `${activeProvider === "agy" ? "Agy" : "Grok"} image editing supports up to 3 reference images.`,
+                },
+                code,
+                parentNodeId,
+            });
+        }
+        const started = startJob({
+            requestId,
+            kind: "node",
+            prompt: body.prompt,
+            meta: {
+                kind: "node",
+                sessionId,
+                parentNodeId,
+                clientNodeId,
+                refsCount: referencePayload.refsCount,
+                referenceBytes: referencePayload.referenceBytes,
+                referenceB64Chars: referencePayload.referenceB64Chars,
+            },
+        });
+        if (started && isStartJobFailure(started)) {
+            finishStatus = "error";
+            finishHttpStatus = started.code === "TOO_MANY_JOBS" ? 429 : 409;
+            finishErrorCode = started.code;
+            if (started.code === "TOO_MANY_JOBS") {
+                res.setHeader("Retry-After", String(INFLIGHT_RETRY_AFTER_SECONDS));
+            }
+            return writeNodeError(res, finishHttpStatus, started.code, started.code === "TOO_MANY_JOBS"
+                ? "Too many concurrent generation jobs"
+                : "Request ID already in use", parentNodeId, {}, requestId);
+        }
+        jobOwned = true;
+        registerJobAbortController(requestId, cancelController);
+        if (asyncMode)
+            res.status(202).json({ requestId });
+        logEvent("node", "request", {
+            requestId,
+            operation,
+            sessionId,
+            parentNodeId,
+            clientNodeId,
+            quality,
+            model: effectiveImageModel,
+            size: effectiveSize,
+            moderation,
+            refs: refsForRequest.length,
+            referenceBytes: referencePayload.referenceBytes,
+            referenceMismatchCount,
+            refDetectedMimes: [...new Set(generateReferenceDiagnostics.map((ref) => ref.detectedMime).filter(Boolean))].join(","),
+            refDeclaredMimes: [...new Set(generateReferenceDiagnostics.map((ref) => ref.declaredMime).filter(Boolean))].join(","),
+            inputImageCount,
+            parentImagePresent,
+            contextMode,
+            searchMode,
+            webSearchEnabled,
+            promptChars: prompt.length,
+            promptMode: normalizedPromptMode,
+        });
+        const emitProgress = streamResponse || asyncMode;
+        if (streamResponse) {
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream; charset=utf-8",
+                "Cache-Control": "no-cache, no-transform",
+                Connection: "keep-alive",
+            });
+            writeSse(res, "phase", { requestId, phase: "streaming" });
+            publish(requestId, "phase", { requestId, phase: "streaming" });
+        }
+        else if (asyncMode) {
+            publish(requestId, "phase", { requestId, phase: "streaming" });
+        }
+        let b64, usage, webSearchCalls = 0, revisedPrompt = null;
+        const grokDirectApiKey = activeProvider === "grok-api" ? ctx.xaiApiKey : undefined;
+        let resultFormat = activeProvider === "grok" || activeProvider === "agy" || activeProvider === "grok-api" || activeProvider === "gemini-api" ? "jpeg" : format;
+        const maxAttempts = inputImageCount > 0 ? 1 : 2;
+        let lastErr = null;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            try {
+                logEvent("node", "attempt", {
+                    requestId,
+                    attempt,
+                    operation,
+                    sessionId,
+                    parentNodeId,
+                    clientNodeId,
+                    model: effectiveImageModel,
+                    moderation,
+                    quality,
+                    size: effectiveSize,
+                    refs: refsForRequest.length,
+                    inputImageCount,
+                    parentImagePresent,
+                    contextMode,
+                    searchMode,
+                    webSearchEnabled,
+                });
+                const r = activeProvider === "gemini-api"
+                    ? await generateViaGeminiApi(parentB64 ? `Edit this image: ${prompt}` : prompt, requireRuntimeContext(ctx), {
+                        model: effectiveImageModel,
+                        size: effectiveSize,
+                        signal: cancelController.signal,
+                        requestId,
+                        references: parentB64
+                            ? [{ b64: parentB64, declaredMime: null, detectedMime: null }, ...(refCheck.refDetails || [])]
+                            : refCheck.refDetails,
+                    })
+                    : activeProvider === "agy"
+                        ? await generateViaAgy(parentB64 ? `Edit this image: ${prompt}` : prompt, {
+                            references: parentB64
+                                ? [{ b64: parentB64, declaredMime: null, detectedMime: null }]
+                                : undefined,
+                            signal: cancelController.signal,
+                            requestId,
+                        })
+                        : activeProvider === "grok" || activeProvider === "grok-api"
+                            ? await generateViaGrok(prompt, ctx, {
+                                model: effectiveImageModel,
+                                size: effectiveSize,
+                                requestId,
+                                signal: cancelController.signal,
+                                references: toGrokReferences(parentB64, refsForRequest),
+                                directApiKey: grokDirectApiKey,
+                            })
+                            : parentB64
+                                ? await editViaResponses(activeProvider, prompt, parentB64, quality, effectiveSize, moderation, normalizedPromptMode, ctx, requestId, {
+                                    model: effectiveImageModel,
+                                    references: refsForRequest,
+                                    searchMode,
+                                    reasoningEffort,
+                                    webSearchEnabled,
+                                    signal: cancelController.signal,
+                                })
+                                : await generateViaResponses(activeProvider, prompt, quality, effectiveSize, moderation, refsForRequest, requestId, normalizedPromptMode, ctx, {
+                                    model: effectiveImageModel,
+                                    reasoningEffort,
+                                    webSearchEnabled,
+                                    signal: cancelController.signal,
+                                    partialImages: emitProgress ? 2 : 0,
+                                    onPartialImage: emitProgress
+                                        ? (partial) => {
+                                            if (isJobCanceled(requestId))
+                                                return;
+                                            const pd = { requestId, image: dataUrlFromB64(format, partial.b64), index: partial.index };
+                                            if (streamResponse)
+                                                writeSse(res, "partial", pd);
+                                            publish(requestId, "partial", pd);
+                                        }
+                                        : null,
+                                });
+                throwIfJobCanceled(requestId);
+                if (r.b64) {
+                    b64 = r.b64;
+                    usage = r.usage;
+                    webSearchCalls = r.webSearchCalls || 0;
+                    revisedPrompt = r.revisedPrompt || null;
+                    if (activeProvider === "grok" || activeProvider === "grok-api" || activeProvider === "gemini-api") {
+                        resultFormat = imageFormatFromMime(("mime" in r ? r.mime : undefined) || detectImageMimeFromB64(r.b64) || "image/jpeg");
+                    }
+                    break;
+                }
+                lastErr = { message: "Empty response (safety refusal)" };
+            }
+            catch (e) {
+                lastErr = asUpstream(e);
+                if (isNonRetryableGenerationError(lastErr))
+                    break;
+            }
+            if (attempt + 1 < maxAttempts) {
+                logEvent("node", "retry", {
+                    requestId,
+                    attempt: attempt + 1,
+                    operation,
+                    parentNodeId,
+                    clientNodeId,
+                    errorCode: lastErr?.code,
+                    errorEventType: lastErr?.eventType,
+                    errorEventCount: lastErr?.eventCount,
+                });
+            }
+        }
+        if (!b64) {
+            const finalErr = normalizeGenerationFailure(lastErr, {
+                safetyMessage: lastErr?.message || "Empty response after generation attempt",
+            });
+            finishStatus = "error";
+            finishHttpStatus = finalErr.status || 500;
+            finishErrorCode = finalErr.code || "NODE_GEN_FAILED";
+            logEvent("node", "final_error", {
+                requestId,
+                operation,
+                finalCode: finishErrorCode,
+                upstreamCode: lastErr?.upstreamCode || lastErr?.code,
+                errorEventType: lastErr?.eventType,
+                errorEventCount: lastErr?.eventCount,
+                diagnosticReason: lastErr?.diagnosticReason,
+                retryKind: lastErr?.retryKind,
+                referencesDroppedOnRetry: lastErr?.referencesDroppedOnRetry,
+                attempts: maxAttempts,
+                outerHttpAlreadyCommitted: res.headersSent,
+                sseErrorSent: streamResponse,
+            });
+            return writeNodeError(res, finishHttpStatus ?? 500, finishErrorCode ?? "NODE_GEN_FAILED", finalErr.message, parentNodeId, nodeErrorDetails(finalErr, lastErr), requestId);
+        }
+        const nodeId = newNodeId();
+        throwIfJobCanceled(requestId);
+        const elapsed = +((Date.now() - startTime) / 1000).toFixed(1);
+        const meta = {
+            nodeId,
+            parentNodeId,
+            sessionId,
+            clientNodeId,
+            prompt,
+            userPrompt: prompt,
+            revisedPrompt,
+            promptMode: normalizedPromptMode,
+            options: { quality, size: effectiveSize, format: resultFormat, moderation },
+            model: effectiveImageModel,
+            reasoningEffort,
+            createdAt: Date.now(),
+            createdAtIso: new Date().toISOString(),
+            elapsed,
+            usage: usage || null,
+            webSearchCalls,
+            webSearchEnabled,
+            contextMode,
+            searchMode,
+            provider: activeProvider,
+            kind: parentB64 ? "edit" : "generate",
+            requestId,
+            refsCount: refsForRequest.length,
+            quality,
+            size: effectiveSize,
+            format: resultFormat,
+            moderation,
+        };
+        await mkdir(ctx.config.storage.generatedDir, { recursive: true });
+        throwIfJobCanceled(requestId);
+        const { filename } = await saveNode(ctx.rootDir, {
+            nodeId,
+            b64,
+            meta,
+            ext: resultFormat,
+            generatedDir: ctx.config.storage.generatedDir,
+        });
+        finishMeta = { nodeId, filename, imageChars: b64.length };
+        finishHttpStatus = 200;
+        logEvent("node", "saved", {
+            requestId,
+            nodeId,
+            filename,
+            imageChars: b64.length,
+            elapsedMs: Date.now() - startTime,
+        });
+        const payload = {
+            nodeId,
+            parentNodeId,
+            requestId,
+            image: dataUrlFromB64(resultFormat, b64),
+            filename,
+            url: `/generated/${filename}`,
+            elapsed,
+            usage,
+            webSearchCalls,
+            webSearchEnabled,
+            provider: activeProvider,
+            model: effectiveImageModel,
+            reasoningEffort,
+            size: effectiveSize,
+            format: resultFormat,
+            moderation,
+            refsCount: refsForRequest.length,
+            contextMode,
+            searchMode,
+            warnings: qualityWarnings,
+            revisedPrompt,
+            promptMode: normalizedPromptMode,
+        };
+        publishJobEvent(requestId, "done", payload);
+        if (res.writableEnded) {
+            // async mode — response already sent
+        }
+        else if (streamResponse) {
+            writeSse(res, "done", payload);
+            res.end();
+        }
+        else {
+            res.json(payload);
+        }
+    }
+    catch (e) {
+        const err = errInfo(e);
+        const ext = (err.raw && typeof err.raw === "object" ? err.raw : {});
+        const code = err.code || classifyUpstreamError(err.message) || "NODE_GEN_FAILED";
+        if (isGenerationCanceledError(err.raw) || isJobCanceled(requestId)) {
+            const canceled = makeGenerationCanceledError();
+            finishCanceled = true;
+            finishHttpStatus = canceled.status;
+            finishErrorCode = canceled.code;
+            return writeNodeError(res, canceled.status, canceled.code, canceled.message, parentNodeId, {}, requestId);
+        }
+        finishStatus = "error";
+        finishHttpStatus = err.status || 500;
+        finishErrorCode = code;
+        logError("node", "error", err.raw, { requestId, code, parentNodeId, sessionId, clientNodeId });
+        writeNodeError(res, err.status || 500, code, err.message, parentNodeId, {
+            upstreamCode: ext.upstreamCode || null,
+            upstreamType: ext.upstreamType || null,
+            upstreamParam: ext.upstreamParam || null,
+        }, requestId);
+    }
+    finally {
+        if (jobOwned)
+            finishJob(requestId, {
+                canceled: finishCanceled,
+                status: finishStatus,
+                httpStatus: finishHttpStatus,
+                errorCode: finishErrorCode,
+                meta: finishMeta,
+            });
+    }
+}

package/lib/nodeValidation.js

@@ -0,0 +1,23 @@
+import { validateAndNormalizeRefs } from "./refs.js";
+import { validateModeration } from "./routeHelpers.js";
+import { validateGenerationPrompt } from "./generationInputValidation.js";
+export function validateNodeInputs(ctx, prompt, references, moderation) {
+    const promptError = validateGenerationPrompt(prompt);
+    if (promptError)
+        return promptError;
+    const refCheckResult = validateAndNormalizeRefs(references);
+    if (refCheckResult.error) {
+        return {
+            error: { code: refCheckResult.code, message: refCheckResult.error },
+            code: refCheckResult.code,
+        };
+    }
+    const moderationCheck = validateModeration(ctx, moderation);
+    if (moderationCheck.error) {
+        return { error: { code: "INVALID_MODERATION", message: moderationCheck.error } };
+    }
+    return {
+        prompt: prompt,
+        refCheck: refCheckResult,
+    };
+}