cascade-ai 0.50.0 → 0.52.0

package/dist/index.js

@@ -1845,7 +1845,7 @@ function reconcilePrice(model, live) {
 }
 
 // src/constants.ts
-var CASCADE_VERSION = "0.50.0";
+var CASCADE_VERSION = "0.52.0";
 var CASCADE_CONFIG_DIR = ".cascade";
 var CASCADE_MD_FILE = "CASCADE.md";
 var CASCADE_IGNORE_FILE = ".cascadeignore";
@@ -2358,46 +2358,37 @@ var BaseProvider = class {
 };
 
 // src/providers/model-filter.ts
-var NON_CHAT_PATTERNS = [
-  "embed",
+var MODALITY_PATTERNS = [
+  ["embedding", ["embed"]],
   // text-embedding-3, nomic-embed, mxbai-embed, snowflake-arctic-embed
-  "(?:^|[-_/])tts(?:[-_/]|$)",
-  "text-to-speech",
-  "speech",
-  // text-to-speech
-  "whisper",
-  "transcrib",
-  "(?:^|[-_/])stt(?:[-_/]|$)",
-  // speech-to-text
-  "dall[-]?e",
-  "imagen",
-  "image-generation",
-  "gpt-image",
-  "(?:^|[-_/])image(?:[-_/]|$)",
-  "stable-diffusion",
-  "sdxl",
-  "flux",
-  // image gen
-  "moderation",
-  "(?:^|[-_/])guard(?:[-_/]|$)",
-  // moderation / safety
-  "rerank",
-  "(?:^|[-_/])audio(?:[-_/]|$)",
-  "native-audio",
-  "realtime",
-  // audio / realtime
-  "veo",
-  "sora",
-  "(?:^|[-_/])video(?:[-_/]|$)",
-  // video
-  "(?:^|[-_/])aqa(?:[-_/]|$)",
-  // attributed QA
-  "(?:^|[-_/])live(?:[-_/]|$)",
-  // live-audio variants
-  "(?:^|[-_/])(?:davinci|babbage)(?:[-_/]|$)"
-  // legacy completion-only base models
+  ["transcription", ["whisper", "transcrib", "(?:^|[-_/])stt(?:[-_/]|$)"]],
+  ["speech", ["(?:^|[-_/])tts(?:[-_/]|$)", "text-to-speech", "speech"]],
+  ["video", ["veo", "sora", "(?:^|[-_/])video(?:[-_/]|$)"]],
+  ["image", [
+    "dall[-]?e",
+    "imagen",
+    "image-generation",
+    "gpt-image",
+    "(?:^|[-_/])image(?:[-_/]|$)",
+    "stable-diffusion",
+    "sdxl",
+    "flux"
+  ]],
+  ["moderation", ["moderation", "(?:^|[-_/])guard(?:[-_/]|$)"]],
+  ["rerank", ["rerank"]],
+  ["realtime", [
+    "(?:^|[-_/])audio(?:[-_/]|$)",
+    "native-audio",
+    "realtime",
+    "(?:^|[-_/])live(?:[-_/]|$)",
+    // live-audio variants
+    "(?:^|[-_/])aqa(?:[-_/]|$)"
+    // attributed QA
+  ]],
+  ["legacy-completion", ["(?:^|[-_/])(?:davinci|babbage)(?:[-_/]|$)"]]
 ];
-var NON_CHAT = new RegExp(NON_CHAT_PATTERNS.join("|"), "i");
+MODALITY_PATTERNS.map(([m, pats]) => [m, new RegExp(pats.join("|"), "i")]);
+var NON_CHAT = new RegExp(MODALITY_PATTERNS.flatMap(([, p]) => p).join("|"), "i");
 function isChatModel(id, methods) {
   if (methods && methods.length > 0) {
     const canGenerate = methods.some((m) => /generatecontent|generatemessage|chat|completion/i.test(m));
@@ -2925,6 +2916,115 @@ var AzureOpenAIProvider = class extends OpenAIProvider {
     }
   }
 };
+
+// src/providers/gemini-schema.ts
+var ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "format",
+  "title",
+  "description",
+  "nullable",
+  "enum",
+  "items",
+  "properties",
+  "required",
+  "propertyOrdering",
+  "minItems",
+  "maxItems",
+  "minProperties",
+  "maxProperties",
+  "minimum",
+  "maximum",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "example",
+  "default",
+  "anyOf"
+]);
+var ALLOWED_TYPES = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "array", "object"]);
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function normalizeType(value) {
+  if (typeof value === "string") {
+    return ALLOWED_TYPES.has(value) ? { type: value } : {};
+  }
+  if (Array.isArray(value)) {
+    const types = value.filter((t) => typeof t === "string");
+    const nullable = types.includes("null");
+    const concrete = types.find((t) => t !== "null" && ALLOWED_TYPES.has(t));
+    return {
+      ...concrete ? { type: concrete } : {},
+      ...nullable ? { nullable: true } : {}
+    };
+  }
+  return {};
+}
+function normalizeEnum(value) {
+  if (!Array.isArray(value) || value.length === 0) return void 0;
+  return value.map((v) => typeof v === "string" ? v : JSON.stringify(v));
+}
+function sanitizeGeminiSchema(schema) {
+  if (!isPlainObject(schema)) return void 0;
+  const out = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (!ALLOWED_KEYS.has(key)) continue;
+    switch (key) {
+      case "type": {
+        Object.assign(out, normalizeType(value));
+        break;
+      }
+      case "enum": {
+        const e = normalizeEnum(value);
+        if (e) out["enum"] = e;
+        break;
+      }
+      case "properties": {
+        if (!isPlainObject(value)) break;
+        const props = {};
+        for (const [propName, propSchema] of Object.entries(value)) {
+          const cleaned = sanitizeGeminiSchema(propSchema);
+          props[propName] = cleaned && Object.keys(cleaned).length ? cleaned : { type: "string" };
+        }
+        out["properties"] = props;
+        break;
+      }
+      case "items": {
+        const cleaned = sanitizeGeminiSchema(value);
+        if (cleaned) out["items"] = cleaned;
+        break;
+      }
+      case "anyOf": {
+        if (!Array.isArray(value)) break;
+        const variants = value.map((v) => sanitizeGeminiSchema(v)).filter((v) => !!v && Object.keys(v).length > 0);
+        if (variants.length) out["anyOf"] = variants;
+        break;
+      }
+      case "required": {
+        if (Array.isArray(value)) {
+          out["required"] = value.filter((r) => typeof r === "string");
+        }
+        break;
+      }
+      default:
+        out[key] = value;
+    }
+  }
+  if (!out["type"] && out["properties"]) out["type"] = "object";
+  if (!out["type"] && out["items"]) out["type"] = "array";
+  return out;
+}
+function toGeminiParameters(inputSchema) {
+  const cleaned = sanitizeGeminiSchema(inputSchema);
+  if (!cleaned) return void 0;
+  const props = cleaned["properties"];
+  if (isPlainObject(props) && Object.keys(props).length === 0) return void 0;
+  if (Object.keys(cleaned).length === 0) return void 0;
+  return cleaned;
+}
+
+// src/providers/gemini.ts
 var GeminiProvider = class extends BaseProvider {
   client;
   constructor(config, model) {
@@ -3145,7 +3245,12 @@ var GeminiProvider = class extends BaseProvider {
     return {
       name: tool.name,
       description: tool.description,
-      parameters: tool.inputSchema
+      // Convert, never cast. Gemini's parameters field is an OpenAPI subset
+      // that 400s on unknown keys, and MCP servers ship schemas carrying their
+      // own extensions (GitHub's adds `x-mcp-header` to every header-bound
+      // property). Casting sent those through verbatim and every request failed
+      // before the model saw it. See providers/gemini-schema.ts.
+      parameters: toGeminiParameters(tool.inputSchema)
     };
   }
 };
@@ -3173,7 +3278,7 @@ async function nodeHttpFetch(input, init = {}, redirectCount = 0) {
     headers["accept-encoding"] = "gzip, deflate, br";
   }
   const body = init.body == null ? void 0 : typeof init.body === "string" ? init.body : Buffer.from(init.body);
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const req = lib.request(
       {
         hostname: u.hostname,
@@ -3190,7 +3295,7 @@ async function nodeHttpFetch(input, init = {}, redirectCount = 0) {
           const nextUrl = new URL(location, u).href;
           const downgrade = status === 303 || (status === 301 || status === 302) && method !== "GET" && method !== "HEAD";
           const nextInit = downgrade ? { ...init, method: "GET", body: void 0 } : init;
-          resolve(nodeHttpFetch(nextUrl, nextInit, redirectCount + 1));
+          resolve2(nodeHttpFetch(nextUrl, nextInit, redirectCount + 1));
           return;
         }
         const encoding = (res.headers["content-encoding"] ?? "").toLowerCase();
@@ -3205,7 +3310,7 @@ async function nodeHttpFetch(input, init = {}, redirectCount = 0) {
           if (Array.isArray(v)) respHeaders.set(k, v.join(", "));
           else if (typeof v === "string") respHeaders.set(k, v);
         }
-        resolve(new Response(stream, {
+        resolve2(new Response(stream, {
           status,
           statusText: res.statusMessage ?? "",
           headers: respHeaders
@@ -3850,7 +3955,7 @@ var TpmLimiter = class {
       }
       const deficit = want - bucket.available;
       const waitMs = Math.max(50, Math.ceil(deficit / bucket.tokensPerMinute * 6e4));
-      await new Promise((resolve) => setTimeout(resolve, waitMs));
+      await new Promise((resolve2) => setTimeout(resolve2, waitMs));
     }
   }
   /**
@@ -3913,14 +4018,14 @@ var LocalRequestQueue = class {
       this.active++;
       return this.makeRelease();
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       let settled = false;
       let timer;
       const resolver = (release) => {
         if (settled) return;
         settled = true;
         if (timer !== void 0) clearTimeout(timer);
-        resolve(release);
+        resolve2(release);
       };
       if (timeoutMs !== void 0 && timeoutMs > 0) {
         timer = setTimeout(() => {
@@ -4551,6 +4656,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
   tpmLimiter;
   localQueue;
   taskAnalyzer;
+  pendingFeedbackSource;
   worldStateDB;
   privacyPaths;
   guidanceQueue;
@@ -5005,8 +5111,18 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     return windows.length ? Math.min(...windows) : void 0;
   }
   /** Wire the Cascade Auto task analyzer used for per-subtask model routing. */
+  /**
+   * Feed per-model thumbs counts into Auto routing. Forwarded to the analyzer
+   * because that is where the public benchmark score is combined; the prior
+   * adjusts that number rather than sitting anywhere else in the pipeline.
+   */
+  setFeedbackSource(source) {
+    this.taskAnalyzer?.setFeedbackSource(source);
+    this.pendingFeedbackSource = source;
+  }
   setTaskAnalyzer(analyzer) {
     this.taskAnalyzer = analyzer;
+    if (this.pendingFeedbackSource) analyzer.setFeedbackSource(this.pendingFeedbackSource);
   }
   setWorldStateDB(db) {
     this.worldStateDB = db;
@@ -6100,8 +6216,11 @@ Now execute your subtask using this context where relevant.`
       const result = await this.runAgentLoop(systemPrompt, this.tools);
       output = result.output;
       toolCalls = result.toolCalls;
-      this.sendStatusUpdate({ progressPct: 65, currentAction: "Verifying required artifacts", status: "IN_PROGRESS" });
-      const artifactCheck = await this.verifyArtifacts(assignment);
+      const mustProduceArtifact = this.requiresArtifact();
+      if (mustProduceArtifact) {
+        this.sendStatusUpdate({ progressPct: 65, currentAction: "Verifying required artifacts", status: "IN_PROGRESS" });
+      }
+      const artifactCheck = mustProduceArtifact ? await this.verifyArtifacts(assignment) : { ok: true, issues: [] };
       if (!artifactCheck.ok) {
         correctionAttempts = 1;
         issues.push(...artifactCheck.issues);
@@ -6381,11 +6500,11 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
           if (!wasApproved) return `Tool ${tc.name} was denied by user.`;
         } else {
           const LEGACY_APPROVAL_TIMEOUT_MS = 6e5;
-          const legacyDecision = await new Promise((resolve) => {
+          const legacyDecision = await new Promise((resolve2) => {
             const eventName = `tool:approval-response:${this.id}-${tc.id}`;
             const timer = setTimeout(() => {
               this.removeAllListeners(eventName);
-              resolve({ approved: false });
+              resolve2({ approved: false });
             }, LEGACY_APPROVAL_TIMEOUT_MS);
             timer.unref?.();
             this.emit("tool:approval-request", {
@@ -6398,7 +6517,7 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
             });
             this.once(eventName, (d) => {
               clearTimeout(timer);
-              resolve(d);
+              resolve2(d);
             });
           });
           if (legacyDecision.always) this.sessionApprovals.set(tc.name, legacyDecision.approved);
@@ -6418,6 +6537,9 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
         tierId: this.id,
         sessionId: this.taskId,
         requireApproval: false,
+        // Media generation can run for a minute; without this a cancelled run
+        // still pays for an image nobody will see.
+        ...this.signal ? { signal: this.signal } : {},
         saveSnapshot: async (path26, content) => {
           this.store?.addFileSnapshot(this.taskId, path26, content);
         },
@@ -6465,7 +6587,8 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
         const result = await this.toolRegistry.execute(altTool, tc.input, {
           tierId: this.id,
           sessionId: this.taskId,
-          requireApproval: false
+          requireApproval: false,
+          ...this.signal ? { signal: this.signal } : {}
         });
         const str = typeof result === "string" ? result : JSON.stringify(result);
         if (!str.startsWith("Tool error:") && !str.startsWith("Error:")) {
@@ -6487,7 +6610,8 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
           const result = await this.toolRegistry.execute(newToolName, tc.input, {
             tierId: this.id,
             sessionId: this.taskId,
-            requireApproval: false
+            requireApproval: false,
+            ...this.signal ? { signal: this.signal } : {}
           });
           const str = typeof result === "string" ? result : JSON.stringify(result);
           if (!str.startsWith("Tool error:")) return `[Synthesized ${newToolName}]: ${str}`;
@@ -6905,7 +7029,7 @@ var PeerBus = class extends EventEmitter {
     this.outputs.set(subtaskId, entry);
     this.emit("output:ready", entry);
     const waiting = this.waiters.get(subtaskId) ?? [];
-    for (const resolve of waiting) resolve(entry);
+    for (const resolve2 of waiting) resolve2(entry);
     this.waiters.delete(subtaskId);
   }
   /**
@@ -6936,10 +7060,10 @@ var PeerBus = class extends EventEmitter {
   waitFor(subtaskId, timeoutMs = 12e4) {
     const existing = this.outputs.get(subtaskId);
     if (existing && !this.retryPending.has(subtaskId)) return Promise.resolve(existing);
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const resolver = (output) => {
         clearTimeout(timer);
-        resolve(output);
+        resolve2(output);
       };
       const timer = setTimeout(() => {
         const waiting = this.waiters.get(subtaskId);
@@ -6993,10 +7117,10 @@ var PeerBus = class extends EventEmitter {
    */
   collect(timeoutMs) {
     const collected = [...this.broadcastLog];
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const timer = setTimeout(() => {
         off();
-        resolve(collected);
+        resolve2(collected);
       }, timeoutMs);
       const handler = (msg) => {
         collected.push({ fromId: msg.fromId, payload: msg.payload, timestamp: msg.timestamp });
@@ -7010,7 +7134,7 @@ var PeerBus = class extends EventEmitter {
         const broadcasters = new Set(collected.map((m) => m.fromId));
         if (broadcasters.size >= this.members.size) {
           off();
-          resolve(collected);
+          resolve2(collected);
         }
       };
       this.on("broadcast", checkComplete);
@@ -7028,7 +7152,7 @@ var PeerBus = class extends EventEmitter {
       return;
     }
     this.emitCoordination(tierId, `\u23F3 waiting for ${filePath} (held by ${existing.holderId})`);
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         reject(new Error(`File lock timeout for ${filePath} (held by ${existing.holderId})`));
       }, timeoutMs);
@@ -7036,7 +7160,7 @@ var PeerBus = class extends EventEmitter {
         clearTimeout(timer);
         this.fileLocks.set(filePath, { holderId: tierId, lockedAt: (/* @__PURE__ */ new Date()).toISOString(), waiters: [] });
         this.emitCoordination(tierId, `\u{1F512} locked ${filePath}`);
-        resolve();
+        resolve2();
       });
     });
   }
@@ -7061,11 +7185,11 @@ var PeerBus = class extends EventEmitter {
    */
   waitForFileRelease(filePath, timeoutMs = 3e4) {
     if (!this.fileLocks.has(filePath)) return Promise.resolve();
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => reject(new Error(`Timeout waiting for file release: ${filePath}`)), timeoutMs);
       this.once(`file:released:${filePath}`, () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
     });
   }
@@ -7131,13 +7255,13 @@ var PeerBus = class extends EventEmitter {
       this.emit(`barrier:${barrierName}`);
       return;
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         reject(new Error(`Barrier timeout: ${barrierName} (${bar.arrived.size}/${bar.total} arrived)`));
       }, 12e4);
       this.once(`barrier:${barrierName}`, () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
     });
   }
@@ -8682,6 +8806,170 @@ Reply with exactly one word: YES, NO, or UNSURE.
   }
 };
 
+// src/core/multimodal/registry.ts
+var CAPABILITIES = [
+  // ── Image ──
+  {
+    modality: "image",
+    provider: "openai",
+    modelId: "dall-e-3",
+    api: "openai-images"
+  },
+  {
+    modality: "image",
+    provider: "gemini",
+    modelId: "gemini-3-pro-image",
+    api: "gemini-predict"
+  },
+  // ── Speech (text → audio) ──
+  {
+    modality: "speech",
+    provider: "openai",
+    modelId: "tts-1",
+    api: "openai-speech"
+  },
+  {
+    // The only quality claim in this table that needs no leaderboard: OpenAI
+    // ships these as the same voice at two fidelities and charges double for
+    // this one. That is the vendor's own ordering, not an inference.
+    modality: "speech",
+    provider: "openai",
+    modelId: "tts-1-hd",
+    api: "openai-speech",
+    quality: 70,
+    qualityBasis: "OpenAI's own hd variant of tts-1, priced 2x"
+  },
+  // ── Transcription (audio → text) ──
+  {
+    modality: "transcription",
+    provider: "openai",
+    modelId: "whisper-1",
+    api: "openai-transcriptions"
+  },
+  // ── Video ──
+  {
+    // 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-lro"
+  }
+];
+function capabilityCost(cap) {
+  const match = findPricing(cap.modelId, cap.provider, {
+    fallbackProviders: cap.provider === "gemini" ? ["vertex"] : []
+  });
+  const rate = match?.entry.rates?.[0];
+  if (!rate) return null;
+  const unitLabel = {
+    per_image: "per image",
+    per_second: "per second of video",
+    per_character: "per character",
+    per_audio_minute: "per audio minute"
+  };
+  const unit = unitLabel[rate.unit] ?? rate.unit;
+  const amount = rate.amount;
+  const shown = amount < 1e-3 ? amount.toExponential(2) : amount.toFixed(4);
+  return { label: `$${shown} ${unit}`, amount, unit };
+}
+var MultimodalRegistry = class {
+  /** Provider types the user has actually configured a key for. */
+  available;
+  constructor(availableProviders) {
+    this.available = new Set(availableProviders);
+  }
+  /** Every capability whose provider is configured AND which Cascade can call. */
+  usable(modality) {
+    return CAPABILITIES.filter(
+      (c) => !c.unsupported && this.available.has(c.provider) && (!modality || c.modality === modality)
+    );
+  }
+  /** Modalities this account can actually generate right now. */
+  availableModalities() {
+    return [...new Set(this.usable().map((c) => c.modality))];
+  }
+  /**
+   * Pick a model for a modality.
+   *
+   * Ranked models beat unranked ones, then higher quality, then lower unit
+   * price. An explicit `preferModel` wins outright when it is usable — the user
+   * naming a model is a stronger signal than any prior.
+   */
+  select(modality, opts = {}) {
+    const pool = this.usable(modality);
+    if (!pool.length) return null;
+    if (opts.preferModel) {
+      const wanted = pool.find((c) => c.modelId === opts.preferModel);
+      if (wanted) {
+        return { capability: wanted, cost: capabilityCost(wanted), reason: `Requested explicitly: ${wanted.modelId}.` };
+      }
+    }
+    const scored = pool.map((c) => ({ c, cost: capabilityCost(c) })).sort((a, b) => {
+      const qa = a.c.quality ?? -1;
+      const qb = b.c.quality ?? -1;
+      if (qa !== qb) return qb - qa;
+      const pa = a.cost?.amount ?? Number.POSITIVE_INFINITY;
+      const pb = b.cost?.amount ?? Number.POSITIVE_INFINITY;
+      return pa - pb;
+    });
+    const best = scored[0];
+    const ranked = best.c.quality !== void 0;
+    const reason = ranked ? `${best.c.modelId} (${best.c.provider}) \u2014 ranked highest for ${modality}: ${best.c.qualityBasis}.` + (best.cost ? ` ${best.cost.label}.` : "") : `${best.c.modelId} (${best.c.provider}) \u2014 cheapest usable ${modality} model` + (best.cost ? ` at ${best.cost.label}` : "") + ". No published quality ranking is applied for this modality, so this is a cost choice, not a quality one.";
+    return { capability: best.c, cost: best.cost, reason };
+  }
+  /**
+   * A plain-language account of what this account can and cannot generate —
+   * including the things it cannot, and why. The planner sees this, so being
+   * candid here is what stops it inventing a `generate_music` call.
+   */
+  describe() {
+    const lines = [];
+    const usable = this.usable();
+    if (usable.length) {
+      lines.push("Generation models available on your configured providers:");
+      for (const modality of ["image", "speech", "transcription", "video"]) {
+        const forModality = usable.filter((c) => c.modality === modality);
+        if (!forModality.length) continue;
+        const shown = forModality.map((c) => {
+          const cost = capabilityCost(c);
+          return `${c.modelId}${cost ? ` (${cost.label})` : ""}`;
+        });
+        lines.push(`  ${modality}: ${shown.join(", ")}`);
+      }
+    } else {
+      lines.push("No generation models are available \u2014 none of your configured providers offers one.");
+    }
+    const blocked = CAPABILITIES.filter((c) => c.unsupported && this.available.has(c.provider));
+    for (const c of blocked) {
+      lines.push(`  ${c.modality}: ${c.modelId} exists on your account but is not callable. ${c.unsupported}`);
+    }
+    lines.push(
+      "  music: no supported provider exposes a music-generation API, so Cascade cannot generate music."
+    );
+    return lines.join("\n");
+  }
+};
+
+// src/tools/base.ts
+var BaseTool = class {
+  workspaceRoot = process.cwd();
+  setWorkspaceRoot(root) {
+    this.workspaceRoot = root;
+  }
+  isDangerous() {
+    return false;
+  }
+  getDefinition() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+};
+
 // src/core/router/provider-errors.ts
 var SYSTEMIC = /* @__PURE__ */ new Set([
   "rate_limit",
@@ -8746,7 +9034,7 @@ function classifyProviderError(err) {
   return { kind, systemic: isSystemicKind(kind), status, raw };
 }
 function describeProviderError(c, modelId) {
-  const on = ` on ${modelId}` ;
+  const on = modelId ? ` on ${modelId}` : "";
   const detail = c.raw ? ` Provider said: ${c.raw}` : "";
   switch (c.kind) {
     case "rate_limit":
@@ -8768,6 +9056,417 @@ function describeProviderError(c, modelId) {
   }
 }
 
+// src/core/multimodal/generate.ts
+var DEFAULT_TIMEOUT_MS = 12e4;
+async function callProvider(fn, modelId) {
+  try {
+    return await fn();
+  } catch (err) {
+    const classified = classifyProviderError(err);
+    throw new Error(describeProviderError(classified, modelId));
+  }
+}
+async function postJson(url, body, headers, signal) {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), DEFAULT_TIMEOUT_MS);
+  const onAbort = () => ac.abort();
+  signal?.addEventListener("abort", onAbort);
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...headers },
+      body: JSON.stringify(body),
+      signal: ac.signal
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw Object.assign(new Error(text || res.statusText), { status: res.status });
+    }
+    return res;
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+  }
+}
+function baseUrlFor(cfg, fallback) {
+  return (cfg.baseUrl ?? fallback).replace(/\/+$/, "");
+}
+function stamp(ext) {
+  return `cascade-${Date.now()}.${ext}`;
+}
+async function generateImage(cap, cfg, req, signal) {
+  return callProvider(async () => {
+    if (cap.api === "openai-images") {
+      const url = `${baseUrlFor(cfg, "https://api.openai.com/v1")}/images/generations`;
+      const res = await postJson(url, {
+        model: cap.modelId,
+        prompt: req.prompt,
+        size: req.size ?? "1024x1024",
+        n: 1,
+        // b64 rather than a URL: see the file header — provider URLs expire.
+        response_format: "b64_json"
+      }, { Authorization: `Bearer ${cfg.apiKey ?? ""}` }, signal);
+      const body = await res.json();
+      const first = body.data?.[0];
+      if (!first?.b64_json) throw new Error("Image response contained no image data.");
+      return {
+        data: Buffer.from(first.b64_json, "base64"),
+        mimeType: "image/png",
+        filename: stamp("png"),
+        modelId: cap.modelId,
+        provider: cap.provider,
+        ...first.revised_prompt ? { revisedPrompt: first.revised_prompt } : {}
+      };
+    }
+    if (cap.api === "gemini-predict") {
+      const base = baseUrlFor(cfg, "https://generativelanguage.googleapis.com/v1beta");
+      const url = `${base}/models/${encodeURIComponent(cap.modelId)}:predict`;
+      const res = await postJson(url, {
+        instances: [{ prompt: req.prompt }],
+        parameters: { sampleCount: 1 }
+      }, { "x-goog-api-key": cfg.apiKey ?? "" }, signal);
+      const body = await res.json();
+      const first = body.predictions?.[0];
+      if (!first?.bytesBase64Encoded) throw new Error("Image response contained no image data.");
+      const mimeType = first.mimeType ?? "image/png";
+      return {
+        data: Buffer.from(first.bytesBase64Encoded, "base64"),
+        mimeType,
+        filename: stamp(mimeType.includes("jpeg") ? "jpg" : "png"),
+        modelId: cap.modelId,
+        provider: cap.provider
+      };
+    }
+    throw new Error(`${cap.modelId} is not an image generator.`);
+  }, cap.modelId);
+}
+async function generateSpeech(cap, cfg, req, signal) {
+  return callProvider(async () => {
+    if (cap.api !== "openai-speech") throw new Error(`${cap.modelId} is not a speech model.`);
+    const format = req.format ?? "mp3";
+    const url = `${baseUrlFor(cfg, "https://api.openai.com/v1")}/audio/speech`;
+    const res = await postJson(url, {
+      model: cap.modelId,
+      input: req.text,
+      voice: req.voice ?? "alloy",
+      response_format: format
+    }, { Authorization: `Bearer ${cfg.apiKey ?? ""}` }, signal);
+    const mime = {
+      mp3: "audio/mpeg",
+      opus: "audio/opus",
+      aac: "audio/aac",
+      flac: "audio/flac",
+      wav: "audio/wav"
+    };
+    return {
+      data: Buffer.from(await res.arrayBuffer()),
+      mimeType: mime[format] ?? "application/octet-stream",
+      filename: stamp(format),
+      modelId: cap.modelId,
+      provider: cap.provider
+    };
+  }, 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.`);
+    const url = `${baseUrlFor(cfg, "https://api.openai.com/v1")}/audio/transcriptions`;
+    const form = new FormData();
+    form.append("model", cap.modelId);
+    if (req.language) form.append("language", req.language);
+    form.append("file", new Blob([new Uint8Array(req.audio)]), req.filename);
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), DEFAULT_TIMEOUT_MS);
+    const onAbort = () => ac.abort();
+    signal?.addEventListener("abort", onAbort);
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${cfg.apiKey ?? ""}` },
+        body: form,
+        signal: ac.signal
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw Object.assign(new Error(text || res.statusText), { status: res.status });
+      }
+      const body = await res.json();
+      return { text: body.text ?? "", modelId: cap.modelId };
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    }
+  }, cap.modelId);
+}
+
+// src/tools/generate-media.ts
+function resolve(deps, modality, preferModel) {
+  const selected = deps.registry.select(modality, preferModel ? { preferModel } : {});
+  if (!selected) {
+    return { ok: false, error: `No ${modality} model is available on your configured providers.` };
+  }
+  const cfg = deps.lookupProvider(selected.capability.provider);
+  if (!cfg) {
+    return {
+      ok: false,
+      error: `${selected.capability.modelId} needs the ${selected.capability.provider} provider, which is not configured.`
+    };
+  }
+  return { ok: true, selected, cfg };
+}
+var GenerateImageTool = class extends BaseTool {
+  constructor(deps) {
+    super();
+    this.deps = deps;
+  }
+  deps;
+  name = "generate_image";
+  description = "Generate an image from a text description using the best available image model. Returns where the image was saved. Use when the user asks for a picture, illustration, diagram render, logo or any visual asset.";
+  inputSchema = {
+    type: "object",
+    properties: {
+      prompt: { type: "string", description: "What the image should show. Be specific about subject, style and composition." },
+      size: { type: "string", description: 'Pixel size, e.g. "1024x1024" (default), "1792x1024", "1024x1792".' },
+      model: { type: "string", description: "Optional: force a specific image model instead of the automatic choice." }
+    },
+    required: ["prompt"]
+  };
+  async execute(input, options) {
+    const prompt = String(input["prompt"] ?? "").trim();
+    if (!prompt) return 'Provide a "prompt" describing the image.';
+    const r = resolve(this.deps, "image", input["model"] ? String(input["model"]) : void 0);
+    if (!r.ok) return r.error;
+    const size = input["size"] ? String(input["size"]) : void 0;
+    const asset = await generateImage(
+      r.selected.capability,
+      r.cfg,
+      { prompt, ...size ? { size } : {} },
+      options.signal
+    );
+    const location = await this.deps.sink(asset);
+    return [
+      `Image generated and saved to ${location}.`,
+      `Model: ${asset.modelId} \u2014 ${r.selected.reason}`,
+      // DALL·E rewrites the prompt before drawing; the model needs to know what
+      // was actually rendered, not what it asked for, or its description of the
+      // result will not match the image.
+      asset.revisedPrompt ? `The provider rewrote the prompt to: ${asset.revisedPrompt}` : ""
+    ].filter(Boolean).join("\n");
+  }
+};
+var GenerateSpeechTool = class extends BaseTool {
+  constructor(deps) {
+    super();
+    this.deps = deps;
+  }
+  deps;
+  name = "generate_speech";
+  description = "Turn text into spoken audio using the best available text-to-speech model. Returns where the audio was saved. Use when the user asks for narration, a voiceover or an audio version of some text.";
+  inputSchema = {
+    type: "object",
+    properties: {
+      text: { type: "string", description: "The text to speak." },
+      voice: { type: "string", description: "Voice id: alloy, echo, fable, onyx, nova, shimmer. Default alloy." },
+      format: { type: "string", description: "Audio format: mp3 (default), opus, aac, flac, wav." },
+      model: { type: "string", description: "Optional: force a specific speech model." }
+    },
+    required: ["text"]
+  };
+  async execute(input, options) {
+    const text = String(input["text"] ?? "").trim();
+    if (!text) return 'Provide "text" to speak.';
+    const r = resolve(this.deps, "speech", input["model"] ? String(input["model"]) : void 0);
+    if (!r.ok) return r.error;
+    const fmt = String(input["format"] ?? "mp3");
+    const allowed = ["mp3", "opus", "aac", "flac", "wav"];
+    const format = allowed.includes(fmt) ? fmt : "mp3";
+    const asset = await generateSpeech(
+      r.selected.capability,
+      r.cfg,
+      { text, voice: input["voice"] ? String(input["voice"]) : void 0, format },
+      options.signal
+    );
+    const location = await this.deps.sink(asset);
+    return `Speech generated and saved to ${location}.
+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();
+    this.deps = deps;
+    this.readFile = readFile;
+  }
+  deps;
+  readFile;
+  name = "transcribe_audio";
+  description = "Transcribe a local audio file to text using the best available speech-to-text model. Use when the user supplies audio and wants its contents in writing.";
+  inputSchema = {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to the audio file to transcribe." },
+      language: { type: "string", description: 'Optional ISO-639-1 language hint, e.g. "en", improves accuracy.' },
+      model: { type: "string", description: "Optional: force a specific transcription model." }
+    },
+    required: ["path"]
+  };
+  async execute(input, options) {
+    const filePath = String(input["path"] ?? "").trim();
+    if (!filePath) return 'Provide a "path" to the audio file.';
+    const r = resolve(this.deps, "transcription", input["model"] ? String(input["model"]) : void 0);
+    if (!r.ok) return r.error;
+    let audio;
+    try {
+      audio = await this.readFile(filePath);
+    } catch {
+      return `Could not read the audio file at ${filePath}.`;
+    }
+    const { text, modelId } = await transcribeAudio(
+      r.selected.capability,
+      r.cfg,
+      {
+        audio,
+        filename: filePath.split(/[\\/]/).pop() || "audio",
+        ...input["language"] ? { language: String(input["language"]) } : {}
+      },
+      options.signal
+    );
+    return text ? `Transcript (${modelId}):
+
+${text}` : `${modelId} returned an empty transcript \u2014 the file may be silent or in an unsupported format.`;
+  }
+};
+function buildMediaTools(deps, readFile) {
+  const tools = [];
+  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;
+}
+
 // src/core/run-breaker.ts
 var DEFAULT_FAILURE_THRESHOLD = 3;
 var RunBreaker = class {
@@ -8833,26 +9532,6 @@ var RunBreaker = class {
     return out;
   }
 };
-
-// src/tools/base.ts
-var BaseTool = class {
-  workspaceRoot = process.cwd();
-  setWorkspaceRoot(root) {
-    this.workspaceRoot = root;
-  }
-  isDangerous() {
-    return false;
-  }
-  getDefinition() {
-    return {
-      name: this.name,
-      description: this.description,
-      inputSchema: this.inputSchema
-    };
-  }
-};
-
-// src/tools/shell.ts
 var execAsync = promisify(exec);
 var ShellTool = class extends BaseTool {
   name = "shell";
@@ -9548,7 +10227,7 @@ var PDFCreateTool = class extends BaseTool {
     if (!fs23.existsSync(dir)) {
       fs23.mkdirSync(dir, { recursive: true });
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       try {
         const doc = new PDFDocument({ margin: 50 });
         const stream = fs23.createWriteStream(filePath);
@@ -9566,7 +10245,7 @@ var PDFCreateTool = class extends BaseTool {
         });
         doc.end();
         stream.on("finish", () => {
-          resolve(`Successfully created PDF at ${filePath} (${content.length} characters)`);
+          resolve2(`Successfully created PDF at ${filePath} (${content.length} characters)`);
         });
         stream.on("error", (err) => {
           reject(new Error(`Failed to write PDF: ${err.message}`));
@@ -9638,7 +10317,7 @@ var CodeInterpreterTool = class extends BaseTool {
     const filePath = path24.join(tmpDir, fileName);
     fs23.writeFileSync(filePath, code, "utf-8");
     const execArgs = [filePath, ...args];
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const startMs = Date.now();
       execFile(cmdPrefix, execArgs, { cwd: this.workspaceRoot, timeout: 3e4 }, (error, stdout, stderr) => {
         const duration = Date.now() - startMs;
@@ -9652,17 +10331,17 @@ var CodeInterpreterTool = class extends BaseTool {
         if (error) {
           const timedOut = error.killed && duration >= 3e4;
           if (timedOut) {
-            resolve(`Execution timed out after 30s. Consider breaking the task into smaller pieces.
+            resolve2(`Execution timed out after 30s. Consider breaking the task into smaller pieces.
 Partial stdout: ${stdout}
 Stderr: ${stderr}`);
           } else {
-            resolve(`Execution failed (${duration}ms):
+            resolve2(`Execution failed (${duration}ms):
 Error: ${error.message}
 Stderr: ${stderr}
 Stdout: ${stdout}`);
           }
         } else {
-          resolve(`Execution successful (${duration}ms):
+          resolve2(`Execution successful (${duration}ms):
 Stdout: ${stdout}
 Stderr: ${stderr}`);
         }
@@ -10316,7 +10995,7 @@ var ToolRegistry = class extends EventEmitter {
    */
   waitForTool(toolName, timeoutMs = 6e4) {
     if (this.tools.has(toolName)) return Promise.resolve();
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         this.off("tool:added", handler);
         reject(new Error(`Timeout waiting for tool: ${toolName}`));
@@ -10325,7 +11004,7 @@ var ToolRegistry = class extends EventEmitter {
         if (name === toolName) {
           clearTimeout(timer);
           this.off("tool:added", handler);
-          resolve();
+          resolve2();
         }
       };
       this.on("tool:added", handler);
@@ -11000,20 +11679,20 @@ var PermissionEscalator = class extends EventEmitter {
     resolver(decision);
   }
   waitForUserDecision(req) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       let timer;
       const wrappedResolver = (decision) => {
         if (timer) clearTimeout(timer);
         if (decision.always) {
           this.taskWideCache.set(req.toolName, decision.approved);
         }
-        resolve(decision);
+        resolve2(decision);
       };
       this.pendingUserDecisions.set(req.id, wrappedResolver);
       if (this.approvalTimeoutMs > 0 && Number.isFinite(this.approvalTimeoutMs)) {
         timer = setTimeout(() => {
           if (this.pendingUserDecisions.delete(req.id)) {
-            resolve({
+            resolve2({
               requestId: req.id,
               approved: false,
               decidedBy: "USER",
@@ -11112,7 +11791,14 @@ var ToolsConfigSchema = 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: z.array(z.string()).optional()
+  enabledTools: z.array(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: z.array(z.string()).optional()
 });
 var HookDefinitionSchema = z.object({
   name: z.string().optional(),
@@ -11180,6 +11866,14 @@ var BudgetConfigSchema = z.object({
   maxTokensPerRun: z.number().int().positive().default(2e5),
   /** Optional hard per-task cost ceiling (USD). Unset = only the token cap applies. */
   maxCostPerRunUsd: z.number().positive().optional(),
+  /**
+   * Consecutive systemic failures against ONE model before the run stops
+   * launching work that would fail the same way (dead key, wrong model id,
+   * exhausted quota). Lower reacts sooner and wastes less; higher absorbs a
+   * longer transient before giving up. Only failures that will certainly repeat
+   * are counted — see core/run-breaker.ts.
+   */
+  failureThreshold: z.number().int().min(1).max(20).default(3),
   warnAtPct: z.number().default(80)
 });
 var WorkspaceConfigSchema = z.object({
@@ -11467,6 +12161,23 @@ var noopTelemetry = {
   }
 };
 
+// src/core/router/feedback-prior.ts
+var MAX_FEEDBACK_ADJUSTMENT = 0.05;
+var PRIOR_STRENGTH = 10;
+function feedbackAdjustment(counts) {
+  const good = Math.max(0, Math.floor(counts.good));
+  const bad = Math.max(0, Math.floor(counts.bad));
+  const n = good + bad;
+  if (n === 0) return 0;
+  const half = PRIOR_STRENGTH / 2;
+  const shrunk = (good + half) / (n + PRIOR_STRENGTH);
+  return (shrunk - 0.5) * 2 * MAX_FEEDBACK_ADJUSTMENT;
+}
+function applyFeedback(score01, counts) {
+  const adjusted = score01 + feedbackAdjustment(counts);
+  return Math.max(0, Math.min(1, adjusted));
+}
+
 // src/core/router/task-analyzer.ts
 var CODE_SIGNALS = [
   /\b(?:function|class|interface|async|await|import|export|const|let|var|def|return|if|else|for|while|try|catch)\b/,
@@ -11541,6 +12252,8 @@ var TASK_TYPE_TAGS = {
 };
 var TaskAnalyzer = class {
   tracker;
+  /** Per-model thumbs counts, when the host collects them. */
+  feedback;
   bias;
   lastProfile = null;
   lastSelectedModels = /* @__PURE__ */ new Map();
@@ -11548,6 +12261,14 @@ var TaskAnalyzer = class {
     this.tracker = tracker;
     this.bias = bias;
   }
+  /**
+   * Supply per-model rating counts. Optional by design: a host that collects no
+   * feedback (the CLI, a fresh install) scores exactly as it did before, since
+   * feedbackAdjustment returns 0 for an empty record.
+   */
+  setFeedbackSource(source) {
+    this.feedback = source;
+  }
   setTracker(tracker) {
     this.tracker = tracker;
   }
@@ -11631,7 +12352,10 @@ var TaskAnalyzer = class {
     const perf = this.tracker?.performanceScore(model.id, profile.type) ?? 0.5;
     const costEff = this.costEfficiency(model, profile.complexity);
     const match = this.taskMatchScore(model, profile);
-    const benchmark = 0.3 + 0.7 * benchmarkScore01(model, profile.type);
+    const rated = this.feedback?.(model.id);
+    const publicScore = benchmarkScore01(model, profile.type);
+    const adjusted = rated ? applyFeedback(publicScore, rated) : publicScore;
+    const benchmark = 0.3 + 0.7 * adjusted;
     switch (this.bias) {
       case "quality":
         return perf * match * benchmark ** 2 * (0.85 + 0.15 * costEff);
@@ -12033,10 +12757,10 @@ var DynamicTool = class extends BaseTool {
       `;
       const script = await isolate.compileScript(bootstrap);
       const runPromise = script.run(context, { timeout: timeoutMs, promise: true }).then((v) => String(v ?? ""));
-      const timeoutPromise = new Promise((resolve) => {
+      const timeoutPromise = new Promise((resolve2) => {
         const t = setTimeout(() => {
           dispose();
-          resolve(`Dynamic tool "${this.name}" timed out after ${timeoutMs}ms and was terminated.`);
+          resolve2(`Dynamic tool "${this.name}" timed out after ${timeoutMs}ms and was terminated.`);
         }, timeoutMs + 500);
         t.unref?.();
       });
@@ -12054,7 +12778,7 @@ var DynamicTool = class extends BaseTool {
   /** Spawn the worker, service its callTool/fetch bridge, enforce the kill timeout. */
   runInWorker(input, callTool) {
     const timeoutMs = Math.max(200, Number(process.env["CASCADE_DYNAMIC_TOOL_TIMEOUT_MS"]) || DYNAMIC_TOOL_TIMEOUT_MS);
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       let settled = false;
       const worker = new Worker(HARNESS_SRC, {
         eval: true,
@@ -12066,7 +12790,7 @@ var DynamicTool = class extends BaseTool {
         settled = true;
         clearTimeout(timer);
         void worker.terminate();
-        resolve(value);
+        resolve2(value);
       };
       const timer = setTimeout(
         () => finish(`Dynamic tool "${this.name}" timed out after ${timeoutMs}ms and was terminated.`),
@@ -13612,6 +14336,8 @@ ${prompt}`;
 var Cascade = class _Cascade extends EventEmitter {
   router;
   toolRegistry;
+  multimodal;
+  mediaSink;
   mcpClient;
   codeIndex;
   config;
@@ -13650,6 +14376,10 @@ var Cascade = class _Cascade extends EventEmitter {
       }
     });
     this.toolRegistry = new ToolRegistry(this.config.tools, workspacePath);
+    this.multimodal = new MultimodalRegistry(
+      (this.config.providers ?? []).map((p) => p.type)
+    );
+    this.registerMediaTools(workspacePath);
     this.telemetry = config.telemetry?.enabled ? new Telemetry(config.telemetry, config.telemetry.distinctId ?? "anonymous") : noopTelemetry;
     this.worldStateDB = new WorldStateDB(this.workspacePath, this.config.workspace?.debugWorldState ?? false);
     this.router.setWorldStateDB(this.worldStateDB);
@@ -13703,14 +14433,14 @@ var Cascade = class _Cascade extends EventEmitter {
     if (this.listenerCount("mcp:approval-required") === 0) {
       return false;
     }
-    return await new Promise((resolve) => {
-      this.pendingMcpApprovals.set(server.name, resolve);
+    return await new Promise((resolve2) => {
+      this.pendingMcpApprovals.set(server.name, resolve2);
       const timeout = setTimeout(() => {
-        if (this.pendingMcpApprovals.delete(server.name)) resolve(false);
+        if (this.pendingMcpApprovals.delete(server.name)) resolve2(false);
       }, 3e4);
       const wrap = (approved) => {
         clearTimeout(timeout);
-        resolve(approved);
+        resolve2(approved);
       };
       this.pendingMcpApprovals.set(server.name, wrap);
       this.emit("mcp:approval-required", { server });
@@ -13784,17 +14514,17 @@ var Cascade = class _Cascade extends EventEmitter {
     }
     const t2Count = plan.sections.length;
     const t3Count = plan.sections.reduce((sum, s) => sum + (s.t3Subtasks?.length ?? 0), 0);
-    return await new Promise((resolve) => {
+    return await new Promise((resolve2) => {
       const timeout = setTimeout(() => {
         if (this.pendingPlanApproval) {
           this.pendingPlanApproval = void 0;
-          resolve({ approved: true });
+          resolve2({ approved: true });
         }
       }, 12e4);
       this.pendingPlanApproval = (decision) => {
         clearTimeout(timeout);
         this.pendingPlanApproval = void 0;
-        resolve(decision);
+        resolve2(decision);
       };
       this.emit("plan:approval-required", {
         taskId,
@@ -13827,17 +14557,17 @@ var Cascade = class _Cascade extends EventEmitter {
   }
   async requestContextApproval(info) {
     if (this.listenerCount("context:approval-required") === 0) return true;
-    return await new Promise((resolve) => {
+    return await new Promise((resolve2) => {
       const timeout = setTimeout(() => {
         if (this.pendingContextApproval) {
           this.pendingContextApproval = void 0;
-          resolve(true);
+          resolve2(true);
         }
       }, 12e4);
       this.pendingContextApproval = (approved) => {
         clearTimeout(timeout);
         this.pendingContextApproval = void 0;
-        resolve(approved);
+        resolve2(approved);
       };
       this.emit("context:approval-required", info);
     });
@@ -13917,6 +14647,68 @@ ${input}` }],
     if (this.store) t1.setStore(this.store);
     return t1.previewPlan(prompt);
   }
+  /**
+   * Register image / speech / transcription tools for the modalities this
+   * config can actually serve.
+   *
+   * The sink writes bytes into the workspace, because that is what a desktop or
+   * CLI run wants and it keeps a generated asset indistinguishable from any
+   * other file the run produced. A host with different storage (the cloud
+   * 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 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: this.mediaSink ?? (async (asset) => {
+          const fsp = await import('fs/promises');
+          const nodePath = await import('path');
+          const dir = nodePath.join(workspacePath, "generated");
+          await fsp.mkdir(dir, { recursive: true });
+          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');
+        return fsp.readFile(p);
+      }
+    );
+    for (const tool of tools) {
+      if (!permitted(tool.name)) continue;
+      tool.setWorkspaceRoot(workspacePath);
+      this.toolRegistry.register(tool);
+    }
+  }
+  /**
+   * Supply per-model thumbs-up/down counts so Auto routing can weigh how models
+   * have actually performed for this user, on top of public benchmarks.
+   *
+   * Optional everywhere: with no source, or an empty record, scoring is
+   * byte-identical to before. The adjustment is capped and sample-size shrunk —
+   * see core/router/feedback-prior.ts.
+   */
+  setFeedbackSource(source) {
+    this.router.setFeedbackSource(source);
+  }
   /** True when a task stopped at the budget cap and can be resumed via /continue. */
   hasResumableRun() {
     return this.lastInterruptedRun != null;
@@ -14406,7 +15198,7 @@ ${prompt}` : prompt;
     if (toolCreator) toolCreator.setPermissionEscalator(escalator);
     const rootPrompt = buildContextualPrompt(options.prompt, options.conversationHistory);
     let finalOutput = "";
-    const runBreaker = new RunBreaker();
+    const runBreaker = new RunBreaker(this.config.budget?.failureThreshold);
     let t2Results = [];
     let runError = null;
     let identityPrompt = "";
@@ -16579,12 +17371,12 @@ var DashboardServer = class {
         console.warn("\u26A0 Dashboard auth is DISABLED while bound to a non-loopback interface \u2014 this allows unauthenticated remote task execution.");
       }
     }
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const onError = (err) => reject(err);
       this.httpServer.once("error", onError);
       this.httpServer.listen(this.port, this.host, () => {
         this.httpServer.off("error", onError);
-        resolve();
+        resolve2();
       });
     });
     try {
@@ -16608,8 +17400,8 @@ var DashboardServer = class {
     } catch {
     }
     this.globalStore = null;
-    await new Promise((resolve, reject) => {
-      this.httpServer.close((err) => err ? reject(err) : resolve());
+    await new Promise((resolve2, reject) => {
+      this.httpServer.close((err) => err ? reject(err) : resolve2());
     });
   }
   getSocket() {
@@ -16806,8 +17598,8 @@ var DashboardServer = class {
    * timeout denies it.
    */
   makeApprovalCallback(sessionId) {
-    return (request) => new Promise((resolve) => {
-      this.pendingApprovals.set(request.id, { resolve, sessionId });
+    return (request) => new Promise((resolve2) => {
+      this.pendingApprovals.set(request.id, { resolve: resolve2, sessionId });
     });
   }
   /**
@@ -17907,7 +18699,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;
@@ -18118,9 +18910,9 @@ var CloudClient = class _CloudClient {
     this.store.clear();
   }
 };
-function sleep(ms, signal) {
-  return new Promise((resolve, reject) => {
-    const t = setTimeout(resolve, ms);
+function sleep2(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    const t = setTimeout(resolve2, ms);
     signal?.addEventListener("abort", () => {
       clearTimeout(t);
       reject(new Error("aborted"));