@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/src/utils/resolve-cost-history-config.ts

@@ -1,38 +0,0 @@
-import type { ChatConfig } from '@genesislcap/foundation-ai';
-
-/** Resolved cost-history settings from `chatConfig.costHistory`. */
-export interface ResolvedCostHistoryConfig {
-  /** When `true`, sessions are persisted automatically and history is shown. */
-  enabled: boolean;
-  /** Host label for the active session (e.g. project name). */
-  title?: string;
-  /** `localStorage` scope key; falls back to element `id` then `'default'`. */
-  scope?: string;
-  /** Show running session USD on the Usage tab. Default: `true`. */
-  showCost: boolean;
-  /** Show cumulative session tokens on the Usage tab. Default: `true`. */
-  showTokens: boolean;
-  /** Live-session badge label on the Usage tab summary. */
-  badgeLabel: string;
-  /**
-   * Host-supplied disclosure line for the Usage tab. Stays optional — unlike
-   * `badgeLabel` there is no default, because only the host knows what its `scope`
-   * spans, and the library must not assert it.
-   */
-  summaryHint?: string;
-}
-
-/** Resolve `chatConfig.costHistory` with defaults applied. */
-export function resolveCostHistoryConfig(chatConfig: ChatConfig): ResolvedCostHistoryConfig {
-  const cost = chatConfig.costHistory;
-
-  return {
-    enabled: cost?.enabled === true,
-    title: cost?.title?.trim() || undefined,
-    scope: cost?.scope?.trim() || undefined,
-    showCost: cost?.showCost !== false,
-    showTokens: cost?.showTokens !== false,
-    badgeLabel: cost?.badgeLabel ?? 'Currently building',
-    summaryHint: cost?.summaryHint?.trim() || undefined,
-  };
-}

package/src/utils/resolve-preference-baseline.test.ts

@@ -1,84 +0,0 @@
-import type { ChatConfig } from '@genesislcap/foundation-ai';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import type { SessionPreferences } from '../state/persistence/session-persistence-provider';
-import { resolvePreferenceBaseline } from './resolve-preference-baseline';
-
-// GENC-1351 #2: the preference baseline resolves with precedence
-//   slice defaults  <  chatConfig.ui defaults  <  stored user preferences.
-// The regression this guards: when stored prefs are absent (first load / wiped
-// backend) the result must fall through to the chatConfig.ui defaults, NOT to
-// everything-disabled.
-
-const FULL_UI: ChatConfig['ui'] = {
-  showToolCalls: true,
-  showThinkingSteps: true,
-  showNarration: true,
-  showAgentSwitchIndicator: true,
-  animations: { userConfigurable: true },
-};
-
-const Suite = createLogicSuite('resolvePreferenceBaseline');
-
-Suite('with no stored prefs, falls back to chatConfig.ui defaults (the nuke case)', () => {
-  const r = resolvePreferenceBaseline(FULL_UI, null);
-  assert.is(r.showToolCalls, true);
-  assert.is(r.showThinkingSteps, true);
-  assert.is(r.showNarration, true);
-  assert.is(r.showAgentSwitchIndicator, true);
-  assert.ok(r.enabledAnimations.length > 0, 'config animations enabled by default');
-  assert.is(r.enabled, undefined, 'no stored enabled → leave host default untouched');
-});
-
-Suite('with no stored prefs AND empty/unbound chatConfig, everything is off', () => {
-  // The transient state during connect before chatConfig binds — all-false is
-  // correct HERE; the element re-runs the baseline once chatConfig arrives.
-  const r = resolvePreferenceBaseline(undefined, null);
-  assert.equal(
-    [r.showToolCalls, r.showThinkingSteps, r.showNarration, r.showAgentSwitchIndicator],
-    [false, false, false, false],
-  );
-  assert.equal(r.enabledAnimations, []);
-});
-
-Suite('stored prefs override the config defaults field-by-field', () => {
-  const stored: SessionPreferences = {
-    enabled: true,
-    showToolCalls: false,
-    showThinkingSteps: false,
-    showNarration: true,
-    showAgentSwitchIndicator: false,
-    animations: ['halo'],
-  };
-  const r = resolvePreferenceBaseline(FULL_UI, stored);
-  assert.is(r.showToolCalls, false, 'stored false beats config true');
-  assert.is(r.showThinkingSteps, false);
-  assert.is(r.showNarration, true);
-  assert.is(r.showAgentSwitchIndicator, false);
-  assert.equal(r.enabledAnimations, ['halo'], 'stored animations applied as-is');
-  assert.is(r.enabled, true, 'stored enabled surfaces');
-});
-
-Suite('a partial stored blob overrides only present fields; others keep config default', () => {
-  const stored = { showToolCalls: false } as SessionPreferences;
-  const r = resolvePreferenceBaseline(FULL_UI, stored);
-  assert.is(r.showToolCalls, false, 'present field overridden');
-  assert.is(r.showThinkingSteps, true, 'absent field keeps config default');
-  assert.is(r.showAgentSwitchIndicator, true);
-  assert.is(r.enabled, undefined, 'absent enabled stays undefined');
-});
-
-Suite('stored prefs over an empty config still apply (config layer is all-false)', () => {
-  const stored: SessionPreferences = { showToolCalls: true, showThinkingSteps: true };
-  const r = resolvePreferenceBaseline(undefined, stored);
-  assert.is(r.showToolCalls, true);
-  assert.is(r.showThinkingSteps, true);
-  assert.is(r.showNarration, false, 'not in stored, not in config → false');
-});
-
-Suite('de-dupes stored animations (heals blobs from the old settings-modal append bug)', () => {
-  const stored = { animations: ['loading', 'halo', 'loading', 'halo'] } as SessionPreferences;
-  const r = resolvePreferenceBaseline(FULL_UI, stored);
-  assert.equal(r.enabledAnimations, ['loading', 'halo'], 'duplicates collapsed, order preserved');
-});
-
-Suite.run();

package/src/utils/resolve-preference-baseline.ts

@@ -1,80 +0,0 @@
-import type { ChatConfig } from '@genesislcap/foundation-ai';
-import { DEFAULT_ANIMATIONS, type AiAssistantAnimation } from '../main/main.types';
-import type { SessionPreferences } from '../state/persistence/session-persistence-provider';
-import { resolveExclusiveLoadingStyle } from './animation-exclusivity';
-
-/**
- * The effective user-facing preference state for a freshly created session store
- * (GENC-1351 #2), resolved from the two inputs that feed it.
- *
- * @internal
- */
-export interface ResolvedPreferenceBaseline {
-  showToolCalls: boolean;
-  showThinkingSteps: boolean;
-  showNarration: boolean;
-  showAgentSwitchIndicator: boolean;
-  enabledAnimations: AiAssistantAnimation[];
-  /**
-   * The remembered "remember chat" toggle — present only when stored prefs carried
-   * an `enabled` value. Left `undefined` otherwise so the caller keeps the
-   * host-configured default rather than forcing a value.
-   */
-  enabled?: boolean;
-}
-
-/**
- * Resolve the effective preference baseline for a fresh store, applying the
- * precedence (lowest → highest):
- *
- *   slice defaults  <  `chatConfig.ui` defaults  <  stored user preferences
- *
- * The `chatConfig.ui` layer is the fallback when the user has no stored prefs
- * (e.g. a first-ever load, or after the persistence backend is wiped) — the case
- * the old "read config once on connect" path got wrong whenever `chatConfig` had
- * not bound yet. Stored prefs, when present, override only the fields they carry;
- * absent fields keep the config default. Pure, so the precedence is unit-testable
- * independent of the element/store wiring.
- *
- * Config-supplied animations are normalised through {@link resolveExclusiveLoadingStyle}
- * (a raw config list may name both loading styles); stored animations are applied
- * as-is, since they were already normalised when saved.
- *
- * @internal
- */
-export function resolvePreferenceBaseline(
-  ui: ChatConfig['ui'],
-  stored: SessionPreferences | null | undefined,
-): ResolvedPreferenceBaseline {
-  const u = ui ?? {};
-  // Layer 1 — chatConfig.ui defaults.
-  const baseline: ResolvedPreferenceBaseline = {
-    showToolCalls: u.showToolCalls === true,
-    showThinkingSteps: u.showThinkingSteps === true,
-    showNarration: u.showNarration === true,
-    showAgentSwitchIndicator: u.showAgentSwitchIndicator === true,
-    enabledAnimations: resolveExclusiveLoadingStyle(
-      (u.animations?.enabled as AiAssistantAnimation[]) ??
-        (u.animations ? [...DEFAULT_ANIMATIONS] : []),
-    ),
-  };
-
-  // Layer 2 — stored user preferences override the fields they carry.
-  if (stored) {
-    if (stored.enabled !== undefined) baseline.enabled = stored.enabled;
-    if (stored.showToolCalls !== undefined) baseline.showToolCalls = stored.showToolCalls;
-    if (stored.showThinkingSteps !== undefined)
-      baseline.showThinkingSteps = stored.showThinkingSteps;
-    if (stored.showNarration !== undefined) baseline.showNarration = stored.showNarration;
-    if (stored.showAgentSwitchIndicator !== undefined) {
-      baseline.showAgentSwitchIndicator = stored.showAgentSwitchIndicator;
-    }
-    if (Array.isArray(stored.animations)) {
-      // De-dupe defensively — historical blobs may hold duplicates from the old
-      // settings-modal append bug (now fixed at the `setEnabledAnimations` source).
-      baseline.enabledAnimations = [...new Set(stored.animations)] as AiAssistantAnimation[];
-    }
-  }
-
-  return baseline;
-}

package/src/utils/strip-agent-handlers.test.ts

@@ -1,99 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import type { AgentConfig } from '../config/config';
-import { stripAgentHandlers } from './strip-agent-handlers';
-
-const cfg = (overrides: Record<string, unknown>): AgentConfig =>
-  ({ name: 'agent', ...overrides }) as unknown as AgentConfig;
-
-/** Mirrors what redux's serializable-state check does: find any function anywhere. */
-const hasFunctionDeep = (value: unknown): boolean => {
-  if (typeof value === 'function') return true;
-  if (Array.isArray(value)) return value.some(hasFunctionDeep);
-  if (value !== null && typeof value === 'object') {
-    return Object.values(value).some(hasFunctionDeep);
-  }
-  return false;
-};
-
-const suite = createLogicSuite('stripAgentHandlers');
-
-suite('drops object-form toolHandlers (the redux-leak regression)', () => {
-  const stripped = stripAgentHandlers(
-    cfg({ toolHandlers: { vfs_list: async () => 'x', vfs_read: async () => 'y' } }),
-  ) as Record<string, unknown>;
-  // The whole handler bag is gone — not left behind with live functions inside.
-  assert.not.ok(stripped.toolHandlers);
-  assert.not.ok(hasFunctionDeep(stripped));
-});
-
-suite('drops factory-function toolHandlers and the lifecycle/dispatch hooks', () => {
-  const stripped = stripAgentHandlers(
-    cfg({
-      toolHandlers: () => ({ t: async () => 'x' }),
-      onActivate: async () => {},
-      onDeactivate: async () => {},
-      getDebugSnapshot: () => ({}),
-      onUnresolvedTool: () => 'redirect',
-    }),
-  ) as Record<string, unknown>;
-  assert.not.ok(stripped.toolHandlers);
-  assert.not.ok(stripped.onActivate);
-  assert.not.ok(stripped.onDeactivate);
-  assert.not.ok(stripped.getDebugSnapshot);
-  assert.not.ok(stripped.onUnresolvedTool);
-});
-
-suite('drops function-form resolvers but keeps static forms and plain data', () => {
-  const stripped = stripAgentHandlers(
-    cfg({
-      systemPrompt: () => 'dynamic', // function → dropped
-      displayName: 'Static Name', // string → kept
-      temperature: 0.5, // number → kept
-      toolChoice: 'auto', // string → kept
-      toolDefinitions: [{ name: 'x', description: 'd', parameters: {} }], // data array → kept
-      manualSelection: { enabled: true, hint: 'pick me' }, // data object → kept
-    }),
-  ) as Record<string, unknown>;
-  assert.not.ok(stripped.systemPrompt);
-  assert.is(stripped.displayName, 'Static Name');
-  assert.is(stripped.temperature, 0.5);
-  assert.is(stripped.toolChoice, 'auto');
-  assert.equal(stripped.toolDefinitions, [{ name: 'x', description: 'd', parameters: {} }]);
-  assert.equal(stripped.manualSelection, { enabled: true, hint: 'pick me' });
-});
-
-suite('recurses into subAgents, stripping their object-form toolHandlers', () => {
-  const stripped = stripAgentHandlers(
-    cfg({
-      name: 'boss',
-      toolHandlers: () => ({}),
-      subAgents: [
-        cfg({
-          name: 'worker',
-          toolHandlers: { vfs_list: async () => 'x', vfs_read: async () => 'y' },
-        }),
-      ],
-    }),
-  ) as Record<string, unknown>;
-  const subs = stripped.subAgents as Array<Record<string, unknown>>;
-  assert.is(subs.length, 1);
-  assert.is(subs[0].name, 'worker');
-  assert.not.ok(subs[0].toolHandlers, 'sub-agent toolHandlers must be stripped (the reported bug)');
-  // Nothing function-valued survives anywhere in the projection.
-  assert.not.ok(hasFunctionDeep(stripped));
-});
-
-suite('produces a projection with no function at any depth', () => {
-  const stripped = stripAgentHandlers(
-    cfg({
-      name: 'boss',
-      onActivate: async () => {},
-      subAgents: [cfg({ name: 'w', toolHandlers: { t: async () => {} } })],
-    }),
-  );
-  assert.not.ok(hasFunctionDeep(stripped));
-  // Round-trips to the expected serializable shape.
-  assert.equal(JSON.parse(JSON.stringify(stripped)), { name: 'boss', subAgents: [{ name: 'w' }] });
-});
-
-suite.run();

package/src/utils/strip-agent-handlers.ts

@@ -1,53 +0,0 @@
-import type { AgentConfig } from '../config/config';
-
-/**
- * Project an `AgentConfig` down to a JSON-serializable shape for the redux
- * session store. Drops two kinds of field:
- *
- * 1. **Directly function-valued** — the lifecycle/dispatch hooks (`onActivate`,
- *    `onDeactivate`, `getDebugSnapshot`, `onUnresolvedTool`) and the function
- *    form of the per-turn resolvers (`systemPrompt`, `toolDefinitions`,
- *    `displayName`, `provider`, `temperature`, `toolChoice`, `cachePolicy`,
- *    `thinkingPolicy`, `toolHandlers`).
- * 2. **Object "handler bags" whose *values* are functions** — `toolHandlers` in
- *    its object form is `{ name: handler }`, so `typeof` is `'object'`, not
- *    `'function'`. A by-value check on the field alone misses it, leaking a live
- *    handler into store state and tripping redux's serializability check (the
- *    regression this guards against — top-level agents tend to use the factory
- *    function form, but sub-agents commonly declare an object literal).
- *
- * `subAgents` are projected recursively. Static forms (string / number / array /
- * plain data object) pass through unchanged.
- *
- * Filtering by value rather than an explicit field list means a new
- * function-valued field on `AgentConfig` is handled automatically — no denylist
- * to maintain. The live config on the driver stays the source of truth; the
- * slice only holds this serializable projection and functions are never read
- * back from it.
- *
- * @internal
- */
-export function stripAgentHandlers(agent: AgentConfig): Omit<AgentConfig, 'toolHandlers'> {
-  const serializable: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(agent)) {
-    // Projected recursively below.
-    if (key === 'subAgents') continue;
-    // Directly function-valued field.
-    if (typeof value === 'function') continue;
-    // Object/array whose values include a function (e.g. `toolHandlers` in object
-    // form). Drop the whole field — the projection type omits it and a function
-    // must never reach the store.
-    if (
-      value !== null &&
-      typeof value === 'object' &&
-      Object.values(value).some((v) => typeof v === 'function')
-    ) {
-      continue;
-    }
-    serializable[key] = value;
-  }
-  if (agent.subAgents?.length) {
-    serializable.subAgents = agent.subAgents.map(stripAgentHandlers);
-  }
-  return serializable as unknown as Omit<AgentConfig, 'toolHandlers'>;
-}

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

@@ -1,136 +0,0 @@
-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('adds widget-reported externalCostUsd alongside provider cost', () => {
-  // A message can carry both: provider LLM `cost` and a widget's `externalCostUsd`.
-  const cost = sumCosts([
-    assistantMsg({ cost: 0.5 }), // provider only
-    assistantMsg({ externalCostUsd: 0.25 }), // external only (e.g. an interaction message)
-    assistantMsg({ cost: 0.1, externalCostUsd: 0.4 }), // both
-    userMsg(), // neither — ignored
-  ]);
-  // 0.5 + 0.25 + 0.1 + 0.4 = 1.25
-  assert.is(cost, 1.25);
-});
-
-suite('includes externalCostUsd inside a sub-agent trace', () => {
-  const cost = sumCosts([
-    assistantMsg({
-      toolCalls: [
-        {
-          id: 'tc',
-          name: 'sub',
-          args: {},
-          subAgentTrace: [assistantMsg({ cost: 0.5, externalCostUsd: 0.5 })],
-        },
-      ],
-    }),
-  ]);
-  assert.is(cost, 1);
-});
-
-suite.run();

package/src/utils/sum-costs.ts

@@ -1,18 +0,0 @@
-import type { ChatMessage } from '@genesislcap/foundation-ai';
-import { sumUsage } from './sum-usage';
-
-/**
- * Sum cost across a message list: each message's provider-reported LLM `cost`
- * plus any `externalCostUsd` a widget reported for its own external service
- * calls, 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 {
-  return sumUsage(messages).costUsd;
-}

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

@@ -1,93 +0,0 @@
-import type { ChatMessage } from '@genesislcap/foundation-ai';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { formatCompactTokenCount, formatCompactTokenCountSafe, sumTokens } from './sum-tokens';
-
-const assistantMsg = (overrides: Partial<ChatMessage> = {}): ChatMessage => ({
-  role: 'assistant',
-  content: '',
-  ...overrides,
-});
-
-const suite = createLogicSuite('sumTokens');
-
-suite('returns 0 for an empty message list', () => {
-  assert.is(sumTokens([]), 0);
-});
-
-suite('sums input and output tokens on top-level messages', () => {
-  assert.is(
-    sumTokens([
-      assistantMsg({ inputTokens: 100, outputTokens: 50 }),
-      assistantMsg({ inputTokens: 200, outputTokens: 0 }),
-    ]),
-    350,
-  );
-});
-
-suite('includes sub-agent trace tokens attached to a tool call', () => {
-  assert.is(
-    sumTokens([
-      assistantMsg({
-        inputTokens: 10,
-        outputTokens: 5,
-        toolCalls: [
-          {
-            id: 'tc1',
-            name: 'spawn_sub',
-            args: {},
-            subAgentTrace: [assistantMsg({ inputTokens: 1000, outputTokens: 400 })],
-          },
-        ],
-      }),
-    ]),
-    1415,
-  );
-});
-
-const formatSuite = createLogicSuite('formatCompactTokenCount');
-
-formatSuite('formats millions with one decimal when needed', () => {
-  assert.is(
-    formatCompactTokenCount(1_400_000),
-    '<span class="value">1.4</span><span class="suffix">M</span>',
-  );
-});
-
-formatSuite('formats whole millions without a decimal', () => {
-  assert.is(
-    formatCompactTokenCount(2_000_000),
-    '<span class="value">2</span><span class="suffix">M</span>',
-  );
-});
-
-formatSuite('formats thousands compactly', () => {
-  assert.is(
-    formatCompactTokenCount(3_200),
-    '<span class="value">3.2</span><span class="suffix">K</span>',
-  );
-});
-
-formatSuite('formats small counts with grouping', () => {
-  assert.is(formatCompactTokenCount(842), '842');
-});
-
-formatSuite('rolls K suffix up to M when rounding would yield 1000K', () => {
-  assert.is(
-    formatCompactTokenCount(999_950),
-    '<span class="value">1</span><span class="suffix">M</span>',
-  );
-  assert.is(
-    formatCompactTokenCount(999_949),
-    '<span class="value">999.9</span><span class="suffix">K</span>',
-  );
-});
-
-formatSuite('safe formatter preserves compact markup', () => {
-  assert.is(
-    formatCompactTokenCountSafe(1_400_000),
-    '<span class="value">1.4</span><span class="suffix">M</span>',
-  );
-});
-
-suite.run();
-formatSuite.run();

package/src/utils/sum-tokens.ts

@@ -1,68 +0,0 @@
-import type { ChatMessage } from '@genesislcap/foundation-ai';
-import DOMPurify from 'dompurify';
-import { sumUsage, totalTokens } from './sum-usage';
-
-/**
- * Total tokens across a message list — the headline figure, with the per-bucket
- * split available from {@link sumUsage} for anything that needs to show *why* a
- * large token count cost little.
- *
- * Identical arithmetic to the old per-message `inputTokens + outputTokens` sum:
- * the three input buckets partition `inputTokens`, so they re-add to it exactly.
- * It does now additionally count usage banked by a compaction, which is the point
- * — that spend used to vanish when the summarised turns left the transcript.
- *
- * Returns 0 when no message carries token metadata.
- *
- * @internal
- */
-export function sumTokens(messages: readonly ChatMessage[]): number {
-  return totalTokens(sumUsage(messages));
-}
-
-const TOKEN_SCALE_DECIMAL_FACTOR = 10;
-const TOKENS_PER_MILLION = 1_000_000;
-const TOKENS_PER_THOUSAND = 1_000;
-const SUFFIX_ROLLOVER_THRESHOLD = 1000;
-
-const roundScaled = (scaled: number): number =>
-  Math.round(scaled * TOKEN_SCALE_DECIMAL_FACTOR) / TOKEN_SCALE_DECIMAL_FACTOR;
-
-const formatScaledTokenMarkup = (rounded: number, suffix: string): string => {
-  const value = Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
-  return `<span class="value">${value}</span><span class="suffix">${suffix}</span>`;
-};
-
-const scaledSuffixLabel = (tokens: number): string | undefined => {
-  if (tokens >= TOKENS_PER_MILLION) return 'M';
-  if (tokens >= TOKENS_PER_THOUSAND) {
-    const kRounded = roundScaled(tokens / TOKENS_PER_THOUSAND);
-    if (kRounded >= SUFFIX_ROLLOVER_THRESHOLD) return 'M';
-    return 'K';
-  }
-  return undefined;
-};
-
-const scaledNumericValue = (tokens: number): number | undefined => {
-  const suffix = scaledSuffixLabel(tokens);
-  if (!suffix) return undefined;
-  if (suffix === 'M') return roundScaled(tokens / TOKENS_PER_MILLION);
-  return roundScaled(tokens / TOKENS_PER_THOUSAND);
-};
-
-/**
- * Compact display for large token counts (e.g. 1_400_000 → value "1.4" + suffix "M").
- * Returns HTML markup so the suffix can be styled separately in the settings modal.
- *
- * @internal
- */
-export function formatCompactTokenCount(tokens: number): string {
-  const suffix = scaledSuffixLabel(tokens);
-  if (!suffix) return tokens.toLocaleString();
-  return formatScaledTokenMarkup(scaledNumericValue(tokens)!, suffix);
-}
-
-/** {@link formatCompactTokenCount} passed through DOMPurify for `:innerHTML` bindings. */
-export function formatCompactTokenCountSafe(tokens: number): string {
-  return DOMPurify.sanitize(formatCompactTokenCount(tokens));
-}