cascade-ai 0.51.0 → 0.52.0

package/dist/cli.cjs

@@ -1793,7 +1793,7 @@ var CASCADE_VERSION, CASCADE_CONFIG_FILE, CASCADE_DB_FILE, CASCADE_DASHBOARD_SEC
 var init_constants = __esm({
   "src/constants.ts"() {
     init_pricing();
-    CASCADE_VERSION = "0.51.0";
+    CASCADE_VERSION = "0.52.0";
     CASCADE_CONFIG_FILE = ".cascade/config.json";
     CASCADE_DB_FILE = ".cascade/memory.db";
     CASCADE_DASHBOARD_SECRET_FILE = ".cascade/dashboard-secret";
@@ -5050,7 +5050,14 @@ var ToolsConfigSchema = zod.z.object({
    * built-in tool (shell/file/git/…) from existing at all, rather than just
    * gating it behind approval. Omitted = full default set (unchanged).
    */
-  enabledTools: zod.z.array(zod.z.string()).optional()
+  enabledTools: zod.z.array(zod.z.string()).optional(),
+  /**
+   * Tools to remove even when they would otherwise be registered. Unlike
+   * `enabledTools` (an allowlist over the built-in set), this also reaches
+   * tools registered outside it — MCP tools and media generation — which is
+   * the only way to turn those off.
+   */
+  disabledTools: zod.z.array(zod.z.string()).optional()
 });
 var HookDefinitionSchema = zod.z.object({
   name: zod.z.string().optional(),
@@ -11075,17 +11082,13 @@ var CAPABILITIES = [
   },
   // ── Video ──
   {
-    // Listed so `describe()` can tell the truth about what exists, and so the
-    // planner is told video is out of reach rather than left to invent a tool.
-    // Veo is a long-running operation: submit, poll, then fetch bytes from a
-    // signed URL. That is a different execution shape from every other entry
-    // here and is not wired up — claiming otherwise would produce a tool that
-    // fails at call time instead of an honest "not yet".
+    // Long-running: submit returns an operation name, the video lands minutes
+    // later, and the bytes come from a short-lived signed URL. generate.ts owns
+    // that polling loop; the registry only records the shape via `api`.
     modality: "video",
     provider: "gemini",
     modelId: "veo-3.1-generate-001",
-    api: "gemini-predict",
-    unsupported: "Veo runs as a long-running operation (submit \u2192 poll \u2192 fetch). Not wired up yet."
+    api: "gemini-predict-lro"
   }
 ];
 function capabilityCost(cap) {
@@ -11398,6 +11401,75 @@ async function generateSpeech(cap, cfg, req, signal) {
     };
   }, cap.modelId);
 }
+var VIDEO_POLL_INTERVAL_MS = 1e4;
+var VIDEO_TIMEOUT_MS = 8 * 6e4;
+function sleep(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal?.aborted) return reject(new Error("Cancelled."));
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      reject(new Error("Cancelled."));
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function generateVideo(cap, cfg, req, signal, onProgress) {
+  return callProvider(async () => {
+    if (cap.api !== "gemini-predict-lro") throw new Error(`${cap.modelId} is not a video generator.`);
+    const base = baseUrlFor(cfg, "https://generativelanguage.googleapis.com/v1beta");
+    const key = cfg.apiKey ?? "";
+    const headers = { "x-goog-api-key": key };
+    const submit = await postJson(
+      `${base}/models/${encodeURIComponent(cap.modelId)}:predictLongRunning`,
+      {
+        instances: [{ prompt: req.prompt }],
+        parameters: {
+          aspectRatio: req.aspectRatio ?? "16:9",
+          ...req.seconds ? { durationSeconds: req.seconds } : {}
+        }
+      },
+      headers,
+      signal
+    );
+    const started = await submit.json();
+    if (!started.name) throw new Error("Video request was accepted but returned no operation to poll.");
+    onProgress?.(`Video generation started (${cap.modelId}). This usually takes 1-3 minutes.`);
+    const deadline = Date.now() + VIDEO_TIMEOUT_MS;
+    let operation = {};
+    while (Date.now() < deadline) {
+      await sleep(VIDEO_POLL_INTERVAL_MS, signal);
+      const poll = await fetch(`${base}/${started.name}`, { headers, signal });
+      if (!poll.ok) {
+        const text = await poll.text().catch(() => "");
+        throw Object.assign(new Error(text || poll.statusText), { status: poll.status });
+      }
+      operation = await poll.json();
+      if (operation.done) break;
+      onProgress?.("Still rendering\u2026");
+    }
+    if (!operation.done) {
+      throw new Error(
+        `Video was still rendering after ${Math.round(VIDEO_TIMEOUT_MS / 6e4)} minutes. It may still complete on the provider side, but Cascade stopped waiting.`
+      );
+    }
+    if (operation.error?.message) throw new Error(operation.error.message);
+    const uri = operation.response?.generateVideoResponse?.generatedSamples?.[0]?.video?.uri;
+    if (!uri) throw new Error("Video finished but the response contained no video.");
+    const media = await fetch(uri, { headers, signal });
+    if (!media.ok) throw new Error(`Video finished but could not be downloaded (HTTP ${media.status}).`);
+    return {
+      data: Buffer.from(await media.arrayBuffer()),
+      mimeType: "video/mp4",
+      filename: stamp("mp4"),
+      modelId: cap.modelId,
+      provider: cap.provider
+    };
+  }, cap.modelId);
+}
 async function transcribeAudio(cap, cfg, req, signal) {
   return callProvider(async () => {
     if (cap.api !== "openai-transcriptions") throw new Error(`${cap.modelId} is not a transcription model.`);
@@ -11522,6 +11594,58 @@ var GenerateSpeechTool = class extends BaseTool {
 Model: ${asset.modelId} \u2014 ${r.selected.reason}`;
   }
 };
+var DEFAULT_VIDEO_SECONDS = 5;
+var MAX_VIDEO_SECONDS = 8;
+var GenerateVideoTool = class extends BaseTool {
+  constructor(deps) {
+    super();
+    this.deps = deps;
+  }
+  deps;
+  name = "generate_video";
+  // The price is in the description on purpose. Video is ~1000x the cost of an
+  // image per call, it is billed per SECOND, and the model choosing the
+  // duration is the one deciding the bill — so the number has to be where the
+  // model reads before calling, not only in the result afterwards.
+  description = "Generate a short video clip from a text description. EXPENSIVE and slow: billed per second of output (about $0.40/second, so a 5-second clip costs roughly $2) and takes 1-3 minutes. Only use when the user explicitly asks for a video, and prefer the shortest duration that satisfies the request.";
+  inputSchema = {
+    type: "object",
+    properties: {
+      prompt: { type: "string", description: "What the video should show: subject, action, camera movement, style." },
+      seconds: { type: "number", description: `Clip length, 1-${MAX_VIDEO_SECONDS} seconds (default ${DEFAULT_VIDEO_SECONDS}). Billed per second \u2014 keep it short.` },
+      aspectRatio: { type: "string", description: 'Frame shape: "16:9" (default) or "9:16" for vertical.' },
+      model: { type: "string", description: "Optional: force a specific video model." }
+    },
+    required: ["prompt"]
+  };
+  async execute(input, options) {
+    const prompt = String(input["prompt"] ?? "").trim();
+    if (!prompt) return 'Provide a "prompt" describing the video.';
+    const r = resolve(this.deps, "video", input["model"] ? String(input["model"]) : void 0);
+    if (!r.ok) return r.error;
+    const asked = typeof input["seconds"] === "number" ? input["seconds"] : DEFAULT_VIDEO_SECONDS;
+    const seconds = Math.max(1, Math.min(MAX_VIDEO_SECONDS, Math.round(asked)));
+    const asset = await generateVideo(
+      r.selected.capability,
+      r.cfg,
+      {
+        prompt,
+        seconds,
+        ...input["aspectRatio"] ? { aspectRatio: String(input["aspectRatio"]) } : {}
+      },
+      options.signal,
+      // Progress goes to the run log so a two-minute wait doesn't look like a
+      // hang — the single most likely reason someone kills a working render.
+      (note) => options.onProgress?.(note)
+    );
+    const location = await this.deps.sink(asset);
+    const unit = r.selected.cost;
+    const estimate = unit ? ` Estimated cost: $${(unit.amount * seconds).toFixed(2)} (${seconds}s x ${unit.label}).` : "";
+    const clamped = seconds !== Math.round(asked) ? ` Duration was clamped to ${seconds}s (max ${MAX_VIDEO_SECONDS}).` : "";
+    return `Video generated and saved to ${location}.
+Model: ${asset.modelId}.${estimate}${clamped}`;
+  }
+};
 var TranscribeAudioTool = class extends BaseTool {
   constructor(deps, readFile) {
     super();
@@ -11572,6 +11696,7 @@ function buildMediaTools(deps, readFile) {
   const modalities = new Set(deps.registry.availableModalities());
   if (modalities.has("image")) tools.push(new GenerateImageTool(deps));
   if (modalities.has("speech")) tools.push(new GenerateSpeechTool(deps));
+  if (modalities.has("video")) tools.push(new GenerateVideoTool(deps));
   if (modalities.has("transcription") && readFile) tools.push(new TranscribeAudioTool(deps, readFile));
   return tools;
 }
@@ -15991,6 +16116,7 @@ var Cascade = class _Cascade extends EventEmitter__default.default {
   router;
   toolRegistry;
   multimodal;
+  mediaSink;
   mcpClient;
   codeIndex;
   config;
@@ -16310,14 +16436,27 @@ ${input}` }],
    * server stores a file row) constructs the tools itself via buildMediaTools
    * with its own sink.
    */
+  /**
+   * Replace where generated media is written.
+   *
+   * The default sink writes into the workspace, which is what a desktop or CLI
+   * run wants. A host with different storage — the cloud server keeps a file
+   * row plus bytes under the tenant's directory — supplies its own here, and
+   * the media tools are rebuilt around it. Re-registering by name replaces the
+   * existing tools rather than duplicating them.
+   */
+  setMediaSink(sink) {
+    this.mediaSink = sink;
+    this.registerMediaTools(this.workspacePath);
+  }
   registerMediaTools(workspacePath) {
-    const allowlist = this.config.tools?.enabledTools;
-    const permitted = (name) => !allowlist || allowlist.includes(name);
+    const denied = new Set(this.config.tools?.disabledTools ?? []);
+    const permitted = (name) => !denied.has(name);
     const tools = buildMediaTools(
       {
         registry: this.multimodal,
         lookupProvider: (provider) => (this.config.providers ?? []).find((p) => p.type === provider),
-        sink: async (asset) => {
+        sink: this.mediaSink ?? (async (asset) => {
           const fsp = await import('fs/promises');
           const nodePath = await import('path');
           const dir = nodePath.join(workspacePath, "generated");
@@ -16325,7 +16464,7 @@ ${input}` }],
           const dest = nodePath.join(dir, asset.filename);
           await fsp.writeFile(dest, asset.data);
           return nodePath.relative(workspacePath, dest);
-        }
+        })
       },
       async (p) => {
         const fsp = await import('fs/promises');
@@ -17329,7 +17468,7 @@ var CloudClient = class _CloudClient {
     const deadline = Date.now() + start.expiresIn * 1e3;
     while (Date.now() < deadline) {
       if (opts.signal?.aborted) throw new Error("Sign-in cancelled.");
-      await sleep(interval * 1e3, opts.signal);
+      await sleep2(interval * 1e3, opts.signal);
       const r = await this.pollDevice(start.deviceCode);
       if (r === "slow_down") {
         interval += 5;
@@ -17540,7 +17679,7 @@ var CloudClient = class _CloudClient {
     this.store.clear();
   }
 };
-function sleep(ms, signal) {
+function sleep2(ms, signal) {
   return new Promise((resolve2, reject) => {
     const t = setTimeout(resolve2, ms);
     signal?.addEventListener("abort", () => {