@dxos/plugin-assistant 0.8.4-main.69d29f4 → 0.8.4-main.6fa680abb7

package/src/{components → containers/ChatDialog}/ChatDialog.tsx

@@ -4,19 +4,19 @@
 
 import React, { useCallback, useState } from 'react';
 
-import { useAtomCapability } from '@dxos/app-framework/react';
+import { useAtomCapability } from '@dxos/app-framework/ui';
+import { type Chat as ChatTypes } from '@dxos/assistant-toolkit';
 import { Obj } from '@dxos/echo';
 import { useTranslation } from '@dxos/react-ui';
 import { ChatDialog as NaturalChatDialog } from '@dxos/react-ui-chat';
 
-import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../hooks';
-import { meta } from '../meta';
-import { type Assistant, AssistantCapabilities } from '../types';
-
-import { Chat, type ChatRootProps } from './Chat';
+import { Chat, type ChatRootProps } from '../../components';
+import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../../hooks';
+import { meta } from '../../meta';
+import { AssistantCapabilities } from '../../types';
 
 export type ChatDialogProps = {
-  chat?: Assistant.Chat;
+  chat?: ChatTypes.Chat;
 };
 
 export const ChatDialog = ({ chat }: ChatDialogProps) => {
@@ -70,5 +70,3 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
     </Chat.Root>
   );
 };
-
-export default ChatDialog;

package/src/containers/ChatDialog/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ChatDialog } from './ChatDialog';
+
+export default ChatDialog;

package/src/containers/Project/ProjectArticle.tsx

@@ -0,0 +1,117 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Atom, useAtomValue } from '@effect-atom/atom-react';
+import * as Option from 'effect/Option';
+import React, { forwardRef, useMemo, useState } from 'react';
+
+import { Surface } from '@dxos/app-framework/ui';
+import { type SurfaceComponentProps, useObjectMenuItems, useObjectNavigate } from '@dxos/app-toolkit/ui';
+import { type Project } from '@dxos/assistant-toolkit';
+import { Filter, Obj, Query } from '@dxos/echo';
+import { AtomObj, AtomRef } from '@dxos/echo-atom';
+import { useQuery } from '@dxos/react-client/echo';
+import { Card, Panel, ScrollArea, Toolbar } from '@dxos/react-ui';
+import { Menu } from '@dxos/react-ui-menu';
+import { Focus, Mosaic, type MosaicTileProps } from '@dxos/react-ui-mosaic';
+import { isNonNullable } from '@dxos/util';
+
+export type ProjectArticleProps = SurfaceComponentProps<Project.Project>;
+
+export const ProjectArticle = ({ subject: project }: ProjectArticleProps) => {
+  const inputQueue = useAtomValue(
+    AtomObj.make(project).pipe((_) =>
+      Atom.make((get) =>
+        Option.fromNullable(get(_).queue).pipe(Option.map(AtomRef.make), Option.map(get), Option.getOrUndefined),
+      ),
+    ),
+  );
+
+  const inputQueueItems: Obj.Unknown[] = useQuery(inputQueue, Query.select(Filter.everything()));
+
+  const artifacts = useAtomValue(
+    useMemo(
+      () =>
+        AtomObj.make(project).pipe((project) =>
+          Atom.make((get) => {
+            return get(project).artifacts.map((artifact) => get(AtomRef.make(artifact.data)) as Obj.Unknown);
+          }),
+        ),
+      [project],
+    ),
+  );
+
+  const [viewport, setViewport] = useState<HTMLElement | null>(null);
+
+  const stackObjects = [...artifacts, ...inputQueueItems].filter(isNonNullable);
+
+  return (
+    <Panel.Root className='dx-article'>
+      <Panel.Content>
+        {/* TODO(burdon): Factor out. */}
+        {stackObjects.length === 0 && (
+          <div className='text-subdued'>
+            Project has no objects associated with it.
+            <br />
+            <br />
+            To get started:
+            <br />- Write the initative spec: what is the goal of the project?
+            <br />- subscribe project to your email.
+            <br />- Chat with the agent.
+          </div>
+        )}
+
+        {stackObjects.length > 0 && (
+          <Focus.Group asChild>
+            <Mosaic.Container asChild withFocus autoScroll={viewport}>
+              <ScrollArea.Root orientation='vertical'>
+                <ScrollArea.Viewport classNames='p-2' ref={setViewport}>
+                  <Mosaic.Stack items={stackObjects} getId={(item) => item.id} draggable={false} Tile={StackTile} />
+                </ScrollArea.Viewport>
+              </ScrollArea.Root>
+            </Mosaic.Container>
+          </Focus.Group>
+        )}
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+const StackTile = forwardRef<HTMLDivElement, MosaicTileProps<Obj.Unknown>>(
+  ({ data, location, debug }, forwardedRef) => {
+    const objectMenuItems = useObjectMenuItems(data);
+    const handleNavigate = useObjectNavigate(data);
+
+    return (
+      <Mosaic.Tile asChild id={data.id} data={data} location={location} debug={debug}>
+        <Focus.Group asChild>
+          <Menu.Root>
+            <Card.Root ref={forwardedRef} data-testid='board-item'>
+              <Card.Toolbar>
+                <Card.IconBlock></Card.IconBlock>
+                <Card.Title onClick={handleNavigate}>{Obj.getLabel(data)}</Card.Title>
+                {/* TODO(wittjosiah): Reconcile with Card.Menu. */}
+                <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.Toolbar>
+              <Card.Content>
+                <Surface.Surface role='card--content' limit={1} data={{ subject: data }} />
+              </Card.Content>
+            </Card.Root>
+          </Menu.Root>
+        </Focus.Group>
+      </Mosaic.Tile>
+    );
+  },
+);
+StackTile.displayName = 'StackTile';
+
+export default ProjectArticle;

package/src/containers/Project/ProjectSettings.tsx

@@ -0,0 +1,134 @@
+//
+// 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 } from '@dxos/app-framework/ui';
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import { Project } 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 { ButtonGroup, Input } from '@dxos/react-ui';
+import { FeedAnnotation } from '@dxos/schema';
+
+import { syncTriggers } from './triggers';
+
+export const ProjectSettings = ({ subject: project }: SurfaceComponentProps<Project.Project>) => {
+  const computeRuntime = useCapability(AutomationCapabilities.ComputeRuntime);
+
+  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(() => {
+    return Obj.subscribe(project, () => {
+      queueMicrotask(() => syncTriggers(project));
+    });
+  }, [project]);
+
+  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 className='flex flex-col gap-4'>
+      <Input.Root>
+        <Input.Label>Spec (what is the goal of the project?)</Input.Label>
+        <MarkdownEditor.Root id={spec?.id ?? ''} object={spec}>
+          <MarkdownEditor.Content initialValue={specInitialValue} />
+        </MarkdownEditor.Root>
+      </Input.Root>
+      <ButtonGroup classNames='h-10'>
+        <Button onClick={handleResetHistory}>Reset Chat History</Button>
+      </ButtonGroup>
+      <div>
+        <h2 className='text-lg font-bold'>Subscriptions</h2>
+        {subscribableObjects.length > 0 && (
+          <div>
+            {subscribableObjects.map((object) => (
+              <Input.Root key={object.id}>
+                <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)}</Input.Label>
+              </Input.Root>
+            ))}
+          </div>
+        )}
+        {subscribableObjects.length === 0 && (
+          <div className='text-sm text-description'>Space has no feeds to subscribe to.</div>
+        )}
+      </div>
+    </div>
+  );
+};
+
+export default ProjectSettings;

package/src/containers/Project/index.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type ComponentType, type FunctionComponent, lazy } from 'react';
+
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import type { Project } from '@dxos/assistant-toolkit';
+
+import type { ProjectArticleProps } from './ProjectArticle';
+
+export const ProjectArticle: ComponentType<ProjectArticleProps> = lazy(() => import('./ProjectArticle'));
+
+export const ProjectSettings: FunctionComponent<SurfaceComponentProps<Project.Project>> = lazy(
+  () => import('./ProjectSettings'),
+);

package/src/containers/Project/triggers.ts

@@ -0,0 +1,149 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Option from 'effect/Option';
+
+import { type Project, ProjectFunctions } from '@dxos/assistant-toolkit';
+import { Feed, Obj, Ref } from '@dxos/echo';
+import { FunctionDefinition, Trigger } from '@dxos/functions';
+import { Filter } from '@dxos/react-client/echo';
+import { FeedAnnotation } from '@dxos/schema';
+
+// TODO(dmaretskyi): Perhaps the association is better done with a relation.
+
+/**
+ * Foreign key {@link PROJECT_TRIGGER_EXTENSION_KEY} => <initative id : ObjectId>
+ */
+const PROJECT_TRIGGER_EXTENSION_KEY = 'org.dxos.extension.ProjectTrigger';
+
+/**
+ * Foreign key {@link PROJECT_TRIGGER_EXTENSION_KEY} => <dxn string of subscription target>
+ */
+const PROJECT_TRIGGER_TARGET_EXTENSION_KEY = 'org.dxos.extension.ProjectTriggerTarget';
+
+/** Checks if an object's schema has the FeedAnnotation. */
+const hasFeedAnnotation = (obj: Obj.Unknown): boolean => {
+  const schema = Obj.getSchema(obj);
+  if (!schema) {
+    return false;
+  }
+  const annotation = FeedAnnotation.get(schema);
+  return Option.isSome(annotation) && annotation.value === true;
+};
+
+/**
+ * Syncs triggers in the database with the project subscriptions.
+ */
+export const syncTriggers = async (project: Project.Project) => {
+  const db = Obj.getDatabase(project);
+  if (!db) {
+    return;
+  }
+
+  const triggers = await db
+    .query(Filter.foreignKeys(Trigger.Trigger, [{ source: PROJECT_TRIGGER_EXTENSION_KEY, id: project.id }]))
+    .run();
+
+  // Delete triggers that are not in subscriptions.
+  for (const trigger of triggers) {
+    const target = Obj.getKeys(trigger, PROJECT_TRIGGER_TARGET_EXTENSION_KEY).at(0)?.id;
+
+    const exists = project.subscriptions.find((subscription) => subscription.dxn.toString() === target);
+    if (!exists && !(project.useQualifyingAgent && target === Obj.getDXN(project)?.toString())) {
+      db.remove(trigger);
+    }
+  }
+
+  // Add triggers that are not in the database.
+  for (const subscription of project.subscriptions) {
+    const relevantTrigger = triggers.find((trigger) =>
+      Obj.getKeys(trigger, PROJECT_TRIGGER_TARGET_EXTENSION_KEY).some((key) => key.id === subscription.dxn.toString()),
+    );
+    if (relevantTrigger) {
+      continue;
+    }
+
+    const target = await subscription.tryLoad();
+    if (!target) {
+      continue;
+    }
+
+    let feedObj: Feed.Feed | undefined;
+    if (Obj.instanceOf(Feed.Feed, target)) {
+      feedObj = target;
+    } else if (hasFeedAnnotation(target)) {
+      feedObj = await (target as any).feed?.tryLoad();
+    }
+
+    const queueDxn = Option.fromNullable(feedObj).pipe(
+      Option.filter(Obj.instanceOf(Feed.Feed)),
+      Option.map(Feed.getQueueDxn),
+      Option.getOrUndefined,
+    );
+    if (!queueDxn) {
+      continue;
+    }
+
+    db.add(
+      Trigger.make({
+        [Obj.Parent]: project,
+        [Obj.Meta]: {
+          keys: [
+            // TODO(dmaretskyi): Query by parent instead of manually adding keys.
+            { source: PROJECT_TRIGGER_EXTENSION_KEY, id: project.id },
+            { source: PROJECT_TRIGGER_TARGET_EXTENSION_KEY, id: subscription.dxn.toString() },
+          ],
+        },
+        enabled: true,
+        spec: {
+          kind: 'queue',
+          queue: queueDxn.toString(),
+        },
+        function: Ref.make(
+          FunctionDefinition.serialize(
+            project.useQualifyingAgent ? ProjectFunctions.Qualifier : ProjectFunctions.Agent,
+          ),
+        ),
+        input: {
+          project: Ref.make(project),
+          event: '{{event}}',
+        },
+        concurrency: project.useQualifyingAgent ? 5 : undefined,
+      }),
+    );
+  }
+
+  if (project.useQualifyingAgent) {
+    const qualifierTrigger = triggers.find((trigger) =>
+      Obj.getKeys(trigger, PROJECT_TRIGGER_TARGET_EXTENSION_KEY).some(
+        (key) => key.id === Obj.getDXN(project)?.toString(),
+      ),
+    );
+    if (!qualifierTrigger && project.queue) {
+      db.add(
+        Trigger.make({
+          [Obj.Parent]: project,
+          [Obj.Meta]: {
+            keys: [
+              { source: PROJECT_TRIGGER_EXTENSION_KEY, id: project.id },
+              { source: PROJECT_TRIGGER_TARGET_EXTENSION_KEY, id: Obj.getDXN(project)?.toString() ?? '' },
+            ],
+          },
+          function: Ref.make(FunctionDefinition.serialize(ProjectFunctions.Agent)),
+          enabled: true,
+          spec: {
+            kind: 'queue',
+            queue: project.queue.dxn.toString(),
+          },
+          input: {
+            project: Ref.make(project),
+            event: '{{event}}',
+          },
+        }),
+      );
+    }
+  }
+
+  await db.flush({ indexes: true });
+};

package/src/containers/PromptArticle/PromptArticle.tsx

@@ -0,0 +1,59 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useMemo } from 'react';
+
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import { AgentFunctions } from '@dxos/assistant-toolkit';
+import { type Prompt } from '@dxos/blueprints';
+import { Obj } from '@dxos/echo';
+import { type FunctionDefinition } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+import { invokeFunctionWithTracing, useComputeRuntimeCallback } from '@dxos/plugin-automation';
+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 = SurfaceComponentProps<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<FunctionDefinition.Input<typeof AgentFunctions.Prompt> | undefined>(
+    () =>
+      subject && db
+        ? {
+            prompt: db.makeRef(Obj.getDXN(subject)),
+            input: {},
+          }
+        : undefined,
+    [subject, db],
+  );
+
+  const handleRun = useComputeRuntimeCallback(
+    db?.spaceId,
+    () => {
+      invariant(inputData);
+      return invokeFunctionWithTracing(AgentFunctions.Prompt, inputData);
+    },
+    [inputData],
+  );
+
+  return (
+    <Panel.Root role={role} className='dx-article'>
+      <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,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { PromptArticle } from './PromptArticle';
+
+export default PromptArticle;

package/src/containers/TriggerStatus/TriggerStatus.tsx

@@ -0,0 +1,140 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useMemo } from 'react';
+
+import { type InvocationsState } from '@dxos/functions-runtime';
+import { useTriggerRuntimeControls } from '@dxos/plugin-automation';
+import { useActiveSpace } from '@dxos/plugin-space';
+import { StatusBar } from '@dxos/plugin-status-bar';
+import { type Database } from '@dxos/react-client/echo';
+import { Icon, Input, Popover, useTranslation } from '@dxos/react-ui';
+import { Settings } from '@dxos/react-ui-form';
+import { mx } from '@dxos/ui-theme';
+
+import { meta } from '../../meta';
+
+type TriggerStatusState = 'disabled' | 'idle' | 'running' | 'error';
+
+const getIcon = (state: TriggerStatusState): string => {
+  switch (state) {
+    case 'disabled':
+      return 'ph--lightning-slash--regular';
+    case 'idle':
+      return 'ph--lightning--regular';
+    case 'running':
+      return 'ph--lightning--fill';
+    case 'error':
+      return 'ph--warning--regular';
+  }
+};
+
+const getIconClassNames = (state: TriggerStatusState): string | undefined => {
+  switch (state) {
+    case 'running':
+      return 'animate-pulse text-accent-text';
+    case 'error':
+      return 'text-error-text';
+    default:
+      return undefined;
+  }
+};
+
+export const TriggerStatus = () => {
+  const space = useActiveSpace();
+  const db = space?.db;
+  if (!db) {
+    return null;
+  }
+
+  return <SpaceStatusMain db={db} />;
+};
+
+const SpaceStatusMain = ({ db }: { db: Database.Database }) => {
+  const { state, start, stop } = useTriggerRuntimeControls(db);
+  const isRunning = state?.enabled ?? false;
+
+  // Determine the current trigger status state.
+  const triggerState: TriggerStatusState = useMemo(() => {
+    if (!isRunning) {
+      return 'disabled';
+    }
+
+    // Check if there's any pending invocation.
+    const hasPending = state?.invocations.some((invocation) => invocation.result === null);
+    if (hasPending) {
+      return 'running';
+    }
+
+    // Check if the last invocation failed.
+    const lastInvocation = state?.invocations.at(-1);
+    if (lastInvocation?.result?._tag === 'Failure') {
+      return 'error';
+    }
+
+    return 'idle';
+  }, [isRunning, state?.invocations]);
+
+  const { t } = useTranslation(meta.id);
+  const title = t(`trigger status ${triggerState} label`);
+  const icon = <Icon icon={getIcon(triggerState)} classNames={getIconClassNames(triggerState)} />;
+
+  return (
+    <Popover.Root>
+      <Popover.Trigger asChild>
+        <StatusBar.Item title={title}>{icon}</StatusBar.Item>
+      </Popover.Trigger>
+      <Popover.Portal>
+        <Popover.Content>
+          <TriggerStatusPopover
+            isRunning={isRunning}
+            state={triggerState}
+            currentFunctionName={state?.invocations.at(-1)?.function?.name ?? state?.invocations.at(-1)?.function?.key}
+            lastInvocation={state?.invocations.at(-1)}
+            onToggle={isRunning ? stop : start}
+          />
+          <Popover.Arrow />
+        </Popover.Content>
+      </Popover.Portal>
+    </Popover.Root>
+  );
+};
+
+interface TriggerStatusPopoverProps {
+  isRunning: boolean;
+  state: TriggerStatusState;
+  currentFunctionName?: string;
+  lastInvocation?: InvocationsState;
+  onToggle: () => void;
+}
+
+const TriggerStatusPopover = ({
+  isRunning,
+  state,
+  currentFunctionName,
+  lastInvocation,
+  onToggle,
+}: TriggerStatusPopoverProps) => {
+  const { t } = useTranslation(meta.id);
+
+  return (
+    <div className='min-w-[240px] p-2 space-y-3'>
+      {/* Runtime Toggle */}
+      <Settings.ItemInput title={t('trigger runtime label')} description={t('trigger runtime description')}>
+        <Input.Switch classNames='justify-self-end' checked={isRunning} onCheckedChange={onToggle} />
+      </Settings.ItemInput>
+
+      {/* Status Indicator */}
+      <div className='flex items-center gap-2 pt-2 border-t border-separator'>
+        <Icon icon={getIcon(state)} classNames={mx(getIconClassNames(state), 'shrink-0')} />
+        <span className='text-sm'>{t(`trigger status ${state} label`)}</span>
+        {currentFunctionName && state === 'running' && (
+          <span className='text-xs text-description'>{currentFunctionName}</span>
+        )}
+      </div>
+    </div>
+  );
+};
+
+export default TriggerStatus;

package/src/containers/TriggerStatus/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { TriggerStatus } from './TriggerStatus';
+
+export default TriggerStatus;