@dxos/plugin-assistant 0.8.4-main.406dc2a → 0.8.4-main.422d1c7879

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/types';
+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.change(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,100 @@
+//
+// 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';
+import { ClientPlugin } from '@dxos/plugin-client';
+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 { AssistantPlugin } from '../../AssistantPlugin';
+import { translations } from '../../translations';
+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 = {};

package/src/containers/AgentProperties/AgentProperties.tsx

@@ -0,0 +1,127 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom';
+import { useAtomValue } from '@effect-atom/atom-react';
+import * as Option from 'effect/Option';
+import React, { useCallback, useEffect, useMemo } from 'react';
+
+import { useCapability } from '@dxos/app-framework/ui';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Agent, SyncTriggers } from '@dxos/assistant-toolkit';
+import { DXN, Obj, Ref } from '@dxos/echo';
+import { AtomObj } from '@dxos/echo-atom';
+import { log } from '@dxos/log';
+import { Operation } from '@dxos/operation';
+import { AutomationCapabilities } from '@dxos/plugin-automation/types';
+import { Filter, useQuery } from '@dxos/react-client/echo';
+import { Input, useTranslation } from '@dxos/react-ui';
+import { FeedAnnotation } from '@dxos/schema';
+
+import { meta } from '#meta';
+
+export type AgentPropertiesProps = AppSurface.ObjectPropertiesProps<Agent.Agent>;
+
+export const AgentProperties = ({ subject: agent }: AgentPropertiesProps) => {
+  const { t } = useTranslation(meta.id);
+  const db = Obj.getDatabase(agent);
+
+  // TODO(burdon): Factor out (separate component from container)?
+  const computeRuntime = useCapability(AutomationCapabilities.ComputeRuntime);
+  useEffect(() => {
+    if (!db) {
+      return;
+    }
+
+    return Obj.subscribe(agent, () => {
+      queueMicrotask(() => {
+        const runtime = computeRuntime.getRuntime(db.spaceId);
+        runtime
+          .runPromise(
+            Operation.invoke(SyncTriggers, {
+              agent: Ref.make(agent),
+            }),
+          )
+          .catch((err) => log.catch(err));
+      });
+    });
+  }, [db, agent, computeRuntime]);
+
+  // Build a filter matching objects of any schema annotated as a feed.
+  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;
+    });
+
+    return feedSchemas.length === 0 ? Filter.nothing() : Filter.or(...feedSchemas.map((schema) => Filter.type(schema)));
+  }, [db]);
+
+  const subscribedObjects = useQuery(db, feedFilter);
+
+  // Query all existing subscriptions (e.g., mail, calendar, etc.)
+  const existingSubscriptions = useAtomValue(
+    useMemo(
+      () =>
+        AtomObj.make(agent).pipe((_) =>
+          Atom.make((get) => {
+            const agentObj = get(_);
+            const selectedSubscriptions: Obj.Unknown[] = subscribedObjects.filter((object) =>
+              agentObj.subscriptions.some((subscription) => DXN.equals(subscription.dxn, Obj.getDXN(object))),
+            );
+
+            return selectedSubscriptions;
+          }),
+        ),
+      [agent, subscribedObjects],
+    ),
+  );
+
+  // Create/remove agent subscription.
+  const handleSubscriptionChange = useCallback(
+    (object: Obj.Unknown, checked: boolean) => {
+      Obj.change(agent, (agent) => {
+        if (checked) {
+          agent.subscriptions.push(Ref.fromDXN(Obj.getDXN(object)));
+        } else {
+          agent.subscriptions = agent.subscriptions.filter(
+            (subscription) => !DXN.equals(subscription.dxn, Obj.getDXN(object)),
+          );
+        }
+      });
+    },
+    [agent],
+  );
+
+  if (subscribedObjects.length === 0) {
+    return null;
+  }
+
+  return (
+    <div role='none' className='dx-expander flex flex-col'>
+      <Input.Root>
+        <Input.Label classNames='mt-form-gap'>{t('subscriptions.label')}</Input.Label>
+      </Input.Root>
+
+      {subscribedObjects.map((object) => (
+        <Input.Root key={object.id}>
+          <div className='flex items-center gap-2'>
+            <Input.Checkbox
+              checked={existingSubscriptions.includes(object)}
+              onCheckedChange={(checked) => {
+                handleSubscriptionChange(object, checked === true);
+              }}
+            />
+            <Input.Label>{Obj.getLabel(object) ?? object.id}</Input.Label>
+          </div>
+        </Input.Root>
+      ))}
+    </div>
+  );
+};

package/src/containers/AgentProperties/index.ts

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

package/src/containers/BlueprintArticle/BlueprintArticle.tsx

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { type Blueprint } from '@dxos/blueprints';
+import { Panel, Toolbar } from '@dxos/react-ui';
+import { useAttention } from '@dxos/react-ui-attention';
+
+import { TemplateEditor } from '#components';
+
+export type BlueprintArticleProps = AppSurface.ObjectArticleProps<Blueprint.Blueprint>;
+
+export const BlueprintArticle = ({ role, attendableId, subject }: BlueprintArticleProps) => {
+  const { hasAttention } = useAttention(attendableId);
+
+  return (
+    <Panel.Root role={role} classNames='dx-document'>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root disabled={!hasAttention} />
+      </Panel.Toolbar>
+      <Panel.Content asChild>
+        <TemplateEditor id={subject.id} template={subject.instructions} />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};

package/src/containers/BlueprintArticle/index.ts

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

package/src/containers/ChatCompanion/ChatCompanion.tsx

@@ -0,0 +1,142 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Array from 'effect/Array';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import React, { forwardRef, useCallback, useMemo } from 'react';
+
+import { useCapabilities, useOperationInvoker } from '@dxos/app-framework/ui';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Chat } from '@dxos/assistant-toolkit';
+import { Blueprint } from '@dxos/blueprints';
+import { getSpace } from '@dxos/client/echo';
+import { Filter, Obj, Ref } from '@dxos/echo';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
+import { useQuery } from '@dxos/react-client/echo';
+import { useAsyncEffect } from '@dxos/react-ui';
+
+import { type ChatEvent } from '#components';
+import { useBlueprintRegistry, useContextBinder } from '#hooks';
+import { AssistantOperation } from '#operations';
+
+import ChatContainer from '../ChatContainer';
+
+export type ChatCompanionProps = AppSurface.ArticleProps<Chat.Chat, {}, Obj.Unknown>;
+
+export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
+  ({ role, subject: chat, companionTo, attendableId }, forwardedRef) => {
+    const { invokePromise } = useOperationInvoker();
+    const blueprintRegistry = useBlueprintRegistry();
+    const space = getSpace(companionTo);
+    const feedTarget = chat?.feed.target;
+    const binder = useContextBinder(space, feedTarget);
+
+    // Persist chat on first submit.
+    const handleEvent = useCallback(
+      async (event: ChatEvent) => {
+        if (!space || !chat) {
+          return;
+        }
+
+        if (event.type === 'submit' && !getSpace(chat)) {
+          await invokePromise(SpaceOperation.AddObject, {
+            object: chat,
+            target: space.db,
+            hidden: true,
+          });
+          await invokePromise(SpaceOperation.AddRelation, {
+            db: space.db,
+            schema: Chat.CompanionTo,
+            source: chat,
+            target: companionTo,
+          });
+          await invokePromise(AssistantOperation.SetCurrentChat, {
+            companionTo,
+            chat,
+          });
+        }
+      },
+      [chat, space, companionTo, invokePromise],
+    );
+
+    const metadata = useCapabilities(AppCapabilities.Metadata);
+    const blueprintKeys = useMemo(
+      () =>
+        Function.pipe(
+          metadata,
+          Array.findFirst(
+            (
+              capability,
+            ): capability is {
+              id: string;
+              metadata: { blueprints?: string[] };
+            } => capability.id === Obj.getTypename(companionTo),
+          ),
+          Option.flatMap((c) => Option.fromNullable(c.metadata.blueprints)),
+          Option.getOrElse(() => [] as string[]),
+        ),
+      [metadata, companionTo],
+    );
+    const existingBlueprints = useQuery(space?.db, Filter.type(Blueprint.Blueprint));
+    const pluginBlueprints = useMemo(
+      () => existingBlueprints.filter((blueprint) => blueprintKeys.includes(blueprint.key)),
+      [existingBlueprints, blueprintKeys],
+    );
+
+    // Initialize related blueprints that are not already in the space.
+    useAsyncEffect(async () => {
+      if (!space) {
+        return;
+      }
+
+      // NOTE: This must be run instead of using the useQuery result to avoid duplicates.
+      const existingBlueprints = await space.db.query(Filter.type(Blueprint.Blueprint)).run();
+      for (const key of blueprintKeys) {
+        const existingBlueprint = existingBlueprints.find((blueprint) => blueprint.key === key);
+        if (existingBlueprint) {
+          continue;
+        }
+
+        const blueprint = blueprintRegistry.getByKey(key);
+        if (!blueprint) {
+          continue;
+        }
+
+        space.db.add(Obj.clone(blueprint, { deep: true }));
+      }
+    }, [space, blueprintRegistry, blueprintKeys]);
+
+    useAsyncEffect(async () => {
+      if (!binder?.isOpen) {
+        return;
+      }
+
+      if (pluginBlueprints.length > 0) {
+        await binder.bind({
+          blueprints: pluginBlueprints.map((blueprint) => Ref.make(blueprint)),
+        });
+      }
+
+      if (Obj.instanceOf(Blueprint.Blueprint, companionTo)) {
+        await binder.bind({ blueprints: [Ref.make(companionTo)] });
+      } else {
+        await binder.bind({ objects: [Ref.make(companionTo)] });
+      }
+    }, [binder, companionTo, blueprintKeys]);
+
+    return (
+      <ChatContainer
+        role={role ?? 'article'}
+        space={space}
+        subject={chat}
+        attendableId={attendableId}
+        companionTo={companionTo}
+        onEvent={handleEvent}
+        ref={forwardedRef}
+      />
+    );
+  },
+);

package/src/containers/ChatCompanion/index.ts

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