@dxos/plugin-automation 0.8.4-main.5ad4a44 → 0.8.4-main.66e292d

package/src/components/FunctionsPanel/FunctionsPanel.tsx

@@ -5,10 +5,13 @@
 import * as Schema from 'effect/Schema';
 import React, { useCallback, useMemo } from 'react';
 
-import { LayoutAction, createIntent, useIntentDispatcher } from '@dxos/app-framework';
-import { FunctionType, ScriptType } from '@dxos/functions';
-import { Filter, type Space, fullyQualifiedId, useQuery } from '@dxos/react-client/echo';
-import { Button, useTranslation } from '@dxos/react-ui';
+import { LayoutAction, createIntent } from '@dxos/app-framework';
+import { useIntentDispatcher } from '@dxos/app-framework/react';
+import { Obj } from '@dxos/echo';
+import { Function, Script } from '@dxos/functions';
+import { SpaceAction } from '@dxos/plugin-space/types';
+import { Filter, type Space, useQuery } from '@dxos/react-client/echo';
+import { Button, IconButton, useTranslation } from '@dxos/react-ui';
 import { controlItemClasses } from '@dxos/react-ui-form';
 import { List } from '@dxos/react-ui-list';
 import { ghostHover, mx } from '@dxos/react-ui-theme';
@@ -23,8 +26,8 @@ export type FunctionsPanelProps = {
 
 export const FunctionsPanel = ({ space }: FunctionsPanelProps) => {
   const { t } = useTranslation(meta.id);
-  const functions = useQuery(space, Filter.type(FunctionType));
-  const scripts = useQuery(space, Filter.type(ScriptType));
+  const functions = useQuery(space, Filter.type(Function.Function));
+  const scripts = useQuery(space, Filter.type(Script.Script));
   const { dispatchPromise: dispatch } = useIntentDispatcher();
 
   const functionToScriptMap = useMemo(
@@ -40,13 +43,13 @@ export const FunctionsPanel = ({ space }: FunctionsPanelProps) => {
           }
           return map;
         },
-        {} as Record<string, ScriptType>,
+        {} as Record<string, Script.Script>,
       ),
     [functions, scripts],
   );
 
   const getScriptName = useCallback(
-    (func: FunctionType) => {
+    (func: Function.Function) => {
       const script = functionToScriptMap[func.id];
       return script?.name;
     },
@@ -54,23 +57,33 @@ export const FunctionsPanel = ({ space }: FunctionsPanelProps) => {
   );
 
   const handleGoToScript = useCallback(
-    (func: FunctionType) => {
+    (func: Function.Function) => {
       const script = functionToScriptMap[func.id];
       if (script) {
-        void dispatch(createIntent(LayoutAction.Open, { part: 'main', subject: [fullyQualifiedId(script)] }));
+        void dispatch(
+          createIntent(LayoutAction.Open, {
+            part: 'main',
+            subject: [Obj.getDXN(script).toString()],
+          }),
+        );
       }
     },
     [functionToScriptMap, dispatch],
   );
 
+  const handleDelete = useCallback(
+    (func: Function.Function) => dispatch(createIntent(SpaceAction.RemoveObjects, { objects: [func] })),
+    [dispatch],
+  );
+
   return (
     <div role='none' className={mx(controlItemClasses)}>
       {functions.length > 0 && (
-        <List.Root<FunctionType> items={functions} isItem={Schema.is(FunctionType)} getId={(func) => func.id}>
+        <List.Root<Function.Function> items={functions} isItem={Schema.is(Function.Function)} getId={(func) => func.id}>
           {({ items }) => (
-            <div role='list' className='flex flex-col w-full'>
+            <div role='list' className='flex flex-col is-full'>
               {items?.map((func) => (
-                <List.Item<FunctionType>
+                <List.Item<Function.Function>
                   key={func.id}
                   item={func}
                   classNames={mx(grid, ghostHover, 'items-center', 'pli-2', 'min-bs-[3rem]')}
@@ -84,6 +97,12 @@ export const FunctionsPanel = ({ space }: FunctionsPanelProps) => {
                   {functionToScriptMap[func.id] && (
                     <Button onClick={() => handleGoToScript(func)}>{t('go to function source button label')}</Button>
                   )}
+                  <IconButton
+                    iconOnly
+                    icon='ph--trash--regular'
+                    label={t('delete function button label')}
+                    onClick={() => handleDelete(func)}
+                  />
                 </List.Item>
               ))}
             </div>

package/src/components/FunctionsRegistry/FunctionsRegistry.tsx

@@ -0,0 +1,127 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Array from 'effect/Array';
+import * as EffectFunction from 'effect/Function';
+import * as Order from 'effect/Order';
+import * as Schema from 'effect/Schema';
+import { useState } from 'react';
+import React, { useCallback } from 'react';
+
+import { Function } from '@dxos/functions';
+import { getDeployedFunctions } from '@dxos/functions-runtime/edge';
+import { useClient } from '@dxos/react-client';
+import { Filter, Query, type Space, useQuery } from '@dxos/react-client/echo';
+import { useAsyncEffect } from '@dxos/react-ui';
+import { IconButton, useTranslation } from '@dxos/react-ui';
+import { controlItemClasses } from '@dxos/react-ui-form';
+import { List } from '@dxos/react-ui-list';
+import { ghostHover, mx } from '@dxos/react-ui-theme';
+
+import { meta } from '../../meta';
+
+const grid = 'grid grid-cols-[1fr_1fr_auto] min-bs-[2.5rem]';
+
+type FunctionsRegistryProps = {
+  space: Space;
+};
+
+export const FunctionsRegistry = ({ space }: FunctionsRegistryProps) => {
+  const client = useClient();
+  const [loading, setLoading] = useState(true);
+  const [functions, setFunctions] = useState<Function.Function[]>([]);
+  const { t } = useTranslation(meta.id);
+
+  const dbFunctions = useQuery(space, Filter.type(Function.Function));
+
+  const state = (func: Function.Function) => {
+    const dbFunction = dbFunctions.find((f) => f.key === func.key);
+    if (!dbFunction) {
+      return 'import';
+    }
+    if (dbFunction.version === func.version && dbFunction.updated === func.updated) {
+      return 'none';
+    }
+    return 'update';
+  };
+
+  useAsyncEffect(async () => {
+    setLoading(true);
+    const functions = await getDeployedFunctions(client);
+    setFunctions(functions);
+    setLoading(false);
+  }, []);
+
+  const dedupedFunctions = EffectFunction.pipe(
+    functions,
+    Array.filter((_) => _.key !== undefined),
+    Array.sort(Order.reverse(Order.mapInput(Order.string, (_: Function.Function) => _.updated ?? ''))),
+    Array.dedupeWith((self, that) => self.key === that.key),
+    Array.sort(Order.mapInput(Order.string, (_: Function.Function) => _.key ?? '')),
+  );
+
+  const hanleImportOrUpdate = useCallback(
+    async (func: Function.Function) => {
+      const {
+        objects: [existingFunc],
+      } = await space.db.query(Query.type(Function.Function, { key: func.key })).run();
+      if (!existingFunc) {
+        space.db.add(func);
+        return;
+      }
+      Function.setFrom(existingFunc, func);
+    },
+    [space],
+  );
+
+  return (
+    <div role='none' className={mx(controlItemClasses)}>
+      {dedupedFunctions.length > 0 && (
+        <List.Root<Function.Function>
+          items={dedupedFunctions}
+          isItem={Schema.is(Function.Function)}
+          getId={(func) => func.id}
+        >
+          {({ items }) => (
+            <div role='list' className='flex flex-col is-full'>
+              {items?.map((func) => (
+                <List.Item<Function.Function>
+                  key={func.id}
+                  item={func}
+                  classNames={mx(grid, ghostHover, 'items-center', 'pli-2', 'min-bs-[3rem]')}
+                >
+                  <div className='flex flex-col truncate'>
+                    <List.ItemTitle classNames='truncate'>{func.name}</List.ItemTitle>
+                    <div className='text-xs text-description truncate'>{func.key}</div>
+                  </div>
+                  <div className='flex flex-col truncate'>
+                    <div className='text-xs text-description truncate'>{func.version}</div>
+                    <div className='text-xs text-description truncate'>
+                      {func.updated ? `Uploaded ${new Date(func.updated).toLocaleString()}` : ''}
+                    </div>
+                  </div>
+
+                  <IconButton
+                    iconOnly
+                    icon={state(func) === 'update' ? 'ph--arrows-clockwise--regular' : 'ph--download--regular'}
+                    label={
+                      state(func) === 'update' ? t('update function button label') : t('import function button label')
+                    }
+                    disabled={state(func) === 'none'}
+                    onClick={() => hanleImportOrUpdate(func)}
+                  />
+                </List.Item>
+              ))}
+            </div>
+          )}
+        </List.Root>
+      )}
+
+      {dedupedFunctions.length === 0 && !loading && (
+        <div className='text-center plb-4 text-gray-500'>{t('no functions found')}</div>
+      )}
+      {loading && <div className='text-center plb-4 text-gray-500'>{t('loading functions')}</div>}
+    </div>
+  );
+};

package/src/components/FunctionsRegistry/index.ts

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

package/src/components/TriggerEditor/FunctionInputEditor.tsx

@@ -6,12 +6,12 @@ import React, { useCallback, useMemo } from 'react';
 
 import { Ref, Type } from '@dxos/echo';
 import { type JsonPath } from '@dxos/echo/internal';
-import { type FunctionType } from '@dxos/functions';
+import { type Function } from '@dxos/functions';
 import { useOnTransition } from '@dxos/react-ui';
 import { Form, type FormInputStateProps, type QueryRefOptions, useFormValues } from '@dxos/react-ui-form';
 
 export type FunctionInputEditorProps = {
-  functions: FunctionType[];
+  functions: Function.Function[];
   onQueryRefOptions: QueryRefOptions;
 } & FormInputStateProps;
 

package/src/components/TriggerEditor/SpecSelector.tsx

@@ -5,7 +5,7 @@
 import React, { useCallback, useMemo } from 'react';
 
 import { Filter, Query } from '@dxos/echo';
-import { type FunctionTrigger, TriggerKinds, type TriggerType } from '@dxos/functions';
+import { Trigger } from '@dxos/functions';
 import { useTranslation } from '@dxos/react-ui';
 import { type InputProps, SelectInput, useInputProps } from '@dxos/react-ui-form';
 
@@ -15,10 +15,10 @@ export type SpecSelectorProps = InputProps;
 
 export const SpecSelector = (props: SpecSelectorProps) => {
   const { t } = useTranslation(meta.id);
-  const specProps = useInputProps(['spec' satisfies keyof FunctionTrigger]);
+  const specProps = useInputProps(['spec' satisfies keyof Trigger.Trigger]);
 
   const handleTypeChange = useCallback(
-    (_type: any, value: string): TriggerType | undefined => {
+    (_type: any, value: string): Trigger.Spec | undefined => {
       const getDefaultTriggerSpec = (kind: string) => {
         switch (kind) {
           case 'timer':
@@ -27,7 +27,6 @@ export const SpecSelector = (props: SpecSelectorProps) => {
             return {
               kind: 'subscription',
               query: {
-                string: 'Query.select(Filter.nothing())',
                 ast: Query.select(Filter.nothing()).ast,
               },
             };
@@ -55,7 +54,7 @@ export const SpecSelector = (props: SpecSelectorProps) => {
 
   const options = useMemo(
     () =>
-      TriggerKinds.map((kind) => ({
+      Trigger.Kinds.map((kind) => ({
         value: kind,
         label: t(`trigger type ${kind}`),
       })),

package/src/components/TriggerEditor/TriggerEditor.stories.tsx

@@ -5,35 +5,45 @@
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useState } from 'react';
 
-import { Filter, Obj, Ref } from '@dxos/echo';
-import { FunctionTrigger, FunctionType } from '@dxos/functions';
+import { Filter, Obj, Ref, Tag, Type } from '@dxos/echo';
+import { Function } from '@dxos/functions';
+import { Trigger } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 import { faker } from '@dxos/random';
-import { useSpaces } from '@dxos/react-client/echo';
-import { ContactType, withClientProvider } from '@dxos/react-client/testing';
+import { useQuery } from '@dxos/react-client/echo';
+import { TestSchema, useClientProvider, withClientProvider } from '@dxos/react-client/testing';
 import { useAsyncEffect } from '@dxos/react-ui';
-import { withTheme } from '@dxos/react-ui/testing';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { Employer, Organization, Person, Project } from '@dxos/types';
 
 import { functions } from '../../testing';
 import { translations } from '../../translations';
 
 import { TriggerEditor, type TriggerEditorProps } from './TriggerEditor';
 
+const types = [
+  // TODO(burdon): Get label from annotation.
+  { value: Organization.Organization.typename, label: 'Organization' },
+  { value: Person.Person.typename, label: 'Person' },
+  { value: Type.getTypename(Project.Project), label: 'Project' },
+  { value: Employer.Employer.typename, label: 'Employer' },
+];
+
 const DefaultStory = (props: Partial<TriggerEditorProps>) => {
-  const spaces = useSpaces();
-  const space = spaces[1];
-  const [trigger, setTrigger] = useState<FunctionTrigger>();
+  const { space } = useClientProvider();
+  const [trigger, setTrigger] = useState<Trigger.Trigger>();
+  const tags = useQuery(space, Filter.type(Tag.Tag));
 
   useAsyncEffect(async () => {
     if (!space) {
       return;
     }
 
-    const result = await space.db.query(Filter.type(FunctionType)).run();
+    const result = await space.db.query(Filter.type(Function.Function)).run();
     const fn = result.objects.find((fn) => fn.name === 'example.com/function/forex');
     invariant(fn);
     const trigger = space.db.add(
-      Obj.make(FunctionTrigger, {
+      Trigger.make({
         function: Ref.make(fn),
         spec: { kind: 'webhook' },
         input: {
@@ -50,8 +60,15 @@ const DefaultStory = (props: Partial<TriggerEditorProps>) => {
   }
 
   return (
-    <div role='none' className='w-[32rem] bs-fit border border-separator rounded-sm'>
-      <TriggerEditor space={space} trigger={trigger} onSave={(values) => console.log('on save', values)} {...props} />
+    <div role='none' className='is-[32rem] bs-fit border border-separator rounded-sm'>
+      <TriggerEditor
+        space={space}
+        trigger={trigger}
+        types={types}
+        tags={tags}
+        onSave={(values) => console.log('on save', values)}
+        {...props}
+      />
     </div>
   );
 };
@@ -62,17 +79,22 @@ const meta = {
   render: DefaultStory,
   decorators: [
     withTheme,
+    withLayout({ container: 'column' }),
     withClientProvider({
       createIdentity: true,
       createSpace: true,
-      types: [FunctionType, FunctionTrigger, ContactType],
+      types: [Tag.Tag, Function.Function, Trigger.Trigger, TestSchema.ContactType],
       onCreateSpace: ({ space }) => {
+        space.db.add(Tag.make({ label: 'Important' }));
+        space.db.add(Tag.make({ label: 'Investor' }));
+        space.db.add(Tag.make({ label: 'New' }));
+
         for (const fn of functions) {
-          space.db.add(Obj.make(FunctionType, fn));
+          space.db.add(Function.make(fn));
         }
         Array.from({ length: 10 }).map(() => {
           return space.db.add(
-            Obj.make(ContactType, {
+            Obj.make(TestSchema.ContactType, {
               name: faker.person.fullName(),
               identifiers: [],
             }),
@@ -82,7 +104,6 @@ const meta = {
     }),
   ],
   parameters: {
-    layout: 'column',
     translations,
   },
 } satisfies Meta<typeof DefaultStory>;

package/src/components/TriggerEditor/TriggerEditor.tsx

@@ -5,41 +5,38 @@
 import React, { useCallback, useMemo } from 'react';
 
 import { ComputeGraph } from '@dxos/conductor';
-import { Type } from '@dxos/echo';
-import { FunctionTrigger, FunctionType, ScriptType } from '@dxos/functions';
+import { DXN, type Query } from '@dxos/echo';
+import { Function, Script, Trigger } from '@dxos/functions';
 import { Filter, Ref, type Space, useQuery } from '@dxos/react-client/echo';
-import { Input, useDensityContext, useElevationContext, useThemeContext, useTranslation } from '@dxos/react-ui';
-import { Editor, createBasicExtensions, createThemeExtensions } from '@dxos/react-ui-editor';
+import { Input } from '@dxos/react-ui';
+import { QueryForm, type QueryFormProps } from '@dxos/react-ui-components';
 import { type CustomInputMap, Form, InputHeader, SelectInput, useRefQueryLookupHandler } from '@dxos/react-ui-form';
-import { inputTheme, mx } from '@dxos/react-ui-theme';
-
-import { meta } from '../../meta';
 
 import { FunctionInputEditor, type FunctionInputEditorProps } from './FunctionInputEditor';
 import { SpecSelector } from './SpecSelector';
 
 export type TriggerEditorProps = {
   space: Space;
-  trigger: FunctionTrigger;
+  trigger: Trigger.Trigger;
   // TODO(wittjosiah): This needs to apply to whole spec but currently only applies to spec.kind & spec.query.
   readonlySpec?: boolean;
-  onSave?: (trigger: Omit<FunctionTrigger, 'id'>) => void;
+  onSave?: (trigger: Omit<Trigger.Trigger, 'id'>) => void;
   onCancel?: () => void;
-};
+} & Pick<QueryFormProps, 'types' | 'tags'>;
 
-export const TriggerEditor = ({ space, trigger, readonlySpec, onSave, onCancel }: TriggerEditorProps) => {
-  const handleSave = (values: FunctionTrigger) => {
+export const TriggerEditor = ({ space, trigger, readonlySpec, types, tags, onSave, onCancel }: TriggerEditorProps) => {
+  const handleSave = ({ id: _, ...values }: Trigger.Trigger) => {
     onSave?.(values);
   };
 
   const handleRefQueryLookup = useRefQueryLookupHandler({ space });
-  const Custom = useCustomInputs({ space, readonlySpec, onQueryRefOptions: handleRefQueryLookup });
+  const Custom = useCustomInputs({ space, readonlySpec, types, tags, onQueryRefOptions: handleRefQueryLookup });
 
   return (
     <Form
       outerSpacing={false}
       Custom={Custom}
-      schema={FunctionTrigger}
+      schema={Trigger.Trigger}
       values={trigger}
       onSave={handleSave}
       onCancel={onCancel}
@@ -48,24 +45,21 @@ export const TriggerEditor = ({ space, trigger, readonlySpec, onSave, onCancel }
   );
 };
 
-const useCustomInputs = ({
-  space,
-  readonlySpec,
-  onQueryRefOptions,
-}: {
+type UseCustomInputsProps = {
   space: Space;
   readonlySpec?: boolean;
   onQueryRefOptions: FunctionInputEditorProps['onQueryRefOptions'];
-}) => {
-  const { t } = useTranslation(meta.id);
-  const functions = useQuery(space, Filter.type(FunctionType));
+} & Pick<QueryFormProps, 'types' | 'tags'>;
+
+const useCustomInputs = ({ space, readonlySpec, types, tags, onQueryRefOptions }: UseCustomInputsProps) => {
+  const functions = useQuery(space, Filter.type(Function.Function));
   const workflows = useQuery(space, Filter.type(ComputeGraph));
-  const scripts = useQuery(space, Filter.type(ScriptType));
+  const scripts = useQuery(space, Filter.type(Script.Script));
 
   return useMemo(
     (): CustomInputMap => ({
       // Function selector.
-      ['function' satisfies keyof FunctionTrigger]: (props) => {
+      ['function' satisfies keyof Trigger.Trigger]: (props) => {
         const getValue = useCallback(() => {
           const formValue = props.getValue();
           if (Ref.isRef(formValue)) {
@@ -76,7 +70,7 @@ const useCustomInputs = ({
 
         const handleOnValueChange = useCallback(
           (_type: any, dxnString: string) => {
-            const dxn = Type.DXN.parse(dxnString);
+            const dxn = DXN.parse(dxnString);
             if (dxn) {
               const ref = Ref.fromDXN(dxn);
               props.onValueChange('object', ref);
@@ -101,39 +95,15 @@ const useCustomInputs = ({
       // TODO(wittjosiah): Copied from ViewEditor.
       // Query input editor.
       ['spec.query' as const]: (props) => {
-        const { themeMode } = useThemeContext();
-        const density = useDensityContext();
-        const elevation = useElevationContext();
-        const value = props.getValue() as any;
-
-        // TODO(wittjosiah): Including props.onValueChange in deps causes infinite loop.
         const handleChange = useCallback(
-          (text: string) => props.onValueChange('object', { ...value, string: text }),
-          [],
-        );
-
-        const extensions = useMemo(
-          () => [
-            createBasicExtensions({ readOnly: readonlySpec, placeholder: t('query placeholder') }),
-            createThemeExtensions({ themeMode }),
-          ],
-          [],
+          (query: Query.Any) => props.onValueChange('object', { ast: query.ast }),
+          [props.onValueChange],
         );
 
-        // TODO(wittjosiah): This is probably not the right way to do these styles.
         return (
           <Input.Root>
             <InputHeader label={props.label} />
-            <Editor
-              classNames={mx(
-                inputTheme.input({ density, elevation }),
-                'flex items-center',
-                'focus-within:bg-focusSurface focus-within:border-separator focus-within:hover:bg-focusSurface',
-              )}
-              extensions={extensions}
-              value={value.string}
-              onChange={handleChange}
-            />
+            <QueryForm initialQuery={(props.getValue() as any).ast} types={types} tags={tags} onChange={handleChange} />
           </Input.Root>
         );
       },
@@ -151,7 +121,7 @@ const getWorkflowOptions = (graphs: ComputeGraph[]) => {
   return graphs.map((graph) => ({ label: `compute-${graph.id}`, value: `dxn:echo:@:${graph.id}` }));
 };
 
-const getFunctionOptions = (scripts: ScriptType[], functions: FunctionType[]) => {
-  const getLabel = (fn: FunctionType) => scripts.find((s) => fn.source?.target?.id === s.id)?.name ?? fn.name;
+const getFunctionOptions = (scripts: Script.Script[], functions: Function.Function[]) => {
+  const getLabel = (fn: Function.Function) => scripts.find((s) => fn.source?.target?.id === s.id)?.name ?? fn.name;
   return functions.map((fn) => ({ label: getLabel(fn), value: `dxn:echo:@:${fn.id}` }));
 };

package/src/hooks/useComputeRuntimeCallback.ts

@@ -2,10 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import type * as Effect from 'effect/Effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
 import { useCallback } from 'react';
 
-import { useCapability } from '@dxos/app-framework';
+import { useCapability } from '@dxos/app-framework/react';
+import { type FunctionDefinition, FunctionInvocationService } from '@dxos/functions';
+import { InvocationTracer, TracingServiceExt } from '@dxos/functions-runtime';
+import { log } from '@dxos/log';
 import type { Space } from '@dxos/react-client/echo';
 
 import { AutomationCapabilities } from '../capabilities';
@@ -13,6 +18,7 @@ import { AutomationCapabilities } from '../capabilities';
 /**
  * Create an effectful function that has access to compute services
  */
+// TODO(burdon): Factor out (figure out cross-plugin capabilities dependencies).
 export const useComputeRuntimeCallback = <T>(
   space: Space | undefined,
   fn: () => Effect.Effect<T, any, AutomationCapabilities.ComputeServices>,
@@ -25,6 +31,38 @@ export const useComputeRuntimeCallback = <T>(
     if (!runtime) {
       throw new TypeError('Space not provided to useComputeRuntimeCallback');
     }
+
     return runtime.runPromise(fn());
   }, [runtime, ...(deps ?? [])]);
 };
+
+// TODO(wittjosiah): Function invoking should automatically be traced (DX-647).
+export const invokeFunctionWithTracing = <I, O>(functionDef: FunctionDefinition<I, O>, inputData: I) =>
+  Effect.gen(function* () {
+    const tracer = yield* InvocationTracer;
+    const trace = yield* tracer.traceInvocationStart({
+      target: undefined,
+      payload: {
+        data: {},
+      },
+    });
+
+    // Invoke the function.
+    const result = yield* FunctionInvocationService.invokeFunction(functionDef, inputData).pipe(
+      Effect.provide(TracingServiceExt.layerQueue(trace.invocationTraceQueue)),
+      Effect.exit,
+    );
+
+    if (Exit.isFailure(result)) {
+      const error = Cause.prettyErrors(result.cause)[0];
+      log.error(error.message, error.cause ?? error.stack);
+    }
+
+    yield* tracer.traceInvocationEnd({
+      trace,
+      // TODO(dmaretskyi): Might miss errors.
+      exception: Exit.isFailure(result) ? Cause.prettyErrors(result.cause)[0] : undefined,
+    });
+
+    return result;
+  });

package/src/hooks/useTriggerRuntimeControls.ts

@@ -5,21 +5,22 @@
 import * as Effect from 'effect/Effect';
 
 import { Filter } from '@dxos/echo';
-import { FunctionTrigger, TriggerDispatcher } from '@dxos/functions';
+import { Trigger } from '@dxos/functions';
+import { TriggerDispatcher } from '@dxos/functions-runtime';
 import { type Space, useQuery } from '@dxos/react-client/echo';
 import { useAsyncState } from '@dxos/react-ui';
 
 import { useComputeRuntimeCallback } from './useComputeRuntimeCallback';
 
 interface TriggerRuntimeControls {
-  triggers: FunctionTrigger[];
+  triggers: Trigger.Trigger[];
   isRunning: boolean;
   start: () => void;
   stop: () => void;
 }
 
 export const useTriggerRuntimeControls = (space: Space | undefined): TriggerRuntimeControls => {
-  const triggers = useQuery(space, Filter.type(FunctionTrigger));
+  const triggers = useQuery(space, Filter.type(Trigger.Trigger));
 
   const [isRunningState, setIsRunningState] = useAsyncState(
     useComputeRuntimeCallback(space, () => TriggerDispatcher.pipe(Effect.map((t) => t.running))),

package/src/index.ts

@@ -6,5 +6,6 @@ export { AutomationCapabilities } from './capabilities';
 export * from './components';
 export * from './meta';
 export * from './events';
+export * from './hooks';
 
 export * from './AutomationPlugin';

package/src/meta.ts

@@ -3,12 +3,15 @@
 //
 
 import { type PluginMeta } from '@dxos/app-framework';
+import { trim } from '@dxos/util';
 
 export const meta: PluginMeta = {
   id: 'dxos.org/plugin/automation',
   name: 'Automation',
-  description:
-    'The Automation tab allows you to trigger pre-defined workflows related to the element you are interacting with inside of Composer.',
+  description: trim`
+    Workflow automation engine that triggers custom actions based on object events and conditions.
+    Create automated pipelines that respond to changes and streamline repetitive tasks.
+  `,
   icon: 'ph--robot--regular',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-automation',
 };