@genesislcap/ai-assistant 14.444.1 → 14.445.1

package/src/utils/sum-costs.test.ts

@@ -0,0 +1,108 @@
+import type { ChatMessage } from '@genesislcap/foundation-ai';
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import { sumCosts } from './sum-costs';
+
+const userMsg = (overrides: Partial<ChatMessage> = {}): ChatMessage => ({
+  role: 'user',
+  content: '',
+  ...overrides,
+});
+
+const assistantMsg = (overrides: Partial<ChatMessage> = {}): ChatMessage => ({
+  role: 'assistant',
+  content: '',
+  ...overrides,
+});
+
+const suite = createLogicSuite('sumCosts');
+
+suite('returns 0 for an empty message list', () => {
+  assert.is(sumCosts([]), 0);
+});
+
+suite('returns 0 when no message carries cost (e.g. all from a no-usage provider)', () => {
+  assert.is(sumCosts([userMsg(), assistantMsg({ content: 'hi' })]), 0);
+});
+
+suite('sums top-level message costs', () => {
+  // Use integer-cents arithmetic to avoid float-equality flake; the production
+  // path only ever adds floats here, so any rounding lives in display, not sum.
+  const cost = sumCosts([
+    assistantMsg({ cost: 0.5 }),
+    assistantMsg({ cost: 1.5 }),
+    userMsg(), // no cost — ignored
+  ]);
+  assert.is(cost, 2);
+});
+
+suite('includes sub-agent trace costs attached to a tool call', () => {
+  const parentToolCallMsg = assistantMsg({
+    cost: 0.1,
+    toolCalls: [
+      {
+        id: 'tc1',
+        name: 'spawn_sub',
+        args: {},
+        subAgentTrace: [assistantMsg({ cost: 0.5 }), assistantMsg({ cost: 0.4 })],
+      },
+    ],
+  });
+  // 0.1 (parent) + 0.5 + 0.4 (sub) = 1.0
+  assert.is(sumCosts([parentToolCallMsg]), 1);
+});
+
+suite('recurses into nested sub-agent traces', () => {
+  const innerTrace: ChatMessage[] = [assistantMsg({ cost: 0.25 })];
+  const middleTrace: ChatMessage[] = [
+    assistantMsg({
+      cost: 0.5,
+      toolCalls: [{ id: 'inner', name: 'spawn_inner', args: {}, subAgentTrace: innerTrace }],
+    }),
+  ];
+  const top = assistantMsg({
+    cost: 1,
+    toolCalls: [{ id: 'middle', name: 'spawn_middle', args: {}, subAgentTrace: middleTrace }],
+  });
+  // 1 + 0.5 + 0.25 = 1.75
+  assert.is(sumCosts([top]), 1.75);
+});
+
+suite('handles a mix of tool calls with and without subAgentTrace', () => {
+  const cost = sumCosts([
+    assistantMsg({
+      cost: 1,
+      toolCalls: [
+        { id: 'a', name: 'plain_tool', args: {} }, // no trace — skipped
+        {
+          id: 'b',
+          name: 'sub_tool',
+          args: {},
+          subAgentTrace: [assistantMsg({ cost: 2 })],
+        },
+      ],
+    }),
+  ]);
+  assert.is(cost, 3);
+});
+
+suite('ignores missing cost fields inside an otherwise-populated trace', () => {
+  const cost = sumCosts([
+    assistantMsg({
+      toolCalls: [
+        {
+          id: 'tc',
+          name: 'sub',
+          args: {},
+          subAgentTrace: [
+            userMsg(), // role=user, no cost
+            assistantMsg({ content: 'partial', cost: 0.3 }),
+            assistantMsg({ content: 'unbilled' }), // no cost field
+          ],
+        },
+      ],
+    }),
+  ]);
+  assert.is(cost, 0.3);
+});
+
+suite.run();

package/src/utils/sum-costs.ts

@@ -0,0 +1,22 @@
+import type { ChatMessage } from '@genesislcap/foundation-ai';
+
+/**
+ * Sum the `cost` field across a message list, recursing into each tool call's
+ * `subAgentTrace` so LLM calls made by sub-agents (potentially on a different
+ * provider with different rates) contribute to the total.
+ *
+ * Returns 0 when no messages carry a cost — providers that don't report usage
+ * metadata (e.g. Chrome built-in) are skipped silently.
+ *
+ * @internal
+ */
+export function sumCosts(messages: readonly ChatMessage[]): number {
+  let total = 0;
+  for (const m of messages) {
+    if (m.cost != null) total += m.cost;
+    for (const tc of m.toolCalls ?? []) {
+      if (tc.subAgentTrace) total += sumCosts(tc.subAgentTrace);
+    }
+  }
+  return total;
+}