@genesislcap/ai-assistant 15.3.2 → 15.3.3-alpha-4899ddd.0

package/dist/chat-driver.mjs

@@ -969,6 +969,67 @@ var GeminiProvider = class {
   }
 };
 
+// ../../foundation-ai/dist/esm/transports/budget-exhausted-error.js
+var BUDGET_EXCEEDED_CODE = "BUDGET_EXCEEDED";
+var VENDOR_LABELS = Object.freeze({
+  anthropic: "Anthropic",
+  gemini: "Gemini",
+  openai: "OpenAI",
+  chrome: "Chrome"
+});
+var BUDGETED_VENDORS = Object.freeze([
+  "anthropic",
+  "gemini"
+]);
+var VENDOR_TYPE_BY_LABEL = new Map(Object.entries(VENDOR_LABELS).map(([type, label]) => [
+  label.toLowerCase(),
+  type
+]));
+function vendorTypeOfLabel(label) {
+  if (typeof label !== "string")
+    return void 0;
+  return VENDOR_TYPE_BY_LABEL.get(label.trim().toLowerCase());
+}
+var BUDGET_EXCEEDED_STATUS = 402;
+var DEFAULT_BUDGET_EXHAUSTED_MESSAGE = "You've reached your AI usage limit. Contact your administrator to raise it.";
+var BudgetExhaustedError = class extends Error {
+  constructor(vendorLabel, budgetUsd, spentUsd, detail, extra) {
+    super(`${vendorLabel} request refused: the AI usage budget is exhausted` + (budgetUsd != null ? ` (spent ${spentUsd != null ? `$${spentUsd}` : "an unknown amount"} of a $${budgetUsd} budget)` : "") + (detail ? `: ${detail}` : "") + ". Retrying will not clear this \u2014 the budget must be raised.");
+    this.vendorLabel = vendorLabel;
+    this.budgetUsd = budgetUsd;
+    this.spentUsd = spentUsd;
+    this.detail = detail;
+    this.name = "BudgetExhaustedError";
+    this.otherVendorAvailable = extra === null || extra === void 0 ? void 0 : extra.otherVendorAvailable;
+    this.serverVendor = extra === null || extra === void 0 ? void 0 : extra.serverVendor;
+  }
+};
+var isBudgetRejection = (status, code) => status === BUDGET_EXCEEDED_STATUS || code === BUDGET_EXCEEDED_CODE;
+var parseJsonOrUndefined = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch (_a) {
+    return void 0;
+  }
+};
+var codeOf = (payload) => {
+  const code = payload === null || payload === void 0 ? void 0 : payload.code;
+  return typeof code === "string" ? code : void 0;
+};
+var numberOrUndefined = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var booleanOrUndefined = (value) => typeof value === "boolean" ? value : void 0;
+var stringOrUndefined = (value) => typeof value === "string" && value.trim() !== "" ? value : void 0;
+function budgetExhaustedFrom(vendorLabel, payload, fallbackDetail) {
+  var _a, _b, _c, _d;
+  const body = typeof payload === "object" && payload !== null ? payload : {};
+  const details = typeof body.details === "object" && body.details !== null ? body.details : {};
+  const detail = typeof body.error === "string" ? body.error : fallbackDetail;
+  return new BudgetExhaustedError(vendorLabel, (_a = numberOrUndefined(body.budgetUsd)) !== null && _a !== void 0 ? _a : numberOrUndefined(details.budgetUsd), (_b = numberOrUndefined(body.spentUsd)) !== null && _b !== void 0 ? _b : numberOrUndefined(details.spentUsd), detail, {
+    otherVendorAvailable: (_c = booleanOrUndefined(body.otherVendorAvailable)) !== null && _c !== void 0 ? _c : booleanOrUndefined(details.otherVendorAvailable),
+    serverVendor: (_d = stringOrUndefined(body.vendor)) !== null && _d !== void 0 ? _d : stringOrUndefined(details.vendor)
+  });
+}
+
 // ../../foundation-ai/dist/esm/types/config.types.js
 var SUPPORTED_GEMINI_MODEL_IDS = [
   "gemini-2.5-pro",
@@ -1123,15 +1184,19 @@ function postWithRetry(options) {
           signal: combinedSignal,
           credentials
         });
-        if (retryableStatuses.includes(response.status) && attempt < MAX_RETRIES) {
-          logger.warn(`${vendorLabel}Transport: retryable status ${response.status}, retrying (attempt ${attempt + 1}/${MAX_RETRIES})`);
-          clearTimeout(timeoutId);
-          yield backoff(attempt);
-          continue;
-        }
         if (!response.ok) {
-          const err = yield response.text();
-          throw new Error(`${vendorLabel} request error ${response.status}: ${err}`);
+          const errText = yield response.text();
+          const parsed = parseJsonOrUndefined(errText);
+          if (isBudgetRejection(response.status, codeOf(parsed))) {
+            throw budgetExhaustedFrom(vendorLabel, parsed, errText || void 0);
+          }
+          if (retryableStatuses.includes(response.status) && attempt < MAX_RETRIES) {
+            logger.warn(`${vendorLabel}Transport: retryable status ${response.status}, retrying (attempt ${attempt + 1}/${MAX_RETRIES})`);
+            clearTimeout(timeoutId);
+            yield backoff(attempt);
+            continue;
+          }
+          throw new Error(`${vendorLabel} request error ${response.status}: ${errText}`);
         }
         if (((_b = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get("content-type")) === null || _b === void 0 ? void 0 : _b.toLowerCase().includes("application/x-ndjson")) && response.body) {
           rearmStallTimer();
@@ -1141,6 +1206,9 @@ function postWithRetry(options) {
           if (frame.code === "UPSTREAM_STALLED") {
             throw new DOMException(`${vendorLabel} request stalled: ${(_c = frame.error) !== null && _c !== void 0 ? _c : "no upstream data"}`, "TimeoutError");
           }
+          if (isBudgetRejection(frame.status, frame.code)) {
+            throw budgetExhaustedFrom(vendorLabel, frame);
+          }
           if (retryableStatuses.includes(frame.status) && attempt < MAX_RETRIES) {
             logger.warn(`${vendorLabel}Transport: retryable status ${frame.status} (err frame), retrying (attempt ${attempt + 1}/${MAX_RETRIES})`);
             clearTimeout(timeoutId);
@@ -1603,7 +1671,7 @@ ${att.content}` });
         headers: requestHeaders,
         body,
         credentials,
-        vendorLabel: "Anthropic",
+        vendorLabel: VENDOR_LABELS.anthropic,
         retryableStatuses: _AnthropicTransport.RETRYABLE_STATUSES,
         timeout: this.timeout,
         stallTimeout: this.stallTimeout,
@@ -2252,7 +2320,7 @@ ${att.content}`
         headers,
         body: payload,
         credentials,
-        vendorLabel: "Gemini",
+        vendorLabel: VENDOR_LABELS.gemini,
         retryableStatuses: _GeminiTransport.RETRYABLE_STATUSES,
         timeout: this.timeout,
         stallTimeout: this.stallTimeout,
@@ -2954,6 +3022,19 @@ The above summarizes earlier parts of this conversation that were compacted. Con
 var TOOL_FOLD_SYMBOL = Symbol("toolFold");
 
 // src/components/chat-driver/chat-driver.ts
+var budgetDetailOf = (e) => {
+  const vendor = vendorTypeOfLabel(e.vendorLabel) ?? vendorTypeOfLabel(e.serverVendor);
+  if (e.budgetUsd == null && e.spentUsd == null && !vendor) return void 0;
+  return {
+    budgetUsd: e.budgetUsd,
+    spentUsd: e.spentUsd,
+    vendorLabel: e.vendorLabel,
+    ...vendor ? { vendor } : {},
+    // Server-known truth the client cannot re-derive, so it rides all the way to
+    // the banner rather than being re-guessed there from registry membership.
+    ...e.otherVendorAvailable != null ? { otherVendorAvailable: e.otherVendorAvailable } : {}
+  };
+};
 var DEFAULT_MAX_TOOL_ITERATIONS = 50;
 var DEFAULT_MAX_FOLD_OPERATIONS = 5;
 var DEFAULT_MAX_TURN_SNAPSHOTS = 400;
@@ -3136,6 +3217,22 @@ var ChatDriver = class _ChatDriver extends EventTarget {
      * picked up on the next turn.
      */
     this.resolvedStatusCache = /* @__PURE__ */ new Map();
+    /**
+     * Set the moment a budget wall is observed anywhere in this turn — this
+     * driver's own 402, or a sub-agent's (which surfaces here only as a
+     * `'budget_exhausted'` tool result). Read at the top of the tool loop to end
+     * the turn before issuing another model call that would hit the same wall.
+     * Reset per turn alongside the other per-turn counters.
+     */
+    this.budgetExhaustedThisTurn = false;
+    /**
+     * Whether this turn's budget wall came from a SUB-AGENT rather than this
+     * driver's own request. Decides whether `lastResolvedProvider` is a valid
+     * attribution fallback: for an own wall it is the refusing vendor, for a
+     * child's wall it is the parent's vendor — the one known NOT to have refused.
+     * Reset per turn alongside `budgetWallDetail`.
+     */
+    this.budgetWallViaSubAgent = false;
     const {
       toolHandlers = {},
       toolDefinitions = [],
@@ -3145,11 +3242,13 @@ var ChatDriver = class _ChatDriver extends EventTarget {
       maxFoldOperations = DEFAULT_MAX_FOLD_OPERATIONS,
       maxTurnSnapshots = DEFAULT_MAX_TURN_SNAPSHOTS,
       sessionKey = "",
-      activityBus = NOOP_ACTIVITY_BUS
+      activityBus = NOOP_ACTIVITY_BUS,
+      budgetExhaustedMessage = DEFAULT_BUDGET_EXHAUSTED_MESSAGE
     } = config;
     this.maxToolIterations = maxToolIterations;
     this.sessionKey = sessionKey;
     this.activityBus = activityBus;
+    this.budgetExhaustedMessage = budgetExhaustedMessage;
     if (typeof toolHandlers === "function") {
       this.toolHandlersFactory = toolHandlers;
       this.toolHandlers = {};
@@ -3256,8 +3355,56 @@ var ChatDriver = class _ChatDriver extends EventTarget {
    * (rather than set to `undefined`) so a happy-path result stays byte-identical to
    * the historical `{ reason: 'done' }`.
    */
-  turnDone(failureReason) {
-    return failureReason ? { reason: "done", failureReason } : { reason: "done" };
+  turnDone(failureReason, budget) {
+    if (!failureReason) return { reason: "done" };
+    return budget ? { reason: "done", failureReason, budget } : { reason: "done", failureReason };
+  }
+  /**
+   * Terminal budget outcome for a wall hit **outside** the tool loop — today,
+   * `OrchestratingDriver`'s classification phase, which calls the provider
+   * directly and so never enters `runToolLoop`.
+   *
+   * Does **not** publish `tool-loop-end`: no `tool-loop-start` was published for
+   * the classify phase, and an unbalanced end would break start/end pairing for
+   * subscribers that rely on it. The driver **return value** is what reports this
+   * case — see `FoundationAiAssistant`'s latch, which reads both seams for
+   * exactly this reason.
+   *
+   * The non-sub-agent tail of the in-loop `BudgetExhaustedError` branch lives
+   * here so there is one copy of the log line, the debug-log entry, the
+   * transcript bubble and the result shape rather than two that can drift.
+   *
+   * @param pendingUserMessage - a user message that has NOT yet been appended,
+   *   appended first so the answer does not end up replying to nothing. Only the
+   *   classification seam passes it: `OrchestratingDriver` dispatches the user's
+   *   text as an optimistic `history-updated` detail and leaves the real append
+   *   to `chatDriver.sendMessage`, which never runs when `classify()` throws — so
+   *   the bubble below would re-dispatch a history the user's own message was
+   *   never in, and it would vanish from the transcript on the next render. The
+   *   in-loop caller has already appended it and passes nothing.
+   *
+   * @internal
+   */
+  reportBudgetExhausted(e, pendingUserMessage) {
+    if (pendingUserMessage) this.appendToHistory(pendingUserMessage);
+    this.budgetExhaustedThisTurn = true;
+    logger2.error("ChatDriver: AI budget exhausted", e);
+    recordTurnError(this.sessionKey, "budget-exhausted", {
+      agent: this.activeAgentName,
+      provider: this.lastResolvedProviderName,
+      // The registry ALIAS (e.g. 'high') is what `provider` records; the vendor
+      // is the thing a per-vendor budget is actually scoped to, and it was known
+      // at both ends and discarded in the middle until now. Taken from the
+      // refusing transport's label first — this method also serves the
+      // classification seam, where `lastResolvedProvider` is the PREVIOUS turn's
+      // vendor (or nothing), because classify runs against the registry default.
+      vendor: vendorTypeOfLabel(e.vendorLabel) ?? vendorTypeOfLabel(e.serverVendor) ?? this.lastResolvedProvider,
+      budgetUsd: e.budgetUsd,
+      spentUsd: e.spentUsd,
+      isSubAgent: this.isSubAgent
+    });
+    this.appendToHistory({ role: "assistant", content: this.budgetExhaustedMessage });
+    return this.turnDone("budget-exhausted", budgetDetailOf(e));
   }
   /** The typed failure reason on a loop result, or `undefined` for a clean turn / handoff. */
   static failureReasonOf(result) {
@@ -3267,10 +3414,28 @@ var ChatDriver = class _ChatDriver extends EventTarget {
    * Build the `tool-loop-end` event detail for a turn's result. A failure carries a
    * `{ failureReason }` detail; a clean turn emits `undefined` — the historical shape,
    * kept byte-identical so subscribers see exactly what they always have.
+   *
+   * A budget failure additionally carries `vendor` — the concrete vendor
+   * (`'anthropic'`/`'gemini'`) the walled turn resolved to, which the driver knows
+   * and used to discard. Optional and additive: a subscriber reading only
+   * `failureReason` is unaffected, a non-budget failure still emits the historical
+   * `{ failureReason }` with no `vendor` key, and the value is a plain string so
+   * the detail stays structured-cloneable for the cross-tab hop. It is the field a
+   * per-vendor budget model needs and the one that would be awkward to retrofit.
    */
-  static loopEndDetail(result) {
+  loopEndDetail(result) {
     const failureReason = _ChatDriver.failureReasonOf(result);
-    return failureReason ? { failureReason } : void 0;
+    if (!failureReason) return void 0;
+    if (failureReason !== "budget-exhausted") {
+      return { failureReason };
+    }
+    const budget = result.reason === "done" ? result.budget : void 0;
+    const vendor = budget?.vendor ?? (this.budgetWallViaSubAgent ? void 0 : this.lastResolvedProvider);
+    return {
+      failureReason,
+      ...vendor ? { vendor } : {},
+      ...budget ? { budget } : {}
+    };
   }
   /**
    * Swap in a new agent's configuration. Called by OrchestratingDriver before
@@ -3456,9 +3621,9 @@ var ChatDriver = class _ChatDriver extends EventTarget {
    * under a separate session key, so recording here would orphan the event off
    * the user-visible debug-log timeline.)
    */
-  failSubAgent(reason) {
+  failSubAgent(reason, budget) {
     if (!this.isSubAgent || this.subAgentFailure) return;
-    this.subAgentFailure = { reason };
+    this.subAgentFailure = budget ? { reason, budget } : { reason };
   }
   /**
    * Returns true if `releaseAgent` was called during the most recent turn.
@@ -3903,6 +4068,9 @@ Output format (strict):
     this.subAgentCompletion = void 0;
     this.subAgentFailure = void 0;
     this.agentReleaseRequested = false;
+    this.budgetExhaustedThisTurn = false;
+    this.budgetWallDetail = void 0;
+    this.budgetWallViaSubAgent = false;
     this.appendToHistory({ role: "user", content: userInput, attachments });
     this.turnStartedAt = Date.now();
     recordMetaEvent(this.sessionKey, "turn.start", {
@@ -3937,7 +4105,7 @@ Output format (strict):
       });
       this.busy = false;
       this.endTurn();
-      this.activityBus.publish("tool-loop-end", _ChatDriver.loopEndDetail(result));
+      this.activityBus.publish("tool-loop-end", this.loopEndDetail(result));
     }
   }
   /**
@@ -4128,8 +4296,14 @@ Output format (strict):
       recordMetaEvent(this.sessionKey, "subagent.completed", { agent: name });
       return { outcome: { ok: true, result: completion.result }, trace };
     }
-    const reason = child.getSubAgentFailure()?.reason ?? "max_iterations";
+    const failure = child.getSubAgentFailure();
+    const reason = failure?.reason ?? "max_iterations";
     recordMetaEvent(this.sessionKey, "subagent.failed", { agent: name, reason });
+    if (reason === "budget_exhausted") {
+      this.budgetExhaustedThisTurn = true;
+      this.budgetWallViaSubAgent = true;
+      this.budgetWallDetail ??= failure?.budget;
+    }
     return { outcome: { ok: false, reason }, trace };
   }
   /**
@@ -4142,6 +4316,9 @@ Output format (strict):
     this.beginTurn();
     this.subAgentCompletion = void 0;
     this.subAgentFailure = void 0;
+    this.budgetExhaustedThisTurn = false;
+    this.budgetWallDetail = void 0;
+    this.budgetWallViaSubAgent = false;
     this.turnStartedAt = Date.now();
     recordMetaEvent(this.sessionKey, "turn.start", {
       phase: "continueFromHistory",
@@ -4175,7 +4352,7 @@ Output format (strict):
       });
       this.busy = false;
       this.endTurn();
-      this.activityBus.publish("tool-loop-end", _ChatDriver.loopEndDetail(result));
+      this.activityBus.publish("tool-loop-end", this.loopEndDetail(result));
     }
   }
   // ---------------------------------------------------------------------------
@@ -4329,6 +4506,31 @@ Output format (strict):
       if (this.turnController.signal.aborted) {
         return this.completeAbortedTurn();
       }
+      if (this.budgetExhaustedThisTurn) {
+        logger2.error("ChatDriver: ending the turn \u2014 a sub-agent hit the AI budget wall");
+        recordTurnError(this.sessionKey, "budget-exhausted", {
+          agent: this.activeAgentName,
+          provider: this.lastResolvedProviderName,
+          // The CHILD's vendor when it knew one, and NOTHING otherwise. On this
+          // path the wall is definitionally the child's, and on a mixed registry
+          // `lastResolvedProvider` is this driver's own vendor — the one known
+          // NOT to have refused. An unattributable child wall must degrade to
+          // the vendor-agnostic block (which `latchBlockedFrom` handles
+          // fail-safe), never to a vendor that is known to be wrong: naming the
+          // parent's vendor here walled BOTH — the child's via its own
+          // tool-loop-end, the parent's via this event — and derived `blocked`
+          // over headroom that still existed.
+          vendor: this.budgetWallDetail?.vendor,
+          via: "sub-agent",
+          isSubAgent: this.isSubAgent
+        });
+        if (this.isSubAgent) {
+          this.failSubAgent("budget_exhausted", this.budgetWallDetail);
+        } else {
+          this.appendToHistory({ role: "assistant", content: this.budgetExhaustedMessage });
+        }
+        return this.turnDone("budget-exhausted", this.budgetWallDetail);
+      }
       const promptCtx = {
         agentName: this.activeAgentName ?? "",
         history: this.history,
@@ -4499,6 +4701,25 @@ ${tailBody}
           }
           return this.turnDone("response-truncated");
         }
+        if (e instanceof BudgetExhaustedError) {
+          this.budgetExhaustedThisTurn = true;
+          this.budgetWallDetail = budgetDetailOf(e);
+          this.budgetWallViaSubAgent = false;
+          if (this.isSubAgent) {
+            logger2.error("ChatDriver: AI budget exhausted", e);
+            recordTurnError(this.sessionKey, "budget-exhausted", {
+              agent: this.activeAgentName,
+              provider: this.lastResolvedProviderName,
+              vendor: vendorTypeOfLabel(e.vendorLabel) ?? vendorTypeOfLabel(e.serverVendor) ?? this.lastResolvedProvider,
+              budgetUsd: e.budgetUsd,
+              spentUsd: e.spentUsd,
+              isSubAgent: true
+            });
+            this.failSubAgent("budget_exhausted", this.budgetWallDetail);
+            return this.turnDone("budget-exhausted", this.budgetWallDetail);
+          }
+          return this.reportBudgetExhausted(e);
+        }
         if (e instanceof DOMException && e.name === "TimeoutError") {
           logger2.error("ChatDriver: request timed out", e);
           recordTurnError(this.sessionKey, "exception", {
@@ -4974,6 +5195,17 @@ var OrchestratingDriver = class extends EventTarget {
      * user stops. Reset at the start of each `sendMessage`.
      */
     this.cancelled = false;
+    /**
+     * Whether the CURRENT turn's user message has reached the inner driver's
+     * history. False through the pre-first-turn classify (where the only echo of
+     * the message is an optimistic `history-updated` dispatch), true from the
+     * moment `chatDriver.sendMessage` is entered — including through every later
+     * handoff classify. Read by the budget-wall catch in `sendMessage` to decide
+     * whether `reportBudgetExhausted` must append the message itself: appending
+     * it when already appended duplicated it; not appending it when unappended
+     * made it vanish. Reset at the top of each `runOrchestratedTurn`.
+     */
+    this.userMessageAppended = false;
     /**
      * Sticky user pick from the picker (or the host's `setAgent` API). Only
      * changes on explicit user action. Survives flow completion: when a stateful
@@ -5015,7 +5247,8 @@ var OrchestratingDriver = class extends EventTarget {
       maxFoldOperations: options.maxFoldOperations,
       maxTurnSnapshots: options.maxTurnSnapshots,
       sessionKey: this.sessionKey,
-      activityBus: options.activityBus
+      activityBus: options.activityBus,
+      budgetExhaustedMessage: options.budgetExhaustedMessage
     });
     this.chatDriver.addEventListener("history-updated", (e) => {
       this.dispatchEvent(new CustomEvent("history-updated", { detail: e.detail }));
@@ -5114,7 +5347,25 @@ var OrchestratingDriver = class extends EventTarget {
     return this.chatDriver.getSuggestions(history, prompt2, count, agentInfo);
   }
   async sendMessage(input, attachments) {
+    try {
+      return await this.runOrchestratedTurn(input, attachments);
+    } catch (e) {
+      if (e instanceof BudgetExhaustedError) {
+        return this.chatDriver.reportBudgetExhausted(
+          e,
+          this.userMessageAppended ? void 0 : {
+            role: "user",
+            content: input,
+            ...attachments ? { attachments } : {}
+          }
+        );
+      }
+      throw e;
+    }
+  }
+  async runOrchestratedTurn(input, attachments) {
     this.cancelled = false;
+    this.userMessageAppended = false;
     const history = this.chatDriver.getHistory();
     this.dispatchEvent(
       new CustomEvent("history-updated", {
@@ -5128,6 +5379,7 @@ var OrchestratingDriver = class extends EventTarget {
     let handoffs = 0;
     let handoffSummary = "";
     let remainingTask = "";
+    let lastResult;
     while (true) {
       if (this.cancelled) break;
       await this.applyAgent(currentAgent);
@@ -5136,8 +5388,10 @@ var OrchestratingDriver = class extends EventTarget {
         const contextPrimer = handoffSummary ? [{ role: "user", content: `[Context from previous agent]: ${handoffSummary}` }] : [];
         result = await this.chatDriver.continueFromHistory(contextPrimer);
       } else {
+        this.userMessageAppended = true;
         result = await this.chatDriver.sendMessage(input, attachments);
       }
+      lastResult = result;
       if (this.chatDriver.getAgentReleaseRequested()) {
         await this.releaseActiveAgent();
         break;
@@ -5159,7 +5413,7 @@ var OrchestratingDriver = class extends EventTarget {
       this.dispatchEvent(new CustomEvent("orchestrating-start"));
       currentAgent = await this.classify(remainingTask, updatedHistory);
     }
-    return { reason: "done" };
+    return lastResult?.reason === "done" ? lastResult : { reason: "done" };
   }
   async continueFromHistory(transientPrimer) {
     return this.chatDriver.continueFromHistory(transientPrimer);
@@ -5342,6 +5596,7 @@ ${recentMessages}` : ""}`;
         }
       }
     };
+    let routedNoMatch = false;
     for (let attempt = 0; attempt <= this.classifierRetries; attempt += 1) {
       try {
         const options = {
@@ -5361,8 +5616,10 @@ ${recentMessages}` : ""}`;
         if (index >= 0 && index < this.specialists.length) {
           return this.specialists[index];
         }
+        routedNoMatch = true;
         break;
       } catch (e) {
+        if (e instanceof BudgetExhaustedError) throw e;
         logger2.warn(`OrchestratingDriver: classifier attempt ${attempt + 1} failed:`, e);
         if (attempt === this.classifierRetries) {
           logger2.error("OrchestratingDriver: classifier failed after all retries, using fallback");
@@ -5370,10 +5627,12 @@ ${recentMessages}` : ""}`;
       }
     }
     if (this.fallback) return this.fallback;
-    const specialistNames = this.specialists.map((s) => s.name).join(", ");
-    this.appendInlineMessage(
-      `I'm not sure how to help with that. I can assist with: ${specialistNames}.`
-    );
+    if (routedNoMatch) {
+      const specialistNames = this.specialists.map((s) => s.name).join(", ");
+      this.appendInlineMessage(
+        `I'm not sure how to help with that. I can assist with: ${specialistNames}.`
+      );
+    }
     return this.specialists[0];
   }
   /**