@dxos/compute 0.9.1-main.c7dcc2e112 → 0.10.0

package/src/Process.ts

@@ -5,6 +5,8 @@
 // @import-as-namespace
 
 import type { Atom } from '@effect-atom/atom';
+import * as Rpc from '@effect/rpc/Rpc';
+import * as RpcGroup from '@effect/rpc/RpcGroup';
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import type * as Exit from 'effect/Exit';
@@ -13,8 +15,9 @@ import * as Schema from 'effect/Schema';
 import * as Scope from 'effect/Scope';
 import type * as Types from 'effect/Types';
 
+import { Annotation } from '@dxos/echo';
 import { assertArgument } from '@dxos/invariant';
-import { DXN, type URI } from '@dxos/keys';
+import { DXN, URI } from '@dxos/keys';
 import { log } from '@dxos/log';
 
 import * as Operation from './Operation';
@@ -40,7 +43,7 @@ export type ID = Schema.Schema.Type<typeof ID>;
  * - onAlarm -> called for processes scheduling alarms.
  * - onChildEvent -> called when child process produces output or exits.
  */
-export interface Callbacks<I, O, R> {
+export interface Callbacks<_Input, _Output, _Requirements, _Rpcs extends Rpc.Any> {
   /**
    * Called when the process is spawned.
    * Not called for processes that are resumed from a previously suspended state.
@@ -50,7 +53,7 @@ export interface Callbacks<I, O, R> {
    *
    * Note: This function should aim to complete in under 5 seconds to avoid exceeding limits in serverless environments.
    */
-  onSpawn(): Effect.Effect<void, never, R | BaseServices>;
+  onSpawn(): Effect.Effect<void, never, _Requirements | BaseServices>;
 
   /**
    * Called when there's input available to process.
@@ -62,21 +65,26 @@ export interface Callbacks<I, O, R> {
    *
    * Note: This function should aim to complete in under 5 seconds to avoid exceeding limits in serverless environments.
    */
-  onInput(input: I): Effect.Effect<void, never, R | BaseServices>;
+  onInput(input: _Input): Effect.Effect<void, never, _Requirements | BaseServices>;
 
   /**
    * Called when the process's alarm is triggered.
    *
    * @throws Throwing in the handler will terminate the process with an error.
    */
-  onAlarm(): Effect.Effect<void, never, R | BaseServices>;
+  onAlarm(): Effect.Effect<void, never, _Requirements | BaseServices>;
 
   /**
    * Called when the process's child process produces output or exits.
    *
    * This allows the parent process to hibernate while a long-running child process is running.
    */
-  onChildEvent(event: ChildEvent<unknown>): Effect.Effect<void, never, R | BaseServices>;
+  onChildEvent(event: ChildEvent<unknown>): Effect.Effect<void, never, _Requirements | BaseServices>;
+
+  /**
+   * Handlers for the RPCs provided by the process.
+   */
+  rpcHandlers: Context.Context<Rpc.ToHandler<_Rpcs>>;
 }
 
 /**
@@ -141,17 +149,36 @@ export interface Params {
   readonly name: string | null;
 
   /**
-   * URI of the target this process is assigned to.
-   */
-  readonly target: URI.URI | null;
-
-  /**
-   * User-facing notifications requested for this process's lifecycle phases.
-   * Surfaced on {@link Info} so a notification tracker can subscribe to the process monitor.
+   * User-defined annotations for the process.
+   * Can only be set when the process is spawned.
    */
-  readonly notify?: Operation.NotifyOptions;
+  readonly annotations: Annotation.Dictionary;
 }
 
+/**
+ * Attaches the process to a target object.
+ */
+export const TargetAnnotation = Annotation.make({
+  id: 'org.dxos.process.target',
+  schema: URI.Schema,
+});
+
+/**
+ * Notification descriptor for surfacing process lifecycle events to the user.
+ */
+export const NotifyAnnotation = Annotation.make({
+  id: 'org.dxos.process.notify',
+  schema: Operation.NotifyOptions,
+});
+
+/**
+ * Marks a process as the harness host for its conversation (discovery substrate).
+ */
+export const HarnessHostAnnotation = Annotation.make({
+  id: 'org.dxos.process.harnessHost',
+  schema: Schema.Boolean,
+});
+
 //
 // Executable.
 //
@@ -165,7 +192,12 @@ export type ProcessTypeId = typeof ProcessTypeId;
  * `create` is used to instantiate a new process.
  * Can store runtime state in scope of `create` function.
  */
-export interface Process<I, O, R> extends Process.Variance<I, O, R> {
+export interface Process<
+  _Input,
+  _Output,
+  _Requirements = never,
+  _Rpcs extends Rpc.Any = never,
+> extends Process.Variance<_Input, _Output, _Requirements, _Rpcs> {
   /**
    * Unique identifier for the executable in the reverse DNS format.
    */
@@ -178,25 +210,38 @@ export interface Process<I, O, R> extends Process.Variance<I, O, R> {
 
   readonly services: readonly Context.Tag<any, any>[];
 
+  // Runtime RPC group, stored as `any`. `RpcGroup`/`RpcClient` are invariant in their type
+  // argument (and `Callbacks.rpcHandlers` is contravariant in it), so referencing `_Rpcs` in the
+  // structural fields would block `Process<…, never>` from being assignable to `Process.Any`.
+  // The precise group is carried by the covariant `Variance` phantom and recovered at `spawn`.
+  // See design spec §4.4.
+  readonly rpcs: RpcGroup.RpcGroup<any>;
+
   /**
    * Create a new instance of the process.
    */
-  create(ctx: ProcessContext<I, O>): Effect.Effect<Callbacks<I, O, R>, never, R | BaseServices | Scope.Scope>;
+  create(
+    ctx: ProcessContext<_Input, _Output>,
+  ): Effect.Effect<Callbacks<_Input, _Output, _Requirements, any>, never, _Requirements | BaseServices | Scope.Scope>;
 }
 
 export const isProcess = (executable: unknown): executable is Process.Any =>
   typeof executable === 'object' && executable !== null && ProcessTypeId in executable;
 
 export namespace Process {
-  export interface Variance<I, O, R> {
+  export interface Variance<_Input, _Output, _Requirements, _Rpcs> {
     readonly [ProcessTypeId]: {
-      readonly _Input: Types.Contravariant<I>;
-      readonly _Output: Types.Covariant<O>;
-      readonly _Requirements: Types.Covariant<R>;
+      readonly _Input: Types.Contravariant<_Input>;
+      readonly _Output: Types.Covariant<_Output>;
+      readonly _Requirements: Types.Covariant<_Requirements>;
+
+      // Phantom-covariant: lets `never`-RPC processes stay assignable to `Process.Any` while
+      // `spawn` still recovers the precise group from this slot. See design spec §4.4.
+      readonly _Rpcs: Types.Covariant<_Rpcs>;
     };
   }
 
-  export type Any = Process<any, any, never>;
+  export type Any = Process<any, any, any, any>;
 }
 
 export interface MakeProcessOpts {
@@ -208,6 +253,7 @@ export interface MakeProcessOpts {
   readonly input: Schema.Schema.AnyNoContext;
   readonly output: Schema.Schema.AnyNoContext;
   readonly services: readonly Context.Tag<any, any>[];
+  readonly rpcs?: RpcGroup.RpcGroup<any>;
 }
 
 export const make = <const Opts extends Types.NoExcessProperties<MakeProcessOpts, Opts>>(
@@ -219,7 +265,8 @@ export const make = <const Opts extends Types.NoExcessProperties<MakeProcessOpts
       Callbacks<
         Schema.Schema.Type<Opts['input']>,
         Schema.Schema.Type<Opts['output']>,
-        Context.Tag.Identifier<NonNullable<Opts['services']>[number]>
+        Context.Tag.Identifier<NonNullable<Opts['services']>[number]>,
+        RpcGroup.Rpcs<Opts['rpcs']>
       >
     >,
     never,
@@ -228,12 +275,14 @@ export const make = <const Opts extends Types.NoExcessProperties<MakeProcessOpts
 ): Process<
   Schema.Schema.Type<Opts['input']>,
   Schema.Schema.Type<Opts['output']>,
-  Context.Tag.Identifier<NonNullable<Opts['services']>[number]>
+  Context.Tag.Identifier<NonNullable<Opts['services']>[number]>,
+  RpcGroup.Rpcs<Opts['rpcs']>
 > => {
   assertArgument(/^[a-z0-9]([a-z0-9.\-/]*[a-z0-9])?$/i.test(opts.key), 'key', 'Invalid key');
   return {
     [ProcessTypeId]: {} as any,
     ...opts,
+    rpcs: opts.rpcs ?? RpcGroup.make(),
     create: (ctx) =>
       create(ctx).pipe(
         Effect.map((partial) => ({
@@ -242,18 +291,39 @@ export const make = <const Opts extends Types.NoExcessProperties<MakeProcessOpts
           onAlarm: () => Effect.void,
           onChildEvent: () => Effect.void,
           ...partial,
+          rpcHandlers: sanitizeRpcs(opts.rpcs, partial.rpcHandlers),
         })),
       ),
   };
 };
 
+// Returns `Context.Context<any>`: the runtime handler bag is stored untyped because
+// `Callbacks.rpcHandlers` is contravariant in `_Rpcs` (see design spec §4.4); the precise
+// handler contract is enforced by `make`'s `create` parameter, not by this internal helper.
+const sanitizeRpcs = <Rpcs extends Rpc.Any>(
+  defined: RpcGroup.RpcGroup<Rpcs> | undefined,
+  provided: Context.Context<Rpc.ToHandler<Rpcs>> | undefined,
+): Context.Context<any> => {
+  // Handlers are required only when a non-empty RPC group is declared.
+  const needsRpcs = defined !== undefined && defined.requests.size > 0;
+  if (!needsRpcs) {
+    // `Context.empty()` is `Context<never>`; `Context`'s requirement parameter is contravariant,
+    // so the empty (no-handler) context needs widening to the untyped bag.
+    return provided ?? (Context.empty() as Context.Context<any>);
+  }
+  if (!provided) {
+    throw new TypeError('Process declared RPCs but did not provide any handlers');
+  }
+  return provided;
+};
+
 /**
  * Durable marker recording that an operation's input handler has begun executing.
  * Persisted before the handler runs so that, after an interruption (suspend/restart), a
  * re-delivered input can tell that the previous attempt was in-flight. Cleared automatically
  * when the process reaches a terminal state (the runtime clears the process's storage).
  */
-const OperationStartedKey = StorageService.key(Schema.parseJson(Schema.Boolean), 'operation/started').pipe(
+const OperationStartedCell = StorageService.cell(Schema.parseJson(Schema.Boolean), 'operation/started').pipe(
   StorageService.withDefault(() => false),
 );
 
@@ -281,13 +351,13 @@ export const fromOperation = <const Op extends Operation.Definition.Any>(
           onInput: (input: Operation.Definition.Input<Op>) =>
             Effect.gen(function* () {
               if (!idempotent) {
-                const started = yield* OperationStartedKey.get;
+                const started = yield* OperationStartedCell.get;
                 if (started) {
                   return yield* Effect.die(
                     new Error(`non-idempotent operation "${op.meta.key}" was interrupted; cannot retry safely`),
                   );
                 }
-                yield* OperationStartedKey.set(true);
+                yield* OperationStartedCell.set(true);
               }
 
               // Emit operation start event.

package/src/Runnable.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Operation from './Operation';
+
+// TODO(wittjosiah): Currently just Operation. Widen to a union (Operation | ComputeGraph | …) once the
+// dispatcher/EDGE can run non-Operation runnables as a Process.
+export type Runnable = Operation.PersistentOperation;
+export const Runnable = Operation.PersistentOperation;

package/src/Script.ts

@@ -6,27 +6,27 @@
 
 import * as Schema from 'effect/Schema';
 
-import { DXN, Annotation, Obj, Ref, Type } from '@dxos/echo';
+import { Annotation, DXN, Obj, Ref, Type } from '@dxos/echo';
 import { FormInputAnnotation } from '@dxos/echo/Annotation';
 import { Text } from '@dxos/schema';
 
 /**
  * Source script.
  */
-export const Script = Schema.Struct({
-  name: Schema.String.pipe(Schema.optional),
-  description: Schema.String.pipe(Schema.optional),
-  // 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: Ref.Ref(Text.Text).pipe(FormInputAnnotation.set(false)),
-}).pipe(
-  Annotation.LabelAnnotation.set(['name']),
-  Annotation.IconAnnotation.set({ icon: 'ph--code--regular', hue: 'sky' }),
-  Type.makeObject(DXN.make('org.dxos.type.script', '0.1.0')),
-);
+export class Script extends Type.makeObject<Script>(DXN.make('org.dxos.type.script', '0.1.0'))(
+  Schema.Struct({
+    name: Schema.String.pipe(Schema.optional),
+    description: Schema.String.pipe(Schema.optional),
+    // 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: Ref.Ref(Text.Text).pipe(FormInputAnnotation.set(false)),
+  }).pipe(
+    Annotation.LabelAnnotation.set(['name']),
+    Annotation.IconAnnotation.set({ icon: 'ph--code--regular', hue: 'sky' }),
+  ),
+) {}
 
-export type Script = Type.InstanceType<typeof Script>;
 type Props = Omit<Obj.MakeProps<typeof Script>, 'source'> & { source?: string };
 
 export const make = ({ source = '', ...props }: Props = {}): Script =>

package/src/ServiceResolver.ts

@@ -164,7 +164,7 @@ export const layerRequirements = <const Tags extends readonly Context.Tag<any, a
  * @example
  * ```ts
  * processManagerRuntime.runPromise(
- *   myEffect.pipe(Effect.provide(ServiceResolver.provide({ space }, Database.Service, Feed.FeedService))),
+ *   myEffect.pipe(Effect.provide(ServiceResolver.provide({ space }, Database.Service))),
  * );
  * ```
  */

package/src/Skill.ts

@@ -0,0 +1,218 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { ToolId } from '@dxos/ai';
+import { Annotation, Database, DXN, Filter, Obj, Ref, Registry, Type, URI } from '@dxos/echo';
+import { BaseError } from '@dxos/errors';
+// Text is referenced in the inferred type of Skill (via Template.Template → Ref.Ref(Text.Text));
+// the import lets TypeScript name it in the emitted .d.ts.
+// eslint-disable-next-line unused-imports/no-unused-imports
+import { type Text } from '@dxos/schema';
+
+import * as McpServer from './McpServer';
+import * as Operation from './Operation';
+import * as Template from './Template';
+import * as Trigger from './Trigger';
+
+/**
+ * Skill schema defines the structure for AI assistant skills.
+ * Skills contain instructions, tools, and artifacts that guide the AI's behavior.
+ * Skills may use tools to create and read artifacts, which are managed by the assistant.
+ *
+ * The registry `key` and `version` are stored in the object meta — access them via
+ * `Obj.getMeta(skill).key` and `Obj.getMeta(skill).version`.
+ */
+export class Skill extends Type.makeObject<Skill>(DXN.make('org.dxos.type.skill', '0.2.0'))(
+  Schema.Struct({
+    /**
+     * Human-readable name of the skill.
+     */
+    name: Schema.String.annotations({
+      description: 'Human-readable name of the skill',
+    }),
+
+    /**
+     * Description of the skill's purpose and functionality.
+     */
+    description: Schema.optional(Schema.String).annotations({
+      description: "Description of the skill's purpose and functionality",
+    }),
+
+    /**
+     * Instructions that guide the AI assistant's behavior and responses.
+     * These are system prompts or guidelines that the AI should follow.
+     */
+    instructions: Template.Template.annotations({
+      description: "Instructions that guide the AI assistant's behavior and responses",
+    }),
+
+    /**
+     * Array of tools that the AI assistant can use when this skill is active.
+     */
+    tools: Schema.Array(ToolId).annotations({
+      description: 'Array of tools that the AI assistant can use when this skill is active',
+    }),
+
+    /**
+     * Whether an agent is allowed to auto-enable this skill in a conversation.
+     */
+    agentCanEnable: Schema.optional(Schema.Boolean).annotations({
+      description: 'Whether an agent is allowed to auto-enable this skill in a conversation.',
+    }),
+
+    /**
+     * Array of MCP servers that the AI assistant can use when this skill is active.
+     */
+    mcpServers: Schema.optional(Schema.Array(McpServer.McpServer)),
+
+    /**
+     * Hooks triggered automatically at certain points in the agent's lifecycle.
+     */
+    hooks: Schema.optional(Schema.Array(Schema.suspend(() => Hook))),
+  }).pipe(
+    Annotation.LabelAnnotation.set(['name']),
+    Annotation.IconAnnotation.set({ icon: 'ph--blueprint--regular', hue: 'sky' }),
+  ),
+) {}
+
+/**
+ * Controls when the hook is triggered.
+ */
+export const HookSpec = Schema.Union(
+  /**
+   * Triggered when the agent is about to start a request.
+   * A request is a series of agent/tool turns that the model drives.
+   */
+  Schema.TaggedStruct('begin-request', {}),
+  /**
+   * Triggered when the agent has completed a request.
+   * A request is a series of agent/tool turns that the model drives.
+   */
+  Schema.TaggedStruct('end-request', {}),
+);
+
+/**
+ * Allows hooking into the agent's lifecycle.
+ * NOTE: Intentionally similar to Trigger, perhaps we should merge them.
+ */
+export const Hook = Schema.Struct({
+  /**
+   * What to do when the hook is triggered.
+   *
+   * Can be a Ref to a PersistentOperation.
+   */
+  function: Schema.optional(Ref.Ref(Obj.Unknown).annotations({ title: 'Function' })),
+
+  /**
+   * Controls when the hook is triggered.
+   */
+  spec: HookSpec,
+
+  /**
+   * Passed as the input data to the function.
+   * Must match the function's input schema.
+   */
+  input: Trigger.InputTemplate.pipe(Annotation.FormInputAnnotation.set(false), Schema.optional),
+});
+
+/**
+ * Create a new Skill.
+ * The `key` (and optional `version`) are stored in the object meta.
+ * `key` must be a valid DXN name (e.g. `org.dxos.skill.mySkill`).
+ */
+export const make: {
+  <T extends string>(
+    props: {
+      key: [DXN.Name<T>] extends [never] ? `Invalid DXN name "${T}": final segment must be camelCase (no hyphens)` : T;
+      version?: string;
+      name: string;
+    } & Partial<Skill>,
+  ): Skill;
+} = ({ key, version, tools = [], instructions = Template.make(), ...props }) =>
+  Obj.make(Skill, {
+    [Obj.Meta]: { key, version },
+    tools,
+    instructions,
+    ...props,
+  });
+
+/**
+ * Get the registry key for a skill.
+ */
+export const getKey = (skill: Skill): string => {
+  const key = Obj.getMeta(skill).key;
+  if (key === undefined) {
+    throw new Error('Skill is missing the meta key.');
+  }
+  return key;
+};
+
+/**
+ * Get the registry version for a skill, if any.
+ */
+export const getVersion = (skill: Skill): string | undefined => Obj.getMeta(skill).version;
+
+/**
+ * Util to create tool definitions for a skill.
+ */
+export const toolDefinitions = ({
+  tools = [],
+  operations = [],
+}: {
+  tools?: string[];
+  operations?: Operation.Definition.Any[];
+}) => [...operations.map((op) => ToolId.make(DXN.getName(op.meta.key))), ...tools.map((tool) => ToolId.make(tool))];
+
+/**
+ * Factory for the skills.
+ */
+export type Definition = {
+  key: DXN.Name<string>;
+  make: () => Skill;
+};
+
+/**
+ * Returns the canonical URI used to reference this skill in the registry.
+ * Use this URI with `Ref.fromURI` to bind a skill without cloning it to the DB.
+ *
+ * TODO(wittjosiah): Should use Obj.getURI instead once it supports options to prefer meta key over EID.
+ */
+export const registryURI = (key: DXN.Name<string>): URI.URI => (DXN.tryMake(`dxn:${key}`) ?? URI.make(key)) as URI.URI;
+
+/**
+ * Resolves a skill from the registry by its meta key.
+ * Does not check the local database for the skill.
+ */
+export const resolve = (key: string): Effect.Effect<Skill, NotFoundError, Registry.Service> =>
+  Effect.gen(function* () {
+    const results = yield* Registry.runQuery(Filter.and(Filter.type(Skill), Filter.key(key)));
+    const skill = results[0];
+    if (!skill) {
+      return yield* Effect.fail(new NotFoundError({ context: { key } }));
+    }
+    return skill;
+  });
+
+/**
+ * Upserts a skill into the database.
+ * If the skill already exists in the database, the local (possibly forked) copy is returned as-is.
+ * Otherwise, a fresh copy is cloned from the registry and added.
+ * @deprecated Since we're using a registry we no longer need to store skills in the database.
+ */
+// TODO(dmaretskyi): Remove.
+export const upsert = (key: string): Effect.Effect<Skill, NotFoundError, Registry.Service | Database.Service> =>
+  Effect.gen(function* () {
+    const local = yield* Database.query(Filter.and(Filter.type(Skill), Filter.key(key))).run;
+    if (local.length > 0) {
+      return local[0];
+    }
+    return yield* Database.add(Obj.clone(yield* resolve(key), { deep: 'all' }));
+  });
+
+export class NotFoundError extends BaseError.extend('SkillNotFound', 'Skill not found') {}

package/src/StorageService.ts

@@ -48,9 +48,9 @@ export const list = Effect.serviceFunctionEffect(StorageService, (_) => _.list);
 export const clear = Effect.serviceFunctionEffect(StorageService, (_) => _.clear);
 
 /**
- * Typed key in a storage service.
+ * Typed cell in a storage service.
  */
-export interface Key<T> extends Pipeable.Pipeable {
+export interface Cell<T> extends Pipeable.Pipeable {
   readonly key: string;
 
   get: Effect.Effect<Option.Option<T>, never, StorageService>;
@@ -59,9 +59,12 @@ export interface Key<T> extends Pipeable.Pipeable {
 }
 
 /**
- * Create a typed key in a storage service.
+ * Create a typed cell in a storage service.
  */
-export const key = <S extends Schema.Schema<any, string, any>>(schema: S, key: string): Key<Schema.Schema.Type<S>> => {
+export const cell = <S extends Schema.Schema<any, string, any>>(
+  schema: S,
+  key: string,
+): Cell<Schema.Schema.Type<S>> => {
   return {
     key,
     get: get(schema, key),
@@ -74,9 +77,9 @@ export const key = <S extends Schema.Schema<any, string, any>>(schema: S, key: s
 };
 
 /**
- * Typed key in a storage service with a default value.
+ * Typed cell in a storage service with a default value.
  */
-export interface KeyWithDefault<T, U> extends Pipeable.Pipeable {
+export interface CellWithDefault<T, U> extends Pipeable.Pipeable {
   readonly key: string;
   get: Effect.Effect<T | U, never, StorageService>;
   set(value: U): Effect.Effect<void, never, StorageService>;
@@ -84,16 +87,16 @@ export interface KeyWithDefault<T, U> extends Pipeable.Pipeable {
 }
 
 /**
- * Assign a default value to a key if it is not present.
+ * Assign a default value to a cell if it is not present.
  */
 export const withDefault =
   <T>(getDefault: () => NoInfer<T>) =>
-  (key: Key<T>): KeyWithDefault<T, T> => {
+  (cell: Cell<T>): CellWithDefault<T, T> => {
     return {
-      key: key.key,
-      get: key.get.pipe(Effect.map(Option.getOrElse(() => getDefault()))),
-      set: (value) => key.set(value),
-      delete: () => key.delete(),
+      key: cell.key,
+      get: cell.get.pipe(Effect.map(Option.getOrElse(() => getDefault()))),
+      set: (value) => cell.set(value),
+      delete: () => cell.delete(),
       pipe(...args: any) {
         return Pipeable.pipeArguments(this, arguments);
       },

package/src/Template.ts

@@ -63,6 +63,7 @@ export const Template = Schema.Struct({
 });
 
 export type Template = Schema.Schema.Type<typeof Template>;
+
 export type MakeProps = Partial<{ id: string; source: string; inputs: Input[] }>;
 
 export const make = ({ id, source, inputs = [] }: MakeProps = {}): Template => ({
@@ -104,9 +105,9 @@ export const processTemplate = (
             if (results.length === 0) {
               return yield* Effect.fail(new FunctionNotFoundError(input.operation));
             }
-            const fn = Operation.deserialize(results[0]);
 
             // NOTE: Operations referenced by template inputs must accept void input — see `Input.operation`.
+            const fn = Operation.deserialize(results[0]);
             const result = yield* Operation.invoke(fn, undefined as any).pipe(Effect.orDie);
             return [input.name, result] as const;
           }

package/src/Trace.ts

@@ -9,9 +9,11 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import * as Schema from 'effect/Schema';
 
-import { DXN, Annotation, Obj, Type } from '@dxos/echo';
+import { Annotation, DXN, Obj, Ref, Type } from '@dxos/echo';
 import { log } from '@dxos/log';
 
+import * as Trigger from './Trigger';
+
 /**
  * Writes ephemeral or persistent events to the trace.
  * Exposed to processes and operations to record events to the trace.
@@ -110,14 +112,14 @@ export const Meta = Schema.Struct({
   space: Schema.optional(Schema.String),
 
   /**
-   * ID of the conversation feed object if present.
+   * Ref to the conversation feed object if present.
    */
-  conversationId: Schema.optional(Obj.ID),
+  conversation: Ref.Ref(Obj.Unknown).pipe(Schema.optional),
 
   /**
-   * ID of the trigger object if invocation resulted from a trigger.
+   * Ref to the trigger object if invocation resulted from a trigger.
    */
-  triggerId: Schema.optional(Obj.ID),
+  trigger: Ref.Ref(Trigger.Trigger).pipe(Schema.optional),
 
   /**
    * ID of the tool call that created the current process.
@@ -148,12 +150,12 @@ export const MessageData = Schema.Struct({
   events: Schema.Array(Event),
 });
 export type MessageData = Schema.Schema.Type<typeof MessageData>;
-export const Message = MessageData.pipe(
-  Annotation.IconAnnotation.set({ icon: 'ph--note--regular', hue: 'rose' }),
-  Annotation.HiddenAnnotation.set(true),
-  Type.makeObject(DXN.make('org.dxos.type.traceMessage', '0.1.0')),
-);
-export type Message = Type.InstanceType<typeof Message>;
+export class Message extends Type.makeObject<Message>(DXN.make('org.dxos.type.traceMessage', '0.1.0'))(
+  MessageData.pipe(
+    Annotation.IconAnnotation.set({ icon: 'ph--note--regular', hue: 'rose' }),
+    Annotation.HiddenAnnotation.set(true),
+  ),
+) {}
 /**
  * Flattened representation of a signle event in a trace message.
  * Events are stored in batched messages for efficiency, but flat representation is more convenient for consumption.