@dxos/plugin-assistant 0.8.4-main.72ec0f3 → 0.8.4-main.74a063c4e0

package/src/containers/ProjectSettings/ProjectSettings.tsx

@@ -0,0 +1,139 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom';
+import { useAtomValue } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import React, { useCallback, useEffect, useMemo } from 'react';
+
+import { useCapability, useOperationInvoker } from '@dxos/app-framework/ui';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Project, SyncTriggers } from '@dxos/assistant-toolkit';
+import { DXN, Obj, Ref } from '@dxos/echo';
+import { AtomObj, AtomRef } from '@dxos/echo-atom';
+import { QueueService } from '@dxos/functions';
+import { AutomationCapabilities } from '@dxos/plugin-automation/types';
+import { MarkdownEditor } from '@dxos/plugin-markdown';
+import { Filter, useQuery } from '@dxos/react-client/echo';
+import { useObject } from '@dxos/react-client/echo';
+import { Button } from '@dxos/react-ui';
+import { useTranslation, Input } from '@dxos/react-ui';
+import { FeedAnnotation } from '@dxos/schema';
+
+import { meta } from '#meta';
+
+export type ProjectSettingsProps = AppSurface.ObjectSettingsProps<Project.Project>;
+
+export const ProjectSettings = ({ subject: project }: ProjectSettingsProps) => {
+  const { t } = useTranslation(meta.id);
+  const computeRuntime = useCapability(AutomationCapabilities.ComputeRuntime);
+  const { invokePromise } = useOperationInvoker();
+
+  const handleResetHistory = useCallback(async () => {
+    const runtime = computeRuntime.getRuntime(Obj.getDatabase(project)!.spaceId);
+    await runtime.runPromise(Project.resetChatHistory(project));
+    if (!project.queue) {
+      await runtime.runPromise(
+        Effect.gen(function* () {
+          const queue = yield* QueueService.createQueue();
+          Obj.change(project, (project) => {
+            project.queue = Ref.fromDXN(queue.dxn);
+          });
+        }),
+      );
+    }
+  }, [project, computeRuntime]);
+
+  const spec = useAtomValue(AtomRef.make(project.spec));
+  const [specInitialValue] = useObject(spec, 'content');
+
+  useEffect(() => {
+    const db = Obj.getDatabase(project);
+    if (!db) return;
+    return Obj.subscribe(project, () => {
+      queueMicrotask(() => void invokePromise(SyncTriggers, { project: Ref.make(project) }));
+    });
+  }, [project, invokePromise]);
+
+  const db = Obj.getDatabase(project);
+  const feedFilter = useMemo(() => {
+    if (!db) {
+      return Filter.nothing();
+    }
+
+    const schemas = db.schemaRegistry.query({ location: ['database', 'runtime'] }).runSync();
+    const feedSchemas = schemas.filter((schema) => {
+      const annotation = FeedAnnotation.get(schema);
+      return Option.isSome(annotation) && annotation.value === true;
+    });
+
+    if (feedSchemas.length === 0) {
+      return Filter.nothing();
+    }
+
+    return Filter.or(...feedSchemas.map((schema) => Filter.type(schema)));
+  }, [db]);
+  const subscribableObjects = useQuery(db, feedFilter);
+
+  const existingSubscripts = useAtomValue(
+    useMemo(
+      () =>
+        AtomObj.make(project).pipe((_) =>
+          Atom.make((get) => {
+            const project = get(_);
+            const selectedSubscriptions: Obj.Unknown[] = subscribableObjects.filter((object) =>
+              project.subscriptions.some((subscription) => DXN.equals(subscription.dxn, Obj.getDXN(object))),
+            );
+
+            return selectedSubscriptions;
+          }),
+        ),
+      [project, subscribableObjects],
+    ),
+  );
+
+  return (
+    <div role='none' className='dx-container grid grid-rows-[min-content_1fr_min-content] gap-2 pb-trim-md'>
+      <div role='none' className='flex flex-col'>
+        <Input.Root>
+          <Input.Label>{t('subscriptions.label')}</Input.Label>
+        </Input.Root>
+        {subscribableObjects.map((object) => (
+          <Input.Root key={object.id}>
+            <div className='flex items-center gap-2'>
+              <Input.Checkbox
+                checked={existingSubscripts.includes(object)}
+                onCheckedChange={(checked) => {
+                  Obj.change(project, (project) => {
+                    if (checked) {
+                      project.subscriptions.push(Ref.fromDXN(Obj.getDXN(object)));
+                    } else {
+                      project.subscriptions = project.subscriptions.filter(
+                        (subscription) => !DXN.equals(subscription.dxn, Obj.getDXN(object)),
+                      );
+                    }
+                  });
+                }}
+              />
+              <Input.Label>{Obj.getLabel(object) ?? object.id}</Input.Label>
+            </div>
+          </Input.Root>
+        ))}
+      </div>
+      <div className='dx-expander flex flex-col'>
+        <Input.Root>
+          <Input.Label>{t('instructions.label')}</Input.Label>
+          {spec && (
+            <MarkdownEditor.Root id={spec.id} object={spec}>
+              <MarkdownEditor.Content initialValue={specInitialValue} />
+            </MarkdownEditor.Root>
+          )}
+        </Input.Root>
+      </div>
+      {/* TODO(burdon): Move into toolbar in parent. */}
+      <Button onClick={handleResetHistory}>{t('reset-history.button')}</Button>
+    </div>
+  );
+};

package/src/containers/ProjectSettings/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export { ProjectSettings as default } from './ProjectSettings';

package/src/containers/PromptArticle/PromptArticle.tsx

@@ -0,0 +1,59 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useMemo } from 'react';
+
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { AgentPrompt } from '@dxos/assistant-toolkit';
+import { type Prompt } from '@dxos/blueprints';
+import { Obj } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { Operation } from '@dxos/operation';
+import { useComputeRuntimeCallback } from '@dxos/plugin-automation/hooks';
+import { Panel, Toolbar, useTranslation } from '@dxos/react-ui';
+import { useAttention } from '@dxos/react-ui-attention';
+
+import { TemplateEditor } from '#components';
+import { meta } from '#meta';
+
+export type PromptArticleProps = AppSurface.ObjectArticleProps<Prompt.Prompt>;
+
+export const PromptArticle = ({ role, attendableId, subject }: PromptArticleProps) => {
+  const { t } = useTranslation(meta.id);
+  const { hasAttention } = useAttention(attendableId);
+  const db = Obj.getDatabase(subject);
+
+  const inputData = useMemo<Operation.Definition.Input<typeof AgentPrompt> | undefined>(
+    () =>
+      subject && db
+        ? {
+            prompt: db.makeRef(Obj.getDXN(subject)),
+            input: {},
+          }
+        : undefined,
+    [subject, db],
+  );
+
+  const handleRun = useComputeRuntimeCallback(
+    db?.spaceId,
+    () => {
+      invariant(inputData);
+      return Operation.invoke(AgentPrompt, inputData);
+    },
+    [inputData],
+  );
+
+  return (
+    <Panel.Root role={role} className='dx-document'>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root disabled={!hasAttention} onClick={handleRun}>
+          <Toolbar.IconButton iconOnly icon='ph--play--regular' label={t('run-prompt.label')} onClick={handleRun} />
+        </Toolbar.Root>
+      </Panel.Toolbar>
+      <Panel.Content asChild>
+        <TemplateEditor id={subject.id} template={subject.instructions} />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};

package/src/containers/PromptArticle/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { PromptArticle as default } from './PromptArticle';

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

@@ -0,0 +1,129 @@
+//
+// 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 { type AppSurface } from '@dxos/app-toolkit/ui';
+import { DatabaseBlueprint, MarkdownBlueprint, WebSearchBlueprint } from '@dxos/assistant-toolkit';
+import { Prompt } from '@dxos/blueprints';
+import { Filter, Obj, Ref } from '@dxos/echo';
+import { useQuery } from '@dxos/react-client/echo';
+import { IconButton } from '@dxos/react-ui';
+
+import { AssistantOperation } from '#operations';
+
+export type PromptListProps = AppSurface.ObjectSectionProps<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,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { PromptList as default } from './PromptList';

package/src/containers/TracePanel/TracePanel.tsx

@@ -0,0 +1,305 @@
+//
+// 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()),
+      );
+    }),
+    (_) => 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;
+              }
+            }
+          }
+
+          // Process operation trace events.
+          if (Trace.isOfType(Trace.OperationStart, event)) {
+            builder.addOperationStart(
+              `${event.id}:${event.data.key}:start`,
+              event.data.name ?? event.data.key,
+              event.timestamp,
+            );
+          }
+          if (Trace.isOfType(Trace.OperationEnd, event)) {
+            builder.addOperationEnd(
+              `${event.id}:${event.data.key}:end`,
+              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>();
+
+  #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),
+    });
+  }
+
+  addOperationStart(id: string, operationName: string, ts: number) {
+    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,
+    operationName: string,
+    outcome: 'success' | 'failure',
+    error: string | undefined,
+    ts: number,
+  ) {
+    const isError = outcome === 'failure';
+    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),
+    });
+  }
+}
+
+/**
+ * Branch name for top-level operation invocations.
+ */
+const OPERATIONS_BRANCH = 'operations';