@shop-os/modelkit 0.2.27 → 0.3.1

package/dist/index.cjs

@@ -50,6 +50,7 @@ __export(index_exports, {
   SURFACES: () => SURFACES2,
   SurfaceSchema: () => SurfaceSchema,
   VIDEO_INPUT_SPEC_KEYS: () => VIDEO_INPUT_SPEC_KEYS,
+  VIDEO_TOOL_MODELS: () => VIDEO_TOOL_MODELS,
   adapterServesType: () => adapterServesType,
   aiSdkTextAdapter: () => aiSdkTextAdapter,
   arkAdapter: () => arkAdapter,
@@ -63,6 +64,7 @@ __export(index_exports, {
   describeThrown: () => describeThrown,
   experimental_generateImage: () => generateImage,
   falAdapter: () => falAdapter,
+  falWebhookBodySchema: () => falWebhookBodySchema,
   fileCatalogCache: () => fileCatalogCache,
   generateAudio: () => generateAudio,
   generateImage: () => generateImage,
@@ -87,6 +89,7 @@ __export(index_exports, {
   normalizeExposure: () => normalizeExposure,
   openaiImageAdapter: () => openaiImageAdapter,
   passthroughTextModel: () => passthroughTextModel,
+  planVideoTool: () => planVideoTool,
   pollUntil: () => pollUntil,
   prepareMediaPart: () => prepareMediaPart,
   primeCatalog: () => primeCatalog,
@@ -94,6 +97,7 @@ __export(index_exports, {
   readErrorBody: () => readErrorBody,
   replicateAdapter: () => replicateAdapter,
   resetLiveCatalog: () => resetLiveCatalog,
+  resolutionTier: () => resolutionTier,
   resolveAudioOptions: () => resolveAudioOptions,
   resolveImageOptions: () => resolveImageOptions,
   resolveKeys: () => resolveKeys,
@@ -107,6 +111,7 @@ __export(index_exports, {
   toGeneratedImage: () => toGeneratedImage,
   validateInputSpec: () => validateInputSpec,
   videoLengthViolation: () => videoLengthViolation,
+  videoToolConstraints: () => videoToolConstraints,
   withRetry: () => withRetry,
   xaiVideoAdapter: () => xaiVideoAdapter
 });
@@ -1416,6 +1421,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";
@@ -1552,7 +1562,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",
@@ -1577,7 +1587,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"
     },
@@ -1589,7 +1599,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.
@@ -1611,7 +1625,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"],
@@ -1633,7 +1648,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",
@@ -1653,7 +1668,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"],
@@ -1675,7 +1691,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.
@@ -1695,12 +1711,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"
     },
@@ -1717,7 +1741,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",
@@ -2081,11 +2105,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
 ];
 
@@ -2240,6 +2369,10 @@ var ALL_KEY_SET = /* @__PURE__ */ new Set([
   ...IMAGE_INPUT_SPEC_KEYS,
   ...AUDIO_INPUT_SPEC_KEYS
 ]);
+var TYPES_BY_ADAPTER = /* @__PURE__ */ new Map([
+  ["replicate", ["video", "image", "audio"]],
+  ["fal", ["image"]]
+]);
 var ALLOWED_KEYS_BY_TYPE = /* @__PURE__ */ new Map([
   ["video", VIDEO_KEY_SET],
   ["image", IMAGE_KEY_SET],
@@ -2278,7 +2411,8 @@ var StaticSchema = import_zod2.z.record(import_zod2.z.string(), ProviderScalarSc
 var InputSpecSchema = import_zod2.z.strictObject({
   fields: FieldsSchema,
   values: ValuesSchema.optional(),
-  static: StaticSchema.optional()
+  static: StaticSchema.optional(),
+  editEndpoint: import_zod2.z.string().min(1).optional()
 }).superRefine((spec, ctx) => {
   const mappedNames = new Set(Object.values(spec.fields));
   for (const key of Object.keys(spec.static ?? {})) {
@@ -2306,18 +2440,21 @@ function validateInputSpec(raw, row) {
     };
   }
   const spec = parsed.data;
-  if (row.adapter !== "replicate") {
+  const supportedTypes = TYPES_BY_ADAPTER.get(row.adapter);
+  if (supportedTypes === void 0) {
     return {
       ok: false,
-      issues: [{ path: [], message: "inputSpec is only supported on replicate rows" }]
+      issues: [
+        { path: [], message: "inputSpec is only supported on replicate and fal rows" }
+      ]
     };
   }
   const issues = [];
   const allowed = ALLOWED_KEYS_BY_TYPE.get(row.type);
-  if (allowed === void 0) {
+  if (allowed === void 0 || !supportedTypes.includes(row.type)) {
     issues.push({
       path: [],
-      message: `inputSpec is not supported for "${row.type}" rows`
+      message: row.adapter === "fal" ? `inputSpec on fal rows is only supported for image rows, not "${row.type}"` : `inputSpec is not supported for "${row.type}" rows`
     });
   } else {
     for (const key of Object.keys(spec.fields)) {
@@ -2337,6 +2474,19 @@ function validateInputSpec(raw, row) {
       }
     }
   }
+  if (spec.editEndpoint !== void 0) {
+    if (row.adapter !== "fal") {
+      issues.push({
+        path: ["editEndpoint"],
+        message: "inputSpec.editEndpoint is only supported on fal rows"
+      });
+    } else if (!("references" in spec.fields)) {
+      issues.push({
+        path: ["editEndpoint"],
+        message: 'inputSpec.editEndpoint needs a "references" entry in inputSpec.fields'
+      });
+    }
+  }
   const seenNames = /* @__PURE__ */ new Map();
   for (const [key, name] of Object.entries(spec.fields)) {
     const first = seenNames.get(name);
@@ -2382,7 +2532,15 @@ var ADAPTER_IDS = [
   "higgsfield",
   "xai-video"
 ];
-var ModelTypeSchema = import_zod3.z.enum(["text", "image", "video", "audio", "upscale", "bg-remove"]);
+var ModelTypeSchema = import_zod3.z.enum([
+  "text",
+  "image",
+  "video",
+  "audio",
+  "upscale",
+  "bg-remove",
+  "video-tool"
+]);
 var LifecycleSchema = import_zod3.z.enum(["active", "deprecated", "retired"]);
 var SurfaceSchema = import_zod3.z.enum(["cowork", "space_builder"]);
 var SURFACES2 = SurfaceSchema.options;
@@ -2462,7 +2620,22 @@ var ReferenceLimitsSchema = import_zod3.z.looseObject({
   audios: import_zod3.z.number().optional(),
   total: import_zod3.z.number().optional(),
   audioOnly: import_zod3.z.boolean().optional(),
-  videoSeconds: VideoSecondsLimitsSchema.optional()
+  videoSeconds: VideoSecondsLimitsSchema.optional(),
+  audioSeconds: import_zod3.z.looseObject({
+    min: import_zod3.z.number().optional(),
+    max: import_zod3.z.number().optional(),
+    total: import_zod3.z.number().optional()
+  }).optional(),
+  audioFormats: import_zod3.z.array(import_zod3.z.string()).optional(),
+  audioMaxBytes: import_zod3.z.number().positive().optional()
+});
+var RangeSchema = import_zod3.z.looseObject({ min: import_zod3.z.number(), max: import_zod3.z.number() });
+var VideoToolConstraintsSchema = import_zod3.z.looseObject({
+  kind: import_zod3.z.enum(["upscale", "interpolate", "hdr"]),
+  upscaleFactor: RangeSchema.optional(),
+  maxOutputLongEdge: import_zod3.z.number().positive().optional(),
+  fps: RangeSchema.optional(),
+  outputFormats: import_zod3.z.array(import_zod3.z.enum(["h265", "prores"])).min(1).optional()
 });
 var ModelConstraintsSchema = import_zod3.z.looseObject({
   aspectRatios: import_zod3.z.array(AspectRatioSchema).optional(),
@@ -2477,7 +2650,14 @@ var ModelConstraintsSchema = import_zod3.z.looseObject({
   supports: import_zod3.z.array(SupportedOptionSchema).optional(),
   ratioIgnoredWith: import_zod3.z.array(import_zod3.z.enum(["firstFrame", "sourceVideo"])).optional(),
   sourceVideoSeconds: VideoSecondsLimitsSchema.omit({ total: true }).extend({ inReferenceTotal: import_zod3.z.boolean().optional() }).optional(),
-  extension: import_zod3.z.looseObject({ segmentSeconds: import_zod3.z.number(), maxTotalSeconds: import_zod3.z.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: import_zod3.z.looseObject({
+    segmentSeconds: import_zod3.z.number(),
+    maxTotalSeconds: import_zod3.z.number(),
+    returns: import_zod3.z.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: import_zod3.z.unknown().optional(),
@@ -2549,6 +2729,7 @@ var CatalogDisplaySchema = import_zod3.z.looseObject({
 });
 var CatalogCapabilitiesSchema = import_zod3.z.looseObject({
   acceptsSourceVideo: import_zod3.z.boolean().optional(),
+  videoEdit: import_zod3.z.boolean().optional(),
   framesExcludeReferences: import_zod3.z.boolean().optional(),
   lastFrameRequiresFirstFrame: import_zod3.z.boolean().optional(),
   reasoning: import_zod3.z.boolean().optional(),
@@ -2591,6 +2772,13 @@ var CatalogModelSchemaBase = import_zod3.z.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",
@@ -3597,7 +3785,7 @@ async function generateSeedanceVideo(req, ctx) {
 }
 
 // src/adapters/fal.ts
-var import_zod9 = require("zod");
+var import_zod12 = require("zod");
 var import_client = require("@fal-ai/client");
 
 // src/adapters/fal-http.ts
@@ -3685,6 +3873,428 @@ function createFalHttpClient(opts) {
   };
 }
 
+// src/adapters/fal-gateway.ts
+var import_zod9 = require("zod");
+var falDetailSchema = import_zod9.z.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
+var import_zod11 = require("zod");
+
+// src/catalog/video-tools-spec.ts
+var import_zod10 = require("zod");
+var RangeSchema2 = import_zod10.z.object({ min: import_zod10.z.number(), max: import_zod10.z.number() });
+var ToolSchema = import_zod10.z.object({
+  kind: import_zod10.z.enum(["upscale", "interpolate", "hdr"]),
+  upscaleFactor: RangeSchema2.optional(),
+  maxOutputLongEdge: import_zod10.z.number().positive().optional(),
+  fps: RangeSchema2.optional(),
+  outputFormats: import_zod10.z.array(import_zod10.z.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 = import_zod11.z.url().refine((value) => new URL(value).origin === FAL_QUEUE_ORIGIN, {
+  message: "not a fal queue URL"
+});
+var submitResponseSchema = import_zod11.z.object({
+  request_id: import_zod11.z.string().min(1),
+  status_url: queueUrlSchema,
+  response_url: queueUrlSchema,
+  cancel_url: queueUrlSchema
+});
+var statusResponseSchema = import_zod11.z.object({ status: import_zod11.z.string() });
+var videoFileSchema = import_zod11.z.object({
+  url: import_zod11.z.url(),
+  content_type: import_zod11.z.string().nullish(),
+  file_size: import_zod11.z.number().nullish()
+});
+var toolOutputSchema = import_zod11.z.object({ video: videoFileSchema });
+var falWebhookBodySchema = import_zod11.z.object({
+  request_id: import_zod11.z.string().min(1),
+  gateway_request_id: import_zod11.z.string().nullish(),
+  status: import_zod11.z.enum(["OK", "ERROR"]),
+  payload: JsonValueSchema.nullish(),
+  error: import_zod11.z.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 import_zod11.z.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/input-spec-mapper.ts
+function canonicalValue(req, key) {
+  return req[key];
+}
+function isMediaRef(value) {
+  return value instanceof Object && ("url" in value || "bytes" in value);
+}
+function toProviderValue(value, refToUrl2) {
+  if (Array.isArray(value)) {
+    return value.map(refToUrl2);
+  }
+  if (isMediaRef(value)) {
+    return refToUrl2(value);
+  }
+  return value;
+}
+function applyInputSpec(spec, req, refToUrl2, opts) {
+  const out = {};
+  for (const [canonical, providerField] of Object.entries(spec.fields)) {
+    if (!isInputSpecKey(canonical)) continue;
+    const value = canonicalValue(req, canonical);
+    if (value === void 0) continue;
+    if (opts?.omit?.(canonical, value)) continue;
+    const serialised = toProviderValue(value, refToUrl2);
+    const mapped = spec.values?.[canonical]?.[String(value)];
+    out[providerField] = mapped ?? serialised;
+  }
+  for (const [key, value] of Object.entries(spec.static ?? {})) {
+    out[key] = value;
+  }
+  return out;
+}
+function resolveRowInputSpec(req, ctx) {
+  const raw = ctx.model.providerOptions?.["modelkit"]?.["inputSpec"];
+  if (raw === void 0) return { kind: "absent" };
+  const result = validateInputSpec(raw, ctx.model);
+  if (!result.ok) {
+    ctx.logger.warn(
+      `[modelkit] ${ctx.model.id} has an invalid providerOptions.modelkit.inputSpec; the call fails`
+    );
+    return { kind: "invalid", issues: result.issues };
+  }
+  return {
+    kind: "ok",
+    spec: result.spec,
+    input: applyInputSpec(result.spec, req, refToUrl, {
+      omit: (key, value) => key === "aspectRatio" && value === "adaptive"
+    })
+  };
+}
+function describeInputSpecIssue(issue) {
+  if (!issue) return "invalid inputSpec";
+  return issue.path.length === 0 ? issue.message : `${issue.path.map((part) => String(part)).join(".")} ${issue.message}`;
+}
+function invalidInputSpecError(provider, ctx, issues) {
+  return new ModelKitError({
+    code: "unsupported_option",
+    message: `${provider} row "${ctx.model.id}" has an invalid providerOptions.modelkit.inputSpec: ${describeInputSpecIssue(issues[0])}`,
+    provider,
+    model: ctx.model.id,
+    retryable: false
+  });
+}
+
 // src/adapters/fal.ts
 var MUSE_T2I_ENDPOINT = "meta/muse-image/text-to-image";
 var MUSE_EDIT_ENDPOINT = "meta/muse-image/edit";
@@ -3692,7 +4302,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 = import_zod9.z.object({ data: JsonValueSchema });
+var falSubscribePayloadSchema = import_zod12.z.object({ data: JsonValueSchema });
 function defaultCreateFalClient(opts) {
   if (opts.maxRetries !== void 0)
     return createFalHttpClient({
@@ -3739,30 +4349,30 @@ function createFalAdapter(deps = defaultDeps) {
     id: "fal",
     generateImage: (req, ctx) => {
       throwIfAborted(ctx.signal);
+      const spec = resolveRowInputSpec(req, ctx);
+      if (spec.kind === "invalid") {
+        return Promise.reject(invalidInputSpecError("fal", ctx, spec.issues));
+      }
+      if (spec.kind === "ok") return generateSpecImage(req, ctx, deps, spec);
       if (isIdeogram(ctx.model.providerModelId)) return generateIdeogramImage(req, ctx, deps);
       return generateMuseImage(req, ctx, deps);
     },
     generateVideo: (req, ctx) => {
       throwIfAborted(ctx.signal);
       return generateFalVideo(req, ctx, deps);
-    }
+    },
+    submitVideoTool: submitFalVideoTool,
+    videoToolStatus: falVideoToolStatus,
+    videoToolResult: falVideoToolResult,
+    cancelVideoTool: cancelFalVideoTool
   };
 }
 var falAdapter = createFalAdapter();
-var falDetailSchema = import_zod9.z.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 = import_zod9.z.object({
-  status: import_zod9.z.number().optional(),
-  statusCode: import_zod9.z.number().optional(),
+var falSdkThrownSchema = import_zod12.z.object({
+  status: import_zod12.z.number().optional(),
+  statusCode: import_zod12.z.number().optional(),
   body: JsonValueSchema.optional(),
-  message: import_zod9.z.string().optional()
+  message: import_zod12.z.string().optional()
 });
 function falSdkError(cause, model) {
   const parsed = falSdkThrownSchema.safeParse(cause);
@@ -3777,45 +4387,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 = import_zod9.z.object({
-  request_id: import_zod9.z.string(),
-  status_url: import_zod9.z.string(),
-  response_url: import_zod9.z.string()
+var falQueueSubmitSchema = import_zod12.z.object({
+  request_id: import_zod12.z.string(),
+  status_url: import_zod12.z.string(),
+  response_url: import_zod12.z.string()
 });
-var falQueueStatusSchema = import_zod9.z.object({ status: import_zod9.z.string() });
+var falQueueStatusSchema = import_zod12.z.object({ status: import_zod12.z.string() });
 async function passthroughRequest(ctx, endpoint, input) {
   const cfg = gatewayConfig(ctx);
   const submitRes = await gatewayFetch(cfg, ctx.fetch, `${FAL_QUEUE_HOST}/${endpoint}`, {
@@ -3948,14 +4525,44 @@ 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 = import_zod9.z.object({
-  images: import_zod9.z.array(
-    import_zod9.z.object({
-      url: import_zod9.z.string().optional(),
-      content_type: import_zod9.z.string().nullable().optional()
+var museImageResultSchema = import_zod12.z.object({
+  images: import_zod12.z.array(
+    import_zod12.z.object({
+      url: import_zod12.z.string().optional(),
+      content_type: import_zod12.z.string().nullable().optional()
     })
   ).optional()
 });
+async function collectFalImages(payload, ctx, req, label) {
+  const parsed = museImageResultSchema.safeParse(payload);
+  const images = parsed.success ? parsed.data.images ?? [] : [];
+  const files = await Promise.all(
+    images.flatMap((img) => {
+      if (img.url === void 0) return [];
+      return [decodeImage(ctx, img.url, img.content_type ?? void 0)];
+    })
+  );
+  if (files.length === 0) {
+    throw new ModelKitError({
+      code: "provider_rejected",
+      message: `${label} returned no image`,
+      provider: "fal",
+      model: ctx.model.id,
+      retryable: false
+    });
+  }
+  return {
+    images: files.map((f) => ({ bytes: f.bytes, mime: f.mime })),
+    usage: imageUsage(ctx, req, files.length),
+    raw: payload
+  };
+}
+async function generateSpecImage(req, ctx, deps, spec) {
+  const hasReferences = (req.references ?? []).length > 0;
+  const endpoint = hasReferences && spec.spec.editEndpoint !== void 0 ? spec.spec.editEndpoint : ctx.model.providerModelId;
+  const payload = await runJob(ctx, deps, endpoint, spec.input);
+  return collectFalImages(payload, ctx, req, `fal ${endpoint}`);
+}
 async function generateMuseImage(req, ctx, deps) {
   const refs = (req.references ?? []).map(refToUrl);
   const isEdit = refs.length > 0;
@@ -3972,29 +4579,7 @@ async function generateMuseImage(req, ctx, deps) {
   const custom = id.includes("/") && !id.startsWith("meta/muse-image") ? id : void 0;
   const endpoint = custom ?? (isEdit ? MUSE_EDIT_ENDPOINT : MUSE_T2I_ENDPOINT);
   const payload = await runJob(ctx, deps, endpoint, input);
-  const parsed = museImageResultSchema.safeParse(payload);
-  const images = parsed.success ? parsed.data.images ?? [] : [];
-  const firstUrl = images[0]?.url;
-  if (images.length === 0 || firstUrl === void 0) {
-    throw new ModelKitError({
-      code: "provider_rejected",
-      message: "fal Meta Muse returned no image",
-      provider: "fal",
-      model: ctx.model.id,
-      retryable: false
-    });
-  }
-  const files = await Promise.all(
-    images.flatMap((img) => {
-      if (img.url === void 0) return [];
-      return [decodeImage(ctx, img.url, img.content_type ?? void 0)];
-    })
-  );
-  return {
-    images: files.map((f) => ({ bytes: f.bytes, mime: f.mime })),
-    usage: imageUsage(ctx, req, files.length),
-    raw: payload
-  };
+  return collectFalImages(payload, ctx, req, "fal Meta Muse");
 }
 var IDEOGRAM_MODEL_IDS = /* @__PURE__ */ new Set(["ideogram/v4.5"]);
 function isIdeogram(providerModelId) {
@@ -4039,28 +4624,7 @@ async function generateIdeogramImage(req, ctx, deps) {
     if (references.length > 0) input.reference_image_urls = references;
   }
   const payload = await runJob(ctx, deps, endpoint, input);
-  const parsed = museImageResultSchema.safeParse(payload);
-  const images = parsed.success ? parsed.data.images ?? [] : [];
-  const files = await Promise.all(
-    images.flatMap((img) => {
-      if (img.url === void 0) return [];
-      return [decodeImage(ctx, img.url, img.content_type ?? void 0)];
-    })
-  );
-  if (files.length === 0) {
-    throw new ModelKitError({
-      code: "provider_rejected",
-      message: "fal Ideogram returned no image",
-      provider: "fal",
-      model: ctx.model.id,
-      retryable: false
-    });
-  }
-  return {
-    images: files.map((f) => ({ bytes: f.bytes, mime: f.mime })),
-    usage: imageUsage(ctx, req, files.length),
-    raw: payload
-  };
+  return collectFalImages(payload, ctx, req, "fal Ideogram");
 }
 var H3_MAX_MODEL_IDS = /* @__PURE__ */ new Set([
   "minimax/h3-max",
@@ -4122,8 +4686,8 @@ function klingO1Input(req) {
   if (refs.length > 0) input.image_urls = refs;
   return input;
 }
-var falVideoResultSchema = import_zod9.z.object({
-  video: import_zod9.z.object({ url: import_zod9.z.string().optional() }).optional()
+var falVideoResultSchema = import_zod12.z.object({
+  video: import_zod12.z.object({ url: import_zod12.z.string().optional() }).optional()
 });
 function extractVideoUrl(result, endpoint, model) {
   const parsed = falVideoResultSchema.safeParse(result);
@@ -4324,11 +4888,11 @@ async function passthroughVideoJob(ctx, req, endpoint, input) {
 }
 
 // src/adapters/google-genai.ts
-var import_zod11 = require("zod");
+var import_zod14 = require("zod");
 var import_genai = require("@google/genai");
 
 // src/adapters/google-files.ts
-var import_zod10 = require("zod");
+var import_zod13 = require("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;
@@ -4338,17 +4902,17 @@ var GENERIC_MEDIA_TYPES = /* @__PURE__ */ new Set([
   "binary/octet-stream",
   "application/binary"
 ]);
-var uploadedFileSchema = import_zod10.z.object({
-  file: import_zod10.z.object({
-    uri: import_zod10.z.string().optional(),
-    name: import_zod10.z.string().optional(),
-    state: import_zod10.z.string().optional(),
-    mimeType: import_zod10.z.string().optional()
+var uploadedFileSchema = import_zod13.z.object({
+  file: import_zod13.z.object({
+    uri: import_zod13.z.string().optional(),
+    name: import_zod13.z.string().optional(),
+    state: import_zod13.z.string().optional(),
+    mimeType: import_zod13.z.string().optional()
   }).optional()
 });
-var fileStateSchema = import_zod10.z.object({
-  state: import_zod10.z.string().optional(),
-  error: import_zod10.z.object({ message: import_zod10.z.string().optional() }).optional()
+var fileStateSchema = import_zod13.z.object({
+  state: import_zod13.z.string().optional(),
+  error: import_zod13.z.object({ message: import_zod13.z.string().optional() }).optional()
 });
 function resolveMime(declared, fallback) {
   const clean = declared?.split(";")[0]?.trim().toLowerCase();
@@ -4565,7 +5129,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 = import_zod11.z.string();
+var errorTextSchema = import_zod14.z.string();
 function isGoogleGenaiVideoKnown(providerModelId) {
   return providerModelId.startsWith("veo-") || providerModelId.startsWith("gemini-omni");
 }
@@ -5171,15 +5735,15 @@ async function prepareGoogleMediaPart(ref, mediaType, ctx) {
 // src/adapters/google-image.ts
 var import_google2 = require("@ai-sdk/google");
 var import_ai2 = require("ai");
-var import_zod12 = require("zod");
+var import_zod15 = require("zod");
 var GEMINI_IMAGE_TIMEOUT_MS = 6e5;
 var defaultGoogleImageDeps = {
   createGoogleClient: (opts) => (0, import_google2.createGoogleGenerativeAI)(opts),
   runTextGeneration: (opts) => (0, import_ai2.generateText)(opts)
 };
-var causeChainNodeSchema = import_zod12.z.object({
-  message: import_zod12.z.string().optional(),
-  cause: import_zod12.z.unknown().optional()
+var causeChainNodeSchema = import_zod15.z.object({
+  message: import_zod15.z.string().optional(),
+  cause: import_zod15.z.unknown().optional()
 });
 function extractBlockReason(cause) {
   let current = cause;
@@ -5299,7 +5863,7 @@ function createGoogleImageAdapter(deps = defaultGoogleImageDeps) {
 var googleImageAdapter = createGoogleImageAdapter();
 
 // src/adapters/higgsfield.ts
-var import_zod13 = require("zod");
+var import_zod16 = require("zod");
 
 // src/adapters/higgsfield-motions.ts
 var MOTION_MAP = {
@@ -5518,14 +6082,14 @@ function klingEndpointFields(providerModelId) {
   const path = (providerModelId.startsWith("/") ? providerModelId.slice(1) : providerModelId).toLowerCase();
   return KLING_ENDPOINT_FIELDS.get(path) ?? UNLISTED_KLING_FIELDS;
 }
-var klingCreateSchema = import_zod13.z.object({ status_url: import_zod13.z.string() });
-var klingStatusSchema = import_zod13.z.object({
-  status: import_zod13.z.string().optional(),
-  video: import_zod13.z.object({ url: import_zod13.z.string().optional() }).optional(),
+var klingCreateSchema = import_zod16.z.object({ status_url: import_zod16.z.string() });
+var klingStatusSchema = import_zod16.z.object({
+  status: import_zod16.z.string().optional(),
+  video: import_zod16.z.object({ url: import_zod16.z.string().optional() }).optional(),
   error: JsonValueSchema.optional()
 });
-var errorMessageSchema = import_zod13.z.object({ message: import_zod13.z.string().optional() });
-var textValueSchema = import_zod13.z.string();
+var errorMessageSchema = import_zod16.z.object({ message: import_zod16.z.string().optional() });
+var textValueSchema = import_zod16.z.string();
 function klingErrorDetail(error) {
   if (error === void 0) return "unknown_error";
   const asText = textValueSchema.safeParse(error);
@@ -5681,8 +6245,8 @@ async function generateKlingVideo(req, ctx) {
     }
   };
 }
-var dopMotionOptionsSchema = import_zod13.z.object({
-  modelkit: import_zod13.z.object({ motion: import_zod13.z.string().optional() }).optional()
+var dopMotionOptionsSchema = import_zod16.z.object({
+  modelkit: import_zod16.z.object({ motion: import_zod16.z.string().optional() }).optional()
 });
 function dopMotionId(ctx) {
   const parsed = dopMotionOptionsSchema.safeParse(ctx.model.providerOptions);
@@ -5698,7 +6262,7 @@ function dopMotionId(ctx) {
     });
   return id;
 }
-var jsonRecordSchema = import_zod13.z.record(import_zod13.z.string(), JsonValueSchema);
+var jsonRecordSchema = import_zod16.z.record(import_zod16.z.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) {
@@ -5726,8 +6290,8 @@ function dopUrl(body) {
   }
   return void 0;
 }
-var dopCreateSchema = import_zod13.z.object({ id: import_zod13.z.string() });
-var dopStatusSchema = import_zod13.z.object({ status: import_zod13.z.string().optional() });
+var dopCreateSchema = import_zod16.z.object({ id: import_zod16.z.string() });
+var dopStatusSchema = import_zod16.z.object({ status: import_zod16.z.string().optional() });
 async function generateDopVideo(req, ctx) {
   const firstFrame = req.firstFrame ? refToUrl(req.firstFrame) : void 0;
   if (!firstFrame) {
@@ -5855,7 +6419,7 @@ var higgsfieldAdapter = {
 
 // src/adapters/openai-image.ts
 var import_openai2 = __toESM(require("openai"), 1);
-var import_zod14 = require("zod");
+var import_zod17 = require("zod");
 var MAX_EDIT_REFERENCES = 16;
 function aspectRatioToSize(ratio, tier) {
   const TIER_LONG_EDGE = {
@@ -5938,9 +6502,9 @@ function toProviderError2(cause, ctx) {
     ctx.model.id
   );
 }
-var openaiUsageSchema = import_zod14.z.object({
-  input_tokens: import_zod14.z.number().optional(),
-  output_tokens: import_zod14.z.number().optional()
+var openaiUsageSchema = import_zod17.z.object({
+  input_tokens: import_zod17.z.number().optional(),
+  output_tokens: import_zod17.z.number().optional()
 });
 var openaiImageAdapter = {
   id: "openai-image",
@@ -6351,13 +6915,13 @@ var prodiaAdapter = {
 var import_replicate = __toESM(require("replicate"), 1);
 
 // src/adapters/replicate-http.ts
-var import_zod15 = require("zod");
-var predictionSchema = import_zod15.z.object({
-  id: import_zod15.z.string(),
-  status: import_zod15.z.string(),
+var import_zod18 = require("zod");
+var predictionSchema = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  status: import_zod18.z.string(),
   output: JsonValueSchema.optional(),
   error: JsonValueSchema.optional(),
-  metrics: import_zod15.z.object({ predict_time: import_zod15.z.number().optional() }).optional()
+  metrics: import_zod18.z.object({ predict_time: import_zod18.z.number().optional() }).optional()
 });
 function createReplicateHttpClient(opts) {
   async function request(path, body, signal) {
@@ -6408,42 +6972,7 @@ function createReplicateHttpClient(opts) {
 }
 
 // src/adapters/replicate.ts
-var import_zod16 = require("zod");
-
-// src/adapters/input-spec-mapper.ts
-function canonicalValue(req, key) {
-  return req[key];
-}
-function isMediaRef(value) {
-  return value instanceof Object && ("url" in value || "bytes" in value);
-}
-function toProviderValue(value, refToUrl2) {
-  if (Array.isArray(value)) {
-    return value.map(refToUrl2);
-  }
-  if (isMediaRef(value)) {
-    return refToUrl2(value);
-  }
-  return value;
-}
-function applyInputSpec(spec, req, refToUrl2, opts) {
-  const out = {};
-  for (const [canonical, providerField] of Object.entries(spec.fields)) {
-    if (!isInputSpecKey(canonical)) continue;
-    const value = canonicalValue(req, canonical);
-    if (value === void 0) continue;
-    if (opts?.omit?.(canonical, value)) continue;
-    const serialised = toProviderValue(value, refToUrl2);
-    const mapped = spec.values?.[canonical]?.[String(value)];
-    out[providerField] = mapped ?? serialised;
-  }
-  for (const [key, value] of Object.entries(spec.static ?? {})) {
-    out[key] = value;
-  }
-  return out;
-}
-
-// src/adapters/replicate.ts
+var import_zod19 = require("zod");
 var POLL_INTERVAL_MS = 1e3;
 var POLL_TIMEOUT_MS = 15 * 6e4;
 var defaultReplicateDeps = {
@@ -6483,8 +7012,8 @@ function route(providerModelId) {
   if (!providerModelId.includes("/")) return { version: providerModelId };
   return { model: providerModelId };
 }
-var replicateResponseStatusSchema = import_zod16.z.object({
-  response: import_zod16.z.object({ status: import_zod16.z.number() }).partial()
+var replicateResponseStatusSchema = import_zod19.z.object({
+  response: import_zod19.z.object({ status: import_zod19.z.number() }).partial()
 });
 function replicateError(cause, ctx) {
   if (isModelKitError(cause)) return cause;
@@ -6511,7 +7040,7 @@ function isUrlFn(value) {
 function extractOutputUrl(output) {
   const root = Array.isArray(output) ? output[0] : output;
   if (root === void 0) throw noOutput();
-  const asString = import_zod16.z.string().safeParse(root);
+  const asString = import_zod19.z.string().safeParse(root);
   if (asString.success && asString.data) return asString.data;
   if (root instanceof URL) return root.href;
   if (isObjectOutput(root)) {
@@ -6520,15 +7049,15 @@ function extractOutputUrl(output) {
       if (urlValue !== void 0 && isUrlFn(urlValue)) {
         const called = urlValue();
         if (called instanceof URL) return called.href;
-        const calledString = import_zod16.z.string().safeParse(called);
+        const calledString = import_zod19.z.string().safeParse(called);
         if (calledString.success && calledString.data) return calledString.data;
       } else {
-        const direct = import_zod16.z.string().safeParse(urlValue);
+        const direct = import_zod19.z.string().safeParse(urlValue);
         if (direct.success && direct.data) return direct.data;
       }
     }
     if ("default" in root) {
-      const fallback = import_zod16.z.string().safeParse(root.default);
+      const fallback = import_zod19.z.string().safeParse(root.default);
       if (fallback.success && fallback.data) return fallback.data;
     }
   }
@@ -6589,7 +7118,7 @@ async function runPrediction(ctx, input, deps) {
     }
     return void 0;
   }, pollOpts);
-  const predictTime = import_zod16.z.number().safeParse(done.metrics?.predict_time);
+  const predictTime = import_zod19.z.number().safeParse(done.metrics?.predict_time);
   if (done.output === void 0) throw noOutput();
   return {
     url: extractOutputUrl(done.output),
@@ -6686,38 +7215,6 @@ function replicateNoMapper(ctx, section) {
     retryable: false
   });
 }
-function describeInputSpecIssue(issue) {
-  if (!issue) return "invalid inputSpec";
-  return issue.path.length === 0 ? issue.message : `${issue.path.map((part) => String(part)).join(".")} ${issue.message}`;
-}
-function replicateInvalidSpec(ctx, issues) {
-  const detail = describeInputSpecIssue(issues[0]);
-  return new ModelKitError({
-    code: "unsupported_option",
-    message: `replicate row "${ctx.model.id}" has an invalid providerOptions.modelkit.inputSpec: ${detail}`,
-    provider: "replicate",
-    model: ctx.model.id,
-    retryable: false
-  });
-}
-function omitAdaptive(key, value) {
-  return key === "aspectRatio" && value === "adaptive";
-}
-function replicateInputSpec(req, ctx) {
-  const raw = ctx.model.providerOptions?.["modelkit"]?.["inputSpec"];
-  if (raw === void 0) return { kind: "absent" };
-  const result = validateInputSpec(raw, ctx.model);
-  if (!result.ok) {
-    ctx.logger.warn(
-      `[modelkit] ${ctx.model.id} has an invalid providerOptions.modelkit.inputSpec; the call fails`
-    );
-    return { kind: "invalid", issues: result.issues };
-  }
-  return {
-    kind: "ok",
-    input: applyInputSpec(result.spec, req, refToUrl, { omit: omitAdaptive })
-  };
-}
 var QWEN_IMAGE_RATIOS = /* @__PURE__ */ new Set([
   "1:1",
   "16:9",
@@ -6861,8 +7358,9 @@ async function generateReplicateImage(req, ctx, deps) {
       break;
     }
     default: {
-      const specResult = replicateInputSpec(req, ctx);
-      if (specResult.kind === "invalid") throw replicateInvalidSpec(ctx, specResult.issues);
+      const specResult = resolveRowInputSpec(req, ctx);
+      if (specResult.kind === "invalid")
+        throw invalidInputSpecError("replicate", ctx, specResult.issues);
       if (specResult.kind === "ok") {
         input = specResult.input;
         break;
@@ -6942,9 +7440,10 @@ async function generateReplicateVideo(req, ctx, deps) {
   else if (kind === "kling-omni") input = klingOmniInput(req);
   else if (kind === "hailuo") input = hailuoInput(req);
   else {
-    const specResult = replicateInputSpec(req, ctx);
+    const specResult = resolveRowInputSpec(req, ctx);
     if (specResult.kind === "absent") throw replicateNoMapper(ctx, "video");
-    if (specResult.kind === "invalid") throw replicateInvalidSpec(ctx, specResult.issues);
+    if (specResult.kind === "invalid")
+      throw invalidInputSpecError("replicate", ctx, specResult.issues);
     input = specResult.input;
   }
   const api = client(ctx, deps);
@@ -6978,7 +7477,7 @@ async function generateReplicateVideo(req, ctx, deps) {
       throw replicateError(cause, ctx);
     }
     if (current.status === "succeeded") {
-      const predictTime = import_zod16.z.number().safeParse(current.metrics?.predict_time);
+      const predictTime = import_zod19.z.number().safeParse(current.metrics?.predict_time);
       if (current.output === void 0) throw noOutput();
       return {
         url: extractOutputUrl(current.output),
@@ -7099,9 +7598,10 @@ async function generateReplicateAudio(req, ctx, deps) {
   else if (kind === "elevenlabs") input = elevenLabsMusicInput(req, ctx);
   else if (kind === "lyria") input = lyriaAudioInput(req, ctx);
   else {
-    const specResult = replicateInputSpec(req, ctx);
+    const specResult = resolveRowInputSpec(req, ctx);
     if (specResult.kind === "absent") throw replicateNoMapper(ctx, "audio");
-    if (specResult.kind === "invalid") throw replicateInvalidSpec(ctx, specResult.issues);
+    if (specResult.kind === "invalid")
+      throw invalidInputSpecError("replicate", ctx, specResult.issues);
     input = specResult.input;
   }
   const { url, predictTime, raw } = await runPrediction(ctx, input, deps);
@@ -7119,7 +7619,7 @@ async function generateReplicateAudio(req, ctx, deps) {
 // src/adapters/xai-video.ts
 var import_ai3 = require("ai");
 var import_xai2 = require("@ai-sdk/xai");
-var import_zod17 = require("zod");
+var import_zod20 = require("zod");
 var POLL_INTERVAL_MS2 = 1e4;
 var POLL_TIMEOUT_MS2 = 15 * 6e4;
 var defaultXaiDeps = {
@@ -7132,8 +7632,8 @@ function createXaiVideoAdapter(deps = defaultXaiDeps) {
   };
 }
 var xaiVideoAdapter = createXaiVideoAdapter();
-var xaiResponseStatusSchema = import_zod17.z.object({
-  response: import_zod17.z.object({ status: import_zod17.z.number() }).partial()
+var xaiResponseStatusSchema = import_zod20.z.object({
+  response: import_zod20.z.object({ status: import_zod20.z.number() }).partial()
 });
 function xaiError(cause, ctx) {
   const info = describeThrown(cause);
@@ -7141,12 +7641,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 = import_zod17.z.object({
+var xaiMetaSchema = import_zod20.z.object({
   videoUrl: JsonValueSchema.optional(),
   costInUsdTicks: JsonValueSchema.optional(),
   duration: JsonValueSchema.optional()
 });
-var xaiProviderMetadataSchema = import_zod17.z.object({ xai: xaiMetaSchema });
+var xaiProviderMetadataSchema = import_zod20.z.object({ xai: xaiMetaSchema });
 function metaOf(result) {
   const parsed = xaiProviderMetadataSchema.partial().safeParse(result.providerMetadata);
   if (!parsed.success) return {};
@@ -7254,7 +7754,7 @@ async function mapResult(ctx, req, result) {
     };
   }
   const meta = metaOf(result);
-  const videoUrl = import_zod17.z.string().safeParse(meta.videoUrl);
+  const videoUrl = import_zod20.z.string().safeParse(meta.videoUrl);
   if (videoUrl.success && videoUrl.data) {
     const res = await ctx.fetch(videoUrl.data);
     if (!res.ok) {
@@ -7277,7 +7777,7 @@ async function mapResult(ctx, req, result) {
   });
 }
 function usage(ctx, req, meta) {
-  const costTicks = import_zod17.z.number().safeParse(meta.costInUsdTicks);
+  const costTicks = import_zod20.z.number().safeParse(meta.costInUsdTicks);
   const cost = costTicks.success ? costTicks.data / 1e10 : void 0;
   const event = {
     model: ctx.model.id,
@@ -7410,22 +7910,22 @@ var liveState = store[KEY] ??= {
 var liveCatalog = liveState.catalog;
 
 // src/catalog/load.ts
-var import_zod18 = require("zod");
+var import_zod21 = require("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 = import_zod18.z.object({
-  rows: import_zod18.z.array(JsonValueSchema),
-  revision: import_zod18.z.string().optional()
+var EnvelopeSchema = import_zod21.z.object({
+  rows: import_zod21.z.array(JsonValueSchema),
+  revision: import_zod21.z.string().optional()
 });
 function dropReason(path, message) {
   return path.length === 0 ? message : `${path.map((part) => String(part)).join(".")} ${message}`;
 }
 function rowId(raw) {
-  const parsed = import_zod18.z.object({ id: import_zod18.z.string().min(1) }).loose().safeParse(raw);
+  const parsed = import_zod21.z.object({ id: import_zod21.z.string().min(1) }).loose().safeParse(raw);
   if (!parsed.success) return "?";
   return parsed.data.id;
 }
@@ -8282,7 +8782,7 @@ function createTextSteps(initial, resolve, callerProviderOptions) {
 
 // src/client.ts
 var import_ai5 = require("ai");
-var import_zod19 = require("zod");
+var import_zod22 = require("zod");
 
 // src/generated-image.ts
 function toGeneratedImage(image) {
@@ -8364,10 +8864,10 @@ function textAbortOptions(sdk, context) {
   if (abortSignal) return { abortSignal };
   return {};
 }
-var catalogId = import_zod19.z.string();
-var exactSize = import_zod19.z.templateLiteral([import_zod19.z.number(), "x", import_zod19.z.number()]);
-var sdkRatio = import_zod19.z.templateLiteral([import_zod19.z.number(), ":", import_zod19.z.number()]);
-var sizeTier = import_zod19.z.enum(["512", "1K", "2K", "4K"]);
+var catalogId = import_zod22.z.string();
+var exactSize = import_zod22.z.templateLiteral([import_zod22.z.number(), "x", import_zod22.z.number()]);
+var sdkRatio = import_zod22.z.templateLiteral([import_zod22.z.number(), ":", import_zod22.z.number()]);
+var sizeTier = import_zod22.z.enum(["512", "1K", "2K", "4K"]);
 function isCatalogId(model) {
   return catalogId.safeParse(model).success;
 }
@@ -8477,6 +8977,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);
@@ -8832,6 +9350,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;
@@ -8958,6 +9504,7 @@ var describe = (modelId) => createDefaultModelKit().describe(modelId);
   SURFACES,
   SurfaceSchema,
   VIDEO_INPUT_SPEC_KEYS,
+  VIDEO_TOOL_MODELS,
   adapterServesType,
   aiSdkTextAdapter,
   arkAdapter,
@@ -8971,6 +9518,7 @@ var describe = (modelId) => createDefaultModelKit().describe(modelId);
   describeThrown,
   experimental_generateImage,
   falAdapter,
+  falWebhookBodySchema,
   fileCatalogCache,
   generateAudio,
   generateImage,
@@ -8995,6 +9543,7 @@ var describe = (modelId) => createDefaultModelKit().describe(modelId);
   normalizeExposure,
   openaiImageAdapter,
   passthroughTextModel,
+  planVideoTool,
   pollUntil,
   prepareMediaPart,
   primeCatalog,
@@ -9002,6 +9551,7 @@ var describe = (modelId) => createDefaultModelKit().describe(modelId);
   readErrorBody,
   replicateAdapter,
   resetLiveCatalog,
+  resolutionTier,
   resolveAudioOptions,
   resolveImageOptions,
   resolveKeys,
@@ -9015,6 +9565,7 @@ var describe = (modelId) => createDefaultModelKit().describe(modelId);
   toGeneratedImage,
   validateInputSpec,
   videoLengthViolation,
+  videoToolConstraints,
   withRetry,
   xaiVideoAdapter,
   ...require("ai")