@dxos/plugin-assistant 0.8.4-main.ae835ea → 0.8.4-main.bcb3aa67d6

package/src/containers/PromptList/PromptList.stories.tsx

@@ -0,0 +1,130 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { SERVICES_CONFIG } from '@dxos/ai/testing';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Prompt } from '@dxos/blueprints';
+import { Filter } from '@dxos/echo';
+import { AutomationPlugin } from '@dxos/plugin-automation';
+import { ClientPlugin } from '@dxos/plugin-client';
+import { Markdown } from '@dxos/plugin-markdown/types';
+import { corePlugins } from '@dxos/plugin-testing';
+import { Config } from '@dxos/react-client';
+import { useQuery, useSpaces } from '@dxos/react-client/echo';
+import { Panel } from '@dxos/react-ui';
+import { Loading, withLayout } from '@dxos/react-ui/testing';
+import { Organization } from '@dxos/types';
+
+import { AssistantPlugin } from '../../AssistantPlugin';
+import { translations } from '../../translations';
+import { TracePanel } from '../TracePanel';
+
+import { PromptList } from './PromptList';
+
+// TODO(burdon): Factor out (see assistant-stories)
+export const config = {
+  remote: new Config({
+    runtime: {
+      services: SERVICES_CONFIG.REMOTE,
+    },
+  }),
+  persistent: new Config({
+    runtime: {
+      client: {
+        storage: {
+          persistent: true,
+        },
+      },
+      services: SERVICES_CONFIG.REMOTE,
+    },
+  }),
+  local: new Config({
+    runtime: {
+      services: SERVICES_CONFIG.LOCAL,
+    },
+  }),
+};
+
+const DefaultStory = () => {
+  const spaces = useSpaces();
+  const space = spaces[spaces.length - 1];
+  const [subject] = useQuery(space?.db, Filter.type(Organization.Organization));
+  if (!subject) {
+    return <Loading data={{ space: !!space, subject: !!subject }} />;
+  }
+
+  return (
+    <Panel.Root>
+      <Panel.Toolbar className='flex p-1 items-center'>
+        <PromptList subject={subject} role='toolbar-input' />
+      </Panel.Toolbar>
+      <Panel.Content>
+        <TracePanel space={space} />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-assistant/containers/PromptList',
+  render: DefaultStory,
+  decorators: [
+    withLayout({ layout: 'column' }),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          types: [Prompt.Prompt, Organization.Organization, Markdown.Document],
+          config: config.remote,
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* Effect.promise(() => client.halo.createIdentity());
+              const space = yield* Effect.promise(() => client.spaces.create());
+              yield* Effect.promise(() => space.waitUntilReady());
+              space.db.add(
+                Organization.make({
+                  name: 'DXOS',
+                }),
+              );
+              space.db.add(
+                Prompt.make({
+                  name: 'Summarize',
+                  instructions: 'Create a new markdown document that is a summary of the selected object.',
+                }),
+              );
+              space.db.add(
+                Prompt.make({
+                  name: 'Analyze',
+                  instructions: 'Analyze the selected content.',
+                }),
+              );
+              space.db.add(
+                Prompt.make({
+                  name: 'Translate',
+                  instructions: 'Translate the selected content to Spanish.',
+                }),
+              );
+            }),
+        }),
+
+        AssistantPlugin(),
+        AutomationPlugin(),
+      ],
+    }),
+  ],
+  parameters: {
+    layout: 'centered',
+    translations,
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/containers/PromptList/PromptList.tsx

@@ -0,0 +1,49 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { DatabaseBlueprint, MarkdownBlueprint, WebSearchBlueprint } from '@dxos/assistant-toolkit';
+import { Prompt } from '@dxos/blueprints';
+import { Filter, Obj, Ref } from '@dxos/echo';
+import { IconButton } from '@dxos/react-ui';
+import { useQuery } from '@dxos/react-client/echo';
+import { ObjectSurfaceProps } from '@dxos/app-toolkit/ui';
+
+import { AssistantOperation } from '#operations';
+
+export type PromptListProps = ObjectSurfaceProps<Obj.Unknown>;
+
+export const PromptList = ({ subject }: PromptListProps) => {
+  const { invokePromise } = useOperationInvoker();
+  const db = Obj.getDatabase(subject);
+  const prompts = useQuery(db, Filter.type(Prompt.Prompt));
+  if (!db) {
+    return null;
+  }
+
+  return (
+    <div role='none' className='flex gap-2'>
+      {prompts.map((prompt, i) => (
+        <div key={i}>
+          <IconButton
+            icon='ph--magic-wand--regular'
+            label={Obj.getLabel(prompt) ?? Obj.getDXN(prompt).toString()}
+            onClick={() => {
+              void invokePromise(AssistantOperation.RunPromptInNewChat, {
+                db,
+                prompt: Ref.make(prompt),
+                objects: [subject],
+                // TODO(burdon): Concifgure from Prompt object.
+                blueprints: [DatabaseBlueprint.key, WebSearchBlueprint.key, MarkdownBlueprint.key],
+                background: true,
+              });
+            }}
+          />
+        </div>
+      ))}
+    </div>
+  );
+};

package/src/containers/PromptList/index.ts

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

package/src/containers/TracePanel/TracePanel.tsx

@@ -0,0 +1,258 @@
+//
+// 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 { Filter, Query } from '@dxos/echo';
+import { AtomQuery } from '@dxos/echo-atom';
+import { FeedTraceSink, Process } from '@dxos/functions-runtime';
+import { DXN } from '@dxos/keys';
+import { LogLevel } from '@dxos/log';
+import { useComputeRuntimeService, useTriggerRuntimeControls } from '@dxos/plugin-automation/hooks';
+import { type Space } from '@dxos/react-client/echo';
+import { Panel, useTranslation } from '@dxos/react-ui';
+import { mx } from '@dxos/ui-theme';
+import { Timeline, type Commit } from '@dxos/react-ui-components';
+
+import { AGENT_PROCESS_KEY, CompleteBlock } from '@dxos/assistant';
+import { Trace } from '@dxos/functions';
+import { SpaceId } from '@dxos/keys';
+
+import { meta } from '#meta';
+
+import { ProcessTree } from '../../components';
+
+export const TracePanel = ({ space }: { space: Space }) => {
+  const { t } = useTranslation(meta.id);
+  const { invokePromise } = useOperationInvoker();
+  const { state, start, stop } = useTriggerRuntimeControls(space.db);
+  const activeProcesses = useActiveProcesses(space.id);
+  const isRunning = state?.enabled ?? false;
+  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()),
+      );
+    }),
+    (_) => 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.data.block.text,
+                    event.timestamp,
+                  );
+                } else {
+                  builder.addAssistantMessage(
+                    event.id,
+                    event.meta.conversationId ?? 'unknown_conversation',
+                    event.data.block.text,
+                    event.timestamp,
+                  );
+                }
+                break;
+              }
+              case 'toolCall': {
+                builder.addToolCall(
+                  `${event.data.block.toolCallId}:call`,
+                  event.meta.conversationId ?? 'unknown_conversation',
+                  event.data.block.name,
+                  event.timestamp,
+                );
+                break;
+              }
+              case 'toolResult': {
+                builder.addToolResult(
+                  `${event.data.block.toolCallId}:result`,
+                  event.meta.conversationId ?? 'unknown_conversation',
+                  event.data.block.error,
+                  event.timestamp,
+                );
+                break;
+              }
+            }
+          }
+        }
+
+        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>();
+
+  #addCommit(commit: Commit) {
+    this.#branches.add(commit.branch);
+    this.#commits.push(commit);
+    this.#lastCommitByBranch.set(commit.branch, commit.id);
+  }
+
+  #defaultParents(branch: string) {
+    return this.#lastCommitByBranch.get(branch) ? [this.#lastCommitByBranch.get(branch)!] : [];
+  }
+
+  build() {
+    return {
+      commits: this.#commits,
+      branches: [...this.#branches],
+    };
+  }
+
+  addUserMessage(id: string, coversationId: string, text: string, ts: number) {
+    this.#addCommit({
+      id,
+      branch: coversationId,
+      parents: this.#defaultParents(coversationId),
+      icon: 'ph--paper-plane-right--regular',
+      level: LogLevel.VERBOSE,
+      message: text.slice(0, 100),
+      timestamp: new Date(ts),
+    });
+  }
+
+  addAssistantMessage(id: string, coversationId: string, text: string, ts: number) {
+    this.#addCommit({
+      id,
+      branch: coversationId,
+      parents: this.#defaultParents(coversationId),
+      icon: 'ph--robot--regular',
+      level: LogLevel.VERBOSE,
+      message: text.slice(0, 100),
+      timestamp: new Date(ts),
+    });
+  }
+
+  addToolCall(id: string, coversationId: string, toolName: string, ts: number) {
+    this.#addCommit({
+      id,
+      branch: coversationId,
+      parents: this.#defaultParents(coversationId),
+      icon: 'ph--wrench--regular',
+      level: LogLevel.INFO,
+      message: toolName,
+      timestamp: new Date(ts),
+    });
+  }
+
+  addToolResult(id: string, coversationId: string, error: string | undefined, ts: number) {
+    this.#addCommit({
+      id,
+      branch: coversationId,
+      parents: this.#defaultParents(coversationId),
+      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),
+    });
+  }
+}

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();
+    });
+  });
+});