@dxos/plugin-assistant 0.8.4-main.c85a9c8dae → 0.8.4-main.dfabb4ec29

package/src/components/Toolbox/Toolbox.stories.tsx

@@ -8,14 +8,14 @@ import React from 'react';
 
 import { withPluginManager } from '@dxos/app-framework/testing';
 import { capabilities } from '@dxos/assistant-toolkit/testing';
-import { ChessPlugin } from '@dxos/plugin-chess';
-import { ClientPlugin } from '@dxos/plugin-client';
-import { MapPlugin } from '@dxos/plugin-map';
-import { TablePlugin } from '@dxos/plugin-table';
+import { ChessPlugin } from '@dxos/plugin-chess/plugin';
+import { ClientPlugin } from '@dxos/plugin-client/plugin';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { MapPlugin } from '@dxos/plugin-map/plugin';
+import { TablePlugin } from '@dxos/plugin-table/plugin';
 import { corePlugins } from '@dxos/plugin-testing';
-import { withTheme } from '@dxos/react-ui/testing';
 
-import { translations } from '../../translations';
+import { translations } from '#translations';
 
 import { Toolbox, type ToolboxProps } from './Toolbox';
 
@@ -28,14 +28,13 @@ const meta = {
   component: Toolbox as any,
   render: DefaultStory,
   decorators: [
-    withTheme(),
     withPluginManager({
       plugins: [
         ...corePlugins(),
         ClientPlugin({
           onClientInitialized: ({ client }) =>
             Effect.gen(function* () {
-              yield* Effect.promise(() => client.halo.createIdentity());
+              yield* initializeIdentity(client);
             }),
         }),
         ChessPlugin(),

package/src/components/Toolbox/Toolbox.tsx

@@ -2,77 +2,84 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { type FC, Fragment, useEffect, useState } from 'react';
+import React, { Fragment, useEffect, useState } from 'react';
 
-import { type Blueprint } from '@dxos/blueprints';
+import { type Blueprint } from '@dxos/compute';
+import { Operation } from '@dxos/compute';
 import { type Database, type Ref } from '@dxos/echo';
-import { Function } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { Filter, useQuery } from '@dxos/react-client/echo';
 import { ScrollArea, type ThemedClassName } from '@dxos/react-ui';
-import { mx } from '@dxos/ui-theme';
+import { composable, composableProps, mx } from '@dxos/ui-theme';
+
+import { ServiceType } from '#types';
 
 import { type AiChatProcessor } from '../../processor';
-import { ServiceType } from '../../types';
 
-export type ToolboxProps = ThemedClassName<{
+export type ToolboxProps = {
   services?: { service: ServiceType }[];
-  functions?: Function.Function[];
+  functions?: Operation.PersistentOperation[];
   // TODO(burdon): Combine into single array.
   blueprints?: readonly Blueprint.Blueprint[];
   activeBlueprints?: readonly Ref.Ref<Blueprint.Blueprint>[];
-}>;
-
-export const Toolbox = ({ classNames, functions, services, blueprints, activeBlueprints }: ToolboxProps) => {
-  return (
-    <ScrollArea.Root thin orientation='vertical'>
-      <ScrollArea.Viewport classNames={classNames}>
-        {blueprints && blueprints.length > 0 && (
-          <Section
-            title='Blueprints'
-            items={blueprints.map(({ name, description, tools }) => ({
-              name,
-              description,
-              subitems: tools.map((toolId) => ({ name: `∙ ${safeToolId(toolId)}` })),
-            }))}
-          />
-        )}
-
-        {activeBlueprints && activeBlueprints.length > 0 && (
-          <Section
-            title='Blueprints'
-            items={activeBlueprints.map(({ target }) => ({
-              name: target?.name ?? '',
-              description: target?.description ?? '',
-              subitems: target?.tools.map((toolId) => ({ name: `∙ ${safeToolId(toolId)}` })),
-            }))}
-          />
-        )}
-
-        {services && services.length > 0 && (
-          <Section
-            title='Services'
-            items={services.map(({ service: { serviceId, name, description } }) => ({
-              name: name ?? serviceId,
-              description,
-              // subitems: tools.map(({ name, description }) => ({ name: `∙ ${name}`, description })),
-            }))}
-          />
-        )}
-
-        {functions && functions.length > 0 && (
-          <Section title='Functions' items={functions.map(({ name, description }) => ({ name, description }))} />
-        )}
-      </ScrollArea.Viewport>
-    </ScrollArea.Root>
-  );
 };
 
-const Section: FC<{
+export const Toolbox = composable<HTMLDivElement, ToolboxProps>(
+  ({ functions, services, blueprints, activeBlueprints, ...props }, forwardedRef) => {
+    return (
+      <ScrollArea.Root {...composableProps(props)} thin orientation='vertical' ref={forwardedRef}>
+        <ScrollArea.Viewport>
+          {blueprints && blueprints.length > 0 && (
+            <Section
+              title='Blueprints'
+              items={blueprints.map(({ name, description, tools }) => ({
+                name,
+                description,
+                subitems: tools.map((toolId) => ({ name: `∙ ${safeToolId(toolId)}` })),
+              }))}
+            />
+          )}
+
+          {activeBlueprints && activeBlueprints.length > 0 && (
+            <Section
+              title='Blueprints'
+              items={activeBlueprints.map(({ target }) => ({
+                name: target?.name ?? '',
+                description: target?.description ?? '',
+                subitems: target?.tools.map((toolId) => ({ name: `∙ ${safeToolId(toolId)}` })),
+              }))}
+            />
+          )}
+
+          {services && services.length > 0 && (
+            <Section
+              title='Services'
+              items={services.map(({ service: { serviceId, name, description } }) => ({
+                name: name ?? serviceId,
+                description,
+                // subitems: tools.map(({ name, description }) => ({ name: `∙ ${name}`, description })),
+              }))}
+            />
+          )}
+
+          {functions && functions.length > 0 && (
+            <Section title='Functions' items={functions.map(({ name, description }) => ({ name, description }))} />
+          )}
+        </ScrollArea.Viewport>
+      </ScrollArea.Root>
+    );
+  },
+);
+
+Toolbox.displayName = 'Toolbox';
+
+type SectionProps = {
   title: string;
   items: { name: string; description?: string; subitems?: { name: string; description?: string }[] }[];
   striped?: boolean;
-}> = ({ title, items, striped }) => {
+};
+
+const Section = ({ title, items, striped }: SectionProps) => {
   const stripeClassNames = 'odd:bg-neutral-50 dark:odd:bg-neutral-800';
   const gridClassNames = 'grid grid-cols-[8rem_1fr]';
   const subGridClassNames = mx('col-span-full grid grid-cols-subgrid text-xs px-2', striped && stripeClassNames);
@@ -102,12 +109,12 @@ const Section: FC<{
   );
 };
 
-export type ToolboxContainerProps = ThemedClassName<{
+export type ToolboxPanelProps = ThemedClassName<{
   db?: Database.Database;
   processor?: AiChatProcessor;
 }>;
 
-export const ToolboxContainer = ({ classNames, db, processor }: ToolboxContainerProps) => {
+export const ToolboxPanel = ({ classNames, db, processor }: ToolboxPanelProps) => {
   // Registered services.
   const services = useQuery(db, Filter.type(ServiceType));
   const [serviceTools, setServiceTools] = useState<{ service: ServiceType }[]>([]);
@@ -123,7 +130,7 @@ export const ToolboxContainer = ({ classNames, db, processor }: ToolboxContainer
   }, [services]);
 
   // Deployed functions.
-  const functions = useQuery(db, Filter.type(Function.Function));
+  const functions = useQuery(db, Filter.type(Operation.PersistentOperation));
 
   return (
     <Toolbox

package/src/components/index.ts

@@ -2,6 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
+import { type ComponentType, lazy } from 'react';
+
 export * from './Chat';
+export * from './ProcessTree';
 export * from './TemplateEditor';
 export * from './Toolbox';
+
+export const AssistantSettings: ComponentType<any> = lazy(() => import('./AssistantSettings'));

package/src/containers/AgentArticle/AgentArticle.stories.tsx

@@ -0,0 +1,120 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Plan, Agent } from '@dxos/assistant-toolkit';
+import { Obj, Ref } from '@dxos/echo';
+import { AutomationPlugin } from '@dxos/plugin-automation/plugin';
+import { ClientPlugin } from '@dxos/plugin-client/plugin';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { PreviewPlugin } from '@dxos/plugin-preview/testing';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { random } from '@dxos/random';
+import { Filter, useQuery, useSpaces } from '@dxos/react-client/echo';
+import { Loading, withTheme } from '@dxos/react-ui/testing';
+import { Text } from '@dxos/schema';
+import { createObjectFactory, TypeSpec } from '@dxos/schema/testing';
+import { Message, Organization, Person } from '@dxos/types';
+
+import { createMessage } from '#testing';
+import { translations } from '#translations';
+
+import { AssistantPlugin } from '../../AssistantPlugin';
+import { AgentArticle } from './AgentArticle';
+
+random.seed(1);
+
+type DefaultStoryProps = {
+  spec?: TypeSpec[];
+  inputs?: boolean;
+};
+
+const DefaultStory = (_: DefaultStoryProps) => {
+  const [space] = useSpaces();
+  const [agent] = useQuery(space?.db, Filter.type(Agent.Agent));
+  if (!agent) {
+    return <Loading />;
+  }
+
+  return <AgentArticle role='article' subject={agent} attendableId='story' />;
+};
+
+const meta = {
+  title: 'plugins/plugin-assistant/containers/AgentArticle',
+  render: DefaultStory,
+  decorators: [
+    withTheme(),
+    withPluginManager<DefaultStoryProps>(({ args: { spec = [], inputs } }) => ({
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          types: [Agent.Agent, Message.Message, Plan.Plan, Text.Text, Organization.Organization, Person.Person],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* initializeIdentity(client);
+              const [space] = client.spaces.get();
+              yield* Effect.promise(() => space.waitUntilReady());
+
+              const factory = createObjectFactory(space.db, random as any);
+              const artifacts = yield* Effect.promise(() => factory(spec));
+
+              const inputQueue = space.queues.create();
+              if (inputs) {
+                yield* Effect.promise(() =>
+                  inputQueue.append([
+                    createMessage('user', [{ _tag: 'text', text: 'Summarize the current artifacts.' }]),
+                    createMessage('assistant', [
+                      { _tag: 'text', text: 'Here is a quick overview of the organizations and contacts in context.' },
+                    ]),
+                    createMessage('user', [{ _tag: 'text', text: 'Flag anything that needs follow-up.' }]),
+                  ]),
+                );
+              }
+
+              space.db.add(
+                Obj.make(Agent.Agent, {
+                  instructions: Ref.make(Text.make()),
+                  plan: Ref.make(Plan.makePlan({ tasks: [] })),
+                  artifacts: artifacts.map((obj) => ({
+                    name: Obj.getLabel(obj) ?? 'Artifact',
+                    data: Ref.make(obj),
+                  })),
+                  queue: Ref.fromDXN(inputQueue.dxn),
+                  subscriptions: [],
+                }),
+              );
+            }),
+        }),
+        AutomationPlugin(),
+        AssistantPlugin(),
+        PreviewPlugin(),
+        StorybookPlugin({}),
+      ],
+    })),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<DefaultStoryProps>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    inputs: true,
+    spec: [
+      { type: Organization.Organization, count: 10 },
+      { type: Person.Person, count: 10 },
+    ],
+  },
+};
+
+export const Empty: Story = {};

package/src/containers/AgentArticle/AgentArticle.tsx

@@ -0,0 +1,200 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Atom, useAtomValue } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import React, { forwardRef, useCallback, useMemo, useState } from 'react';
+
+import { Surface, useCapabilities } from '@dxos/app-framework/ui';
+import { AppSurface, useObjectMenuItems } from '@dxos/app-toolkit/ui';
+import { Agent } from '@dxos/assistant-toolkit';
+import { Annotation, Filter, Obj, Query, Ref } from '@dxos/echo';
+import { AtomObj, AtomRef } from '@dxos/echo-atom';
+import { QueueService } from '@dxos/functions';
+import { AutomationCapabilities } from '@dxos/plugin-automation';
+import { useQuery } from '@dxos/react-client/echo';
+import { Card, Message, Panel, ScrollArea, Toolbar, useTranslation } from '@dxos/react-ui';
+import { Masonry } from '@dxos/react-ui-masonry';
+import { Menu } from '@dxos/react-ui-menu';
+import { Focus, Mosaic, type MosaicTileProps } from '@dxos/react-ui-mosaic';
+import { composable } from '@dxos/ui-theme';
+import { isNonNullable } from '@dxos/util';
+
+import { meta } from '#meta';
+
+type Tab = 'artifacts' | 'inputs';
+
+export type AgentArticleProps = AppSurface.ObjectArticleProps<Agent.Agent>;
+
+export const AgentArticle = ({ role, subject: agent }: AgentArticleProps) => {
+  const { t } = useTranslation(meta.id);
+  const [tab, setTab] = useState<Tab>('artifacts');
+  const [viewport, setViewport] = useState<HTMLElement | null>(null);
+
+  const [computeRuntime] = useCapabilities(AutomationCapabilities.ComputeRuntime);
+  // TODO(burdon): Clear input queue also.
+  const handleResetHistory = useCallback(async () => {
+    if (!computeRuntime) {
+      return;
+    }
+
+    const space = Obj.getDatabase(agent);
+    if (!space) {
+      return;
+    }
+
+    const runtime = computeRuntime.getRuntime(space.spaceId);
+    await runtime.runPromise(Agent.resetChatHistory(agent));
+    if (!agent.queue) {
+      await runtime.runPromise(
+        Effect.gen(function* () {
+          const queue = yield* QueueService.createQueue();
+          Obj.update(agent, (agent) => {
+            agent.queue = Ref.fromDXN(queue.dxn);
+          });
+        }),
+      );
+    }
+  }, [agent, computeRuntime]);
+
+  const artifacts = useAtomValue(
+    useMemo(
+      () =>
+        AtomObj.make(agent).pipe((agent) =>
+          Atom.make((get) => {
+            return get(agent)
+              .artifacts.map((artifact) => get(AtomRef.make(artifact.data)))
+              .filter(isNonNullable);
+          }),
+        ),
+      [agent],
+    ),
+  );
+
+  const inputQueue = useAtomValue(
+    AtomObj.make(agent).pipe((_) =>
+      Atom.make((get) =>
+        Option.fromNullable(get(_).queue).pipe(Option.map(AtomRef.make), Option.map(get), Option.getOrUndefined),
+      ),
+    ),
+  );
+
+  const inputObjects = useQuery(inputQueue, Query.select(Filter.everything()));
+
+  return (
+    <Panel.Root role={role}>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root>
+          <Toolbar.ToggleGroup type='single' value={tab} onValueChange={(value) => value && setTab(value as Tab)}>
+            <Toolbar.ToggleGroupIconItem value='artifacts' label={t('artifacts.label')} icon='ph--cube--regular' />
+            <Toolbar.ToggleGroupIconItem value='inputs' label={t('input-queue.label')} icon='ph--queue--regular' />
+          </Toolbar.ToggleGroup>
+          <Toolbar.Separator />
+          <Toolbar.IconButton
+            icon='ph--trash--regular'
+            label={t('reset-history.button')}
+            onCanPlay={handleResetHistory}
+          />
+        </Toolbar.Root>
+      </Panel.Toolbar>
+      <Panel.Content className='dx-container flex flex-col'>
+        {tab === 'artifacts' && (
+          <>
+            {artifacts.length === 0 && (
+              <Message.Root classNames='m-2' valence='info'>
+                <Message.Title>{t('project-empty-spec.message')}</Message.Title>
+                <Message.Content>{t('project-empty-spec.description')}</Message.Content>
+              </Message.Root>
+            )}
+
+            <Masonry.Root Tile={MasonryArtifactTile}>
+              <Masonry.Content padding thin centered>
+                <Masonry.Viewport items={artifacts} getId={(item: Obj.Unknown) => item.id} />
+              </Masonry.Content>
+            </Masonry.Root>
+          </>
+        )}
+
+        {tab === 'inputs' && (
+          <Mosaic.Container asChild withFocus autoScroll={viewport} classNames='dx-document'>
+            <ScrollArea.Root orientation='vertical' padding thin centered>
+              <ScrollArea.Viewport ref={setViewport}>
+                <Mosaic.VirtualStack
+                  Tile={StackTile}
+                  classNames='gap-2'
+                  draggable={false}
+                  estimateSize={() => 160}
+                  gap={8}
+                  getId={(item: Obj.Unknown) => item.id}
+                  getScrollElement={() => viewport}
+                  items={inputObjects}
+                />
+              </ScrollArea.Viewport>
+            </ScrollArea.Root>
+          </Mosaic.Container>
+        )}
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+const ArtifactTileCard = composable<HTMLDivElement, { data: Obj.Unknown }>(({ data, ...props }, forwardedRef) => {
+  const objectMenuItems = useObjectMenuItems(data);
+  const icon = Function.pipe(
+    Obj.getSchema(data),
+    Option.fromNullable,
+    Option.flatMap(Annotation.IconAnnotation.get),
+    Option.map(({ icon }) => icon),
+    Option.getOrElse(() => 'ph--placeholder--regular'),
+  );
+
+  return (
+    <Card.Root {...props} ref={forwardedRef} data-testid='board-item' fullWidth>
+      <Card.Toolbar>
+        <Card.IconBlock padding>
+          <Card.Icon icon={icon} />
+        </Card.IconBlock>
+        <Card.Title>{Obj.getLabel(data)}</Card.Title>
+        {/* TODO(wittjosiah): Reconcile with Card.Menu. */}
+        <Card.IconBlock padding>
+          <Menu.Trigger asChild disabled={!objectMenuItems?.length}>
+            <Toolbar.IconButton iconOnly variant='ghost' icon='ph--dots-three-vertical--regular' label='Actions' />
+          </Menu.Trigger>
+          <Menu.Content items={objectMenuItems} />
+        </Card.IconBlock>
+      </Card.Toolbar>
+      <Card.Content>
+        <Surface.Surface
+          type={AppSurface.Card}
+          limit={1}
+          data={{ subject: data } satisfies AppSurface.ObjectCardData}
+        />
+      </Card.Content>
+    </Card.Root>
+  );
+});
+
+ArtifactTileCard.displayName = 'ArtifactTileCard';
+
+const MasonryArtifactTile = ({ data }: { data: Obj.Unknown; index: number }) => (
+  <Menu.Root>
+    <ArtifactTileCard data={data} />
+  </Menu.Root>
+);
+
+const StackTile = forwardRef<HTMLDivElement, MosaicTileProps<Obj.Unknown>>(
+  ({ data, location, debug, current }, forwardedRef) => (
+    <Menu.Root>
+      <Mosaic.Tile asChild id={data.id} data={data} location={location} debug={debug}>
+        <Focus.Item asChild current={current}>
+          <ArtifactTileCard ref={forwardedRef} data={data} />
+        </Focus.Item>
+      </Mosaic.Tile>
+    </Menu.Root>
+  ),
+);
+
+StackTile.displayName = 'StackTile';

package/src/containers/AgentArticle/index.ts

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

package/src/containers/AgentProperties/AgentProperties.stories.tsx

@@ -0,0 +1,101 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Plan, Agent } from '@dxos/assistant-toolkit';
+import { Obj, Ref } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { AutomationPlugin } from '@dxos/plugin-automation/plugin';
+import { ClientPlugin } from '@dxos/plugin-client/plugin';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { corePlugins } from '@dxos/plugin-testing';
+import { Filter, useQuery, useSpaces } from '@dxos/react-client/echo';
+import { Button } from '@dxos/react-ui';
+import { ObjectProperties } from '@dxos/react-ui-form';
+import { Loading, withLayout } from '@dxos/react-ui/testing';
+import { Text } from '@dxos/schema';
+import { Organization } from '@dxos/types';
+
+import { translations } from '#translations';
+
+import { AssistantPlugin } from '../../AssistantPlugin';
+import { AgentProperties } from './AgentProperties';
+
+type DefaultStoryProps = {};
+
+const DefaultStory = (_: DefaultStoryProps) => {
+  const [space] = useSpaces();
+  const [agent] = useQuery(space?.db, Filter.type(Agent.Agent));
+  if (!agent) {
+    return <Loading />;
+  }
+
+  return (
+    <ObjectProperties object={agent}>
+      <AgentProperties role='object-properties' subject={agent} />
+      <Button
+        classNames='mt-form-gap'
+        onClick={() => {
+          log.info('agent', { agent, instructions: agent.instructions.target });
+        }}
+      >
+        Debug
+      </Button>
+    </ObjectProperties>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-assistant/containers/AgentProperties',
+  render: DefaultStory,
+  decorators: [
+    withLayout({ layout: 'column' }),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          types: [Agent.Agent, Plan.Plan, Text.Text, Organization.Organization],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* initializeIdentity(client);
+              const [space] = client.spaces.get();
+              yield* Effect.promise(() => space.waitUntilReady());
+
+              const organization = space.db.add(
+                Obj.make(Organization.Organization, {
+                  name: 'Acme Corp',
+                  description: 'Sample organization for the story.',
+                }),
+              );
+
+              space.db.add(
+                Obj.make(Agent.Agent, {
+                  instructions: Ref.make(Text.make()),
+                  plan: Ref.make(Plan.makePlan({ tasks: [] })),
+                  artifacts: [{ name: 'Organization', data: Ref.make(organization) }],
+                  subscriptions: [],
+                }),
+              );
+            }),
+        }),
+        AutomationPlugin(),
+        AssistantPlugin(),
+      ],
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<DefaultStoryProps>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};