@dxos/functions 0.8.4-main.7ace549 → 0.8.4-main.8360d9e660

package/src/sdk.ts

@@ -7,9 +7,10 @@ import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
 import { type AiService } from '@dxos/ai';
-import { Obj, Type } from '@dxos/echo';
-import { type DatabaseService } from '@dxos/echo-db';
+import { type Feed, JsonSchema, Obj, type Type } from '@dxos/echo';
+import { type Database } from '@dxos/echo';
 import { assertArgument, failedInvariant } from '@dxos/invariant';
+import { Operation } from '@dxos/operation';
 
 import {
   type CredentialsService,
@@ -37,8 +38,10 @@ export type FunctionServices =
   | InvocationServices
   | AiService.AiService
   | CredentialsService
-  | DatabaseService
+  | Database.Service
+  // TODO(wittjosiah): Remove QueueService — use Feed.Service instead.
   | QueueService
+  | Feed.Service
   | FunctionInvocationService;
 
 /**
@@ -67,26 +70,29 @@ export interface FunctionContext {
 
 const typeId = Symbol.for('@dxos/functions/FunctionDefinition');
 
-export type FunctionDefinition<T = any, O = any, S extends FunctionServices = FunctionServices> = {
+/**
+ * Deployable function definition.
+ */
+export type FunctionDefinition<TInput = any, TOutput = any, S extends FunctionServices = FunctionServices> = {
   [typeId]: true;
+
   key: string;
   name: string;
   description?: string;
-  inputSchema: Schema.Schema<T, any>;
-  outputSchema?: Schema.Schema<O, any>;
+  inputSchema: Schema.Schema<TInput, any>;
+  outputSchema?: Schema.Schema<TOutput, any>;
 
   /**
    * List of types the function uses.
    * This is used to ensure that the types are available when the function is executed.
    */
-  types: readonly Type.Obj.Any[];
+  types: readonly Type.AnyEntity[];
 
   /**
    * Keys of the required services.
    */
   services: readonly string[];
 
-  handler: FunctionHandler<T, O, S>;
   meta?: {
     /**
      * Tools that are projected from functions have this annotation.
@@ -99,6 +105,8 @@ export type FunctionDefinition<T = any, O = any, S extends FunctionServices = Fu
      */
     deployedFunctionId?: string;
   };
+
+  handler: FunctionHandler<TInput, TOutput, S>;
 };
 
 export declare namespace FunctionDefinition {
@@ -119,7 +127,8 @@ export type FunctionProps<T, O> = {
    * List of types the function uses.
    * This is used to ensure that the types are available when the function is executed.
    */
-  types?: readonly Type.Obj.Any[];
+  types?: readonly Type.AnyEntity[];
+
   // TODO(dmaretskyi): This currently doesn't cause a compile-time error if the handler requests a service that is not specified
   services?: readonly Context.Tag<any, any>[];
 
@@ -176,7 +185,7 @@ export const defineFunction: {
     handler: handlerWithSpan,
     types: types ?? [],
     services: !services ? [] : getServiceKeys(services),
-  } satisfies FunctionDefinition.Any;
+  };
 };
 
 const getServiceKeys = (services: readonly Context.Tag<any, any>[]) => {
@@ -184,11 +193,58 @@ const getServiceKeys = (services: readonly Context.Tag<any, any>[]) => {
     if (typeof tag.key === 'string') {
       return tag.key;
     }
-    console.log(tag);
     failedInvariant();
   });
 };
 
+/**
+ * Converts a FunctionDefinition to an OperationDefinition with handler.
+ * The function handler is adapted to the OperationHandler format.
+ *
+ * Note: FunctionDefinition stores service keys as strings, not Tag types,
+ * so we can't use Operation.withHandler's type inference here.
+ */
+export const toOperation = <T, O, S extends FunctionServices = FunctionServices>(
+  functionDef: FunctionDefinition<T, O, S>,
+): Operation.Definition<T, O> & { handler: Operation.Handler<T, O, any, S> } => {
+  const op = Operation.make({
+    schema: {
+      input: functionDef.inputSchema,
+      output: functionDef.outputSchema ?? Schema.Any,
+    },
+    meta: {
+      key: functionDef.key,
+      name: functionDef.name,
+      description: functionDef.description,
+    },
+  });
+
+  // Adapt FunctionHandler signature to OperationHandler format.
+  // FunctionHandler expects { context, data }, OperationHandler expects just input.
+  const operationHandler: Operation.Handler<T, O, any, S> = (input: T) => {
+    const result = functionDef.handler({
+      context: {} as FunctionContext,
+      data: input,
+    });
+
+    // Convert Promise or plain value to Effect.
+    if (Effect.isEffect(result)) {
+      return result;
+    }
+    if (result instanceof Promise) {
+      return Effect.tryPromise(() => result);
+    }
+    return Effect.succeed(result as O);
+  };
+
+  // Manually attach handler since FunctionDefinition stores service keys as strings,
+  // not Tag types, so withHandler's type inference doesn't apply.
+  return {
+    ...op,
+    handler: operationHandler,
+  };
+};
+
 export const FunctionDefinition = {
   make: defineFunction,
   isFunction: (value: unknown): value is FunctionDefinition.Any => {
@@ -202,6 +258,7 @@ export const FunctionDefinition = {
     assertArgument(Obj.instanceOf(Function.Function, functionObj), 'functionObj');
     return deserializeFunction(functionObj);
   },
+  toOperation,
 };
 
 export const serializeFunction = (functionDef: FunctionDefinition.Any): Function.Function => {
@@ -210,12 +267,12 @@ export const serializeFunction = (functionDef: FunctionDefinition.Any): Function
     name: functionDef.name,
     version: '0.1.0',
     description: functionDef.description,
-    inputSchema: Type.toJsonSchema(functionDef.inputSchema),
-    outputSchema: !functionDef.outputSchema ? undefined : Type.toJsonSchema(functionDef.outputSchema),
+    inputSchema: JsonSchema.toJsonSchema(functionDef.inputSchema),
+    outputSchema: !functionDef.outputSchema ? undefined : JsonSchema.toJsonSchema(functionDef.outputSchema),
     services: functionDef.services,
   });
   if (functionDef.meta?.deployedFunctionId) {
-    setUserFunctionIdInMetadata(Obj.getMeta(fn), functionDef.meta.deployedFunctionId);
+    Obj.change(fn, (fn) => setUserFunctionIdInMetadata(Obj.getMeta(fn), functionDef.meta!.deployedFunctionId!));
   }
   return fn;
 };
@@ -227,8 +284,8 @@ export const deserializeFunction = (functionObj: Function.Function): FunctionDef
     key: functionObj.key ?? functionObj.name,
     name: functionObj.name,
     description: functionObj.description,
-    inputSchema: !functionObj.inputSchema ? Schema.Unknown : Type.toEffectSchema(functionObj.inputSchema),
-    outputSchema: !functionObj.outputSchema ? undefined : Type.toEffectSchema(functionObj.outputSchema),
+    inputSchema: !functionObj.inputSchema ? Schema.Unknown : JsonSchema.toEffectSchema(functionObj.inputSchema),
+    outputSchema: !functionObj.outputSchema ? undefined : JsonSchema.toEffectSchema(functionObj.outputSchema),
     // TODO(dmaretskyi): This should throw error.
     handler: () => {},
     services: functionObj.services ?? [],

package/src/services/credentials.ts

@@ -11,7 +11,7 @@ import * as Layer from 'effect/Layer';
 import * as Redacted from 'effect/Redacted';
 
 import { Query } from '@dxos/echo';
-import { DatabaseService } from '@dxos/echo-db';
+import { Database } from '@dxos/echo';
 import { AccessToken } from '@dxos/types';
 
 export type CredentialQuery = {
@@ -60,7 +60,12 @@ export class CredentialsService extends Context.Tag('@dxos/functions/Credentials
   static configuredLayer = (credentials: ServiceCredential[]) =>
     Layer.succeed(CredentialsService, new ConfiguredCredentialsService(credentials));
 
-  static layerConfig = (credentials: { service: string; apiKey: Config.Config<Redacted.Redacted<string>> }[]) =>
+  static layerConfig = (
+    credentials: {
+      service: string;
+      apiKey: Config.Config<Redacted.Redacted<string>>;
+    }[],
+  ) =>
     Layer.effect(
       CredentialsService,
       Effect.gen(function* () {
@@ -77,20 +82,34 @@ export class CredentialsService extends Context.Tag('@dxos/functions/Credentials
       }),
     );
 
-  static layerFromDatabase = () =>
+  static layerFromDatabase = ({ caching = false }: { caching?: boolean } = {}) =>
     Layer.effect(
       CredentialsService,
       Effect.gen(function* () {
-        const dbService = yield* DatabaseService;
+        const dbService = yield* Database.Service;
+        const cache = new Map<string, ServiceCredential[]>();
+
         const queryCredentials = async (query: CredentialQuery): Promise<ServiceCredential[]> => {
-          const { objects: accessTokens } = await dbService.db.query(Query.type(AccessToken.AccessToken)).run();
-          return accessTokens
+          const cacheKey = JSON.stringify(query);
+          if (caching && cache.has(cacheKey)) {
+            return cache.get(cacheKey)!;
+          }
+
+          const accessTokens = await dbService.db.query(Query.type(AccessToken.AccessToken)).run();
+          const credentials = accessTokens
             .filter((accessToken) => accessToken.source === query.service)
             .map((accessToken) => ({
               service: accessToken.source,
               apiKey: accessToken.token,
             }));
+
+          if (caching) {
+            cache.set(cacheKey, credentials);
+          }
+
+          return credentials;
         };
+
         return {
           getCredential: async (query) => {
             const credentials = await queryCredentials(query);
@@ -131,13 +150,10 @@ export class ConfiguredCredentialsService implements Context.Tag.Service<Credent
 }
 
 /**
- * Maps the request to include the API key from the credential.
+ * Maps the request to include the given token in the Authorization header.
  */
-export const withAuthorization = (query: CredentialQuery, kind?: 'Bearer' | 'Basic') =>
-  HttpClient.mapRequestEffect(
-    Effect.fnUntraced(function* (request) {
-      const key = yield* CredentialsService.getApiKey(query).pipe(Effect.map(Redacted.value));
-      const authorization = kind ? `${kind} ${key}` : key;
-      return HttpClientRequest.setHeader(request, 'Authorization', authorization);
-    }),
-  );
+export const withAuthorization = (token: string, kind?: 'Bearer' | 'Basic') =>
+  HttpClient.mapRequest((request) => {
+    const authorization = kind ? `${kind} ${token}` : token;
+    return HttpClientRequest.setHeader(request, 'Authorization', authorization);
+  });

package/src/services/event-logger.ts

@@ -52,7 +52,7 @@ export type ComputeEventPayload = Schema.Schema.Type<typeof ComputeEventPayload>
 
 export const ComputeEvent = Schema.Struct({
   payload: ComputeEventPayload,
-}).pipe(Type.Obj({ typename: 'dxos.org/type/ComputeEvent', version: '0.1.0' }));
+}).pipe(Type.object({ typename: 'org.dxos.type.compute-event', version: '0.1.0' }));
 
 /**
  * Logs event for the compute workflows.
@@ -75,7 +75,7 @@ export class ComputeEventLogger extends Context.Tag('@dxos/functions/ComputeEven
       const tracing = yield* TracingService;
       return {
         log: (event: ComputeEventPayload) => {
-          tracing.write(Obj.make(ComputeEvent, { payload: event }));
+          tracing.write(Obj.make(ComputeEvent, { payload: event }), tracing.getTraceContext());
         },
         nodeId: undefined,
       };

package/src/services/function-invocation-service.ts

@@ -3,7 +3,9 @@
 //
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
 
+import type { FunctionNotFoundError } from '../errors';
 import { type FunctionDefinition, type InvocationServices } from '../sdk';
 
 export class FunctionInvocationService extends Context.Tag('@dxos/functions/FunctionInvocationService')<
@@ -13,11 +15,23 @@ export class FunctionInvocationService extends Context.Tag('@dxos/functions/Func
       functionDef: FunctionDefinition<I, O, any>,
       input: I,
     ): Effect.Effect<O, never, InvocationServices>;
+
+    resolveFunction(key: string): Effect.Effect<FunctionDefinition.Any, FunctionNotFoundError>;
   }
 >() {
+  static layerNotAvailable = Layer.succeed(FunctionInvocationService, {
+    invokeFunction: () => Effect.die('FunctionInvocationService is not avaialble.'),
+    resolveFunction: () => Effect.die('FunctionInvocationService is not available.'),
+  });
+
   static invokeFunction = <I, O>(
     functionDef: FunctionDefinition<I, O, any>,
     input: I,
   ): Effect.Effect<O, never, FunctionInvocationService | InvocationServices> =>
     Effect.serviceFunctionEffect(FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
+
+  static resolveFunction = (
+    key: string,
+  ): Effect.Effect<FunctionDefinition.Any, FunctionNotFoundError, FunctionInvocationService> =>
+    Effect.serviceFunctionEffect(FunctionInvocationService, (service) => service.resolveFunction)(key);
 }

package/src/services/index.ts

@@ -2,8 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-export { DatabaseService } from '@dxos/echo-db';
-
 export * from './credentials';
 export { ConfiguredCredentialsService, type ServiceCredential } from './credentials';
 export * from './event-logger';

package/src/services/tracing.ts

@@ -7,10 +7,12 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
 import { AgentStatus } from '@dxos/ai';
-import { Obj } from '@dxos/echo';
-import { type ObjectId } from '@dxos/keys';
+import { type DXN, Obj } from '@dxos/echo';
+import { ObjectId } from '@dxos/keys';
 import { Message } from '@dxos/types';
 
+import type { Trigger } from '../types';
+
 /**
  * Provides a way for compute primitives (functions, workflows, tools)
  * to emit an execution trace as a series of structured ECHO objects.
@@ -27,15 +29,35 @@ export class TracingService extends Context.Tag('@dxos/functions/TracingService'
      * Write an event to the tracing queue.
      * @param event - The event to write. Must be an a typed object.
      */
-    write: (event: Obj.Any) => void;
+    write: (event: Obj.Unknown, traceContext: TracingService.TraceContext) => void;
+
+    traceInvocationStart({
+      payload,
+      target,
+    }: {
+      payload: TracingService.FunctionInvocationPayload;
+      target?: DXN;
+    }): Effect.Effect<TracingService.InvocationTraceData>;
+
+    traceInvocationEnd({
+      trace,
+      exception,
+    }: {
+      trace: TracingService.InvocationTraceData;
+      exception?: any;
+    }): Effect.Effect<void>;
   }
 >() {
   static noop: Context.Tag.Service<TracingService> = {
     getTraceContext: () => ({}),
     write: () => {},
+    traceInvocationStart: () =>
+      Effect.sync(() => ({ invocationId: ObjectId.random(), invocationTraceQueue: undefined })),
+    traceInvocationEnd: () => Effect.sync(() => {}),
   };
 
   static layerNoop: Layer.Layer<TracingService> = Layer.succeed(TracingService, TracingService.noop);
+
   /**
    * Creates a TracingService layer that emits events to the parent tracing service.
    */
@@ -46,12 +68,25 @@ export class TracingService extends Context.Tag('@dxos/functions/TracingService'
         const tracing = yield* TracingService;
         const context = mapContext(tracing.getTraceContext());
         return {
-          write: (event) => tracing.write(event),
+          write: (event, context) => tracing.write(event, context),
           getTraceContext: () => context,
+          traceInvocationStart: () => Effect.die('Tracing invocation inside another invocation is not supported.'),
+          traceInvocationEnd: () => Effect.die('Tracing invocation inside another invocation is not supported.'),
         };
       }),
     );
 
+  /**
+   * Create sublayer to trace an invocation.
+   * @param data
+   * @returns
+   */
+  static layerInvocation = (data: TracingService.InvocationTraceData) =>
+    TracingService.layerSubframe((context) => ({
+      ...context,
+      currentInvocation: data,
+    }));
+
   /**
    * Emit the current human-readable execution status.
    */
@@ -66,6 +101,7 @@ export class TracingService extends Context.Tag('@dxos/functions/TracingService'
         created: new Date().toISOString(),
         ...data,
       }),
+      tracing.getTraceContext(),
     );
   });
 
@@ -82,12 +118,15 @@ export class TracingService extends Context.Tag('@dxos/functions/TracingService'
           ...data.properties,
         },
       }),
+      tracing.getTraceContext(),
     );
   });
 }
 
 export namespace TracingService {
   export interface TraceContext {
+    currentInvocation?: InvocationTraceData;
+
     /**
      * If this thread sprung from a tool call, this is the ID of the message containing the tool call.
      */
@@ -100,6 +139,26 @@ export namespace TracingService {
 
     debugInfo?: unknown;
   }
+
+  /**
+   * Trace data for a function/trigger invocation.
+   */
+  export interface InvocationTraceData {
+    invocationId: ObjectId;
+    invocationTraceQueue?: DXN.String;
+  }
+
+  /**
+   * Payload for a function/trigger invocation.
+   */
+  export interface FunctionInvocationPayload {
+    data?: any;
+    inputNodeId?: string;
+    trigger?: {
+      id: string;
+      kind: Trigger.Kind;
+    };
+  }
 }
 
 /**

package/src/types/Function.ts

@@ -4,7 +4,7 @@
 
 import * as Schema from 'effect/Schema';
 
-import { Annotation, JsonSchema, Obj, Type } from '@dxos/echo';
+import { Annotation, JsonSchema, Obj, Ref, Type } from '@dxos/echo';
 import { SystemTypeAnnotation } from '@dxos/echo/internal';
 
 import { Script } from './Script';
@@ -36,7 +36,7 @@ export const Function = Schema.Struct({
 
   // Reference to a source script if it exists within ECHO.
   // TODO(burdon): Don't ref ScriptType directly (core).
-  source: Schema.optional(Type.Ref(Script)),
+  source: Schema.optional(Ref.Ref(Script)),
 
   inputSchema: Schema.optional(JsonSchema.JsonSchema),
   outputSchema: Schema.optional(JsonSchema.JsonSchema),
@@ -50,11 +50,12 @@ export const Function = Schema.Struct({
   // Local binding to a function name.
   binding: Schema.optional(Schema.String),
 }).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/Function',
+  Type.object({
+    typename: 'org.dxos.type.function',
     version: '0.1.0',
   }),
   Annotation.LabelAnnotation.set(['name']),
+  Annotation.IconAnnotation.set({ icon: 'ph--function--regular', hue: 'blue' }),
   SystemTypeAnnotation.set(true),
 );
 
@@ -68,13 +69,15 @@ export const make = (props: Obj.MakeProps<typeof Function>) => Obj.make(Function
  * @param source - Source object to copy properties from.
  */
 export const setFrom = (target: Function, source: Function) => {
-  target.key = source.key ?? target.key;
-  target.name = source.name ?? target.name;
-  target.version = source.version;
-  target.description = source.description;
-  target.updated = source.updated;
-  // TODO(dmaretskyi): A workaround for an ECHO bug.
-  target.inputSchema = source.inputSchema ? JSON.parse(JSON.stringify(source.inputSchema)) : undefined;
-  target.outputSchema = source.outputSchema ? JSON.parse(JSON.stringify(source.outputSchema)) : undefined;
-  Obj.getMeta(target).keys = JSON.parse(JSON.stringify(Obj.getMeta(source).keys));
+  Obj.change(target, (t) => {
+    t.key = source.key ?? target.key;
+    t.name = source.name ?? target.name;
+    t.version = source.version;
+    t.description = source.description;
+    t.updated = source.updated;
+    // TODO(dmaretskyi): A workaround for an ECHO bug.
+    t.inputSchema = source.inputSchema ? JSON.parse(JSON.stringify(source.inputSchema)) : undefined;
+    t.outputSchema = source.outputSchema ? JSON.parse(JSON.stringify(source.outputSchema)) : undefined;
+    Obj.getMeta(t).keys = JSON.parse(JSON.stringify(Obj.getMeta(source).keys));
+  });
 };

package/src/types/Script.ts

@@ -17,17 +17,22 @@ export const Script = Schema.Struct({
   // TODO(burdon): Change to hash of deployed content.
   // Whether source has changed since last deploy.
   changed: Schema.Boolean.pipe(FormInputAnnotation.set(false), Schema.optional),
-  source: Type.Ref(Text.Text).pipe(FormInputAnnotation.set(false)),
+  source: Ref.Ref(Text.Text).pipe(FormInputAnnotation.set(false)),
 }).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/Script',
+  Type.object({
+    typename: 'org.dxos.type.script',
     version: '0.1.0',
   }),
   Annotation.LabelAnnotation.set(['name']),
+  Annotation.IconAnnotation.set({
+    icon: 'ph--code--regular',
+    hue: 'sky',
+  }),
 );
+
 export interface Script extends Schema.Schema.Type<typeof Script> {}
 
 type Props = Omit<Obj.MakeProps<typeof Script>, 'source'> & { source?: string };
 
-export const make = ({ source = '', ...props }: Props = {}) =>
+export const make = ({ source = '', ...props }: Props = {}): Script =>
   Obj.make(Script, { ...props, source: Ref.make(Text.make(source)) });

package/src/types/Trigger.ts

@@ -5,9 +5,10 @@
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { Obj, QueryAST, Type } from '@dxos/echo';
+import { Annotation, Obj, QueryAST, Ref, Type } from '@dxos/echo';
 import { OptionsAnnotationId, SystemTypeAnnotation } from '@dxos/echo/internal';
 import { DXN } from '@dxos/keys';
+import { Expando } from '@dxos/schema';
 
 /**
  * Type discriminator for TriggerType.
@@ -21,15 +22,16 @@ const kindLiteralAnnotations = { title: 'Kind' };
 
 export const EmailSpec = Schema.Struct({
   kind: Schema.Literal('email').annotations(kindLiteralAnnotations),
-}).pipe(Schema.mutable);
+});
 export type EmailSpec = Schema.Schema.Type<typeof EmailSpec>;
 
+// TODO(wittjosiah): Remove. Migrate to Subscription triggers once EDGE supports them for feed queries.
 export const QueueSpec = Schema.Struct({
   kind: Schema.Literal('queue').annotations(kindLiteralAnnotations),
 
   // TODO(dmaretskyi): Change to a reference.
   queue: DXN.Schema,
-}).pipe(Schema.mutable);
+});
 export type QueueSpec = Schema.Schema.Type<typeof QueueSpec>;
 
 /**
@@ -40,7 +42,7 @@ export const SubscriptionSpec = Schema.Struct({
   query: Schema.Struct({
     raw: Schema.optional(Schema.String.annotations({ title: 'Query' })),
     ast: QueryAST.Query,
-  }).pipe(Schema.mutable),
+  }),
   options: Schema.optional(
     Schema.Struct({
       // Watch changes to object (not just creation).
@@ -49,7 +51,7 @@ export const SubscriptionSpec = Schema.Struct({
       delay: Schema.optional(Schema.Number.annotations({ title: 'Delay' })),
     }).annotations({ title: 'Options' }),
   ),
-}).pipe(Schema.mutable);
+});
 export type SubscriptionSpec = Schema.Schema.Type<typeof SubscriptionSpec>;
 
 /**
@@ -61,7 +63,7 @@ export const TimerSpec = Schema.Struct({
     title: 'Cron',
     [SchemaAST.ExamplesAnnotationId]: ['0 0 * * *'],
   }),
-}).pipe(Schema.mutable);
+});
 export type TimerSpec = Schema.Schema.Type<typeof TimerSpec>;
 
 /**
@@ -80,7 +82,7 @@ export const WebhookSpec = Schema.Struct({
       title: 'Port',
     }),
   ),
-}).pipe(Schema.mutable);
+});
 export type WebhookSpec = Schema.Schema.Type<typeof WebhookSpec>;
 
 /**
@@ -96,12 +98,12 @@ export type Spec = Schema.Schema.Type<typeof Spec>;
  * Function is invoked with the `payload` passed as input data.
  * The event that triggers the function is available in the function context.
  */
-const Trigger_ = Schema.Struct({
+const TriggerSchema = Schema.Struct({
   /**
    * Function or workflow to invoke.
    */
   // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema.optional(Type.Ref(Type.Expando).annotations({ title: 'Function' })),
+  function: Schema.optional(Ref.Ref(Expando.Expando).annotations({ title: 'Function' })),
 
   /**
    * Only used for workflowSchema.
@@ -110,31 +112,43 @@ const Trigger_ = Schema.Struct({
    */
   inputNodeId: Schema.optional(Schema.String.annotations({ title: 'Input Node ID' })),
 
+  // TODO(burdon): NO BOOLEAN PROPERTIES (enabld/disabled/paused, etc.)
+  //  Need lint rule; or agent rule to require PR review for "boolean" key word.
   enabled: Schema.optional(Schema.Boolean.annotations({ title: 'Enabled' })),
 
   spec: Schema.optional(Spec),
 
+  concurrency: Schema.optional(
+    Schema.Number.annotations({
+      title: 'Concurrency',
+      default: 1,
+      description:
+        'Maximum number of concurrent invocations of the trigger. For queue triggers, this will process queue items in parallel.',
+    }),
+  ),
+
   /**
    * Passed as the input data to the function.
    * Must match the function's input schema.
    *
    * @example
    * {
-   *   item: '{{$.trigger.event}}',
+   *   item: '{{event.item}}',
    *   instructions: 'Summarize and perform entity-extraction'
    *   mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
    * }
    */
-  input: Schema.optional(Schema.mutable(Schema.Record({ key: Schema.String, value: Schema.Any }))),
+  input: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
 }).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/Trigger',
+  Type.object({
+    typename: 'org.dxos.type.trigger',
     version: '0.1.0',
   }),
+  Annotation.IconAnnotation.set({ icon: 'ph--lightning--regular', hue: 'yellow' }),
   SystemTypeAnnotation.set(true),
 );
-export interface Trigger extends Schema.Schema.Type<typeof Trigger_> {}
-export interface TriggerEncoded extends Schema.Schema.Encoded<typeof Trigger_> {}
-export const Trigger: Schema.Schema<Trigger, TriggerEncoded> = Trigger_;
+
+export interface Trigger extends Schema.Schema.Type<typeof TriggerSchema> {}
+export const Trigger: Type.Obj<Trigger> = TriggerSchema as any;
 
 export const make = (props: Obj.MakeProps<typeof Trigger>) => Obj.make(Trigger, props);