@genesislcap/ai-assistant 15.6.2 → 15.7.0

package/dist/esm/components/chat-driver/chat-driver.test.js

@@ -1,5 +1,5 @@
 import { __awaiter } from "tslib";
-import { isChatToolCallUnknown, MalformedFunctionCallError, ResponseTruncatedError, } from '@genesislcap/foundation-ai';
+import { BudgetExhaustedError, DEFAULT_BUDGET_EXHAUSTED_MESSAGE, isChatToolCallUnknown, MalformedFunctionCallError, ResponseTruncatedError, } from '@genesislcap/foundation-ai';
 import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
 import { AgenticActivityBus } from '../../channel/ai-activity-bus';
 import { clearMetaEventRegistry, getMetaEvents } from '../../state/debug-event-log';
@@ -1854,6 +1854,12 @@ const truncatedProvider = () => ({
         throw new ResponseTruncatedError('test-model', 1024, 1024, ['noop']);
     }),
 });
+/** A provider refused for budget (deterministic, terminal — must not retry). */
+const budgetExhaustedProvider = () => ({
+    chat: () => __awaiter(void 0, void 0, void 0, function* () {
+        throw new BudgetExhaustedError('Anthropic', 25, 25.4, 'AI budget exhausted');
+    }),
+});
 /** A provider that throws a generic error (the sendMessage catch-all → 'exception'). */
 const throwingProvider = () => ({
     chat: () => __awaiter(void 0, void 0, void 0, function* () {
@@ -1943,4 +1949,461 @@ outcome('a clean turn leaves the legacy shape byte-unchanged (no failureReason)'
     assert.not.ok(getMetaEvents('outcome-ok').some((e) => e.type === 'turn.error'), 'a clean turn records no turn.error');
     cap.stop();
 }));
+// ── Budget exhaustion (GENC-1464) ──────────────────────────────────────────────
+outcome('budget-exhausted surfaces at both seams', () => __awaiter(void 0, void 0, void 0, function* () {
+    yield assertSurfacesReason('budget', budgetExhaustedProvider(), 'budget-exhausted');
+}));
+outcome('a budget wall is terminal — no transient retry, and actionable copy', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d;
+    clearMetaEventRegistry();
+    let calls = 0;
+    const provider = {
+        chat: () => __awaiter(void 0, void 0, void 0, function* () {
+            calls += 1;
+            throw new BudgetExhaustedError('Anthropic', 25, 25.4);
+        }),
+        // Resolvable vendor, so the per-vendor fields below are exercised.
+        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return ({ provider: 'anthropic', model: 'test-model' }); }),
+    };
+    const config = agent({
+        name: 'Static',
+        toolDefinitions: [def('noop')],
+        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
+    });
+    const driver = makeDriver(config, provider, 'outcome-budget-once', outcomeBus);
+    const cap = captureLoopEnd();
+    const result = yield driver.sendMessage('go');
+    // The whole point of the typed branch: it sits BEFORE the transient-retry
+    // catch, so the driver must not burn MAX_SETUP_TRANSPORT_RETRIES attempts
+    // against a wall that no retry can clear.
+    assert.is(calls, 1, 'a budget wall is not retried — exactly one model call');
+    assert.is(result.reason === 'done' ? result.failureReason : undefined, 'budget-exhausted', 'the turn ends with the budget-exhausted failure reason');
+    // The figures now reach the CALLER, not just the debug log — this is what lets
+    // the element render "$25.40 of $25" in its banner without catching the
+    // transport error itself.
+    const budget = result.reason === 'done' ? result.budget : undefined;
+    assert.is(budget === null || budget === void 0 ? void 0 : budget.budgetUsd, 25);
+    assert.is(budget === null || budget === void 0 ? void 0 : budget.spentUsd, 25.4);
+    assert.is(budget === null || budget === void 0 ? void 0 : budget.vendorLabel, 'Anthropic');
+    // The bus detail carries the resolved vendor beside the reason.
+    assert.is(cap.detail().failureReason, 'budget-exhausted');
+    assert.is(cap.detail().vendor, 'anthropic');
+    cap.stop();
+    const last = driver.getHistory().at(-1);
+    assert.ok((last === null || last === void 0 ? void 0 : last.role) === 'assistant', 'turn ends with an assistant message');
+    // Identity, not substrings: the transcript bubble and the element's blocked
+    // banner now read from one shared const, and this is what pins them together.
+    assert.is(last.content, DEFAULT_BUDGET_EXHAUSTED_MESSAGE);
+    assert.not.ok(last.content.includes('something went wrong'), 'must not fall through to the generic apology');
+    // The budget figures ride the debug-log entry so a support ticket can show them.
+    const err = getMetaEvents('outcome-budget-once').find((e) => e.type === 'turn.error');
+    assert.is((_a = err.detail) === null || _a === void 0 ? void 0 : _a.budgetUsd, 25);
+    assert.is((_b = err.detail) === null || _b === void 0 ? void 0 : _b.spentUsd, 25.4);
+    // The registry ALIAS and the VENDOR are different things; record both.
+    assert.is((_c = err.detail) === null || _c === void 0 ? void 0 : _c.provider, 'test');
+    assert.is((_d = err.detail) === null || _d === void 0 ? void 0 : _d.vendor, 'anthropic');
+}));
+outcome('a non-budget failure emits the historical detail shape, with no vendor', () => __awaiter(void 0, void 0, void 0, function* () {
+    // Back-compat for subscribers that structurally compare the `tool-loop-end`
+    // detail: only a budget failure grew a field.
+    clearMetaEventRegistry();
+    const config = agent({
+        name: 'Static',
+        toolDefinitions: [def('noop')],
+        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
+    });
+    const driver = makeDriver(config, throwingProvider(), 'outcome-vendor-compat', outcomeBus);
+    const cap = captureLoopEnd();
+    yield driver.sendMessage('go');
+    assert.equal(cap.detail(), { failureReason: 'exception' }, 'no vendor key was added');
+    cap.stop();
+}));
+outcome('a 402 with no figures still carries the vendor that refused it', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    // The regression this pins: the driver used to drop the ENTIRE budget object
+    // when both figures were absent, and `vendorLabel` — the authoritative
+    // attribution source — went with it. The element then fell back to the
+    // driver's last-resolved provider, i.e. the PREVIOUS turn's vendor, and walled
+    // the wrong one. Three live shapes arrive here with no figures: a bare gateway
+    // 402, a code-only body, and the framed err frame whose figures are `null`.
+    clearMetaEventRegistry();
+    const provider = {
+        chat: () => __awaiter(void 0, void 0, void 0, function* () {
+            throw new BudgetExhaustedError('Anthropic');
+        }),
+    };
+    const config = agent({
+        name: 'Static',
+        toolDefinitions: [def('noop')],
+        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
+    });
+    const driver = makeDriver(config, provider, 'outcome-budget-nofigures', outcomeBus);
+    const cap = captureLoopEnd();
+    const result = yield driver.sendMessage('go');
+    const budget = result.reason === 'done' ? result.budget : undefined;
+    assert.ok(budget, 'a figure-less wall still reports who refused it');
+    assert.is(budget.vendorLabel, 'Anthropic');
+    assert.is(budget.vendor, 'anthropic');
+    // Still no figures — the element reads their ABSENCE as "leave any host-set
+    // banner copy alone", so they must not be invented.
+    assert.is(budget.budgetUsd, undefined);
+    assert.is(budget.spentUsd, undefined);
+    // Both seams, since the bus one lands first and wins the latch.
+    assert.is((_a = cap.detail().budget) === null || _a === void 0 ? void 0 : _a.vendor, 'anthropic');
+    cap.stop();
+    assert.is(result.reason === 'done' ? result.failureReason : undefined, 'budget-exhausted');
+}));
+outcome('a wall with nothing to report at all still omits the budget key', () => __awaiter(void 0, void 0, void 0, function* () {
+    // The other direction: `budget` is present when there is something to say and
+    // absent when there is not, so presence keeps meaning something. No figures AND
+    // an unclaimed label leaves nothing to carry — and the element's fail-safe
+    // (block everything) is the correct outcome for an unattributable wall.
+    clearMetaEventRegistry();
+    const provider = {
+        chat: () => __awaiter(void 0, void 0, void 0, function* () {
+            throw new BudgetExhaustedError('Acme AI');
+        }),
+    };
+    const config = agent({
+        name: 'Static',
+        toolDefinitions: [def('noop')],
+        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
+    });
+    const driver = makeDriver(config, provider, 'outcome-budget-nothing', outcomeBus);
+    const result = yield driver.sendMessage('go');
+    assert.not.ok('budget' in result, 'nothing reportable → no budget key');
+    assert.is(result.reason === 'done' ? result.failureReason : undefined, 'budget-exhausted');
+}));
+outcome('a figure-less wall attributes to the refusing transport, not the last turn', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    // The exact failure: turn 1 runs on Gemini, turn 2's request is refused by
+    // Anthropic with a figure-less 402. `lastResolvedProvider` still says `gemini`,
+    // so the pre-fix driver reported Gemini and the user was told to switch to the
+    // vendor that had actually run out.
+    clearMetaEventRegistry();
+    let walled = false;
+    const provider = {
+        chat: () => __awaiter(void 0, void 0, void 0, function* () {
+            if (!walled) {
+                walled = true;
+                return { role: 'assistant', content: 'first turn, on Gemini' };
+            }
+            throw new BudgetExhaustedError('Anthropic');
+        }),
+    };
+    // The registry resolves to Gemini, so `lastResolvedProvider` is `gemini` by the
+    // time the Anthropic wall lands — the disagreement has to be seeded to prove
+    // which source is believed.
+    const registry = {
+        get: () => provider,
+        default: () => provider,
+        defaultName: () => 'test',
+        names: () => ['test'],
+        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return ({ provider: 'gemini', model: 'gemini-test' }); }),
+        listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
+    };
+    const driver = new ChatDriver(registry, {
+        sessionKey: 'outcome-budget-stale-vendor',
+        activityBus: outcomeBus,
+    });
+    driver.applyAgent(agent({ name: 'Static', toolDefinitions: [def('noop')], toolHandlers: {} }));
+    yield driver.sendMessage('one');
+    const result = yield driver.sendMessage('two');
+    const budget = result.reason === 'done' ? result.budget : undefined;
+    assert.is(budget === null || budget === void 0 ? void 0 : budget.vendor, 'anthropic', 'the transport that said no, not the one before it');
+    const err = getMetaEvents('outcome-budget-stale-vendor').find((e) => e.type === 'turn.error');
+    assert.is((_a = err.detail) === null || _a === void 0 ? void 0 : _a.vendor, 'anthropic', 'and the debug log agrees');
+}));
+outcome("the proxy's own `vendor` rescues an unclaimed transport label", () => __awaiter(void 0, void 0, void 0, function* () {
+    // A multiplexing or white-labelled gateway fronts several upstreams behind one
+    // transport, so its static label names none of them. The 402's `vendor` is then
+    // the only thing that knows which pot was actually booked against — second
+    // opinion, never first: the transport's own label still wins where it resolves.
+    clearMetaEventRegistry();
+    const provider = {
+        chat: () => __awaiter(void 0, void 0, void 0, function* () {
+            throw new BudgetExhaustedError('Acme AI', undefined, undefined, undefined, {
+                serverVendor: 'Gemini',
+            });
+        }),
+    };
+    const config = agent({
+        name: 'Static',
+        toolDefinitions: [def('noop')],
+        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
+    });
+    const driver = makeDriver(config, provider, 'outcome-budget-server-vendor', outcomeBus);
+    const result = yield driver.sendMessage('go');
+    const budget = result.reason === 'done' ? result.budget : undefined;
+    assert.is(budget === null || budget === void 0 ? void 0 : budget.vendorLabel, 'Acme AI', 'the transport label is reported verbatim');
+    assert.is(budget === null || budget === void 0 ? void 0 : budget.vendor, 'gemini', 'and attribution still lands');
+}));
+outcome("the proxy's `otherVendorAvailable` verdict reaches both seams", () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    // The one fact the element cannot re-derive: registry membership says which
+    // vendors EXIST, never which still have budget. It has to survive the trip.
+    clearMetaEventRegistry();
+    const provider = {
+        chat: () => __awaiter(void 0, void 0, void 0, function* () {
+            throw new BudgetExhaustedError('Anthropic', 25, 25, undefined, {
+                otherVendorAvailable: false,
+            });
+        }),
+    };
+    const config = agent({
+        name: 'Static',
+        toolDefinitions: [def('noop')],
+        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
+    });
+    const driver = makeDriver(config, provider, 'outcome-budget-other-vendor', outcomeBus);
+    const cap = captureLoopEnd();
+    const result = yield driver.sendMessage('go');
+    assert.is(result.reason === 'done' ? (_a = result.budget) === null || _a === void 0 ? void 0 : _a.otherVendorAvailable : undefined, false, 'the return-value seam');
+    assert.is((_b = cap.detail().budget) === null || _b === void 0 ? void 0 : _b.otherVendorAvailable, false, 'and the bus seam, which lands first and wins the latch');
+    cap.stop();
+}));
+outcome('a host-supplied budgetExhaustedMessage replaces the transcript copy', () => __awaiter(void 0, void 0, void 0, function* () {
+    clearMetaEventRegistry();
+    const provider = {
+        chat: () => __awaiter(void 0, void 0, void 0, function* () {
+            throw new BudgetExhaustedError('Anthropic', 25, 25.4);
+        }),
+    };
+    const driver = new ChatDriver(makeRegistry(provider), {
+        sessionKey: 'outcome-budget-custom',
+        activityBus: outcomeBus,
+        budgetExhaustedMessage: 'Contact ops@acme.com',
+    });
+    driver.applyAgent(agent({ name: 'Static', toolDefinitions: [def('noop')], toolHandlers: {} }));
+    yield driver.sendMessage('go');
+    // The banner was already overridable; without this seam a white-labelled host
+    // got its own copy in the banner and 'contact Genesis' directly below it.
+    assert.is(driver.getHistory().at(-1).content, 'Contact ops@acme.com');
+}));
+// ── A sub-agent's wall is terminal for the parent too (GENC-1464) ──────────────
+// `SubAgentFailureReason.budget_exhausted` is documented as "terminal for the
+// parent too". Nothing parent-side read it, so the parent's tool loop appended
+// the failed outcome as a tool result and called the model again — into the same
+// wall. With N batched delegations that was N doomed children AND a doomed parent
+// call, and the element's `failureReason === 'budget-exhausted'` latch never fired.
+/** A sub-agent whose own turn is refused for budget; the parent's turns are not. */
+const parentOkChildWalled = () => {
+    let parentCalls = 0;
+    return {
+        parentCalls: () => parentCalls,
+        provider: {
+            chat: (_h, _u, options) => __awaiter(void 0, void 0, void 0, function* () {
+                var _a;
+                const names = ((_a = options === null || options === void 0 ? void 0 : options.tools) !== null && _a !== void 0 ? _a : []).map((t) => t.name);
+                if (names.includes('delegate')) {
+                    parentCalls += 1;
+                    return callsTool('delegate', `d${parentCalls}`);
+                }
+                throw new BudgetExhaustedError('Anthropic', 25, 25.4);
+            }),
+        },
+    };
+};
+const walledWorker = () => agent({
+    name: 'worker',
+    toolDefinitions: [def('finish')],
+    toolHandlers: { finish: () => __awaiter(void 0, void 0, void 0, function* () { return 'x'; }) },
+});
+outcome('a sub-agent budget wall ends the parent turn without another model call', () => __awaiter(void 0, void 0, void 0, function* () {
+    clearMetaEventRegistry();
+    const { parentCalls, provider } = parentOkChildWalled();
+    const parent = delegatingParent(walledWorker(), () => undefined);
+    const driver = makeDriver(parent, provider, 'outcome-subagent-budget', outcomeBus);
+    const result = yield driver.sendMessage('go');
+    assert.is(parentCalls(), 1, 'the parent never calls the model again after the wall');
+    assert.is(result.reason === 'done' ? result.failureReason : undefined, 'budget-exhausted');
+    assert.is(driver.getHistory().at(-1).content, DEFAULT_BUDGET_EXHAUSTED_MESSAGE);
+}));
+outcome("a sub-agent's wall is attributed to the CHILD's vendor, not the parent's", () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    // A sub-agent can sit on a different vendor from its parent (`applyAgent` reads
+    // `config.provider`). The wall reaches the parent only as a tool result, so
+    // while the parent carried nothing but a boolean it reported
+    // `lastResolvedProvider` — its own vendor, i.e. precisely the one that did NOT
+    // refuse. Under a two-vendor registry that walls Gemini because an Anthropic
+    // child 402'd, and the host then blocks a composer that still had headroom.
+    clearMetaEventRegistry();
+    const { provider } = parentOkChildWalled();
+    // Seeded disagreement: the registry resolves Gemini, so the parent's
+    // `lastResolvedProvider` is `gemini` while the child is refused by Anthropic.
+    const registry = {
+        get: () => provider,
+        default: () => provider,
+        defaultName: () => 'test',
+        names: () => ['test'],
+        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return ({ provider: 'gemini', model: 'gemini-test' }); }),
+        listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
+    };
+    const driver = new ChatDriver(registry, {
+        sessionKey: 'outcome-subagent-budget-vendor',
+        activityBus: outcomeBus,
+    });
+    driver.applyAgent(delegatingParent(walledWorker(), () => undefined));
+    const result = yield driver.sendMessage('go');
+    const budget = result.reason === 'done' ? result.budget : undefined;
+    assert.is(budget === null || budget === void 0 ? void 0 : budget.vendor, 'anthropic', "the child's refusing vendor survives the hop");
+    assert.is(budget === null || budget === void 0 ? void 0 : budget.budgetUsd, 25, "and so do the child's figures");
+    assert.is(budget === null || budget === void 0 ? void 0 : budget.spentUsd, 25.4);
+    const err = getMetaEvents('outcome-subagent-budget-vendor').find((e) => e.type === 'turn.error');
+    assert.is((_a = err.detail) === null || _a === void 0 ? void 0 : _a.vendor, 'anthropic', 'and the debug log agrees');
+}));
+outcome('N batched sub-agent calls still produce at most one doomed parent call', () => __awaiter(void 0, void 0, void 0, function* () {
+    clearMetaEventRegistry();
+    let parentCalls = 0;
+    const provider = {
+        chat: (_h, _u, options) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const names = ((_a = options === null || options === void 0 ? void 0 : options.tools) !== null && _a !== void 0 ? _a : []).map((t) => t.name);
+            if (names.includes('delegate')) {
+                parentCalls += 1;
+                return {
+                    role: 'assistant',
+                    content: '',
+                    toolCalls: [
+                        { id: 'd1', name: 'delegate', args: {} },
+                        { id: 'd2', name: 'delegate', args: {} },
+                    ],
+                };
+            }
+            throw new BudgetExhaustedError('Anthropic', 25, 25.4);
+        }),
+    };
+    const parent = delegatingParent(walledWorker(), () => undefined);
+    const driver = makeDriver(parent, provider, 'outcome-subagent-budget-batched', outcomeBus);
+    const result = yield driver.sendMessage('go');
+    assert.is(parentCalls, 1);
+    assert.is(result.reason === 'done' ? result.failureReason : undefined, 'budget-exhausted');
+}));
+outcome('a non-terminal sub-agent failure still lets the parent continue', () => __awaiter(void 0, void 0, void 0, function* () {
+    // The short-circuit is scoped strictly to the budget reason — every other
+    // SubAgentFailureReason is something the parent can legitimately recover from.
+    clearMetaEventRegistry();
+    let parentCalls = 0;
+    const provider = {
+        chat: (_h, _u, options) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const names = ((_a = options === null || options === void 0 ? void 0 : options.tools) !== null && _a !== void 0 ? _a : []).map((t) => t.name);
+            if (names.includes('delegate')) {
+                parentCalls += 1;
+                return parentCalls === 1
+                    ? callsTool('delegate', 'd1')
+                    : { role: 'assistant', content: 'carried on regardless' };
+            }
+            // The child answers in free text without calling its completion tool →
+            // `max_iterations`, a recoverable failure.
+            return { role: 'assistant', content: 'no structured result' };
+        }),
+    };
+    let captured;
+    const parent = delegatingParent(walledWorker(), (o) => {
+        captured = o;
+    });
+    const driver = makeDriver(parent, provider, 'outcome-subagent-nonterminal', outcomeBus);
+    const result = yield driver.sendMessage('go');
+    assert.equal(captured, { ok: false, reason: 'max_iterations' });
+    assert.is(parentCalls, 2, 'the parent loop kept running');
+    assert.is(result.reason === 'done' ? result.failureReason : undefined, undefined);
+}));
+outcome("a later unattributable child wall does not erase the first child's attribution", () => __awaiter(void 0, void 0, void 0, function* () {
+    // Batched delegations: child A is refused by Anthropic WITH attribution,
+    // child B by a transport whose label no vendor claims (figure-less 402 → no
+    // BudgetDetail at all). A plain assignment let B's `undefined` clobber A's
+    // attribution, and the fallback then reported the PARENT's vendor — under a
+    // Gemini-resolving registry, precisely the vendor that did not refuse.
+    clearMetaEventRegistry();
+    let childCalls = 0;
+    const provider = {
+        chat: (_h, _u, options) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const names = ((_a = options === null || options === void 0 ? void 0 : options.tools) !== null && _a !== void 0 ? _a : []).map((t) => t.name);
+            if (names.includes('delegate')) {
+                return {
+                    role: 'assistant',
+                    content: '',
+                    toolCalls: [
+                        { id: 'd1', name: 'delegate', args: {} },
+                        { id: 'd2', name: 'delegate', args: {} },
+                    ],
+                };
+            }
+            childCalls += 1;
+            throw childCalls === 1
+                ? new BudgetExhaustedError('Anthropic', 25, 25.4)
+                : new BudgetExhaustedError('Acme AI'); // unclaimed label, no figures
+        }),
+    };
+    const registry = {
+        get: () => provider,
+        default: () => provider,
+        defaultName: () => 'test',
+        names: () => ['test'],
+        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return ({ provider: 'gemini', model: 'gemini-test' }); }),
+        listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
+    };
+    const driver = new ChatDriver(registry, {
+        sessionKey: 'outcome-subagent-budget-clobber',
+        activityBus: outcomeBus,
+    });
+    driver.applyAgent(delegatingParent(walledWorker(), () => undefined));
+    const result = yield driver.sendMessage('one');
+    const budget = result.reason === 'done' ? result.budget : undefined;
+    assert.is(budget === null || budget === void 0 ? void 0 : budget.vendor, 'anthropic', "child A's attribution survives child B's blank wall");
+}));
+outcome('a fully unattributable child wall degrades vendor-agnostic, never to the parent', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    // When NO child wall carries attribution, the honest event is vendor-less.
+    // Falling back to `lastResolvedProvider` named the parent's vendor — walling
+    // BOTH vendors (the child's via its own tool-loop-end, the parent's via this
+    // one) and deriving `blocked` over headroom that still existed.
+    clearMetaEventRegistry();
+    const events = [];
+    const bus = new AgenticActivityBus();
+    bus.subscribe('tool-loop-end', (d) => events.push(d));
+    // The provider must carry its own `getStatus` — `lastResolvedProvider` is
+    // stamped from the PROVIDER's status, not the registry's, and a status-less
+    // mock leaves it unset, which lets the buggy fallback pass vacuously (there
+    // is no wrong vendor to fall back to).
+    const provider = {
+        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return ({ provider: 'gemini', model: 'gemini-test' }); }),
+        chat: (_h, _u, options) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const names = ((_a = options === null || options === void 0 ? void 0 : options.tools) !== null && _a !== void 0 ? _a : []).map((t) => t.name);
+            if (names.includes('delegate'))
+                return callsTool('delegate', 'd1');
+            // The CHILD's turn: refused by a transport whose label no vendor claims.
+            throw new BudgetExhaustedError('Acme AI'); // no figures either
+        }),
+    };
+    const registry = {
+        get: () => provider,
+        default: () => provider,
+        defaultName: () => 'test',
+        names: () => ['test'],
+        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return ({ provider: 'gemini', model: 'gemini-test' }); }),
+        listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
+    };
+    const driver = new ChatDriver(registry, {
+        sessionKey: 'outcome-subagent-budget-agnostic',
+        activityBus: bus,
+    });
+    driver.applyAgent(delegatingParent(walledWorker(), () => undefined));
+    yield driver.sendMessage('go');
+    // The PARENT's loop-end is the last one on the bus. It must carry the
+    // failure without naming the parent's (gemini) vendor.
+    const parentEnd = events.at(-1);
+    assert.is(parentEnd === null || parentEnd === void 0 ? void 0 : parentEnd.failureReason, 'budget-exhausted');
+    assert.is(parentEnd === null || parentEnd === void 0 ? void 0 : parentEnd.vendor, undefined, 'no vendor is better than the wrong vendor');
+    // The CHILD's folded-in turn.error legitimately carries its own best-effort
+    // self-attribution (its resolved provider really did make the refused call);
+    // the record this fix governs is the PARENT's short-circuit, tagged
+    // `via: 'sub-agent'`.
+    const err = getMetaEvents('outcome-subagent-budget-agnostic').find((e) => { var _a; return e.type === 'turn.error' && ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.via) === 'sub-agent'; });
+    assert.ok(err, "the parent's short-circuit recorded the wall");
+    assert.is((_a = err.detail) === null || _a === void 0 ? void 0 : _a.vendor, undefined, 'and named no vendor rather than the wrong one');
+}));
 outcome.run();