@aexol/spectral 0.9.231 → 0.9.240

package/dist/extensions/logic-trace.js

@@ -26,7 +26,7 @@
  * generic helpers from `../memory/` and never writes any memory state.
  */
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { isAbsolute, join } from "node:path";
 import { Type } from "../sdk/ai/index.js";
 import { agentLoop, uuidv7, } from "../sdk/agent-core/index.js";
 import { getAgentDir, } from "../sdk/coding-agent/index.js";
@@ -776,6 +776,7 @@ async function attemptLogicTraceSync(deps) {
 // ---------------------------------------------------------------------------
 const LOGIC_TRACE_READ_TOOL_NAME = "remote_logic_trace_read";
 const LOGIC_TRACE_WRITE_TOOL_NAME = "remote_logic_trace_write";
+const LOGIC_TRACE_WRITE_FILE_TOOL_NAME = "remote_logic_trace_write_file";
 const UNBOUND_TEXT = "No Aexol Studio project binding found in this directory.\n" +
     "Use local_bind_project to link this directory to a Studio project (then read/write logic.aexol), " +
     "or `spectral bind <project-id>` from the terminal.";
@@ -841,7 +842,9 @@ function buildWriteTool(ensureBackend) {
         name: LOGIC_TRACE_WRITE_TOOL_NAME,
         label: "Write Logic Trace",
         description: `Manually upsert the ONE ${LOGIC_TRACE_REMOTE_PATH} file in the bound Aexol Studio project with a COMPLETE .aexol spec. ` +
-            `Merge, never append-only: read it first, then write the full updated file. Refresh it after meaningful business-logic changes.`,
+            `Merge, never append-only: read it first, then write the full updated file. Refresh it after meaningful business-logic changes. ` +
+            `For large specs (roughly >150 lines) the inline \`content\` argument risks provider gateway timeouts while the whole merged spec streams as a single tool call — ` +
+            `instead write the merged spec to a local file (e.g. \`.aexol/logic.draft.aexol\`) and call ${LOGIC_TRACE_WRITE_FILE_TOOL_NAME}.`,
         promptSnippet: `Use ${LOGIC_TRACE_WRITE_TOOL_NAME}(content, reason) to fully regenerate ${LOGIC_TRACE_REMOTE_PATH} (the ONE business-logic spec in the bound Studio project) after meaningful business-logic changes.`,
         promptGuidelines: [
             `There is EXACTLY ONE logic file per project: ${LOGIC_TRACE_REMOTE_PATH}. Never create extra spec files; never append changelogs into it.`,
@@ -849,87 +852,207 @@ function buildWriteTool(ensureBackend) {
             "Only full-spec writes; this tool upserts (updates the existing file or creates it when missing) and never deletes it.",
             "Use it after meaningful business-logic changes (new/changed types, enums, roles, workflows, agents); automatic refresh handles the rest.",
             "The tool returns ✓ when the complete spec parses, and an Error with parser diagnostics when it does not.",
+            `For large specs (roughly >150 lines) the inline \`content\` argument risks provider timeouts — write the merged spec to a local file (e.g. \`.aexol/logic.draft.aexol\`) and use ${LOGIC_TRACE_WRITE_FILE_TOOL_NAME} instead.`,
         ],
         parameters: WriteSchema,
         async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-            // Same explicit retry semantics as remote_logic_trace_read: this is
-            // the agent deliberately acting, so a memoized bootstrap failure may
-            // be re-attempted (and is unlocked on success).
-            const backend = await ensureBackend(ctx.cwd, { retry: true });
-            if (!backend.ok) {
-                return textResult(`Aexol backend unavailable: ${backend.message}`, true);
-            }
-            const binding = await refreshBindingForCwd(ctx.cwd);
-            if (!binding)
-                return textResult(UNBOUND_TEXT, true);
-            // EXPLICIT agent action: the content the agent deliberately wrote is
-            // stored verbatim (trim only) — the redaction pass is reserved for
-            // automatically drafted sync content, not for the agent's own
-            // deliberate full-spec write.
-            const content = (params.content ?? "").trim();
-            if (!content) {
-                return textResult("Error: content (the complete .aexol spec) is required.", true);
-            }
-            // Parser-backed gate BEFORE any remote call: invalid content must
-            // neither mutate the cloud file nor even probe the project-file
-            // listing, so writes fail fast with parser diagnostics instead of
-            // storing a spec the Aexol toolchain cannot read.
-            const validation = validateLogicTraceSpec(content);
-            if (!validation.ok) {
-                return textResult("Error: content is not a valid .aexol spec.\n" + formatSpecErrors(validation), true);
+            return upsertLogicTraceFromAgent(ensureBackend, {
+                cwd: ctx.cwd,
+                content: params.content ?? "",
+                reason: params.reason ?? "",
+                hasUI: ctx.hasUI,
+                ui: ctx.ui,
+            });
+        },
+    };
+}
+/**
+ * Full manual-write flow shared by `remote_logic_trace_write`: resolve the
+ * bound backend, then run the shared upsert. Behavior and result messages are
+ * byte-identical to the pre-refactor single-tool implementation.
+ */
+async function upsertLogicTraceFromAgent(ensureBackend, input) {
+    const bound = await resolveBoundBackend(ensureBackend, input.cwd);
+    if (!bound.ok)
+        return bound.result;
+    return upsertLogicTrace({
+        backend: bound.backend,
+        binding: bound.binding,
+        cwd: input.cwd,
+        content: input.content,
+        reason: input.reason,
+        hasUI: input.hasUI,
+        ui: input.ui,
+    });
+}
+/**
+ * Shared prelude for the manual write tools: same explicit retry semantics as
+ * remote_logic_trace_read — this is the agent deliberately acting, so a
+ * memoized bootstrap failure may be re-attempted (and is unlocked on success).
+ */
+async function resolveBoundBackend(ensureBackend, cwd) {
+    const backend = await ensureBackend(cwd, { retry: true });
+    if (!backend.ok) {
+        return { ok: false, result: textResult(`Aexol backend unavailable: ${backend.message}`, true) };
+    }
+    const binding = await refreshBindingForCwd(cwd);
+    if (!binding)
+        return { ok: false, result: textResult(UNBOUND_TEXT, true) };
+    return { ok: true, backend, binding };
+}
+/**
+ * Shared tail for the manual write tools: trim → parser gate → mandatory
+ * list → update-or-create upsert → ack. Both `remote_logic_trace_write` and
+ * `remote_logic_trace_write_file` funnel through here so their remote
+ * behavior and result messages stay byte-identical.
+ */
+async function upsertLogicTrace(input) {
+    // EXPLICIT agent action: the content the agent deliberately wrote is
+    // stored verbatim (trim only) — the redaction pass is reserved for
+    // automatically drafted sync content, not for the agent's own
+    // deliberate full-spec write.
+    const content = input.content.trim();
+    if (!content) {
+        return textResult("Error: content (the complete .aexol spec) is required.", true);
+    }
+    // Parser-backed gate BEFORE any remote call: invalid content must
+    // neither mutate the cloud file nor even probe the project-file
+    // listing, so writes fail fast with parser diagnostics instead of
+    // storing a spec the Aexol toolchain cannot read.
+    const validation = validateLogicTraceSpec(content);
+    if (!validation.ok) {
+        return textResult("Error: content is not a valid .aexol spec.\n" + formatSpecErrors(validation), true);
+    }
+    try {
+        // Manual upsert: list (mandatory — create silently no-ops when the
+        // path already exists) then update-or-create. No LLM, no dedupe.
+        const remote = await fetchRemoteLogicFile(input.backend.client, input.binding.projectId, input.binding.teamId);
+        const state = stateFor(input.cwd);
+        state.remote = {
+            id: remote.id,
+            contentHash: remote.content !== undefined ? hashId(remote.content) : undefined,
+        };
+        // Every remote_* call carries the binding ids (projectId + teamId
+        // when present) so team access resolves to the BOUND project, not
+        // to the first team membership of the user token.
+        const teamArg = input.binding.teamId ? { teamId: input.binding.teamId } : {};
+        let id;
+        if (remote.id) {
+            const res = await input.backend.client.callTool("remote_update_project_file", {
+                id: remote.id,
+                content,
+                projectId: input.binding.projectId,
+                ...teamArg,
+            });
+            if (res.isError)
+                return textResult(`Failed to update ${LOGIC_TRACE_REMOTE_PATH}: ${toolResultText(res)}`, true);
+            id = remote.id;
+        }
+        else {
+            const res = await input.backend.client.callTool("remote_create_project_file", {
+                path: LOGIC_TRACE_REMOTE_PATH,
+                content,
+                projectId: input.binding.projectId,
+                ...teamArg,
+            });
+            if (res.isError)
+                return textResult(`Failed to create ${LOGIC_TRACE_REMOTE_PATH}: ${toolResultText(res)}`, true);
+            id = extractCreatedFileId(res.content);
+        }
+        const contentHash = hashId(content);
+        state.remote = { id: id ?? null, contentHash };
+        notifyWith({ hasUI: input.hasUI, ui: input.ui }, `logic.aexol updated in project ${input.binding.name ?? input.binding.projectId}`);
+        return textResult(`✓ ${LOGIC_TRACE_REMOTE_PATH} ${remote.id ? "updated" : "created"} ` +
+            `(project ${input.binding.name ?? input.binding.projectId}, reason: ${input.reason.trim()}).` +
+            (input.ackSuffix ?? ""));
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return textResult(`Failed to write ${LOGIC_TRACE_REMOTE_PATH}: ${msg}`, true);
+    }
+}
+/**
+ * The `-file` variant of the manual write: reads the COMPLETE merged spec
+ * from a LOCAL file instead of a giant inline `content` argument, so agents
+ * pushing large specs avoid the provider gateway timeouts that streaming one
+ * huge tool-call argument can trigger. Validation + upsert are identical to
+ * `remote_logic_trace_write` (same helpers, same messages).
+ */
+function buildWriteFileTool(ensureBackend) {
+    const WriteFileSchema = Type.Object({
+        path: Type.String({
+            minLength: 1,
+            description: "Path to a LOCAL file holding the COMPLETE merged .aexol spec (e.g. `.aexol/logic.draft.aexol`). Relative to the working directory or absolute.",
+        }),
+        reason: Type.String({
+            minLength: 1,
+            description: "Why this full-spec update is needed (echoed in the ack).",
+        }),
+    });
+    return {
+        name: LOGIC_TRACE_WRITE_FILE_TOOL_NAME,
+        label: "Write Logic Trace From File",
+        description: `Manually upsert the ONE ${LOGIC_TRACE_REMOTE_PATH} file in the bound Aexol Studio project from a LOCAL file on disk. ` +
+            `Reads the file, validates it with the same parser gate as ${LOGIC_TRACE_WRITE_TOOL_NAME}, then performs the identical list-first create/update upsert. ` +
+            `Merge, never append-only: read ${LOGIC_TRACE_REMOTE_PATH} first, write the FULL merged spec to a local file (e.g. \`.aexol/logic.draft.aexol\`), then call this tool. ` +
+            `PREFERRED for large specs (roughly >150 lines): passing the spec as a local file avoids the provider gateway timeouts a giant inline \`content\` argument risks while streaming a single tool call.`,
+        promptSnippet: `Use ${LOGIC_TRACE_WRITE_FILE_TOOL_NAME}(path, reason) to upsert ${LOGIC_TRACE_REMOTE_PATH} (the ONE business-logic spec in the bound Studio project) from a local .aexol file — the preferred path for large specs (>150 lines).`,
+        promptGuidelines: [
+            `There is EXACTLY ONE logic file per project: ${LOGIC_TRACE_REMOTE_PATH}. Never create extra spec files; never append changelogs into it.`,
+            `Always ${LOGIC_TRACE_READ_TOOL_NAME} before writing, and write the FULL merged spec to the local file — not a diff, not an appendix.`,
+            "Only full-spec writes; this tool upserts (updates the existing file or creates it when missing) and never deletes it.",
+            `The tool returns ✓ (with the source file and its line count) when the complete spec parses, and an Error with parser diagnostics when it does not.`,
+            `For large specs (roughly >150 lines) prefer this file-based write: giant inline \`content\` arguments on ${LOGIC_TRACE_WRITE_TOOL_NAME} risk provider timeouts.`,
+        ],
+        parameters: WriteFileSchema,
+        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+            const rawPath = (params.path ?? "").trim();
+            if (!rawPath) {
+                return textResult("Error: path (the local .aexol file holding the complete spec) is required.", true);
             }
+            const filePath = isAbsolute(rawPath) ? rawPath : join(ctx.cwd, rawPath);
+            // Same explicit retry semantics as the other manual tools (see
+            // resolveBoundBackend).
+            const bound = await resolveBoundBackend(ensureBackend, ctx.cwd);
+            if (!bound.ok)
+                return bound.result;
+            let content;
             try {
-                // Manual upsert: list (mandatory — create silently no-ops when the
-                // path already exists) then update-or-create. No LLM, no dedupe.
-                const remote = await fetchRemoteLogicFile(backend.client, binding.projectId, binding.teamId);
-                const state = stateFor(ctx.cwd);
-                state.remote = {
-                    id: remote.id,
-                    contentHash: remote.content !== undefined ? hashId(remote.content) : undefined,
-                };
-                // Every remote_* call carries the binding ids (projectId + teamId
-                // when present) so team access resolves to the BOUND project, not
-                // to the first team membership of the user token.
-                const teamArg = binding.teamId ? { teamId: binding.teamId } : {};
-                let id;
-                if (remote.id) {
-                    const res = await backend.client.callTool("remote_update_project_file", {
-                        id: remote.id,
-                        content,
-                        projectId: binding.projectId,
-                        ...teamArg,
-                    });
-                    if (res.isError)
-                        return textResult(`Failed to update ${LOGIC_TRACE_REMOTE_PATH}: ${toolResultText(res)}`, true);
-                    id = remote.id;
-                }
-                else {
-                    const res = await backend.client.callTool("remote_create_project_file", {
-                        path: LOGIC_TRACE_REMOTE_PATH,
-                        content,
-                        projectId: binding.projectId,
-                        ...teamArg,
-                    });
-                    if (res.isError)
-                        return textResult(`Failed to create ${LOGIC_TRACE_REMOTE_PATH}: ${toolResultText(res)}`, true);
-                    id = extractCreatedFileId(res.content);
-                }
-                const contentHash = hashId(content);
-                state.remote = { id: id ?? null, contentHash };
-                notifyWith({ hasUI: ctx.hasUI, ui: ctx.ui }, `logic.aexol updated in project ${binding.name ?? binding.projectId}`);
-                return textResult(`✓ ${LOGIC_TRACE_REMOTE_PATH} ${remote.id ? "updated" : "created"} ` +
-                    `(project ${binding.name ?? binding.projectId}, reason: ${params.reason.trim()}).`);
+                content = readFileSync(filePath, "utf-8");
             }
             catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return textResult(`Failed to write ${LOGIC_TRACE_REMOTE_PATH}: ${msg}`, true);
+                const code = err.code;
+                const detail = code === "ENOENT"
+                    ? "file does not exist"
+                    : code === "EISDIR"
+                        ? "path is a directory, not a file"
+                        : code === "EACCES" || code === "EPERM"
+                            ? "file is not readable"
+                            : `failed to read (${code ?? "unknown error"})`;
+                return textResult(`Error: cannot read "${rawPath}": ${detail}.`, true);
+            }
+            if (content.charCodeAt(0) === 0xfeff)
+                content = content.slice(1); // strip BOM
+            if (!content.trim()) {
+                return textResult(`Error: "${rawPath}" is empty — no .aexol spec content to write.`, true);
             }
+            const lineCount = content.split("\n").length;
+            return upsertLogicTrace({
+                backend: bound.backend,
+                binding: bound.binding,
+                cwd: ctx.cwd,
+                content,
+                reason: params.reason ?? "",
+                hasUI: ctx.hasUI,
+                ui: ctx.ui,
+                ackSuffix: ` Source: ${filePath} (${lineCount} lines).`,
+            });
         },
     };
 }
 /**
  * Logic trace extension entry point: automatic refresh hooks
- * (`turn_end`, `session_before_compact`) plus the two agent tools.
+ * (`turn_end`, `session_before_compact`) plus the three agent tools.
  */
 export function logicTraceExtension(ext, options = {}) {
     const draftRunner = options.draftRunner ?? runLogicTraceDraft;
@@ -992,6 +1115,12 @@ export function logicTraceExtension(ext, options = {}) {
     catch (err) {
         process.stderr.write(`[logic-trace] Failed to register ${LOGIC_TRACE_WRITE_TOOL_NAME}: ${err instanceof Error ? err.message : String(err)}\n`);
     }
+    try {
+        ext.registerTool(buildWriteFileTool(ensureBackend));
+    }
+    catch (err) {
+        process.stderr.write(`[logic-trace] Failed to register ${LOGIC_TRACE_WRITE_FILE_TOOL_NAME}: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
     ext.on("session_start", async (_event, ctx) => {
         const config = loadLogicTraceConfig(ctx.cwd);
         if (config.passive)

package/dist/extensions/video-generation/index.d.ts

@@ -0,0 +1,3 @@
+import type { ExtensionAPI } from "../../sdk/coding-agent/index.js";
+export default function videoGenerationExtension(ext: ExtensionAPI): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/video-generation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/video-generation/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAmB,YAAY,EAAkB,MAAM,iCAAiC,CAAC;AA+NrG,wBAA8B,wBAAwB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAsGvF"}

package/dist/extensions/video-generation/index.js

@@ -0,0 +1,299 @@
+import { Type } from "typebox";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { extname, join, resolve } from "node:path";
+import { generateVideos, getVideoModel, getVideoModels } from "../../sdk/ai/index.js";
+import { base64FromImageData } from "../../sdk/ai/utils/image-source.js";
+import { uploadImage } from "../../backend/generated-images.js";
+// Backend routing (backendUrl + machineJwt) is resolved the same way the
+// image tool gets it, so video generation routes through the backend proxy
+// (POST /video/generation) using the backend's own OPENROUTER_API_KEY and
+// falls back to direct OpenRouter when the proxy is unavailable or the CLI
+// is not logged in.
+import { resolveBackendRouting } from "../../backend/machine-routing.js";
+const frameImageSchema = Type.Union([
+    Type.String({
+        description: "Path to a frame image file (relative to the project working directory or absolute).",
+    }),
+    Type.Object({
+        data: Type.String({ description: "Frame image as raw base64 or data URL." }),
+        mimeType: Type.Optional(Type.String({ default: "image/png", description: "Frame image MIME type." })),
+    }, { description: "Frame image provided inline as base64 data." }),
+    Type.Object({
+        path: Type.String({ description: "Path to a frame image file (relative to the project working directory or absolute)." }),
+        mimeType: Type.Optional(Type.String({ description: "Frame image MIME type. Defaults to the type detected from the file extension." })),
+    }, { description: "Frame image provided as a file path." }),
+]);
+const videoGenerateSchema = Type.Object({
+    prompt: Type.String({ description: "Text prompt describing the video to generate." }),
+    model: Type.Optional(Type.String({ default: "google/veo-3.1", description: "OpenRouter video model id." })),
+    duration: Type.Optional(Type.Number({ description: "Clip duration in seconds (model-dependent, e.g. 4-10 for Veo)." })),
+    resolution: Type.Optional(Type.String({ description: "Resolution tier, e.g. 480p, 720p, 768p, 1080p." })),
+    aspect_ratio: Type.Optional(Type.String({ description: "Aspect ratio, e.g. 16:9, 9:16, 1:1." })),
+    size: Type.Optional(Type.String({ description: "OpenRouter size shorthand, e.g. 1280x720." })),
+    generate_audio: Type.Optional(Type.Boolean({ default: true, description: "Whether to generate audio with the video (model-dependent)." })),
+    seed: Type.Optional(Type.Number()),
+    frame_images: Type.Optional(Type.Array(frameImageSchema, { description: "Optional frame images for image-to-video generation. Each element may be a file path string, an object { data: <base64 or data URL>, mimeType?: string }, or an object { path: <file path>, mimeType?: string }." })),
+});
+function videoModel(modelId) {
+    const exact = getVideoModel("openrouter", modelId);
+    if (exact)
+        return exact;
+    return getVideoModels("openrouter").find((model) => model.id === modelId);
+}
+const GENERATED_VIDEOS_DIR = ".generated_videos";
+const VIDEO_MIME_TYPE = "video/mp4";
+function mimeTypeForPath(filePath) {
+    switch (extname(filePath).toLowerCase()) {
+        case ".png":
+            return "image/png";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".webp":
+            return "image/webp";
+        case ".gif":
+            return "image/gif";
+        default:
+            return "image/png";
+    }
+}
+function readFrameImageFromPath(filePath, mimeType) {
+    let data;
+    try {
+        data = readFileSync(filePath).toString("base64");
+    }
+    catch (error) {
+        const code = error?.code;
+        if (code === "ENOENT") {
+            throw new Error(`Frame image file does not exist: ${filePath}`);
+        }
+        if (code === "EACCES" || code === "EPERM") {
+            throw new Error(`Permission denied while reading frame image: ${filePath}`);
+        }
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to read frame image: ${filePath} (${detail})`);
+    }
+    return {
+        type: "image",
+        data,
+        mimeType: mimeType ?? mimeTypeForPath(filePath),
+    };
+}
+function normalizeFrameImages(frames, cwd) {
+    if (!frames)
+        return [];
+    return frames.map((frame, index) => {
+        if (typeof frame === "string") {
+            return readFrameImageFromPath(resolve(cwd, frame), undefined);
+        }
+        if (typeof frame !== "object" || frame === null) {
+            throw new Error(`Invalid frame image at index ${index}: expected a file path string or an object with "data" or "path".`);
+        }
+        const reference = frame;
+        if (typeof reference.data === "string" && typeof reference.path === "string") {
+            throw new Error(`Invalid frame image at index ${index}: provide only one of "data" (inline base64) or "path" (file path), not both.`);
+        }
+        if (typeof reference.data === "string") {
+            return {
+                type: "image",
+                data: reference.data,
+                mimeType: reference.mimeType ?? "image/png",
+            };
+        }
+        if (typeof reference.path === "string") {
+            return readFrameImageFromPath(resolve(cwd, reference.path), reference.mimeType);
+        }
+        throw new Error(`Invalid frame image at index ${index}: expected a file path string or an object with "data" or "path".`);
+    });
+}
+function slugFromPrompt(prompt) {
+    const slug = prompt
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 40);
+    return slug || "video";
+}
+function timestamp() {
+    return new Date().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
+}
+/**
+ * Save a locally-downloaded video (direct OpenRouter path) under
+ * `.generated_videos/`. Proxy-path videos have no inline bytes here — the
+ * backend stores them and reports the hosted url instead.
+ */
+function saveGeneratedVideo(video, prompt, cwd) {
+    if (!video.data)
+        return undefined;
+    const dir = join(cwd, GENERATED_VIDEOS_DIR);
+    mkdirSync(dir, { recursive: true });
+    const filename = `${slugFromPrompt(prompt)}-${timestamp()}.mp4`;
+    const filepath = join(dir, filename);
+    writeFileSync(filepath, Buffer.from(base64FromImageData(video.data), "base64"));
+    return filepath;
+}
+function bytesFromVideoData(data) {
+    return new Uint8Array(Buffer.from(base64FromImageData(data), "base64"));
+}
+/**
+ * Make the generated video reachable through a backend URL so the session can
+ * carry a url instead of megabytes of base64. Only applies to videos that
+ * came back as inline bytes (direct OpenRouter fallback path) — proxy-path
+ * videos are already stored server-side. Best effort by design: an upload
+ * failure must not fail video generation; the caller falls back to the local
+ * file + inline bytes and annotates the result text.
+ */
+async function hostGeneratedVideo(video, routing, signal) {
+    if (video.url && video.videoId)
+        return { hosted: { url: video.url, videoId: video.videoId } };
+    if (!routing)
+        return { error: "not routed through the backend (video kept local)" };
+    if (!video.data)
+        return { error: "video has no inline bytes (kept local)" };
+    try {
+        const result = await uploadImage({
+            backendUrl: routing.backendUrl,
+            token: routing.machineJwt,
+            bytes: bytesFromVideoData(video.data),
+            contentType: video.mimeType || VIDEO_MIME_TYPE,
+            kind: "video",
+            signal,
+        });
+        return { result };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function isHosted(outcome) {
+    return Boolean(outcome.hosted ?? outcome.result);
+}
+function hostedUrl(outcome) {
+    return outcome.hosted?.url ?? outcome.result.url;
+}
+function hostedId(outcome) {
+    return outcome.hosted?.videoId ?? outcome.result.imageId;
+}
+function resultText(model, credits, savedPath, outcome) {
+    const lines = ["✓ Generated 1 video", `Model: ${model}`];
+    lines.push(`Cost: ${credits ?? 0} credits`);
+    if (savedPath)
+        lines.push(`Saved: ${savedPath}`);
+    else if (!isHosted(outcome))
+        lines.push("Saved: (no local copy — see errors below)");
+    if (isHosted(outcome)) {
+        lines.push(`Hosted: ${hostedUrl(outcome)}`);
+    }
+    if (!isHosted(outcome) && outcome.error) {
+        // Explicit annotation: the video bytes were NOT uploaded, so the video
+        // exists only as the local file (path above); remote URL unavailable.
+        lines.push(`⚠️ The video could not be uploaded to cloud storage and exists only locally; remote URL unavailable.`);
+        lines.push(`- ${outcome.error}`);
+    }
+    return lines.join("\n");
+}
+export default async function videoGenerationExtension(ext) {
+    const tool = {
+        name: "video_generate",
+        label: "Generate Video",
+        description: "Generate videos through OpenRouter's Videos API and save them to .generated_videos/ in the project. " +
+            "Returns the saved file path and hosted URL so the user can view the generated video. " +
+            "Supports text-to-video and image-to-video via optional frame images. " +
+            "Models cannot read video — the result carries a text summary; the video block is for the user's UI.",
+        promptSnippet: "`video_generate { prompt, model?, duration?, aspect_ratio?, resolution?, frame_images? }` — generate video content (mp4, saved to .generated_videos/)",
+        parameters: videoGenerateSchema,
+        async execute(_toolCallId, params, signal, onUpdate, ctx) {
+            const input = params;
+            const modelId = input.model ?? "google/veo-3.1";
+            const model = videoModel(modelId);
+            if (!model) {
+                return {
+                    content: [{ type: "text", text: `❌ Unknown OpenRouter video model: ${modelId}` }],
+                    details: { isError: true, model: modelId },
+                };
+            }
+            const context = {
+                input: [
+                    { type: "text", text: input.prompt },
+                    ...normalizeFrameImages(input.frame_images, ctx.cwd),
+                ],
+            };
+            // Route through the backend video proxy (POST /video/generation)
+            // using the machine JWT, mirroring image generation. Falls back to
+            // direct OpenRouter (submit + poll + download with the local
+            // OPENROUTER_API_KEY) when routing cannot be resolved or the proxy
+            // is unavailable.
+            const routing = await resolveBackendRouting();
+            const response = await generateVideos(model, context, {
+                ...input,
+                signal,
+                ...(routing ? { backendUrl: routing.backendUrl, apiKey: routing.machineJwt } : {}),
+                // Surface long-poll progress to the UI as partial tool results.
+                onProgress: (message) => {
+                    try {
+                        onUpdate?.({
+                            content: [{ type: "text", text: message }],
+                            details: { progress: message, model: model.id },
+                        });
+                    }
+                    catch {
+                        // Progress callbacks must never break generation.
+                    }
+                },
+            });
+            if (response.stopReason !== "stop") {
+                const message = response.errorMessage ?? "Video generation failed";
+                return {
+                    content: [{ type: "text", text: `❌ ${message}` }],
+                    details: { isError: true, model: model.id, stopReason: response.stopReason, errorMessage: message },
+                };
+            }
+            const video = response.output.find((item) => item.type === "video");
+            if (!video) {
+                return {
+                    content: [{ type: "text", text: "❌ Video generation returned no video" }],
+                    details: { isError: true, model: model.id },
+                };
+            }
+            // Local copy first — for videos that actually came back as bytes
+            // (direct OpenRouter fallback). Proxy-path videos have no `data`
+            // here, so nothing is written and the hosted url is reported.
+            const savedPath = saveGeneratedVideo(video, input.prompt, ctx.cwd);
+            const outcome = await hostGeneratedVideo(video, routing, signal);
+            // Swap base64 for the hosted URL when possible: the session keeps
+            // `{ url, videoId }` and avoids megabytes of base64. Videos that
+            // failed to upload keep their inline bytes (fallback, annotated in
+            // the result text).
+            const block = isHosted(outcome)
+                ? {
+                    type: "video",
+                    url: hostedUrl(outcome),
+                    videoId: hostedId(outcome),
+                    mimeType: video.mimeType,
+                }
+                : video;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: resultText(response.model, response.usage?.credits, savedPath, outcome),
+                    },
+                    block,
+                ],
+                details: {
+                    isError: false,
+                    model: response.model,
+                    count: 1,
+                    usage: response.usage,
+                    savedPath,
+                    videoId: isHosted(outcome) ? hostedId(outcome) : undefined,
+                    url: isHosted(outcome) ? hostedUrl(outcome) : undefined,
+                },
+            };
+        },
+    };
+    ext.registerTool(tool);
+    process.stderr.write("[video-generation] Registered video_generate tool.\n");
+}

package/dist/generated/zeus/const.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../../src/generated/zeus/const.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAC,GAAG,CA0zB5C,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAC,GAAG,CAumC1C,CAAA;AAED,eAAO,MAAM,GAAG;;;;CAIf,CAAA"}
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../../src/generated/zeus/const.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAC,GAAG,CAm0B5C,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAC,GAAG,CA4nC1C,CAAA;AAED,eAAO,MAAM,GAAG;;;;CAIf,CAAA"}