@dxos/plugin-automation 0.7.5-main.9d2a38b → 0.7.5-main.b19bfc8

package/src/AutomationPlugin.tsx

@@ -2,17 +2,20 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Capabilities, contributes, defineModule, definePlugin, Events, oneOf } from '@dxos/app-framework';
+import { Capabilities, contributes, createIntent, defineModule, definePlugin, Events } from '@dxos/app-framework';
 import { FunctionTrigger } from '@dxos/functions';
 import { ClientCapabilities, ClientEvents } from '@dxos/plugin-client';
-import { DeckCapabilities } from '@dxos/plugin-deck';
-import { RefArray } from '@dxos/react-client/echo';
+import { DeckCapabilities, DeckEvents } from '@dxos/plugin-deck';
+import { SpaceCapabilities } from '@dxos/plugin-space';
+import { defineObjectForm } from '@dxos/plugin-space/types';
+import { isEchoObject, getSpace } from '@dxos/react-client/echo';
 
-import { AppGraphBuilder, ReactSurface } from './capabilities';
+import { AiClient, AppGraphBuilder, IntentResolver, ReactSurface, AutomationSettings } from './capabilities';
 import { AUTOMATION_PLUGIN, meta } from './meta';
 import translations from './translations';
-import { ChainPromptType, ChainType } from './types';
+import { AutomationAction, AIChatType, ServiceType, TemplateType } from './types';
 
+// TODO(wittjosiah): Rename to AssistantPlugin?
 export const AutomationPlugin = () =>
   definePlugin(meta, [
     defineModule({
@@ -20,44 +23,78 @@ export const AutomationPlugin = () =>
       activatesOn: Events.SetupTranslations,
       activate: () => contributes(Capabilities.Translations, translations),
     }),
+    defineModule({
+      id: `${meta.id}/module/settings`,
+      activatesOn: Events.SetupSettings,
+      activate: AutomationSettings,
+    }),
     defineModule({
       id: `${meta.id}/module/metadata`,
-      activatesOn: oneOf(Events.Startup, Events.SetupAppGraph),
-      activate: () =>
+      activatesOn: Events.SetupMetadata,
+      activate: () => [
+        contributes(Capabilities.Metadata, {
+          id: TemplateType.typename,
+          metadata: {
+            placeholder: ['template title placeholder', { ns: AUTOMATION_PLUGIN }],
+            icon: 'ph--code-block--regular',
+          },
+        }),
         contributes(Capabilities.Metadata, {
-          id: ChainType.typename,
+          id: AIChatType.typename,
           metadata: {
-            placeholder: ['object placeholder', { ns: AUTOMATION_PLUGIN }],
-            icon: 'ph--magic-wand--regular',
-            // TODO(wittjosiah): Move out of metadata.
-            loadReferences: async (chain: ChainType) => await RefArray.loadAll(chain.prompts ?? []),
+            placeholder: ['chat title placeholder', { ns: AUTOMATION_PLUGIN }],
+            icon: 'ph--atom--regular',
           },
         }),
+      ],
+    }),
+    defineModule({
+      id: `${meta.id}/module/object-form`,
+      activatesOn: ClientEvents.SetupSchema,
+      activate: () => [
+        contributes(
+          SpaceCapabilities.ObjectForm,
+          defineObjectForm({
+            objectSchema: AIChatType,
+            getIntent: (_, options) => createIntent(AutomationAction.CreateChat, { spaceId: options.space.id }),
+          }),
+        ),
+        contributes(
+          SpaceCapabilities.ObjectForm,
+          defineObjectForm({
+            objectSchema: TemplateType,
+            getIntent: () => createIntent(AutomationAction.CreateTemplate),
+          }),
+        ),
+      ],
     }),
     defineModule({
       id: `${meta.id}/module/schema`,
-      activatesOn: ClientEvents.SetupClient,
-      activate: () => contributes(ClientCapabilities.SystemSchema, [ChainType, ChainPromptType, FunctionTrigger]),
+      activatesOn: ClientEvents.SetupSchema,
+      activate: () => contributes(ClientCapabilities.Schema, [FunctionTrigger, ServiceType, TemplateType]),
     }),
     defineModule({
       id: `${meta.id}/module/complementary-panels`,
-      activatesOn: Events.Startup,
+      activatesOn: DeckEvents.SetupComplementaryPanels,
       activate: () => [
+        contributes(DeckCapabilities.ComplementaryPanel, {
+          id: 'service-registry',
+          label: ['service registry label', { ns: AUTOMATION_PLUGIN }],
+          icon: 'ph--plugs--regular',
+        }),
         contributes(DeckCapabilities.ComplementaryPanel, {
           id: 'automation',
           label: ['automation panel label', { ns: AUTOMATION_PLUGIN }],
           icon: 'ph--magic-wand--regular',
-        }),
-        contributes(DeckCapabilities.ComplementaryPanel, {
-          id: 'assistant',
-          label: ['assistant panel label', { ns: AUTOMATION_PLUGIN }],
-          icon: 'ph--atom--regular',
+          filter: (node) => isEchoObject(node.data) && !!getSpace(node.data),
         }),
       ],
     }),
     defineModule({
       id: `${meta.id}/module/react-surface`,
-      activatesOn: Events.Startup,
+      activatesOn: Events.SetupReactSurface,
+      // TODO(wittjosiah): Should occur before the chat is loaded when surfaces activation is more granular.
+      activatesBefore: [Events.SetupArtifactDefinition],
       activate: ReactSurface,
     }),
     defineModule({
@@ -65,4 +102,14 @@ export const AutomationPlugin = () =>
       activatesOn: Events.SetupAppGraph,
       activate: AppGraphBuilder,
     }),
+    defineModule({
+      id: `${meta.id}/module/intent-resolver`,
+      activatesOn: Events.SetupIntentResolver,
+      activate: IntentResolver,
+    }),
+    defineModule({
+      id: `${meta.id}/module/ai-client`,
+      activatesOn: ClientEvents.ClientReady,
+      activate: AiClient,
+    }),
   ]);

package/src/capabilities/ai-client.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { contributes, type PluginsContext } from '@dxos/app-framework';
+import { AIServiceClientImpl } from '@dxos/assistant';
+import { ClientCapabilities } from '@dxos/plugin-client';
+
+import { AutomationCapabilities } from './capabilities';
+
+// TODO(wittjosiah): Factor out.
+const DEFAULT_AI_SERVICE_URL = 'http://localhost:8788';
+
+export default (context: PluginsContext) => {
+  const client = context.requestCapability(ClientCapabilities.Client);
+  const endpoint = client.config.values.runtime?.services?.ai?.server ?? DEFAULT_AI_SERVICE_URL;
+  const aiClient = new AIServiceClientImpl({ endpoint });
+  return contributes(AutomationCapabilities.AiClient, aiClient);
+};

package/src/capabilities/app-graph-builder.ts

@@ -2,126 +2,98 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes, type PluginsContext } from '@dxos/app-framework';
+import {
+  Capabilities,
+  contributes,
+  createIntent,
+  LayoutAction,
+  type PromiseIntentDispatcher,
+  type PluginsContext,
+} from '@dxos/app-framework';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
 import { ClientCapabilities } from '@dxos/plugin-client';
-import { createExtension, toSignal } from '@dxos/plugin-graph';
-import { memoizeQuery } from '@dxos/plugin-space';
-import { getTypename, parseId, SpaceState } from '@dxos/react-client/echo';
+import { createExtension, type Node, ROOT_ID } from '@dxos/plugin-graph';
+import { SpaceAction } from '@dxos/plugin-space/types';
+import { type Space, Filter, getSpace } from '@dxos/react-client/echo';
 
-import { AUTOMATION_PLUGIN } from '../meta';
+import { ASSISTANT_DIALOG, AUTOMATION_PLUGIN } from '../meta';
+import { AIChatType, AutomationAction } from '../types';
 
-export default (context: PluginsContext) => {
-  const resolve = (typename: string) =>
-    context.requestCapabilities(Capabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
-
-  return contributes(Capabilities.AppGraphBuilder, [
+export default (context: PluginsContext) =>
+  contributes(Capabilities.AppGraphBuilder, [
     createExtension({
-      id: `${AUTOMATION_PLUGIN}/automation-for-subject`,
-      resolver: ({ id }) => {
-        if (!id.endsWith('~automation')) {
-          return;
-        }
-
-        const type = 'orphan-settings-for-subject';
-        const icon = 'ph--magic-wand--regular';
-
-        const client = context.requestCapability(ClientCapabilities.Client);
-        const [subjectId] = id.split('~');
-        const { spaceId, objectId } = parseId(subjectId);
-        const spaces = toSignal(
-          (onChange) => client.spaces.subscribe(() => onChange()).unsubscribe,
-          () => client.spaces.get(),
-        );
-        const space = spaces?.find((space) => space.id === spaceId && space.state.get() === SpaceState.SPACE_READY);
-        if (!objectId) {
-          // TODO(burdon): Ref SPACE_PLUGIN ns.
-          const label = space
-            ? space.properties.name || ['unnamed space label', { ns: AUTOMATION_PLUGIN }]
-            : ['unnamed object settings label', { ns: AUTOMATION_PLUGIN }];
-
-          // TODO(wittjosiah): Support comments for arbitrary subjects.
-          //   This is to ensure that the comments panel is not stuck on an old object.
-          return {
-            id,
-            type,
-            data: null,
-            properties: {
-              icon,
-              label,
-              showResolvedThreads: false,
-              object: null,
-              space,
-            },
-          };
-        }
+      id: `${AUTOMATION_PLUGIN}/assistant`,
+      filter: (node): node is Node<null> => node.id === ROOT_ID,
+      actions: () => [
+        {
+          id: `${LayoutAction.UpdateDialog._tag}/assistant/open`,
+          data: async () => {
+            const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
+            const client = context.requestCapability(ClientCapabilities.Client);
+            const layout = context.requestCapability(Capabilities.Layout);
+            const { graph } = context.requestCapability(Capabilities.AppGraph);
 
-        const [object] = memoizeQuery(space, { id: objectId });
-        if (!object || !subjectId) {
-          return;
-        }
+            // TODO(burdon): Get space from workspace.
+            // TODO(burdon): If need to create chat, then add to dispatch stack below.
+            let chat: AIChatType | undefined;
+            if (layout.active.length > 0) {
+              const node = graph.findNode(layout.active[0]);
+              if (node) {
+                const space = getSpace(node.data);
+                if (space) {
+                  chat = await getOrCreateChat(dispatch, space);
+                }
+              }
+            } else {
+              const space = client.spaces.default;
+              chat = await getOrCreateChat(dispatch, space);
+            }
 
-        const meta = resolve(getTypename(object) ?? '');
-        const label = meta.label?.(object) ||
-          object.name ||
-          meta.placeholder || ['unnamed object settings label', { ns: AUTOMATION_PLUGIN }];
+            if (!chat) {
+              log.warn('no chat found');
+              return;
+            }
 
-        return {
-          id,
-          type,
-          data: null,
-          properties: {
-            icon,
-            label,
-            object,
+            await dispatch(
+              createIntent(LayoutAction.UpdateDialog, {
+                part: 'dialog',
+                subject: ASSISTANT_DIALOG,
+                options: {
+                  state: true,
+                  blockAlign: 'end',
+                  props: {
+                    chat,
+                  },
+                },
+              }),
+            );
           },
-        };
-      },
-    }),
-    createExtension({
-      id: `${AUTOMATION_PLUGIN}/assistant-for-subject`,
-      resolver: ({ id }) => {
-        // TODO(Zan): Find util (or make one). Effect schema!!
-        if (!id.endsWith('~assistant')) {
-          return;
-        }
-
-        const client = context.requestCapability(ClientCapabilities.Client);
-        const [subjectId] = id.split('~');
-        const { spaceId, objectId } = parseId(subjectId);
-        const spaces = toSignal(
-          (onChange) => client.spaces.subscribe(() => onChange()).unsubscribe,
-          () => client.spaces.get(),
-        );
-        const space = spaces?.find((space) => space.id === spaceId && space.state.get() === SpaceState.SPACE_READY);
-        if (!objectId) {
-          // TODO(wittjosiah): Support assistant for arbitrary subjects.
-          //   This is to ensure that the assistant panel is not stuck on an old object.
-          return {
-            id,
-            type: 'orphan-automation-for-subject',
-            data: null,
-            properties: {
-              icon: 'ph--atom--regular',
-              label: ['assistant panel label', { ns: AUTOMATION_PLUGIN }],
-              object: null,
-              space,
-            },
-          };
-        }
-
-        const [object] = memoizeQuery(space, { id: objectId });
-
-        return {
-          id,
-          type: 'orphan-automation-for-subject',
-          data: null,
           properties: {
-            icon: 'ph--atom--regular',
-            label: ['assistant panel label', { ns: AUTOMATION_PLUGIN }],
-            object,
+            label: ['open assistant label', { ns: AUTOMATION_PLUGIN }],
+            icon: 'ph--chat-centered-text--regular',
+            disposition: 'pin-end',
+            position: 'hoist',
+            keyBinding: {
+              macos: 'shift+meta+k',
+              windows: 'shift+ctrl+k',
+            },
           },
-        };
-      },
+        },
+      ],
     }),
   ]);
+
+// TODO(burdon): Factor out.
+const getOrCreateChat = async (dispatch: PromiseIntentDispatcher, space: Space): Promise<AIChatType | undefined> => {
+  const { objects } = await space.db.query(Filter.schema(AIChatType)).run();
+  if (objects.length > 0) {
+    // TODO(burdon): Is this the most recent?
+    return objects[objects.length - 1];
+  }
+
+  const { data } = await dispatch(createIntent(AutomationAction.CreateChat, { spaceId: space.id }));
+  invariant(data?.object instanceof AIChatType);
+  await dispatch(createIntent(SpaceAction.AddObject, { target: space, object: data.object }));
+  return data.object;
 };

package/src/capabilities/capabilities.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { defineCapability } from '@dxos/app-framework';
+import { type AIServiceClientImpl } from '@dxos/assistant';
+
+import { AUTOMATION_PLUGIN } from '../meta';
+
+export namespace AutomationCapabilities {
+  export const AiClient = defineCapability<AIServiceClientImpl>(`${AUTOMATION_PLUGIN}/capability/ai-client`);
+}

package/src/capabilities/index.ts

@@ -4,5 +4,10 @@
 
 import { lazy } from '@dxos/app-framework';
 
+export const AiClient = lazy(() => import('./ai-client'));
+export const AutomationSettings = lazy(() => import('./settings'));
 export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
+export const IntentResolver = lazy(() => import('./intent-resolver'));
 export const ReactSurface = lazy(() => import('./react-surface'));
+
+export * from './capabilities';

package/src/capabilities/intent-resolver.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, contributes, createResolver } from '@dxos/app-framework';
+import { ObjectId } from '@dxos/echo-schema';
+import { DXN, QueueSubspaceTags } from '@dxos/keys';
+import { create, refFromDXN } from '@dxos/live-object';
+
+import { AutomationAction, AIChatType, TemplateType } from '../types';
+
+export default () => [
+  contributes(
+    Capabilities.IntentResolver,
+    createResolver({
+      intent: AutomationAction.CreateChat,
+      resolve: ({ spaceId, name }) => ({
+        data: {
+          object: create(AIChatType, {
+            name,
+            queue: refFromDXN(new DXN(DXN.kind.QUEUE, [QueueSubspaceTags.DATA, spaceId, ObjectId.random()])),
+          }),
+        },
+      }),
+    }),
+  ),
+  contributes(
+    Capabilities.IntentResolver,
+    createResolver({
+      intent: AutomationAction.CreateTemplate,
+      resolve: ({ name }) => ({
+        data: {
+          object: create(TemplateType, { name, source: '{{! Template }}' }),
+        },
+      }),
+    }),
+  ),
+];

package/src/capabilities/react-surface.tsx

@@ -5,17 +5,46 @@
 import React from 'react';
 
 import { Capabilities, contributes, createSurface } from '@dxos/app-framework';
-import { getSpace, isEchoObject, type ReactiveEchoObject } from '@dxos/react-client/echo';
+import { SettingsStore } from '@dxos/local-storage';
+import { getSpace, isEchoObject, isSpace, type ReactiveEchoObject } from '@dxos/react-client/echo';
 
-import { AssistantPanel, AutomationPanel } from '../components';
-import { AUTOMATION_PLUGIN } from '../meta';
+import {
+  AssistantDialog,
+  AutomationPanel,
+  AutomationSettings,
+  ChatContainer,
+  ServiceRegistry,
+  TemplateContainer,
+} from '../components';
+import { AUTOMATION_PLUGIN, ASSISTANT_DIALOG } from '../meta';
+import { AIChatType, type AutomationSettingsProps, TemplateType } from '../types';
 
 export default () =>
   contributes(Capabilities.ReactSurface, [
     createSurface({
-      id: `${AUTOMATION_PLUGIN}/assistant`,
-      role: 'complementary--assistant',
-      component: ({ data }) => <AssistantPanel subject={data.subject} />,
+      id: `${AUTOMATION_PLUGIN}/settings`,
+      role: 'article',
+      filter: (data): data is { subject: SettingsStore<AutomationSettingsProps> } =>
+        data.subject instanceof SettingsStore && data.subject.prefix === AUTOMATION_PLUGIN,
+      component: ({ data: { subject } }) => <AutomationSettings settings={subject.value} />,
+    }),
+    createSurface({
+      id: ASSISTANT_DIALOG,
+      role: 'dialog',
+      filter: (data): data is { props: { chat: AIChatType } } => data.component === ASSISTANT_DIALOG,
+      component: ({ data }) => <AssistantDialog {...data.props} />,
+    }),
+    createSurface({
+      id: `${AUTOMATION_PLUGIN}/chat`,
+      role: 'article',
+      filter: (data): data is { subject: AIChatType } => data.subject instanceof AIChatType,
+      component: ({ data, role }) => <ChatContainer role={role} chat={data.subject} />,
+    }),
+    createSurface({
+      id: `${AUTOMATION_PLUGIN}/template`,
+      role: 'article',
+      filter: (data): data is { subject: TemplateType } => data.subject instanceof TemplateType,
+      component: ({ data, role }) => <TemplateContainer role={role} template={data.subject} />,
     }),
     createSurface({
       id: `${AUTOMATION_PLUGIN}/automation`,
@@ -24,4 +53,11 @@ export default () =>
         isEchoObject(data.subject) && !!getSpace(data.subject),
       component: ({ data }) => <AutomationPanel space={getSpace(data.subject)!} object={data.subject} />,
     }),
+    createSurface({
+      id: `${AUTOMATION_PLUGIN}/service-registry`,
+      role: 'complementary--service-registry',
+      component: ({ data }) => (
+        <ServiceRegistry space={isSpace(data.subject) ? data.subject : getSpace(data.subject)!} />
+      ),
+    }),
   ]);

package/src/capabilities/settings.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, contributes } from '@dxos/app-framework';
+import { create } from '@dxos/live-object';
+
+import { AUTOMATION_PLUGIN } from '../meta';
+import { type AutomationSettingsProps, AutomationSettingsSchema } from '../types';
+
+export default () => {
+  const settings = create<AutomationSettingsProps>({});
+
+  return contributes(Capabilities.Settings, {
+    schema: AutomationSettingsSchema,
+    prefix: AUTOMATION_PLUGIN,
+    value: settings,
+  });
+};

package/src/components/AmbientDialog/AmbientDialog.stories.tsx

@@ -0,0 +1,81 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import '@dxos-theme';
+
+import { type StoryObj, type Meta } from '@storybook/react';
+import React, { useState } from 'react';
+
+import { IntentPlugin } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Config } from '@dxos/client';
+import { faker } from '@dxos/random';
+import { withClientProvider } from '@dxos/react-client/testing';
+import { Dialog, Toolbar, Button } from '@dxos/react-ui';
+import { withTheme, withLayout } from '@dxos/storybook-utils';
+
+import { AmbientDialog } from './AmbientDialog';
+import translations from '../../translations';
+
+const meta: Meta<typeof AmbientDialog> = {
+  title: 'plugins/plugin-automation/AmbientDialog',
+  component: AmbientDialog,
+  render: () => {
+    const [open, setOpen] = useState(true);
+    const [items, setItems] = useState<string[]>([]);
+    return (
+      <>
+        <div>
+          <Toolbar.Root>
+            <Toolbar.Button onClick={() => setOpen(true)}>Open</Toolbar.Button>
+          </Toolbar.Root>
+        </div>
+        <Dialog.Root open={open} onOpenChange={setOpen}>
+          <AmbientDialog>
+            <div className='flex flex-col h-full overflow-hidden'>
+              <div className='flex flex-col h-full gap-2 overflow-auto'>
+                {items.map((item) => (
+                  <div key={item} className='px-2'>
+                    {item}
+                  </div>
+                ))}
+                {items.length > 0 && <div className='pbe-2' />}
+              </div>
+              <div className='shrink-0 h-[40px]'>
+                <Button onClick={() => setItems([...items, faker.lorem.word()])}>Add</Button>
+              </div>
+            </div>
+          </AmbientDialog>
+        </Dialog.Root>
+      </>
+    );
+  },
+  decorators: [
+    withClientProvider({
+      config: new Config({
+        runtime: {
+          client: { edgeFeatures: { signaling: true } },
+          services: {
+            edge: { url: 'https://edge.dxos.workers.dev/' },
+            iceProviders: [{ urls: 'https://edge.dxos.workers.dev/ice' }],
+          },
+        },
+      }),
+      createIdentity: true,
+      createSpace: true,
+    }),
+    withPluginManager({ plugins: [IntentPlugin()] }),
+    withTheme,
+    withLayout({ fullscreen: true, tooltips: true }),
+  ],
+  parameters: {
+    translations,
+  },
+};
+
+export default meta;
+
+type Story = StoryObj<typeof AmbientDialog>;
+
+export const Default: Story = {};