@shop-os/modelkit 0.2.26 → 0.3.0

package/dist/index.js

@@ -1304,6 +1304,11 @@ var NEGATIVE_PROMPT = "blur, distort, and low quality";
 var FRAMES_EXCLUDE_REFERENCES = { framesExcludeReferences: true };
 var KLING_PROMPT = { referenceSyntax: "numbered", maxChars: 2500 };
 var SEEDANCE_PROMPT = { referenceSyntax: "numbered", maxChars: 3e4 };
+var SEEDANCE_2_AUDIO = {
+  audioSeconds: { min: 2, max: 15, total: 15 },
+  audioFormats: ["wav", "mp3"],
+  audioMaxBytes: 15 * 1024 * 1024
+};
 var H3_PROMPT = { referenceSyntax: "numbered", maxChars: 5e4 };
 var OMNI_PROMPT = { referenceSyntax: "caption", maxChars: 5e4 };
 var BYTEDANCE_LOGO = "https://d31vvfpk2ppdyq.cloudfront.net/assets/image/3bba5d81-4e57-4e71-911b-cdfa05acca2c_compressed.png";
@@ -1440,7 +1445,7 @@ var VIDEO_MODELS = [
       description: "Google's conversational video model with native audio, human support, and natural language editing. Aspect ratio only \u2014 resolution and duration are model-determined.",
       logo: GOOGLE_LOGO2
     },
-    capabilities: { acceptsSourceVideo: true }
+    capabilities: { acceptsSourceVideo: true, videoEdit: true }
   },
   {
     id: "gemini-omni-1.1-flash",
@@ -1465,7 +1470,7 @@ var VIDEO_MODELS = [
       // with a video task, so those calls carry the prompt alone).
       // First-to-last-frame interpolation: `<LAST_FRAME>` goes with `<FIRST_FRAME>`.
       supports: ["videoExtension", "lastFrame"],
-      extension: { segmentSeconds: 10, maxTotalSeconds: 40 },
+      extension: { segmentSeconds: 10, maxTotalSeconds: 40, returns: "joined" },
       prompt: OMNI_PROMPT,
       audio: "always"
     },
@@ -1477,7 +1482,11 @@ var VIDEO_MODELS = [
       logo: GOOGLE_LOGO2,
       description: "Google Gemini Omni Flash 1.1 conversational video generation, editing and extension; text, image, and up to 10-second video input, 3-10 second output at up to 4K and 24 FPS, extendable to 40 seconds."
     },
-    capabilities: { acceptsSourceVideo: true, lastFrameRequiresFirstFrame: true }
+    capabilities: {
+      acceptsSourceVideo: true,
+      videoEdit: true,
+      lastFrameRequiresFirstFrame: true
+    }
   },
   {
     // vibe-triggers and Space Builder drop the ratio when a frame is wired; Cowork always sends it.
@@ -1499,7 +1508,8 @@ var VIDEO_MODELS = [
         videos: 3,
         audios: 3,
         audioOnly: false,
-        videoSeconds: { min: 2, max: 15, total: 15 }
+        videoSeconds: { min: 2, max: 15, total: 15 },
+        ...SEEDANCE_2_AUDIO
       },
       sourceVideoSeconds: { min: 2, max: 15, inReferenceTotal: true },
       ratioIgnoredWith: ["firstFrame", "sourceVideo"],
@@ -1521,7 +1531,7 @@ var VIDEO_MODELS = [
       description: "High-quality AI video generation with reference image conditioning. Supports 4-15 second clips with human preprocessing.",
       logo: BYTEDANCE_LOGO
     },
-    capabilities: { acceptsSourceVideo: true, ...FRAMES_EXCLUDE_REFERENCES }
+    capabilities: { acceptsSourceVideo: true, videoEdit: false, ...FRAMES_EXCLUDE_REFERENCES }
   },
   {
     id: "seedance-2.0-fast",
@@ -1541,7 +1551,8 @@ var VIDEO_MODELS = [
         videos: 3,
         audios: 3,
         audioOnly: false,
-        videoSeconds: { min: 2, max: 15, total: 15 }
+        videoSeconds: { min: 2, max: 15, total: 15 },
+        ...SEEDANCE_2_AUDIO
       },
       sourceVideoSeconds: { min: 2, max: 15, inReferenceTotal: true },
       ratioIgnoredWith: ["firstFrame", "sourceVideo"],
@@ -1563,7 +1574,7 @@ var VIDEO_MODELS = [
       logo: BYTEDANCE_LOGO,
       description: "Speed- and cost-optimized ByteDance Seedance 2.0 Fast; text plus image, video, and audio references to generate or edit 4-15 second clips."
     },
-    capabilities: { acceptsSourceVideo: true, ...FRAMES_EXCLUDE_REFERENCES }
+    capabilities: { acceptsSourceVideo: true, videoEdit: false, ...FRAMES_EXCLUDE_REFERENCES }
   },
   {
     // omni_reference_task_type edit/extend: adaptive ratio, edit sends duration -1.
@@ -1583,12 +1594,20 @@ var VIDEO_MODELS = [
         images: 30,
         videos: 10,
         audios: 10,
-        videoSeconds: { min: 2, max: 30, total: 30, editMin: 4 }
+        videoSeconds: { min: 2, max: 30, total: 30, editMin: 4 },
+        // BytePlus: 2-30 s per clip, 30 s in all, wav/mp3, 15 MB each.
+        audioSeconds: { min: 2, max: 30, total: 30 },
+        audioFormats: ["wav", "mp3"],
+        audioMaxBytes: 15 * 1024 * 1024
       },
       sourceVideoSeconds: { min: 2, max: 30, editMin: 4, inReferenceTotal: true },
       ratioIgnoredWith: ["firstFrame", "sourceVideo"],
       // No seed: 2.x echoes it but does not honour it (two seeded runs differed, 2026-10-01).
-      supports: ["generateAudio", "lastFrame", "watermark", "taskType"],
+      supports: ["generateAudio", "lastFrame", "watermark", "taskType", "videoExtension"],
+      // Extend (probe 2026-10-02, 480p): returns ONLY the added footage, continuing from
+      // the source's last frame at the source's framing and fps but at the requested
+      // resolution, so the caller joins the clips. Forward only in practice.
+      extension: { segmentSeconds: 30, maxTotalSeconds: 60, returns: "new" },
       prompt: SEEDANCE_PROMPT,
       audio: "optional"
     },
@@ -1605,7 +1624,7 @@ var VIDEO_MODELS = [
       logo: BYTEDANCE_LOGO,
       description: "ByteDance Seedance 2.5 for long-form storytelling and omni-reference generation/editing; up to 50 reference assets and 4-30 second clips at up to 1080p."
     },
-    capabilities: { acceptsSourceVideo: true, ...FRAMES_EXCLUDE_REFERENCES }
+    capabilities: { acceptsSourceVideo: true, videoEdit: true, ...FRAMES_EXCLUDE_REFERENCES }
   },
   {
     id: "grok-imagine",
@@ -1969,11 +1988,116 @@ var VIDEO_MODELS = [
   }
 ];
 
+// src/catalog/video-tools.ts
+var TOPAZ_LOGO = "https://cdn.jsdelivr.net/npm/@lobehub/icons-static-png@1.97.0/light/topazlabs.png";
+var TOPAZ_SOURCE_SECONDS = { max: 300 };
+var TOPAZ_USAGE = { unit: "seconds" };
+var VIDEO_TOOL_MODELS = [
+  {
+    id: "topaz-precision",
+    aliases: [],
+    label: "Topaz Precision",
+    type: "video-tool",
+    adapter: "fal",
+    providerModelId: "topaz/upscale/video/precision",
+    lifecycle: "active",
+    exposure: ["cowork"],
+    constraints: {
+      supports: [],
+      sourceVideoSeconds: TOPAZ_SOURCE_SECONDS,
+      tool: { kind: "upscale", upscaleFactor: { min: 1, max: 4 }, maxOutputLongEdge: 3840 }
+    },
+    defaults: {},
+    providerOptions: { fal: { model: "Proteus" } },
+    usage: TOPAZ_USAGE,
+    pricingKind: "video_per_second",
+    display: {
+      provider: "topaz",
+      logo: TOPAZ_LOGO,
+      description: "Topaz Proteus upscaling: sharper, cleaner footage up to 4K while staying faithful to the source.",
+      sortOrder: 20
+    }
+  },
+  {
+    id: "topaz-starlight",
+    aliases: [],
+    label: "Topaz Starlight",
+    type: "video-tool",
+    adapter: "fal",
+    providerModelId: "topaz/upscale/video/generative",
+    lifecycle: "active",
+    exposure: ["cowork"],
+    constraints: {
+      supports: [],
+      sourceVideoSeconds: TOPAZ_SOURCE_SECONDS,
+      tool: { kind: "upscale", upscaleFactor: { min: 1, max: 4 }, maxOutputLongEdge: 3840 }
+    },
+    defaults: {},
+    providerOptions: { fal: { model: "Starlight Precise 2.6" } },
+    usage: TOPAZ_USAGE,
+    pricingKind: "video_per_second",
+    display: {
+      provider: "topaz",
+      logo: TOPAZ_LOGO,
+      description: "Topaz Starlight Precise 2.6: generative upscaling that rebuilds fine detail, up to 4K. Slower and costlier than Precision.",
+      sortOrder: 10
+    }
+  },
+  {
+    id: "topaz-apollo",
+    aliases: [],
+    label: "Topaz Apollo",
+    type: "video-tool",
+    adapter: "fal",
+    providerModelId: "topaz/interpolate/video",
+    lifecycle: "active",
+    exposure: ["cowork"],
+    constraints: {
+      supports: [],
+      sourceVideoSeconds: TOPAZ_SOURCE_SECONDS,
+      tool: { kind: "interpolate", fps: { min: 16, max: 120 } }
+    },
+    defaults: {},
+    providerOptions: { fal: { model: "Apollo" } },
+    usage: TOPAZ_USAGE,
+    pricingKind: "video_per_second",
+    display: {
+      provider: "topaz",
+      logo: TOPAZ_LOGO,
+      description: "Topaz Apollo frame interpolation: smoother motion at up to 120 fps, same length as the source."
+    }
+  },
+  {
+    id: "topaz-hyperion-2.5",
+    aliases: [],
+    label: "Topaz Hyperion 2.5",
+    type: "video-tool",
+    adapter: "fal",
+    providerModelId: "topaz/sdr-to-hdr/video",
+    lifecycle: "active",
+    exposure: ["cowork"],
+    constraints: {
+      supports: [],
+      sourceVideoSeconds: TOPAZ_SOURCE_SECONDS,
+      tool: { kind: "hdr", outputFormats: ["h265", "prores"] }
+    },
+    defaults: {},
+    usage: TOPAZ_USAGE,
+    pricingKind: "video_per_second",
+    display: {
+      provider: "topaz",
+      logo: TOPAZ_LOGO,
+      description: "Topaz Hyperion 2.5 SDR to HDR: a 10-bit HDR master in H.265 (HDR10) or ProRes 422 HQ, at the source's size and frame rate."
+    }
+  }
+];
+
 // src/catalog/models.ts
 var MODELS = [
   ...TEXT_MODELS,
   ...IMAGE_MODELS,
   ...VIDEO_MODELS,
+  ...VIDEO_TOOL_MODELS,
   ...OTHER_MODELS
 ];
 
@@ -2270,7 +2394,15 @@ var ADAPTER_IDS = [
   "higgsfield",
   "xai-video"
 ];
-var ModelTypeSchema = z3.enum(["text", "image", "video", "audio", "upscale", "bg-remove"]);
+var ModelTypeSchema = z3.enum([
+  "text",
+  "image",
+  "video",
+  "audio",
+  "upscale",
+  "bg-remove",
+  "video-tool"
+]);
 var LifecycleSchema = z3.enum(["active", "deprecated", "retired"]);
 var SurfaceSchema = z3.enum(["cowork", "space_builder"]);
 var SURFACES2 = SurfaceSchema.options;
@@ -2350,7 +2482,22 @@ var ReferenceLimitsSchema = z3.looseObject({
   audios: z3.number().optional(),
   total: z3.number().optional(),
   audioOnly: z3.boolean().optional(),
-  videoSeconds: VideoSecondsLimitsSchema.optional()
+  videoSeconds: VideoSecondsLimitsSchema.optional(),
+  audioSeconds: z3.looseObject({
+    min: z3.number().optional(),
+    max: z3.number().optional(),
+    total: z3.number().optional()
+  }).optional(),
+  audioFormats: z3.array(z3.string()).optional(),
+  audioMaxBytes: z3.number().positive().optional()
+});
+var RangeSchema = z3.looseObject({ min: z3.number(), max: z3.number() });
+var VideoToolConstraintsSchema = z3.looseObject({
+  kind: z3.enum(["upscale", "interpolate", "hdr"]),
+  upscaleFactor: RangeSchema.optional(),
+  maxOutputLongEdge: z3.number().positive().optional(),
+  fps: RangeSchema.optional(),
+  outputFormats: z3.array(z3.enum(["h265", "prores"])).min(1).optional()
 });
 var ModelConstraintsSchema = z3.looseObject({
   aspectRatios: z3.array(AspectRatioSchema).optional(),
@@ -2365,7 +2512,14 @@ var ModelConstraintsSchema = z3.looseObject({
   supports: z3.array(SupportedOptionSchema).optional(),
   ratioIgnoredWith: z3.array(z3.enum(["firstFrame", "sourceVideo"])).optional(),
   sourceVideoSeconds: VideoSecondsLimitsSchema.omit({ total: true }).extend({ inReferenceTotal: z3.boolean().optional() }).optional(),
-  extension: z3.looseObject({ segmentSeconds: z3.number(), maxTotalSeconds: z3.number() }).optional(),
+  // segmentSeconds/maxTotalSeconds stay required: a kit before 0.3.0 drops a row whose
+  // extension lacks them, so every extension block keeps them.
+  extension: z3.looseObject({
+    segmentSeconds: z3.number(),
+    maxTotalSeconds: z3.number(),
+    returns: z3.enum(["new", "joined"]).optional()
+  }).optional(),
+  tool: VideoToolConstraintsSchema.optional(),
   // Loose on purpose: the read path keeps a row whose value is invalid (the accessors in
   // conventions.ts read it as "not set"); CatalogModelSchema below rejects it on write.
   audio: z3.unknown().optional(),
@@ -2437,6 +2591,7 @@ var CatalogDisplaySchema = z3.looseObject({
 });
 var CatalogCapabilitiesSchema = z3.looseObject({
   acceptsSourceVideo: z3.boolean().optional(),
+  videoEdit: z3.boolean().optional(),
   framesExcludeReferences: z3.boolean().optional(),
   lastFrameRequiresFirstFrame: z3.boolean().optional(),
   reasoning: z3.boolean().optional(),
@@ -2479,6 +2634,13 @@ var CatalogModelSchemaBase = z3.looseObject({
       message: "active text rows need contextWindow"
     });
   }
+  if (row.type === "video-tool" && row.constraints.tool === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["constraints", "tool"],
+      message: "video-tool rows need constraints.tool"
+    });
+  }
   if (row.replacedBy !== void 0 && row.replacedBy === row.id) {
     ctx.addIssue({
       code: "custom",
@@ -3485,7 +3647,7 @@ async function generateSeedanceVideo(req, ctx) {
 }
 
 // src/adapters/fal.ts
-import { z as z9 } from "zod";
+import { z as z12 } from "zod";
 import { createFalClient } from "@fal-ai/client";
 
 // src/adapters/fal-http.ts
@@ -3573,6 +3735,364 @@ function createFalHttpClient(opts) {
   };
 }
 
+// src/adapters/fal-gateway.ts
+import { z as z9 } from "zod";
+var falDetailSchema = z9.object({ detail: JsonValueSchema });
+function liftDetail(body) {
+  const parsed = falDetailSchema.safeParse(body);
+  const detail = parsed.success ? parsed.data.detail : void 0;
+  return detail ?? body;
+}
+function falError(status, body, model) {
+  return classifyHttpError(status, liftDetail(body), "fal", model);
+}
+function gatewayConfig(ctx) {
+  const cf = ctx.routing.cloudflare;
+  const falKey = ctx.keys.fal;
+  const cfToken = ctx.keys.cloudflare;
+  if (!cf?.accountId || !cf?.gatewayId || !falKey && !cfToken) {
+    throw new ModelKitError({
+      code: "auth",
+      message: "fal passthrough is not configured. Set routing.cloudflare and FAL_KEY or the gateway token (BYOK).",
+      provider: "fal",
+      model: ctx.model.id,
+      retryable: false
+    });
+  }
+  const config = {
+    baseUrl: `https://gateway.ai.cloudflare.com/v1/${cf.accountId}/${cf.gatewayId}/fal`
+  };
+  if (falKey) config.falKey = falKey;
+  if (cfToken) config.cfToken = cfToken;
+  if (ctx.call.maxRetries !== void 0) config.singleAttempt = true;
+  if (ctx.signal !== void 0) config.signal = ctx.signal;
+  return config;
+}
+async function gatewayFetch(cfg, fetchImpl, targetUrl, init) {
+  const headers2 = { "x-fal-target-url": targetUrl };
+  if (cfg.falKey) headers2.Authorization = `Bearer ${cfg.falKey}`;
+  if (init.body) headers2["Content-Type"] = "application/json";
+  if (cfg.cfToken) headers2["cf-aig-authorization"] = `Bearer ${cfg.cfToken}`;
+  if (cfg.singleAttempt) headers2["cf-aig-max-attempts"] = "1";
+  const request = { method: init.method, headers: headers2 };
+  if (cfg.signal !== void 0) request.signal = cfg.signal;
+  if (init.body !== void 0) request.body = init.body;
+  return fetchImpl(cfg.baseUrl, request);
+}
+
+// src/adapters/fal-video-tools.ts
+import { z as z11 } from "zod";
+
+// src/catalog/video-tools-spec.ts
+import { z as z10 } from "zod";
+var RangeSchema2 = z10.object({ min: z10.number(), max: z10.number() });
+var ToolSchema = z10.object({
+  kind: z10.enum(["upscale", "interpolate", "hdr"]),
+  upscaleFactor: RangeSchema2.optional(),
+  maxOutputLongEdge: z10.number().positive().optional(),
+  fps: RangeSchema2.optional(),
+  outputFormats: z10.array(z10.enum(["h265", "prores"])).min(1).optional()
+});
+function videoToolConstraints(row) {
+  if (row.type !== "video-tool") return void 0;
+  const parsed = ToolSchema.safeParse(row.constraints.tool);
+  if (!parsed.success) return void 0;
+  const { kind, upscaleFactor, maxOutputLongEdge, fps, outputFormats } = parsed.data;
+  return {
+    kind,
+    ...upscaleFactor !== void 0 && { upscaleFactor },
+    ...maxOutputLongEdge !== void 0 && { maxOutputLongEdge },
+    ...fps !== void 0 && { fps },
+    ...outputFormats !== void 0 && { outputFormats }
+  };
+}
+function resolutionTier(width, height) {
+  const shortEdge = Math.min(width, height);
+  if (shortEdge <= 360) return "360p";
+  if (shortEdge <= 480) return "480p";
+  if (shortEdge <= 720) return "720p";
+  if (shortEdge <= 1080) return "1080p";
+  if (shortEdge <= 1440) return "2k";
+  return "4k";
+}
+function fail(error) {
+  return { ok: false, error };
+}
+function planVideoTool(row, req) {
+  const tool = videoToolConstraints(row);
+  if (!tool) return fail(`${row.id} is not a video tool`);
+  const { width, height, durationSeconds, fps } = req.source;
+  if (!(width > 0 && height > 0 && durationSeconds > 0)) {
+    return fail("The source video's width, height and duration are required");
+  }
+  const maxSeconds = row.constraints.sourceVideoSeconds?.max;
+  if (maxSeconds !== void 0 && durationSeconds > maxSeconds) {
+    return fail(`${row.label} takes source videos up to ${maxSeconds} seconds.`);
+  }
+  const base = {
+    durationSeconds,
+    ...fps !== void 0 && { fps }
+  };
+  if (tool.kind === "upscale") {
+    const factor = req.upscaleFactor;
+    if (factor === void 0) return fail("An upscale factor is required");
+    const range = tool.upscaleFactor;
+    if (range && (factor < range.min || factor > range.max)) {
+      return fail(`${row.label} upscales by ${range.min}x to ${range.max}x.`);
+    }
+    const outWidth = Math.round(width * factor);
+    const outHeight = Math.round(height * factor);
+    const limit = tool.maxOutputLongEdge;
+    if (limit !== void 0 && Math.max(outWidth, outHeight) > limit) {
+      return fail(
+        `A ${factor}x upscale of a ${width}x${height} video passes the ${limit}px limit.`
+      );
+    }
+    return {
+      ok: true,
+      output: {
+        ...base,
+        width: outWidth,
+        height: outHeight,
+        resolution: resolutionTier(outWidth, outHeight),
+        format: "h264"
+      }
+    };
+  }
+  if (tool.kind === "interpolate") {
+    const target = req.targetFps;
+    if (target === void 0 || !Number.isInteger(target)) {
+      return fail("A whole-number target frame rate is required");
+    }
+    const range = tool.fps;
+    if (range && (target < range.min || target > range.max)) {
+      return fail(`${row.label} outputs ${range.min} to ${range.max} fps.`);
+    }
+    return {
+      ok: true,
+      output: {
+        durationSeconds,
+        fps: target,
+        width,
+        height,
+        resolution: resolutionTier(width, height),
+        format: "h264"
+      }
+    };
+  }
+  const formats = tool.outputFormats ?? ["h265"];
+  const format = req.outputFormat ?? formats[0] ?? "h265";
+  if (!formats.includes(format)) {
+    return fail(`${row.label} writes ${formats.join(" or ")}.`);
+  }
+  return {
+    ok: true,
+    output: { ...base, width, height, resolution: resolutionTier(width, height), format }
+  };
+}
+
+// src/adapters/fal-video-tools.ts
+var FAL_QUEUE_ORIGIN = "https://queue.fal.run";
+var queueUrlSchema = z11.url().refine((value) => new URL(value).origin === FAL_QUEUE_ORIGIN, {
+  message: "not a fal queue URL"
+});
+var submitResponseSchema = z11.object({
+  request_id: z11.string().min(1),
+  status_url: queueUrlSchema,
+  response_url: queueUrlSchema,
+  cancel_url: queueUrlSchema
+});
+var statusResponseSchema = z11.object({ status: z11.string() });
+var videoFileSchema = z11.object({
+  url: z11.url(),
+  content_type: z11.string().nullish(),
+  file_size: z11.number().nullish()
+});
+var toolOutputSchema = z11.object({ video: videoFileSchema });
+var falWebhookBodySchema = z11.object({
+  request_id: z11.string().min(1),
+  gateway_request_id: z11.string().nullish(),
+  status: z11.enum(["OK", "ERROR"]),
+  payload: JsonValueSchema.nullish(),
+  error: z11.string().nullish(),
+  payload_error: JsonValueSchema.nullish()
+});
+async function queueFetch(ctx, url, method, body) {
+  const payload = body === void 0 ? void 0 : JSON.stringify(body);
+  try {
+    if (ctx.routing.fal === "cloudflare-passthrough") {
+      return await gatewayFetch(gatewayConfig(ctx), ctx.fetch, url, {
+        method,
+        ...payload !== void 0 && { body: payload }
+      });
+    }
+    const falKey = ctx.keys.fal;
+    if (!falKey) {
+      throw new ModelKitError({
+        code: "auth",
+        message: "Missing API key for fal",
+        provider: "fal",
+        model: ctx.model.id,
+        retryable: false
+      });
+    }
+    return await ctx.fetch(url, {
+      method,
+      headers: {
+        Authorization: `Key ${falKey}`,
+        ...payload !== void 0 && { "Content-Type": "application/json" }
+      },
+      ...payload !== void 0 && { body: payload },
+      ...ctx.signal !== void 0 && { signal: ctx.signal }
+    });
+  } catch (cause) {
+    if (cause instanceof ModelKitError) throw cause;
+    throw classifyThrown("fal", cause, ctx.model.id);
+  }
+}
+async function readJson(ctx, res) {
+  if (!res.ok) throw falError(res.status, await readBody(res), ctx.model.id);
+  return JsonValueSchema.parse(await res.json());
+}
+function providerModelName(ctx) {
+  return z11.string().safeParse(ctx.model.providerOptions?.["fal"]?.["model"]).data;
+}
+function toolInput(ctx, req, output) {
+  const tool = videoToolConstraints(ctx.model);
+  const model = providerModelName(ctx);
+  const input = { video_url: req.source.url };
+  if (tool?.kind === "upscale") {
+    if (model !== void 0) input["model"] = model;
+    input["upscale_factor"] = req.upscaleFactor ?? 1;
+    input["H264_output"] = true;
+  } else if (tool?.kind === "interpolate") {
+    if (model !== void 0) input["model"] = model;
+    input["target_fps"] = req.targetFps ?? 60;
+    input["slowdown_factor"] = 1;
+    input["H264_output"] = true;
+  } else {
+    input["output_format"] = output.format === "prores" ? "prores" : "mp4";
+  }
+  return input;
+}
+async function submitFalVideoTool(req, ctx, opts) {
+  const plan = planVideoTool(ctx.model, req);
+  if (!plan.ok) {
+    throw new ModelKitError({
+      code: "unsupported_option",
+      message: plan.error,
+      provider: "fal",
+      model: ctx.model.id,
+      retryable: false
+    });
+  }
+  const target = new URL(`${FAL_QUEUE_ORIGIN}/${ctx.model.providerModelId}`);
+  if (opts.webhookUrl !== void 0) target.searchParams.set("fal_webhook", opts.webhookUrl);
+  const res = await queueFetch(ctx, target.toString(), "POST", toolInput(ctx, req, plan.output));
+  const parsed = submitResponseSchema.safeParse(await readJson(ctx, res));
+  if (!parsed.success) {
+    throw new ModelKitError({
+      code: "provider_rejected",
+      message: `fal ${ctx.model.providerModelId} submit returned no queue URLs`,
+      provider: "fal",
+      model: ctx.model.id,
+      retryable: false
+    });
+  }
+  return {
+    model: ctx.model.id,
+    provider: "fal",
+    requestId: parsed.data.request_id,
+    statusUrl: parsed.data.status_url,
+    responseUrl: parsed.data.response_url,
+    cancelUrl: parsed.data.cancel_url,
+    output: plan.output
+  };
+}
+function checkedQueueUrl(ctx, url) {
+  if (!queueUrlSchema.safeParse(url).success) {
+    throw new ModelKitError({
+      code: "provider_rejected",
+      message: "Video-tool submission carries a URL outside fal's queue",
+      provider: "fal",
+      model: ctx.model.id,
+      retryable: false
+    });
+  }
+  return url;
+}
+async function falVideoToolStatus(sub, ctx) {
+  const res = await queueFetch(ctx, checkedQueueUrl(ctx, sub.statusUrl), "GET");
+  const { status } = statusResponseSchema.parse(await readJson(ctx, res));
+  if (status === "IN_QUEUE") return "queued";
+  if (status === "COMPLETED") return "completed";
+  return "running";
+}
+function usageOf(ctx, output) {
+  return {
+    model: ctx.model.id,
+    provider: "fal",
+    modality: "VIDEO",
+    unit: "seconds",
+    quantity: output.durationSeconds,
+    durationSeconds: output.durationSeconds,
+    resolution: output.resolution,
+    ...output.fps !== void 0 && { fps: output.fps }
+  };
+}
+function resultOf(ctx, sub, payload) {
+  const parsed = toolOutputSchema.safeParse(payload);
+  if (!parsed.success) {
+    throw new ModelKitError({
+      code: "provider_rejected",
+      message: `fal ${ctx.model.providerModelId} returned no video`,
+      provider: "fal",
+      model: ctx.model.id,
+      retryable: false
+    });
+  }
+  const file = parsed.data.video;
+  return {
+    video: {
+      url: file.url,
+      ...file.content_type != null && { mime: file.content_type },
+      ...file.file_size != null && { bytes: file.file_size }
+    },
+    output: sub.output,
+    usage: usageOf(ctx, sub.output),
+    raw: payload
+  };
+}
+async function falVideoToolResult(sub, ctx, webhook) {
+  if (webhook !== void 0) {
+    if (webhook.request_id !== sub.requestId) {
+      throw new ModelKitError({
+        code: "provider_rejected",
+        message: "fal webhook is for a different request",
+        provider: "fal",
+        model: ctx.model.id,
+        retryable: false
+      });
+    }
+    if (webhook.status === "ERROR") {
+      throw falError(
+        void 0,
+        webhook.payload ?? webhook.error ?? "fal job failed",
+        ctx.model.id
+      );
+    }
+    return resultOf(ctx, sub, webhook.payload);
+  }
+  const res = await queueFetch(ctx, checkedQueueUrl(ctx, sub.responseUrl), "GET");
+  return resultOf(ctx, sub, await readJson(ctx, res));
+}
+async function cancelFalVideoTool(sub, ctx) {
+  const res = await queueFetch(ctx, checkedQueueUrl(ctx, sub.cancelUrl), "PUT");
+  if (res.ok) return true;
+  if (res.status === 400) return false;
+  throw falError(res.status, await readBody(res), ctx.model.id);
+}
+
 // src/adapters/fal.ts
 var MUSE_T2I_ENDPOINT = "meta/muse-image/text-to-image";
 var MUSE_EDIT_ENDPOINT = "meta/muse-image/edit";
@@ -3580,7 +4100,7 @@ var KLING_O1_ENDPOINT = "fal-ai/kling-video/o1/video-to-video/reference";
 var FAL_QUEUE_HOST = "https://queue.fal.run";
 var PASSTHROUGH_POLL_MS = 2e3;
 var PASSTHROUGH_MAX_WAIT_MS = 18e4;
-var falSubscribePayloadSchema = z9.object({ data: JsonValueSchema });
+var falSubscribePayloadSchema = z12.object({ data: JsonValueSchema });
 function defaultCreateFalClient(opts) {
   if (opts.maxRetries !== void 0)
     return createFalHttpClient({
@@ -3633,24 +4153,19 @@ function createFalAdapter(deps = defaultDeps) {
     generateVideo: (req, ctx) => {
       throwIfAborted(ctx.signal);
       return generateFalVideo(req, ctx, deps);
-    }
+    },
+    submitVideoTool: submitFalVideoTool,
+    videoToolStatus: falVideoToolStatus,
+    videoToolResult: falVideoToolResult,
+    cancelVideoTool: cancelFalVideoTool
   };
 }
 var falAdapter = createFalAdapter();
-var falDetailSchema = z9.object({ detail: JsonValueSchema });
-function liftDetail(body) {
-  const parsed = falDetailSchema.safeParse(body);
-  const detail = parsed.success ? parsed.data.detail : void 0;
-  return detail ?? body;
-}
-function falError(status, body, model) {
-  return classifyHttpError(status, liftDetail(body), "fal", model);
-}
-var falSdkThrownSchema = z9.object({
-  status: z9.number().optional(),
-  statusCode: z9.number().optional(),
+var falSdkThrownSchema = z12.object({
+  status: z12.number().optional(),
+  statusCode: z12.number().optional(),
   body: JsonValueSchema.optional(),
-  message: z9.string().optional()
+  message: z12.string().optional()
 });
 function falSdkError(cause, model) {
   const parsed = falSdkThrownSchema.safeParse(cause);
@@ -3665,45 +4180,12 @@ function falSdkError(cause, model) {
     body: liftDetail(info.body)
   });
 }
-function gatewayConfig(ctx) {
-  const cf = ctx.routing.cloudflare;
-  const falKey = ctx.keys.fal;
-  const cfToken = ctx.keys.cloudflare;
-  if (!cf?.accountId || !cf?.gatewayId || !falKey && !cfToken) {
-    throw new ModelKitError({
-      code: "auth",
-      message: "fal passthrough is not configured. Set routing.cloudflare and FAL_KEY or the gateway token (BYOK).",
-      provider: "fal",
-      model: ctx.model.id,
-      retryable: false
-    });
-  }
-  const config = {
-    baseUrl: `https://gateway.ai.cloudflare.com/v1/${cf.accountId}/${cf.gatewayId}/fal`
-  };
-  if (falKey) config.falKey = falKey;
-  if (cfToken) config.cfToken = cfToken;
-  if (ctx.call.maxRetries !== void 0) config.singleAttempt = true;
-  if (ctx.signal !== void 0) config.signal = ctx.signal;
-  return config;
-}
-async function gatewayFetch(cfg, fetchImpl, targetUrl, init) {
-  const headers2 = { "x-fal-target-url": targetUrl };
-  if (cfg.falKey) headers2.Authorization = `Bearer ${cfg.falKey}`;
-  if (init.body) headers2["Content-Type"] = "application/json";
-  if (cfg.cfToken) headers2["cf-aig-authorization"] = `Bearer ${cfg.cfToken}`;
-  if (cfg.singleAttempt) headers2["cf-aig-max-attempts"] = "1";
-  const request = { method: init.method, headers: headers2 };
-  if (cfg.signal !== void 0) request.signal = cfg.signal;
-  if (init.body !== void 0) request.body = init.body;
-  return fetchImpl(cfg.baseUrl, request);
-}
-var falQueueSubmitSchema = z9.object({
-  request_id: z9.string(),
-  status_url: z9.string(),
-  response_url: z9.string()
+var falQueueSubmitSchema = z12.object({
+  request_id: z12.string(),
+  status_url: z12.string(),
+  response_url: z12.string()
 });
-var falQueueStatusSchema = z9.object({ status: z9.string() });
+var falQueueStatusSchema = z12.object({ status: z12.string() });
 async function passthroughRequest(ctx, endpoint, input) {
   const cfg = gatewayConfig(ctx);
   const submitRes = await gatewayFetch(cfg, ctx.fetch, `${FAL_QUEUE_HOST}/${endpoint}`, {
@@ -3836,11 +4318,11 @@ async function decodeImage(ctx, url, contentType) {
   const mime = res.headers.get("content-type") ?? contentType ?? "image/png";
   return { bytes: new Uint8Array(await res.arrayBuffer()), mime };
 }
-var museImageResultSchema = z9.object({
-  images: z9.array(
-    z9.object({
-      url: z9.string().optional(),
-      content_type: z9.string().nullable().optional()
+var museImageResultSchema = z12.object({
+  images: z12.array(
+    z12.object({
+      url: z12.string().optional(),
+      content_type: z12.string().nullable().optional()
     })
   ).optional()
 });
@@ -4010,8 +4492,8 @@ function klingO1Input(req) {
   if (refs.length > 0) input.image_urls = refs;
   return input;
 }
-var falVideoResultSchema = z9.object({
-  video: z9.object({ url: z9.string().optional() }).optional()
+var falVideoResultSchema = z12.object({
+  video: z12.object({ url: z12.string().optional() }).optional()
 });
 function extractVideoUrl(result, endpoint, model) {
   const parsed = falVideoResultSchema.safeParse(result);
@@ -4212,13 +4694,13 @@ async function passthroughVideoJob(ctx, req, endpoint, input) {
 }
 
 // src/adapters/google-genai.ts
-import { z as z11 } from "zod";
+import { z as z14 } from "zod";
 import {
   GoogleGenAI
 } from "@google/genai";
 
 // src/adapters/google-files.ts
-import { z as z10 } from "zod";
+import { z as z13 } from "zod";
 var GOOGLE_FILES_BASE = "https://generativelanguage.googleapis.com";
 var GOOGLE_FILES_POLL_INTERVAL_MS = 2e3;
 var GOOGLE_FILES_POLL_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -4228,17 +4710,17 @@ var GENERIC_MEDIA_TYPES = /* @__PURE__ */ new Set([
   "binary/octet-stream",
   "application/binary"
 ]);
-var uploadedFileSchema = z10.object({
-  file: z10.object({
-    uri: z10.string().optional(),
-    name: z10.string().optional(),
-    state: z10.string().optional(),
-    mimeType: z10.string().optional()
+var uploadedFileSchema = z13.object({
+  file: z13.object({
+    uri: z13.string().optional(),
+    name: z13.string().optional(),
+    state: z13.string().optional(),
+    mimeType: z13.string().optional()
   }).optional()
 });
-var fileStateSchema = z10.object({
-  state: z10.string().optional(),
-  error: z10.object({ message: z10.string().optional() }).optional()
+var fileStateSchema = z13.object({
+  state: z13.string().optional(),
+  error: z13.object({ message: z13.string().optional() }).optional()
 });
 function resolveMime(declared, fallback) {
   const clean = declared?.split(";")[0]?.trim().toLowerCase();
@@ -4455,7 +4937,7 @@ var OMNI_POLL_INTERVAL_MS = 1e4;
 var RESULT_TIMEOUT_MS2 = 15 * 60 * 1e3;
 var OMNI_INLINE_LIMIT_BYTES = 4 * 1024 * 1024;
 var MEDIA_PART_INLINE_LIMIT_BYTES = 20 * 1024 * 1024;
-var errorTextSchema = z11.string();
+var errorTextSchema = z14.string();
 function isGoogleGenaiVideoKnown(providerModelId) {
   return providerModelId.startsWith("veo-") || providerModelId.startsWith("gemini-omni");
 }
@@ -5061,15 +5543,15 @@ async function prepareGoogleMediaPart(ref, mediaType, ctx) {
 // src/adapters/google-image.ts
 import { createGoogleGenerativeAI as createGoogleGenerativeAI2 } from "@ai-sdk/google";
 import { generateText } from "ai";
-import { z as z12 } from "zod";
+import { z as z15 } from "zod";
 var GEMINI_IMAGE_TIMEOUT_MS = 6e5;
 var defaultGoogleImageDeps = {
   createGoogleClient: (opts) => createGoogleGenerativeAI2(opts),
   runTextGeneration: (opts) => generateText(opts)
 };
-var causeChainNodeSchema = z12.object({
-  message: z12.string().optional(),
-  cause: z12.unknown().optional()
+var causeChainNodeSchema = z15.object({
+  message: z15.string().optional(),
+  cause: z15.unknown().optional()
 });
 function extractBlockReason(cause) {
   let current = cause;
@@ -5189,7 +5671,7 @@ function createGoogleImageAdapter(deps = defaultGoogleImageDeps) {
 var googleImageAdapter = createGoogleImageAdapter();
 
 // src/adapters/higgsfield.ts
-import { z as z13 } from "zod";
+import { z as z16 } from "zod";
 
 // src/adapters/higgsfield-motions.ts
 var MOTION_MAP = {
@@ -5408,14 +5890,14 @@ function klingEndpointFields(providerModelId) {
   const path = (providerModelId.startsWith("/") ? providerModelId.slice(1) : providerModelId).toLowerCase();
   return KLING_ENDPOINT_FIELDS.get(path) ?? UNLISTED_KLING_FIELDS;
 }
-var klingCreateSchema = z13.object({ status_url: z13.string() });
-var klingStatusSchema = z13.object({
-  status: z13.string().optional(),
-  video: z13.object({ url: z13.string().optional() }).optional(),
+var klingCreateSchema = z16.object({ status_url: z16.string() });
+var klingStatusSchema = z16.object({
+  status: z16.string().optional(),
+  video: z16.object({ url: z16.string().optional() }).optional(),
   error: JsonValueSchema.optional()
 });
-var errorMessageSchema = z13.object({ message: z13.string().optional() });
-var textValueSchema = z13.string();
+var errorMessageSchema = z16.object({ message: z16.string().optional() });
+var textValueSchema = z16.string();
 function klingErrorDetail(error) {
   if (error === void 0) return "unknown_error";
   const asText = textValueSchema.safeParse(error);
@@ -5571,8 +6053,8 @@ async function generateKlingVideo(req, ctx) {
     }
   };
 }
-var dopMotionOptionsSchema = z13.object({
-  modelkit: z13.object({ motion: z13.string().optional() }).optional()
+var dopMotionOptionsSchema = z16.object({
+  modelkit: z16.object({ motion: z16.string().optional() }).optional()
 });
 function dopMotionId(ctx) {
   const parsed = dopMotionOptionsSchema.safeParse(ctx.model.providerOptions);
@@ -5588,7 +6070,7 @@ function dopMotionId(ctx) {
     });
   return id;
 }
-var jsonRecordSchema = z13.record(z13.string(), JsonValueSchema);
+var jsonRecordSchema = z16.record(z16.string(), JsonValueSchema);
 var DOP_URL_KEYS = ["url", "video_url", "output_url", "result_url", "download_url"];
 var DOP_NESTED_KEYS = ["video", "result", "results"];
 function dopUrl(body) {
@@ -5616,8 +6098,8 @@ function dopUrl(body) {
   }
   return void 0;
 }
-var dopCreateSchema = z13.object({ id: z13.string() });
-var dopStatusSchema = z13.object({ status: z13.string().optional() });
+var dopCreateSchema = z16.object({ id: z16.string() });
+var dopStatusSchema = z16.object({ status: z16.string().optional() });
 async function generateDopVideo(req, ctx) {
   const firstFrame = req.firstFrame ? refToUrl(req.firstFrame) : void 0;
   if (!firstFrame) {
@@ -5745,7 +6227,7 @@ var higgsfieldAdapter = {
 
 // src/adapters/openai-image.ts
 import OpenAI from "openai";
-import { z as z14 } from "zod";
+import { z as z17 } from "zod";
 var MAX_EDIT_REFERENCES = 16;
 function aspectRatioToSize(ratio, tier) {
   const TIER_LONG_EDGE = {
@@ -5828,9 +6310,9 @@ function toProviderError2(cause, ctx) {
     ctx.model.id
   );
 }
-var openaiUsageSchema = z14.object({
-  input_tokens: z14.number().optional(),
-  output_tokens: z14.number().optional()
+var openaiUsageSchema = z17.object({
+  input_tokens: z17.number().optional(),
+  output_tokens: z17.number().optional()
 });
 var openaiImageAdapter = {
   id: "openai-image",
@@ -6241,13 +6723,13 @@ var prodiaAdapter = {
 import Replicate from "replicate";
 
 // src/adapters/replicate-http.ts
-import { z as z15 } from "zod";
-var predictionSchema = z15.object({
-  id: z15.string(),
-  status: z15.string(),
+import { z as z18 } from "zod";
+var predictionSchema = z18.object({
+  id: z18.string(),
+  status: z18.string(),
   output: JsonValueSchema.optional(),
   error: JsonValueSchema.optional(),
-  metrics: z15.object({ predict_time: z15.number().optional() }).optional()
+  metrics: z18.object({ predict_time: z18.number().optional() }).optional()
 });
 function createReplicateHttpClient(opts) {
   async function request(path, body, signal) {
@@ -6298,7 +6780,7 @@ function createReplicateHttpClient(opts) {
 }
 
 // src/adapters/replicate.ts
-import { z as z16 } from "zod";
+import { z as z19 } from "zod";
 
 // src/adapters/input-spec-mapper.ts
 function canonicalValue(req, key) {
@@ -6373,8 +6855,8 @@ function route(providerModelId) {
   if (!providerModelId.includes("/")) return { version: providerModelId };
   return { model: providerModelId };
 }
-var replicateResponseStatusSchema = z16.object({
-  response: z16.object({ status: z16.number() }).partial()
+var replicateResponseStatusSchema = z19.object({
+  response: z19.object({ status: z19.number() }).partial()
 });
 function replicateError(cause, ctx) {
   if (isModelKitError(cause)) return cause;
@@ -6401,7 +6883,7 @@ function isUrlFn(value) {
 function extractOutputUrl(output) {
   const root = Array.isArray(output) ? output[0] : output;
   if (root === void 0) throw noOutput();
-  const asString = z16.string().safeParse(root);
+  const asString = z19.string().safeParse(root);
   if (asString.success && asString.data) return asString.data;
   if (root instanceof URL) return root.href;
   if (isObjectOutput(root)) {
@@ -6410,15 +6892,15 @@ function extractOutputUrl(output) {
       if (urlValue !== void 0 && isUrlFn(urlValue)) {
         const called = urlValue();
         if (called instanceof URL) return called.href;
-        const calledString = z16.string().safeParse(called);
+        const calledString = z19.string().safeParse(called);
         if (calledString.success && calledString.data) return calledString.data;
       } else {
-        const direct = z16.string().safeParse(urlValue);
+        const direct = z19.string().safeParse(urlValue);
         if (direct.success && direct.data) return direct.data;
       }
     }
     if ("default" in root) {
-      const fallback = z16.string().safeParse(root.default);
+      const fallback = z19.string().safeParse(root.default);
       if (fallback.success && fallback.data) return fallback.data;
     }
   }
@@ -6479,7 +6961,7 @@ async function runPrediction(ctx, input, deps) {
     }
     return void 0;
   }, pollOpts);
-  const predictTime = z16.number().safeParse(done.metrics?.predict_time);
+  const predictTime = z19.number().safeParse(done.metrics?.predict_time);
   if (done.output === void 0) throw noOutput();
   return {
     url: extractOutputUrl(done.output),
@@ -6868,7 +7350,7 @@ async function generateReplicateVideo(req, ctx, deps) {
       throw replicateError(cause, ctx);
     }
     if (current.status === "succeeded") {
-      const predictTime = z16.number().safeParse(current.metrics?.predict_time);
+      const predictTime = z19.number().safeParse(current.metrics?.predict_time);
       if (current.output === void 0) throw noOutput();
       return {
         url: extractOutputUrl(current.output),
@@ -7009,7 +7491,7 @@ async function generateReplicateAudio(req, ctx, deps) {
 // src/adapters/xai-video.ts
 import { experimental_generateVideo } from "ai";
 import { createXai as createXai2 } from "@ai-sdk/xai";
-import { z as z17 } from "zod";
+import { z as z20 } from "zod";
 var POLL_INTERVAL_MS2 = 1e4;
 var POLL_TIMEOUT_MS2 = 15 * 6e4;
 var defaultXaiDeps = {
@@ -7022,8 +7504,8 @@ function createXaiVideoAdapter(deps = defaultXaiDeps) {
   };
 }
 var xaiVideoAdapter = createXaiVideoAdapter();
-var xaiResponseStatusSchema = z17.object({
-  response: z17.object({ status: z17.number() }).partial()
+var xaiResponseStatusSchema = z20.object({
+  response: z20.object({ status: z20.number() }).partial()
 });
 function xaiError(cause, ctx) {
   const info = describeThrown(cause);
@@ -7031,12 +7513,12 @@ function xaiError(cause, ctx) {
   const status = info.status ?? (nested.success ? nested.data.response?.status : void 0);
   return classifyThrown("xai-video", cause, ctx.model.id, { status, body: info.body });
 }
-var xaiMetaSchema = z17.object({
+var xaiMetaSchema = z20.object({
   videoUrl: JsonValueSchema.optional(),
   costInUsdTicks: JsonValueSchema.optional(),
   duration: JsonValueSchema.optional()
 });
-var xaiProviderMetadataSchema = z17.object({ xai: xaiMetaSchema });
+var xaiProviderMetadataSchema = z20.object({ xai: xaiMetaSchema });
 function metaOf(result) {
   const parsed = xaiProviderMetadataSchema.partial().safeParse(result.providerMetadata);
   if (!parsed.success) return {};
@@ -7144,7 +7626,7 @@ async function mapResult(ctx, req, result) {
     };
   }
   const meta = metaOf(result);
-  const videoUrl = z17.string().safeParse(meta.videoUrl);
+  const videoUrl = z20.string().safeParse(meta.videoUrl);
   if (videoUrl.success && videoUrl.data) {
     const res = await ctx.fetch(videoUrl.data);
     if (!res.ok) {
@@ -7167,7 +7649,7 @@ async function mapResult(ctx, req, result) {
   });
 }
 function usage(ctx, req, meta) {
-  const costTicks = z17.number().safeParse(meta.costInUsdTicks);
+  const costTicks = z20.number().safeParse(meta.costInUsdTicks);
   const cost = costTicks.success ? costTicks.data / 1e10 : void 0;
   const event = {
     model: ctx.model.id,
@@ -7300,22 +7782,22 @@ var liveState = store[KEY] ??= {
 var liveCatalog = liveState.catalog;
 
 // src/catalog/load.ts
-import { z as z18 } from "zod";
+import { z as z21 } from "zod";
 function rowCount() {
   return liveCatalog.list({ lifecycle: ["active", "deprecated", "retired"] }).length;
 }
 function authHeaders(auth) {
   return "bearer" in auth ? { Authorization: `Bearer ${auth.bearer}` } : { "x-api-key": auth.apiKey };
 }
-var EnvelopeSchema = z18.object({
-  rows: z18.array(JsonValueSchema),
-  revision: z18.string().optional()
+var EnvelopeSchema = z21.object({
+  rows: z21.array(JsonValueSchema),
+  revision: z21.string().optional()
 });
 function dropReason(path, message) {
   return path.length === 0 ? message : `${path.map((part) => String(part)).join(".")} ${message}`;
 }
 function rowId(raw) {
-  const parsed = z18.object({ id: z18.string().min(1) }).loose().safeParse(raw);
+  const parsed = z21.object({ id: z21.string().min(1) }).loose().safeParse(raw);
   if (!parsed.success) return "?";
   return parsed.data.id;
 }
@@ -8179,7 +8661,7 @@ import {
   streamObject as aiStreamObject2,
   streamText as aiStreamText2
 } from "ai";
-import { z as z19 } from "zod";
+import { z as z22 } from "zod";
 
 // src/generated-image.ts
 function toGeneratedImage(image) {
@@ -8235,11 +8717,17 @@ function textUsageProvider(model, transport) {
 }
 
 // src/client.ts
-function requiredKeys(model, config, transport) {
-  if (model.adapter === "fal" && config.routing?.fal === "cloudflare-passthrough")
-    return ["cloudflare"];
+function routingFor(config, tier) {
+  const routing = config.routing ?? {};
+  if (tier !== "sloosh") return routing;
+  const direct = { ...routing };
+  if (direct.text === "cloudflare") direct.text = "direct";
+  if (direct.fal === "cloudflare-passthrough") direct.fal = "direct";
+  return direct;
+}
+function requiredKeys(model, routing, transport) {
+  if (model.adapter === "fal" && routing.fal === "cloudflare-passthrough") return ["cloudflare"];
   if (model.adapter === "ai-sdk-text") {
-    const routing = config.routing ?? {};
     const names = [textKeyName(model, transport)];
     if (textUsesCloudflareGateway(model, routing, transport)) names.push("cloudflare");
     return names;
@@ -8255,10 +8743,10 @@ function textAbortOptions(sdk, context) {
   if (abortSignal) return { abortSignal };
   return {};
 }
-var catalogId = z19.string();
-var exactSize = z19.templateLiteral([z19.number(), "x", z19.number()]);
-var sdkRatio = z19.templateLiteral([z19.number(), ":", z19.number()]);
-var sizeTier = z19.enum(["512", "1K", "2K", "4K"]);
+var catalogId = z22.string();
+var exactSize = z22.templateLiteral([z22.number(), "x", z22.number()]);
+var sdkRatio = z22.templateLiteral([z22.number(), ":", z22.number()]);
+var sizeTier = z22.enum(["512", "1K", "2K", "4K"]);
 function isCatalogId(model) {
   return catalogId.safeParse(model).success;
 }
@@ -8343,7 +8831,8 @@ function createModelKit(config, adapters) {
         model: model.id
       });
     const transport = resolveAnthropicTransport(model, config, call.tier, warnOnce);
-    const names = requiredKeys(model, config, transport);
+    const routing = routingFor(config, call.tier);
+    const names = requiredKeys(model, routing, transport);
     if (call.tier === "enterprise") {
       const missing = missingEnterpriseKeys(config, names);
       if (missing.length > 0)
@@ -8356,7 +8845,7 @@ function createModelKit(config, adapters) {
     const ctx = {
       model,
       keys,
-      routing: config.routing ?? {},
+      routing,
       fetch: fetchImpl,
       logger,
       call,
@@ -8367,6 +8856,24 @@ function createModelKit(config, adapters) {
     if (call.signal) ctx.signal = call.signal;
     return { adapter, ctx };
   }
+  function videoToolTarget(modelId, call) {
+    mediaRetryOptions(call);
+    const model = catalog.require(modelId);
+    if (model.type !== "video-tool")
+      throw new ModelKitError({
+        code: "unsupported_option",
+        message: `${model.id} is not a video tool`,
+        model: model.id
+      });
+    return context(model, call, []);
+  }
+  function noVideoTools(adapter, model) {
+    return new ModelKitError({
+      code: "unsupported_option",
+      message: `${adapter.id} has no video tools`,
+      model: model.id
+    });
+  }
   async function emit(event) {
     try {
       await config.onUsage?.(event);
@@ -8722,6 +9229,34 @@ function createModelKit(config, adapters) {
         usageProvider: provider
       };
     },
+    async submitVideoTool(req, call = {}) {
+      const { webhookUrl, ...rest } = call;
+      const { adapter, ctx } = videoToolTarget(req.model, rest);
+      if (!adapter.submitVideoTool) throw noVideoTools(adapter, ctx.model);
+      return adapter.submitVideoTool(
+        req,
+        ctx,
+        webhookUrl !== void 0 ? { webhookUrl } : {}
+      );
+    },
+    async videoToolStatus(sub, call = {}) {
+      const { adapter, ctx } = videoToolTarget(sub.model, call);
+      if (!adapter.videoToolStatus) throw noVideoTools(adapter, ctx.model);
+      return adapter.videoToolStatus(sub, ctx);
+    },
+    async videoToolResult(sub, call = {}) {
+      const { webhook, ...rest } = call;
+      const { adapter, ctx } = videoToolTarget(sub.model, rest);
+      if (!adapter.videoToolResult) throw noVideoTools(adapter, ctx.model);
+      const result = await adapter.videoToolResult(sub, ctx, webhook);
+      await emit({ ...result.usage, model: ctx.model.id, unit: ctx.model.usage.unit });
+      return result;
+    },
+    async cancelVideoTool(sub, call = {}) {
+      const { adapter, ctx } = videoToolTarget(sub.model, call);
+      if (!adapter.cancelVideoTool) throw noVideoTools(adapter, ctx.model);
+      return adapter.cancelVideoTool(sub, ctx);
+    },
     usageProvider(modelId, call = {}) {
       const entry = catalog.require(modelId);
       if (entry.type !== "text") return entry.adapter;
@@ -8847,6 +9382,7 @@ export {
   SURFACES2 as SURFACES,
   SurfaceSchema,
   VIDEO_INPUT_SPEC_KEYS,
+  VIDEO_TOOL_MODELS,
   adapterServesType,
   aiSdkTextAdapter,
   arkAdapter,
@@ -8860,6 +9396,7 @@ export {
   describeThrown,
   generateImage as experimental_generateImage,
   falAdapter,
+  falWebhookBodySchema,
   fileCatalogCache,
   generateAudio,
   generateImage,
@@ -8884,6 +9421,7 @@ export {
   normalizeExposure,
   openaiImageAdapter,
   passthroughTextModel,
+  planVideoTool,
   pollUntil,
   prepareMediaPart,
   primeCatalog,
@@ -8891,6 +9429,7 @@ export {
   readErrorBody,
   replicateAdapter,
   resetLiveCatalog,
+  resolutionTier,
   resolveAudioOptions,
   resolveImageOptions,
   resolveKeys,
@@ -8904,6 +9443,7 @@ export {
   toGeneratedImage,
   validateInputSpec,
   videoLengthViolation,
+  videoToolConstraints,
   withRetry,
   xaiVideoAdapter
 };