corent-mcp 0.8.1 → 0.10.0

package/dist/server.js

@@ -18,7 +18,7 @@ import { z } from "zod";
 import { MEDIA_WIDGET_HTML } from "./widget-html.js";
 import { registerPrompts } from "./prompts.js";
 export const DEFAULT_API_URL = "https://api.corent.tech";
-export const SERVER_VERSION = "0.8.1";
+export const SERVER_VERSION = "0.10.0";
 // Transport resilience, matching the two SDKs: a 429 or 5xx is retried with
 // backoff, but ONLY on calls that carry an Idempotency-Key (or are GETs), so a
 // retry can never buy a second generation.
@@ -84,6 +84,8 @@ function errorCode(err) {
         return "invalid_request";
     if (err.status === 409 || detail.includes("estimate"))
         return "estimate_exceeds_ceiling";
+    if (err.status === 400 && detail.includes("max_cost_cents"))
+        return "estimate_exceeds_ceiling";
     if (err.status === 429)
         return "rate_limited";
     if (err.status === 503)
@@ -170,6 +172,20 @@ export function createCorentServer(config = {}) {
             content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
         };
     }
+    /**
+     * POST /v1/intent answers task_type "film" for anything one clip cannot
+     * deliver (longer than one take, or several characters telling a story), and
+     * /v1/intent/execute will not make a single clip for it. Say so in this
+     * server's own tool names, so the assistant goes to plan_film.
+     */
+    function pointFilmsToPlanFilm(res) {
+        if (res && typeof res === "object" && res.plan?.task_type === "film") {
+            res.next_step = "plan_film";
+            const hint = "This is a film: call plan_film with the same request, show the user the plan and price, then make_film.";
+            res.message = typeof res.message === "string" && res.message ? `${res.message} ${hint}` : hint;
+        }
+        return res;
+    }
     function wrap(fn) {
         return async (args) => {
             try {
@@ -237,6 +253,12 @@ export function createCorentServer(config = {}) {
         // deliverable in it (parity audit 2026-08-30).
         audio: z.array(z.object({ url: z.string() }).passthrough()).optional(),
         progress_percent: z.number().nullable().optional(),
+        // Video jobs (2026-09-12): the PNG of the final frame when return_last_frame
+        // was asked for (pass it as the next clip's image_url), the task the model
+        // ran (auto | reference | edit | extend) and the ACTUAL clip length.
+        last_frame_url: z.string().nullable().optional(),
+        task: z.string().nullable().optional(),
+        duration_s: z.number().nullable().optional(),
         meta: mediaMeta.optional(),
         error: z.string().optional(),
     };
@@ -332,10 +354,73 @@ export function createCorentServer(config = {}) {
         headers: { "Idempotency-Key": idempotencyKey() },
         body: JSON.stringify(args),
     })));
+    // --- Video references (Seedance 2.x, 2026-09-12). The prompt points at
+    // them as "@Image 1", "@Video 1", "@Audio 1" in the order given. The API
+    // enforces three rules; they are mirrored here so a bad combination is
+    // refused before it costs a round trip.
+    const VIDEO_ASPECTS = ["16:9", "9:16", "1:1", "adaptive"];
+    const VIDEO_TASKS = ["auto", "reference", "edit", "extend"];
+    const REAL_FACE_RULE = "The supplier rejects photos of REAL people as references; characters generated inside Corent are accepted.";
+    const videoReferenceFields = {
+        reference_image_urls: z
+            .array(z.string().url())
+            .min(1)
+            .max(30)
+            .optional()
+            .describe("1 to 30 public https images the clip should keep to (a character, a product, a setting). Refer to " +
+            "them in the prompt as @Image 1, @Image 2 in this order. Needs model " +
+            "(corent-seedance-2.5); cannot be combined with image_url/end_image_url. " + REAL_FACE_RULE),
+        reference_video_urls: z
+            .array(z.string().url())
+            .min(1)
+            .max(10)
+            .optional()
+            .describe("1 to 10 public https clips, @Video 1, @Video 2 in the prompt: the source for an edit or extend task, " +
+            "or motion/style to follow. Cannot be combined with image_url/end_image_url."),
+        reference_audio_urls: z
+            .array(z.string().url())
+            .min(1)
+            .max(10)
+            .optional()
+            .describe("1 to 10 public https audio files, @Audio 1 in the prompt, e.g. a track the clip should cut to."),
+        task: z
+            .enum(VIDEO_TASKS)
+            .optional()
+            .describe("What to do with the references (default auto). edit changes something in @Video 1 and keeps its " +
+            "length: omit duration_s. extend continues @Video 1. Both need reference_video_urls and " +
+            "aspect_ratio omitted or adaptive. The prompt must say the intent (add, remove, replace, change; " +
+            "extend, continue)."),
+        return_last_frame: z
+            .boolean()
+            .optional()
+            .describe("true also stores a PNG of the final frame and returns it as last_frame_url on the finished job, so the " +
+            "next clip can start exactly there (pass it as image_url). Use it to chain shots."),
+        output_format: z.enum(["mp4", "mov"]).optional().describe("Delivered file type (default mp4)."),
+    };
+    function checkVideoRules(args, where = "") {
+        const bad = (message) => {
+            throw new CorentApiError(422, { message: `${where}${message}` });
+        };
+        const frames = Boolean(args.image_url || args.end_image_url);
+        const refs = ["reference_image_urls", "reference_video_urls", "reference_audio_urls"].some((k) => Array.isArray(args[k]) && args[k].length > 0);
+        const task = args.task ?? "auto";
+        if (frames && refs) {
+            bad("image_url/end_image_url (first/last frame) cannot be combined with reference_*: pick one way to guide the clip.");
+        }
+        if ((task === "edit" || task === "extend") && !(Array.isArray(args.reference_video_urls) && args.reference_video_urls.length)) {
+            bad(`task ${task} needs at least one reference_video_urls entry: the clip to ${task}.`);
+        }
+        if (task === "edit" && args.duration_s !== undefined) {
+            bad("omit duration_s on an edit task: the edited clip keeps the source clip's length.");
+        }
+        if ((frames || task === "edit" || task === "extend") && args.aspect_ratio !== undefined && args.aspect_ratio !== "adaptive") {
+            bad('aspect_ratio must be omitted or "adaptive" on first/last-frame, edit and extend tasks: the clip keeps the source\'s shape.');
+        }
+    }
     server.registerTool("generate_video", {
         title: "Generate video",
         _meta: toolMeta("Starting video", "Video job started", true),
-        description: "Start a video from a text prompt, or animate a source image. Asynchronous: returns a job id at once; poll get_job until status is completed. Costs tens of cents to a few dollars per clip (premium ~52c, pro ~84c). Failed generations are never billed.",
+        description: "Start a video from text, a source image, or references (@Image 1, @Video 1, @Audio 1 in the prompt). Asynchronous: returns a job id; poll get_job until completed. Premium ~52c, pro ~84c per clip; failed generations are never billed. References need corent-seedance-2.5; photos of real people are rejected as references.",
         inputSchema: {
             prompt: z.string().describe("What to generate, in plain language"),
             tier: z
@@ -347,15 +432,19 @@ export function createCorentServer(config = {}) {
                 .optional()
                 .describe("Optional content style hint, same vocabulary as generate_image"),
             aspect_ratio: z
-                .enum(["16:9", "9:16", "1:1"])
+                .enum(VIDEO_ASPECTS)
                 .optional()
-                .describe("Shape of the clip. OMIT IT when animating a source image: those models render the still's own shape and cannot be given a different one, so naming a shape is refused rather than silently ignored. Omitted for text-to-video means the model's own default (landscape)."),
+                .describe("Shape of the clip. OMIT IT (or pass adaptive) when animating a source image, editing or extending a clip: those keep the source's own shape, so naming another is refused rather than silently ignored. Omitted for text-to-video means the model's own default (landscape)."),
             duration_s: z.number().int().min(1).max(30).optional().describe("Requested duration in seconds"),
             resolution: z
                 .enum(["720p", "1080p", "4k"])
                 .optional()
                 .describe("Pixel resolution (default 720p). Tier-capped: pro allows up to 1080p, max_pro up to 4k; above the tier's cap it is clamped down, never rejected. Higher resolutions cost more (1080p ~2.5x, 4k ~5.5x). GET /v1/tiers lists each tier's menu with prices."),
-            image_url: z.string().url().optional().describe("If set, animates this image instead of pure text-to-video"),
+            image_url: z
+                .string()
+                .url()
+                .optional()
+                .describe("If set, animates this image as the FIRST frame instead of pure text-to-video. Use a previous clip's last_frame_url to continue from it."),
             audio: z
                 .boolean()
                 .optional()
@@ -383,15 +472,105 @@ export function createCorentServer(config = {}) {
             model: z
                 .string()
                 .optional()
-                .describe('Direct model access: pin an exact model by name, e.g. "corent-seedance-2.0" (list_models shows the menu; every name there is spelled corent-*). Bypasses routing -- never substituted; duration and resolution snap to THAT model\'s own menu rather than a tier cap. Mutually exclusive with tier.'),
+                .describe('Direct model access: pin an exact model by name, e.g. "corent-seedance-2.5" (list_models shows the menu; every name there is spelled corent-*). Bypasses routing -- never substituted; duration and resolution snap to THAT model\'s own menu rather than a tier cap. Mutually exclusive with tier. list_models reports supports_reference_images, supports_video_edit, supports_video_extend and supports_last_frame per video model.'),
+            ...videoReferenceFields,
         },
         outputSchema: jobOutput,
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-    }, wrap(async (args) => corent("/v1/videos/generate", {
-        method: "POST",
-        headers: { "Idempotency-Key": idempotencyKey() },
-        body: JSON.stringify(args),
-    })));
+    }, wrap(async (args) => {
+        checkVideoRules(args);
+        return corent("/v1/videos/generate", {
+            method: "POST",
+            headers: { "Idempotency-Key": idempotencyKey() },
+            body: JSON.stringify(args),
+        });
+    }));
+    // --- Two conveniences over generate_video for the clip-in, clip-out asks.
+    // Same endpoint, same Idempotency-Key, same widget; they only set task and
+    // put the source clip in reference_video_urls so the agent cannot get the
+    // plumbing wrong. ---
+    const editExtendShared = {
+        reference_image_urls: z
+            .array(z.string().url())
+            .min(1)
+            .max(30)
+            .optional()
+            .describe("Optional images the result should match (@Image 1, @Image 2 in the prompt), e.g. a character or product to bring in. " +
+            REAL_FACE_RULE),
+        reference_audio_urls: z
+            .array(z.string().url())
+            .min(1)
+            .max(10)
+            .optional()
+            .describe("Optional audio (@Audio 1 in the prompt) for the result to follow."),
+        model: z
+            .string()
+            .optional()
+            .describe('Model to run, default "corent-seedance-2.5", the model that can edit or extend a clip today.'),
+        resolution: z.enum(["720p", "1080p", "4k"]).optional().describe("Pixel resolution (default 720p); higher costs more."),
+        audio: z.boolean().optional().describe("Ask for native sound in the result."),
+        seed: z.number().int().min(0).optional().describe("Reproducibility, same contract as generate_video."),
+        negative_prompt: z.string().optional().describe("What must NOT appear in the result."),
+        return_last_frame: z
+            .boolean()
+            .optional()
+            .describe("true returns last_frame_url on the finished job, a PNG of the final frame to start the next clip from."),
+        output_format: z.enum(["mp4", "mov"]).optional().describe("Delivered file type (default mp4)."),
+    };
+    server.registerTool("edit_video", {
+        title: "Edit video",
+        _meta: toolMeta("Editing video", "Video edit started", true),
+        description: "Edit an existing clip with a prompt: add, remove, replace or change something in @Video 1. Keeps the source clip's length and shape. Asynchronous: returns a job id; poll get_job until completed. Runs on corent-seedance-2.5. Photos of real people are rejected as references; Corent-made characters are fine.",
+        inputSchema: {
+            prompt: z
+                .string()
+                .min(1)
+                .describe('The change, naming the source as @Video 1 and using an edit verb: "Replace the red car in @Video 1 with a blue bicycle".'),
+            video_url: z.string().url().describe("Public https URL of the clip to edit (becomes @Video 1)."),
+            ...editExtendShared,
+        },
+        outputSchema: jobOutput,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, wrap(async ({ prompt, video_url, model, ...rest }) => {
+        const body = { prompt, task: "edit", reference_video_urls: [video_url], model: model ?? "corent-seedance-2.5", ...rest };
+        checkVideoRules(body);
+        return corent("/v1/videos/generate", {
+            method: "POST",
+            headers: { "Idempotency-Key": idempotencyKey() },
+            body: JSON.stringify(body),
+        });
+    }));
+    server.registerTool("extend_video", {
+        title: "Extend video",
+        _meta: toolMeta("Extending video", "Video extension started", true),
+        description: "Continue an existing clip (@Video 1) forward or backward, with a prompt for what happens next or before. Keeps the source shape; duration_s is the added length. Asynchronous: returns a job id; poll get_job until completed. Runs on corent-seedance-2.5. Pair with return_last_frame to chain shots.",
+        inputSchema: {
+            prompt: z.string().min(1).describe("What happens in the new footage. The direction line is added for you."),
+            video_url: z.string().url().describe("Public https URL of the clip to continue (becomes @Video 1)."),
+            direction: z
+                .enum(["forward", "backward"])
+                .optional()
+                .describe("forward (default) adds footage after the clip; backward adds what happened before it."),
+            duration_s: z.number().int().min(1).max(30).optional().describe("Seconds of NEW footage to add."),
+            ...editExtendShared,
+        },
+        outputSchema: jobOutput,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, wrap(async ({ prompt, video_url, direction, model, ...rest }) => {
+        const body = {
+            prompt: `Extend @Video 1 ${direction ?? "forward"}. ${prompt}`,
+            task: "extend",
+            reference_video_urls: [video_url],
+            model: model ?? "corent-seedance-2.5",
+            ...rest,
+        };
+        checkVideoRules(body);
+        return corent("/v1/videos/generate", {
+            method: "POST",
+            headers: { "Idempotency-Key": idempotencyKey() },
+            body: JSON.stringify(body),
+        });
+    }));
     server.registerTool("generate_speech", {
         title: "Generate speech (voice)",
         _meta: toolMeta("Generating speech", "Speech ready"),
@@ -644,22 +823,31 @@ export function createCorentServer(config = {}) {
                 .array(z.object({
                 prompt: z.string(),
                 tier: z.enum(TIERS).optional(),
+                model: z.string().optional().describe("Pin a model, e.g. corent-seedance-2.5 for reference/edit/extend items."),
                 style: z.enum(IMAGE_STYLES).optional(),
-                aspect_ratio: z.enum(["16:9", "9:16", "1:1"]).optional(),
+                aspect_ratio: z.enum(VIDEO_ASPECTS).optional(),
                 duration_s: z.number().int().min(1).max(30).optional(),
                 resolution: z.enum(["720p", "1080p", "4k"]).optional(),
+                image_url: z.string().url().optional(),
+                end_image_url: z.string().url().optional(),
+                audio: z.boolean().optional(),
+                seed: z.number().int().min(0).optional(),
+                ...videoReferenceFields,
             }))
                 .min(1)
                 .max(50)
-                .describe("1 to 50 video requests"),
+                .describe("1 to 50 video requests; each item takes the same reference fields as generate_video"),
         },
         outputSchema: batchOutput,
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-    }, wrap(async ({ items }) => corent("/v1/videos/generate/batch", {
-        method: "POST",
-        headers: { "Idempotency-Key": idempotencyKey() },
-        body: JSON.stringify({ items }),
-    })));
+    }, wrap(async ({ items }) => {
+        items.forEach((item, i) => checkVideoRules(item, `items[${i}]: `));
+        return corent("/v1/videos/generate/batch", {
+            method: "POST",
+            headers: { "Idempotency-Key": idempotencyKey() },
+            body: JSON.stringify({ items }),
+        });
+    }));
     server.registerTool("get_batch", {
         title: "Check batch progress",
         _meta: toolMeta("Checking batch", "Batch checked"),
@@ -715,7 +903,7 @@ export function createCorentServer(config = {}) {
     server.registerTool("plan", {
         title: "Plan (cost preview, no generation)",
         _meta: toolMeta("Planning", "Plan ready"),
-        description: "Preview how Corent would handle a plain-language request without generating anything (a fraction of a cent). Returns image vs video, tier, aspect ratio, duration and an estimated cost. Covers image and video only; for speech call generate_speech. Impossible asks come back with can_fulfill false and a reason.",
+        description: "Preview how Corent would handle a plain-language request, without generating: image vs video, tier, shape, duration and an estimated cost. Image and video only; speech is generate_speech. A story with several characters or anything over about 30 seconds is a film: use plan_film. Impossible asks come back with can_fulfill false.",
         inputSchema: {
             intent: z
                 .string()
@@ -724,13 +912,14 @@ export function createCorentServer(config = {}) {
         outputSchema: {
             plan: z.object({ can_fulfill: z.boolean().optional() }).passthrough().optional(),
             estimated_cost_cents: z.number().nullable().optional(),
+            next_step: z.string().nullable().optional(),
         },
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-    }, wrap(async ({ intent }) => corent("/v1/intent", { method: "POST", body: JSON.stringify({ intent }) })));
+    }, wrap(async ({ intent }) => pointFilmsToPlanFilm(await corent("/v1/intent", { method: "POST", body: JSON.stringify({ intent }) }))));
     server.registerTool("create", {
         title: "Create (plan + generate, budget-capped)",
         _meta: toolMeta("Creating", "Created", true),
-        description: "Describe what you want in plain language; Corent plans and generates it, choosing image vs video, tier, shape and duration. max_cost_cents is a required spend ceiling: above it nothing is generated and you are told the estimate. Images return a URL; videos return a job id for get_job. Failed generations are never billed.",
+        description: "Describe one image or one clip in plain language; Corent picks type, tier, shape and duration and generates it. max_cost_cents is a required ceiling: above it nothing is generated. Videos return a job id for get_job. Failed generations are never billed. A story with several characters or anything over about 30 seconds is a film: use plan_film, then make_film.",
         inputSchema: {
             intent: z.string().describe("What you want, in natural language"),
             max_cost_cents: z
@@ -745,6 +934,7 @@ export function createCorentServer(config = {}) {
             actual_cost_cents: z.number().nullable().optional(),
             result: z.object({}).passthrough().nullable().optional(),
             message: z.string().nullable().optional(),
+            next_step: z.string().nullable().optional(),
         },
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
     }, wrap(async ({ intent, max_cost_cents }) => {
@@ -758,8 +948,142 @@ export function createCorentServer(config = {}) {
         if (res && typeof res.message === "string") {
             res.message = res.message.replace("confirm_estimated_cost_cents_up_to", "max_cost_cents");
         }
-        return res;
+        return pointFilmsToPlanFilm(res);
+    }));
+    // --- Films (v0.10.0): one sentence in, one finished video with sound out.
+    // Corent writes the script, creates the characters once, shoots every scene
+    // with them, checks and reshoots, and joins the scenes. plan_film is free and
+    // shows the price; make_film spends, capped by max_cost_cents; a failed or
+    // cancelled film is not billed. ---
+    const FILM_ASPECTS = ["16:9", "9:16", "1:1"];
+    const FILM_RESOLUTIONS = ["720p", "1080p"];
+    const filmOptions = {
+        duration_s: z.number().int().min(10).max(120).optional().describe("Length of the finished film in seconds, 10 to 120 (default 30)."),
+        aspect_ratio: z.enum(FILM_ASPECTS).optional().describe("16:9 (default), 9:16 for vertical, or 1:1."),
+        resolution: z.enum(FILM_RESOLUTIONS).optional().describe("720p (default) or 1080p; 1080p costs more."),
+        language: z.string().optional().describe('Language the characters speak, e.g. "en" or "es". Omit to follow the brief.'),
+        customer_id: z.string().min(1).max(128).optional().describe("Your own id for the end customer this film is for."),
+    };
+    const filmCharacter = z
+        .object({
+        id: z.string().optional(),
+        name: z.string().nullable().optional(),
+        description: z.string().nullable().optional(),
+        image_url: z.string().nullable().optional(),
+    })
+        .passthrough();
+    const filmScene = z
+        .object({
+        index: z.number().optional(),
+        duration_s: z.number().nullable().optional(),
+        setting: z.string().nullable().optional(),
+        action: z.string().nullable().optional(),
+        camera: z.string().nullable().optional(),
+        characters: z.array(z.string()).nullable().optional(),
+        dialogue: z.array(z.object({ character_id: z.string().optional(), line: z.string().optional() }).passthrough()).nullable().optional(),
+        status: z.string().nullable().optional(),
+        video_url: z.string().nullable().optional(),
+        last_frame_url: z.string().nullable().optional(),
+        reshoots: z.number().nullable().optional(),
+    })
+        .passthrough();
+    const filmOutput = {
+        film_id: z.string().optional(),
+        status: z.string().optional(),
+        progress_percent: z.number().nullable().optional(),
+        stage_detail: z.string().nullable().optional(),
+        title: z.string().nullable().optional(),
+        characters: z.array(filmCharacter).nullable().optional(),
+        scenes: z.array(filmScene).nullable().optional(),
+        video_url: z.string().nullable().optional(),
+        duration_s: z.number().nullable().optional(),
+        estimated_cost_cents: z.number().nullable().optional(),
+        cost_cents: z.number().nullable().optional(),
+        billed: z.boolean().nullable().optional(),
+        quality_notes: z.array(z.string()).nullable().optional(),
+        error: z.string().nullable().optional(),
+        error_message: z.string().nullable().optional(),
+        created_at: z.string().nullable().optional(),
+        completed_at: z.string().nullable().optional(),
+        customer_id: z.string().nullable().optional(),
+    };
+    server.registerTool("plan_film", {
+        title: "Plan a film (script and price, free)",
+        _meta: toolMeta("Writing the film plan", "Film plan ready"),
+        description: "Turn a one-sentence film idea into a plan without spending anything: title, characters, every scene with its dialogue, total length and the price range. The plan lasts 24 hours. Show the user the plan and the price and get a clear yes before make_film. Use it for any story with several characters or anything over about 30 seconds.",
+        inputSchema: {
+            brief: z
+                .string()
+                .min(1)
+                .max(2000)
+                .describe("The film in the user's own words, e.g. 'a 50 second parody where 5 founders start a startup and know nothing'."),
+            ...filmOptions,
+        },
+        outputSchema: {
+            plan_id: z.string().optional(),
+            title: z.string().nullable().optional(),
+            logline: z.string().nullable().optional(),
+            style: z.string().nullable().optional(),
+            characters: z.array(filmCharacter).nullable().optional(),
+            scenes: z.array(filmScene).nullable().optional(),
+            total_duration_s: z.number().nullable().optional(),
+            estimated_cost_cents: z.number().nullable().optional(),
+            estimated_cost_range: z.object({ min: z.number().optional(), max: z.number().optional() }).passthrough().nullable().optional(),
+            expires_at: z.string().nullable().optional(),
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, wrap(async (args) => corent("/v1/films/plan", { method: "POST", body: JSON.stringify(args) })));
+    server.registerTool("make_film", {
+        title: "Make a film (budget-capped)",
+        _meta: toolMeta("Starting film", "Film started", true),
+        description: "Start the film the user approved: pass plan_id from plan_film (or a brief), and max_cost_cents a little above the estimate. The charge never goes above max_cost_cents, and a failed or cancelled film is not billed. Returns film_id right away; a film takes about 15 to 30 minutes, so check get_film every 60 seconds.",
+        inputSchema: {
+            plan_id: z.string().optional().describe("The plan_id from plan_film. Preferred: it is the plan and price the user saw."),
+            brief: z.string().min(1).max(2000).optional().describe("Only when there is no plan_id: the film idea, planned and made in one go."),
+            ...filmOptions,
+            max_cost_cents: z
+                .number()
+                .int()
+                .min(1)
+                .describe("Spend ceiling in cents. Refused up front if the estimate is higher; the charge never goes above it."),
+            webhook_url: z.string().url().optional().describe("Optional https URL that receives the finished film."),
+            webhook_secret: z.string().optional().describe("Optional secret that signs the webhook delivery."),
+        },
+        outputSchema: filmOutput,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, wrap(async ({ plan_id, brief, duration_s, aspect_ratio, resolution, language, ...rest }) => {
+        if (!plan_id && !brief) {
+            throw new CorentApiError(422, { message: "Pass plan_id from plan_film, or a brief." });
+        }
+        const options = { duration_s, aspect_ratio, resolution, language };
+        if (plan_id && (brief || Object.values(options).some((v) => v !== undefined))) {
+            throw new CorentApiError(422, {
+                message: "A plan already fixes the story, length, shape and resolution: pass plan_id on its own, or call plan_film again with the new options.",
+            });
+        }
+        const body = plan_id ? { plan_id, ...rest } : { brief, ...options, ...rest };
+        return corent("/v1/films", {
+            method: "POST",
+            headers: { "Idempotency-Key": idempotencyKey() },
+            body: JSON.stringify(body),
+        });
     }));
+    server.registerTool("get_film", {
+        title: "Check film progress",
+        _meta: toolMeta("Checking film", "Film checked", true),
+        description: "Progress of a film from make_film: the stage (queued, writing, casting, shooting, checking, editing, completed, failed, cancelled), progress_percent, and each scene. When completed it carries video_url, the finished film with sound, and cost_cents. Read-only and free. Tell the user the stage in one plain sentence.",
+        inputSchema: { film_id: z.string().min(1).describe("The film_id returned by make_film") },
+        outputSchema: filmOutput,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, wrap(async ({ film_id }) => corent(`/v1/films/${encodeURIComponent(film_id)}`)));
+    server.registerTool("cancel_film", {
+        title: "Cancel a film",
+        _meta: toolMeta("Cancelling film", "Film cancelled"),
+        description: "Stop a film that has not finished. A cancelled film is not billed. Use it as soon as the user says they did not mean to start it or want to change the story. A film that already finished stays completed.",
+        inputSchema: { film_id: z.string().min(1).describe("The film_id to cancel") },
+        outputSchema: filmOutput,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, wrap(async ({ film_id }) => corent(`/v1/films/${encodeURIComponent(film_id)}/cancel`, { method: "POST" })));
     // --- Image tools (v0.8.0): edit what already exists instead of generating
     // anew. All three are synchronous, flat-priced, and replay-safe under an
     // Idempotency-Key exactly like generate_image. ---