ima2-gen 2.0.2 → 2.0.4-preview-260626

package/lib/agentImageVideoGen.js

@@ -16,6 +16,7 @@ import { parseVideoParams } from "./agentGenerationPlanner.js";
 import { appendAgentTurn, getAgentImages, getAgentSession, importAgentImage, } from "./agentStore.js";
 import { errInfo } from "./errInfo.js";
 import { forceImagePrompt, isTextOnlyResult, textOnlyError, notFound } from "./agentRuntime.js";
+const AGENT_GROK_PLANNER_MODEL = "grok-4.3";
 export async function generateAgentImageWithRetry(ctx, sessionId, prompt, manifest, webSearchEnabled, options) {
     let lastError = null;
     for (let attempt = 0; attempt < 2; attempt++) {
@@ -43,9 +44,10 @@ export async function generateAgentImageWithRetry(ctx, sessionId, prompt, manife
 }
 async function generateAgentImage(ctx, sessionId, prompt, manifest, webSearchEnabled, options) {
     const requestId = options.requestId ?? `agent_${ulid()}`;
+    const grokPlannerModel = isAgentGrokPlannerModel(options.model) ? options.model : undefined;
     const providerOptions = resolveProviderOptions(ctx, {
         provider: options.provider ?? "oauth",
-        rawModel: options.model,
+        rawModel: grokPlannerModel ? undefined : options.model,
         rawReasoningEffort: options.reasoningEffort,
         rawSize: options.size ?? "1024x1024",
         rawWebSearchEnabled: webSearchEnabled,
@@ -72,7 +74,8 @@ async function generateAgentImage(ctx, sessionId, prompt, manifest, webSearchEna
                 size: providerOptions.size,
                 requestId,
                 signal: options.signal ?? undefined,
-                references: await loadAgentCurrentImageReferences(ctx, sessionId),
+                references: await loadAgentCurrentImageReferences(ctx, sessionId, options.sourceImagePolicy ?? "none"),
+                plannerModel: grokPlannerModel,
             })
             : await generateViaResponses(activeProvider, `${manifest}\n\nUser request:\n${prompt}`, options.quality ?? "medium", providerOptions.size, options.moderation ?? "low", [], requestId, "auto", ctx, {
                 model: providerOptions.model,
@@ -90,16 +93,23 @@ async function generateAgentImage(ctx, sessionId, prompt, manifest, webSearchEna
     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) {
+async function loadAgentCurrentImageReferences(ctx, sessionId, policy) {
+    if (policy === "none") {
+        logEvent("agent", "grok_ref_policy", { sessionId, policy, attached: false });
+        return [];
+    }
     const session = getAgentSession(sessionId);
     const currentImage = session?.lastImageId
         ? getAgentImages(sessionId).find((image) => image.id === session.lastImageId)
         : null;
-    if (!currentImage?.filename)
+    if (!currentImage?.filename) {
+        logEvent("agent", "grok_ref_policy", { sessionId, policy, attached: false });
         return [];
+    }
     try {
         const b64 = (await readFile(join(ctx.config.storage.generatedDir, currentImage.filename))).toString("base64");
         const mime = detectImageMimeFromB64(b64);
+        logEvent("agent", "grok_ref_policy", { sessionId, policy, attached: true, filename: currentImage.filename });
         return [{ b64, declaredMime: mime, detectedMime: mime }];
     }
     catch (error) {
@@ -179,7 +189,13 @@ export async function runAgentVideoGeneration(ctx, sessionId, prompt, options =
             catch { /* fallback to T2V */ }
         }
     }
-    const videoParams = parseVideoParams(prompt);
+    // LLM-planned params win; the prompt regex remains the fallback extractor.
+    const parsedParams = parseVideoParams(prompt);
+    const videoParams = {
+        duration: options.videoParams?.duration ?? parsedParams.duration,
+        resolution: options.videoParams?.resolution ?? parsedParams.resolution,
+        aspectRatio: options.videoParams?.aspectRatio ?? parsedParams.aspectRatio,
+    };
     const result = await generateVideoViaGrok(prompt, ctx, {
         model: "grok-imagine-video",
         mode,
@@ -189,6 +205,7 @@ export async function runAgentVideoGeneration(ctx, sessionId, prompt, options =
         aspectRatio: (videoParams.aspectRatio ?? "auto"),
         requestId,
         signal: options.signal ?? undefined,
+        plannerModel: isAgentGrokPlannerModel(options.model) ? options.model : undefined,
     });
     const video = await persistAgentVideo(ctx, sessionId, prompt, requestId, result);
     const finishedAt = Date.now();
@@ -215,12 +232,15 @@ export async function runAgentVideoGeneration(ctx, sessionId, prompt, options =
     const assistantTurn = appendAgentTurn({
         sessionId,
         role: "assistant",
-        text: `Generated 1 video artifact. ${result.revisedPrompt}`,
+        text: options.assistantText?.trim() || `Generated 1 video artifact. ${result.revisedPrompt}`,
         imageIds: [video.id],
         status: "complete",
     });
     return { assistantTurn, imageIds: [video.id], webFindingIds: [] };
 }
+function isAgentGrokPlannerModel(model) {
+    return model === AGENT_GROK_PLANNER_MODEL;
+}
 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");

package/lib/agentPlannerModel.js

@@ -0,0 +1,172 @@
+import { normalizeAgentGenerationPlan } from "./agentGenerationPlanner.js";
+import { readResponsesTextPayload } from "./agentQuestionResponder.js";
+import { formatToolManifestForPrompt } from "./agentToolManifest.js";
+import { getAgentSession } from "./agentStore.js";
+import { errInfo } from "./errInfo.js";
+import { logEvent } from "./logger.js";
+import { getGrokEndpoint, getPlannerConfig } from "./grokImageCore.js";
+import { waitForOAuthReady } from "./oauthProxy/runtime.js";
+import { requireRuntimeContext } from "./runtimeContext.js";
+function buildPlannerDeveloperPrompt(hasSourceImage, imageCount) {
+    return [
+        "You are the generation planner for the ima2 Agent. Decide how to fulfill the user's request using the available tools.",
+        "",
+        "Available tools (name, purpose, parameter schema):",
+        formatToolManifestForPrompt(),
+        "",
+        "Tool execution contract:",
+        "- You do not call provider image/video APIs directly. You choose a plan; the ima2 runtime executes the corresponding ima2.* tools.",
+        "- The session model is the planner/LLM model, not an image or video model. For example, grok-4.3 means Grok planner/provider routing; image generation still uses ima2.generate_image with the configured Grok image backend.",
+        "- For image creation/edit requests choose mode single or fanout, which maps to ima2.get_image_context followed by ima2.generate_image.",
+        "- For image creation/edit requests, also choose sourceImagePolicy: none for a fresh image, current to use the session's current image as an edit/reference input, or auto only when genuinely ambiguous.",
+        "- For video creation requests choose mode video, which maps to ima2.generate_video. Never put video model names in prompts.",
+        "- For failure questions choose mode errors, which maps to ima2.get_generation_errors.",
+        "",
+        "Session context:",
+        `- Images in session: ${imageCount}`,
+        `- Last image available as image-to-video source: ${hasSourceImage ? "yes" : "no"}`,
+        "",
+        "Decide ONE plan and respond with ONLY a JSON object (no prose, no code fences):",
+        '{"mode":"single|fanout|video|question|errors","prompts":["..."],"plannedVariants":1,"plannedParallelism":1,"sourceImagePolicy":"none|current|auto","videoParams":{"duration":5,"resolution":"480p","aspectRatio":"auto"},"assistantText":"...","reason":"short reason"}',
+        "",
+        "Rules:",
+        "- You are a conversational assistant first. Generate media ONLY when the user clearly asks you to create or edit an image/video. Everything else (questions, chat, greetings, feedback, follow-ups) is mode question.",
+        "- mode single: one image. prompts has exactly 1 entry (the generation prompt, user language preserved).",
+        "- mode fanout: multiple image variants. prompts has one entry per variant; respect any count the user asked for.",
+        "- sourceImagePolicy for single/fanout: use none for new/fresh/separate/from-scratch requests, including '새로', '별도', 'i2i 말고', '새로운 방식', 'new image', 'from scratch', 'without reference'.",
+        "- sourceImagePolicy for single/fanout: use current only when the user explicitly asks to use/edit/modify/transform/reference the current image, including '이 이미지', '현재 이미지', '방금 그거', '참조', 'reference', 'i2i', 'image-to-image', '유지해서'.",
+        "- sourceImagePolicy for plain image requests with no explicit reference wording is none.",
+        "- mode video: one video via ima2.generate_video. Choose it only when the user asks to CREATE a video. prompts has exactly 1 entry. Extract duration (1-15 s), resolution (480p|720p), aspectRatio (auto|1:1|16:9|9:16|4:3|3:4|3:2|2:3) from the request into videoParams; omit fields the user did not specify.",
+        "- mode question: the user is NOT requesting generation — a question (capabilities, how-to, status), small talk, a greeting, or feedback — e.g. '영상 생성가능하니?', 'can you make videos?', '고마워'. prompts must be []. Write the full answer in assistantText. Mentioning a media word like 'video' or '영상' inside a question does NOT make it a generation request.",
+        "- mode errors: the user is asking why a previous generation failed or about recent errors. prompts must be [].",
+        "- assistantText: REQUIRED for every mode, written in the user's language. For question/errors it is the full reply. For single/fanout/video it is a short natural chat reply telling the user what you are creating (1-2 sentences, no markdown headings).",
+        "- Preserve the user's prompt content; do not censor, embellish, or translate it.",
+        "- reason: one short sentence explaining the decision.",
+    ].join("\n");
+}
+export async function requestAgentPlanFromModel(ctxRaw, input) {
+    const ctx = requireRuntimeContext(ctxRaw);
+    const plannerCfg = ctx.config.agentPlanner;
+    if (!plannerCfg?.enabled)
+        return null;
+    if (input.settings.provider === "agy")
+        return null;
+    const timeoutMs = plannerCfg.timeoutMs ?? 30_000;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const signal = input.signal ? AbortSignal.any([controller.signal, input.signal]) : controller.signal;
+    try {
+        const session = getAgentSession(input.sessionId);
+        const developerPrompt = buildPlannerDeveloperPrompt(Boolean(session?.lastImageId), session?.imageCount ?? 0);
+        const rawText = input.settings.provider === "grok"
+            ? await requestGrokPlan(ctx, developerPrompt, input.prompt, signal)
+            : await requestResponsesPlan(ctx, developerPrompt, input.prompt, input.settings, signal);
+        const parsed = extractJsonObject(rawText);
+        if (!parsed) {
+            logEvent("agent_planner", "parse_failed", { requestId: input.requestId, provider: input.settings.provider, chars: rawText.length });
+            return null;
+        }
+        const plan = normalizeAgentGenerationPlan(input.prompt, { ...parsed, source: "llm-planner" }, input.settings);
+        logEvent("agent_planner", "planned", {
+            requestId: input.requestId,
+            provider: input.settings.provider,
+            mode: plan.mode,
+            plannedVariants: plan.plannedVariants,
+            source: plan.source,
+        });
+        return plan;
+    }
+    catch (error) {
+        const err = errInfo(error);
+        logEvent("agent_planner", "fallback", {
+            requestId: input.requestId,
+            provider: input.settings.provider,
+            code: err.name === "AbortError" ? "AGENT_PLANNER_TIMEOUT" : err.code,
+            message: err.message,
+        });
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function requestGrokPlan(ctx, developerPrompt, userPrompt, signal) {
+    const { url, headers } = getGrokEndpoint(ctx, "/v1/chat/completions");
+    const planner = getPlannerConfig(ctx);
+    const res = await fetch(url, {
+        method: "POST",
+        headers,
+        signal,
+        body: JSON.stringify({
+            model: planner.model,
+            stream: false,
+            messages: [
+                { role: "system", content: developerPrompt },
+                { role: "user", content: userPrompt },
+            ],
+        }),
+    });
+    if (!res.ok)
+        throw plannerHttpError("grok", res.status);
+    const body = await res.json();
+    return typeof body.choices?.[0]?.message?.content === "string" ? body.choices[0].message.content : "";
+}
+async function requestResponsesPlan(ctx, developerPrompt, userPrompt, settings, signal) {
+    let url;
+    let headers;
+    if (settings.provider === "api") {
+        if (!ctx.apiKey)
+            throw plannerError("API key is required for Agent planner", "API_KEY_REQUIRED", 401);
+        url = "https://api.openai.com/v1/responses";
+        headers = { "Content-Type": "application/json", Accept: "text/event-stream", Authorization: `Bearer ${ctx.apiKey}` };
+    }
+    else {
+        await waitForOAuthReady(ctx);
+        url = `${ctx.oauthUrl}/v1/responses`;
+        headers = { "Content-Type": "application/json", Accept: "text/event-stream" };
+    }
+    // stream:true is required — the bundled OAuth proxy returns an empty
+    // `output` array for non-streaming Responses calls, which used to make the
+    // planner silently fall back to the regex-derived image plan.
+    const res = await fetch(url, {
+        method: "POST",
+        headers,
+        signal,
+        body: JSON.stringify({
+            model: settings.model,
+            input: [
+                { role: "developer", content: developerPrompt },
+                { role: "user", content: userPrompt },
+            ],
+            reasoning: { effort: "low" },
+            stream: true,
+        }),
+    });
+    if (!res.ok)
+        throw plannerHttpError(settings.provider, res.status);
+    const payload = await readResponsesTextPayload(res);
+    return payload.text;
+}
+export function extractJsonObject(raw) {
+    const text = raw.replace(/```(?:json)?/gi, "").trim();
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
+    if (start === -1 || end === -1 || end <= start)
+        return null;
+    try {
+        const parsed = JSON.parse(text.slice(start, end + 1));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function plannerHttpError(provider, status) {
+    return plannerError(`Agent planner upstream rejected the request (${provider})`, "AGENT_PLANNER_UPSTREAM_FAILED", status >= 400 && status < 600 ? status : 502);
+}
+function plannerError(message, code, status) {
+    const err = new Error(message);
+    err.code = code;
+    err.status = status;
+    return err;
+}

package/lib/agentQuestionResponder.js

@@ -40,9 +40,7 @@ export async function requestAgentQuestionAnswer(ctxRaw, question, options = {})
             });
             if (!res.ok)
                 throw await questionHttpError(res, options.provider);
-            const parsed = res.headers.get("content-type")?.includes("text/event-stream")
-                ? await readTextStream(res)
-                : readTextBody(await res.json());
+            const parsed = await readResponsesTextPayload(res);
             if (!parsed.text.trim())
                 throw questionError("Agent question returned an empty response", "AGENT_QUESTION_EMPTY", 502);
             return { text: parsed.text.trim().slice(0, 4_000), usage: parsed.usage };
@@ -94,6 +92,14 @@ async function questionHttpError(res, provider) {
         throw errInfo(error).raw;
     }
 }
+// Shared with the agent planner: the bundled OAuth proxy returns an empty
+// `output` array for stream:false Responses calls, so any text consumer must
+// be able to read the SSE stream instead of relying on the JSON body.
+export async function readResponsesTextPayload(res) {
+    return res.headers.get("content-type")?.includes("text/event-stream")
+        ? readTextStream(res)
+        : readTextBody(await res.json());
+}
 async function readTextStream(res) {
     try {
         const reader = res.body?.getReader();

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,8 +1,11 @@
 import { ulid } from "ulid";
+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);
@@ -16,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, {
@@ -29,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 = {}) {
@@ -38,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" });
@@ -54,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,
         });
@@ -88,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();
@@ -142,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 {
@@ -167,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 || "";
@@ -231,7 +315,7 @@ 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)));
 }
 export function notFound(sessionId) {
     const err = new Error(`Agent session not found: ${sessionId}`);

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) {