@dxos/plugin-assistant 0.8.4-main.937b3ca → 0.8.4-main.9be5663bfe

package/src/containers/TracePanel/TracePanel.tsx

@@ -0,0 +1,361 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom';
+import { useAtomValue } from '@effect-atom/atom-react';
+import { pipe } from 'effect/Function';
+import React, { useCallback, useMemo } from 'react';
+
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { AGENT_PROCESS_KEY, CompleteBlock } from '@dxos/assistant';
+import { Filter, Query } from '@dxos/echo';
+import { AtomQuery } from '@dxos/echo-atom';
+import { Trace } from '@dxos/functions';
+import { FeedTraceSink, Process } from '@dxos/functions-runtime';
+import { DXN, SpaceId } from '@dxos/keys';
+import { LogLevel } from '@dxos/log';
+import { useComputeRuntimeService } from '@dxos/plugin-automation/hooks';
+import { type Space } from '@dxos/react-client/echo';
+import { Panel } from '@dxos/react-ui';
+import { Timeline, type Commit } from '@dxos/react-ui-components';
+import { mx } from '@dxos/ui-theme';
+
+import { ProcessTree } from '../../components';
+
+export const TracePanel = ({ space }: { space: Space }) => {
+  const { invokePromise } = useOperationInvoker();
+  const activeProcesses = useActiveProcesses(space.id);
+  const runtime = useComputeRuntimeService(Process.ProcessMonitorService, space.id);
+
+  const { branches, commits } = useAtomValue(
+    useMemo(
+      () => getExecutionGraph(space, runtime?.processTreeAtom ?? Atom.make(() => [])),
+      [space, runtime?.processTreeAtom],
+    ),
+  );
+
+  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}`] });
+        }
+      }
+    },
+    [invokePromise],
+  );
+
+  return (
+    <Panel.Root>
+      <Panel.Content className='grid grid-rows-[min-content_1fr]'>
+        <ProcessTree
+          classNames={mx('max-h-[8lh] px-2', activeProcesses.length > 0 && 'border-b border-separator')}
+          processes={activeProcesses}
+        />
+        <Timeline classNames='py-1' branches={branches} commits={commits} compact onCommitClick={handleCommitClick} />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+type InvocationInfo = {
+  eventLimit: number;
+};
+
+const getExecutionGraph = (
+  space: Space,
+  processTreeAtom: Atom.Atom<readonly Process.Info[]>,
+  { eventLimit = 100 }: { eventLimit?: number } = {},
+): Atom.Atom<{
+  branches: string[];
+  commits: Commit[];
+}> => {
+  return pipe(
+    AtomQuery.make(space.db, FeedTraceSink.query),
+    Atom.map((feeds) => {
+      // 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.make((get) => {
+        const builder = new GraphBuilder();
+
+        const events = get(_)
+          .slice(-eventLimit)
+          .flatMap((message) =>
+            message.events.map((event: Trace.Event) => ({
+              id: message.id,
+              meta: message.meta,
+              ...event,
+            })),
+          );
+
+        for (const event of events) {
+          if (Trace.isOfType(CompleteBlock, event)) {
+            switch (event.data.block._tag) {
+              case 'text': {
+                if (event.data.role === 'user') {
+                  builder.addUserMessage(
+                    event.id,
+                    event.meta.conversationId ?? 'unknown_conversation',
+                    event.meta.pid ?? crypto.randomUUID(),
+                    event.data.block.text,
+                    event.timestamp,
+                  );
+                } else {
+                  builder.addAssistantMessage(
+                    event.id,
+                    event.meta.conversationId ?? 'unknown_conversation',
+                    event.meta.pid ?? crypto.randomUUID(),
+                    event.data.block.text,
+                    event.timestamp,
+                  );
+                }
+                break;
+              }
+              case 'status': {
+                builder.addStatusMessage(
+                  event.id,
+                  event.meta.conversationId ?? 'unknown_conversation',
+                  event.meta.pid ?? crypto.randomUUID(),
+                  event.data.block.statusText,
+                  event.timestamp,
+                );
+                break;
+              }
+              case 'toolCall': {
+                builder.addToolCall(
+                  `${event.data.block.toolCallId}:call`,
+                  event.meta.conversationId ?? 'unknown_conversation',
+                  event.meta.pid ?? crypto.randomUUID(),
+                  event.data.block.name,
+                  event.timestamp,
+                );
+                break;
+              }
+              case 'toolResult': {
+                builder.addToolResult(
+                  `${event.data.block.toolCallId}:result`,
+                  event.meta.conversationId ?? 'unknown_conversation',
+                  event.meta.pid ?? crypto.randomUUID(),
+                  event.data.block.error,
+                  event.timestamp,
+                );
+                break;
+              }
+            }
+          }
+
+          // Process operation trace events.
+          if (Trace.isOfType(Trace.OperationStart, event)) {
+            if (!event.meta.conversationId) {
+              // Operations inside conversations will be handled by tool call events.
+              builder.addOperationStart(
+                `${event.id}:${event.data.key}:start`,
+                event.meta.pid ?? crypto.randomUUID(),
+                event.data.name ?? event.data.key,
+                event.timestamp,
+              );
+            }
+          }
+          if (Trace.isOfType(Trace.OperationEnd, event)) {
+            if (!event.meta.conversationId) {
+              // Operations inside conversations will be handled by tool call events.
+              builder.addOperationEnd(
+                `${event.id}:${event.data.key}:end`,
+                event.meta.pid ?? crypto.randomUUID(),
+                event.data.name ?? event.data.key,
+                event.data.outcome,
+                event.data.error,
+                event.timestamp,
+              );
+            }
+          }
+        }
+
+        const activeProcesses = get(processTreeAtom);
+        for (const process of activeProcesses) {
+          if (
+            process.key === AGENT_PROCESS_KEY &&
+            process.params.target &&
+            (process.state === Process.State.RUNNING || process.state === Process.State.HYBERNATING)
+          ) {
+            const conversationId = DXN.parse(process.params.target).asEchoDXN()?.echoId;
+            if (conversationId) {
+              builder.addRunningAgent(process.pid, conversationId, Date.now());
+            }
+          }
+        }
+        return builder.build();
+      }),
+  );
+};
+
+// Stable ref.
+const atomEmpty = Atom.make(() => [] as const);
+
+const useActiveProcesses = (id?: SpaceId) => {
+  const runtime = useComputeRuntimeService(Process.ProcessMonitorService, id);
+  return useAtomValue(runtime?.processTreeAtom ?? atomEmpty);
+};
+
+class GraphBuilder {
+  #commits: Commit[] = [];
+  #branches = new Set<string>();
+  #lastCommitByBranch = new Map<string, string>();
+  #operationPidToStartCommitId = new Map<string, string>();
+
+  #addCommit(commit: Commit, opts?: { replaceCommit?: string }) {
+    this.#branches.add(commit.branch);
+    if (opts?.replaceCommit) {
+      const commitIdx = this.#commits.findIndex((commit) => commit.id === opts.replaceCommit);
+      if (commitIdx !== -1) {
+        this.#commits[commitIdx] = commit;
+      }
+    } else {
+      this.#commits.push(commit);
+      this.#lastCommitByBranch.set(commit.branch, commit.id);
+    }
+  }
+
+  #defaultParents(branch: string, opts?: { branchForFirst?: string }) {
+    return this.#lastCommitByBranch.get(branch)
+      ? [this.#lastCommitByBranch.get(branch)!]
+      : opts?.branchForFirst
+        ? [opts.branchForFirst]
+        : [];
+  }
+
+  build() {
+    return {
+      commits: this.#commits,
+      branches: [...this.#branches],
+    };
+  }
+
+  addUserMessage(id: string, coversationId: string, pid: string, text: string, ts: number) {
+    this.#addCommit({
+      id,
+      branch: coversationId,
+      parents: this.#defaultParents(coversationId, { branchForFirst: this.#operationPidToStartCommitId.get(pid) }),
+      icon: 'ph--paper-plane-right--regular',
+      level: LogLevel.VERBOSE,
+      message: text.slice(0, 100),
+      timestamp: new Date(ts),
+    });
+  }
+
+  addAssistantMessage(id: string, coversationId: string, pid: string, text: string, ts: number) {
+    this.#addCommit({
+      id,
+      branch: coversationId,
+      parents: this.#defaultParents(coversationId, { branchForFirst: this.#operationPidToStartCommitId.get(pid) }),
+      icon: 'ph--drone--regular',
+      level: LogLevel.VERBOSE,
+      message: text.slice(0, 100),
+      timestamp: new Date(ts),
+    });
+  }
+
+  addStatusMessage(id: string, coversationId: string, pid: string, status: string, ts: number) {
+    this.#addCommit({
+      id,
+      branch: coversationId,
+      parents: this.#defaultParents(coversationId, { branchForFirst: this.#operationPidToStartCommitId.get(pid) }),
+      icon: 'ph--dot-outline--regular',
+      level: LogLevel.INFO,
+      message: status,
+      timestamp: new Date(ts),
+    });
+  }
+  addToolCall(id: string, coversationId: string, pid: string, toolName: string, ts: number) {
+    this.#addCommit({
+      id,
+      branch: coversationId,
+      parents: this.#defaultParents(coversationId, { branchForFirst: this.#operationPidToStartCommitId.get(pid) }),
+      icon: 'ph--wrench--regular',
+      level: LogLevel.INFO,
+      message: toolName,
+      timestamp: new Date(ts),
+    });
+  }
+
+  addToolResult(id: string, coversationId: string, pid: string, error: string | undefined, ts: number) {
+    this.#addCommit({
+      id,
+      branch: coversationId,
+      parents: this.#defaultParents(coversationId, { branchForFirst: this.#operationPidToStartCommitId.get(pid) }),
+      icon: error ? 'ph--x-circle--regular' : 'ph--check-circle--regular',
+      level: error ? LogLevel.ERROR : LogLevel.INFO,
+      message: error ? `Error: ${error}` : 'Success',
+      timestamp: new Date(ts),
+    });
+  }
+
+  addRunningAgent(pid: string, conversationId: string, ts: number) {
+    this.#addCommit({
+      id: pid,
+      branch: conversationId,
+      parents: this.#defaultParents(conversationId),
+      icon: 'ph--spinner-gap--regular',
+      level: LogLevel.INFO,
+      message: 'Generating...',
+      timestamp: new Date(ts),
+    });
+  }
+
+  addOperationStart(id: string, pid: string, operationName: string, ts: number) {
+    this.#operationPidToStartCommitId.set(pid, id);
+    this.#addCommit({
+      id,
+      branch: OPERATIONS_BRANCH,
+      parents: this.#defaultParents(OPERATIONS_BRANCH),
+      icon: 'ph--play--regular',
+      level: LogLevel.INFO,
+      message: operationName,
+      timestamp: new Date(ts),
+    });
+  }
+
+  addOperationEnd(
+    id: string,
+    pid: string,
+    operationName: string,
+    outcome: 'success' | 'failure',
+    error: string | undefined,
+    ts: number,
+  ) {
+    const isError = outcome === 'failure';
+    const startCommitId = this.#operationPidToStartCommitId.get(pid);
+    const hasChildren = this.#commits.some((commit) => commit.parents?.includes(startCommitId!));
+    this.#addCommit(
+      {
+        id,
+        branch: OPERATIONS_BRANCH,
+        parents: this.#defaultParents(OPERATIONS_BRANCH),
+        icon: isError ? 'ph--x-circle--regular' : 'ph--check-circle--regular',
+        level: isError ? LogLevel.ERROR : LogLevel.INFO,
+        message: isError ? `${operationName}: ${error ?? 'Failed'}` : operationName,
+        timestamp: new Date(ts),
+      },
+      {
+        replaceCommit: hasChildren ? undefined : this.#operationPidToStartCommitId.get(pid),
+      },
+    );
+  }
+}
+
+/**
+ * Branch name for top-level operation invocations.
+ */
+const OPERATIONS_BRANCH = 'operations';

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

@@ -0,0 +1,153 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import {
+  extractDxnsFromObject,
+  extractDxnsFromString,
+  extractFirstDxnFromToolInput,
+  extractFirstDxnFromToolResult,
+} from './dxn-extractor';
+
+describe('dxn-extractor', () => {
+  describe('extractDxnsFromString', () => {
+    test('extracts plain DXN from string', ({ expect }) => {
+      const result = extractDxnsFromString('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');
+      expect(result).toHaveLength(1);
+      expect(result[0].toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+    });
+
+    test('extracts multiple DXNs from string', ({ expect }) => {
+      const result = extractDxnsFromString(
+        'Objects: dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4 and @dxn:queue:data:SPACE:QUEUE:01KG7R1ZXWFMWQ4DA1Q6TN1DG5',
+      );
+      expect(result).toHaveLength(2);
+    });
+
+    test('deduplicates DXNs', ({ expect }) => {
+      const result = extractDxnsFromString(
+        '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');
+      expect(result).toHaveLength(0);
+    });
+  });
+
+  describe('extractDxnsFromObject', () => {
+    test('extracts IPLD-style reference { "/": "dxn:..." }', ({ expect }) => {
+      const result = extractDxnsFromObject({
+        '/': 'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4',
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+    });
+
+    test('extracts @dxn key reference { "@dxn": "dxn:..." }', ({ expect }) => {
+      const result = extractDxnsFromObject({
+        '@dxn': 'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4',
+        name: 'Test',
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+    });
+
+    test('extracts reference block { _tag: "reference", reference: { dxn: ... } }', ({ expect }) => {
+      const result = extractDxnsFromObject({
+        _tag: 'reference',
+        reference: {
+          dxn: 'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4',
+        },
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+    });
+
+    test('extracts DXN from nested object', ({ expect }) => {
+      const result = extractDxnsFromObject({
+        data: {
+          items: [
+            {
+              ref: { '/': 'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4' },
+            },
+          ],
+        },
+      });
+      expect(result).toHaveLength(1);
+    });
+
+    test('extracts DXN from string property', ({ expect }) => {
+      const result = extractDxnsFromObject({
+        message: 'Created object dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4',
+      });
+      expect(result).toHaveLength(1);
+    });
+
+    test('extracts DXN from array', ({ expect }) => {
+      const result = extractDxnsFromObject([
+        { '/': 'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4' },
+        { '/': 'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG5' },
+      ]);
+      expect(result).toHaveLength(2);
+    });
+
+    test('handles null and undefined', ({ expect }) => {
+      expect(extractDxnsFromObject(null)).toHaveLength(0);
+      expect(extractDxnsFromObject(undefined)).toHaveLength(0);
+    });
+  });
+
+  describe('extractFirstDxnFromToolInput', () => {
+    test('extracts DXN from JSON tool input', ({ expect }) => {
+      const input = JSON.stringify({
+        objectRef: { '/': 'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4' },
+      });
+      const result = extractFirstDxnFromToolInput(input);
+      expect(result?.toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+    });
+
+    test('extracts DXN from invalid JSON string', ({ expect }) => {
+      const input = 'Invalid JSON but contains dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4';
+      const result = extractFirstDxnFromToolInput(input);
+      expect(result?.toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+    });
+
+    test('returns undefined for input without DXNs', ({ expect }) => {
+      const input = JSON.stringify({ name: 'Test' });
+      const result = extractFirstDxnFromToolInput(input);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('extractFirstDxnFromToolResult', () => {
+    test('extracts DXN from JSON tool result', ({ expect }) => {
+      const result = JSON.stringify({
+        created: { '/': 'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4' },
+      });
+      const dxn = extractFirstDxnFromToolResult(result);
+      expect(dxn?.toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+    });
+
+    test('returns undefined for undefined result', ({ expect }) => {
+      const dxn = extractFirstDxnFromToolResult(undefined);
+      expect(dxn).toBeUndefined();
+    });
+
+    test('returns undefined for result without DXNs', ({ expect }) => {
+      const result = JSON.stringify({ success: true });
+      const dxn = extractFirstDxnFromToolResult(result);
+      expect(dxn).toBeUndefined();
+    });
+  });
+});

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

@@ -0,0 +1,178 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { DXN } from '@dxos/keys';
+
+/**
+ * Patterns for extracting DXN references from tool call params/results.
+ *
+ * Supported formats:
+ * - `{ "/": "dxn:..." }` - IPLD-style encoded references
+ * - `{ "@dxn": "dxn:..." }` - Alternative format with @dxn key
+ * - `@dxn:...` - In-text references (with @ prefix)
+ * - `dxn:...` - Plain DXN strings
+ */
+
+/**
+ * Regex to match DXN strings in various formats.
+ * Matches: dxn:kind:part1:part2:...
+ */
+const DXN_PATTERN = /dxn:[a-zA-Z0-9]+(?::[a-zA-Z0-9@_-]+)+/g;
+
+/**
+ * Regex to match @dxn: prefixed references in text.
+ */
+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[] => {
+  const dxns: DXN[] = [];
+  const seen = new Set<string>();
+
+  // Match @dxn: prefixed references.
+  let match;
+  while ((match = AT_DXN_PATTERN.exec(text)) !== null) {
+    const dxnStr = match[1];
+    if (!seen.has(dxnStr)) {
+      const dxn = DXN.tryParse(dxnStr);
+      if (dxn) {
+        dxns.push(dxn);
+        seen.add(dxnStr);
+      }
+    }
+  }
+
+  // Match plain dxn: strings.
+  while ((match = DXN_PATTERN.exec(text)) !== null) {
+    const dxnStr = match[0];
+    if (!seen.has(dxnStr)) {
+      const dxn = DXN.tryParse(dxnStr);
+      if (dxn) {
+        dxns.push(dxn);
+        seen.add(dxnStr);
+      }
+    }
+  }
+
+  return dxns;
+};
+
+/**
+ * Extracts DXN references from a JSON object.
+ * Handles IPLD-style references `{ "/": "dxn:..." }` and `{ "@dxn": "dxn:..." }`.
+ */
+export const extractDxnsFromObject = (obj: unknown): DXN[] => {
+  const dxns: DXN[] = [];
+  const seen = new Set<string>();
+
+  const addDxn = (dxnStr: string) => {
+    if (!seen.has(dxnStr)) {
+      const dxn = DXN.tryParse(dxnStr);
+      if (dxn) {
+        dxns.push(dxn);
+        seen.add(dxnStr);
+      }
+    }
+  };
+
+  const traverse = (value: unknown): void => {
+    if (value === null || value === undefined) {
+      return;
+    }
+
+    if (typeof value === 'string') {
+      // Check if the string itself is a DXN.
+      if (value.startsWith('dxn:')) {
+        addDxn(value);
+      } else if (value.startsWith('@dxn:')) {
+        addDxn(value.slice(1));
+      }
+      // Also extract DXNs from within the string.
+      const extracted = extractDxnsFromString(value);
+      for (const dxn of extracted) {
+        addDxn(dxn.toString());
+      }
+      return;
+    }
+
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        traverse(item);
+      }
+      return;
+    }
+
+    if (typeof value === 'object') {
+      const record = value as Record<string, unknown>;
+
+      // Check for IPLD-style reference: { "/": "dxn:..." }
+      if ('/' in record && typeof record['/'] === 'string') {
+        const dxnStr = record['/'];
+        if (typeof dxnStr === 'string' && dxnStr.startsWith('dxn:')) {
+          addDxn(dxnStr);
+        }
+      }
+
+      // Check for @dxn key: { "@dxn": "dxn:..." }
+      if ('@dxn' in record && typeof record['@dxn'] === 'string') {
+        const dxnStr = record['@dxn'];
+        if (typeof dxnStr === 'string' && dxnStr.startsWith('dxn:')) {
+          addDxn(dxnStr);
+        }
+      }
+
+      // Check for reference blocks: { _tag: 'reference', reference: { 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);
+        }
+      }
+
+      // Recursively traverse all properties.
+      for (const key of Object.keys(record)) {
+        traverse(record[key]);
+      }
+    }
+  };
+
+  traverse(obj);
+  return dxns;
+};
+
+/**
+ * Extracts the first DXN from a tool call input string (JSON).
+ */
+export const extractFirstDxnFromToolInput = (input: string): DXN | undefined => {
+  try {
+    const parsed = JSON.parse(input);
+    const dxns = extractDxnsFromObject(parsed);
+    return dxns[0];
+  } catch {
+    // If JSON parsing fails, try to extract from the raw string.
+    const dxns = extractDxnsFromString(input);
+    return dxns[0];
+  }
+};
+
+/**
+ * Extracts the first DXN from a tool result string (JSON).
+ */
+export const extractFirstDxnFromToolResult = (result: string | undefined): DXN | undefined => {
+  if (!result) {
+    return undefined;
+  }
+
+  try {
+    const parsed = JSON.parse(result);
+    const dxns = extractDxnsFromObject(parsed);
+    return dxns[0];
+  } catch {
+    // If JSON parsing fails, try to extract from the raw string.
+    const dxns = extractDxnsFromString(result);
+    return dxns[0];
+  }
+};

package/src/containers/TracePanel/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { TracePanel } from './TracePanel';
+
+export * from './TracePanel';
+
+export default TracePanel;