@dxos/plugin-assistant 0.8.4-main.7996785055 → 0.8.4-main.8baae0fced

package/src/containers/{ChatContainer/ChatContainer.tsx → ChatArticle/ChatArticle.tsx}

@@ -6,30 +6,30 @@ import React, { forwardRef, useEffect, useRef } from 'react';
 
 import { Capabilities } from '@dxos/app-framework';
 import { useAtomCapability, useCapability } from '@dxos/app-framework/ui';
-import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
 import { type Space, getSpace } from '@dxos/client/echo';
 import { type Obj } from '@dxos/echo';
 import { Panel } from '@dxos/react-ui';
 import { getParentId } from '@dxos/react-ui-attention';
 
-import { Chat as ChatComponent, type ChatRootProps } from '../../components';
-import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../../hooks';
-import { AssistantCapabilities, type ChatType } from '../../types';
+import { Chat as ChatComponent, type ChatRootProps } from '#components';
+import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '#hooks';
+import { type Assistant, AssistantCapabilities, type ChatType } from '#types';
 
-export type ChatContainerProps = SurfaceComponentProps<
-  ChatType.Chat | undefined,
-  {
-    space?: Space;
-    companionTo?: Obj.Unknown;
-  } & Pick<ChatRootProps, 'onEvent'>
->;
+export type ChatArticleProps = (
+  | AppSurface.ObjectArticleProps<ChatType.Chat | undefined>
+  | AppSurface.ObjectSectionProps<ChatType.Chat | undefined>
+) & {
+  space?: Space;
+  companionTo?: Obj.Unknown;
+} & Pick<ChatRootProps, 'onEvent'>;
 
-export const ChatContainer = forwardRef<HTMLDivElement, ChatContainerProps>((props, forwardedRef) => {
+export const ChatArticle = forwardRef<HTMLDivElement, ChatArticleProps>((props, forwardedRef) => {
   const { role, attendableId, subject: chat, space: spaceProp, companionTo, onEvent } = props;
   const parentId = attendableId ? getParentId(attendableId) : undefined;
   const space = spaceProp ?? getSpace(chat);
   const settings = useAtomCapability(AssistantCapabilities.Settings);
-  const services = useChatServices({ id: space?.id });
+  const runtime = useChatServices({ id: space?.id });
   const [online, setOnline] = useOnline();
   const { preset, ...chatProps } = usePresets(online);
   const blueprintRegistry = useBlueprintRegistry();
@@ -37,7 +37,7 @@ export const ChatContainer = forwardRef<HTMLDivElement, ChatContainerProps>((pro
     space,
     chat,
     preset,
-    services,
+    runtime,
     blueprintRegistry,
     settings,
   });
@@ -62,20 +62,35 @@ export const ChatContainer = forwardRef<HTMLDivElement, ChatContainerProps>((pro
     }
   }, [processor, attendableId, registry, stateAtom]);
 
+  const feedTarget = chat?.feed.target;
+  const view = (chat?.view as Assistant.ChatView | undefined) ?? settings.chatView;
+
   if (!processor) {
     return null;
   }
 
   return (
-    <ChatComponent.Root db={space?.db} chat={chat} processor={processor} onEvent={onEvent}>
-      <Panel.Root role={role} classNames='dx-document' ref={forwardedRef}>
+    <ChatComponent.Root db={space?.db} chat={chat} feed={feedTarget} processor={processor} onEvent={onEvent}>
+      <Panel.Root role={role} ref={forwardedRef}>
         <Panel.Toolbar className='bg-toolbar-surface'>
-          <ChatComponent.Toolbar classNames='dx-document' attendableId={parentId} companionTo={companionTo} />
+          <ChatComponent.Toolbar classNames='dx-document' attendableId={attendableId} companionTo={companionTo} />
         </Panel.Toolbar>
         <Panel.Content>
-          <ChatComponent.Viewport>
-            <ChatComponent.Thread />
-            <div role='none' className='p-4'>
+          <ChatComponent.Content>
+            <div className='dx-container relative'>
+              <ChatComponent.Thread viewType={view} />
+              {view !== 'summary' && (
+                <div className='absolute bottom-2 left-0 right-0'>
+                  <div className='dx-document px-4'>
+                    <ChatComponent.Status classNames='px-3 rounded-sm bg-group-surface' />
+                  </div>
+                </div>
+              )}
+            </div>
+            <div className='dx-document px-4 pb-4'>
+              <div className='flex flex-col items-center py-2 overflow-hidden'>
+                <ChatComponent.TaskList classNames='max-h-[120px] border border-separator rounded-sm text-description' />
+              </div>
               <ChatComponent.Prompt
                 {...chatProps}
                 outline
@@ -84,7 +99,7 @@ export const ChatContainer = forwardRef<HTMLDivElement, ChatContainerProps>((pro
                 onOnlineChange={setOnline}
               />
             </div>
-          </ChatComponent.Viewport>
+          </ChatComponent.Content>
         </Panel.Content>
       </Panel.Root>
     </ChatComponent.Root>

package/src/containers/ChatArticle/index.ts

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

package/src/containers/ChatCompanion/ChatCompanion.tsx

@@ -2,135 +2,44 @@
 // 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, useEffect, useMemo, useRef, useState } from 'react';
+import React, { forwardRef, useCallback, useMemo } from 'react';
 
-import { useAtomCapability, useCapabilities, useOperationInvoker } from '@dxos/app-framework/ui';
-import { AppCapabilities } from '@dxos/app-toolkit';
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { BlueprintsAnnotation } 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 { DXN, Filter, Obj, Query, Ref } from '@dxos/echo';
-import { SpaceOperation } from '@dxos/plugin-space/operations';
+import { Blueprint } from '@dxos/compute';
+import { Filter, Obj, Ref } from '@dxos/echo';
+import { SpaceOperation } from '@dxos/plugin-space';
 import { useQuery } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
 
-import { type ChatEvent } from '../../components';
-import { useBlueprintRegistry, useContextBinder } from '../../hooks';
-import { Assistant, AssistantCapabilities } from '../../types';
-import { AssistantOperation } from '../../operations';
-import ChatContainer from '../ChatContainer';
+import { type ChatEvent } from '#components';
+import { useBlueprintRegistry, useContextBinder } from '#hooks';
+import { AssistantOperation } from '#types';
 
-// TODO(burdon): Use definition.
-// export type ChatCompanionProps = SurfaceComponentProps<Chat.Chat>;
+import ChatArticle from '../ChatArticle';
 
-export type ChatCompanionProps = {
-  role?: string;
-  data: {
-    subject: Chat.Chat | 'assistant-chat';
-    attendableId: string;
-    companionTo: Obj.Unknown;
-  };
-};
+export type ChatCompanionProps = AppSurface.ArticleProps<Chat.Chat, {}, Obj.Unknown>;
 
 export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
-  ({ role, data }: ChatCompanionProps, forwardedRef) => {
+  ({ role, subject: chat, companionTo, attendableId }, forwardedRef) => {
     const { invokePromise } = useOperationInvoker();
     const blueprintRegistry = useBlueprintRegistry();
-
-    const companionTo = data.companionTo;
     const space = getSpace(companionTo);
-    const [chat, setChat] = useState(data.subject === 'assistant-chat' ? undefined : data.subject);
-
-    // Watch the state atom directly to detect when plus button clears the chat selection.
-    const state = useAtomCapability(AssistantCapabilities.State);
-    const companionToId = Obj.getDXN(companionTo).toString();
-    const currentChatState = state?.currentChat[companionToId];
-
-    // Track if initial setup has been done (to distinguish initial mount from plus button click).
-    // Reset when companionTo changes.
-    const initialSetupDoneRef = useRef(false);
-    const prevCompanionToIdRef = useRef(companionToId);
-    if (prevCompanionToIdRef.current !== companionToId) {
-      initialSetupDoneRef.current = false;
-      prevCompanionToIdRef.current = companionToId;
-    }
-
-    // Sync local chat state with the state atom.
-    // When currentChatState is undefined (plus button clicked), reset local chat.
-    // When data.subject is a Chat object, use it directly.
-    // When currentChatState is a different chat, fetch and set it.
-    useEffect(() => {
-      // If state says no chat selected AND current chat is persisted, reset local state (handles plus button click).
-      // Don't reset in-memory chats - they're expected to have currentChatState === undefined.
-      if (!currentChatState && chat && getSpace(chat)) {
-        setChat(undefined);
-      } else if (data.subject !== 'assistant-chat') {
-        // If data.subject is a Chat object (resolved from graph), use it.
-        setChat(data.subject);
-      } else if (currentChatState && space) {
-        // currentChatState is set but graph couldn't resolve it - fetch manually.
-        const currentChatDxnStr = chat ? Obj.getDXN(chat).toString() : undefined;
-        if (currentChatState !== currentChatDxnStr) {
-          // Parse DXN and fetch the chat object from the database.
-          const parsedDxn = DXN.tryParse(currentChatState);
-          if (parsedDxn) {
-            const chatRef = space.db.makeRef(parsedDxn);
-            const resolvedChat = chatRef?.target;
-            if (Obj.instanceOf(Assistant.Chat, resolvedChat)) {
-              setChat(resolvedChat);
-            }
-          }
-        }
-      }
-    }, [currentChatState, data.subject, space, chat]);
-
-    const chatQueue = space && chat ? space.queues.get(chat.queue.dxn) : undefined;
-    const binder = useContextBinder(chatQueue);
-
-    // Initialize companion chat if it doesn't exist, but don't add it to the space immediately.
-    useAsyncEffect(async () => {
-      if (!space || chat) {
-        return;
-      }
-
-      // Only query for existing chats on initial mount, not when plus button is clicked.
-      if (!initialSetupDoneRef.current) {
-        // Query for existing companion chats linked to this object.
-        const existingChats = await space.db
-          .query(Query.select(Filter.id(companionTo.id)).targetOf(Chat.CompanionTo).source())
-          .run();
-
-        initialSetupDoneRef.current = true;
+    const feedTarget = chat?.feed.target;
+    const binder = useContextBinder(space, feedTarget);
 
-        // Use existing chat if found on initial mount.
-        if (existingChats.length > 0) {
-          const existingChat = existingChats.at(-1) as Assistant.Chat;
-          setChat(existingChat);
-          await invokePromise(AssistantOperation.SetCurrentChat, { companionTo, chat: existingChat });
-          return;
-        }
-      }
-
-      // Create chat in-memory only - it will be added to space on first message.
-      const { data: createResult } = await invokePromise(AssistantOperation.CreateChat, {
-        db: space.db,
-        addToSpace: false,
-      });
-      setChat(createResult?.object);
-    }, [chat, space, companionTo, invokePromise]);
-
-    // Add chat to space and create relation when user submits the first message.
+    // Persist chat on first submit.
     const handleEvent = useCallback(
       async (event: ChatEvent) => {
-        if (!chat || !space) {
+        if (!space || !chat) {
           return;
         }
 
-        // If chat is not in space yet, persist it on first submit.
-        if (event.type === 'submit' && !getSpace(chat)) {
+        if (event.type === 'submit' && !Obj.getDatabase(chat)) {
           await invokePromise(SpaceOperation.AddObject, {
             object: chat,
             target: space.db,
@@ -151,27 +60,20 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
       [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 blueprintKeys = useMemo(() => {
+      const schema = companionTo ? Obj.getSchema(companionTo) : undefined;
+      if (!schema) {
+        return [] as string[];
+      }
+      return Option.getOrElse(() => [] as string[])(BlueprintsAnnotation.get(schema));
+    }, [companionTo]);
     const existingBlueprints = useQuery(space?.db, Filter.type(Blueprint.Blueprint));
     const pluginBlueprints = useMemo(
-      () => existingBlueprints.filter((blueprint) => blueprintKeys.includes(blueprint.key)),
+      () =>
+        existingBlueprints.filter((blueprint) => {
+          const key = Obj.getMeta(blueprint).key;
+          return key !== undefined && blueprintKeys.includes(key);
+        }),
       [existingBlueprints, blueprintKeys],
     );
 
@@ -184,7 +86,7 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
       // 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);
+        const existingBlueprint = existingBlueprints.find((blueprint) => Obj.getMeta(blueprint).key === key);
         if (existingBlueprint) {
           continue;
         }
@@ -217,11 +119,11 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
     }, [binder, companionTo, blueprintKeys]);
 
     return (
-      <ChatContainer
-        role={role}
-        attendableId={data.attendableId}
+      <ChatArticle
+        role={role ?? 'article'}
         space={space}
         subject={chat}
+        attendableId={attendableId}
         companionTo={companionTo}
         onEvent={handleEvent}
         ref={forwardedRef}

package/src/containers/ChatCompanion/index.ts

@@ -2,6 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-import { ChatCompanion } from './ChatCompanion';
-
-export default ChatCompanion;
+export { ChatCompanion as default } from './ChatCompanion';

package/src/containers/ChatDialog/ChatDialog.tsx

@@ -10,10 +10,10 @@ import { Obj } from '@dxos/echo';
 import { useTranslation } from '@dxos/react-ui';
 import { ChatDialog as NaturalChatDialog } from '@dxos/react-ui-chat';
 
-import { Chat, type ChatRootProps } from '../../components';
-import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../../hooks';
-import { meta } from '../../meta';
-import { AssistantCapabilities } from '../../types';
+import { Chat, type ChatRootProps } from '#components';
+import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '#hooks';
+import { meta } from '#meta';
+import { type Assistant, AssistantCapabilities } from '#types';
 
 export type ChatDialogProps = {
   chat?: ChatTypes.Chat;
@@ -24,17 +24,11 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
 
   const db = chat && Obj.getDatabase(chat);
   const settings = useAtomCapability(AssistantCapabilities.Settings);
-  const services = useChatServices({ id: db?.spaceId });
+  const runtime = useChatServices({ id: db?.spaceId });
   const [online, setOnline] = useOnline();
   const { preset, ...chatProps } = usePresets(online);
   const blueprintRegistry = useBlueprintRegistry();
-  const processor = useChatProcessor({
-    chat,
-    preset,
-    services,
-    blueprintRegistry,
-    settings,
-  });
+  const processor = useChatProcessor({ chat, preset, runtime, blueprintRegistry, settings });
 
   // TODO(burdon): Refocus when open.
   const [open, setOpen] = useState(true);
@@ -59,9 +53,9 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
   return (
     <Chat.Root chat={chat} processor={processor} onEvent={handleEvent}>
       <NaturalChatDialog.Root open={open} expanded={expanded} onOpenChange={setOpen}>
-        <NaturalChatDialog.Header title={t('assistant dialog title')} />
+        <NaturalChatDialog.Header title={t('assistant-dialog.title')} />
         <NaturalChatDialog.Content>
-          <Chat.Thread />
+          <Chat.Thread viewType={(chat.view as Assistant.ChatView | undefined) ?? settings.chatView} />
         </NaturalChatDialog.Content>
         <NaturalChatDialog.Footer classNames='p-1.5'>
           <Chat.Prompt {...chatProps} preset={preset?.id} online={online} onOnlineChange={setOnline} expandable />

package/src/containers/ChatDialog/index.ts

@@ -2,6 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-import { ChatDialog } from './ChatDialog';
-
-export default ChatDialog;
+export { ChatDialog as default } from './ChatDialog';

package/src/containers/PlanArticle/PlanArticle.tsx

@@ -0,0 +1,33 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import React from 'react';
+
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { type Plan } from '@dxos/assistant-toolkit';
+import { Panel, ScrollArea, Toolbar } from '@dxos/react-ui';
+import { useAttention } from '@dxos/react-ui-attention';
+
+import { TaskList } from '#components';
+
+export type PlanArticleProps = AppSurface.ObjectArticleProps<Plan.Plan>;
+
+export const PlanArticle = ({ role, attendableId, subject }: PlanArticleProps) => {
+  const { hasAttention } = useAttention(attendableId);
+
+  return (
+    <Panel.Root role={role} classNames='dx-document'>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root disabled={!hasAttention} />
+      </Panel.Toolbar>
+      <Panel.Content asChild>
+        <ScrollArea.Root orientation='vertical'>
+          <ScrollArea.Viewport>
+            <TaskList plan={subject} />
+          </ScrollArea.Viewport>
+        </ScrollArea.Root>
+      </Panel.Content>
+    </Panel.Root>
+  );
+};

package/src/containers/PlanArticle/index.ts

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

package/src/containers/RoutineArticle/RoutineArticle.stories.tsx

@@ -0,0 +1,75 @@
+//
+// 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 { Routine } from '@dxos/compute';
+import { Filter } from '@dxos/echo';
+import { AutomationPlugin } from '@dxos/plugin-automation/testing';
+import { ClientPlugin } from '@dxos/plugin-client/testing';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { corePlugins } from '@dxos/plugin-testing';
+import { useQuery, useSpaces } from '@dxos/react-client/echo';
+import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
+
+import { translations } from '#translations';
+
+import { AssistantPlugin } from '../../AssistantPlugin';
+import { RoutineArticle } from './RoutineArticle';
+
+const DefaultStory = () => {
+  const [space] = useSpaces();
+  const [routine] = useQuery(space?.db, Filter.type(Routine.Routine));
+  if (!routine) {
+    return <Loading />;
+  }
+
+  return <RoutineArticle role='article' subject={routine} attendableId='story' />;
+};
+
+const meta = {
+  title: 'plugins/plugin-assistant/containers/RoutineArticle',
+  render: DefaultStory,
+  decorators: [
+    withTheme(),
+    withLayout({ layout: 'column' }),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          types: [Routine.Routine],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* initializeIdentity(client);
+              const [space] = client.spaces.get();
+              yield* Effect.promise(() => space.waitUntilReady());
+
+              space.db.add(
+                Routine.make({
+                  name: 'Summarize',
+                  description: 'Summarize the selected object.',
+                  instructions: 'Create a new markdown document that is a summary of the selected object.',
+                }),
+              );
+            }),
+        }),
+        AutomationPlugin(),
+        AssistantPlugin(),
+      ],
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/containers/RoutineArticle/RoutineArticle.tsx

@@ -0,0 +1,109 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+
+import { useSpaceCallback } from '@dxos/app-framework/ui';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { AgentPrompt } from '@dxos/assistant-toolkit';
+import { Operation, type Routine } from '@dxos/compute';
+import { Database, Feed, Obj } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { Panel, Toolbar, useTranslation } from '@dxos/react-ui';
+import { useAttention } from '@dxos/react-ui-attention';
+import { JsonHighlighter } from '@dxos/react-ui-syntax-highlighter';
+
+import { TemplateEditor } from '#components';
+import { meta } from '#meta';
+
+export type RoutineArticleProps = AppSurface.ObjectArticleProps<Routine.Routine>;
+
+type RunState =
+  | { status: 'idle' }
+  | { status: 'running' }
+  | { status: 'success'; result: unknown }
+  | { status: 'error'; error: Error };
+
+// TODO(burdon): Trigger editor.
+export const RoutineArticle = ({ role, attendableId, subject }: RoutineArticleProps) => {
+  const { t } = useTranslation(meta.id);
+  const { hasAttention } = useAttention(attendableId);
+  const invoke = usePromptHandler(subject);
+  const [state, setState] = useState<RunState>({ status: 'idle' });
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+
+  const handleRun = useCallback(async () => {
+    setState({ status: 'running' });
+    try {
+      const result = await invoke();
+      if (mountedRef.current) {
+        setState({ status: 'success', result });
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        setState({ status: 'error', error: err instanceof Error ? err : new Error(String(err)) });
+      }
+    }
+  }, [invoke]);
+
+  return (
+    <Panel.Root role={role} className='dx-document'>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root disabled={!hasAttention || state.status === 'running'}>
+          <Toolbar.IconButton
+            iconOnly
+            icon={state.status === 'running' ? 'ph--spinner-gap--regular' : 'ph--play--regular'}
+            label={t('run-prompt.label')}
+            onClick={handleRun}
+          />
+        </Toolbar.Root>
+      </Panel.Toolbar>
+      <Panel.Content classNames='flex flex-col gap-2'>
+        <TemplateEditor id={subject.id} template={subject.instructions} />
+        <RoutineResult state={state} />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+const RoutineResult = ({ state }: { state: RunState }) => {
+  const { t } = useTranslation(meta.id);
+  switch (state.status) {
+    case 'idle':
+      return null;
+    case 'running':
+      return <div className='p-2 text-sm text-subdued'>{t('routine-running.label')}</div>;
+    case 'error':
+      return <div className='p-2 text-sm text-error'>{state.error.message}</div>;
+    case 'success':
+      return <JsonHighlighter classNames='p-2! text-sm' data={state.result} />;
+  }
+};
+
+const usePromptHandler = (routine: Routine.Routine) => {
+  const db = Obj.getDatabase(routine);
+  const data = useMemo<Operation.Definition.Input<typeof AgentPrompt> | undefined>(() => {
+    if (db && routine) {
+      return {
+        prompt: db.makeRef(Obj.getDXN(routine)),
+        input: {},
+      };
+    }
+  }, [routine, db]);
+
+  return useSpaceCallback(
+    db?.spaceId,
+    [Database.Service, Feed.FeedService] as const,
+    () => {
+      invariant(data);
+      return Operation.invoke(AgentPrompt, data);
+    },
+    [data],
+  );
+};

package/src/containers/RoutineArticle/index.ts

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