@genesislcap/ai-assistant 14.467.1 → 14.467.2

package/src/utils/flatten-sub-agent-messages.ts

@@ -0,0 +1,88 @@
+import type { ChatMessage } from '@genesislcap/foundation-ai';
+
+/**
+ * A chat message lifted into the debug-log timeline as a `kind: 'message'` entry.
+ *
+ * @beta
+ */
+export type TimelineMessage = ChatMessage & {
+  kind: 'message';
+  /**
+   * Set only on entries hoisted out of a `subAgentTrace`: the sub-agent's own
+   * (un-breadcrumbed) `agentName`, kept for filtering since the displayed
+   * `agentName` is rewritten to a `"<parent> › <sub-agent>"` breadcrumb.
+   */
+  subAgentName?: string;
+  /** Delegation depth — absent/0 for top-level, 1 for a sub-agent, 2 for a sub-agent's sub-agent, … */
+  subAgentDepth?: number;
+  /** Id of the parent tool call that spawned this run — correlates a hoisted message back to its delegation. */
+  subAgentOf?: string;
+};
+
+/**
+ * Flatten sub-agent conversations into a single top-level message stream for the
+ * debug-log timeline.
+ *
+ * A tool call that delegates to a sub-agent carries the sub-agent's entire
+ * conversation on `toolCall.subAgentTrace`. The live UI reads that nested shape,
+ * but a top-to-bottom timeline reads far better with those messages inline next to
+ * the turn that produced them. This walks the list and, for every tool call with a
+ * `subAgentTrace`, hoists the sub-agent's messages up as their own timeline
+ * entries while **removing** the nested copy from the emitted parent tool call — a
+ * move, not a copy. The data is relocated, never duplicated: the export stays the
+ * same size and a naive `sum(timeline[].cost)` does not double-count (the
+ * canonical `sumCosts` total still reads the un-flattened history).
+ *
+ * Hoisted entries are:
+ * - **breadcrumbed**: `agentName` becomes `"<parent> › <sub-agent>"`, composing for
+ *   nested sub-agents (`"<parent> › <sub> › <subsub>"`); the raw sub-agent name is
+ *   preserved on `subAgentName`.
+ * - **depth-tagged** (`subAgentDepth`) and **correlated** to the spawning tool call
+ *   (`subAgentOf`), so the delegation tree is reconstructable even when two
+ *   sub-agents run within the same parent turn.
+ *
+ * Top-level messages (depth 0) are emitted unchanged apart from the trace strip.
+ * Order is preserved within each list; the caller sorts the whole timeline by
+ * timestamp afterwards, and every sub-agent message carries its own timestamp, so
+ * hoisted entries interleave chronologically between the parent's tool-call and
+ * tool-result messages.
+ *
+ * @internal
+ */
+export function flattenSubAgentMessages(
+  messages: readonly ChatMessage[],
+  prefix = '',
+  depth = 0,
+  subAgentOf?: string,
+): TimelineMessage[] {
+  return messages.flatMap((m) => {
+    const breadcrumb = prefix ? `${prefix} › ${m.agentName ?? '?'}` : m.agentName;
+    const traceCalls = m.toolCalls?.filter((tc) => tc.subAgentTrace?.length) ?? [];
+
+    const entry: TimelineMessage = {
+      kind: 'message',
+      ...m,
+      // Move the (about-to-be-hoisted) child conversations out of the emitted tool
+      // calls. Setting it to `undefined` drops the key from the serialized export.
+      ...(traceCalls.length > 0 && {
+        toolCalls: m.toolCalls!.map((tc) =>
+          tc.subAgentTrace ? { ...tc, subAgentTrace: undefined } : tc,
+        ),
+      }),
+      // Mark + breadcrumb hoisted sub-agent messages; top-level (depth 0) stays as-is.
+      ...(depth > 0 && {
+        agentName: breadcrumb,
+        subAgentName: m.agentName,
+        subAgentDepth: depth,
+        subAgentOf,
+      }),
+    };
+
+    if (traceCalls.length === 0) return [entry];
+
+    const hoisted = traceCalls.flatMap((tc) =>
+      flattenSubAgentMessages(tc.subAgentTrace!, breadcrumb ?? '', depth + 1, tc.id),
+    );
+    return [entry, ...hoisted];
+  });
+}

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

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,52 @@
+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`, `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'>;
+}