ima2-gen 2.0.15 → 2.0.16

package/lib/oauthProxy/generators.js

@@ -1,14 +1,11 @@
 import { setJobPhase } from "../inflight.js";
 import { logEvent } from "../logger.js";
-import { compressReferenceB64ForOAuth } from "../referenceImageCompress.js";
 import { safeReferenceDiagnostics } from "../refs.js";
 import { throwOAuthHttpError, throwOAuthTimeoutError } from "./errors.js";
-import { AUTO_PROMPT_FIDELITY_SUFFIX, DIRECT_PROMPT_FIDELITY_SUFFIX, EDIT_DEVELOPER_PROMPT, EDIT_NO_SEARCH_DEVELOPER_PROMPT, GENERATE_DEVELOPER_PROMPT, GENERATE_NO_SEARCH_DEVELOPER_PROMPT, MULTIMODE_DEVELOPER_PROMPT, MULTIMODE_NO_SEARCH_DEVELOPER_PROMPT, buildEditTextPrompt, buildMultimodeSequencePrompt, buildUserTextPrompt, } from "./prompts.js";
+import { GENERATE_DEVELOPER_PROMPT, GENERATE_NO_SEARCH_DEVELOPER_PROMPT, buildUserTextPrompt, } from "./prompts.js";
 import { normalizeReferenceForOAuth } from "./references.js";
 import { buildImageTools, createOAuthGenerationTimeout, fetchOAuth, getOAuthUrl, resolveReasoningEffort, resolveWebSearchEnabled, summarizeEventTypes, waitForOAuthReady, } from "./runtime.js";
-import { readImageStream, readMultimodeImageStream } from "./streams.js";
-import { config } from "../../config.js";
-const RESEARCH_SUFFIX = config.oauth.researchSuffix;
+import { readImageStream } from "./streams.js";
 export async function generateViaOAuth(prompt, quality, size, moderation = "low", references = [], requestId = null, mode = "auto", ctx = {}, options = {}) {
     await waitForOAuthReady(ctx);
     const oauthUrl = getOAuthUrl(ctx);
@@ -184,244 +181,4 @@ export async function generateViaOAuth(prompt, quality, size, moderation = "low"
         timeout.clear();
     }
 }
-export async function generateMultimodeViaOAuth(prompt, quality, size, moderation = "low", references = [], requestId = null, mode = "auto", ctx = {}, options = {}) {
-    await waitForOAuthReady(ctx);
-    const oauthUrl = getOAuthUrl(ctx);
-    const model = options.model || ctx.config?.imageModels?.default || "gpt-5.4-mini";
-    const maxGeneratedImages = Math.max(1, Math.trunc(Number(ctx.config?.limits?.maxGeneratedImages) || 24));
-    const maxImages = Math.min(maxGeneratedImages, Math.max(1, Math.trunc(Number(options.maxImages) || 1)));
-    const webSearchEnabled = resolveWebSearchEnabled(options);
-    const tools = buildImageTools(webSearchEnabled, {
-        quality,
-        size,
-        moderation,
-        ...(options.partialImages ? { partial_images: options.partialImages } : {}),
-    });
-    const referenceInputs = references.map(normalizeReferenceForOAuth);
-    const userText = buildMultimodeSequencePrompt(mode === "direct"
-        ? `${prompt}${DIRECT_PROMPT_FIDELITY_SUFFIX}`
-        : `${prompt}${webSearchEnabled ? RESEARCH_SUFFIX : ""}${AUTO_PROMPT_FIDELITY_SUFFIX}`, maxImages, { webSearchEnabled, size });
-    const userContent = referenceInputs.length
-        ? [
-            ...referenceInputs.map(({ b64, requestMime }) => ({
-                type: "input_image",
-                image_url: `data:${requestMime};base64,${b64}`,
-            })),
-            { type: "input_text", text: userText },
-        ]
-        : userText;
-    logEvent("oauth-multimode", "request", {
-        requestId,
-        model,
-        refsCount: referenceInputs.length,
-        maxImages,
-        promptChars: typeof prompt === "string" ? prompt.length : 0,
-        webSearchEnabled,
-    });
-    const reasoningEffort = resolveReasoningEffort(ctx, options);
-    const developerPrompt = webSearchEnabled ? MULTIMODE_DEVELOPER_PROMPT : MULTIMODE_NO_SEARCH_DEVELOPER_PROMPT;
-    const timeout = createOAuthGenerationTimeout(ctx, requestId, "oauth-multimode");
-    try {
-        const res = await fetchOAuth(`${oauthUrl}/v1/responses`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json", Accept: "text/event-stream" },
-            signal: options.signal || timeout.signal,
-            body: JSON.stringify({
-                model,
-                input: [
-                    { role: "developer", content: `${developerPrompt}\n\nN = ${maxImages}.` },
-                    { role: "user", content: userContent },
-                ],
-                tools,
-                tool_choice: "required",
-                reasoning: { effort: reasoningEffort },
-                stream: true,
-            }),
-        }, { requestId, scope: "oauth-multimode" });
-        logEvent("oauth-multimode", "response", {
-            requestId,
-            model,
-            status: res.status,
-            contentType: res.headers.get("content-type"),
-        });
-        if (!res.ok) {
-            const text = await res.text();
-            logEvent("oauth-multimode", "error_response", { requestId, status: res.status, errorChars: text.length });
-            throwOAuthHttpError(res, text, {
-                requestId,
-                scope: "oauth-multimode",
-                fallbackMessage: `OAuth proxy returned ${res.status}`,
-            });
-        }
-        if (requestId)
-            setJobPhase(requestId, "streaming");
-        const contentType = res.headers.get("content-type") || "";
-        if (!contentType.includes("text/event-stream")) {
-            const json = await res.json();
-            const images = [];
-            for (const item of json.output || []) {
-                if (item.type === "image_generation_call" && item.result && images.length < maxImages) {
-                    images.push({
-                        b64: item.result,
-                        revisedPrompt: typeof item.revised_prompt === "string" ? item.revised_prompt : null,
-                    });
-                }
-            }
-            return {
-                images,
-                usage: json.usage || null,
-                webSearchCalls: 0,
-                eventCount: 0,
-                eventTypes: {},
-                extraIgnored: 0,
-            };
-        }
-        const result = await readMultimodeImageStream(res, {
-            requestId,
-            maxImages,
-            scope: "oauth-multimode",
-            onPartialImage: options.onPartialImage,
-        });
-        logEvent("oauth-multimode", "stream_end", {
-            requestId,
-            events: result.eventCount,
-            imageCount: result.images.length,
-            extraIgnored: result.extraIgnored,
-            ...summarizeEventTypes(result.eventTypes),
-        });
-        return result;
-    }
-    catch (err) {
-        if (timeout.isTimeoutError(err)) {
-            throwOAuthTimeoutError(err, { timeoutMs: timeout.timeoutMs, requestId, scope: "oauth-multimode" });
-        }
-        throw err;
-    }
-    finally {
-        timeout.clear();
-    }
-}
-export async function editViaOAuth(prompt, imageB64, quality, size, moderation = "low", mode = "auto", ctx = {}, requestId = null, options = {}) {
-    await waitForOAuthReady(ctx);
-    const maskPresent = typeof options.mask === "string" && options.mask.length > 0;
-    if (maskPresent && !ctx.config?.oauth?.maskedEditEnabled) {
-        logEvent("oauth-edit", "mask_unsupported", { requestId, maskPresent: true });
-        const err = new Error("Masked edit is not supported by the current OAuth image provider");
-        err.status = 400;
-        err.code = "EDIT_MASK_NOT_SUPPORTED";
-        throw err;
-    }
-    if (maskPresent) {
-        // TODO(#31): enable upstream mask payload after STEP-0 verification
-        logEvent("oauth-edit", "mask_unsupported", { requestId, maskPresent: true });
-        const err = new Error("Masked edit is not supported by the current OAuth image provider");
-        err.status = 400;
-        err.code = "EDIT_MASK_NOT_SUPPORTED";
-        throw err;
-    }
-    const oauthUrl = getOAuthUrl(ctx);
-    const model = options.model || ctx.config?.imageModels?.default || "gpt-5.4-mini";
-    const webSearchEnabled = resolveWebSearchEnabled(options);
-    const textPrompt = buildEditTextPrompt(prompt, mode, { webSearchEnabled, size });
-    const imageForRequest = await compressReferenceB64ForOAuth(imageB64, {
-        maxB64Bytes: ctx.config?.limits?.maxRefB64Bytes,
-        force: true,
-    });
-    const references = Array.isArray(options.references) ? options.references : [];
-    const referenceImagesForRequest = await Promise.all(references.map((ref) => compressReferenceB64ForOAuth(typeof ref === "string" ? ref : ref?.b64, {
-        maxB64Bytes: ctx.config?.limits?.maxRefB64Bytes,
-        force: true,
-    })));
-    const referenceContent = referenceImagesForRequest.map(({ b64 }) => ({
-        type: "input_image",
-        image_url: `data:image/jpeg;base64,${b64}`,
-    }));
-    const tools = buildImageTools(webSearchEnabled, { quality, size, moderation });
-    logEvent("oauth-edit", "request", {
-        requestId,
-        model,
-        refsCount: references.length,
-        inputImageCount: 1 + references.length,
-        parentImagePresent: true,
-        webSearchEnabled,
-        inputImageCompressed: imageForRequest.compressed,
-        inputImageChars: imageForRequest.inputBytes,
-        inputImageRequestChars: imageForRequest.outputBytes,
-    });
-    const reasoningEffort = resolveReasoningEffort(ctx, options);
-    const developerPrompt = webSearchEnabled ? EDIT_DEVELOPER_PROMPT : EDIT_NO_SEARCH_DEVELOPER_PROMPT;
-    const timeout = createOAuthGenerationTimeout(ctx, requestId, "oauth-edit");
-    try {
-        const res = await fetchOAuth(`${oauthUrl}/v1/responses`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json", Accept: "text/event-stream" },
-            signal: timeout.signal,
-            body: JSON.stringify({
-                model,
-                input: [
-                    { role: "developer", content: developerPrompt },
-                    {
-                        role: "user",
-                        content: [
-                            { type: "input_image", image_url: `data:image/jpeg;base64,${imageForRequest.b64}` },
-                            ...referenceContent,
-                            { type: "input_text", text: textPrompt },
-                        ],
-                    },
-                ],
-                tools,
-                tool_choice: "required",
-                reasoning: { effort: reasoningEffort },
-                stream: true,
-            }),
-        }, { requestId, scope: "oauth-edit" });
-        logEvent("oauth-edit", "response", {
-            requestId,
-            model,
-            status: res.status,
-            contentType: res.headers.get("content-type"),
-        });
-        if (!res.ok) {
-            const text = await res.text();
-            logEvent("oauth-edit", "error_response", { requestId, status: res.status, errorChars: text.length });
-            throwOAuthHttpError(res, text, {
-                requestId,
-                scope: "oauth-edit",
-                fallbackMessage: `OAuth edit returned ${res.status}`,
-            });
-        }
-        if (requestId)
-            setJobPhase(requestId, "streaming");
-        const { imageB64: resultB64, usage, revisedPrompt, webSearchCalls, eventCount, eventTypes } = await readImageStream(res, {
-            scope: "oauth-edit",
-            requestId,
-        });
-        logEvent("oauth-edit", "stream_end", {
-            requestId,
-            events: eventCount,
-            hasImage: !!resultB64,
-            ...summarizeEventTypes(eventTypes),
-        });
-        if (resultB64)
-            return { b64: resultB64, usage, revisedPrompt, webSearchCalls };
-        const emptyErr = new Error("No image data received from OAuth edit");
-        emptyErr.eventCount = eventCount;
-        emptyErr.eventTypes = eventTypes;
-        emptyErr.size = size;
-        emptyErr.quality = quality;
-        emptyErr.model = model;
-        emptyErr.refsCount = references.length;
-        emptyErr.inputImageCount = 1 + references.length;
-        emptyErr.parentImagePresent = true;
-        throw emptyErr;
-    }
-    catch (err) {
-        if (timeout.isTimeoutError(err)) {
-            throwOAuthTimeoutError(err, { timeoutMs: timeout.timeoutMs, requestId, scope: "oauth-edit" });
-        }
-        throw err;
-    }
-    finally {
-        timeout.clear();
-    }
-}
+export { generateMultimodeViaOAuth, editViaOAuth } from "./multimodeGenerators.js";

package/lib/oauthProxy/multimodeGenerators.js

@@ -0,0 +1,251 @@
+import { setJobPhase } from "../inflight.js";
+import { logEvent } from "../logger.js";
+import { compressReferenceB64ForOAuth } from "../referenceImageCompress.js";
+import { throwOAuthHttpError, throwOAuthTimeoutError } from "./errors.js";
+import { AUTO_PROMPT_FIDELITY_SUFFIX, DIRECT_PROMPT_FIDELITY_SUFFIX, EDIT_DEVELOPER_PROMPT, EDIT_NO_SEARCH_DEVELOPER_PROMPT, MULTIMODE_DEVELOPER_PROMPT, MULTIMODE_NO_SEARCH_DEVELOPER_PROMPT, buildEditTextPrompt, buildMultimodeSequencePrompt, } from "./prompts.js";
+import { normalizeReferenceForOAuth } from "./references.js";
+import { buildImageTools, createOAuthGenerationTimeout, fetchOAuth, getOAuthUrl, resolveReasoningEffort, resolveWebSearchEnabled, summarizeEventTypes, waitForOAuthReady, } from "./runtime.js";
+import { readImageStream, readMultimodeImageStream } from "./streams.js";
+import { config } from "../../config.js";
+const RESEARCH_SUFFIX = config.oauth.researchSuffix;
+export async function generateMultimodeViaOAuth(prompt, quality, size, moderation = "low", references = [], requestId = null, mode = "auto", ctx = {}, options = {}) {
+    await waitForOAuthReady(ctx);
+    const oauthUrl = getOAuthUrl(ctx);
+    const model = options.model || ctx.config?.imageModels?.default || "gpt-5.4-mini";
+    const maxGeneratedImages = Math.max(1, Math.trunc(Number(ctx.config?.limits?.maxGeneratedImages) || 24));
+    const maxImages = Math.min(maxGeneratedImages, Math.max(1, Math.trunc(Number(options.maxImages) || 1)));
+    const webSearchEnabled = resolveWebSearchEnabled(options);
+    const tools = buildImageTools(webSearchEnabled, {
+        quality,
+        size,
+        moderation,
+        ...(options.partialImages ? { partial_images: options.partialImages } : {}),
+    });
+    const referenceInputs = references.map(normalizeReferenceForOAuth);
+    const userText = buildMultimodeSequencePrompt(mode === "direct"
+        ? `${prompt}${DIRECT_PROMPT_FIDELITY_SUFFIX}`
+        : `${prompt}${webSearchEnabled ? RESEARCH_SUFFIX : ""}${AUTO_PROMPT_FIDELITY_SUFFIX}`, maxImages, { webSearchEnabled, size });
+    const userContent = referenceInputs.length
+        ? [
+            ...referenceInputs.map(({ b64, requestMime }) => ({
+                type: "input_image",
+                image_url: `data:${requestMime};base64,${b64}`,
+            })),
+            { type: "input_text", text: userText },
+        ]
+        : userText;
+    logEvent("oauth-multimode", "request", {
+        requestId,
+        model,
+        refsCount: referenceInputs.length,
+        maxImages,
+        promptChars: typeof prompt === "string" ? prompt.length : 0,
+        webSearchEnabled,
+    });
+    const reasoningEffort = resolveReasoningEffort(ctx, options);
+    const developerPrompt = webSearchEnabled ? MULTIMODE_DEVELOPER_PROMPT : MULTIMODE_NO_SEARCH_DEVELOPER_PROMPT;
+    const timeout = createOAuthGenerationTimeout(ctx, requestId, "oauth-multimode");
+    try {
+        const res = await fetchOAuth(`${oauthUrl}/v1/responses`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Accept: "text/event-stream" },
+            signal: options.signal || timeout.signal,
+            body: JSON.stringify({
+                model,
+                input: [
+                    { role: "developer", content: `${developerPrompt}\n\nN = ${maxImages}.` },
+                    { role: "user", content: userContent },
+                ],
+                tools,
+                tool_choice: "required",
+                reasoning: { effort: reasoningEffort },
+                stream: true,
+            }),
+        }, { requestId, scope: "oauth-multimode" });
+        logEvent("oauth-multimode", "response", {
+            requestId,
+            model,
+            status: res.status,
+            contentType: res.headers.get("content-type"),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            logEvent("oauth-multimode", "error_response", { requestId, status: res.status, errorChars: text.length });
+            throwOAuthHttpError(res, text, {
+                requestId,
+                scope: "oauth-multimode",
+                fallbackMessage: `OAuth proxy returned ${res.status}`,
+            });
+        }
+        if (requestId)
+            setJobPhase(requestId, "streaming");
+        const contentType = res.headers.get("content-type") || "";
+        if (!contentType.includes("text/event-stream")) {
+            const json = await res.json();
+            const images = [];
+            for (const item of json.output || []) {
+                if (item.type === "image_generation_call" && item.result && images.length < maxImages) {
+                    images.push({
+                        b64: item.result,
+                        revisedPrompt: typeof item.revised_prompt === "string" ? item.revised_prompt : null,
+                    });
+                }
+            }
+            return {
+                images,
+                usage: json.usage || null,
+                webSearchCalls: 0,
+                eventCount: 0,
+                eventTypes: {},
+                extraIgnored: 0,
+            };
+        }
+        const result = await readMultimodeImageStream(res, {
+            requestId,
+            maxImages,
+            scope: "oauth-multimode",
+            onPartialImage: options.onPartialImage,
+        });
+        logEvent("oauth-multimode", "stream_end", {
+            requestId,
+            events: result.eventCount,
+            imageCount: result.images.length,
+            extraIgnored: result.extraIgnored,
+            ...summarizeEventTypes(result.eventTypes),
+        });
+        return result;
+    }
+    catch (err) {
+        if (timeout.isTimeoutError(err)) {
+            throwOAuthTimeoutError(err, { timeoutMs: timeout.timeoutMs, requestId, scope: "oauth-multimode" });
+        }
+        throw err;
+    }
+    finally {
+        timeout.clear();
+    }
+}
+export async function editViaOAuth(prompt, imageB64, quality, size, moderation = "low", mode = "auto", ctx = {}, requestId = null, options = {}) {
+    await waitForOAuthReady(ctx);
+    const maskPresent = typeof options.mask === "string" && options.mask.length > 0;
+    if (maskPresent && !ctx.config?.oauth?.maskedEditEnabled) {
+        logEvent("oauth-edit", "mask_unsupported", { requestId, maskPresent: true });
+        const err = new Error("Masked edit is not supported by the current OAuth image provider");
+        err.status = 400;
+        err.code = "EDIT_MASK_NOT_SUPPORTED";
+        throw err;
+    }
+    if (maskPresent) {
+        // TODO(#31): enable upstream mask payload after STEP-0 verification
+        logEvent("oauth-edit", "mask_unsupported", { requestId, maskPresent: true });
+        const err = new Error("Masked edit is not supported by the current OAuth image provider");
+        err.status = 400;
+        err.code = "EDIT_MASK_NOT_SUPPORTED";
+        throw err;
+    }
+    const oauthUrl = getOAuthUrl(ctx);
+    const model = options.model || ctx.config?.imageModels?.default || "gpt-5.4-mini";
+    const webSearchEnabled = resolveWebSearchEnabled(options);
+    const textPrompt = buildEditTextPrompt(prompt, mode, { webSearchEnabled, size });
+    const imageForRequest = await compressReferenceB64ForOAuth(imageB64, {
+        maxB64Bytes: ctx.config?.limits?.maxRefB64Bytes,
+        force: true,
+    });
+    const references = Array.isArray(options.references) ? options.references : [];
+    const referenceImagesForRequest = await Promise.all(references.map((ref) => compressReferenceB64ForOAuth(typeof ref === "string" ? ref : ref?.b64, {
+        maxB64Bytes: ctx.config?.limits?.maxRefB64Bytes,
+        force: true,
+    })));
+    const referenceContent = referenceImagesForRequest.map(({ b64 }) => ({
+        type: "input_image",
+        image_url: `data:image/jpeg;base64,${b64}`,
+    }));
+    const tools = buildImageTools(webSearchEnabled, { quality, size, moderation });
+    logEvent("oauth-edit", "request", {
+        requestId,
+        model,
+        refsCount: references.length,
+        inputImageCount: 1 + references.length,
+        parentImagePresent: true,
+        webSearchEnabled,
+        inputImageCompressed: imageForRequest.compressed,
+        inputImageChars: imageForRequest.inputBytes,
+        inputImageRequestChars: imageForRequest.outputBytes,
+    });
+    const reasoningEffort = resolveReasoningEffort(ctx, options);
+    const developerPrompt = webSearchEnabled ? EDIT_DEVELOPER_PROMPT : EDIT_NO_SEARCH_DEVELOPER_PROMPT;
+    const timeout = createOAuthGenerationTimeout(ctx, requestId, "oauth-edit");
+    try {
+        const res = await fetchOAuth(`${oauthUrl}/v1/responses`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Accept: "text/event-stream" },
+            signal: timeout.signal,
+            body: JSON.stringify({
+                model,
+                input: [
+                    { role: "developer", content: developerPrompt },
+                    {
+                        role: "user",
+                        content: [
+                            { type: "input_image", image_url: `data:image/jpeg;base64,${imageForRequest.b64}` },
+                            ...referenceContent,
+                            { type: "input_text", text: textPrompt },
+                        ],
+                    },
+                ],
+                tools,
+                tool_choice: "required",
+                reasoning: { effort: reasoningEffort },
+                stream: true,
+            }),
+        }, { requestId, scope: "oauth-edit" });
+        logEvent("oauth-edit", "response", {
+            requestId,
+            model,
+            status: res.status,
+            contentType: res.headers.get("content-type"),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            logEvent("oauth-edit", "error_response", { requestId, status: res.status, errorChars: text.length });
+            throwOAuthHttpError(res, text, {
+                requestId,
+                scope: "oauth-edit",
+                fallbackMessage: `OAuth edit returned ${res.status}`,
+            });
+        }
+        if (requestId)
+            setJobPhase(requestId, "streaming");
+        const { imageB64: resultB64, usage, revisedPrompt, webSearchCalls, eventCount, eventTypes } = await readImageStream(res, {
+            scope: "oauth-edit",
+            requestId,
+        });
+        logEvent("oauth-edit", "stream_end", {
+            requestId,
+            events: eventCount,
+            hasImage: !!resultB64,
+            ...summarizeEventTypes(eventTypes),
+        });
+        if (resultB64)
+            return { b64: resultB64, usage, revisedPrompt, webSearchCalls };
+        const emptyErr = new Error("No image data received from OAuth edit");
+        emptyErr.eventCount = eventCount;
+        emptyErr.eventTypes = eventTypes;
+        emptyErr.size = size;
+        emptyErr.quality = quality;
+        emptyErr.model = model;
+        emptyErr.refsCount = references.length;
+        emptyErr.inputImageCount = 1 + references.length;
+        emptyErr.parentImagePresent = true;
+        throw emptyErr;
+    }
+    catch (err) {
+        if (timeout.isTimeoutError(err)) {
+            throwOAuthTimeoutError(err, { timeoutMs: timeout.timeoutMs, requestId, scope: "oauth-edit" });
+        }
+        throw err;
+    }
+    finally {
+        timeout.clear();
+    }
+}

package/lib/routeHelpers.js

@@ -12,8 +12,15 @@ export function imageFormatFromMime(mime) {
     return "png";
 }
 export function writeSse(res, event, data) {
-    res.write(`event: ${event}\n`);
-    res.write(`data: ${JSON.stringify(data)}\n\n`);
+    if (res.writableEnded || res.destroyed)
+        return false;
+    try {
+        res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 export function dataUrlFromB64(format, b64) {
     return `data:image/${format === "jpeg" ? "jpeg" : format};base64,${b64}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ima2-gen",
-  "version": "2.0.15",
+  "version": "2.0.16",
   "packageManager": "npm@11.18.0",
   "description": "Local OAuth image generation studio with classic and node workflows",
   "type": "module",
@@ -105,5 +105,5 @@
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
-  "gitHead": "ab86116ee1d23040e7ab63e49d8a6d4e19eddabd"
+  "gitHead": "579055388e5959dcca3f6bcb3e2e61409ead0a7e"
 }

package/routes/agent.js

@@ -1,6 +1,6 @@
 import { appendAgentTurn, compactAgentSession, createAgentSession, deleteAgentSession, getAgentGenerationSettings, getAgentSession, getAgentWorkspacePayload, importAgentImage, renameAgentSession, setAgentCurrentImage, setAgentGenerationSettings, setAgentLocks, setAgentWebSearch, } from "../lib/agentStore.js";
-import { cancelAgentQueueItem, createAgentQueueItem, getAgentGenerationErrors, getAgentQueueItem, listAgentQueueItems, retryAgentQueueItem, } from "../lib/agentQueueStore.js";
-import { ensureAgentQueueWorker, tickAgentQueueWorker } from "../lib/agentQueueWorker.js";
+import { createAgentQueueItem, getAgentGenerationErrors, getAgentQueueItem, listAgentQueueItems, retryAgentQueueItem, } from "../lib/agentQueueStore.js";
+import { cancelRunningAgentQueueItem, ensureAgentQueueWorker, tickAgentQueueWorker } from "../lib/agentQueueWorker.js";
 import { parseAgentSlashCommand, formatAgentQuestionReply, formatAgentSlashHelp } from "../lib/agentCommandParser.js";
 import { requestAgentQuestionAnswer } from "../lib/agentQuestionResponder.js";
 import { agentAllowedToolPayload, runAgentTurn } from "../lib/agentRuntime.js";
@@ -181,9 +181,9 @@ export function registerAgentRoutes(app, ctxRaw) {
         const item = getAgentQueueItem(req.params.itemId);
         if (!item)
             return sendError(res, queueItemNotFound(req.params.itemId));
-        const ok = cancelAgentQueueItem(item.id);
+        const ok = cancelRunningAgentQueueItem(item.id);
         if (!ok)
-            return sendError(res, queueActionError("AGENT_QUEUE_CANCEL_FAILED", "Only queued Agent work can be canceled."));
+            return sendError(res, queueActionError("AGENT_QUEUE_CANCEL_FAILED", "Only queued or running Agent work can be canceled."));
         res.json(getAgentWorkspacePayload(item.sessionId));
     });
     app.post("/api/agent/queue/:itemId/retry", (req, res) => {

package/routes/canvasVersions.js

@@ -1,5 +1,5 @@
 import express from "express";
-import { createCanvasVersion, updateCanvasVersion } from "../lib/canvasVersionStore.js";
+import { createCanvasVersion, recordCanvasAnnotationBake, revertCanvasAnnotations, updateCanvasVersion, } from "../lib/canvasVersionStore.js";
 import { errInfo } from "../lib/errInfo.js";
 import { requireRuntimeContext } from "../lib/runtimeContext.js";
 function decodeHeader(value) {
@@ -51,6 +51,7 @@ export function registerCanvasVersionRoutes(app, ctxRaw) {
                 sourceFilename,
                 prompt: getPrompt(req),
                 buffer: getRequestBuffer(req),
+                pixelEdited: req.headers["x-ima2-canvas-pixel-edited"] === "true",
             });
             res.json({ item });
         }
@@ -62,4 +63,23 @@ export function registerCanvasVersionRoutes(app, ctxRaw) {
             });
         }
     });
+    app.put("/api/canvas-versions/:filename/annotation-bake", express.json({ limit: ctx.config.server.bodyLimit }), async (req, res) => {
+        try {
+            const item = await recordCanvasAnnotationBake(ctx, decodeURIComponent(req.params.filename), req.body?.snapshot, req.body?.annotationOnly === true);
+            res.json({ item });
+        }
+        catch (e) {
+            const err = errInfo(e);
+            res.status(err.status || 500).json({ error: err.message, code: err.code || "CANVAS_ANNOTATION_BAKE_FAILED" });
+        }
+    });
+    app.post("/api/canvas-versions/:filename/revert-annotations", async (req, res) => {
+        try {
+            res.json(await revertCanvasAnnotations(ctx, decodeURIComponent(req.params.filename)));
+        }
+        catch (e) {
+            const err = errInfo(e);
+            res.status(err.status || 500).json({ error: err.message, code: err.code || "CANVAS_ANNOTATION_REVERT_FAILED" });
+        }
+    });
 }

package/routes/cardNews.js

@@ -1,7 +1,7 @@
 import { listImageTemplates, readTemplatePreview } from "../lib/cardNewsTemplateStore.js";
 import { listRoleTemplates } from "../lib/cardNewsRoleTemplateStore.js";
 import { createCardNewsDraft } from "../lib/cardNewsPlanner.js";
-import { generateCardNewsSet } from "../lib/cardNewsGenerator.js";
+import { generateCardNewsSet, validateCardNewsInput } from "../lib/cardNewsGenerator.js";
 import { createCardNewsJob, finishCardNewsJob, getCardNewsJob, getCardNewsJobPlan, retryCardNewsJob, updateCardNewsJob, updateCardNewsJobCard, } from "../lib/cardNewsJobStore.js";
 import { listCardNewsSets, readCardNewsManifest, readCardNewsSetPlan } from "../lib/cardNewsManifestStore.js";
 import { errInfo } from "../lib/errInfo.js";
@@ -126,6 +126,7 @@ export function registerCardNewsRoutes(app, ctxRaw) {
     app.post("/api/cardnews/jobs", (req, res) => {
         try {
             const body = (req.body ?? {});
+            validateCardNewsInput(body);
             const summary = createCardNewsJob(body);
             runCardNewsJob(ctx, summary.jobId, body);
             res.status(202).json(summary);