cascade-ai 0.51.0 → 0.53.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.53.0";
     CASCADE_CONFIG_FILE = ".cascade/config.json";
     CASCADE_DB_FILE = ".cascade/memory.db";
     CASCADE_DASHBOARD_SECRET_FILE = ".cascade/dashboard-secret";
@@ -2792,26 +2792,14 @@ var init_openai = __esm({
 // src/providers/azure.ts
 var azure_exports = {};
 __export(azure_exports, {
+  AZURE_BASE_MODELS: () => AZURE_BASE_MODELS,
   AzureOpenAIProvider: () => AzureOpenAIProvider,
   azureModelForDeployment: () => azureModelForDeployment,
   inferAzureBaseModel: () => inferAzureBaseModel
 });
 function inferAzureBaseModel(deploymentName) {
   const n = deploymentName.toLowerCase();
-  const rules = [
-    [/gpt-?5\.5/, "gpt-5.5"],
-    [/gpt-?5\.4.*mini/, "gpt-5.4-mini"],
-    [/gpt-?5\.4/, "gpt-5.4"],
-    [/gpt-?5.*nano/, "gpt-5-nano"],
-    [/gpt-?5.*mini/, "gpt-5-mini"],
-    [/gpt-?5/, "gpt-5"],
-    [/gpt-?4\.1-nano/, "gpt-4.1-nano"],
-    [/gpt-?4\.1-mini/, "gpt-4.1-mini"],
-    [/gpt-?4\.1/, "gpt-4.1"],
-    [/gpt-?4o-mini/, "gpt-4o-mini"],
-    [/gpt-?4o/, "gpt-4o"]
-  ];
-  for (const [re, base] of rules) if (re.test(n)) return base;
+  for (const [re, base] of AZURE_BASE_MODEL_RULES) if (re.test(n)) return base;
   return null;
 }
 function azureModelForDeployment(cfg) {
@@ -2856,13 +2844,27 @@ function azureModelForDeployment(cfg) {
     supportsToolUse: true
   };
 }
-var DEFAULT_AZURE_API_VERSION, AzureOpenAIProvider;
+var DEFAULT_AZURE_API_VERSION, AZURE_BASE_MODEL_RULES, AZURE_BASE_MODELS, AzureOpenAIProvider;
 var init_azure = __esm({
   "src/providers/azure.ts"() {
     init_constants();
     init_openai();
     init_pricing();
     DEFAULT_AZURE_API_VERSION = "2024-12-01-preview";
+    AZURE_BASE_MODEL_RULES = [
+      [/gpt-?5\.5/, "gpt-5.5"],
+      [/gpt-?5\.4.*mini/, "gpt-5.4-mini"],
+      [/gpt-?5\.4/, "gpt-5.4"],
+      [/gpt-?5.*nano/, "gpt-5-nano"],
+      [/gpt-?5.*mini/, "gpt-5-mini"],
+      [/gpt-?5/, "gpt-5"],
+      [/gpt-?4\.1-nano/, "gpt-4.1-nano"],
+      [/gpt-?4\.1-mini/, "gpt-4.1-mini"],
+      [/gpt-?4\.1/, "gpt-4.1"],
+      [/gpt-?4o-mini/, "gpt-4o-mini"],
+      [/gpt-?4o/, "gpt-4o"]
+    ];
+    AZURE_BASE_MODELS = AZURE_BASE_MODEL_RULES.map(([, id]) => id);
     AzureOpenAIProvider = class extends OpenAIProvider {
       constructor(config, model) {
         const rawUrl = config.baseUrl ?? AZURE_BASE_URL_TEMPLATE.replace("{resource}", "YOUR_RESOURCE");
@@ -5050,7 +5052,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(),
@@ -5556,6 +5565,26 @@ var ConfigManager = class {
   }
 };
 
+// src/tools/tool-name.ts
+var MCP_TOOL_PREFIX = "mcp__";
+function sanitizeToolNameSegment(segment) {
+  const cleaned = segment.replace(/[^a-zA-Z0-9-]+/g, "_");
+  let start = 0;
+  let end = cleaned.length;
+  while (start < end && cleaned[start] === "_") start++;
+  while (end > start && cleaned[end - 1] === "_") end--;
+  return cleaned.slice(start, end) || "_";
+}
+function mcpToolName(serverName, toolName) {
+  return `${MCP_TOOL_PREFIX}${sanitizeToolNameSegment(serverName)}__${sanitizeToolNameSegment(toolName)}`;
+}
+function isMcpToolName(name) {
+  return name.startsWith(MCP_TOOL_PREFIX);
+}
+function mcpServerPrefix(serverName) {
+  return `${MCP_TOOL_PREFIX}${sanitizeToolNameSegment(serverName)}__`;
+}
+
 // src/cli/utils/terminal-input.ts
 var PASTE_START = "\x1B[200~";
 var PASTE_END = "\x1B[201~";
@@ -11075,17 +11104,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 +11423,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 +11616,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 +11718,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;
 }
@@ -13072,7 +13219,7 @@ var McpToolWrapper = class extends BaseTool {
     this.mcpClient = mcpClient;
     this.serverName = serverName;
     this.toolName = toolName;
-    this.name = `mcp::${serverName}::${toolName}`;
+    this.name = mcpToolName(serverName, toolName);
     this.description = `[MCP:${serverName}] ${description}`;
     this.inputSchema = inputSchema;
   }
@@ -15991,6 +16138,7 @@ var Cascade = class _Cascade extends EventEmitter__default.default {
   router;
   toolRegistry;
   multimodal;
+  mediaSink;
   mcpClient;
   codeIndex;
   config;
@@ -16310,14 +16458,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 +16486,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 +17490,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 +17701,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", () => {
@@ -19419,13 +19580,13 @@ ${msg.content}`).join("\n\n");
         const cascade = cascadeRef.current;
         if (!cascade) return "Cascade not initialized.";
         const toolRegistry = cascade.getToolRegistry();
-        const tools = toolRegistry.getToolDefinitions().filter((t) => t.name.startsWith("mcp::"));
+        const tools = toolRegistry.getToolDefinitions().filter((t) => isMcpToolName(t.name));
         if (tools.length === 0) return "No MCP tools connected.";
         const servers = /* @__PURE__ */ new Set();
         tools.forEach((t) => servers.add(t.name.split("::")[1]));
         const lines = [`Connected MCP Servers (${servers.size}):`];
         for (const server of servers) {
-          const serverTools = tools.filter((t) => t.name.startsWith(`mcp::${server}::`));
+          const serverTools = tools.filter((t) => t.name.startsWith(mcpServerPrefix(server)));
           lines.push(`
 \u25CF ${server} (${serverTools.length} tools)`);
           serverTools.forEach((t) => lines.push(`  - ${t.name.split("::")[2]} \u2014 ${t.description.replace(`[MCP:${server}] `, "")}`));