ima2-gen 2.0.1 → 2.0.3

package/lib/agentQueueStore.js

@@ -143,6 +143,48 @@ export function cancelAgentQueueItem(id) {
   `).run(Date.now(), id);
     return res.changes > 0;
 }
+export function updateAgentQueueItemPlan(id, plan) {
+    const res = getDb().prepare(`
+    UPDATE agent_queue_items
+    SET tool_plan = ?
+    WHERE id = ?
+  `).run(JSON.stringify(plan), id);
+    return res.changes > 0;
+}
+export function getAgentGenerationErrors(sessionId, limit = 10) {
+    const cap = Math.max(1, Math.min(20, Math.round(limit)));
+    const queueRows = getDb().prepare(`
+    SELECT error_code AS code, error_message AS message, prompt, finished_at AS at
+    FROM agent_queue_items
+    WHERE session_id = ? AND status = 'failed'
+    ORDER BY finished_at DESC
+    LIMIT ?
+  `).all(sessionId, cap);
+    const turnRows = getDb().prepare(`
+    SELECT text, created_at AS at
+    FROM agent_turns
+    WHERE session_id = ? AND status = 'error'
+    ORDER BY created_at DESC
+    LIMIT ?
+  `).all(sessionId, cap);
+    const records = [
+        ...queueRows.map((row) => ({
+            scope: "queue",
+            code: row.code,
+            message: row.message ?? "Generation failed without a recorded message.",
+            prompt: row.prompt,
+            at: row.at ?? 0,
+        })),
+        ...turnRows.map((row) => ({
+            scope: "turn",
+            code: null,
+            message: row.text,
+            prompt: null,
+            at: row.at,
+        })),
+    ];
+    return records.sort((a, b) => b.at - a.at).slice(0, cap);
+}
 export function retryAgentQueueItem(id) {
     const res = getDb().prepare(`
     UPDATE agent_queue_items

package/lib/agentQueueWorker.js

@@ -1,5 +1,8 @@
-import { claimNextAgentQueueItem, completeAgentQueueItem, failAgentQueueItem, getAgentQueueItem, } from "./agentQueueStore.js";
-import { runAgentGenerationPlan } from "./agentRuntime.js";
+import { config } from "../config.js";
+import { claimNextAgentQueueItem, completeAgentQueueItem, failAgentQueueItem, getAgentQueueItem, updateAgentQueueItemPlan, } from "./agentQueueStore.js";
+import { requestAgentPlanFromModel } from "./agentPlannerModel.js";
+import { hasAgentErrorTurnRecorded, runAgentGenerationPlan } from "./agentRuntime.js";
+import { appendAgentTurn } from "./agentStore.js";
 import { errInfo } from "./errInfo.js";
 import { finishJob, setJobPhase, startJob } from "./inflight.js";
 import { logEvent } from "./logger.js";
@@ -42,10 +45,42 @@ export async function tickAgentQueueWorker(ctx) {
         ticking = false;
     }
 }
+// LLM planning runs only for plans the regex deriver produced automatically.
+// Slash commands, manual settings, agy sessions, and already-LLM-planned
+// retries keep their stored plan (audit decision F4/F5).
+function isLlmPlanningEligible(item) {
+    return Boolean(config.agentPlanner.enabled &&
+        (item.plan.source === "auto-default" || item.plan.source === "auto-request") &&
+        item.plan.command == null &&
+        item.options.generationStrategy === "auto" &&
+        item.options.provider !== "agy");
+}
+async function resolveRuntimePlan(ctx, item) {
+    if (!isLlmPlanningEligible(item))
+        return item.plan;
+    try {
+        const plan = await requestAgentPlanFromModel(ctx, {
+            sessionId: item.sessionId,
+            prompt: item.prompt,
+            settings: item.options,
+            requestId: item.requestId,
+        });
+        if (!plan)
+            return item.plan;
+        updateAgentQueueItemPlan(item.id, plan);
+        return plan;
+    }
+    catch (error) {
+        const err = errInfo(error);
+        logEvent("agent_queue", "planner_fallback", { itemId: item.id, code: err.code, message: err.message });
+        return item.plan;
+    }
+}
 async function runClaimedQueueItem(ctx, itemId) {
     const item = getAgentQueueItem(itemId);
     if (!item)
         return;
+    const plan = await resolveRuntimePlan(ctx, item);
     startJob({
         requestId: item.requestId,
         kind: "agent_queue",
@@ -53,19 +88,19 @@ async function runClaimedQueueItem(ctx, itemId) {
         meta: {
             sessionId: item.sessionId,
             queueItemId: item.id,
-            variants: item.plan.plannedVariants,
-            parallelism: item.plan.plannedParallelism,
-            requestedVariants: item.plan.requestedVariants,
+            variants: plan.plannedVariants,
+            parallelism: plan.plannedParallelism,
+            requestedVariants: plan.requestedVariants,
         },
     });
     try {
         logEvent("agent_queue", "start", { itemId: item.id, sessionId: item.sessionId });
         setJobPhase(item.requestId, "streaming");
-        const result = await runAgentGenerationPlan(ctx, item.sessionId, item.prompt, item.plan, {
+        const result = await runAgentGenerationPlan(ctx, item.sessionId, item.prompt, plan, {
             ...item.options,
             requestId: item.requestId,
             webSearchEnabled: item.options.webSearchEnabled,
-            parallelism: item.plan.plannedParallelism,
+            parallelism: plan.plannedParallelism,
         }, {
             appendUserTurn: false,
         });
@@ -79,6 +114,21 @@ async function runClaimedQueueItem(ctx, itemId) {
     catch (error) {
         const err = errInfo(error);
         failAgentQueueItem(item.id, { code: err.code, message: err.message });
+        // The chat pane must never fail silently — surface the failure as an
+        // assistant error turn unless the runtime already recorded one.
+        if (!hasAgentErrorTurnRecorded(error)) {
+            try {
+                appendAgentTurn({
+                    sessionId: item.sessionId,
+                    role: "assistant",
+                    text: err.code ? `${err.message} [${err.code}]` : err.message,
+                    status: "error",
+                });
+            }
+            catch (turnError) {
+                logEvent("agent_queue", "error_turn_failed", { itemId: item.id, message: errInfo(turnError).message });
+            }
+        }
         finishJob(item.requestId, {
             status: "failed",
             errorCode: err.code,

package/lib/agentRuntime.js

@@ -1,20 +1,11 @@
-import { randomBytes } from "node:crypto";
-import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
-import { atomicWriteJson } from "./atomicWrite.js";
-import { join } from "node:path";
 import { ulid } from "ulid";
-import { embedImageMetadataBestEffort } from "./imageMetadataStore.js";
-import { invalidateHistoryIndex } from "./historyIndex.js";
-import { logEvent } from "./logger.js";
-import { detectImageMimeFromB64 } from "./refs.js";
-import { resolveProviderOptions } from "./providerOptions.js";
-import { generateViaResponses } from "./responsesImageAdapter.js";
-import { generateViaGrok } from "./grokImageAdapter.js";
-import { generateViaAgy } from "./agyImageAdapter.js";
-import { generateVideoViaGrok } from "./grokVideoAdapter.js";
-import { parseVideoParams } from "./agentGenerationPlanner.js";
-import { appendAgentTurn, buildImageContextManifest, getAgentImages, getAgentSession, importAgentImage, recordAgentWebFinding, restartAgentRuntimeSession, } from "./agentStore.js";
+import { config } from "../config.js";
+import { generateAgentImageWithRetry } from "./agentImageVideoGen.js";
+import { runAgentVideoGeneration } from "./agentImageVideoGen.js";
+import { appendAgentTurn, buildImageContextManifest, getAgentSession, recordAgentWebFinding, restartAgentRuntimeSession, } from "./agentStore.js";
 import { AGENT_ALLOWED_TOOLS, } from "./agentTypes.js";
+import { getAgentGenerationErrors } from "./agentQueueStore.js";
+import { AGENT_TOOL_MANIFEST } from "./agentToolManifest.js";
 import { errInfo } from "./errInfo.js";
 export function assertAgentAllowedTools(tools) {
     const allowed = new Set(AGENT_ALLOWED_TOOLS);
@@ -28,7 +19,7 @@ export function assertAgentAllowedTools(tools) {
     }
 }
 export function agentAllowedToolPayload() {
-    return { tools: [...AGENT_ALLOWED_TOOLS] };
+    return { tools: [...AGENT_ALLOWED_TOOLS], manifest: [...AGENT_TOOL_MANIFEST] };
 }
 export async function runAgentTurn(ctx, sessionId, prompt, options = {}) {
     return runAgentGenerationPlan(ctx, sessionId, prompt, {
@@ -41,6 +32,7 @@ export async function runAgentTurn(ctx, sessionId, prompt, options = {}) {
         reason: "Direct turn endpoint defaults to one image.",
         command: null,
         assistantText: null,
+        sourceImagePolicy: "none",
     }, options, { appendUserTurn: true });
 }
 export async function runAgentGenerationPlan(ctx, sessionId, prompt, plan, options = {}, behavior = {}) {
@@ -50,7 +42,7 @@ export async function runAgentGenerationPlan(ctx, sessionId, prompt, plan, optio
     const webSearchEnabled = options.provider === "agy" ? false : options.provider === "grok" ? true : options.webSearchEnabled ?? session.webSearchEnabled;
     const enabledTools = webSearchEnabled
         ? [...AGENT_ALLOWED_TOOLS]
-        : ["ima2.get_image_context", "ima2.generate_image", "ima2.generate_video"];
+        : ["ima2.get_image_context", "ima2.generate_image", "ima2.generate_video", "ima2.get_generation_errors"];
     assertAgentAllowedTools(enabledTools);
     if (behavior.appendUserTurn !== false) {
         appendAgentTurn({ sessionId, role: "user", text: prompt, status: "complete" });
@@ -66,9 +58,15 @@ export async function runAgentGenerationPlan(ctx, sessionId, prompt, plan, optio
         });
         return { assistantTurn, imageIds: [], webFindingIds: [] };
     }
+    if (plan.mode === "errors") {
+        return runAgentErrorLookup(sessionId, plan);
+    }
+    const preludeSent = appendPlannerPreludeTurn(sessionId, plan);
     if (plan.mode === "video") {
-        return runAgentVideoGeneration(ctx, sessionId, prompt, {
+        return runAgentVideoGeneration(ctx, sessionId, plan.prompts[0] ?? prompt, {
             ...options,
+            videoParams: plan.videoParams ?? options.videoParams ?? null,
+            assistantText: preludeSent ? null : plan.assistantText,
             requestId: options.requestId ?? `agent_video_${ulid()}`,
             skipUserTurn: true,
         });
@@ -100,6 +98,7 @@ export async function runAgentGenerationPlan(ctx, sessionId, prompt, plan, optio
         const result = await runGeneratorWithRuntimeRecovery(ctx, sessionId, generationPrompt, manifest, webSearchEnabled, {
             ...options,
             requestId,
+            sourceImagePolicy: plan.sourceImagePolicy ?? "none",
         });
         const findingIds = recordSearchFindings(sessionId, generationPrompt, result.webSearchCalls, result.provider ?? "oauth");
         const finishedAt = Date.now();
@@ -154,20 +153,84 @@ export async function runAgentGenerationPlan(ctx, sessionId, prompt, plan, optio
     const assistantTurn = appendAgentTurn({
         sessionId,
         role: "assistant",
-        text: formatAgentAssistantText(plan, imageIds.length, responseTexts),
+        text: formatAgentAssistantText(plan, prompt, imageIds.length, responseTexts, preludeSent),
         imageIds,
         webFindingIds: findingIds,
         status: "complete",
     });
     return { assistantTurn, imageIds, webFindingIds: findingIds };
 }
-function formatAgentAssistantText(plan, imageCount, responseTexts) {
-    const countText = imageCount === 1 ? "Generated 1 image artifact." : `Generated ${imageCount} image artifacts.`;
-    const modeText = plan.mode === "fanout"
-        ? `Fanout used ${plan.plannedParallelism} concurrent tool call${plan.plannedParallelism === 1 ? "" : "s"}.`
-        : "Single-image plan completed.";
-    const modelText = responseTexts.length > 0 ? `${responseTexts.join("\n\n")}\n\n` : "";
-    return `${modelText}${countText} ${modeText} ${plan.reason}`.trim();
+function appendPlannerPreludeTurn(sessionId, plan) {
+    const text = plan.assistantText?.trim();
+    if (!text)
+        return false;
+    appendAgentTurn({
+        sessionId,
+        role: "assistant",
+        text,
+        imageIds: [],
+        webFindingIds: [],
+        status: "complete",
+    });
+    return true;
+}
+function runAgentErrorLookup(sessionId, plan) {
+    const startedAt = Date.now();
+    const errors = getAgentGenerationErrors(sessionId, 10);
+    appendAgentTurn({
+        sessionId,
+        role: "tool",
+        text: "ima2.get_generation_errors",
+        status: "complete",
+        raw: {
+            toolCalls: [{
+                    id: `tc_errors_${ulid()}`,
+                    name: "ima2.get_generation_errors",
+                    status: "complete",
+                    startedAt,
+                    finishedAt: Date.now(),
+                    durationMs: Date.now() - startedAt,
+                    outputSummary: errors.length > 0
+                        ? `Found ${errors.length} recent generation error${errors.length === 1 ? "" : "s"}.`
+                        : "No recent generation errors recorded for this session.",
+                }],
+        },
+    });
+    const assistantTurn = appendAgentTurn({
+        sessionId,
+        role: "assistant",
+        text: plan.assistantText?.trim() || formatGenerationErrors(errors),
+        imageIds: [],
+        webFindingIds: [],
+        status: "complete",
+    });
+    return { assistantTurn, imageIds: [], webFindingIds: [] };
+}
+function formatGenerationErrors(errors) {
+    if (errors.length === 0)
+        return "No generation errors are recorded for this session.";
+    const lines = errors.map((error, index) => {
+        const when = new Date(error.at).toISOString();
+        const code = error.code ? ` [${error.code}]` : "";
+        const promptPart = error.prompt ? ` (prompt: ${error.prompt.slice(0, 80)})` : "";
+        return `${index + 1}. ${when}${code} ${error.message}${promptPart}`;
+    });
+    return `Recent generation errors (most recent first):\n${lines.join("\n")}`;
+}
+function formatAgentAssistantText(plan, prompt, imageCount, responseTexts, omitPlannerText = false) {
+    // Behave like a normal chat agent: prefer the planner's natural-language
+    // reply, then any text the image model returned. The mechanical summary is
+    // only the fallback when neither produced prose.
+    const plannerText = omitPlannerText ? "" : (plan.assistantText?.trim() ?? "");
+    const modelText = responseTexts.join("\n\n").trim();
+    const prose = [plannerText, modelText].filter(Boolean).join("\n\n");
+    if (prose)
+        return prose;
+    const languageProbe = [prompt, ...plan.prompts].find((item) => item.trim().length > 0) ?? "";
+    const isKorean = /[\uAC00-\uD7AF]/u.test(languageProbe);
+    if (isKorean)
+        return imageCount === 1 ? "이미지 생성이 완료됐어요." : `이미지 ${imageCount}장을 생성했어요.`;
+    return imageCount === 1 ? "Done - I generated the image." : `Done - I generated ${imageCount} images.`;
 }
 async function runGeneratorWithRuntimeRecovery(ctx, sessionId, prompt, manifest, webSearchEnabled, options) {
     try {
@@ -179,9 +242,18 @@ async function runGeneratorWithRuntimeRecovery(ctx, sessionId, prompt, manifest,
             restartAgentRuntimeSession(sessionId, err.code || err.message);
         }
         appendAgentTurn({ sessionId, role: "assistant", text: err.message, status: "error" });
+        markAgentErrorTurnRecorded(error);
         throw error;
     }
 }
+export function markAgentErrorTurnRecorded(error) {
+    if (error && typeof error === "object") {
+        error.agentErrorTurnRecorded = true;
+    }
+}
+export function hasAgentErrorTurnRecorded(error) {
+    return Boolean(error && typeof error === "object" && error.agentErrorTurnRecorded);
+}
 export function isRuntimeRestartableError(error) {
     const err = errInfo(error);
     const code = err.code || "";
@@ -190,249 +262,6 @@ export function isRuntimeRestartableError(error) {
         code.includes("PROTOCOL") ||
         err.message.toLowerCase().includes("protocol wedge"));
 }
-async function generateAgentImageWithRetry(ctx, sessionId, prompt, manifest, webSearchEnabled, options) {
-    let lastError = null;
-    for (let attempt = 0; attempt < 2; attempt++) {
-        try {
-            const forcedPrompt = attempt === 0 ? prompt : forceImagePrompt(prompt);
-            const result = await generateAgentImage(ctx, sessionId, forcedPrompt, manifest, webSearchEnabled, options);
-            if (result.image)
-                return result;
-        }
-        catch (error) {
-            lastError = error;
-            if (!isTextOnlyResult(error))
-                throw error;
-            if (attempt === 1)
-                break;
-            appendAgentTurn({
-                sessionId,
-                role: "tool",
-                text: "ima2.generate_image retry: text-only result rejected",
-                status: "error",
-            });
-        }
-    }
-    throw textOnlyError(lastError);
-}
-async function generateAgentImage(ctx, sessionId, prompt, manifest, webSearchEnabled, options) {
-    const requestId = options.requestId ?? `agent_${ulid()}`;
-    const providerOptions = resolveProviderOptions(ctx, {
-        provider: options.provider ?? "oauth",
-        rawModel: options.model,
-        rawReasoningEffort: options.reasoningEffort,
-        rawSize: options.size ?? "1024x1024",
-        rawWebSearchEnabled: webSearchEnabled,
-        searchMode: webSearchEnabled ? "on" : "off",
-    });
-    if (providerOptions.error) {
-        const err = new Error(providerOptions.error);
-        err.code = providerOptions.code;
-        err.status = providerOptions.status;
-        throw err;
-    }
-    const activeProvider = providerOptions.provider;
-    const effectiveModel = activeProvider === "grok" && options.quality === "high"
-        ? "grok-imagine-image-quality"
-        : providerOptions.model;
-    const response = activeProvider === "agy"
-        ? await generateViaAgy(`${manifest}\n\nUser request:\n${prompt}`, {
-            requestId,
-            signal: options.signal ?? undefined,
-        })
-        : activeProvider === "grok"
-            ? await generateViaGrok(`${manifest}\n\nUser request:\n${prompt}`, ctx, {
-                model: effectiveModel,
-                size: providerOptions.size,
-                requestId,
-                signal: options.signal ?? undefined,
-                references: await loadAgentCurrentImageReferences(ctx, sessionId),
-            })
-            : await generateViaResponses(activeProvider, `${manifest}\n\nUser request:\n${prompt}`, options.quality ?? "medium", providerOptions.size, options.moderation ?? "low", [], requestId, "auto", ctx, {
-                model: providerOptions.model,
-                reasoningEffort: providerOptions.reasoningEffort,
-                webSearchEnabled,
-                signal: options.signal,
-            });
-    const format = activeProvider === "grok" || activeProvider === "agy"
-        ? imageFormatFromMime(("mime" in response ? response.mime : undefined) || detectImageMimeFromB64(response.b64) || "image/jpeg")
-        : options.format ?? "png";
-    const image = await persistAgentImage(ctx, sessionId, prompt, format, requestId, response, {
-        provider: String(activeProvider),
-        model: String(effectiveModel),
-    });
-    const responseText = "text" in response && typeof response.text === "string" ? response.text : null;
-    return { image, webSearchCalls: response.webSearchCalls || 0, text: responseText, provider: activeProvider };
-}
-async function loadAgentCurrentImageReferences(ctx, sessionId) {
-    const session = getAgentSession(sessionId);
-    const currentImage = session?.lastImageId
-        ? getAgentImages(sessionId).find((image) => image.id === session.lastImageId)
-        : null;
-    if (!currentImage?.filename)
-        return [];
-    try {
-        const b64 = (await readFile(join(ctx.config.storage.generatedDir, currentImage.filename))).toString("base64");
-        const mime = detectImageMimeFromB64(b64);
-        return [{ b64, declaredMime: mime, detectedMime: mime }];
-    }
-    catch (error) {
-        const err = errInfo(error);
-        logEvent("agent", "grok_ref_missing", { sessionId, filename: currentImage.filename, code: err.code, message: err.message });
-        return [];
-    }
-}
-function imageFormatFromMime(mime) {
-    if (mime === "image/jpeg")
-        return "jpeg";
-    if (mime === "image/webp")
-        return "webp";
-    return "png";
-}
-async function persistAgentImage(ctx, sessionId, prompt, format, requestId, response, generation) {
-    await mkdir(ctx.config.storage.generatedDir, { recursive: true });
-    const rand = randomBytes(ctx.config.ids.generatedHexBytes).toString("hex");
-    const filename = `${Date.now()}_${rand}_agent.${format}`;
-    const meta = {
-        kind: "agent",
-        requestId,
-        sessionId,
-        prompt,
-        userPrompt: prompt,
-        revisedPrompt: response.revisedPrompt ?? null,
-        provider: generation.provider,
-        model: generation.model,
-        createdAt: Date.now(),
-        usage: response.usage ?? null,
-        webSearchCalls: response.webSearchCalls ?? 0,
-    };
-    const embedded = await embedImageMetadataBestEffort(Buffer.from(response.b64, "base64"), format, meta, {
-        version: ctx.packageVersion,
-    });
-    const filePath = join(ctx.config.storage.generatedDir, filename);
-    await writeFile(filePath, embedded.buffer);
-    try {
-        await atomicWriteJson(`${filePath}.json`, meta);
-    }
-    catch (err) {
-        await unlink(filePath).catch(() => { });
-        throw err;
-    }
-    invalidateHistoryIndex();
-    logEvent("agent", "saved", { requestId, sessionId, filename });
-    return importAgentImage(sessionId, {
-        id: `ai_${ulid()}`,
-        filename,
-        url: `/generated/${filename}`,
-        prompt,
-        revisedPrompt: response.revisedPrompt ?? null,
-        createdAt: Date.now(),
-    });
-}
-export async function runAgentVideoGeneration(ctx, sessionId, prompt, options = {}) {
-    const session = getAgentSession(sessionId);
-    if (!session)
-        throw notFound(sessionId);
-    if (!options.skipUserTurn) {
-        appendAgentTurn({ sessionId, role: "user", text: prompt, status: "complete" });
-    }
-    const requestId = options.requestId ?? `agent_video_${ulid()}`;
-    const startedAt = Date.now();
-    // Auto I2V: if session has a last image, use it as source
-    let sourceImage;
-    let mode = "text-to-video";
-    if (session.lastImageId) {
-        const images = getAgentImages(sessionId);
-        const lastImage = images.find((img) => img.id === session.lastImageId);
-        if (lastImage?.filename && !lastImage.filename.endsWith(".mp4")) {
-            try {
-                const { loadAssetB64 } = await import("./nodeStore.js");
-                sourceImage = await loadAssetB64(ctx.rootDir, lastImage.filename, ctx.config.storage.generatedDir);
-                mode = "image-to-video";
-            }
-            catch { /* fallback to T2V */ }
-        }
-    }
-    const videoParams = parseVideoParams(prompt);
-    const result = await generateVideoViaGrok(prompt, ctx, {
-        model: "grok-imagine-video",
-        mode,
-        sourceImage,
-        duration: videoParams.duration ?? 5,
-        resolution: videoParams.resolution ?? "480p",
-        aspectRatio: (videoParams.aspectRatio ?? "auto"),
-        requestId,
-        signal: options.signal ?? undefined,
-    });
-    const video = await persistAgentVideo(ctx, sessionId, prompt, requestId, result);
-    const finishedAt = Date.now();
-    const toolCall = {
-        id: `tc_video_${ulid()}`,
-        name: "ima2.generate_video",
-        status: "complete",
-        startedAt,
-        finishedAt,
-        durationMs: finishedAt - startedAt,
-        requestId,
-        inputSummary: prompt,
-        outputSummary: `Generated video ${video.filename}.`,
-        imageIds: [video.id],
-    };
-    appendAgentTurn({
-        sessionId,
-        role: "tool",
-        text: "ima2.generate_video",
-        imageIds: [video.id],
-        status: "complete",
-        raw: { toolCalls: [toolCall] },
-    });
-    const assistantTurn = appendAgentTurn({
-        sessionId,
-        role: "assistant",
-        text: `Generated 1 video artifact. ${result.revisedPrompt}`,
-        imageIds: [video.id],
-        status: "complete",
-    });
-    return { assistantTurn, imageIds: [video.id], webFindingIds: [] };
-}
-async function persistAgentVideo(ctx, sessionId, prompt, requestId, result) {
-    await mkdir(ctx.config.storage.generatedDir, { recursive: true });
-    const rand = randomBytes(ctx.config.ids.generatedHexBytes).toString("hex");
-    const filename = `${Date.now()}_${rand}_agent.mp4`;
-    const meta = {
-        kind: "agent",
-        mediaType: "video",
-        requestId,
-        sessionId,
-        prompt,
-        userPrompt: prompt,
-        revisedPrompt: result.revisedPrompt,
-        provider: "grok",
-        model: "grok-imagine-video",
-        createdAt: Date.now(),
-        usage: result.usage,
-        webSearchCalls: result.webSearchCalls,
-    };
-    const filePath = join(ctx.config.storage.generatedDir, filename);
-    await writeFile(filePath, result.videoBuffer);
-    try {
-        await atomicWriteJson(`${filePath}.json`, meta);
-    }
-    catch (err) {
-        await unlink(filePath).catch(() => { });
-        throw err;
-    }
-    invalidateHistoryIndex();
-    logEvent("agent", "video_saved", { requestId, sessionId, filename });
-    return importAgentImage(sessionId, {
-        id: `ai_${ulid()}`,
-        filename,
-        url: `/generated/${filename}`,
-        prompt,
-        revisedPrompt: result.revisedPrompt,
-        createdAt: Date.now(),
-    });
-}
 function recordSearchFindings(sessionId, prompt, count, provider) {
     if (!count)
         return [];
@@ -446,14 +275,14 @@ function recordSearchFindings(sessionId, prompt, count, provider) {
         }),
     ];
 }
-function forceImagePrompt(prompt) {
+export function forceImagePrompt(prompt) {
     return [
         "The previous turn did not return an image artifact.",
         "Return a final image using ima2.generate_image/image_generation now.",
         `User request: ${prompt}`,
     ].join("\n");
 }
-function isTextOnlyResult(error) {
+export function isTextOnlyResult(error) {
     const err = errInfo(error);
     return [
         "EMPTY_RESPONSE",
@@ -462,7 +291,7 @@ function isTextOnlyResult(error) {
         "IMAGE_TOOL_COMPLETED_WITHOUT_RESULT",
     ].includes(err.code || "") || err.message.includes("No image data");
 }
-function textOnlyError(cause) {
+export function textOnlyError(cause) {
     const err = new Error("Agent result did not include an image artifact.");
     err.code = "AGENT_TEXT_ONLY_RESULT";
     err.status = 422;
@@ -486,9 +315,9 @@ function cleanParallelism(value) {
     const numeric = typeof value === "number" ? value : Number(value);
     if (!Number.isFinite(numeric))
         return 2;
-    return Math.max(1, Math.min(8, Math.round(numeric)));
+    return Math.max(1, Math.min(config.limits.maxParallel, Math.round(numeric)));
 }
-function notFound(sessionId) {
+export function notFound(sessionId) {
     const err = new Error(`Agent session not found: ${sessionId}`);
     err.code = "AGENT_SESSION_NOT_FOUND";
     err.status = 404;

package/lib/agentSettings.js

@@ -1,9 +1,12 @@
+import { config } from "../config.js";
 const PROVIDERS = new Set(["oauth", "api", "grok", "grok-api", "agy", "gemini-api"]);
 const QUALITIES = new Set(["low", "medium", "high"]);
 const FORMATS = new Set(["png", "jpeg", "webp"]);
 const MODERATIONS = new Set(["auto", "low"]);
-const REASONING_EFFORTS = new Set(["low", "medium", "high", "xhigh"]);
+const REASONING_EFFORTS = new Set(["none", "low", "medium", "high", "xhigh"]);
 const GENERATION_STRATEGIES = new Set(["auto", "manual"]);
+const MAX_AGENT_VARIANTS = Math.max(1, Math.trunc(config.limits.maxGeneratedImages));
+const MAX_AGENT_PARALLELISM = Math.max(1, Math.trunc(config.limits.maxParallel));
 export const DEFAULT_AGENT_GENERATION_SETTINGS = {
     provider: "oauth",
     model: "gpt-5.4-mini",
@@ -11,11 +14,11 @@ export const DEFAULT_AGENT_GENERATION_SETTINGS = {
     size: "1024x1024",
     format: "png",
     moderation: "low",
-    reasoningEffort: "medium",
+    reasoningEffort: "none",
     webSearchEnabled: true,
     generationStrategy: "auto",
     variants: 1,
-    maxAutoVariants: 8,
+    maxAutoVariants: MAX_AGENT_VARIANTS,
     parallelism: 2,
 };
 export function normalizeAgentGenerationSettings(value, fallback = DEFAULT_AGENT_GENERATION_SETTINGS) {
@@ -30,9 +33,9 @@ export function normalizeAgentGenerationSettings(value, fallback = DEFAULT_AGENT
         reasoningEffort: cleanEnum(input.reasoningEffort, REASONING_EFFORTS, fallback.reasoningEffort),
         webSearchEnabled: typeof input.webSearchEnabled === "boolean" ? input.webSearchEnabled : fallback.webSearchEnabled,
         generationStrategy: cleanEnum(input.generationStrategy, GENERATION_STRATEGIES, fallback.generationStrategy),
-        variants: cleanPositiveInt(input.variants, fallback.variants, 1, 8),
-        maxAutoVariants: cleanPositiveInt(input.maxAutoVariants, fallback.maxAutoVariants, 1, 8),
-        parallelism: cleanPositiveInt(input.parallelism, fallback.parallelism, 1, 8),
+        variants: cleanPositiveInt(input.variants, fallback.variants, 1, MAX_AGENT_VARIANTS),
+        maxAutoVariants: cleanPositiveInt(input.maxAutoVariants, fallback.maxAutoVariants, 1, MAX_AGENT_VARIANTS),
+        parallelism: cleanPositiveInt(input.parallelism, fallback.parallelism, 1, MAX_AGENT_PARALLELISM),
     };
 }
 export function mergeAgentGenerationSettings(current, patch) {