@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/src/components/chat-driver/chat-driver.turn-usage.test.ts

@@ -1,362 +0,0 @@
-import type {
-  AIProvider,
-  AIProviderRegistry,
-  ChatMessage,
-  ChatToolDefinition,
-} from '@genesislcap/foundation-ai';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import type { AgentConfig } from '../../config/config';
-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: AIProvider): AIProviderRegistry => ({
-  get: () => provider,
-  default: () => provider,
-  defaultName: () => 'test',
-  names: () => ['test'],
-  getStatus: async () => null,
-  listStatuses: async () => [],
-});
-
-/** Answers from a queue, then ends the turn with a plain unpriced reply. */
-const scriptedProvider = (responses: ChatMessage[]): AIProvider => {
-  const queue = [...responses];
-  return {
-    chat: async (): Promise<ChatMessage> => queue.shift() ?? { role: 'assistant', content: 'done' },
-  };
-};
-
-const agent = (overrides: Partial<AgentConfig> & { name: string }): AgentConfig =>
-  ({ description: 'test agent', ...overrides }) as AgentConfig;
-
-const makeDriver = (config: AgentConfig, provider: AIProvider): ChatDriver => {
-  const driver = new ChatDriver(makeRegistry(provider), {
-    maxToolIterations: 50,
-    maxFoldOperations: 5,
-    sessionKey: '',
-  });
-  driver.applyAgent(config);
-  return driver;
-};
-
-const def = (name: string): ChatToolDefinition => ({
-  name,
-  description: `${name} tool`,
-  parameters: { type: 'object', properties: {} },
-});
-
-/** One priced response: a 1000-token prompt that was mostly a cache hit. */
-const priced = (over: Partial<ChatMessage> = {}): ChatMessage => ({
-  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', async () => {
-  const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([priced()]));
-  await 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', async () => {
-  const driver = makeDriver(
-    agent({
-      name: 'a',
-      toolDefinitions: [def('work')],
-      toolHandlers: { work: async () => 'worked' },
-    }),
-    scriptedProvider([
-      priced({ content: '', cost: 0.02, toolCalls: [{ id: 'w1', name: 'work', args: {} }] }),
-      priced({ cost: 0.03 }),
-    ]),
-  );
-  await 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) => s.usage?.costUsd),
-    [0.02, 0.03],
-  );
-});
-
-suite('prices a blank response that produced no message', async () => {
-  // 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 }),
-    ]),
-  );
-  await driver.sendMessage('go');
-
-  const snapshots = driver.getTurnSnapshots();
-  assert.is(snapshots.length, 2, 'the retried attempt has its own snapshot');
-  assert.is(snapshots[0].usage?.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', async () => {
-  // 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([]));
-  await 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', async () => {
-  const response = priced({ reasoning: 'thinking…' });
-  const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([response]));
-  await 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', async () => {
-  // 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: async () => 'worked' },
-    }),
-    scriptedProvider([first, priced({ cost: 0.03 })]),
-  );
-  await 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: Record<string, AIProvider>,
-  defaultName: string,
-): AIProviderRegistry =>
-  ({
-    get: (name: string) => slots[name],
-    default: () => slots[defaultName],
-    defaultName: () => defaultName,
-    names: () => Object.keys(slots),
-    getStatus: async () => null,
-    listStatuses: async () => [],
-  }) as AIProviderRegistry;
-
-const tierProvider = (model: string, responses: ChatMessage[]): AIProvider => {
-  const queue = [...responses];
-  return {
-    getStatus: async () => ({ model, provider: 'anthropic' }) as never,
-    chat: async () => queue.shift() ?? { role: 'assistant', content: 'done' },
-  };
-};
-
-tiers('attributes each step to the tier that ran it when the agent switches mid-flow', async () => {
-  // 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: async () => {
-          planning = false;
-          return 'planned';
-        },
-      },
-    }),
-  );
-  await driver.sendMessage('book me a trade');
-
-  const snapshots = driver.getTurnSnapshots();
-  assert.equal(
-    snapshots.map((s) => [s.providerName, s.model, s.usage?.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', async () => {
-  // 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' }));
-  await 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', async () => {
-  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' }));
-  await driver.sendMessage('go');
-
-  const selected = getMetaEvents('selected').find((e) => e.type === 'provider.selected');
-  assert.ok(selected, 'a provider.selected event is recorded');
-  assert.is(selected!.detail?.provider, 'high', 'the registry slot');
-  assert.is(selected!.detail?.model, 'claude-sonnet-4-6', 'and the model behind it');
-  assert.is(selected!.detail?.vendor, 'anthropic');
-});
-
-tiers.run();

package/src/components/chat-driver/index.ts

@@ -1 +0,0 @@
-export * from './chat-driver';

package/src/components/chat-interaction-wrapper/chat-interaction-wrapper.styles.ts

@@ -1,7 +0,0 @@
-import { css } from '@genesislcap/web-core';
-
-export const AiChatInteractionWrapperStyles = css`
-  :host {
-    display: block;
-  }
-`;

package/src/components/chat-interaction-wrapper/chat-interaction-wrapper.template.ts

@@ -1,6 +0,0 @@
-import { html, ref } from '@genesislcap/web-core';
-import type { AiChatInteractionWrapper } from './chat-interaction-wrapper';
-
-export const AiChatInteractionWrapperTemplate = html<AiChatInteractionWrapper>`
-  <div ${ref('container')} class="container" part="container"></div>
-`;

package/src/components/chat-interaction-wrapper/chat-interaction-wrapper.test.ts

@@ -1,144 +0,0 @@
-import { assert, createComponentSuite } from '@genesislcap/foundation-testing';
-import { DOM } from '@genesislcap/web-core';
-import type { AiChatInteraction } from '../../types/ai-chat-widget';
-import { AiChatInteractionWrapper } from './chat-interaction-wrapper';
-
-// Hold a reference so the custom-element registration isn't tree-shaken.
-AiChatInteractionWrapper;
-
-/**
- * Minimal stand-in for a real interaction widget. The wrapper instantiates the
- * element named by `componentName` and assigns `interactionId`/`interaction` onto
- * it (GENC-1390); the tests read `interaction` back to verify which interaction the
- * rendered widget belongs to and its pending/resolved state.
- */
-const FAKE_WIDGET = 'test-interaction-widget';
-if (!customElements.get(FAKE_WIDGET)) {
-  customElements.define(
-    FAKE_WIDGET,
-    class extends HTMLElement {
-      interactionId?: string;
-      interaction?: AiChatInteraction;
-    },
-  );
-}
-
-type FakeWidget = HTMLElement & { interaction?: AiChatInteraction };
-
-/**
- * Renders a first interaction into a freshly-mounted wrapper.
- *
- * `componentName` is assigned last on purpose. The suite hands us an
- * already-connected element, so the only render trigger left is
- * `componentNameChanged`; setting it last means that render sees `data` and
- * `interactionId` already in place — reproducing production, where the initial
- * widget renders in `connectedCallback` with every bound property present. This
- * keeps the *first* render correct on both the patched and unpatched code so
- * that the id-change rebind is the only behaviour each test isolates.
- */
-async function renderFirstInteraction(element: AiChatInteractionWrapper) {
-  await DOM.nextUpdate();
-  element.data = { label: 'interaction-a' };
-  element.interactionId = 'id-a';
-  element.componentName = FAKE_WIDGET;
-  await DOM.nextUpdate();
-}
-
-const Suite = createComponentSuite<AiChatInteractionWrapper>(
-  'AiChatInteractionWrapper',
-  'ai-chat-interaction-wrapper',
-);
-
-/**
- * Regression for the cog-menu toggle misalignment: FAST's `repeat` reconciles
- * the message list by array index (it has no key function), so toggling "Tool
- * calls"/"Thinking" re-filters the visible messages and rebinds an existing
- * row's wrapper to a *different* interaction. When both interactions use the
- * same component, `componentNameChanged` doesn't fire — so the wrapper must
- * re-render on `interactionId` change, or the previous interaction's widget
- * stays mounted under the new message.
- */
-Suite(
-  're-renders the hosted widget when interactionId changes with the same componentName',
-  async ({ element }) => {
-    await renderFirstInteraction(element);
-
-    const firstWidget = element.container.firstElementChild as FakeWidget;
-    assert.ok(firstWidget, 'a widget is rendered for the first interaction');
-    assert.equal(firstWidget.interaction?.data, { label: 'interaction-a' });
-
-    // Rebind the reused wrapper to a different interaction that happens to use
-    // the same component — `data` then `interactionId`, mirroring the template's
-    // property-binding order. `componentName` is unchanged, so the only thing
-    // that can drive a re-render is the interactionId hook.
-    element.data = { label: 'interaction-b' };
-    element.interactionId = 'id-b';
-    await DOM.nextUpdate();
-
-    const secondWidget = element.container.firstElementChild as FakeWidget;
-    assert.is.not(secondWidget, firstWidget, 'the stale widget is replaced, not left mounted');
-    assert.equal(
-      secondWidget.interaction?.data,
-      { label: 'interaction-b' },
-      'the rendered widget reflects the new interaction, not the stale one',
-    );
-  },
-);
-
-/**
- * Resolving an interaction in place (the user answers it) must forward the
- * result without tearing down and rebuilding the widget — only a genuine change
- * of interaction identity should rebuild.
- */
-Suite('forwards resolved in place without rebuilding the widget', async ({ element }) => {
-  await renderFirstInteraction(element);
-
-  const widget = element.container.firstElementChild as FakeWidget;
-  assert.is(widget.interaction?.status, 'pending', 'the widget starts pending');
-
-  element.resolved = { status: 'approved' };
-  await DOM.nextUpdate();
-
-  assert.is(
-    element.container.firstElementChild,
-    widget,
-    'resolving in place must not rebuild the widget',
-  );
-  assert.is(widget.interaction?.status, 'resolved', 'the widget transitions to resolved in place');
-  assert.equal(
-    widget.interaction?.status === 'resolved' ? widget.interaction.result : undefined,
-    { status: 'approved' },
-    'the resolved result is forwarded to the widget',
-  );
-});
-
-/**
- * When no live `InteractionContext` exists for the interaction — it has resolved and the driver
- * dropped it (the `resolved` binding can lag a render behind during a layout rebuild), or the widget
- * is rendered outside the normal host flow (as here: no host on the root) — the wrapper must hand the
- * widget an INERT context whose `once` refuses, never a live throwaway. A live throwaway re-ran the
- * widget's open-once side effect on the remount following a resolve, re-opening a just-closed side
- * panel and looping the layout rebuild (GENC-1390).
- */
-Suite(
-  'falls back to an inert context (once refuses) when there is no live context',
-  async ({ element }) => {
-    await renderFirstInteraction(element);
-
-    const widget = element.container.firstElementChild as FakeWidget;
-    assert.is(widget.interaction?.status, 'pending', 'the widget is pending');
-    const ctx =
-      widget.interaction?.status === 'pending' ? widget.interaction.interactionContext : undefined;
-    assert.ok(ctx, 'a context is still provided so the widget does not crash on a missing one');
-
-    let ran = 0;
-    const result = ctx!.once('open-review-panel', () => {
-      ran += 1;
-      return 'opened';
-    });
-    assert.is(ran, 0, 'the inert fallback context must not run a once factory');
-    assert.is(result, null, 'once returns null on the inert fallback context');
-  },
-);
-
-Suite.run();