@relayfx/sdk 0.2.15 → 0.3.0

package/dist/types/relay/operation.d.ts

@@ -68,29 +68,36 @@ export declare const StartExecutionInput: Schema.Struct<{
     readonly agent_revision: Schema.optionalKey<Schema.Int>;
     readonly agent_snapshot: Schema.optionalKey<Schema.Codec<Agent.Definition, {
         readonly name: string;
-        readonly permissions: readonly {
-            readonly name: string;
-            readonly value: Schema.Json;
-            readonly metadata?: {
-                readonly [x: string]: Schema.Json;
-            };
-        }[];
+        readonly instructions?: string;
         readonly model: {
             readonly provider: string;
             readonly model: string;
-            readonly metadata?: {
-                readonly [x: string]: Schema.Json;
-            };
             readonly registration_key?: string;
             readonly request_options?: {
                 readonly [x: string]: Schema.Json;
             };
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
         };
         readonly tool_names: readonly string[];
-        readonly metadata?: {
-            readonly [x: string]: Schema.Json;
+        readonly permissions: readonly {
+            readonly name: string;
+            readonly value: Schema.Json;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+        }[];
+        readonly skill_definition_ids?: readonly string[];
+        readonly permission_rules?: {
+            readonly rules: readonly {
+                readonly pattern: string;
+                readonly level: "allow" | "ask" | "deny";
+                readonly reason?: string;
+            }[];
+            readonly fallback?: "allow" | "ask" | "deny";
         };
-        readonly instructions?: string;
+        readonly turn_policy?: Agent.TurnPolicySnapshot;
         readonly compaction_policy?: {
             readonly context_window: number;
             readonly reserve_tokens: number;
@@ -98,47 +105,32 @@ export declare const StartExecutionInput: Schema.Struct<{
             readonly summary_model?: {
                 readonly provider: string;
                 readonly model: string;
-                readonly metadata?: {
-                    readonly [x: string]: Schema.Json;
-                };
                 readonly registration_key?: string;
                 readonly request_options?: {
                     readonly [x: string]: Schema.Json;
                 };
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
             };
         };
-        readonly output_schema_ref?: string;
-        readonly skill_definition_ids?: readonly string[];
-        readonly permission_rules?: {
-            readonly rules: readonly {
-                readonly pattern: string;
-                readonly level: "allow" | "deny" | "ask";
-                readonly reason?: string;
-            }[];
-            readonly fallback?: "allow" | "deny" | "ask";
-        };
-        readonly turn_policy?: Agent.TurnPolicySnapshot;
         readonly max_tool_turns?: number;
         readonly max_wait_turns?: number;
         readonly token_budget?: number;
         readonly child_run_presets?: {
             readonly [x: string]: {
-                readonly metadata?: {
-                    readonly [x: string]: Schema.Json;
-                };
-                readonly permissions?: readonly string[];
+                readonly instructions?: string;
                 readonly model?: {
                     readonly provider: string;
                     readonly model: string;
-                    readonly metadata?: {
-                        readonly [x: string]: Schema.Json;
-                    };
                     readonly registration_key?: string;
                     readonly request_options?: {
                         readonly [x: string]: Schema.Json;
                     };
+                    readonly metadata?: {
+                        readonly [x: string]: Schema.Json;
+                    };
                 };
-                readonly instructions?: string;
                 readonly compaction_policy?: {
                     readonly context_window: number;
                     readonly reserve_tokens: number;
@@ -146,27 +138,35 @@ export declare const StartExecutionInput: Schema.Struct<{
                     readonly summary_model?: {
                         readonly provider: string;
                         readonly model: string;
-                        readonly metadata?: {
-                            readonly [x: string]: Schema.Json;
-                        };
                         readonly registration_key?: string;
                         readonly request_options?: {
                             readonly [x: string]: Schema.Json;
                         };
+                        readonly metadata?: {
+                            readonly [x: string]: Schema.Json;
+                        };
                     };
                 };
                 readonly tool_names?: readonly string[];
+                readonly permissions?: readonly string[];
                 readonly workspace_policy?: {
-                    readonly mode: "share" | "fork";
+                    readonly mode: "fork" | "share";
                     readonly fallback?: "fail" | "fresh";
                 };
                 readonly output_schema_ref?: string;
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
             };
         };
         readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
             readonly name: Schema.String;
             readonly preset_name: Schema.String;
         }, "Encoded">[];
+        readonly output_schema_ref?: string;
+        readonly metadata?: {
+            readonly [x: string]: Schema.Json;
+        };
     }, never, never>>;
     readonly agent_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
     readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
@@ -1107,9 +1107,9 @@ export declare const SpawnChildRunInput: Schema.Struct<{
         readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     }>>;
     readonly compaction_policy: Schema.optionalKey<Schema.Struct<{
-        readonly context_window: Schema.Number;
-        readonly reserve_tokens: Schema.Number;
-        readonly keep_recent_tokens: Schema.Number;
+        readonly context_window: Schema.Finite;
+        readonly reserve_tokens: Schema.Finite;
+        readonly keep_recent_tokens: Schema.Finite;
         readonly summary_model: Schema.optionalKey<Schema.Struct<{
             readonly provider: Schema.String;
             readonly model: Schema.String;
@@ -1203,9 +1203,9 @@ export declare const CreateChildFanOutInput: Schema.Struct<{
                 readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
             }>>;
             readonly compaction_policy: Schema.optionalKey<Schema.Struct<{
-                readonly context_window: Schema.Number;
-                readonly reserve_tokens: Schema.Number;
-                readonly keep_recent_tokens: Schema.Number;
+                readonly context_window: Schema.Finite;
+                readonly reserve_tokens: Schema.Finite;
+                readonly keep_recent_tokens: Schema.Finite;
                 readonly summary_model: Schema.optionalKey<Schema.Struct<{
                     readonly provider: Schema.String;
                     readonly model: Schema.String;
@@ -1294,68 +1294,6 @@ export interface CancelChildFanOutInput extends Schema.Schema.Type<typeof Cancel
 }
 export declare const CancelChildFanOutResult: Schema.Struct<{
     readonly fan_out: Schema.Struct<{
-        readonly state: Schema.Literals<readonly ["joining", "satisfied", "failed", "cancelled"]>;
-        readonly members: Schema.$Array<Schema.Struct<{
-            readonly child_execution_id: Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
-                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
-            };
-            readonly ordinal: Schema.Int;
-            readonly state: Schema.Literals<readonly ["queued", "running", "completed", "failed", "cancelled"]>;
-            readonly output: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"text">;
-                readonly text: Schema.String;
-                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"structured">;
-                readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-                readonly schema_ref: Schema.optionalKey<Schema.String>;
-                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"blob-reference">;
-                readonly uri: Schema.String;
-                readonly media_type: Schema.String;
-                readonly filename: Schema.optionalKey<Schema.String>;
-                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"artifact-reference">;
-                readonly artifact_id: Schema.String;
-                readonly media_type: Schema.optionalKey<Schema.String>;
-                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"tool-call">;
-                readonly call: Schema.Struct<{
-                    readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-                        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-                    };
-                    readonly name: Schema.String;
-                    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-                    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-                }>;
-                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"tool-result">;
-                readonly result: Schema.Struct<{
-                    readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-                        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-                    };
-                    readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-                    readonly error: Schema.optionalKey<Schema.String>;
-                    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-                }>;
-                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-            }>]>>>;
-            readonly error: Schema.optionalKey<Schema.String>;
-            readonly completed_at: Schema.optionalKey<Schema.Int>;
-        }>>;
-        readonly satisfied_at: Schema.optionalKey<Schema.Int>;
-        readonly failed_at: Schema.optionalKey<Schema.Int>;
-        readonly cancelled_at: Schema.optionalKey<Schema.Int>;
         readonly fan_out_id: Schema.brand<Schema.String, "Relay.ChildFanOutId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildFanOutId">;
         };
@@ -1379,9 +1317,9 @@ export declare const CancelChildFanOutResult: Schema.Struct<{
                     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 }>>;
                 readonly compaction_policy: Schema.optionalKey<Schema.Struct<{
-                    readonly context_window: Schema.Number;
-                    readonly reserve_tokens: Schema.Number;
-                    readonly keep_recent_tokens: Schema.Number;
+                    readonly context_window: Schema.Finite;
+                    readonly reserve_tokens: Schema.Finite;
+                    readonly keep_recent_tokens: Schema.Finite;
                     readonly summary_model: Schema.optionalKey<Schema.Struct<{
                         readonly provider: Schema.String;
                         readonly model: Schema.String;
@@ -1456,19 +1394,6 @@ export declare const CancelChildFanOutResult: Schema.Struct<{
         }>, Schema.TaggedStruct<"best-effort", {}>]>;
         readonly created_at: Schema.Int;
         readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    }>;
-}>;
-export interface CancelChildFanOutResult extends Schema.Schema.Type<typeof CancelChildFanOutResult> {
-}
-export declare const InspectChildFanOutInput: Schema.Struct<{
-    readonly fan_out_id: Schema.brand<Schema.String, "Relay.ChildFanOutId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildFanOutId">;
-    };
-}>;
-export interface InspectChildFanOutInput extends Schema.Schema.Type<typeof InspectChildFanOutInput> {
-}
-export declare const InspectChildFanOutResult: Schema.Struct<{
-    readonly fan_out: Schema.NullOr<Schema.Struct<{
         readonly state: Schema.Literals<readonly ["joining", "satisfied", "failed", "cancelled"]>;
         readonly members: Schema.$Array<Schema.Struct<{
             readonly child_execution_id: Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
@@ -1531,6 +1456,19 @@ export declare const InspectChildFanOutResult: Schema.Struct<{
         readonly satisfied_at: Schema.optionalKey<Schema.Int>;
         readonly failed_at: Schema.optionalKey<Schema.Int>;
         readonly cancelled_at: Schema.optionalKey<Schema.Int>;
+    }>;
+}>;
+export interface CancelChildFanOutResult extends Schema.Schema.Type<typeof CancelChildFanOutResult> {
+}
+export declare const InspectChildFanOutInput: Schema.Struct<{
+    readonly fan_out_id: Schema.brand<Schema.String, "Relay.ChildFanOutId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildFanOutId">;
+    };
+}>;
+export interface InspectChildFanOutInput extends Schema.Schema.Type<typeof InspectChildFanOutInput> {
+}
+export declare const InspectChildFanOutResult: Schema.Struct<{
+    readonly fan_out: Schema.NullOr<Schema.Struct<{
         readonly fan_out_id: Schema.brand<Schema.String, "Relay.ChildFanOutId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildFanOutId">;
         };
@@ -1554,9 +1492,9 @@ export declare const InspectChildFanOutResult: Schema.Struct<{
                     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
                 }>>;
                 readonly compaction_policy: Schema.optionalKey<Schema.Struct<{
-                    readonly context_window: Schema.Number;
-                    readonly reserve_tokens: Schema.Number;
-                    readonly keep_recent_tokens: Schema.Number;
+                    readonly context_window: Schema.Finite;
+                    readonly reserve_tokens: Schema.Finite;
+                    readonly keep_recent_tokens: Schema.Finite;
                     readonly summary_model: Schema.optionalKey<Schema.Struct<{
                         readonly provider: Schema.String;
                         readonly model: Schema.String;
@@ -1631,6 +1569,68 @@ export declare const InspectChildFanOutResult: Schema.Struct<{
         }>, Schema.TaggedStruct<"best-effort", {}>]>;
         readonly created_at: Schema.Int;
         readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly state: Schema.Literals<readonly ["joining", "satisfied", "failed", "cancelled"]>;
+        readonly members: Schema.$Array<Schema.Struct<{
+            readonly child_execution_id: Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
+            };
+            readonly ordinal: Schema.Int;
+            readonly state: Schema.Literals<readonly ["queued", "running", "completed", "failed", "cancelled"]>;
+            readonly output: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"text">;
+                readonly text: Schema.String;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"structured">;
+                readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly schema_ref: Schema.optionalKey<Schema.String>;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"blob-reference">;
+                readonly uri: Schema.String;
+                readonly media_type: Schema.String;
+                readonly filename: Schema.optionalKey<Schema.String>;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"artifact-reference">;
+                readonly artifact_id: Schema.String;
+                readonly media_type: Schema.optionalKey<Schema.String>;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"tool-call">;
+                readonly call: Schema.Struct<{
+                    readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+                    };
+                    readonly name: Schema.String;
+                    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                }>;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"tool-result">;
+                readonly result: Schema.Struct<{
+                    readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+                    };
+                    readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly error: Schema.optionalKey<Schema.String>;
+                    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                }>;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>]>>>;
+            readonly error: Schema.optionalKey<Schema.String>;
+            readonly completed_at: Schema.optionalKey<Schema.Int>;
+        }>>;
+        readonly satisfied_at: Schema.optionalKey<Schema.Int>;
+        readonly failed_at: Schema.optionalKey<Schema.Int>;
+        readonly cancelled_at: Schema.optionalKey<Schema.Int>;
     }>>;
 }>;
 export interface InspectChildFanOutResult extends Schema.Schema.Type<typeof InspectChildFanOutResult> {
@@ -2761,6 +2761,91 @@ export declare const ReplayExecutionResult: Schema.Struct<{
 }>;
 export interface ReplayExecutionResult extends Schema.Schema.Type<typeof ReplayExecutionResult> {
 }
+export declare const ExecutionEventPageDirection: Schema.Literals<readonly ["forward", "backward"]>;
+export type ExecutionEventPageDirection = typeof ExecutionEventPageDirection.Type;
+export declare const PageExecutionEventsInput: Schema.Struct<{
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly direction: Schema.Literals<readonly ["forward", "backward"]>;
+    readonly after_cursor: Schema.optionalKey<Schema.String>;
+    readonly before_cursor: Schema.optionalKey<Schema.String>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+export interface PageExecutionEventsInput extends Schema.Schema.Type<typeof PageExecutionEventsInput> {
+}
+export declare const PageExecutionEventsResult: Schema.Struct<{
+    readonly events: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Relay.EventId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EventId">;
+        };
+        readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+        };
+        readonly child_execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
+        }>;
+        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "entity.created", "entity.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+        readonly sequence: Schema.Int;
+        readonly cursor: Schema.String;
+        readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+            readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"structured">;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly schema_ref: Schema.optionalKey<Schema.String>;
+            readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"blob-reference">;
+            readonly uri: Schema.String;
+            readonly media_type: Schema.String;
+            readonly filename: Schema.optionalKey<Schema.String>;
+            readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"artifact-reference">;
+            readonly artifact_id: Schema.String;
+            readonly media_type: Schema.optionalKey<Schema.String>;
+            readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"tool-call">;
+            readonly call: Schema.Struct<{
+                readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+                };
+                readonly name: Schema.String;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>;
+            readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"tool-result">;
+            readonly result: Schema.Struct<{
+                readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+                };
+                readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly error: Schema.optionalKey<Schema.String>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>;
+            readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>]>>>;
+        readonly data: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly created_at: Schema.Int;
+    }>>;
+    readonly has_more: Schema.Boolean;
+    readonly oldest_cursor: Schema.optionalKey<Schema.String>;
+    readonly newest_cursor: Schema.optionalKey<Schema.String>;
+}>;
+export interface PageExecutionEventsResult extends Schema.Schema.Type<typeof PageExecutionEventsResult> {
+}
 export declare const RunnerSummary: Schema.Struct<{
     readonly address: Schema.String;
     readonly healthy: Schema.Boolean;

package/dist/types/relay/postgres.d.ts

@@ -1,6 +1,6 @@
-import { Effect, type Layer } from "effect";
+import { Effect, Layer } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
-import type { DatabaseIdentity, DatabaseLayer, RuntimeConfigurationError, RuntimeMigrationError } from "./runtime";
+import { RuntimeMigrationError, type DatabaseIdentity, type DatabaseLayer, type RuntimeConfigurationError } from "./runtime";
 export interface PostgresRuntimeDatabaseOptions<E, R> {
     readonly clientLayer: Layer.Layer<SqlClient, E, R>;
     readonly databaseIdentity: DatabaseIdentity;

package/dist/types/relay/runtime-capability-policy.d.ts

@@ -9,11 +9,17 @@ export declare class RuntimeCapabilityUnavailable extends RuntimeCapabilityUnava
 export interface Interface {
     readonly admit: (capability: "fan-out" | "workflow-definition") => Effect.Effect<void, RuntimeCapabilityUnavailable>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/RuntimeCapabilityPolicy", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/runtime-capability-policy/Service", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: (role: "embedded" | "runner" | "client", capabilities: {
-    readonly fanOut: boolean;
-    readonly workflowDefinition: boolean;
-}) => Layer.Layer<Service, never, never>;
+export declare const layer: {
+    (capabilities: {
+        readonly fanOut: boolean;
+        readonly workflowDefinition: boolean;
+    }): (role: "embedded" | "runner" | "client") => Layer.Layer<Service>;
+    (role: "embedded" | "runner" | "client", capabilities: {
+        readonly fanOut: boolean;
+        readonly workflowDefinition: boolean;
+    }): Layer.Layer<Service>;
+};
 export {};

package/dist/types/relay/runtime-database.d.ts

@@ -16,6 +16,6 @@ export type Interface = {
     readonly notification: "pg-listen-notify" | "polling";
     readonly verifySchema: Effect.Effect<void, RuntimeMigrationError>;
 };
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/RuntimeDatabase", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/runtime-database/Service", Interface>;
 export declare class Service extends Service_base {
 }

package/dist/types/relay/runtime.d.ts

@@ -9,7 +9,7 @@ export { RuntimeCapabilityUnavailable } from "./runtime-capability-policy";
 export * as RuntimeDatabase from "./runtime-database";
 export declare const DatabaseIdentity: Schema.brand<Schema.NonEmptyString, "@relayfx/sdk/DatabaseIdentity">;
 export type DatabaseIdentity = typeof DatabaseIdentity.Type;
-export declare const makeDatabaseIdentity: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"@relayfx/sdk/DatabaseIdentity">;
+export declare const makeDatabaseIdentity: (input: unknown) => DatabaseIdentity;
 export declare const Dialect: Schema.Literals<readonly ["pg", "mysql", "sqlite"]>;
 export type Dialect = typeof Dialect.Type;
 export declare const DatabaseDialect: unique symbol;
@@ -144,7 +144,7 @@ export interface ReadinessStatus {
 export interface Interface {
     readonly readiness: Effect.Effect<ReadinessStatus, RuntimeReadinessError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/Runtime", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/runtime/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export interface ClusterHttpOptions {
@@ -189,9 +189,9 @@ export interface ClientOptions<DBE, DBR> {
 export type EmbeddedOutput = Service | ClientService;
 export type RunnerOutput = Service | ClientService;
 export type ClientOutput = Service | ClientService;
-export declare const layerEmbedded: <D extends Dialect, DBE, DBR, HostE, HostR, ChildE = never, ChildR = never, WorkflowE = never, WorkflowR = never, ToolE = never, ToolR = never>(options: EmbeddedHostOptions<HostE, HostR, ChildE, ChildR, WorkflowE, WorkflowR, ToolE, ToolR> & {
+export declare function layerEmbedded<D extends Dialect, DBE, DBR, HostE, HostR, ChildE = never, ChildR = never, WorkflowE = never, WorkflowR = never, ToolE = never, ToolR = never>(options: EmbeddedHostOptions<HostE, HostR, ChildE, ChildR, WorkflowE, WorkflowR, ToolE, ToolR> & {
     readonly databaseLayer: DatabaseLayer<D, DBE, DBR>;
-}) => Layer.Layer<EmbeddedOutput, AcquisitionError, DBR | HostR | ToolR | Exclude<ChildR, RunnerRuntime.Service | ClientRuntimeRequirements> | Exclude<WorkflowR, RunnerRuntime.Service | ChildFanOutRuntime.Service | ClientRuntimeRequirements>>;
+}): Layer.Layer<EmbeddedOutput, AcquisitionError, DBR | HostR | ToolR | Exclude<ChildR, RunnerRuntime.Service | ClientRuntimeRequirements> | Exclude<WorkflowR, RunnerRuntime.Service | ChildFanOutRuntime.Service | ClientRuntimeRequirements>>;
 export declare const layerRunner: <DBE, DBR, HostE, HostR, ToolE, ToolR>(options: Omit<RunnerOptions<DBE, DBR, HostE, HostR>, "toolRuntimeLayer"> & {
     readonly toolRuntimeLayer: Layer.Layer<ToolRuntime.Service, ToolE, ToolR>;
 }) => Layer.Layer<RunnerOutput, AcquisitionError, DBR | HostR | ToolR | HttpServer>;

package/dist/types/relay/sqlite-migrations.d.ts

@@ -51,4 +51,4 @@ export declare const migrations: readonly [{
     readonly file: "0010_workflow_runtime.sql";
     readonly source: string;
 }];
-export declare const loader: Effect.Effect<(readonly [1 | 2 | 6 | 3 | 4 | 7 | 5 | 8 | 9 | 10, "baseline" | "durable_tool_placement" | "durable_inbox" | "execution_state" | "durable_entities" | "ephemeral_presence" | "topic_subscriptions" | "child_fan_out" | "workflow_definitions" | "workflow_runtime", Effect.Effect<Effect.Effect<void, import("effect/unstable/sql/SqlError").SqlError, SqlClient>, never, never>])[], never, never>;
+export declare const loader: Effect.Effect<(readonly [1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10, "baseline" | "child_fan_out" | "durable_entities" | "durable_inbox" | "durable_tool_placement" | "ephemeral_presence" | "execution_state" | "topic_subscriptions" | "workflow_definitions" | "workflow_runtime", Effect.Effect<Effect.Effect<void, import("effect/unstable/sql/SqlError").SqlError, SqlClient>, never, never>])[], never, never>;

package/dist/types/relay/sqlite-runtime.d.ts

@@ -1,6 +1,5 @@
 import { type SqliteClientConfig } from "@effect/sql-sqlite-bun/SqliteClient";
 import { ChildFanOutRuntime, WorkflowDefinitionRuntime } from "../runtime/index";
-import { WorkflowDefinitionRepository } from "../store-sql/portable";
 import { Layer } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
 import { RuntimeConfigurationError, RuntimeMigrationError, RuntimeTopologyError, type DatabaseLayer } from "./runtime";
@@ -13,7 +12,13 @@ export interface SQLiteRuntimeDatabaseOptions {
     readonly transformQueryNames?: (name: string) => string;
 }
 export declare const runtimeDatabaseLayer: (options: SQLiteRuntimeDatabaseOptions) => DatabaseLayer<"sqlite", RuntimeConfigurationError | RuntimeTopologyError | RuntimeMigrationError>;
-export declare const migrationsLayer: Layer.Layer<never, import("effect/unstable/sql/SqlError").SqlError | import("@effect/sql-sqlite-bun/SqliteMigrator").MigrationError, SqlClient>;
-export declare const layer: (options: SqliteClientConfig) => Layer.Layer<SqlClient, import("effect/unstable/sql/SqlError").SqlError | import("@effect/sql-sqlite-bun/SqliteMigrator").MigrationError, never>;
-export declare const workflowLayer: <E, R>(options: SqliteClientConfig, handlersLayer: Layer.Layer<WorkflowDefinitionRuntime.HandlerService, E, R>) => Layer.Layer<SqlClient | WorkflowDefinitionRepository.Service | WorkflowDefinitionRuntime.HandlerService | WorkflowDefinitionRuntime.Service, unknown, Exclude<R, SqlClient | WorkflowDefinitionRepository.Service>>;
-export declare const childFanOutLayer: <E, R>(options: SqliteClientConfig, handlersLayer: Layer.Layer<ChildFanOutRuntime.HandlerService, E, R>) => Layer.Layer<ChildFanOutRuntime.Service, unknown, R>;
+export declare const migrationsLayer: Layer.Layer<never, import("@effect/sql-sqlite-bun/SqliteMigrator").MigrationError | import("effect/unstable/sql/SqlError").SqlError, SqlClient>;
+export declare const layer: (options: SqliteClientConfig) => Layer.Layer<SqlClient, import("@effect/sql-sqlite-bun/SqliteMigrator").MigrationError | import("effect/unstable/sql/SqlError").SqlError, never>;
+export declare const workflowLayer: {
+    <E, R>(handlersLayer: Layer.Layer<WorkflowDefinitionRuntime.HandlerService, E, R>): (options: SqliteClientConfig) => ReturnType<typeof workflowLayer<E, R>>;
+    <E, R>(options: SqliteClientConfig, handlersLayer: Layer.Layer<WorkflowDefinitionRuntime.HandlerService, E, R>): Layer.Layer<WorkflowDefinitionRuntime.Service, unknown, R>;
+};
+export declare const childFanOutLayer: {
+    <E, R>(handlersLayer: Layer.Layer<ChildFanOutRuntime.HandlerService, E, R>): (options: SqliteClientConfig) => Layer.Layer<ChildFanOutRuntime.Service, unknown, R>;
+    <E, R>(options: SqliteClientConfig, handlersLayer: Layer.Layer<ChildFanOutRuntime.HandlerService, E, R>): Layer.Layer<ChildFanOutRuntime.Service, unknown, R>;
+};

package/dist/types/relay/tool-worker.d.ts

@@ -1,19 +1,20 @@
 import { Shared, Tool } from "../schema/index";
 import { Duration, Effect } from "effect";
+import { Service as ClientService } from "./client";
 import type { ClientError } from "./client";
 import type { ToolWorkLease } from "./operation";
 export interface HandlerContext {
     readonly lease: ToolWorkLease;
     readonly idempotencyKey: string;
 }
-export type Handler = (input: Shared.JsonValue, context: HandlerContext) => Effect.Effect<Shared.JsonValue, unknown, any>;
-export interface Options {
+export type Handler<E = Error, R = never> = (input: Shared.JsonValue, context: HandlerContext) => Effect.Effect<Shared.JsonValue, E, R>;
+export interface Options<E = Error, R = never> {
     readonly queue: Tool.PlacementKey;
     readonly workerId: Tool.WorkerId;
     readonly leaseDuration: Duration.Input;
     readonly pollInterval?: Duration.Input | undefined;
-    readonly handlers: Readonly<Record<string, Handler>>;
+    readonly handlers: Readonly<Record<string, Handler<E, R>>>;
 }
-export declare const runOnce: (options: Options) => Effect.Effect<boolean, ClientError, any>;
-export declare const run: (options: Options) => Effect.Effect<never, ClientError, any>;
+export declare const runOnce: <E, R>(options: Options<E, R>) => Effect.Effect<boolean, ClientError, R | ClientService>;
+export declare const run: <E, R>(options: Options<E, R>) => Effect.Effect<never, ClientError, R | ClientService>;
 export type Error = ClientError;

package/dist/types/runtime/address/address-book-service.d.ts

@@ -59,15 +59,15 @@ export interface Interface {
     readonly resolve: (addressId: Ids.AddressId) => Effect.Effect<Route, AddressNotFound | AddressUnavailable | AddressDeferred | AddressBookServiceError>;
     readonly register: (addressId: Ids.AddressId, route: Route) => Effect.Effect<Address.RouteRegistered, AddressBookServiceError>;
     readonly get: (addressId: Ids.AddressId) => Effect.Effect<RouteRecord | undefined, AddressBookServiceError>;
-    readonly list: () => Effect.Effect<Address.RouteList, AddressBookServiceError>;
+    readonly list: Effect.Effect<Address.RouteList, AddressBookServiceError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/AddressBook", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/address/address-book-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layerFromRepository: Layer.Layer<Service, never, AddressBookRepository.Service>;
 export declare const memoryLayer: (entries?: Iterable<readonly [Ids.AddressId, Route]>) => Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const resolve: (addressId: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<Route, AddressNotFound | AddressUnavailable | AddressDeferred | AddressBookServiceError, Service>;
+export declare const resolve: (addressId: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<Route, AddressBookServiceError | AddressDeferred | AddressNotFound | AddressUnavailable, Service>;
 export declare const register: (addressId: string & import("effect/Brand").Brand<"Relay.AddressId">, route: Route) => Effect.Effect<Address.RouteRegistered, AddressBookServiceError, Service>;
 export declare const get: (addressId: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<RouteRecord | undefined, AddressBookServiceError, Service>;
 export declare const list: () => Effect.Effect<Address.RouteList, AddressBookServiceError, Service>;