ima2-gen 2.0.1 → 2.0.3

package/lib/agentGenerationPlanner.js

@@ -1,25 +1,35 @@
-const HARD_MAX_VARIANTS = 8;
+import { config } from "../config.js";
+const HARD_MAX_VARIANTS = Math.max(1, Math.trunc(Number(config.limits.maxGeneratedImages) || 24));
 const AMBIGUOUS_MULTI_VARIANTS = 3;
 const KOREAN_COUNT_WORDS = [
-    [/(?:한|하나|1)\s*(?:장|개|가지|컷|시안|버전)/u, 1],
-    [/(?:두|둘|2)\s*(?:장|개|가지|컷|시안|버전)/u, 2],
-    [/(?:세|셋|3)\s*(?:장|개|가지|컷|시안|버전)/u, 3],
-    [/(?:네|넷|4)\s*(?:장|개|가지|컷|시안|버전)/u, 4],
-    [/(?:다섯|5)\s*(?:장|개|가지|컷|시안|버전)/u, 5],
-    [/(?:여섯|6)\s*(?:장|개|가지|컷|시안|버전)/u, 6],
-    [/(?:일곱|7)\s*(?:장|개|가지|컷|시안|버전)/u, 7],
-    [/(?:여덟|8)\s*(?:장|개|가지|컷|시안|버전)/u, 8],
+    [/(?:스물네|스물\s*네|이십사)\s*(?:장|개|가지|컷|시안|버전)/u, 24],
+    [/(?:열두|열\s*두|십이)\s*(?:장|개|가지|컷|시안|버전)/u, 12],
+    [/(?:열|열\s*개)\s*(?:장|개|가지|컷|시안|버전)?/u, 10],
+    [/(?:한|하나)\s*(?:장|개|가지|컷|시안|버전)/u, 1],
+    [/(?:두|둘)\s*(?:장|개|가지|컷|시안|버전)/u, 2],
+    [/(?:세|셋)\s*(?:장|개|가지|컷|시안|버전)/u, 3],
+    [/(?:네|넷)\s*(?:장|개|가지|컷|시안|버전)/u, 4],
+    [/(?:다섯)\s*(?:장|개|가지|컷|시안|버전)/u, 5],
+    [/(?:여섯)\s*(?:장|개|가지|컷|시안|버전)/u, 6],
+    [/(?:일곱)\s*(?:장|개|가지|컷|시안|버전)/u, 7],
+    [/(?:여덟)\s*(?:장|개|가지|컷|시안|버전)/u, 8],
+    [/(?:아홉)\s*(?:장|개|가지|컷|시안|버전)/u, 9],
 ];
 const ENGLISH_COUNT_WORDS = [
-    [/\b(?:one|1)\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 1],
-    [/\b(?:two|2)\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 2],
-    [/\b(?:three|3)\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 3],
-    [/\b(?:four|4)\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 4],
-    [/\b(?:five|5)\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 5],
-    [/\b(?:six|6)\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 6],
-    [/\b(?:seven|7)\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 7],
-    [/\b(?:eight|8)\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 8],
+    [/\btwenty[-\s]?four\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 24],
+    [/\btwelve\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 12],
+    [/\bten\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 10],
+    [/\bone\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 1],
+    [/\btwo\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 2],
+    [/\bthree\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 3],
+    [/\bfour\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 4],
+    [/\bfive\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 5],
+    [/\bsix\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 6],
+    [/\bseven\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 7],
+    [/\beight\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 8],
+    [/\bnine\s*(?:image|variant|version|option|candidate|shot|render)?s?\b/iu, 9],
 ];
+const NUMERIC_COUNT_PATTERN = /(?:^|\b)(\d{1,3})\s*(?:장|개|가지|컷|시안|버전|image|images|variant|variants|version|versions|option|options|candidate|candidates|shot|shots|render|renders)(?:\b|$)/iu;
 export function deriveAgentGenerationPlan({ prompt, settings, command = null }) {
     if (command?.name === "question" || command?.name === "help") {
         return {
@@ -32,6 +42,7 @@ export function deriveAgentGenerationPlan({ prompt, settings, command = null })
             reason: command.name === "help" ? "Slash help answered without image generation." : "Question command answered without image generation.",
             command: command.name,
             assistantText: null,
+            sourceImagePolicy: null,
         };
     }
     if (isVideoIntent(prompt)) {
@@ -45,6 +56,7 @@ export function deriveAgentGenerationPlan({ prompt, settings, command = null })
             reason: "Video generation detected from prompt keywords.",
             command: command?.name ?? null,
             assistantText: null,
+            sourceImagePolicy: "auto",
         };
     }
     const variantDecision = decideVariantCount(prompt, settings, command);
@@ -60,18 +72,41 @@ export function deriveAgentGenerationPlan({ prompt, settings, command = null })
         reason: variantDecision.reason,
         command: command?.name ?? null,
         assistantText: null,
+        sourceImagePolicy: inferSourceImagePolicy(prompt, prompts.length > 1 ? "fanout" : "single"),
     };
 }
 export function normalizeAgentGenerationPlan(prompt, value, settings) {
     const input = value && typeof value === "object" ? value : {};
     const prompts = cleanPromptArray(input.prompts);
+    // errors/question modes legitimately carry no generation prompts — they
+    // must be resolved before the empty-prompts fallback re-derives a regex plan.
+    if (input.mode === "errors" || input.mode === "question") {
+        return {
+            mode: input.mode,
+            prompts: [],
+            requestedVariants: 0,
+            plannedVariants: 0,
+            plannedParallelism: 0,
+            source: cleanPlanSource(input.source),
+            reason: cleanReason(input.reason, input.mode === "errors" ? "User asked about recent generation failures." : "User asked a question answered without generation."),
+            command: cleanCommandName(input.command),
+            assistantText: typeof input.assistantText === "string" ? input.assistantText : null,
+            videoParams: null,
+            sourceImagePolicy: null,
+        };
+    }
     if (prompts.length === 0)
         return deriveAgentGenerationPlan({ prompt, settings, command: cleanCommand(input.command) });
     const plannedVariants = cleanCount(input.plannedVariants, prompts.length, 0, HARD_MAX_VARIANTS);
     const requestedParallelism = cleanCount(input.plannedParallelism, settings.parallelism, 1, HARD_MAX_VARIANTS);
     const plannedParallelism = resolvePlannedParallelism({ ...settings, parallelism: requestedParallelism }, plannedVariants, null);
+    const mode = input.mode === "question"
+        ? "question"
+        : input.mode === "video"
+            ? "video"
+            : prompts.length > 1 ? "fanout" : "single";
     return {
-        mode: input.mode === "question" ? "question" : input.mode === "video" ? "video" : prompts.length > 1 ? "fanout" : "single",
+        mode,
         prompts,
         requestedVariants: cleanCount(input.requestedVariants, plannedVariants, 0, HARD_MAX_VARIANTS),
         plannedVariants,
@@ -80,8 +115,24 @@ export function normalizeAgentGenerationPlan(prompt, value, settings) {
         reason: cleanReason(input.reason, prompts.length > 1 ? "Stored fanout plan." : "Stored single-image plan."),
         command: cleanCommandName(input.command),
         assistantText: typeof input.assistantText === "string" ? input.assistantText : null,
+        videoParams: mode === "video" ? cleanVideoParams(input.videoParams) : null,
+        sourceImagePolicy: cleanSourceImagePolicy(input.sourceImagePolicy) ?? inferSourceImagePolicy(prompt, mode),
     };
 }
+function inferSourceImagePolicy(prompt, mode) {
+    if (mode === "question" || mode === "errors")
+        return null;
+    if (mode === "video")
+        return "auto";
+    const text = prompt.trim();
+    if (/(?:i2i\s*말고|image-to-image\s*말고|새로운\s*방식|새로|별도|독립|from\s+scratch|new\s+image|fresh\s+image|without\s+(?:reference|refs?)|no\s+(?:reference|refs?))/iu.test(text)) {
+        return "none";
+    }
+    if (/(?:이\s*이미지|현재\s*이미지|방금\s*(?:그거|그\s*이미지|이미지)|참조|레퍼런스|reference|refs?|i2i|image-to-image|수정|편집|바꿔|변형|유지(?:해서)?|그걸|그거)/iu.test(text)) {
+        return "current";
+    }
+    return "none";
+}
 function decideVariantCount(prompt, settings, command) {
     if (command?.name === "variants" || command?.name === "generate") {
         const count = clampCount(command.value ?? AMBIGUOUS_MULTI_VARIANTS, HARD_MAX_VARIANTS);
@@ -114,6 +165,11 @@ function decideVariantCount(prompt, settings, command) {
 }
 function inferRequestedVariantCount(prompt) {
     const text = prompt.trim();
+    const numericMatch = NUMERIC_COUNT_PATTERN.exec(text);
+    if (numericMatch) {
+        const count = Math.max(1, Math.trunc(Number.parseInt(numericMatch[1] ?? "", 10) || 1));
+        return { count, reason: `User request explicitly implies ${count} variant${count === 1 ? "" : "s"}.` };
+    }
     for (const [pattern, count] of [...KOREAN_COUNT_WORDS, ...ENGLISH_COUNT_WORDS]) {
         if (pattern.test(text)) {
             return { count, reason: `User request explicitly implies ${count} variant${count === 1 ? "" : "s"}.` };
@@ -156,10 +212,31 @@ function cleanPlanSource(value) {
         value === "auto-request" ||
         value === "manual-settings" ||
         value === "slash-command" ||
-        value === "question-command")
+        value === "question-command" ||
+        value === "llm-planner")
         return value;
     return "auto-default";
 }
+function cleanSourceImagePolicy(value) {
+    if (value === "auto" || value === "none" || value === "current")
+        return value;
+    return null;
+}
+export function cleanVideoParams(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const input = value;
+    const params = {};
+    const duration = typeof input.duration === "number" ? input.duration : Number(input.duration);
+    if (Number.isFinite(duration))
+        params.duration = Math.max(1, Math.min(15, Math.round(duration)));
+    if (input.resolution === "480p" || input.resolution === "720p")
+        params.resolution = input.resolution;
+    if (typeof input.aspectRatio === "string" && /^(auto|16:9|9:16|4:3|3:4|3:2|2:3|1:1)$/.test(input.aspectRatio)) {
+        params.aspectRatio = input.aspectRatio;
+    }
+    return Object.keys(params).length > 0 ? params : null;
+}
 function cleanCommandName(value) {
     if (value === "question" ||
         value === "help" ||

package/lib/agentImageVideoGen.js

@@ -0,0 +1,281 @@
+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, 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++) {
+        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 grokPlannerModel = isAgentGrokPlannerModel(options.model) ? options.model : undefined;
+    const providerOptions = resolveProviderOptions(ctx, {
+        provider: options.provider ?? "oauth",
+        rawModel: grokPlannerModel ? undefined : 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, 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,
+                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, 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) {
+        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) {
+        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 */ }
+        }
+    }
+    // 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,
+        sourceImage,
+        duration: videoParams.duration ?? 5,
+        resolution: videoParams.resolution ?? "480p",
+        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();
+    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: 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");
+    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(),
+    });
+}

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();