@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/src/components/chat-driver/chat-driver.thinking-policy.test.ts

@@ -1,185 +0,0 @@
-import type {
-  AIProvider,
-  AIProviderRegistry,
-  ChatMessage,
-  ChatRequestOptions,
-  ChatThinkingPolicy,
-} from '@genesislcap/foundation-ai';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import type { AgentConfig } from '../../config/config';
-// 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 = (): AIProvider & { seen: Array<ChatThinkingPolicy | undefined> } => {
-  const seen: Array<ChatThinkingPolicy | undefined> = [];
-  let turns = 0;
-  return {
-    seen,
-    chat: async (
-      _history: ChatMessage[],
-      _userMessage: string,
-      options?: ChatRequestOptions,
-    ): Promise<ChatMessage> => {
-      seen.push(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: AIProvider): AIProviderRegistry => ({
-  get: () => provider,
-  default: () => provider,
-  defaultName: () => 'test',
-  names: () => ['test'],
-  getStatus: async () => null,
-  listStatuses: async () => [],
-});
-
-const agent = (overrides: Partial<AgentConfig>): AgentConfig =>
-  ({
-    name: 'worker',
-    description: 'test agent',
-    toolDefinitions: [
-      { name: 'step', description: 'step', parameters: { type: 'object', properties: {} } },
-    ],
-    toolHandlers: { step: async () => 'stepped' },
-    ...overrides,
-  }) as AgentConfig;
-
-/** Run one user turn through a driver carrying `config`, and return the policies seen. */
-const policiesFor = async (
-  config: Partial<AgentConfig>,
-): Promise<Array<ChatThinkingPolicy | undefined>> => {
-  const provider = capturingProvider();
-  const driver = new ChatDriver(makeRegistry(provider), {
-    maxToolIterations: 10,
-    maxFoldOperations: 5,
-    sessionKey: '',
-  });
-  driver.applyAgent(agent(config));
-  await driver.sendMessage('go');
-  return provider.seen;
-};
-
-const suite = createLogicSuite('ChatDriver thinkingPolicy');
-
-suite('leaves the policy undefined when the agent does not set one', async () => {
-  // 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 = await 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', async () => {
-  const seen = await 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', async () => {
-  // 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 = await 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', async () => {
-  // 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'),
-    }),
-  );
-  await driver.sendMessage('go');
-  const firstTurn = [...provider.seen];
-  turn = 1;
-  await 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', async () => {
-  // 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 = await 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', async () => {
-  const seen = await policiesFor({
-    thinkingPolicy: async () => 'off' as ChatThinkingPolicy,
-  });
-  assert.equal([...new Set(seen)], ['off'], 'a promise is resolved, not passed through');
-});
-
-suite.run();

package/src/components/chat-driver/chat-driver.trace-capture.test.ts

@@ -1,251 +0,0 @@
-import type {
-  AIProvider,
-  AIProviderRegistry,
-  ChatMessage,
-  ChatRequestOptions,
-} from '@genesislcap/foundation-ai';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import type { AgentConfig } from '../../config/config';
-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 = (): AIProvider => {
-  let parentTurns = 0;
-  return {
-    chat: async (
-      _history: ChatMessage[],
-      _userMessage: string,
-      options?: ChatRequestOptions,
-    ): Promise<ChatMessage> => {
-      const tools = (options?.tools ?? []).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: AIProvider): AIProviderRegistry => ({
-  get: () => provider,
-  default: () => provider,
-  defaultName: () => 'test',
-  names: () => ['test'],
-  getStatus: async () => null,
-  listStatuses: async () => [],
-});
-
-const agent = (overrides: Partial<AgentConfig> & { name: string }): AgentConfig =>
-  ({ description: 'test agent', ...overrides }) as AgentConfig;
-
-/** A child that reports one unit of usage and completes. */
-const worker = (name: string): AgentConfig =>
-  agent({
-    name,
-    toolDefinitions: [
-      { name: 'work', description: 'work', parameters: { type: 'object', properties: {} } },
-    ],
-    toolHandlers: {
-      work: async (_args, ctx) => {
-        ctx.completeSubAgent?.({ 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: AgentConfig[], invoke: string[]): AgentConfig =>
-  agent({
-    name: 'boss',
-    subAgents: children,
-    toolDefinitions: [
-      { name: 'delegate', description: 'delegate', parameters: { type: 'object', properties: {} } },
-    ],
-    toolHandlers: {
-      delegate: async (_args, ctx) => {
-        await Promise.all(invoke.map((n) => ctx.requestSubAgent!(n, { task: 'go' })));
-        return 'delegated';
-      },
-    },
-  });
-
-const run = async (config: AgentConfig): Promise<readonly ChatMessage[]> => {
-  const driver = new ChatDriver(makeRegistry(ruleProvider()), {
-    maxToolIterations: 20,
-    maxFoldOperations: 5,
-    sessionKey: '',
-  });
-  driver.applyAgent(config);
-  await driver.sendMessage('go');
-  return driver.getHistory();
-};
-
-const tracesIn = (history: readonly ChatMessage[]): readonly ChatMessage[][] =>
-  history.flatMap((m) =>
-    (m.toolCalls ?? []).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', async () => {
-  const names = ['gen_a', 'gen_b', 'gen_c'];
-  const history = await 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', async () => {
-  // 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 = await 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) => n + (r.costUsd ?? 0) + (r.externalCostUsd ?? 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)', async () => {
-  // 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 = await 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', async () => {
-  // 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: async (_args, ctx) => {
-        await Promise.all(names.map((n) => ctx.requestSubAgent!(n, { task: 'go' })));
-        throw new Error('post-processing the children failed');
-      },
-    },
-  });
-
-  const history = await 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', async () => {
-  // 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 = await run(
-    agent({
-      name: 'boss',
-      subAgents: [worker('gen_a')],
-      toolDefinitions: [
-        {
-          name: 'delegate',
-          description: 'delegate',
-          parameters: { type: 'object', properties: {} },
-        },
-      ],
-      toolHandlers: { delegate: async () => 'did it myself' },
-    }),
-  );
-
-  for (const m of history) {
-    for (const tc of m.toolCalls ?? []) {
-      assert.is(tc.subAgentTrace, undefined, 'not an empty array');
-    }
-  }
-  assert.equal(
-    usageRows(history).filter((r) => r.subAgentDepth === 1),
-    [],
-    'no child rows',
-  );
-});
-
-suite.run();