@genesislcap/ai-assistant 15.19.0 → 15.19.1

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

@@ -1,137 +0,0 @@
-import { __awaiter } from "tslib";
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-// Side-effect import — MUST come before `./chat-driver` so the driver subclasses
-// jsdom's EventTarget rather than Node's native one. Mirrors chat-driver.test.ts.
-import './align-event-globals';
-import { ChatDriver } from './chat-driver';
-// ---------------------------------------------------------------------------
-// Per-turn `thinkingPolicy` resolution.
-//
-// The cost case for this option is the SHAPE of a tool loop, not a single call: the
-// opening turn is a real decision and worth reasoning over, while the iterations that
-// follow mostly pick the next tool from a narrow set — and on a thinking model each of
-// those bills reasoning at the full output rate. That saving only exists if the
-// resolver runs per iteration, so these tests assert the sequence across a loop, not
-// just that one value arrives.
-//
-// The other half is the undefined case. Every agent written before this option leaves
-// it unset, and a resolver may answer `undefined` on any given turn; both must reach
-// the transport as `undefined` so the model keeps its own default. `undefined` reaching
-// the wire as `'off'` would be a silent capability regression, and as `'auto'` a silent
-// bill increase — so it is asserted explicitly rather than assumed.
-// ---------------------------------------------------------------------------
-/** Captures the policy seen on each model call; calls one tool, then finishes. */
-const capturingProvider = () => {
-    const seen = [];
-    let turns = 0;
-    return {
-        seen,
-        chat: (_history, _userMessage, options) => __awaiter(void 0, void 0, void 0, function* () {
-            seen.push(options === null || options === void 0 ? void 0 : options.thinkingPolicy);
-            turns += 1;
-            // Two tool calls, so the loop runs three model calls in total — enough for a
-            // per-turn resolver to say something different on the later ones.
-            if (turns <= 2) {
-                return {
-                    role: 'assistant',
-                    content: '',
-                    toolCalls: [{ id: `t${turns}`, name: 'step', args: {} }],
-                };
-            }
-            return { role: 'assistant', content: 'done' };
-        }),
-    };
-};
-const makeRegistry = (provider) => ({
-    get: () => provider,
-    default: () => provider,
-    defaultName: () => 'test',
-    names: () => ['test'],
-    getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
-    listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
-});
-const agent = (overrides) => (Object.assign({ name: 'worker', description: 'test agent', toolDefinitions: [
-        { name: 'step', description: 'step', parameters: { type: 'object', properties: {} } },
-    ], toolHandlers: { step: () => __awaiter(void 0, void 0, void 0, function* () { return 'stepped'; }) } }, overrides));
-/** Run one user turn through a driver carrying `config`, and return the policies seen. */
-const policiesFor = (config) => __awaiter(void 0, void 0, void 0, function* () {
-    const provider = capturingProvider();
-    const driver = new ChatDriver(makeRegistry(provider), {
-        maxToolIterations: 10,
-        maxFoldOperations: 5,
-        sessionKey: '',
-    });
-    driver.applyAgent(agent(config));
-    yield driver.sendMessage('go');
-    return provider.seen;
-});
-const suite = createLogicSuite('ChatDriver thinkingPolicy');
-suite('leaves the policy undefined when the agent does not set one', () => __awaiter(void 0, void 0, void 0, function* () {
-    // The compatibility case: every existing agent. Undefined must reach the transport
-    // as undefined so each model keeps its own default posture — not silently coerced
-    // to 'off' (a capability regression) or 'auto' (a bill increase).
-    const seen = yield policiesFor({});
-    assert.ok(seen.length >= 3, `expected a multi-call loop, got ${seen.length}`);
-    assert.equal(seen.filter((p) => p !== undefined), [], 'no turn invents a policy');
-}));
-suite('applies a static policy to every turn of the loop', () => __awaiter(void 0, void 0, void 0, function* () {
-    const seen = yield policiesFor({ thinkingPolicy: 'off' });
-    assert.ok(seen.length >= 3);
-    assert.equal([...new Set(seen)], ['off'], 'a static value is not just a first-turn setting');
-}));
-suite('pins the resolved policy for the whole tool loop', () => __awaiter(void 0, void 0, void 0, function* () {
-    // A tool-use loop is ONE assistant turn and Anthropic requires a single thinking mode
-    // for its duration. Toggling part-way does not error — the API silently disables
-    // thinking for that request and strips blocks that would leave the turn structure
-    // invalid, so an 'auto' -> 'off' switch loses the continuity the opening call
-    // established and 'off' -> 'auto' never delivers the reasoning asked for. It also
-    // invalidates the prompt cache, costing more than the reasoning it meant to save.
-    //
-    // So a resolver that changes its mind mid-loop must NOT be honoured mid-loop. This
-    // asserts the opposite of what it looks like it should: the later values are ignored.
-    let call = 0;
-    const seen = yield policiesFor({
-        thinkingPolicy: () => {
-            call += 1;
-            return call === 1 ? 'auto' : 'off';
-        },
-    });
-    assert.ok(seen.length >= 3, `expected a multi-call loop, got ${seen.length}`);
-    assert.equal([...new Set(seen)], ['auto'], 'the first call decides; later resolutions do not take effect until the next user turn');
-}));
-suite('re-resolves on the next user turn', () => __awaiter(void 0, void 0, void 0, function* () {
-    // The flip side: pinning is per turn, not for the driver's lifetime, so a state change
-    // between turns still lands.
-    const provider = capturingProvider();
-    const driver = new ChatDriver(makeRegistry(provider), {
-        maxToolIterations: 10,
-        maxFoldOperations: 5,
-        sessionKey: '',
-    });
-    let turn = 0;
-    driver.applyAgent(agent({
-        thinkingPolicy: () => (turn === 0 ? 'auto' : 'off'),
-    }));
-    yield driver.sendMessage('go');
-    const firstTurn = [...provider.seen];
-    turn = 1;
-    yield driver.sendMessage('again');
-    const secondTurn = provider.seen.slice(firstTurn.length);
-    assert.equal([...new Set(firstTurn)], ['auto'], 'turn one holds its posture');
-    assert.equal([...new Set(secondTurn)], ['off'], 'turn two picks up the new one');
-}));
-suite('passes undefined through when the resolver declines to choose', () => __awaiter(void 0, void 0, void 0, function* () {
-    // A resolver may answer on some turns and not others. `undefined` is its third answer —
-    // "leave this model alone" — and must not be normalised into a value. Asserted across
-    // the whole loop because the first call's answer is the one that gets pinned.
-    const seen = yield policiesFor({ thinkingPolicy: () => undefined });
-    assert.ok(seen.length >= 3);
-    assert.equal(seen.filter((p) => p !== undefined), [], 'declining is not the same as choosing');
-}));
-suite('awaits an async resolver', () => __awaiter(void 0, void 0, void 0, function* () {
-    const seen = yield policiesFor({
-        thinkingPolicy: () => __awaiter(void 0, void 0, void 0, function* () { return 'off'; }),
-    });
-    assert.equal([...new Set(seen)], ['off'], 'a promise is resolved, not passed through');
-}));
-suite.run();

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

@@ -1,200 +0,0 @@
-import { __awaiter } from "tslib";
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { sumUsage } from '../../utils/sum-usage';
-import { usageRows } from '../../utils/usage-rows';
-// Side-effect import — MUST come before `./chat-driver` so the driver subclasses
-// jsdom's EventTarget rather than Node's native one. Mirrors chat-driver.test.ts.
-import './align-event-globals';
-import { ChatDriver } from './chat-driver';
-// ---------------------------------------------------------------------------
-// Sub-agent trace capture when ONE tool call invokes SEVERAL sub-agents.
-//
-// The capture slot used to be a single `{ trace?: ChatMessage[] }` per tool call,
-// assigned by each `requestSubAgent`. That covers N tool calls × 1 sub-agent — the
-// case its docblock named — but not 1 tool call × N sub-agents, which is what a
-// code-driven scheduler or a retry produces. All but the last trace was dropped, so
-// those children ran, were billed, and then had no record in history.
-//
-// The failure was invisible to every existing check: `sumUsage` and `usageRows` both
-// recurse into `subAgentTrace`, so they summed a truncated input and still reconciled
-// with each other perfectly. Measured at 1 of 7 traces kept on a seven-way fan-out,
-// ~2.3x under the true cost.
-//
-// These tests assert the traces SURVIVE, which is upstream of any cost assertion.
-// ---------------------------------------------------------------------------
-/** Answers by rule: concurrent children under one turn make a FIFO queue nondeterministic. */
-const ruleProvider = () => {
-    let parentTurns = 0;
-    return {
-        chat: (_history, _userMessage, options) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const tools = ((_a = options === null || options === void 0 ? void 0 : options.tools) !== null && _a !== void 0 ? _a : []).map((t) => t.name);
-            // Child turn: finishes via its completion tool, and reports usage so the
-            // reconciliation assertions have something to add up.
-            if (tools.includes('work')) {
-                return {
-                    role: 'assistant',
-                    content: '',
-                    model: 'claude-sonnet-5',
-                    cost: 0.01,
-                    inputTokens: 100,
-                    outputTokens: 20,
-                    toolCalls: [{ id: 'w1', name: 'work', args: {} }],
-                };
-            }
-            if (tools.includes('delegate') && parentTurns === 0) {
-                parentTurns += 1;
-                return {
-                    role: 'assistant',
-                    content: '',
-                    model: 'claude-sonnet-5',
-                    cost: 0.02,
-                    inputTokens: 200,
-                    outputTokens: 30,
-                    toolCalls: [{ id: 'd0', name: 'delegate', args: {} }],
-                };
-            }
-            return { role: 'assistant', content: 'done', model: 'claude-sonnet-5' };
-        }),
-    };
-};
-const makeRegistry = (provider) => ({
-    get: () => provider,
-    default: () => provider,
-    defaultName: () => 'test',
-    names: () => ['test'],
-    getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
-    listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
-});
-const agent = (overrides) => (Object.assign({ description: 'test agent' }, overrides));
-/** A child that reports one unit of usage and completes. */
-const worker = (name) => agent({
-    name,
-    toolDefinitions: [
-        { name: 'work', description: 'work', parameters: { type: 'object', properties: {} } },
-    ],
-    toolHandlers: {
-        work: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            (_a = ctx.completeSubAgent) === null || _a === void 0 ? void 0 : _a.call(ctx, { ok: true });
-            return 'worked';
-        }),
-    },
-});
-/**
- * A parent whose single `delegate` tool call invokes `names` in turn — the shape a
- * code-driven scheduler produces, and the one the old single slot truncated.
- */
-const boss = (children, invoke) => agent({
-    name: 'boss',
-    subAgents: children,
-    toolDefinitions: [
-        { name: 'delegate', description: 'delegate', parameters: { type: 'object', properties: {} } },
-    ],
-    toolHandlers: {
-        delegate: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-            yield Promise.all(invoke.map((n) => ctx.requestSubAgent(n, { task: 'go' })));
-            return 'delegated';
-        }),
-    },
-});
-const run = (config) => __awaiter(void 0, void 0, void 0, function* () {
-    const driver = new ChatDriver(makeRegistry(ruleProvider()), {
-        maxToolIterations: 20,
-        maxFoldOperations: 5,
-        sessionKey: '',
-    });
-    driver.applyAgent(config);
-    yield driver.sendMessage('go');
-    return driver.getHistory();
-});
-const tracesIn = (history) => history.flatMap((m) => { var _a; return ((_a = m.toolCalls) !== null && _a !== void 0 ? _a : []).flatMap((tc) => (tc.subAgentTrace ? [tc.subAgentTrace] : [])); });
-const suite = createLogicSuite('ChatDriver sub-agent trace capture');
-// ---------------------------------------------------------------------------
-suite('keeps every trace when one tool call invokes three sub-agents', () => __awaiter(void 0, void 0, void 0, function* () {
-    const names = ['gen_a', 'gen_b', 'gen_c'];
-    const history = yield run(boss(names.map(worker), names));
-    const traces = tracesIn(history);
-    assert.is(traces.length, 1, 'one tool call, so one concatenated trace');
-    // Each child contributes at least its own assistant turn. Before the fix this was
-    // one child's worth regardless of how many ran.
-    const seen = new Set(traces[0].map((m) => m.agentName).filter(Boolean));
-    assert.equal([...seen].sort(), names, `every invoked child must appear — got ${JSON.stringify([...seen])}`);
-}));
-suite('prices every child — usageRows emits a row per child and reconciles', () => __awaiter(void 0, void 0, void 0, function* () {
-    // The reconciliation test extended to a fan-out. The single-child version passed
-    // before the fix AND after it, which is exactly why it did not catch this.
-    const names = ['gen_a', 'gen_b', 'gen_c'];
-    const history = yield run(boss(names.map(worker), names));
-    const rows = usageRows(history);
-    const childRows = rows.filter((r) => r.subAgentDepth === 1);
-    assert.is(childRows.length, names.length, 'one row per child that ran');
-    const rowTotal = rows.reduce((n, r) => { var _a, _b; return n + ((_a = r.costUsd) !== null && _a !== void 0 ? _a : 0) + ((_b = r.externalCostUsd) !== null && _b !== void 0 ? _b : 0); }, 0);
-    assert.ok(Math.abs(rowTotal - sumUsage(history).costUsd) < 1e-12, `rows ${rowTotal} vs sumUsage ${sumUsage(history).costUsd}`);
-    // Parent turn ($0.02) + three children ($0.01 each). Asserted as a number so a
-    // regression that silently drops a child fails here rather than only in the
-    // reconciliation above, which would still agree with a truncated input.
-    assert.ok(Math.abs(rowTotal - 0.05) < 1e-12, `expected 0.05, got ${rowTotal}`);
-}));
-suite('keeps both traces when the same sub-agent is invoked twice (a retry)', () => __awaiter(void 0, void 0, void 0, function* () {
-    // The retry shape: one handler, one child name, two invocations. Under the old slot
-    // the first attempt's trace was overwritten by the second.
-    const history = yield run(boss([worker('gen_a')], ['gen_a', 'gen_a']));
-    const traces = tracesIn(history);
-    assert.is(traces.length, 1);
-    const childTurns = traces[0].filter((m) => m.agentName === 'gen_a' && m.cost != null);
-    assert.is(childTurns.length, 2, 'both attempts survive, not just the last');
-    const rows = usageRows(history).filter((r) => r.subAgentDepth === 1);
-    assert.is(rows.length, 2, 'and both are priced');
-}));
-suite('keeps child traces when the parent handler throws after they ran', () => __awaiter(void 0, void 0, void 0, function* () {
-    // Children that completed were billed by the provider. If the error path drops
-    // their traces, the run under-reports exactly as the single-slot bug did — and
-    // just as silently, since `sumUsage` and `usageRows` would still agree with each
-    // other over the truncated input. PR review.
-    const names = ['gen_a', 'gen_b'];
-    const parent = agent({
-        name: 'boss',
-        subAgents: names.map(worker),
-        toolDefinitions: [
-            { name: 'delegate', description: 'delegate', parameters: { type: 'object', properties: {} } },
-        ],
-        toolHandlers: {
-            delegate: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                yield Promise.all(names.map((n) => ctx.requestSubAgent(n, { task: 'go' })));
-                throw new Error('post-processing the children failed');
-            }),
-        },
-    });
-    const history = yield run(parent);
-    const traces = tracesIn(history);
-    assert.is(traces.length, 1, 'the failed tool call still carries its trace');
-    const seen = [...new Set(traces[0].map((m) => m.agentName).filter(Boolean))].sort();
-    assert.equal(seen, names, 'both children survive the throw');
-    const childRows = usageRows(history).filter((r) => r.subAgentDepth === 1);
-    assert.is(childRows.length, 2, 'and both are still priced');
-}));
-suite('leaves subAgentTrace undefined when no sub-agent ran', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    // Presence is the signal readers key off (`usage-rows.ts`, the UI's `when(...)`),
-    // so an empty array would be a different and wrong claim.
-    const history = yield run(agent({
-        name: 'boss',
-        subAgents: [worker('gen_a')],
-        toolDefinitions: [
-            {
-                name: 'delegate',
-                description: 'delegate',
-                parameters: { type: 'object', properties: {} },
-            },
-        ],
-        toolHandlers: { delegate: () => __awaiter(void 0, void 0, void 0, function* () { return 'did it myself'; }) },
-    }));
-    for (const m of history) {
-        for (const tc of (_a = m.toolCalls) !== null && _a !== void 0 ? _a : []) {
-            assert.is(tc.subAgentTrace, undefined, 'not an empty array');
-        }
-    }
-    assert.equal(usageRows(history).filter((r) => r.subAgentDepth === 1), [], 'no child rows');
-}));
-suite.run();

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

@@ -1,268 +0,0 @@
-import { __awaiter } from "tslib";
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { clearMetaEventRegistry, getMetaEvents } from '../../state/debug-event-log';
-import { messageUsage, sumUsage } from '../../utils/sum-usage';
-// Side-effect import — MUST come before `./chat-driver` so the driver subclasses
-// jsdom's EventTarget rather than Node's native one. Mirrors chat-driver.test.ts.
-import './align-event-globals';
-import { ChatDriver } from './chat-driver';
-// ---------------------------------------------------------------------------
-// Per-call usage on the turn snapshots — the four token buckets plus USD priced
-// onto each `kind: 'turn'` entry of the exported debug log.
-//
-// The snapshot is captured BEFORE the model call (that is where the prompt, tool
-// surface and agent state line up with what the model saw), so usage has to be
-// back-filled when the response lands. Two things follow, and both are asserted
-// here: a completed call's turn agrees with the message it produced, and a call
-// that produced NO message (a blank response, retried) is still priced — that
-// spend appears nowhere in the transcript.
-// ---------------------------------------------------------------------------
-const makeRegistry = (provider) => ({
-    get: () => provider,
-    default: () => provider,
-    defaultName: () => 'test',
-    names: () => ['test'],
-    getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
-    listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
-});
-/** Answers from a queue, then ends the turn with a plain unpriced reply. */
-const scriptedProvider = (responses) => {
-    const queue = [...responses];
-    return {
-        chat: () => __awaiter(void 0, void 0, void 0, function* () { var _a; return (_a = queue.shift()) !== null && _a !== void 0 ? _a : { role: 'assistant', content: 'done' }; }),
-    };
-};
-const agent = (overrides) => (Object.assign({ description: 'test agent' }, overrides));
-const makeDriver = (config, provider) => {
-    const driver = new ChatDriver(makeRegistry(provider), {
-        maxToolIterations: 50,
-        maxFoldOperations: 5,
-        sessionKey: '',
-    });
-    driver.applyAgent(config);
-    return driver;
-};
-const def = (name) => ({
-    name,
-    description: `${name} tool`,
-    parameters: { type: 'object', properties: {} },
-});
-/** One priced response: a 1000-token prompt that was mostly a cache hit. */
-const priced = (over = {}) => (Object.assign({ role: 'assistant', content: 'answer', cost: 0.1, inputTokens: 1000, cacheReadTokens: 900, cacheWriteTokens: 50, outputTokens: 20 }, over));
-const suite = createLogicSuite('ChatDriver per-turn usage');
-suite('prices each turn snapshot with the four buckets and USD of its own call', () => __awaiter(void 0, void 0, void 0, function* () {
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([priced()]));
-    yield driver.sendMessage('go');
-    const [turn] = driver.getTurnSnapshots();
-    assert.equal(turn.usage, {
-        costUsd: 0.1,
-        // The prompt split into disjoint buckets: 1000 total, 900 read + 50 written,
-        // so 50 uncached. A reader of the log gets this without re-deriving it.
-        uncachedInputTokens: 50,
-        cacheReadTokens: 900,
-        cacheWriteTokens: 50,
-        outputTokens: 20,
-    }, 'the turn carries its own call’s usage');
-    // The turn and the message it produced are the SAME charge, so they must agree
-    // exactly — a log whose two views of one call disagree is worse than one view.
-    assert.equal(turn.usage, sumUsage(driver.getHistory()), 'turn agrees with the transcript total');
-}));
-suite('prices every model call in a tool loop separately', () => __awaiter(void 0, void 0, void 0, function* () {
-    const driver = makeDriver(agent({
-        name: 'a',
-        toolDefinitions: [def('work')],
-        toolHandlers: { work: () => __awaiter(void 0, void 0, void 0, function* () { return 'worked'; }) },
-    }), scriptedProvider([
-        priced({ content: '', cost: 0.02, toolCalls: [{ id: 'w1', name: 'work', args: {} }] }),
-        priced({ cost: 0.03 }),
-    ]));
-    yield driver.sendMessage('go');
-    const snapshots = driver.getTurnSnapshots();
-    assert.is(snapshots.length, 2, 'one snapshot per model call, not per user turn');
-    assert.equal(snapshots.map((s) => { var _a; return (_a = s.usage) === null || _a === void 0 ? void 0 : _a.costUsd; }), [0.02, 0.03]);
-}));
-suite('prices a blank response that produced no message', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    // A blank turn is billed and then discarded before the retry, so the transcript can
-    // never account for it. The snapshot is the only record — which is the whole reason
-    // usage is stamped before the empty-response branch runs.
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([
-        priced({ content: '', cost: 0.07, outputTokens: 0 }),
-        priced({ cost: 0.03 }),
-    ]));
-    yield driver.sendMessage('go');
-    const snapshots = driver.getTurnSnapshots();
-    assert.is(snapshots.length, 2, 'the retried attempt has its own snapshot');
-    assert.is((_a = snapshots[0].usage) === null || _a === void 0 ? void 0 : _a.costUsd, 0.07, 'the discarded attempt is still priced');
-    assert.is(sumUsage(driver.getHistory()).costUsd, 0.03, 'and is genuinely absent from the transcript — that is the gap the snapshot fills');
-}));
-suite('leaves usage undefined when the provider reports none', () => __awaiter(void 0, void 0, void 0, function* () {
-    // Absent, not zeroed: "this provider reports no usage" (e.g. Chrome's built-in model)
-    // must not read as a free call.
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
-    yield driver.sendMessage('go');
-    assert.is(driver.getTurnSnapshots()[0].usage, undefined);
-}));
-suite.run();
-// ---------------------------------------------------------------------------
-// The reasoning/narration/answer split must not multiply the cache buckets.
-//
-// One model response becomes up to three messages; only the last carries usage.
-// The clearing list was written when usage meant cost + input + output, so when the
-// cache buckets arrived they kept riding along on the display-only copies — and every
-// bucket aggregate (session totals, usage rows, the exported log) counted a split
-// turn's cache volume two or three times. The cost total hid it, since that comes
-// from `cost`, which WAS cleared.
-// ---------------------------------------------------------------------------
-const split = createLogicSuite('ChatDriver response split usage');
-split('counts a reasoning + answer split once, not twice', () => __awaiter(void 0, void 0, void 0, function* () {
-    const response = priced({ reasoning: 'thinking…' });
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([response]));
-    yield driver.sendMessage('go');
-    const history = driver.getHistory();
-    assert.is(history.filter((m) => m.role === 'assistant').length, 2, 'the response did split into a reasoning message and an answer');
-    assert.equal(sumUsage(history), messageUsage(response), 'the split totals exactly one call’s usage');
-    const reasoning = history.find((m) => m.category === 'reasoning');
-    assert.is(reasoning.cacheReadTokens, undefined, 'the display-only copy carries no cache volume');
-    assert.is(reasoning.cacheWriteTokens, undefined);
-}));
-split('counts a reasoning + narration + answer split once', () => __awaiter(void 0, void 0, void 0, function* () {
-    // The three-way case: content alongside a tool call is interstitial narration, so this
-    // response produces reasoning + narration + the tool-call message. Worst case for the
-    // old behaviour — cache volume counted three times.
-    const first = priced({
-        content: 'let me look that up',
-        reasoning: 'thinking…',
-        cost: 0.02,
-        toolCalls: [{ id: 'w1', name: 'work', args: {} }],
-    });
-    const driver = makeDriver(agent({
-        name: 'a',
-        toolDefinitions: [def('work')],
-        toolHandlers: { work: () => __awaiter(void 0, void 0, void 0, function* () { return 'worked'; }) },
-    }), scriptedProvider([first, priced({ cost: 0.03 })]));
-    yield driver.sendMessage('go');
-    const total = sumUsage(driver.getHistory());
-    assert.is(total.costUsd, 0.05, 'two calls, each counted once');
-    assert.is(total.cacheReadTokens, 1800, '900 per call — not 2700 with the narration copies');
-    assert.is(total.cacheWriteTokens, 100);
-    assert.is(total.uncachedInputTokens, 100);
-}));
-split.run();
-// ---------------------------------------------------------------------------
-// Per-turn model attribution across a tier switch.
-//
-// The shape this exists for is an agent whose `provider` selector varies by state —
-// e.g. the showcase trade-operations agent: `({state}) => isPlanning(state) ? High : Low`,
-// planning on sonnet and executing on haiku. Each call has to name the model that ran
-// it, on the turn itself: joining a turn to the message after it works for a normal
-// step but not for a call that produced no message, and `provider.selected` fires only
-// when the slot CHANGES, so the nearest event can be many turns back.
-//
-// The ordering trap: the snapshot is recorded BEFORE the provider is resolved for that
-// call, so stamping `lastResolvedModel` at creation time yields the previous call's
-// model — wrong on exactly the turn the tier changes.
-// ---------------------------------------------------------------------------
-const tiers = createLogicSuite('ChatDriver per-turn model attribution');
-/** A tiered registry: named slots, each reporting its own model via `getStatus`. */
-const tieredRegistry = (slots, defaultName) => ({
-    get: (name) => slots[name],
-    default: () => slots[defaultName],
-    defaultName: () => defaultName,
-    names: () => Object.keys(slots),
-    getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
-    listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
-});
-const tierProvider = (model, responses) => {
-    const queue = [...responses];
-    return {
-        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return ({ model, provider: 'anthropic' }); }),
-        chat: () => __awaiter(void 0, void 0, void 0, function* () { var _a; return (_a = queue.shift()) !== null && _a !== void 0 ? _a : { role: 'assistant', content: 'done' }; }),
-    };
-};
-tiers('attributes each step to the tier that ran it when the agent switches mid-flow', () => __awaiter(void 0, void 0, void 0, function* () {
-    // Responses deliberately carry NO `model` of their own — the common case for a
-    // transport that leaves attribution to the driver, and the one where a stale
-    // `lastResolved*` read would go unnoticed.
-    const slots = {
-        high: tierProvider('claude-sonnet-4-6', [
-            priced({
-                content: '',
-                cost: 0.05,
-                toolCalls: [{ id: 'p1', name: 'finish_planning', args: {} }],
-            }),
-        ]),
-        low: tierProvider('claude-haiku-4-5-20251001', [priced({ content: 'Booked.', cost: 0.001 })]),
-    };
-    // The "state" the selector reads, advanced by the tool — as a flow agent's machine does.
-    let planning = true;
-    const driver = new ChatDriver(tieredRegistry(slots, 'low'), {
-        maxToolIterations: 20,
-        maxFoldOperations: 5,
-        sessionKey: 'tiers',
-    });
-    driver.applyAgent(agent({
-        name: 'Trade Operations',
-        provider: () => (planning ? 'high' : 'low'),
-        toolDefinitions: [def('finish_planning')],
-        toolHandlers: {
-            finish_planning: () => __awaiter(void 0, void 0, void 0, function* () {
-                planning = false;
-                return 'planned';
-            }),
-        },
-    }));
-    yield driver.sendMessage('book me a trade');
-    const snapshots = driver.getTurnSnapshots();
-    assert.equal(snapshots.map((s) => { var _a; return [s.providerName, s.model, (_a = s.usage) === null || _a === void 0 ? void 0 : _a.costUsd]; }), [
-        ['high', 'claude-sonnet-4-6', 0.05],
-        ['low', 'claude-haiku-4-5-20251001', 0.001],
-    ], 'the planning call is attributed to the high tier and the execution call to the low one');
-    assert.equal(snapshots.map((s) => s.provider), ['anthropic', 'anthropic'], 'the vendor behind each slot is recorded too');
-    // A turn and the message it produced must never disagree about which model ran.
-    const assistantModels = driver
-        .getHistory()
-        .filter((m) => m.role === 'assistant' && m.cost != null)
-        .map((m) => m.model);
-    assert.equal(assistantModels, snapshots.map((s) => s.model));
-}));
-tiers('records the SERVING model when a fallback answers on another model', () => __awaiter(void 0, void 0, void 0, function* () {
-    // A server-side fallback chain answers on a different model than the one requested.
-    // The transport stamps the real one; the turn must follow it rather than relabel the
-    // call as the tier's configured model — that would misattribute the spend.
-    const slots = {
-        high: tierProvider('claude-fable-5', [
-            priced({ content: 'answered by the fallback', model: 'claude-opus-4-8' }),
-        ]),
-    };
-    const driver = new ChatDriver(tieredRegistry(slots, 'high'), {
-        maxToolIterations: 20,
-        maxFoldOperations: 5,
-        sessionKey: 'fallback',
-    });
-    driver.applyAgent(agent({ name: 'a', provider: 'high' }));
-    yield driver.sendMessage('go');
-    const [turn] = driver.getTurnSnapshots();
-    assert.is(turn.model, 'claude-opus-4-8', 'the model that answered, not the one asked for');
-    assert.is(turn.providerName, 'high', 'the slot asked for is still recorded');
-}));
-tiers('names the model and vendor on the provider.selected event, not just the slot', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
-    clearMetaEventRegistry();
-    const slots = {
-        high: tierProvider('claude-sonnet-4-6', [priced({ content: 'hi' })]),
-    };
-    const driver = new ChatDriver(tieredRegistry(slots, 'high'), {
-        maxToolIterations: 20,
-        maxFoldOperations: 5,
-        sessionKey: 'selected',
-    });
-    driver.applyAgent(agent({ name: 'a', provider: 'high' }));
-    yield driver.sendMessage('go');
-    const selected = getMetaEvents('selected').find((e) => e.type === 'provider.selected');
-    assert.ok(selected, 'a provider.selected event is recorded');
-    assert.is((_a = selected.detail) === null || _a === void 0 ? void 0 : _a.provider, 'high', 'the registry slot');
-    assert.is((_b = selected.detail) === null || _b === void 0 ? void 0 : _b.model, 'claude-sonnet-4-6', 'and the model behind it');
-    assert.is((_c = selected.detail) === null || _c === void 0 ? void 0 : _c.vendor, 'anthropic');
-}));
-tiers.run();