cascade-ai 0.72.0 → 0.74.0

package/dist/index.js

@@ -1746,6 +1746,15 @@ function findPricing(modelId, provider, opts = {}) {
   }
   return null;
 }
+function hasContextBands(model) {
+  if (model.isLocal) return false;
+  const fallbackProviders = model.provider === "azure" ? ["openai"] : model.provider === "gemini" ? ["vertex"] : [];
+  const match = findPricing(model.id, model.provider, {
+    baseModelId: model.baseModelId,
+    fallbackProviders
+  });
+  return (match?.entry.tiers?.length ?? 0) > 1;
+}
 function tierFor(entry, inputTokens = 0) {
   const tiers = entry.tiers;
   if (!tiers?.length) return null;
@@ -1862,7 +1871,7 @@ function reconcilePrice(model, live) {
 }
 
 // src/constants.ts
-var CASCADE_VERSION = "0.72.0";
+var CASCADE_VERSION = "0.74.0";
 var CASCADE_CONFIG_DIR = ".cascade";
 var CASCADE_MD_FILE = "CASCADE.md";
 var CASCADE_IGNORE_FILE = ".cascadeignore";
@@ -2307,8 +2316,23 @@ var PROVIDER_DISPLAY_NAMES = {
 };
 
 // src/utils/cost.ts
-function resolveModelPricing(model) {
+function resolveModelPricing(model, opts = {}) {
   if (model.isLocal) return { input: 0, output: 0, unknown: false };
+  if (opts.inputTokens != null && hasContextBands(model)) {
+    const banded = resolvePricing(model, { inputTokens: opts.inputTokens });
+    const base = resolvePricing(model, { inputTokens: 0 });
+    if (!banded.unknown && !base.unknown) {
+      const scale = (stamped, baseRate) => stamped > 0 && baseRate > 0 ? stamped / baseRate : 1;
+      const inScale = scale(model.inputCostPer1kTokens, base.input);
+      const outScale = scale(model.outputCostPer1kTokens, base.output);
+      return {
+        input: banded.input * inScale,
+        output: banded.output * outScale,
+        unknown: false,
+        ...banded.estimatedFromProvider ? { estimatedFromProvider: banded.estimatedFromProvider } : {}
+      };
+    }
+  }
   if (model.inputCostPer1kTokens > 0 || model.outputCostPer1kTokens > 0) {
     return {
       input: model.inputCostPer1kTokens,
@@ -2316,7 +2340,7 @@ function resolveModelPricing(model) {
       unknown: false
     };
   }
-  const fromDataset = resolvePricing(model);
+  const fromDataset = resolvePricing(model, { inputTokens: opts.inputTokens });
   if (!fromDataset.unknown) {
     return {
       input: fromDataset.input,
@@ -2338,11 +2362,11 @@ function resolveModelPricing(model) {
   return { input: 0, output: 0, unknown: true };
 }
 function calculateCost(inputTokens, outputTokens, model) {
-  const { input, output } = resolveModelPricing(model);
+  const { input, output } = resolveModelPricing(model, { inputTokens });
   return inputTokens / 1e3 * input + outputTokens / 1e3 * output;
 }
 function buildTokenUsage(inputTokens, outputTokens, model) {
-  const { input, output, unknown } = resolveModelPricing(model);
+  const { input, output, unknown } = resolveModelPricing(model, { inputTokens });
   return {
     inputTokens,
     outputTokens,
@@ -2353,6 +2377,13 @@ function buildTokenUsage(inputTokens, outputTokens, model) {
 }
 
 // src/providers/base.ts
+var ProviderUnreachableError = class extends Error {
+  transient = true;
+  constructor(message) {
+    super(message);
+    this.name = "ProviderUnreachableError";
+  }
+};
 var BaseProvider = class {
   config;
   model;
@@ -2421,6 +2452,21 @@ function anthropicThinkingParam(modelId, maxTokens) {
   if (budget < 1024) return {};
   return { thinking: { type: "enabled", budget_tokens: budget } };
 }
+function toAnthropicTools(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.inputSchema
+  }));
+}
+function toAnthropicToolUse(toolCalls) {
+  return toolCalls.map((tc) => ({
+    type: "tool_use",
+    id: tc.id,
+    name: tc.name,
+    input: tc.input
+  }));
+}
 var AnthropicProvider = class extends BaseProvider {
   client;
   constructor(config, model) {
@@ -2442,11 +2488,7 @@ var AnthropicProvider = class extends BaseProvider {
   }
   async generateStream(options, onChunk) {
     const messages = this.convertMessages(options.messages);
-    const tools = options.tools?.map((t) => ({
-      name: t.name,
-      description: t.description,
-      input_schema: t.inputSchema
-    }));
+    const tools = options.tools && toAnthropicTools(options.tools);
     let fullContent = "";
     let inputTokens = 0;
     let outputTokens = 0;
@@ -2574,14 +2616,7 @@ var AnthropicProvider = class extends BaseProvider {
         const content = [];
         const text = typeof m.content === "string" ? m.content : "";
         if (text) content.push({ type: "text", text });
-        for (const tc of m.toolCalls ?? []) {
-          content.push({
-            type: "tool_use",
-            id: tc.id,
-            name: tc.name,
-            input: tc.input
-          });
-        }
+        content.push(...toAnthropicToolUse(m.toolCalls ?? []));
         if (content.length > 0) {
           result.push({ role: "assistant", content });
         }
@@ -2621,6 +2656,26 @@ function isParamShapeError(err) {
   const msg = String(e?.message ?? e?.error?.message ?? "").toLowerCase();
   return msg.includes("max_completion_tokens") || msg.includes("max_tokens") && (msg.includes("unsupported") || msg.includes("not supported") || msg.includes("use")) || msg.includes("temperature") && (msg.includes("unsupported") || msg.includes("does not support") || msg.includes("only the default"));
 }
+function toOpenAITools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.inputSchema
+    }
+  }));
+}
+function toOpenAIToolCalls(toolCalls) {
+  return toolCalls.map((tc) => ({
+    id: tc.id,
+    type: "function",
+    function: {
+      name: tc.name,
+      arguments: JSON.stringify(tc.input)
+    }
+  }));
+}
 var OpenAIProvider = class extends BaseProvider {
   client;
   /** Once we learn (from the model id or an API error) that this deployment
@@ -2640,14 +2695,7 @@ var OpenAIProvider = class extends BaseProvider {
   }
   async generateStream(options, onChunk) {
     const messages = this.convertMessages(options.messages, options.systemPrompt);
-    const tools = options.tools?.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.inputSchema
-      }
-    }));
+    const tools = options.tools && toOpenAITools(options.tools);
     let fullContent = "";
     let inputTokens = 0;
     let outputTokens = 0;
@@ -2793,14 +2841,7 @@ var OpenAIProvider = class extends BaseProvider {
           result.push({
             role: "assistant",
             content: m.content || "",
-            tool_calls: m.toolCalls.map((toolCall) => ({
-              id: toolCall.id,
-              type: "function",
-              function: {
-                name: toolCall.name,
-                arguments: JSON.stringify(toolCall.input)
-              }
-            }))
+            tool_calls: toOpenAIToolCalls(m.toolCalls)
           });
         } else {
           result.push({ role: m.role, content: m.content });
@@ -3043,6 +3084,38 @@ function toGeminiParameters(inputSchema) {
 }
 
 // src/providers/gemini.ts
+function toGeminiTools(tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    // 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)
+  }));
+}
+function toGeminiFunctionCalls(toolCalls) {
+  return toolCalls.map((tc) => ({
+    functionCall: {
+      name: tc.name,
+      args: tc.input
+    }
+  }));
+}
+function isGeminiAuthStatus(status) {
+  return status === 400 || status === 401 || status === 403;
+}
+async function describeGeminiError(resp) {
+  try {
+    const body = await resp.json();
+    const detail = body?.error?.message ?? body?.error?.status;
+    return detail ? ` \u2014 ${detail}` : "";
+  } catch {
+    return "";
+  }
+}
 var GeminiProvider = class extends BaseProvider {
   client;
   constructor(config, model) {
@@ -3064,7 +3137,7 @@ var GeminiProvider = class extends BaseProvider {
           { category: HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: HarmBlockThreshold.BLOCK_NONE },
           { category: HarmCategory.HARM_CATEGORY_HATE_SPEECH, threshold: HarmBlockThreshold.BLOCK_NONE }
         ],
-        tools: options.tools?.length ? [{ functionDeclarations: options.tools.map(this.convertTool) }] : void 0,
+        tools: options.tools?.length ? [{ functionDeclarations: toGeminiTools(options.tools) }] : void 0,
         abortSignal: options.signal
       }
     });
@@ -3126,9 +3199,7 @@ var GeminiProvider = class extends BaseProvider {
   }
   async listModels() {
     try {
-      const resp = await fetch(
-        `https://generativelanguage.googleapis.com/v1beta/models?key=${this.config.apiKey}`
-      );
+      const resp = await this.fetchModelList();
       if (!resp.ok) {
         return Object.values(MODELS).filter((m) => m.provider === "gemini");
       }
@@ -3159,18 +3230,61 @@ var GeminiProvider = class extends BaseProvider {
       return Object.values(MODELS).filter((m) => m.provider === "gemini");
     }
   }
+  /**
+   * Is this KEY usable — not "does one particular model answer".
+   *
+   * This used to call countTokens() against `this.model.id`, which the router
+   * fills from the first Gemini entry in the bundled catalogue. That made the
+   * whole provider's fate depend on one hard-coded model id: a key that cannot
+   * reach that one model — retired, not enabled for the key's project, served
+   * on a different API version — failed the probe, and because every later step
+   * is gated on the result (`validateCloudProviderModels` and
+   * `discoverProviderModels` both return early for an unavailable provider) the
+   * real model list was never fetched. Gemini vanished entirely, and the CLI
+   * reported "add a provider API key first" about a key that was present and
+   * working.
+   *
+   * Listing models asks the account-level question instead, the same one
+   * OpenAI's probe asks, and it is the same request `listModels()` already
+   * makes for discovery.
+   *
+   * Throws rather than returning false. The router logs the reason it catches,
+   * and "bad key, wrong endpoint/deployment, or unreachable" — three guesses,
+   * no answer — is what made this take a user report to find. A swallowed probe
+   * error is the same defect that once hid a misconfigured Azure deployment.
+   */
   async isAvailable() {
+    if (!this.config.apiKey) throw new Error("no Gemini API key configured");
+    let resp;
     try {
-      await this.client.models.countTokens({
-        model: this.model.id,
-        contents: [{ role: "user", parts: [{ text: "ping" }] }]
-      });
-      return true;
-    } catch {
-      return false;
+      resp = await this.fetchModelList();
+    } catch (err) {
+      throw new ProviderUnreachableError(
+        `could not reach the Gemini API: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (resp.ok) return true;
+    const status = `HTTP ${resp.status} ${resp.statusText}`.trim();
+    const detail = await describeGeminiError(resp);
+    if (isGeminiAuthStatus(resp.status)) {
+      throw new Error(`Gemini rejected the API key: ${status}${detail}`);
     }
+    throw new ProviderUnreachableError(`Gemini model list failed: ${status}${detail}`);
   }
   // ── Private ──────────────────────────────────
+  /**
+   * The account's model list. One place so the availability probe and
+   * discovery cannot ask different questions of the same endpoint.
+   *
+   * The key goes in a header, not the query string: a URL carries into proxy
+   * logs, error reports and shell history, and this one would carry the key
+   * with it.
+   */
+  fetchModelList() {
+    return fetch("https://generativelanguage.googleapis.com/v1beta/models", {
+      headers: { "x-goog-api-key": this.config.apiKey ?? "" }
+    });
+  }
   buildContents(messages, extraImages) {
     const contents = [];
     for (const m of messages) {
@@ -3205,14 +3319,7 @@ var GeminiProvider = class extends BaseProvider {
         const parts = [];
         const textContent = typeof m.content === "string" ? m.content : "";
         if (textContent) parts.push({ text: textContent });
-        for (const tc of m.toolCalls ?? []) {
-          parts.push({
-            functionCall: {
-              name: tc.name,
-              args: tc.input
-            }
-          });
-        }
+        parts.push(...toGeminiFunctionCalls(m.toolCalls ?? []));
         if (parts.length > 0) {
           contents.push({ role: "model", parts });
         }
@@ -3259,18 +3366,6 @@ var GeminiProvider = class extends BaseProvider {
     }
     return parts;
   }
-  convertTool(tool) {
-    return {
-      name: tool.name,
-      description: tool.description,
-      // 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)
-    };
-  }
 };
 try {
   dns.setDefaultResultOrder("ipv4first");
@@ -3363,6 +3458,24 @@ function isToolCapable(modelName) {
   const name = modelName.toLowerCase();
   return TOOL_CAPABLE_FAMILIES.some((family) => name.includes(family));
 }
+function toOllamaTools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.inputSchema
+    }
+  }));
+}
+function toOllamaToolCalls(toolCalls) {
+  return toolCalls.map((tc) => ({
+    function: {
+      name: tc.name,
+      arguments: tc.input
+    }
+  }));
+}
 var OllamaProvider = class extends BaseProvider {
   baseUrl;
   constructor(config, model) {
@@ -3375,14 +3488,7 @@ var OllamaProvider = class extends BaseProvider {
   }
   async generateStream(options, onChunk) {
     const messages = this.convertMessages(options.messages, options.systemPrompt);
-    const ollamaTools = options.tools?.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.inputSchema
-      }
-    }));
+    const ollamaTools = options.tools && toOllamaTools(options.tools);
     const response = await fetch(`${this.baseUrl}/api/chat`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -3562,12 +3668,7 @@ var OllamaProvider = class extends BaseProvider {
         result.push({
           role: "assistant",
           content: typeof m.content === "string" ? m.content : "",
-          tool_calls: m.toolCalls.map((tc) => ({
-            function: {
-              name: tc.name,
-              arguments: tc.input
-            }
-          }))
+          tool_calls: toOllamaToolCalls(m.toolCalls)
         });
         continue;
       }
@@ -3968,6 +4069,21 @@ var DEFAULT_PROVIDER_TPM = {
   "openai-compatible": 3e4,
   ollama: Number.POSITIVE_INFINITY
 };
+function abortReason(signal) {
+  return signal.reason instanceof Error ? signal.reason : new Error("Aborted while waiting for rate-limit capacity");
+}
+function sleepUnlessAborted(ms, signal) {
+  if (!signal) return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve2) => {
+    const done = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve2();
+    };
+    const timer = setTimeout(done, ms);
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
 var TpmLimiter = class {
   buckets = /* @__PURE__ */ new Map();
   constructor(overrides = {}) {
@@ -3986,9 +4102,10 @@ var TpmLimiter = class {
    * are reported back via `refund` when short, or simply settled at the next
    * refill.
    */
-  async acquire(provider, estimatedTokens) {
+  async acquire(provider, estimatedTokens, signal) {
     const bucket = this.buckets.get(provider);
     if (!bucket || bucket.tokensPerMinute === Number.POSITIVE_INFINITY) return;
+    if (signal?.aborted) throw abortReason(signal);
     const want = Math.min(estimatedTokens, bucket.tokensPerMinute);
     for (; ; ) {
       this.refill(bucket);
@@ -3998,7 +4115,8 @@ var TpmLimiter = class {
       }
       const deficit = want - bucket.available;
       const waitMs = Math.max(50, Math.ceil(deficit / bucket.tokensPerMinute * 6e4));
-      await new Promise((resolve2) => setTimeout(resolve2, waitMs));
+      await sleepUnlessAborted(waitMs, signal);
+      if (signal?.aborted) throw abortReason(signal);
     }
   }
   /**
@@ -4044,6 +4162,9 @@ var TpmLimiter = class {
 };
 
 // src/core/router/local-queue.ts
+function abortReason2(signal) {
+  return signal.reason instanceof Error ? signal.reason : new Error("Aborted while waiting for a local inference slot");
+}
 var LocalRequestQueue = class {
   maxConcurrent;
   active = 0;
@@ -4054,9 +4175,16 @@ var LocalRequestQueue = class {
   /**
    * Acquire a queue slot. Returns a `release` function that MUST be called
    * when the inference call is done (even on error). Rejects if the slot
-   * cannot be acquired within `timeoutMs`.
+   * cannot be acquired within `timeoutMs`, or as soon as `signal` fires.
+   *
+   * The signal matters as much as the timeout: with concurrency of 1 a caller
+   * can sit here for half the inference timeout — 150 seconds by default —
+   * and until it was wired up, neither cancelling the run nor spending its
+   * budget got it out. It waited out the window for a slot it would drop the
+   * moment it received one.
    */
-  async acquire(timeoutMs) {
+  async acquire(timeoutMs, signal) {
+    if (signal?.aborted) throw abortReason2(signal);
     if (this.active < this.maxConcurrent) {
       this.active++;
       return this.makeRelease();
@@ -4064,23 +4192,36 @@ var LocalRequestQueue = class {
     return new Promise((resolve2, reject) => {
       let settled = false;
       let timer;
+      const cleanup = () => {
+        if (timer !== void 0) clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+      };
       const resolver = (release) => {
         if (settled) return;
         settled = true;
-        if (timer !== void 0) clearTimeout(timer);
+        cleanup();
         resolve2(release);
       };
+      const abandon = () => {
+        if (settled) return false;
+        settled = true;
+        cleanup();
+        const idx = this.queue.indexOf(resolver);
+        if (idx !== -1) this.queue.splice(idx, 1);
+        return true;
+      };
+      function onAbort() {
+        if (abandon()) reject(abortReason2(signal));
+      }
       if (timeoutMs !== void 0 && timeoutMs > 0) {
         timer = setTimeout(() => {
-          if (settled) return;
-          settled = true;
-          const idx = this.queue.indexOf(resolver);
-          if (idx !== -1) this.queue.splice(idx, 1);
+          if (!abandon()) return;
           reject(new Error(
             `Local model queue: timed out waiting for a free slot after ${timeoutMs}ms. Active: ${this.active}, Queued: ${this.queue.length}. Consider increasing localConcurrency or localInferenceTimeoutMs in your config.`
           ));
         }, timeoutMs);
       }
+      signal?.addEventListener("abort", onAbort, { once: true });
       this.queue.push(resolver);
     });
   }
@@ -4217,6 +4358,116 @@ function fileDeadModelPersistence(filePath) {
   };
 }
 
+// src/core/context/compaction.ts
+var CHARS_PER_TOKEN = 4;
+function estimateTokens(text) {
+  if (!text) return 0;
+  return Math.max(1, Math.ceil(text.length / CHARS_PER_TOKEN));
+}
+function contentToText(content) {
+  if (typeof content === "string") return content;
+  return content.map((c) => c.type === "text" ? c.text : c.type === "tool_result" ? c.content : `[${c.type}]`).join(" ");
+}
+function messagesTokens(messages) {
+  return messages.reduce((n, m) => n + estimateTokens(contentToText(m.content)), 0);
+}
+function atomize(text, maxChars) {
+  const seps = ["\n\n", "\n", ". ", " "];
+  let units = [text];
+  for (const sep of seps) {
+    if (units.every((u) => u.length <= maxChars)) break;
+    const next = [];
+    for (const u of units) {
+      if (u.length <= maxChars) {
+        next.push(u);
+        continue;
+      }
+      const parts = u.split(sep);
+      parts.forEach((p, i) => next.push(i < parts.length - 1 ? p + sep : p));
+    }
+    units = next;
+  }
+  const out = [];
+  for (const u of units) {
+    if (u.length <= maxChars) out.push(u);
+    else for (let i = 0; i < u.length; i += maxChars) out.push(u.slice(i, i + maxChars));
+  }
+  return out;
+}
+function chunkText(text, opts) {
+  const maxChars = Math.max(1, Math.floor(opts.maxTokens * 4));
+  const overlap = Math.min(maxChars - 1, Math.max(0, Math.floor(maxChars * (opts.overlapRatio ?? 0.1))));
+  const trimmed = text.trim();
+  if (!trimmed) return [];
+  if (trimmed.length <= maxChars) return [trimmed];
+  const units = atomize(trimmed, maxChars);
+  const chunks = [];
+  let cur = "";
+  for (const u of units) {
+    if (cur && cur.length + u.length > maxChars) {
+      chunks.push(cur.trim());
+      cur = overlap > 0 ? cur.slice(-overlap) : "";
+    }
+    cur += u;
+  }
+  if (cur.trim()) chunks.push(cur.trim());
+  return chunks;
+}
+function needsCompaction(totalTokens, contextWindow, reserve = 0.2) {
+  if (!contextWindow || contextWindow <= 0) return false;
+  return totalTokens > contextWindow * (1 - reserve);
+}
+async function mapReduceCompact(text, opts) {
+  const capChars = opts.capTokens * 4;
+  let working = text;
+  let truncated = false;
+  if (working.length > capChars) {
+    working = working.slice(0, capChars);
+    truncated = true;
+  }
+  const instruction = opts.instruction ?? "Summarize this content, preserving key facts, names, numbers, and decisions.";
+  let chunks = chunkText(working, { maxTokens: opts.chunkTokens });
+  if (chunks.length <= 1) return { text: working, chunks: chunks.length, calls: 0, truncated };
+  let calls = 0;
+  let parts = await Promise.all(
+    chunks.map((c, i) => {
+      calls++;
+      return opts.summarize(c, `${instruction} (part ${i + 1} of ${chunks.length})`);
+    })
+  );
+  let combined = parts.join("\n\n");
+  const maxPasses = opts.maxReducePasses ?? 3;
+  for (let pass = 0; pass < maxPasses && estimateTokens(combined) > opts.targetTokens; pass++) {
+    const groups = chunkText(combined, { maxTokens: opts.chunkTokens });
+    if (groups.length <= 1) break;
+    parts = await Promise.all(
+      groups.map((g) => {
+        calls++;
+        return opts.summarize(g, "Merge these partial summaries into one cohesive summary; keep all distinct facts.");
+      })
+    );
+    combined = parts.join("\n\n");
+  }
+  const note = truncated ? "\n\n[Note: input exceeded the extended-context cap and was truncated.]" : "";
+  return { text: combined + note, chunks: chunks.length, calls, truncated };
+}
+async function rollingSummary(messages, opts) {
+  if (messages.length <= opts.keepRecent) return messages;
+  const older = messages.slice(0, messages.length - opts.keepRecent);
+  const recent = messages.slice(messages.length - opts.keepRecent);
+  const transcript = older.map((m) => `${m.role}: ${contentToText(m.content)}`).join("\n");
+  const summary = await opts.summarize(
+    transcript,
+    "Summarize this earlier conversation. Preserve facts, decisions, names, numbers, and any open threads or todos."
+  );
+  const summaryMessage = {
+    role: "system",
+    content: `Summary of earlier conversation (folded to fit the context window):
+${summary}`
+  };
+  return [summaryMessage, ...recent];
+}
+
 // src/utils/retry.ts
 var CascadeCancelledError = class extends Error {
   constructor(reason) {
@@ -4251,6 +4502,158 @@ async function withTimeout(promise, timeoutMs, errorMessage = "Operation timed o
     if (timer !== void 0) clearTimeout(timer);
   }
 }
+async function withTimeoutAbort(run, timeoutMs, errorMessage = "Operation timed out", outer) {
+  const outers = (Array.isArray(outer) ? outer : [outer]).filter((sig) => sig !== void 0);
+  const controller = new AbortController();
+  let timer;
+  let rejectRace;
+  const settle = (reason) => {
+    rejectRace?.(reason);
+    controller.abort(reason);
+  };
+  const abortOuter = () => {
+    const fired = outers.find((sig) => sig.aborted);
+    settle(fired?.reason instanceof Error ? fired.reason : new CascadeCancelledError("Run cancelled"));
+  };
+  const failPromise = new Promise((_, reject) => {
+    rejectRace = reject;
+    timer = setTimeout(() => settle(new Error(errorMessage)), timeoutMs);
+  });
+  try {
+    if (outers.some((sig) => sig.aborted)) {
+      abortOuter();
+      return await failPromise;
+    }
+    for (const sig of outers) sig.addEventListener("abort", abortOuter, { once: true });
+    return await Promise.race([run(controller.signal), failPromise]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+    for (const sig of outers) sig.removeEventListener("abort", abortOuter);
+  }
+}
+function anySignal(sources) {
+  const live = sources.filter((s) => s !== void 0);
+  if (live.length === 0) return { release: () => {
+  } };
+  if (live.length === 1) return { signal: live[0], release: () => {
+  } };
+  const controller = new AbortController();
+  function detach() {
+    for (const s of live) s.removeEventListener("abort", onAbort);
+  }
+  function onAbort() {
+    const fired = live.find((s) => s.aborted);
+    controller.abort(fired?.reason instanceof Error ? fired.reason : new CascadeCancelledError("Run cancelled"));
+    detach();
+  }
+  if (live.some((s) => s.aborted)) {
+    onAbort();
+    return { signal: controller.signal, release: detach };
+  }
+  for (const s of live) s.addEventListener("abort", onAbort, { once: true });
+  return { signal: controller.signal, release: detach };
+}
+
+// src/core/router/wire-profile.ts
+var textAndImageOnly = (block) => block.type === "text" || block.type === "image";
+var ANTHROPIC = {
+  // convertMessages: `if (m.role === 'system') continue` — history system
+  // messages are skipped outright; only options.systemPrompt goes as system
+  // input. Compaction emits exactly such a message, holding a summary of the
+  // whole conversation, so charging it refused runs over input never sent.
+  dropsMessage: (m) => m.role === "system",
+  blockHandling: (m) => {
+    if (m.role === "tool") return "stringified";
+    if (m.role === "assistant") return "dropped";
+    return "blocks";
+  },
+  sendsToolCalls: (m) => m.role === "assistant",
+  sendsBlock: textAndImageOnly,
+  sendsToolCallId: true,
+  sizeToolCalls: toAnthropicToolUse,
+  sendsUrlImages: true,
+  readsTopLevelImages: false,
+  sizeTools: toAnthropicTools
+};
+var GEMINI = {
+  // buildContents folds a system message into the next user turn, but only
+  // when it has text: array content collapses to '' and the message is
+  // skipped, as is a whitespace-only string.
+  dropsMessage: (m) => m.role === "system" && !(typeof m.content === "string" ? m.content : "").trim(),
+  blockHandling: (m) => {
+    if (m.role === "tool") return "stringified";
+    if (m.role === "assistant" || m.role === "system") return "dropped";
+    return "blocks";
+  },
+  sendsToolCalls: (m) => m.role === "assistant",
+  sendsBlock: textAndImageOnly,
+  sendsToolCallId: true,
+  sizeToolCalls: toGeminiFunctionCalls,
+  sendsUrlImages: false,
+  readsTopLevelImages: true,
+  sizeTools: toGeminiTools
+};
+var OPENAI = {
+  dropsMessage: () => false,
+  blockHandling: (m) => {
+    if (m.role === "system" || m.role === "tool") return "dropped";
+    return "blocks";
+  },
+  // The tool_calls branch is inside `if (typeof m.content === 'string')`; an
+  // assistant turn with array content falls through to the parts branch and
+  // its tool calls are never attached.
+  sendsToolCalls: (m) => m.role === "assistant" && typeof m.content === "string",
+  sendsBlock: textAndImageOnly,
+  sendsToolCallId: true,
+  sizeToolCalls: toOpenAIToolCalls,
+  sendsUrlImages: true,
+  readsTopLevelImages: false,
+  sizeTools: toOpenAITools
+};
+var OLLAMA = {
+  dropsMessage: () => false,
+  blockHandling: (m) => {
+    if (m.role === "system") return "dropped";
+    if (m.role === "tool") return "stringified";
+    if (m.role === "assistant" && m.toolCalls?.length) return "dropped";
+    return "blocks";
+  },
+  sendsToolCalls: (m) => m.role === "assistant",
+  // The image split maps `b.image.data` with no check on `type`, so a URL is
+  // submitted too (as a URL string in the `images` array).
+  sendsBlock: textAndImageOnly,
+  sendsToolCallId: false,
+  sizeToolCalls: toOllamaToolCalls,
+  sendsUrlImages: true,
+  readsTopLevelImages: false,
+  sizeTools: toOllamaTools
+};
+var PROFILES = {
+  anthropic: ANTHROPIC,
+  gemini: GEMINI,
+  openai: OPENAI,
+  // AzureOpenAIProvider and OpenAICompatibleProvider both extend OpenAIProvider
+  // and neither overrides convertMessages.
+  azure: OPENAI,
+  "openai-compatible": OPENAI,
+  ollama: OLLAMA
+};
+function wireProfile(provider) {
+  return PROFILES[provider] ?? OPENAI;
+}
+function geminiImageCopies(messages) {
+  for (const m of messages) {
+    if (m.role === "user") {
+      const laterUserTurn = messages.slice(messages.indexOf(m) + 1).some((x) => x.role === "user");
+      return laterUserTurn ? 2 : 1;
+    }
+    const text = typeof m.content === "string" ? m.content : "";
+    if (m.role === "system" && text.trim()) return 1;
+    if (m.role === "tool") return 1;
+    if (m.role === "assistant" && (text || m.toolCalls?.length)) return 1;
+  }
+  return 1;
+}
 
 // src/core/router/model-profiler.ts
 var SKIP_PATTERN = /embed|dall-e|whisper|tts|vision|instruct-vision|rerank/i;
@@ -4755,6 +5158,36 @@ function azureModelForTier(tier, ranked) {
   if (tier === "T3") return ranked[ranked.length - 1];
   return ranked[Math.min(1, ranked.length - 1)];
 }
+var IMAGE_TOKENS_MAX = 2e3;
+var IMAGE_TOKENS_EACH = IMAGE_TOKENS_MAX;
+function safeJson(value) {
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+function newRunAbort() {
+  const controller = new AbortController();
+  setMaxListeners(64, controller.signal);
+  return controller;
+}
+var TOKENS_PER_MESSAGE_FRAMING = 4;
+function guardTokens(text) {
+  if (!text) return 0;
+  let asciiChars = 0;
+  let denseBytes = 0;
+  for (const ch of text) {
+    const cp = ch.codePointAt(0);
+    if (cp <= 127) {
+      asciiChars++;
+      continue;
+    }
+    denseBytes += cp <= 2047 ? 2 : cp <= 65535 ? 3 : 4;
+  }
+  if (denseBytes === 0) return estimateTokens(text);
+  return Math.ceil(asciiChars / CHARS_PER_TOKEN) + denseBytes;
+}
 var DISCOVERY_TTL_MS = 15 * 60 * 1e3;
 var DISCOVERY_TIMEOUT_MS = 4e3;
 var cloudDiscoveryCache = /* @__PURE__ */ new Map();
@@ -4807,6 +5240,33 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
   // start of every `cascade run`, independent of the session-wide budget.
   runTokens = 0;
   runCostUsd = 0;
+  /**
+   * Budget held for calls that are IN FLIGHT — admitted by the preflight check
+   * but not yet counted by recordStats. Without these, concurrent calls all
+   * measure themselves against the same unspent allowance and are all admitted.
+   * Released when each call settles; reset by beginRun() alongside the totals.
+   */
+  reservedTokens = 0;
+  reservedCostUsd = 0;
+  /**
+   * Fires when this run's budget is spent, cancelling work already in flight.
+   *
+   * The kill switch was previously only a flag, which stops calls that have
+   * not yet submitted. A parallel wave's earlier members are already at the
+   * provider by then, and they carried on generating for a run whose output
+   * would be discarded. Every provider call chains to this, so tripping the
+   * ceiling reaches the requests that are running, not just the ones queued.
+   */
+  runAbort = newRunAbort();
+  /**
+   * Bumped by every beginRun(). A release handle remembers the generation it
+   * was issued in and does nothing if that has moved on: beginRun() zeroes the
+   * counters, so a call still in flight from the previous run would otherwise
+   * subtract its estimate from the NEW run's totals and drive them negative —
+   * leaving later preflights believing there is more allowance than the cap
+   * actually holds, which is worse than no gate at all.
+   */
+  runGeneration = 0;
   runBudgetExceeded = false;
   runBudgetExceededReason;
   /**
@@ -4976,7 +5436,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     try {
       const cfg = this.config.providers.find((p) => p.type === model.provider) ?? { type: model.provider };
       const provider = this.createProvider(cfg, model);
-      const result = await withTimeout(provider.generate({
+      const result = await withTimeoutAbort((signal) => provider.generate({
         messages: [{ role: "user", content: "Call the echo tool with text set to 'ping'. Use the tool; do not answer in prose." }],
         tools: [{
           name: "echo",
@@ -4984,7 +5444,8 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
           inputSchema: { type: "object", properties: { text: { type: "string", description: "Text to echo" } }, required: ["text"] }
         }],
         maxTokens: 80,
-        temperature: 0
+        temperature: 0,
+        signal
       }), 3e4, "tool-support probe timed out");
       return (result.toolCalls?.length ?? 0) > 0;
     } catch {
@@ -5105,9 +5566,12 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
         this.runBudgetExceededReason ?? "Per-task budget exceeded."
       );
     }
+    const runGeneration = this.runGeneration;
+    const runAbort = this.runAbort;
+    const runSignal = this.runSignal;
     options = applyTierLimits(options, tier, this.config?.tierLimits);
-    if (this.runSignal && !options.signal) {
-      options = { ...options, signal: this.runSignal };
+    if (runSignal && !options.signal) {
+      options = { ...options, signal: runSignal };
     }
     if (options.model && !requireVision) {
       this.ensureProvider(options.model, this.config.providers);
@@ -5129,58 +5593,84 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     if (!model) throw new Error(`No model available for tier ${tier}`);
     const provider = this.getProvider(model);
     if (!provider) throw new Error(`No provider for model ${model.id}`);
+    let releaseReservation = this.enforcePreflightBudget(model, options);
     const requestedTokens = options.maxTokens ?? model.maxOutputTokens ?? 1024;
     const estimatedTokens = Math.min(requestedTokens, model.maxOutputTokens ?? requestedTokens) + 512;
     if (this.tpmLimiter) {
-      await this.tpmLimiter.acquire(model.provider, estimatedTokens);
+      const wait = anySignal([options.signal, runAbort.signal]);
+      try {
+        await this.tpmLimiter.acquire(model.provider, estimatedTokens, wait.signal);
+      } catch (err) {
+        releaseReservation?.();
+        throw this.asAbortFailure(err, options.signal, runSignal);
+      } finally {
+        wait.release();
+      }
     }
     const useStream = Boolean(onChunk) && model.supportsStreaming && typeof provider.generateStream === "function";
     let releaseLocalSlot;
     if (model.isLocal) {
       const inferenceTimeoutMs = this.config.localInferenceTimeoutMs ?? 3e5;
       const queueWaitMs = Math.round(inferenceTimeoutMs / 2);
-      releaseLocalSlot = await this.localQueue.acquire(queueWaitMs);
+      const wait = anySignal([options.signal, runAbort.signal]);
+      try {
+        releaseLocalSlot = await this.localQueue.acquire(queueWaitMs, wait.signal);
+      } catch (err) {
+        releaseReservation?.();
+        throw this.asAbortFailure(err, options.signal, runSignal);
+      } finally {
+        wait.release();
+      }
     }
     try {
+      if (runGeneration === this.runGeneration && this.runBudgetExceeded) {
+        this.tpmLimiter?.refund(model.provider, estimatedTokens);
+        throw new _CascadeRouter.BudgetExceededError(
+          this.runBudgetExceededReason ?? "Per-task budget exceeded."
+        );
+      }
       let result;
       if (model.isLocal) {
         const inferenceTimeoutMs = this.config.localInferenceTimeoutMs ?? 3e5;
-        const inferencePromise = useStream && onChunk ? provider.generateStream(options, (chunk) => {
-          const text = typeof chunk?.text === "string" ? chunk.text : "";
-          if (text) onChunk({ ...chunk, text });
-        }) : provider.generate(options);
-        result = await withTimeout(
-          inferencePromise,
+        result = await withTimeoutAbort(
+          (signal) => useStream && onChunk ? provider.generateStream({ ...options, signal }, (chunk) => {
+            const text = typeof chunk?.text === "string" ? chunk.text : "";
+            if (text) onChunk({ ...chunk, text });
+          }) : provider.generate({ ...options, signal }),
           inferenceTimeoutMs,
-          `Local model ${model.id} inference timed out after ${inferenceTimeoutMs}ms`
+          `Local model ${model.id} inference timed out after ${inferenceTimeoutMs}ms`,
+          [options.signal, runAbort.signal]
         );
       } else if (useStream && onChunk) {
         const cloudTimeoutMs = this.config.cloudInferenceTimeoutMs ?? 12e4;
         try {
-          result = await withTimeout(
-            provider.generateStream(options, (chunk) => {
+          result = await withTimeoutAbort(
+            (signal) => provider.generateStream({ ...options, signal }, (chunk) => {
               const text = typeof chunk?.text === "string" ? chunk.text : "";
               if (text) onChunk({ ...chunk, text });
             }),
             cloudTimeoutMs,
-            `Model ${model.id} stream timed out after ${cloudTimeoutMs}ms`
+            `Model ${model.id} stream timed out after ${cloudTimeoutMs}ms`,
+            [options.signal, runAbort.signal]
           );
         } catch (streamErr) {
-          if (streamErr instanceof Error && streamErr.name === "AbortError" || this.runSignal?.aborted || options.signal?.aborted) {
+          if (streamErr instanceof Error && streamErr.name === "AbortError" || runSignal?.aborted || options.signal?.aborted) {
             throw streamErr;
           }
-          result = await withTimeout(
-            provider.generate(options),
+          result = await withTimeoutAbort(
+            (signal) => provider.generate({ ...options, signal }),
             cloudTimeoutMs,
-            `Model ${model.id} inference timed out after ${cloudTimeoutMs}ms`
+            `Model ${model.id} inference timed out after ${cloudTimeoutMs}ms`,
+            [options.signal, runAbort.signal]
           );
         }
       } else {
         const cloudTimeoutMs = this.config.cloudInferenceTimeoutMs ?? 12e4;
-        result = await withTimeout(
-          provider.generate(options),
+        result = await withTimeoutAbort(
+          (signal) => provider.generate({ ...options, signal }),
           cloudTimeoutMs,
-          `Model ${model.id} inference timed out after ${cloudTimeoutMs}ms`
+          `Model ${model.id} inference timed out after ${cloudTimeoutMs}ms`,
+          [options.signal, runAbort.signal]
         );
       }
       const corrected = buildTokenUsage(
@@ -5199,11 +5689,12 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
       if (!result || typeof result.content !== "string" || !result.usage) {
         throw new Error(`Provider ${model.provider}:${model.id} returned an invalid generation result.`);
       }
-      this.recordStats(tier, model, result.usage, options.featureTag);
+      this.recordStats(tier, model, result.usage, options.featureTag, runGeneration);
       this.failover.recordSuccess(model.provider);
       return result;
     } catch (err) {
-      if (err instanceof Error && err.name === "AbortError" || this.runSignal?.aborted || options.signal?.aborted) {
+      if (err instanceof _CascadeRouter.BudgetExceededError) throw err;
+      if (err instanceof Error && err.name === "AbortError" || runSignal?.aborted || options.signal?.aborted) {
         throw new CascadeCancelledError("Run cancelled");
       }
       const errMsg = err instanceof Error ? err.message : String(err);
@@ -5221,6 +5712,8 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
           });
           releaseLocalSlot?.();
           releaseLocalSlot = void 0;
+          releaseReservation?.();
+          releaseReservation = void 0;
           const retryOpts = options.model && options.model.id === model.id ? { ...options, model: void 0 } : options;
           return this.generate(tier, retryOpts, onChunk, requireVision);
         }
@@ -5242,6 +5735,8 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
           });
           releaseLocalSlot?.();
           releaseLocalSlot = void 0;
+          releaseReservation?.();
+          releaseReservation = void 0;
           const base = options.model && options.model.id === model.id ? { ...options, model: void 0 } : options;
           const retryOpts = { ...base, _notFoundDepth: depth };
           return this.generate(tier, retryOpts, onChunk, requireVision);
@@ -5250,6 +5745,8 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
       throw err;
     } finally {
       releaseLocalSlot?.();
+      releaseReservation?.();
+      releaseReservation = void 0;
     }
   }
   getModelForTier(tier) {
@@ -5512,12 +6009,28 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     return this.selector?.getAllAvailableModels() ?? [];
   }
   // ── Private ──────────────────────────────────
+  /**
+   * Why each configured provider failed its availability probe, kept so the
+   * surfaces can say something better than "add an API key" to a user who
+   * already has one. Cleared and refilled by each detectAvailableProviders().
+   */
+  probeFailures = /* @__PURE__ */ new Map();
+  /**
+   * What stopped the configured providers from being usable, if anything.
+   * Empty when every configured provider passed — or when none was configured,
+   * which is a different problem with a different answer.
+   */
+  providerProbeFailures() {
+    return [...this.probeFailures].map(([provider, reason]) => ({ provider, reason }));
+  }
   /** Logs why a configured provider failed its availability probe. */
   emitProbeFailure(type, reason) {
+    this.probeFailures.set(type, reason);
     console.warn(`[router] provider "${type}" is not available: ${reason}`);
   }
   async detectAvailableProviders(configs) {
     const available = /* @__PURE__ */ new Set();
+    this.probeFailures.clear();
     const checks = configs.map(async (cfg) => {
       try {
         const testModel = this.getAnyModelForProvider(cfg.type);
@@ -5527,7 +6040,13 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
         if (ok) available.add(cfg.type);
         else this.emitProbeFailure(cfg.type, "availability check returned false (bad key, wrong endpoint/deployment, or unreachable)");
       } catch (err) {
-        this.emitProbeFailure(cfg.type, err instanceof Error ? err.message : String(err));
+        const reason = err instanceof Error ? err.message : String(err);
+        if (err instanceof ProviderUnreachableError) {
+          available.add(cfg.type);
+          console.warn(`[router] provider "${cfg.type}" probe did not complete: ${reason} \u2014 continuing with it enabled`);
+          return;
+        }
+        this.emitProbeFailure(cfg.type, reason);
       }
     });
     await Promise.allSettled(checks);
@@ -5620,7 +6139,14 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     }
     return void 0;
   }
-  recordStats(tier, model, usage, featureTag) {
+  /**
+   * `runGeneration` is the generation the call was ADMITTED in — see
+   * `generate()`. Session-wide accounting always applies (the spend is real
+   * whenever it lands), but the per-RUN ceiling is only meaningful for the run
+   * the call belongs to, so a straggler from a finished run is left out of it.
+   * Omitted by the direct callers in tests, which have no run to straddle.
+   */
+  recordStats(tier, model, usage, featureTag, runGeneration) {
     this.stats.totalTokens += usage.totalTokens;
     this.stats.totalCostUsd += usage.estimatedCostUsd;
     this.sessionCostUsd += usage.estimatedCostUsd;
@@ -5645,10 +6171,13 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
         });
       }
     }
-    this.runTokens += usage.totalTokens;
-    this.runCostUsd += usage.estimatedCostUsd;
+    const currentRun = runGeneration === void 0 || runGeneration === this.runGeneration;
+    if (currentRun) {
+      this.runTokens += usage.totalTokens;
+      this.runCostUsd += usage.estimatedCostUsd;
+    }
     this.updateBudgetState();
-    this.enforceRunBudget();
+    if (currentRun) this.enforceRunBudget();
   }
   /**
    * Resets per-run accounting at the start of each `cascade run`. Session
@@ -5658,9 +6187,158 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
   beginRun() {
     this.runTokens = 0;
     this.runCostUsd = 0;
+    this.reservedTokens = 0;
+    this.reservedCostUsd = 0;
+    this.runAbort = newRunAbort();
+    this.runGeneration++;
     this.runBudgetExceeded = false;
     this.runBudgetExceededReason = void 0;
   }
+  /**
+   * Refuse a call whose input alone cannot fit what is left of the run budget.
+   *
+   * `enforceRunBudget()` below runs AFTER a call returns, which makes the caps
+   * a stop rather than a pre-authorisation: the tokens are already bought by
+   * the time it looks. That was tolerable while a prompt could not exceed
+   * 20,000 characters, and stopped being so when that cap was removed in
+   * 0.72.0 — a multi-megabyte prompt is billed in full on the very first call
+   * (the complexity classifier sends the whole thing), and no ceiling
+   * configured downstream can give that money back.
+   *
+   * Deliberately narrow, because a false refusal is worse than a late stop:
+   *
+   *   • INPUT ONLY. What a call returns is not knowable in advance, and
+   *     charging a worst-case `maxTokens` of output against the budget would
+   *     decline runs that would have finished comfortably. Input is the part
+   *     that is already determined, and it is the part the removed cap used to
+   *     bound.
+   *   • Compared against what REMAINS (`cap - spent`), not the whole cap, so a
+   *     call is judged on the budget it can actually draw from.
+   *   • Skipped when the model has no usable price. An estimate cannot be made,
+   *     and refusing on ignorance would break every self-hosted and local model
+   *     the moment a cost cap is set. The post-hoc stop still applies there.
+   *   • Skipped entirely when no cap is configured — there is nothing to
+   *     pre-authorise against.
+   *
+   * The message names the cap AND the estimate, because "too expensive" with
+   * no numbers gives the user nothing to change.
+   */
+  enforcePreflightBudget(model, options) {
+    const budget = this.config?.budget;
+    const maxCost = budget?.maxCostPerRunUsd;
+    const maxTokens = budget?.maxTokensPerRun;
+    if (maxCost == null && maxTokens == null) return void 0;
+    const inputTokens = this.estimateInputTokens(options, model);
+    if (maxTokens != null) {
+      const remaining = maxTokens - this.runTokens - this.reservedTokens;
+      if (inputTokens > remaining) {
+        this.failPreflight(
+          `This request's input is about ${inputTokens.toLocaleString()} tokens, but only ${Math.max(0, remaining).toLocaleString()} of the per-task cap of ${maxTokens.toLocaleString()} remain. Shorten the input, or raise budget.maxTokensPerRun.`
+        );
+      }
+    }
+    let estimatedUsd = 0;
+    if (maxCost != null) {
+      const { input: inputPer1k, unknown } = resolveModelPricing(model, { inputTokens });
+      if (!unknown && inputPer1k > 0) {
+        estimatedUsd = inputTokens / 1e3 * inputPer1k;
+        const remaining = maxCost - this.runCostUsd - this.reservedCostUsd;
+        if (estimatedUsd > remaining) {
+          this.failPreflight(
+            `Sending this request to ${model.provider}:${model.id} would cost about $${estimatedUsd.toFixed(4)} in input alone (~${inputTokens.toLocaleString()} tokens), and only $${Math.max(0, remaining).toFixed(4)} of the per-task cap of $${maxCost.toFixed(4)} remains. Shorten the input, choose a cheaper model, or raise budget.maxCostPerRunUsd.`
+          );
+        }
+      }
+    }
+    this.reservedTokens += inputTokens;
+    this.reservedCostUsd += estimatedUsd;
+    const generation = this.runGeneration;
+    let released = false;
+    return () => {
+      if (released || generation !== this.runGeneration) return;
+      released = true;
+      this.reservedTokens -= inputTokens;
+      this.reservedCostUsd -= estimatedUsd;
+    };
+  }
+  /**
+   * What this call will send, in tokens.
+   *
+   * Text is the bulk of it, but not all of it: providers bill the serialized
+   * TOOL DEFINITIONS on every native-tool call (Anthropic sends each name,
+   * description and input schema), and an image is billed by its own size
+   * rather than as the `[image]` placeholder `contentToText` reduces it to. A
+   * tool-heavy or vision request could therefore pass either cap while its real
+   * input already exceeded the allowance.
+   */
+  estimateInputTokens(options, model) {
+    let tokens = guardTokens(options.systemPrompt ?? "");
+    let images = 0;
+    const wire = wireProfile(model.provider);
+    const countsImage = (img) => wire.sendsUrlImages || img?.type === "base64";
+    for (const message of options.messages) {
+      if (wire.dropsMessage(message)) continue;
+      tokens += TOKENS_PER_MESSAGE_FRAMING;
+      if (typeof message.content === "string") {
+        tokens += guardTokens(message.content);
+      } else {
+        switch (wire.blockHandling(message)) {
+          case "blocks":
+            for (const block of message.content) {
+              if (!wire.sendsBlock(block)) continue;
+              if (block.type === "image") {
+                if (countsImage(block.image)) images++;
+                continue;
+              }
+              tokens += guardTokens(contentToText([block]));
+            }
+            break;
+          case "stringified":
+            tokens += guardTokens(safeJson(message.content));
+            break;
+        }
+      }
+      if (message.toolCalls?.length && wire.sendsToolCalls(message)) {
+        tokens += guardTokens(safeJson(wire.sizeToolCalls(message.toolCalls)));
+      }
+      if (message.toolCallId && message.role === "tool" && wire.sendsToolCallId) {
+        tokens += guardTokens(message.toolCallId);
+      }
+    }
+    if (options.tools?.length) {
+      tokens += guardTokens(safeJson(wire.sizeTools(options.tools)));
+    }
+    if (wire.readsTopLevelImages) {
+      const topLevel = (options.images ?? []).filter(countsImage).length;
+      images += topLevel * geminiImageCopies(options.messages);
+    }
+    tokens += images * IMAGE_TOKENS_EACH;
+    return tokens;
+  }
+  /**
+   * Report a wait that ended because something asked it to stop, the same way
+   * the provider call below reports one.
+   *
+   * The queue waits sit OUTSIDE the try/catch that maps aborts, so without
+   * this a cancellation surfaced as whatever the queue happened to throw and
+   * was retried or failed over like an ordinary error. A budget abort keeps
+   * saying it ran out of budget — otherwise the reason the run stopped is lost
+   * on the way up — and anything else that was aborted becomes a cancellation.
+   */
+  asAbortFailure(err, callSignal, runSignal) {
+    if (err instanceof _CascadeRouter.BudgetExceededError) return err;
+    if (err instanceof CascadeCancelledError) return err;
+    if (callSignal?.aborted || runSignal?.aborted) return new CascadeCancelledError("Run cancelled");
+    return err;
+  }
+  /** Trips the same run-level flag a post-hoc overrun does, and reports it the same way. */
+  failPreflight(reason) {
+    this.runBudgetExceeded = true;
+    this.runBudgetExceededReason = reason;
+    this.runAbort.abort(new _CascadeRouter.BudgetExceededError(reason));
+    this.emit("budget:exceeded", { reason, spentUsd: this.sessionCostUsd });
+    throw new _CascadeRouter.BudgetExceededError(reason);
+  }
   /**
    * Enforce the hard per-task ceiling. Once tripped, the flag makes every
    * subsequent (and concurrent) generate() call in this run fail fast.
@@ -5676,6 +6354,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     const reason = overTokens ? `Per-task token cap of ${maxTokens.toLocaleString()} reached (used ${this.runTokens.toLocaleString()}). Stopping this run to avoid runaway cost \u2014 raise budget.maxTokensPerRun for larger jobs.` : `Per-task cost cap of $${maxCost.toFixed(4)} reached (spent $${this.runCostUsd.toFixed(4)}). Stopping this run to avoid runaway cost.`;
     this.runBudgetExceeded = true;
     this.runBudgetExceededReason = reason;
+    this.runAbort.abort(new _CascadeRouter.BudgetExceededError(reason));
     this.emit("budget:exceeded", { reason, spentUsd: this.sessionCostUsd });
     throw new _CascadeRouter.BudgetExceededError(reason);
   }
@@ -6912,6 +7591,12 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
         maxTokens: 4096,
         ...subtaskModel ? { model: subtaskModel } : {},
         featureTag: this.assignment?.sectionTitle,
+        // The wave signal, so cancel-and-respawn reaches the request that is
+        // RUNNING rather than only stopping the worker at its next checkpoint.
+        // It is a superset of the run signal the router injects when this is
+        // absent (T2 composes it from that signal plus its own per-wave one),
+        // so wiring it here loses no cancellation and adds the wave's.
+        ...this.signal ? { signal: this.signal } : {},
         ...this.localOnlyMatch ? { forceLocal: true } : {}
       };
       const result = await this.router.generate(
@@ -7390,6 +8075,7 @@ ${current}`
 HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
           maxTokens: 4096,
           featureTag: assignment.sectionTitle,
+          ...this.signal ? { signal: this.signal } : {},
           ...this.localOnlyMatch ? { forceLocal: true } : {}
         });
         const next = (improved.content ?? "").trim();
@@ -7451,6 +8137,7 @@ Reply with JSON: { "completeness": "pass"|"fail", "correctness": "pass"|"fail",
 
 HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
       featureTag: assignment.sectionTitle,
+      ...this.signal ? { signal: this.signal } : {},
       ...this.localOnlyMatch ? { forceLocal: true } : {}
     });
     try {
@@ -7490,6 +8177,7 @@ ${output.slice(0, 4e3)}`;
         messages: [{ role: "user", content: prompt }],
         maxTokens: 300,
         temperature: 0,
+        ...this.signal ? { signal: this.signal } : {},
         ...this.localOnlyMatch ? { forceLocal: true } : {}
       });
       const match = /\[[\s\S]*\]/.exec(result.content);
@@ -7601,6 +8289,10 @@ Begin execution now.`;
   }
 };
 var PeerBus = class extends EventEmitter {
+  constructor() {
+    super();
+    this.setMaxListeners(64);
+  }
   outputs = /* @__PURE__ */ new Map();
   waiters = /* @__PURE__ */ new Map();
   members = /* @__PURE__ */ new Set();
@@ -8848,6 +9540,7 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
       const waveSignal = AbortSignal.any(
         [this.signal, this.waveAbortController.signal].filter(Boolean)
       );
+      setMaxListeners(64, waveSignal);
       const runOne = async (id) => {
         const assignment = sanitizedAssignments.find((a) => a.subtaskId === id);
         const worker = workerMap.get(id);
@@ -16491,115 +17184,6 @@ var GraphSearchTool = class extends BaseTool {
   }
 };
 
-// src/core/context/compaction.ts
-function estimateTokens(text) {
-  if (!text) return 0;
-  return Math.max(1, Math.ceil(text.length / 4));
-}
-function contentToText(content) {
-  if (typeof content === "string") return content;
-  return content.map((c) => c.type === "text" ? c.text : c.type === "tool_result" ? c.content : `[${c.type}]`).join(" ");
-}
-function messagesTokens(messages) {
-  return messages.reduce((n, m) => n + estimateTokens(contentToText(m.content)), 0);
-}
-function atomize(text, maxChars) {
-  const seps = ["\n\n", "\n", ". ", " "];
-  let units = [text];
-  for (const sep of seps) {
-    if (units.every((u) => u.length <= maxChars)) break;
-    const next = [];
-    for (const u of units) {
-      if (u.length <= maxChars) {
-        next.push(u);
-        continue;
-      }
-      const parts = u.split(sep);
-      parts.forEach((p, i) => next.push(i < parts.length - 1 ? p + sep : p));
-    }
-    units = next;
-  }
-  const out = [];
-  for (const u of units) {
-    if (u.length <= maxChars) out.push(u);
-    else for (let i = 0; i < u.length; i += maxChars) out.push(u.slice(i, i + maxChars));
-  }
-  return out;
-}
-function chunkText(text, opts) {
-  const maxChars = Math.max(1, Math.floor(opts.maxTokens * 4));
-  const overlap = Math.min(maxChars - 1, Math.max(0, Math.floor(maxChars * (opts.overlapRatio ?? 0.1))));
-  const trimmed = text.trim();
-  if (!trimmed) return [];
-  if (trimmed.length <= maxChars) return [trimmed];
-  const units = atomize(trimmed, maxChars);
-  const chunks = [];
-  let cur = "";
-  for (const u of units) {
-    if (cur && cur.length + u.length > maxChars) {
-      chunks.push(cur.trim());
-      cur = overlap > 0 ? cur.slice(-overlap) : "";
-    }
-    cur += u;
-  }
-  if (cur.trim()) chunks.push(cur.trim());
-  return chunks;
-}
-function needsCompaction(totalTokens, contextWindow, reserve = 0.2) {
-  if (!contextWindow || contextWindow <= 0) return false;
-  return totalTokens > contextWindow * (1 - reserve);
-}
-async function mapReduceCompact(text, opts) {
-  const capChars = opts.capTokens * 4;
-  let working = text;
-  let truncated = false;
-  if (working.length > capChars) {
-    working = working.slice(0, capChars);
-    truncated = true;
-  }
-  const instruction = opts.instruction ?? "Summarize this content, preserving key facts, names, numbers, and decisions.";
-  let chunks = chunkText(working, { maxTokens: opts.chunkTokens });
-  if (chunks.length <= 1) return { text: working, chunks: chunks.length, calls: 0, truncated };
-  let calls = 0;
-  let parts = await Promise.all(
-    chunks.map((c, i) => {
-      calls++;
-      return opts.summarize(c, `${instruction} (part ${i + 1} of ${chunks.length})`);
-    })
-  );
-  let combined = parts.join("\n\n");
-  const maxPasses = opts.maxReducePasses ?? 3;
-  for (let pass = 0; pass < maxPasses && estimateTokens(combined) > opts.targetTokens; pass++) {
-    const groups = chunkText(combined, { maxTokens: opts.chunkTokens });
-    if (groups.length <= 1) break;
-    parts = await Promise.all(
-      groups.map((g) => {
-        calls++;
-        return opts.summarize(g, "Merge these partial summaries into one cohesive summary; keep all distinct facts.");
-      })
-    );
-    combined = parts.join("\n\n");
-  }
-  const note = truncated ? "\n\n[Note: input exceeded the extended-context cap and was truncated.]" : "";
-  return { text: combined + note, chunks: chunks.length, calls, truncated };
-}
-async function rollingSummary(messages, opts) {
-  if (messages.length <= opts.keepRecent) return messages;
-  const older = messages.slice(0, messages.length - opts.keepRecent);
-  const recent = messages.slice(messages.length - opts.keepRecent);
-  const transcript = older.map((m) => `${m.role}: ${contentToText(m.content)}`).join("\n");
-  const summary = await opts.summarize(
-    transcript,
-    "Summarize this earlier conversation. Preserve facts, decisions, names, numbers, and any open threads or todos."
-  );
-  const summaryMessage = {
-    role: "system",
-    content: `Summary of earlier conversation (folded to fit the context window):
-${summary}`
-  };
-  return [summaryMessage, ...recent];
-}
-
 // src/core/steering/guidance.ts
 var GuidanceQueue = class {
   entries = [];
@@ -18151,7 +18735,16 @@ ${finalOutput}` : ""
     const selector = this.router.getSelector();
     const model = options.fastAnswerModel ? selector.selectForTier(tier, options.fastAnswerModel) : selector.getCandidatesForTier(tier)[0] ?? selector.selectForTier(tier);
     if (!model) {
-      throw new Error("No model is available for a fast answer \u2014 add a provider API key first.");
+      const failures2 = this.router.providerProbeFailures();
+      const context = failures2.length ? ` Configured providers: ${failures2.map((f) => `${f.provider}: ${f.reason}`).join("; ")}` : "";
+      if (options.fastAnswerModel) {
+        throw new Error(
+          `No model is available for a fast answer: the pinned model "${options.fastAnswerModel}" could not be resolved \u2014 check it is spelled correctly and served by a configured provider.${context}`
+        );
+      }
+      throw new Error(
+        failures2.length ? `No model is available for a fast answer.${context}` : "No model is available for a fast answer \u2014 add a provider API key first."
+      );
     }
     this.recordDecision(
       "model",
@@ -21742,10 +22335,10 @@ ${cur}`;
 }
 
 // src/retrieval/plan.ts
-var CHARS_PER_TOKEN = 4;
+var CHARS_PER_TOKEN2 = 4;
 function cagCharBudget(contextWindowTokens, opts = {}) {
   const docFraction = opts.docFraction ?? 0.5;
-  const charsPerToken = opts.charsPerToken ?? CHARS_PER_TOKEN;
+  const charsPerToken = opts.charsPerToken ?? CHARS_PER_TOKEN2;
   return Math.max(0, Math.floor(contextWindowTokens * docFraction * charsPerToken));
 }
 function planRetrieval(ctx) {
@@ -22312,6 +22905,6 @@ function applySyncBundle(bundle, config, cleanup) {
   return next;
 }
 
-export { AZURE_BASE_MODELS, AZURE_BASE_URL_TEMPLATE, AuditLogger, CASCADE_AUDIT_FILE, CASCADE_CONFIG_DIR, CASCADE_CONFIG_FILE, CASCADE_DASHBOARD_SECRET_FILE, CASCADE_DB_FILE, CASCADE_IGNORE_FILE, CASCADE_KEYSTORE_FILE, CASCADE_MD_FILE, CASCADE_VERSION, CHARS_PER_TOKEN, COMPLEXITY_T2_COUNT, Cascade, CascadeCancelledError, CascadeIgnore, CascadeRouter, CascadeToolError, CloudClient, CodeSearchTool, ConfigManager, CurrentPageTool, DEFAULT_API_PORT, DEFAULT_APPROVAL_REQUIRED, DEFAULT_AUTO_SUMMARIZE_AT, DEFAULT_CLOUD_URL, DEFAULT_CONTEXT_LIMIT, DEFAULT_DASHBOARD_PORT, DEFAULT_MAX_SESSION_MESSAGES, DEFAULT_RETENTION_DAYS, DEFAULT_THEME, DOCUMENT_MIME, DashboardServer, DependencyScheduler, FileMcpOAuthStore, GLOBAL_CONFIG_DIR, GLOBAL_CREDENTIALS_FILE, GLOBAL_DB_FILE, GLOBAL_KEYSTORE_FILE, GLOBAL_RUNTIME_DB_FILE, GenerateDocumentTool, GraphRetriever, GraphSearchTool, HooksRunner, Keystore, LLMReranker, LM_STUDIO_BASE_URL, MAX_PAGE_TEXT_CHARS, MCP_TOOL_PREFIX, MODELS, McpClient, McpOAuthProvider, MemoryStore, OLLAMA_BASE_URL, OpenAICompatibleEmbedder, PROVIDER_DISPLAY_NAMES, RESUME_SCHEMA_VERSION, ResumeStore, Retriever, SqliteVectorStore, T1Administrator, T1_MODEL_PRIORITY, T2Manager, T2_MODEL_PRIORITY, T3Worker, T3_MODEL_PRIORITY, THEME_NAMES, TOOL_NAMES, TaskGraphValidationError, TaskScheduler, Telemetry, ToolRegistry, VISION_MODEL_PRIORITY, WorkspaceIndex, applySyncBundle, azureModelForDeployment, beginMcpOAuth, buildDocumentTools, buildManifest, buildSessionTranscript, bytesToBase64, cagCharBudget, chartKind, chartToTableRows, chatCompleterFromProviders, chunkCode, chunkText2 as chunkText, compileSectionGraph, compileSubtaskGraph, compileTaskGraph, completeMcpOAuth, connectMcpWithLoopbackOAuth, createCascade, decryptJSON as decryptSyncBlob, diffManifest, disambiguateMcpServerNames, discoverMcpAuthServer, discoverMcpTools, distillSessionFacts, embedderFromProviders, encryptJSON as encryptSyncBlob, evaluateAcceptance, extractCharts, failures, fileExt, fileOAuthProvider, gatherSyncBundle, hasUsableProvider, hashContent, heuristicCodeChunker, inferAzureBaseModel, inlineRuns, isDocumentFormat, isMcpToolName, matchImageLine, mcpServerPrefix, mcpToolName, nodeHttpFetch, parseBlocks, parseChartSpec, parseDelimited, parseRankOrder, parseSlide, planRetrieval, preferIpv4Host, reciprocalRankFusion, refreshMcpToken, removeMcpServerDenials, renderDocument, renderDocx, renderPptx, renderXlsx, runCascade, sessionWorthRemembering, sniffImage, splitSlides, streamCascade, stripInline, summarizeCompleted, undecided, uniqueMcpServerName };
+export { AZURE_BASE_MODELS, AZURE_BASE_URL_TEMPLATE, AuditLogger, CASCADE_AUDIT_FILE, CASCADE_CONFIG_DIR, CASCADE_CONFIG_FILE, CASCADE_DASHBOARD_SECRET_FILE, CASCADE_DB_FILE, CASCADE_IGNORE_FILE, CASCADE_KEYSTORE_FILE, CASCADE_MD_FILE, CASCADE_VERSION, CHARS_PER_TOKEN2 as CHARS_PER_TOKEN, COMPLEXITY_T2_COUNT, Cascade, CascadeCancelledError, CascadeIgnore, CascadeRouter, CascadeToolError, CloudClient, CodeSearchTool, ConfigManager, CurrentPageTool, DEFAULT_API_PORT, DEFAULT_APPROVAL_REQUIRED, DEFAULT_AUTO_SUMMARIZE_AT, DEFAULT_CLOUD_URL, DEFAULT_CONTEXT_LIMIT, DEFAULT_DASHBOARD_PORT, DEFAULT_MAX_SESSION_MESSAGES, DEFAULT_RETENTION_DAYS, DEFAULT_THEME, DOCUMENT_MIME, DashboardServer, DependencyScheduler, FileMcpOAuthStore, GLOBAL_CONFIG_DIR, GLOBAL_CREDENTIALS_FILE, GLOBAL_DB_FILE, GLOBAL_KEYSTORE_FILE, GLOBAL_RUNTIME_DB_FILE, GenerateDocumentTool, GraphRetriever, GraphSearchTool, HooksRunner, Keystore, LLMReranker, LM_STUDIO_BASE_URL, MAX_PAGE_TEXT_CHARS, MCP_TOOL_PREFIX, MODELS, McpClient, McpOAuthProvider, MemoryStore, OLLAMA_BASE_URL, OpenAICompatibleEmbedder, PROVIDER_DISPLAY_NAMES, RESUME_SCHEMA_VERSION, ResumeStore, Retriever, SqliteVectorStore, T1Administrator, T1_MODEL_PRIORITY, T2Manager, T2_MODEL_PRIORITY, T3Worker, T3_MODEL_PRIORITY, THEME_NAMES, TOOL_NAMES, TaskGraphValidationError, TaskScheduler, Telemetry, ToolRegistry, VISION_MODEL_PRIORITY, WorkspaceIndex, applySyncBundle, azureModelForDeployment, beginMcpOAuth, buildDocumentTools, buildManifest, buildSessionTranscript, bytesToBase64, cagCharBudget, chartKind, chartToTableRows, chatCompleterFromProviders, chunkCode, chunkText2 as chunkText, compileSectionGraph, compileSubtaskGraph, compileTaskGraph, completeMcpOAuth, connectMcpWithLoopbackOAuth, createCascade, decryptJSON as decryptSyncBlob, diffManifest, disambiguateMcpServerNames, discoverMcpAuthServer, discoverMcpTools, distillSessionFacts, embedderFromProviders, encryptJSON as encryptSyncBlob, evaluateAcceptance, extractCharts, failures, fileExt, fileOAuthProvider, gatherSyncBundle, hasUsableProvider, hashContent, heuristicCodeChunker, inferAzureBaseModel, inlineRuns, isDocumentFormat, isMcpToolName, matchImageLine, mcpServerPrefix, mcpToolName, nodeHttpFetch, parseBlocks, parseChartSpec, parseDelimited, parseRankOrder, parseSlide, planRetrieval, preferIpv4Host, reciprocalRankFusion, refreshMcpToken, removeMcpServerDenials, renderDocument, renderDocx, renderPptx, renderXlsx, runCascade, sessionWorthRemembering, sniffImage, splitSlides, streamCascade, stripInline, summarizeCompleted, undecided, uniqueMcpServerName };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map