@phuetz/code-buddy 1.6.1 → 2.0.0

package/dist/tools/video/youtube-storyboard.d.ts

@@ -0,0 +1,43 @@
+/**
+ * YouTube storyboard fallback for local visual understanding.
+ *
+ * Some YouTube videos require a PO token for their media streams and therefore
+ * return HTTP 403 to yt-dlp even though captions and public storyboard sheets are
+ * available. This module downloads the highest-resolution storyboard (`sb0`),
+ * extracts its JPEG MIME parts, crops the thumbnail grid into timestamped frames,
+ * and keeps the whole operation local. It never calls a cloud vision provider.
+ *
+ * @module tools/video/youtube-storyboard
+ */
+import type { SampledFrame } from './frame-sample.js';
+import { type MediaFetchDeps } from './media-fetch.js';
+export interface StoryboardSampleOk {
+    frames: SampledFrame[];
+    /** Local yt-dlp MHTML artifact retained for diagnostics/reuse. */
+    storyboardPath: string;
+}
+export interface StoryboardSampleErr {
+    error: string;
+}
+export type StoryboardSampleResult = StoryboardSampleOk | StoryboardSampleErr;
+export interface StoryboardSampleDeps extends MediaFetchDeps {
+    /** Maximum number of cropped frames (default 100). */
+    budget?: number;
+    now?: () => number;
+}
+/** Build yt-dlp arguments for the public, low-bandwidth YouTube storyboard. */
+export declare function buildStoryboardYtdlpArgs(source: string, outputTemplate: string): string[];
+/**
+ * Extract JPEG MIME bodies using their explicit Content-Length. Converting the
+ * whole MHTML to latin1 preserves byte offsets one-for-one, unlike UTF-8.
+ */
+export declare function extractStoryboardJpegs(mhtml: Buffer): Buffer[];
+/** Evenly spread at most `budget` integer indices across `[0, total)`. */
+export declare function storyboardFrameIndices(total: number, budget: number): number[];
+/** Type guard for a successful storyboard sample. */
+export declare function isStoryboardSampleOk(result: StoryboardSampleResult): result is StoryboardSampleOk;
+/**
+ * Download and crop YouTube's public storyboard into timestamped local JPEGs.
+ * Returns `{ error }` on every failure path; never throws.
+ */
+export declare function sampleYoutubeStoryboardFrames(source: string, outDir: string, deps?: StoryboardSampleDeps): Promise<StoryboardSampleResult>;

package/dist/tools/video/youtube-storyboard.js

@@ -0,0 +1,194 @@
+/**
+ * YouTube storyboard fallback for local visual understanding.
+ *
+ * Some YouTube videos require a PO token for their media streams and therefore
+ * return HTTP 403 to yt-dlp even though captions and public storyboard sheets are
+ * available. This module downloads the highest-resolution storyboard (`sb0`),
+ * extracts its JPEG MIME parts, crops the thumbnail grid into timestamped frames,
+ * and keeps the whole operation local. It never calls a cloud vision provider.
+ *
+ * @module tools/video/youtube-storyboard
+ */
+import { spawn as realSpawn } from 'child_process';
+import { mkdir, readFile } from 'fs/promises';
+import { join } from 'path';
+import { logger } from '../../utils/logger.js';
+import { resolveYtdlp } from './media-fetch.js';
+/** Build yt-dlp arguments for the public, low-bandwidth YouTube storyboard. */
+export function buildStoryboardYtdlpArgs(source, outputTemplate) {
+    return [
+        '--js-runtimes',
+        `node:${process.execPath}`,
+        '-f',
+        'sb0',
+        '--write-info-json',
+        '--no-playlist',
+        '-o',
+        outputTemplate,
+        source,
+    ];
+}
+/**
+ * Extract JPEG MIME bodies using their explicit Content-Length. Converting the
+ * whole MHTML to latin1 preserves byte offsets one-for-one, unlike UTF-8.
+ */
+export function extractStoryboardJpegs(mhtml) {
+    const text = mhtml.toString('latin1');
+    const images = [];
+    const contentType = /Content-Type:\s*image\/jpeg/gi;
+    let match;
+    while ((match = contentType.exec(text)) !== null) {
+        const crlfEnd = text.indexOf('\r\n\r\n', match.index);
+        const lfEnd = text.indexOf('\n\n', match.index);
+        const usesCrlf = crlfEnd >= 0 && (lfEnd < 0 || crlfEnd <= lfEnd);
+        const headerEnd = usesCrlf ? crlfEnd : lfEnd;
+        if (headerEnd < 0)
+            break;
+        const headers = text.slice(match.index, headerEnd);
+        const lengthMatch = /Content-Length:\s*(\d+)/i.exec(headers);
+        if (!lengthMatch) {
+            contentType.lastIndex = headerEnd + (usesCrlf ? 4 : 2);
+            continue;
+        }
+        const length = Number.parseInt(lengthMatch[1], 10);
+        const bodyStart = headerEnd + (usesCrlf ? 4 : 2);
+        const bodyEnd = bodyStart + length;
+        if (!Number.isFinite(length) || length <= 0 || bodyEnd > mhtml.length)
+            break;
+        images.push(mhtml.subarray(bodyStart, bodyEnd));
+        contentType.lastIndex = bodyEnd;
+    }
+    return images;
+}
+/** Evenly spread at most `budget` integer indices across `[0, total)`. */
+export function storyboardFrameIndices(total, budget) {
+    if (total <= 0 || budget <= 0)
+        return [];
+    if (total <= budget)
+        return Array.from({ length: total }, (_, i) => i);
+    if (budget === 1)
+        return [0];
+    const indices = new Set();
+    for (let i = 0; i < budget; i++) {
+        indices.add(Math.round((i * (total - 1)) / (budget - 1)));
+    }
+    return [...indices];
+}
+function runProcess(spawn, cmd, args, timeoutMs) {
+    return new Promise((resolve) => {
+        let settled = false;
+        let stderr = '';
+        let timer;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            resolve(result);
+        };
+        let child;
+        try {
+            child = spawn(cmd, args, { stdio: ['ignore', 'ignore', 'pipe'] });
+        }
+        catch (err) {
+            finish({ code: null, stderr: err instanceof Error ? err.message : String(err) });
+            return;
+        }
+        timer = setTimeout(() => {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch {
+                /* already gone */
+            }
+            finish({ code: null, stderr: `${stderr}\n[timeout ${timeoutMs}ms]` });
+        }, timeoutMs);
+        child.stderr?.on('data', (data) => {
+            stderr = `${stderr}${String(data)}`.slice(-4000);
+        });
+        child.on('error', (err) => finish({ code: null, stderr: `${stderr}${err.message}` }));
+        child.on('close', (code) => finish({ code, stderr }));
+    });
+}
+/** Type guard for a successful storyboard sample. */
+export function isStoryboardSampleOk(result) {
+    return 'frames' in result;
+}
+/**
+ * Download and crop YouTube's public storyboard into timestamped local JPEGs.
+ * Returns `{ error }` on every failure path; never throws.
+ */
+export async function sampleYoutubeStoryboardFrames(source, outDir, deps = {}) {
+    const invocation = resolveYtdlp(deps);
+    if (!invocation)
+        return { error: 'yt-dlp introuvable pour le repli storyboard' };
+    const stamp = (deps.now ?? Date.now)();
+    const base = `ytdl-storyboard-${stamp}`;
+    const outputTemplate = join(outDir, `${base}.%(ext)s`);
+    const storyboardPath = join(outDir, `${base}.mhtml`);
+    const infoPath = join(outDir, `${base}.info.json`);
+    const args = [...invocation.baseArgs, ...buildStoryboardYtdlpArgs(source, outputTemplate)];
+    const timeoutMs = deps.timeoutMs ?? 2 * 60 * 1000;
+    logger.info(`[video] full stream unavailable — downloading YouTube storyboard via ${invocation.label}`);
+    const proc = await runProcess(deps.spawn ?? realSpawn, invocation.cmd, args, timeoutMs);
+    if (proc.code !== 0) {
+        return {
+            error: `yt-dlp storyboard exited with code ${proc.code ?? 'unknown'}${proc.stderr.trim() ? `: ${proc.stderr.trim().slice(-500)}` : ''}`,
+        };
+    }
+    try {
+        const [mhtml, rawInfo] = await Promise.all([readFile(storyboardPath), readFile(infoPath, 'utf8')]);
+        const info = JSON.parse(rawInfo);
+        const format = info.formats?.find((candidate) => candidate.format_id === 'sb0');
+        const width = Math.floor(format?.width ?? 0);
+        const height = Math.floor(format?.height ?? 0);
+        const rows = Math.floor(format?.rows ?? 0);
+        const columns = Math.floor(format?.columns ?? 0);
+        const fps = format?.fps ?? 0;
+        const duration = info.duration ?? 0;
+        if (width <= 0 || height <= 0 || rows <= 0 || columns <= 0 || fps <= 0 || duration <= 0) {
+            return { error: 'métadonnées storyboard sb0 incomplètes' };
+        }
+        const sheets = extractStoryboardJpegs(mhtml);
+        if (sheets.length === 0)
+            return { error: 'aucune planche JPEG trouvée dans le storyboard' };
+        const tilesPerSheet = rows * columns;
+        const available = sheets.length * tilesPerSheet;
+        const total = Math.min(available, Math.max(1, Math.ceil(duration * fps)));
+        const indices = storyboardFrameIndices(total, deps.budget ?? 100);
+        const framesDir = join(outDir, `${base}-frames`);
+        await mkdir(framesDir, { recursive: true });
+        const sharp = (await import('sharp')).default;
+        const produced = await Promise.all(indices.map(async (index) => {
+            const sheetIndex = Math.floor(index / tilesPerSheet);
+            const tileIndex = index % tilesPerSheet;
+            const sheet = sheets[sheetIndex];
+            if (!sheet)
+                return null;
+            const row = Math.floor(tileIndex / columns);
+            const column = tileIndex % columns;
+            const framePath = join(framesDir, `frame_${String(index + 1).padStart(4, '0')}.jpg`);
+            try {
+                await sharp(sheet)
+                    .extract({ left: column * width, top: row * height, width, height })
+                    .jpeg({ quality: 88 })
+                    .toFile(framePath);
+                return { path: framePath, t: Math.round((index / fps) * 100) / 100 };
+            }
+            catch (err) {
+                logger.debug(`[video] storyboard crop ${index} failed: ${err instanceof Error ? err.message : String(err)}`);
+                return null;
+            }
+        }));
+        const frames = produced.filter((frame) => frame !== null);
+        if (frames.length === 0)
+            return { error: 'le storyboard n’a produit aucune frame exploitable' };
+        logger.info(`[video] storyboard fallback: ${frames.length} frame(s) over ${duration}s`);
+        return { frames, storyboardPath };
+    }
+    catch (err) {
+        return { error: `repli storyboard illisible: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+//# sourceMappingURL=youtube-storyboard.js.map

package/dist/tools/video-flow-handoff-tool.d.ts

@@ -0,0 +1,181 @@
+/**
+ * ITool adapter over google-flow-handoff / plan-export / result-import review.
+ * Builds or verifies browser-assisted Flow work packets. Never calls an unofficial
+ * API, never bills, never writes files, never publishes.
+ */
+import type { ToolResult } from '../types/index.js';
+import type { ITool, IToolExecutionContext, IToolMetadata, IValidationResult, ToolSchema } from './registry/types.js';
+export declare const VIDEO_FLOW_HANDOFF_PARAMETERS: {
+    type: "object";
+    properties: {
+        operation: {
+            type: string;
+            enum: ("create" | "export" | "verify" | "review_import")[];
+            description: string;
+        };
+        shots: {
+            type: string;
+            items: {
+                type: string;
+            };
+            description: string;
+        };
+        handoff: {
+            type: string;
+            description: string;
+        };
+        plan: {
+            type: string;
+            description: string;
+        };
+        receipt: {
+            type: string;
+            description: string;
+        };
+        capacity: {
+            type: string;
+            description: string;
+            properties: {
+                gpuNode: {
+                    type: string;
+                    description: string;
+                };
+                localGpu: {
+                    type: string;
+                    description: string;
+                };
+                google_flow: {
+                    type: string;
+                    description: string;
+                };
+                remaining_flow_credits: {
+                    type: string;
+                    description: string;
+                };
+                max_flow_credits_per_batch: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        source_plan_sha256: {
+            type: string;
+            description: string;
+        };
+        batch_id: {
+            type: string;
+            description: string;
+        };
+        model: {
+            type: string;
+            enum: string[];
+            description: string;
+        };
+        locale: {
+            type: string;
+            description: string;
+        };
+        duration_seconds: {
+            type: string;
+            description: string;
+        };
+        aspect_ratio: {
+            type: string;
+            enum: string[];
+            description: string;
+        };
+        upscale_4k: {
+            type: string;
+            description: string;
+        };
+        approved_asset_root: {
+            type: string;
+            description: string;
+        };
+        short_id: {
+            type: string;
+            description: string;
+        };
+        include_all_shorts: {
+            type: string;
+            description: string;
+        };
+        remaining_flow_credits: {
+            type: string;
+            description: string;
+        };
+        max_flow_credits_per_batch: {
+            type: string;
+            description: string;
+        };
+        gpu_node_available: {
+            type: string;
+            description: string;
+        };
+        local_gpu_available: {
+            type: string;
+            description: string;
+        };
+        expected_receipt_sha256: {
+            type: string;
+            description: string;
+        };
+        reviewer: {
+            type: string;
+            description: string;
+        };
+        reason: {
+            type: string;
+            description: string;
+        };
+        checks: {
+            type: string;
+            description: string;
+            properties: {
+                identity: {
+                    type: string;
+                    description: string;
+                };
+                anatomy: {
+                    type: string;
+                    description: string;
+                };
+                motion: {
+                    type: string;
+                    description: string;
+                };
+                clean_end: {
+                    type: string;
+                    description: string;
+                };
+                no_speech: {
+                    type: string;
+                    description: string;
+                };
+                no_text_or_logo: {
+                    type: string;
+                    description: string;
+                };
+                safe_content: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare class VideoFlowHandoffTool implements ITool {
+    readonly name = "video_flow_handoff";
+    readonly description = "Build, verify, export or human-review Google Flow (Veo) browser-assisted work packets. Billing stays on Ultra Flow credits; apiBillingAllowed is always false; never publishes.";
+    execute(input: Record<string, unknown>, _context?: IToolExecutionContext): Promise<ToolResult>;
+    getSchema(): ToolSchema;
+    validate(input: unknown): IValidationResult;
+    getMetadata(): IToolMetadata;
+    isAvailable(): boolean;
+}

package/dist/tools/video-flow-handoff-tool.js

@@ -0,0 +1,261 @@
+/**
+ * ITool adapter over google-flow-handoff / plan-export / result-import review.
+ * Builds or verifies browser-assisted Flow work packets. Never calls an unofficial
+ * API, never bills, never writes files, never publishes.
+ */
+import { createGoogleFlowHandoff, verifyGoogleFlowHandoffDigest, } from './video/google-flow-handoff.js';
+import { exportGoogleFlowHandoffFromPlan } from './video/google-flow-plan-export.js';
+import { reviewGoogleFlowImport, } from './video/google-flow-result-import.js';
+import { firstPresent, optionalString, parseEnum, parseHybridCapacity, pickBoolean, pickFiniteNumber, pickInteger, pickString, requireRecord, toolFail, toolOk, } from './video-studio-tool-helpers.js';
+const OPERATIONS = ['create', 'verify', 'export', 'review_import'];
+const MODELS = ['lite', 'fast', 'quality'];
+const ASPECTS = ['9:16', '16:9'];
+const ROLES = ['hero', 'b-roll', 'transition'];
+const CAPACITY_PROPERTIES = {
+    gpuNode: { type: 'boolean', description: 'GPU node local GPU worker is available.' },
+    localGpu: {
+        type: 'boolean',
+        description: 'Local GPU worker is available. Generic compatibility aliases local_gpu, localGpuAvailable and local_gpu_available are accepted; machine-specific legacy keys are not read.',
+    },
+    google_flow: { type: 'boolean', description: 'Google Flow (browser-assisted) is available.' },
+    remaining_flow_credits: { type: 'number', description: 'Remaining Google Flow credits.' },
+    max_flow_credits_per_batch: { type: 'number', description: 'Credit ceiling for this batch.' },
+};
+function parseDuration(value) {
+    if (value === 4 || value === 6 || value === 8)
+        return value;
+    throw new Error('duration_seconds must be 4, 6 or 8');
+}
+function parseShot(value, index) {
+    const record = requireRecord(value, `shots[${index}]`);
+    const role = parseEnum(firstPresent(record, ['role']), ROLES, `shots[${index}].role`);
+    const shot = {
+        id: pickString(record, ['id'], `shots[${index}].id`),
+        characterName: pickString(record, ['character_name', 'characterName'], `shots[${index}].character_name`),
+        declaredAdultAge: pickInteger(record, ['declared_adult_age', 'declaredAdultAge'], `shots[${index}].declared_adult_age`, 1),
+        sourcePath: pickString(record, ['source_path', 'sourcePath'], `shots[${index}].source_path`),
+        sourceSha256: pickString(record, ['source_sha256', 'sourceSha256'], `shots[${index}].source_sha256`),
+        motionPrompt: pickString(record, ['motion_prompt', 'motionPrompt'], `shots[${index}].motion_prompt`),
+        role,
+    };
+    const consumerShortIds = firstPresent(record, ['consumer_short_ids', 'consumerShortIds']);
+    if (Array.isArray(consumerShortIds)) {
+        shot.consumerShortIds = consumerShortIds.map((id, i) => {
+            if (typeof id !== 'string' || !id.trim()) {
+                throw new Error(`shots[${index}].consumer_short_ids[${i}] must be a non-empty string`);
+            }
+            return id.trim();
+        });
+    }
+    const consumers = firstPresent(record, ['consumers']);
+    if (Array.isArray(consumers)) {
+        shot.consumers = consumers.map((item, i) => {
+            const consumer = requireRecord(item, `shots[${index}].consumers[${i}]`);
+            const shotIndex = firstPresent(consumer, ['shot_index', 'shotIndex']);
+            if (typeof shotIndex !== 'number' || !Number.isSafeInteger(shotIndex) || shotIndex < 1) {
+                throw new Error(`shots[${index}].consumers[${i}].shot_index must be an integer >= 1`);
+            }
+            return {
+                shortId: pickString(consumer, ['short_id', 'shortId'], `shots[${index}].consumers[${i}].short_id`),
+                shotIndex,
+            };
+        });
+    }
+    return shot;
+}
+function parseCreateOptions(input) {
+    return {
+        sourcePlanSha256: pickString(input, ['source_plan_sha256', 'sourcePlanSha256'], 'source_plan_sha256'),
+        batchId: pickString(input, ['batch_id', 'batchId'], 'batch_id'),
+        model: parseEnum(input.model, MODELS, 'model'),
+        locale: pickString(input, ['locale'], 'locale'),
+        durationSeconds: parseDuration(firstPresent(input, ['duration_seconds', 'durationSeconds'])),
+        aspectRatio: parseEnum(firstPresent(input, ['aspect_ratio', 'aspectRatio']), ASPECTS, 'aspect_ratio'),
+        upscale4k: pickBoolean(input, ['upscale_4k', 'upscale4k'], 'upscale_4k'),
+        capacity: parseHybridCapacity(input.capacity),
+    };
+}
+function parseFlowReviewChecks(value) {
+    const record = requireRecord(value, 'checks');
+    return {
+        identity: pickBoolean(record, ['identity'], 'checks.identity'),
+        anatomy: pickBoolean(record, ['anatomy'], 'checks.anatomy'),
+        motion: pickBoolean(record, ['motion'], 'checks.motion'),
+        cleanEnd: pickBoolean(record, ['clean_end', 'cleanEnd'], 'checks.clean_end'),
+        noSpeech: pickBoolean(record, ['no_speech', 'noSpeech'], 'checks.no_speech'),
+        noTextOrLogo: pickBoolean(record, ['no_text_or_logo', 'noTextOrLogo'], 'checks.no_text_or_logo'),
+        safeContent: pickBoolean(record, ['safe_content', 'safeContent'], 'checks.safe_content'),
+    };
+}
+export const VIDEO_FLOW_HANDOFF_PARAMETERS = {
+    type: 'object',
+    properties: {
+        operation: {
+            type: 'string',
+            enum: [...OPERATIONS],
+            description: 'create: build a signed Flow handoff from shots. verify: check handoffSha256. export: convert a QA-approved Short plan (reads approved assets, writes nothing). review_import: digest-bound human review of an import receipt (writes nothing). Never bills, never publishes.',
+        },
+        shots: {
+            type: 'array',
+            items: { type: 'object' },
+            description: 'Source shots for create (absolute source_path, SHA-256, adult identity, consumers).',
+        },
+        handoff: {
+            type: 'object',
+            description: 'GoogleFlowHandoff document for verify.',
+        },
+        plan: {
+            type: 'object',
+            description: 'QA-approved Short plan (schemaVersion 3) for export.',
+        },
+        receipt: {
+            type: 'object',
+            description: 'GoogleFlowImportReceipt for review_import.',
+        },
+        capacity: {
+            type: 'object',
+            description: 'Engine availability and Flow credits (create).',
+            properties: { ...CAPACITY_PROPERTIES },
+            required: ['gpuNode', 'localGpu', 'google_flow', 'remaining_flow_credits', 'max_flow_credits_per_batch'],
+            additionalProperties: false,
+        },
+        source_plan_sha256: { type: 'string', description: 'Canonical SHA-256 of the V3 source plan (create).' },
+        batch_id: { type: 'string', description: 'Safe batch id (lowercase kebab).' },
+        model: { type: 'string', enum: ['lite', 'fast', 'quality'], description: 'Flow model family.' },
+        locale: { type: 'string', description: 'BCP 47 locale (create).' },
+        duration_seconds: { type: 'number', description: 'Clip duration in seconds: 4, 6 or 8. Quality requires 8.' },
+        aspect_ratio: { type: 'string', enum: ['9:16', '16:9'], description: 'Output aspect ratio.' },
+        upscale_4k: { type: 'boolean', description: '4K upscale surcharge.' },
+        approved_asset_root: { type: 'string', description: 'Absolute approved-asset root (export).' },
+        short_id: { type: 'string', description: 'Export a single Short id (mutually exclusive with include_all_shorts).' },
+        include_all_shorts: { type: 'boolean', description: 'Export every Short in the plan.' },
+        remaining_flow_credits: { type: 'number', description: 'Remaining Flow credits (export).' },
+        max_flow_credits_per_batch: { type: 'number', description: 'Batch credit ceiling (export).' },
+        gpu_node_available: { type: 'boolean', description: 'GPU node available (export).' },
+        local_gpu_available: { type: 'boolean', description: 'Local GPU available (export).' },
+        expected_receipt_sha256: { type: 'string', description: 'Expected import receipt digest (review_import).' },
+        reviewer: { type: 'string', description: 'Reviewer name (review_import).' },
+        reason: { type: 'string', description: 'Review reason (review_import).' },
+        checks: {
+            type: 'object',
+            description: 'Flow human-review checks (review_import).',
+            properties: {
+                identity: { type: 'boolean', description: 'Identity preserved.' },
+                anatomy: { type: 'boolean', description: 'Anatomy plausible.' },
+                motion: { type: 'boolean', description: 'Motion approved.' },
+                clean_end: { type: 'boolean', description: 'Clean end frame.' },
+                no_speech: { type: 'boolean', description: 'No speech in the clip.' },
+                no_text_or_logo: { type: 'boolean', description: 'No burned-in text or logo.' },
+                safe_content: { type: 'boolean', description: 'Advertiser-safe content.' },
+            },
+            required: ['identity', 'anatomy', 'motion', 'clean_end', 'no_speech', 'no_text_or_logo', 'safe_content'],
+            additionalProperties: false,
+        },
+    },
+    required: ['operation'],
+    additionalProperties: false,
+};
+export class VideoFlowHandoffTool {
+    name = 'video_flow_handoff';
+    description = 'Build, verify, export or human-review Google Flow (Veo) browser-assisted work packets. Billing stays on Ultra Flow credits; apiBillingAllowed is always false; never publishes.';
+    async execute(input, _context) {
+        try {
+            const operation = parseEnum(input.operation, OPERATIONS, 'operation');
+            if (operation === 'create') {
+                const shotsValue = input.shots;
+                if (!Array.isArray(shotsValue) || shotsValue.length === 0) {
+                    throw new Error('shots must be a non-empty array');
+                }
+                const shots = shotsValue.map((shot, index) => parseShot(shot, index));
+                return toolOk(createGoogleFlowHandoff(shots, parseCreateOptions(input)));
+            }
+            if (operation === 'verify') {
+                const handoff = requireRecord(input.handoff, 'handoff');
+                return toolOk({ valid: verifyGoogleFlowHandoffDigest(handoff) });
+            }
+            if (operation === 'export') {
+                const approvedAssetRoot = pickString(input, ['approved_asset_root', 'approvedAssetRoot'], 'approved_asset_root');
+                const includeAll = input.include_all_shorts === true || input.includeAllShorts === true;
+                const shortId = optionalString(input, 'short_id') ?? optionalString(input, 'shortId');
+                return toolOk(await exportGoogleFlowHandoffFromPlan(input.plan, {
+                    approvedAssetRoot,
+                    batchId: pickString(input, ['batch_id', 'batchId'], 'batch_id'),
+                    ...(shortId ? { shortId } : {}),
+                    ...(includeAll ? { includeAllShorts: true } : {}),
+                    model: parseEnum(input.model, MODELS, 'model'),
+                    durationSeconds: parseDuration(firstPresent(input, ['duration_seconds', 'durationSeconds'])),
+                    aspectRatio: parseEnum(firstPresent(input, ['aspect_ratio', 'aspectRatio']), ASPECTS, 'aspect_ratio'),
+                    upscale4k: pickBoolean(input, ['upscale_4k', 'upscale4k'], 'upscale_4k'),
+                    remainingFlowCredits: pickFiniteNumber(input, ['remaining_flow_credits', 'remainingFlowCredits'], 'remaining_flow_credits'),
+                    maxFlowCreditsPerBatch: pickFiniteNumber(input, ['max_flow_credits_per_batch', 'maxFlowCreditsPerBatch'], 'max_flow_credits_per_batch'),
+                    gpuNodeAvailable: pickBoolean(input, ['gpu_node_available', 'gpuNodeAvailable'], 'gpu_node_available'),
+                    localGpuAvailable: pickBoolean(input, ['local_gpu_available', 'localGpuAvailable', 'local_gpu'], 'local_gpu_available'),
+                }));
+            }
+            const receipt = requireRecord(input.receipt, 'receipt');
+            const expected = pickString(input, ['expected_receipt_sha256', 'expectedReceiptSha256'], 'expected_receipt_sha256');
+            return toolOk(reviewGoogleFlowImport({
+                receipt,
+                expectedReceiptSha256: expected,
+                reviewer: pickString(input, ['reviewer'], 'reviewer'),
+                reason: pickString(input, ['reason'], 'reason'),
+                checks: parseFlowReviewChecks(input.checks),
+            }));
+        }
+        catch (error) {
+            return toolFail(error);
+        }
+    }
+    getSchema() {
+        return {
+            name: this.name,
+            description: this.description,
+            parameters: VIDEO_FLOW_HANDOFF_PARAMETERS,
+        };
+    }
+    validate(input) {
+        if (!input || typeof input !== 'object' || Array.isArray(input)) {
+            return { valid: false, errors: ['Input must be an object'] };
+        }
+        const data = input;
+        if (typeof data.operation !== 'string' || !OPERATIONS.includes(data.operation)) {
+            return { valid: false, errors: [`operation must be one of: ${OPERATIONS.join(', ')}`] };
+        }
+        if (data.operation === 'create') {
+            if (!Array.isArray(data.shots) || data.shots.length === 0) {
+                return { valid: false, errors: ['shots (non-empty array) is required for create'] };
+            }
+            if (!data.capacity || typeof data.capacity !== 'object' || Array.isArray(data.capacity)) {
+                return { valid: false, errors: ['capacity is required for create'] };
+            }
+        }
+        if (data.operation === 'verify' && (data.handoff === undefined || typeof data.handoff !== 'object')) {
+            return { valid: false, errors: ['handoff (object) is required for verify'] };
+        }
+        if (data.operation === 'export' && (data.plan === undefined || typeof data.plan !== 'object')) {
+            return { valid: false, errors: ['plan (object) is required for export'] };
+        }
+        if (data.operation === 'review_import' && (data.receipt === undefined || typeof data.receipt !== 'object')) {
+            return { valid: false, errors: ['receipt (object) is required for review_import'] };
+        }
+        return { valid: true };
+    }
+    getMetadata() {
+        return {
+            name: this.name,
+            description: this.description,
+            category: 'media',
+            keywords: [
+                'video', 'flow', 'google flow', 'veo', 'handoff', 'export', 'import',
+                'credits', 'browser', 'packet', 'transfert', 'veo3',
+            ],
+            priority: 8,
+            modifiesFiles: false,
+            makesNetworkRequests: false,
+        };
+    }
+    isAvailable() {
+        return true;
+    }
+}
+//# sourceMappingURL=video-flow-handoff-tool.js.map