@dxos/plugin-assistant 0.8.4-main.7996785055 → 0.8.4-main.8baae0fced

package/src/containers/TracePanel/TracePanel.tsx

@@ -4,344 +4,174 @@
 
 import { Atom } from '@effect-atom/atom';
 import { useAtomValue } from '@effect-atom/atom-react';
-import * as Array from 'effect/Array';
 import { pipe } from 'effect/Function';
-import * as Schema from 'effect/Schema';
-import React, { useCallback, useMemo } from 'react';
+import React, { useCallback, useMemo, useState } from 'react';
 
-import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { Capabilities } from '@dxos/app-framework';
+import { useCapability, useAtomCapability, useOperationInvoker } from '@dxos/app-framework/ui';
 import { LayoutOperation } from '@dxos/app-toolkit';
-import { Filter, Obj, Query } from '@dxos/echo';
-import { AtomObj, AtomQuery, AtomRef } from '@dxos/echo-atom';
-import { InvocationOutcome, InvocationTraceEndEvent, InvocationTraceStartEvent } from '@dxos/functions-runtime';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Process, Trace } from '@dxos/compute';
+import { Filter, Query } from '@dxos/echo';
+import { AtomQuery } from '@dxos/echo-atom';
+import { FeedTraceSink } from '@dxos/functions-runtime';
 import { DXN } from '@dxos/keys';
-import { dbg, LogLevel } from '@dxos/log';
-import { useTriggerRuntimeControls } from '@dxos/plugin-automation';
+import { log } from '@dxos/log';
 import { type Space } from '@dxos/react-client/echo';
-import { Input, Panel, Toolbar, useTranslation } from '@dxos/react-ui';
+import { ScrollContainer } from '@dxos/react-ui';
+import { useAttentionAttributes } from '@dxos/react-ui-attention';
 import { Timeline, type Commit } from '@dxos/react-ui-components';
-import { Message, type ContentBlock } from '@dxos/types';
-
-import { extractFirstDxnFromToolInput, extractFirstDxnFromToolResult } from './dxn-extractor';
-import { meta } from '../../meta';
-
-export const TracePanel = ({ space }: { space: Space }) => {
-  const { t } = useTranslation(meta.id);
-  const { invokePromise } = useOperationInvoker();
-  const { state, start, stop } = useTriggerRuntimeControls(space.db);
-  const isRunning = state?.enabled ?? false;
-
-  const { branches, commits } = useAtomValue(useMemo(() => getExecutionGraph(space), [space]));
-
-  const handleCommitClick = useCallback(
-    (commit: Commit) => {
-      if (commit.link) {
-        const dxn = DXN.tryParse(commit.link)?.asEchoDXN();
-        if (dxn?.spaceId && dxn.echoId) {
-          // TODO(dmaretskyi): Navigates, but fails to open.
-          void invokePromise(LayoutOperation.Open, { subject: [`${dxn.spaceId}:${dxn.echoId}`] });
+import { Syntax } from '@dxos/react-ui-syntax-highlighter';
+import { composable, composableProps, mx } from '@dxos/ui-theme';
+
+import { ProcessTree, ProcessTreeProps } from '#components';
+import { buildExecutionGraph, type ExecutionGraph } from '#execution-graph';
+import { AssistantCapabilities } from '#types';
+
+export type TracePanelProps = AppSurface.SpaceArticleProps<Pick<ProcessTreeProps, 'onProcessTerminate'>>;
+
+export const TracePanel = composable<HTMLDivElement, TracePanelProps>(
+  ({ space, attendableId, onProcessTerminate, ...props }, forwardedRef) => {
+    const attentionAttrs = useAttentionAttributes(attendableId);
+    const { invokePromise } = useOperationInvoker();
+    const settings = useAtomCapability(AssistantCapabilities.Settings);
+    const tracePanelDebug = settings.tracePanelDebug ?? false;
+    const { branches, commits, spanTree, details } = useExecutionGraph(space);
+    const monitor = useCapability(Capabilities.ProcessMonitor);
+    const processes = useAtomValue(monitor?.processTreeAtom ?? atomEmpty);
+
+    const [selectedCommit, setSelectedCommit] = useState<Commit | undefined>();
+    const handleCommitSelect = useCallback(
+      (commit: Commit | undefined) => {
+        setSelectedCommit(commit);
+        if (commit?.link) {
+          const dxn = DXN.tryParse(commit.link)?.asEchoDXN();
+          if (dxn?.spaceId && dxn.echoId) {
+            // TODO(dmaretskyi): Navigates, but fails to open.
+            void invokePromise(LayoutOperation.Open, {
+              subject: [`${dxn.spaceId}:${dxn.echoId}`],
+            });
+          }
         }
-      }
-    },
-    [invokePromise],
-  );
+      },
+      [invokePromise, setSelectedCommit],
+    );
+
+    // Select current branch.
+    const [currentBranch, setCurrentBranch] = useState<string | null>(null);
+    const handleProcessSelect = useCallback(
+      (process: Process.Info) => {
+        const branch = branches.find((branch) => branch === process.pid.toString());
+        if (branch) {
+          setCurrentBranch(branch);
+        }
+      },
+      [branches],
+    );
+
+    return (
+      <div
+        {...composableProps(props, {
+          ...attentionAttrs,
+          classNames: mx(
+            'h-full grid divide-y divide-separator',
+            !tracePanelDebug && selectedCommit
+              ? 'grid-rows-[minmax(0,4lh)_1fr_minmax(0,206px)]'
+              : 'grid-rows-[minmax(0,4lh)_1fr]',
+          ),
+        })}
+        ref={forwardedRef}
+      >
+        <ProcessTree
+          processes={processes}
+          onProcessSelect={handleProcessSelect}
+          onProcessTerminate={onProcessTerminate}
+        />
+
+        <ScrollContainer.Root pin>
+          <ScrollContainer.Content thin>
+            <ScrollContainer.Fade />
+            <ScrollContainer.Viewport>
+              {tracePanelDebug ? (
+                <Syntax.Root data={spanTree}>
+                  <Syntax.Content>
+                    <Syntax.Viewport>
+                      <Syntax.Code className='text-xs' />
+                    </Syntax.Viewport>
+                  </Syntax.Content>
+                </Syntax.Root>
+              ) : (
+                <Timeline
+                  compact
+                  commits={commits}
+                  branches={branches}
+                  currentBranch={currentBranch}
+                  onSelect={handleCommitSelect}
+                />
+              )}
+            </ScrollContainer.Viewport>
+            <ScrollContainer.ScrollDownButton />
+          </ScrollContainer.Content>
+        </ScrollContainer.Root>
+
+        {!tracePanelDebug && selectedCommit && (
+          <Syntax.Root data={details[selectedCommit.id] ?? selectedCommit}>
+            <Syntax.Content>
+              <Syntax.Viewport>
+                <Syntax.Code className='text-xs' />
+              </Syntax.Viewport>
+            </Syntax.Content>
+          </Syntax.Root>
+        )}
+      </div>
+    );
+  },
+);
+
+// Stable ref.
+const atomEmpty = Atom.make(() => [] as const);
+
+type UseExecutionGraphOptions = {
+  eventLimit?: number;
+};
 
-  return (
-    <Panel.Root>
-      <Panel.Toolbar asChild>
-        <Toolbar.Root>
-          <Input.Root>
-            <div className='flex items-center gap-2'>
-              <Input.Switch checked={isRunning} onCheckedChange={isRunning ? stop : start} />
-              <Input.Label>{t('trigger runtime label')}</Input.Label>
-            </div>
-          </Input.Root>
-        </Toolbar.Root>
-      </Panel.Toolbar>
-      <Panel.Content>
-        <Timeline branches={branches} commits={commits} compact onCommitClick={handleCommitClick} />
-      </Panel.Content>
-    </Panel.Root>
+const useExecutionGraph = (space: Space, { eventLimit }: UseExecutionGraphOptions = {}): ExecutionGraph => {
+  const monitor = useCapability(Capabilities.ProcessMonitor);
+  const activeProcesses = useAtomValue(monitor?.processTreeAtom ?? atomEmpty);
+
+  const atom = useMemo(
+    () => getExecutionGraph(space, activeProcesses, { eventLimit }),
+    [space, activeProcesses, eventLimit],
   );
-};
 
-type InvocationInfo = {
-  startEvent: InvocationTraceStartEvent;
-  endEvent: InvocationTraceEndEvent | null;
-  subevents: Obj.Unknown[];
+  return useAtomValue(atom);
 };
 
 const getExecutionGraph = (
   space: Space,
-  {
-    invocationsLimit = 100,
-    subeventsLimit = 20,
-    showSubeventsForLastNInvocations = 4,
-  }: { invocationsLimit?: number; subeventsLimit?: number; showSubeventsForLastNInvocations?: number } = {},
-): Atom.Atom<{
-  branches: string[];
-  commits: Commit[];
-}> => {
+  activeProcesses: readonly Process.Info[] = [],
+  { eventLimit = 300 }: UseExecutionGraphOptions = {},
+): Atom.Atom<ExecutionGraph> => {
   return pipe(
-    space.properties,
-    (_) => AtomObj.make(_),
-    // space properies => Atom<Atom<InvocationTraceEvent[]>>
-    (_) =>
-      Atom.make((get) => {
-        const queueDxn = get(_).invocationTraceQueue?.dxn;
-        return AtomQuery.make(
-          space.db,
-          !queueDxn
-            ? (Query.select(Filter.nothing()) as Query.Query<never>) // TODO(dmaretskyi): Broken echo types here.
-            : Query.select(
-                Filter.or(Filter.type(InvocationTraceStartEvent), Filter.type(InvocationTraceEndEvent)),
-              ).from({
-                queues: [queueDxn.toString()],
-              }),
-        );
-      }),
-    // Flatten atoms
+    AtomQuery.make(space.db, FeedTraceSink.query),
+    Atom.map((feeds) => {
+      log('trace panel query trace feeds', { spaceId: space.id, feedCount: feeds.length });
+      // TODO(dmaretskyi): This should be possible in a single query with properly working limit(1) and feed > feed contents traversal.
+      return AtomQuery.make(
+        space.db,
+        feeds.length > 0
+          ? Query.type(Trace.Message).from(feeds[0])
+          : (Query.select(Filter.nothing()) as Query.Query<never>),
+      );
+    }),
     (_) => Atom.make((get) => get(get(_))),
-    // Atom<InvocationTraceEvent[]> => Atom<InvocationInfo[]>
-    (_) =>
-      Atom.make((get) => {
-        const events = get(_);
-        const invocations: InvocationInfo[] = [];
-
-        for (const event of events) {
-          if (Schema.is(InvocationTraceStartEvent)(event)) {
-            const invocationInfo: InvocationInfo = {
-              startEvent: event,
-              endEvent: null,
-              subevents: [],
-            };
-            invocations.push(invocationInfo);
-          } else if (Schema.is(InvocationTraceEndEvent)(event)) {
-            const invocationInfo = invocations.find((i) => i.startEvent.invocationId === event.invocationId);
-            if (invocationInfo) {
-              invocationInfo.endEvent = event;
-            }
-          }
-        }
-
-        let expandedBudget = showSubeventsForLastNInvocations;
-        for (let i = invocations.length - 1; i >= 0; i--) {
-          const invocation = invocations[i];
-          if (!invocation.startEvent.invocationTraceQueue) {
-            continue;
-          }
-          const subevents = get(
-            AtomQuery.make(
-              space.db,
-              Query.select(Filter.everything())
-                .limit(subeventsLimit)
-                .from({ queues: [invocation.startEvent.invocationTraceQueue?.dxn?.toString()] }),
-            ),
-          );
-          invocation.subevents = subevents;
-          if (subevents.length > 0) {
-            expandedBudget--;
-          }
-          if (expandedBudget <= 0) {
-            break;
-          }
-        }
-
-        return invocations;
-      }),
-
-    // Build commit graph from InvocationInfo[]
     (_) =>
-      Atom.make((get) => {
-        const invocations = get(_);
-        // Two alternating branches for subevents to save horizontal space.
-        const branches: string[] = ['invocations'];
-        const commits: Commit[] = [];
-
-        const sorted = invocations.sort((a, b) => a.startEvent.timestamp - b.startEvent.timestamp);
-        let idx = 0;
-        for (const invocation of sorted.slice(-invocationsLimit)) {
-          const trigger = invocation.startEvent.trigger && AtomRef.make(invocation.startEvent.trigger).pipe(get);
-          const fn =
-            (invocation.startEvent.invocationTarget &&
-              AtomRef.make(invocation.startEvent.invocationTarget).pipe(get)) ??
-            (trigger?.function && AtomRef.make(trigger.function).pipe(get));
-          const chat =
-            invocation.startEvent.chat && AtomRef.make(invocation.startEvent.chat).pipe(get, AtomObj.make, get);
-          dbg(chat);
-
-          const functionName = fn ? Obj.getLabel(fn) : undefined;
-          const triggerName = trigger?.spec?.kind ?? 'trigger';
-          const label = chat
-            ? (Obj.getLabel(chat) ?? 'New Chat')
-            : functionName
-              ? `${functionName} on ${triggerName}`
-              : triggerName;
-
-          const branchName = `invocation-${invocation.startEvent.invocationId.slice(0, 8)}`;
-
-          // Collapse completed invocations with no intermediate events.
-          if (invocation.endEvent && invocation.subevents.length === 0) {
-            commits.push({
-              id: invocation.endEvent.id,
-              branch: 'invocations',
-              parents: commits.length > 0 ? [commits.at(-1)!.id] : [],
-              icon: chat
-                ? 'ph--atom--regular'
-                : invocation.endEvent.outcome === InvocationOutcome.SUCCESS
-                  ? 'ph--check-circle--regular'
-                  : 'ph--x-circle--regular',
-              link: chat ? Obj.getDXN(chat).toString() : undefined,
-              level: invocation.endEvent.outcome === InvocationOutcome.SUCCESS ? LogLevel.INFO : LogLevel.ERROR,
-              message: `${label} - ${invocation.endEvent.outcome}`,
-              timestamp: new Date(invocation.endEvent.timestamp),
-            });
-            continue;
-          }
-
-          // Start of the invocation.
-          commits.push({
-            id: invocation.startEvent.id,
-            branch: 'invocations',
-            parents: commits.length > 0 ? [commits.at(-1)!.id] : [],
-            icon: chat ? 'ph--atom--regular' : invocation.endEvent ? 'ph--play--regular' : 'ph--spinner-gap--regular',
-            level: invocation.endEvent ? LogLevel.INFO : LogLevel.VERBOSE,
-            message: label,
-            timestamp: new Date(invocation.startEvent.timestamp),
-          });
-
-          // Subevents of the invocation.
-          // Track tool call IDs to their corresponding DXNs for linking tool results.
-          const toolCallDxns = new Map<string, string>();
-
-          let prevBlockTag: ContentBlock.Any['_tag'] | undefined;
-          for (const subevent of invocation.subevents.slice(-subeventsLimit)) {
-            if (Obj.instanceOf(Message.Message, subevent)) {
-              for (const block of subevent.blocks) {
-                switch (block._tag) {
-                  case 'text': {
-                    if (prevBlockTag === 'text') {
-                      continue; // Skip consecutive text blocks.
-                    }
-                    prevBlockTag = block._tag;
-                    commits.push({
-                      id: subevent.id,
-                      branch: branchName,
-                      parents: [commits.at(-1)!.id],
-                      icon: subevent.sender.role === 'user' ? 'ph--paper-plane-right--regular' : 'ph--robot--regular',
-                      level: LogLevel.VERBOSE,
-                      message: block.text.slice(0, 100),
-                      timestamp: new Date(subevent.created),
-                    });
-                    if (!branches.includes(branchName)) {
-                      branches.push(branchName);
-                    }
-                    break;
-                  }
-                  case 'toolCall': {
-                    // Extract DXN from tool call input.
-                    const dxn = extractFirstDxnFromToolInput(block.input);
-                    const link = dxn?.toString();
-                    if (link) {
-                      toolCallDxns.set(block.toolCallId, link);
-                    }
-
-                    // Only show tool results.
-                    // commits.push({
-                    //   id: subevent.id,
-                    //   branch: branchName,
-                    //   parents: [commits.at(-1)!.id],
-                    //   icon: 'ph--wrench--regular',
-                    //   level: LogLevel.VERBOSE,
-                    //   message: block.name,
-                    //   timestamp: new Date(subevent.created),
-                    //   link,
-                    // });
-                    // if (!branches.includes(branchName)) {
-                    //   branches.push(branchName);
-                    // }
-                    break;
-                  }
-                  case 'toolResult': {
-                    // Extract DXN from tool result, or use the one from the corresponding tool call.
-                    const resultDxn = extractFirstDxnFromToolResult(block.result);
-                    const link = resultDxn?.toString() ?? toolCallDxns.get(block.toolCallId);
-
-                    prevBlockTag = block._tag;
-                    commits.push({
-                      id: `${subevent.id}_toolCall_${block.toolCallId}`,
-                      branch: branchName,
-                      parents: [commits.at(-1)!.id],
-                      icon: 'ph--wrench--regular',
-                      level: block.error ? LogLevel.ERROR : LogLevel.VERBOSE,
-                      message: block.error ? `${block.name}: ${block.error.slice(0, 50)}` : block.name,
-                      timestamp: new Date(subevent.created),
-                      link,
-                    });
-                    if (!branches.includes(branchName)) {
-                      branches.push(branchName);
-                    }
-                    break;
-                  }
-                  case 'reference': {
-                    // Extract DXN from reference block.
-                    const refDxn = block.reference?.dxn;
-                    const link = refDxn?.toString();
-
-                    commits.push({
-                      id: `${subevent.id}_ref`,
-                      branch: branchName,
-                      parents: [commits.at(-1)!.id],
-                      icon: 'ph--link--regular',
-                      level: LogLevel.INFO,
-                      message: 'Reference',
-                      timestamp: new Date(subevent.created),
-                      link,
-                    });
-                    if (!branches.includes(branchName)) {
-                      branches.push(branchName);
-                    }
-                    break;
-                  }
-                }
-              }
-            }
-          }
-
-          // "Running..." trailing event for invocations that haven't completed.
-          if (!invocation.endEvent && invocation.subevents.length > 0) {
-            commits.push({
-              id: invocation.startEvent.invocationId + 'pending',
-              branch: branchName,
-              parents: [commits.at(-1)!.id],
-              icon: 'ph--dots-three-vertical--regular',
-              level: LogLevel.VERBOSE,
-              message: 'Running...',
-              timestamp: new Date(),
-            });
-          }
-
-          // End of the invocation, merging back into main. Only if there were subevents.
-          if (invocation.endEvent && invocation.subevents.length > 0) {
-            commits.push({
-              id: invocation.endEvent.id,
-              branch: 'invocations',
-              parents: Array.dedupe([invocation.startEvent.invocationId, commits.at(-1)!.id]),
-              icon:
-                invocation.endEvent.outcome === InvocationOutcome.SUCCESS
-                  ? 'ph--check-circle--regular'
-                  : 'ph--x-circle--regular',
-              level: invocation.endEvent.outcome === InvocationOutcome.SUCCESS ? LogLevel.INFO : LogLevel.ERROR,
-              message: `${label} - ${invocation.endEvent.outcome === InvocationOutcome.SUCCESS ? 'Success' : 'Failure'}`,
-              timestamp: new Date(invocation.endEvent.timestamp),
-            });
-          }
-        }
-
-        // Sort in time order.
-        commits.sort((a, b) => (a.timestamp?.getTime() ?? 0) - (b.timestamp?.getTime() ?? 0));
-
-        return { branches, commits };
-      }),
+      Atom.make((get) =>
+        buildExecutionGraph({
+          traceMessages: [...get(_)],
+          activeProcesses,
+          eventLimit,
+        }),
+      ),
   );
 };

package/src/containers/TracePanel/dxn-extractor.test.ts

@@ -6,41 +6,41 @@ import { describe, test } from 'vitest';
 
 import {
   extractDxnsFromObject,
-  extractDxnsFromString,
+  extractDxnFromString,
   extractFirstDxnFromToolInput,
   extractFirstDxnFromToolResult,
 } from './dxn-extractor';
 
 describe('dxn-extractor', () => {
-  describe('extractDxnsFromString', () => {
+  describe('extractDxnFromString', () => {
     test('extracts plain DXN from string', ({ expect }) => {
-      const result = extractDxnsFromString('Found object dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+      const result = extractDxnFromString('Found object dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
       expect(result).toHaveLength(1);
       expect(result[0].toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
     });
 
     test('extracts @dxn prefixed reference from string', ({ expect }) => {
-      const result = extractDxnsFromString('Reference to @dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4 in text');
+      const result = extractDxnFromString('Reference to @dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4 in text');
       expect(result).toHaveLength(1);
       expect(result[0].toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
     });
 
     test('extracts multiple DXNs from string', ({ expect }) => {
-      const result = extractDxnsFromString(
+      const result = extractDxnFromString(
         'Objects: dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4 and @dxn:queue:data:SPACE:QUEUE:01KG7R1ZXWFMWQ4DA1Q6TN1DG5',
       );
       expect(result).toHaveLength(2);
     });
 
     test('deduplicates DXNs', ({ expect }) => {
-      const result = extractDxnsFromString(
+      const result = extractDxnFromString(
         'Same object dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4 and dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4',
       );
       expect(result).toHaveLength(1);
     });
 
     test('returns empty array for string without DXNs', ({ expect }) => {
-      const result = extractDxnsFromString('No DXNs here');
+      const result = extractDxnFromString('No DXNs here');
       expect(result).toHaveLength(0);
     });
   });

package/src/containers/TracePanel/dxn-extractor.ts

@@ -28,7 +28,7 @@ const AT_DXN_PATTERN = /@(dxn:[a-zA-Z0-9]+(?::[a-zA-Z0-9@_-]+)+)/g;
 /**
  * Extracts all DXN references from a string.
  */
-export const extractDxnsFromString = (text: string): DXN[] => {
+export const extractDxnFromString = (text: string): DXN[] => {
   const dxns: DXN[] = [];
   const seen = new Set<string>();
 
@@ -68,7 +68,7 @@ export const extractDxnsFromObject = (obj: unknown): DXN[] => {
   const dxns: DXN[] = [];
   const seen = new Set<string>();
 
-  const addDxn = (dxnStr: string) => {
+  const addDXN = (dxnStr: string) => {
     if (!seen.has(dxnStr)) {
       const dxn = DXN.tryParse(dxnStr);
       if (dxn) {
@@ -86,14 +86,14 @@ export const extractDxnsFromObject = (obj: unknown): DXN[] => {
     if (typeof value === 'string') {
       // Check if the string itself is a DXN.
       if (value.startsWith('dxn:')) {
-        addDxn(value);
+        addDXN(value);
       } else if (value.startsWith('@dxn:')) {
-        addDxn(value.slice(1));
+        addDXN(value.slice(1));
       }
       // Also extract DXNs from within the string.
-      const extracted = extractDxnsFromString(value);
+      const extracted = extractDxnFromString(value);
       for (const dxn of extracted) {
-        addDxn(dxn.toString());
+        addDXN(dxn.toString());
       }
       return;
     }
@@ -112,7 +112,7 @@ export const extractDxnsFromObject = (obj: unknown): DXN[] => {
       if ('/' in record && typeof record['/'] === 'string') {
         const dxnStr = record['/'];
         if (typeof dxnStr === 'string' && dxnStr.startsWith('dxn:')) {
-          addDxn(dxnStr);
+          addDXN(dxnStr);
         }
       }
 
@@ -120,7 +120,7 @@ export const extractDxnsFromObject = (obj: unknown): DXN[] => {
       if ('@dxn' in record && typeof record['@dxn'] === 'string') {
         const dxnStr = record['@dxn'];
         if (typeof dxnStr === 'string' && dxnStr.startsWith('dxn:')) {
-          addDxn(dxnStr);
+          addDXN(dxnStr);
         }
       }
 
@@ -128,7 +128,7 @@ export const extractDxnsFromObject = (obj: unknown): DXN[] => {
       if (record._tag === 'reference' && record.reference && typeof record.reference === 'object') {
         const ref = record.reference as Record<string, unknown>;
         if (ref.dxn && typeof ref.dxn === 'string') {
-          addDxn(ref.dxn);
+          addDXN(ref.dxn);
         }
       }
 
@@ -153,7 +153,7 @@ export const extractFirstDxnFromToolInput = (input: string): DXN | undefined =>
     return dxns[0];
   } catch {
     // If JSON parsing fails, try to extract from the raw string.
-    const dxns = extractDxnsFromString(input);
+    const dxns = extractDxnFromString(input);
     return dxns[0];
   }
 };
@@ -172,7 +172,7 @@ export const extractFirstDxnFromToolResult = (result: string | undefined): DXN |
     return dxns[0];
   } catch {
     // If JSON parsing fails, try to extract from the raw string.
-    const dxns = extractDxnsFromString(result);
+    const dxns = extractDxnFromString(result);
     return dxns[0];
   }
 };

package/src/containers/TracePanel/testing/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './simulated-agent';
+export * from './snapshot-playback';