@relayfx/sdk 0.1.0 → 0.2.1

package/dist/types/schema/child-orchestration-schema.d.ts

@@ -0,0 +1,393 @@
+import { Schema } from "effect";
+export declare const JoinPolicy: Schema.Union<readonly [Schema.TaggedStruct<"all", {}>, Schema.TaggedStruct<"first-success", {}>, Schema.TaggedStruct<"quorum", {
+    readonly count: Schema.Int;
+}>, Schema.TaggedStruct<"best-effort", {}>]>;
+export type JoinPolicy = typeof JoinPolicy.Type;
+export declare const FanOutChild: 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 address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly override: Schema.optionalKey<Schema.Struct<{
+        readonly instructions: Schema.optionalKey<Schema.String>;
+        readonly model: Schema.optionalKey<Schema.Struct<{
+            readonly provider: Schema.String;
+            readonly model: Schema.String;
+            readonly registration_key: Schema.optionalKey<Schema.String>;
+            readonly request_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 tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly workspace_policy: Schema.optionalKey<Schema.Struct<{
+            readonly mode: Schema.Literals<readonly ["share", "fork"]>;
+            readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["fail", "fresh"]>>;
+        }>>;
+        readonly output_schema_ref: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>;
+    readonly input: 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 metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface FanOutChild extends Schema.Schema.Type<typeof FanOutChild> {
+}
+export declare const FanOutDefinition: 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">;
+    };
+    readonly parent_execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly children: 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 address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+        };
+        readonly override: Schema.optionalKey<Schema.Struct<{
+            readonly instructions: Schema.optionalKey<Schema.String>;
+            readonly model: Schema.optionalKey<Schema.Struct<{
+                readonly provider: Schema.String;
+                readonly model: Schema.String;
+                readonly registration_key: Schema.optionalKey<Schema.String>;
+                readonly request_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 tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly workspace_policy: Schema.optionalKey<Schema.Struct<{
+                readonly mode: Schema.Literals<readonly ["share", "fork"]>;
+                readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["fail", "fresh"]>>;
+            }>>;
+            readonly output_schema_ref: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>>;
+        readonly input: 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 metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>;
+    readonly max_concurrency: Schema.Int;
+    readonly join: Schema.Union<readonly [Schema.TaggedStruct<"all", {}>, Schema.TaggedStruct<"first-success", {}>, Schema.TaggedStruct<"quorum", {
+        readonly count: Schema.Int;
+    }>, 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 FanOutDefinition extends Schema.Schema.Type<typeof FanOutDefinition> {
+}
+export declare const MemberState: Schema.Literals<readonly ["queued", "running", "completed", "failed", "cancelled"]>;
+export type MemberState = typeof MemberState.Type;
+export declare const AggregateState: Schema.Literals<readonly ["joining", "satisfied", "failed", "cancelled"]>;
+export type AggregateState = typeof AggregateState.Type;
+export declare const FanOutMember: 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>;
+}>;
+export interface FanOutMember extends Schema.Schema.Type<typeof FanOutMember> {
+}
+export declare const FanOutState: 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">;
+    };
+    readonly parent_execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly children: 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 address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+        };
+        readonly override: Schema.optionalKey<Schema.Struct<{
+            readonly instructions: Schema.optionalKey<Schema.String>;
+            readonly model: Schema.optionalKey<Schema.Struct<{
+                readonly provider: Schema.String;
+                readonly model: Schema.String;
+                readonly registration_key: Schema.optionalKey<Schema.String>;
+                readonly request_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 tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly workspace_policy: Schema.optionalKey<Schema.Struct<{
+                readonly mode: Schema.Literals<readonly ["share", "fork"]>;
+                readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["fail", "fresh"]>>;
+            }>>;
+            readonly output_schema_ref: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>>;
+        readonly input: 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 metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>;
+    readonly max_concurrency: Schema.Int;
+    readonly join: Schema.Union<readonly [Schema.TaggedStruct<"all", {}>, Schema.TaggedStruct<"first-success", {}>, Schema.TaggedStruct<"quorum", {
+        readonly count: Schema.Int;
+    }>, 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 FanOutState extends Schema.Schema.Type<typeof FanOutState> {
+}

package/dist/types/schema/execution-schema.d.ts

@@ -276,7 +276,7 @@ export declare const ChildRunAccepted: Schema.Struct<{
 }>;
 export interface ChildRunAccepted extends Schema.Schema.Type<typeof ChildRunAccepted> {
 }
-export declare const ExecutionEventType: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.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", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+export declare const ExecutionEventType: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.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"]>;
 export type ExecutionEventType = typeof ExecutionEventType.Type;
 export declare const ExecutionEvent: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Relay.EventId"> & {
@@ -288,7 +288,7 @@ export declare const ExecutionEvent: Schema.Struct<{
     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.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", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+    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.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<{

package/dist/types/schema/ids-schema.d.ts

@@ -16,6 +16,14 @@ export declare const AgentId: Schema.brand<Schema.String, "Relay.AgentId"> & {
     make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
 };
 export type AgentId = typeof AgentId.Type;
+export declare const WorkflowDefinitionId: Schema.brand<Schema.String, "Relay.WorkflowDefinitionId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkflowDefinitionId">;
+};
+export type WorkflowDefinitionId = typeof WorkflowDefinitionId.Type;
+export declare const WorkflowOperationId: Schema.brand<Schema.String, "Relay.WorkflowOperationId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
+};
+export type WorkflowOperationId = typeof WorkflowOperationId.Type;
 export declare const EntityKindName: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
     make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
 };
@@ -44,6 +52,10 @@ export declare const ChildExecutionId: Schema.brand<Schema.String, "Relay.ChildE
     make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
 };
 export type ChildExecutionId = typeof ChildExecutionId.Type;
+export declare const ChildFanOutId: Schema.brand<Schema.String, "Relay.ChildFanOutId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildFanOutId">;
+};
+export type ChildFanOutId = typeof ChildFanOutId.Type;
 export declare const MemorySubjectId: Schema.brand<Schema.String, "Relay.MemorySubjectId"> & {
     make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.MemorySubjectId">;
 };

package/dist/types/schema/index.d.ts

@@ -1,5 +1,6 @@
 export * as Address from "./address-schema";
 export * as Agent from "./agent-schema";
+export * as ChildOrchestration from "./child-orchestration-schema";
 export * as Content from "./content-schema";
 export * as Envelope from "./envelope-schema";
 export * as Entity from "./entity-schema";
@@ -12,5 +13,7 @@ export * as Shared from "./shared-schema";
 export * as Skill from "./skill-schema";
 export * as State from "./state-schema";
 export * as Tool from "./tool-schema";
+export * as Waits from "./wait-schema";
+export * as Workflow from "./workflow-schema";
 export * as Workspace from "./workspace-schema";
 export declare const schemaPackage = "./index";

package/dist/types/schema/wait-schema.d.ts

@@ -0,0 +1,98 @@
+import { Schema } from "effect";
+import { WaitMode } from "./envelope-schema";
+import { EnvelopeId, WaitId } from "./ids-schema";
+export declare const WaitKind: Schema.Literals<readonly ["permission", "tool_approval", "tool_placement", "child_join", "inbox", "reply", "timer", "external"]>;
+export type WaitKind = typeof WaitKind.Type;
+export declare const PermissionWait: Schema.Struct<{
+    readonly kind: Schema.Literal<"permission">;
+    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    };
+    readonly tool_call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+    };
+}>;
+export declare const ToolApprovalWait: Schema.Struct<{
+    readonly kind: Schema.Literal<"tool_approval">;
+    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    };
+    readonly tool_call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+    };
+}>;
+export declare const ToolPlacementWait: Schema.Struct<{
+    readonly kind: Schema.Literal<"tool_placement">;
+    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    };
+    readonly tool_call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+    };
+}>;
+export declare const ChildJoinWait: Schema.Struct<{
+    readonly kind: Schema.Literal<"child_join">;
+    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    };
+    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">;
+    };
+}>;
+export declare const InboxWait: Schema.Struct<{
+    readonly kind: Schema.Literal<"inbox">;
+    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    };
+    readonly tool_call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+    };
+}>;
+export declare const ReplyWait: Schema.Struct<{
+    readonly kind: Schema.Literal<"reply">;
+    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    };
+    readonly envelope_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.EnvelopeId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeId">;
+    }>;
+}>;
+export declare const TimerWait: Schema.Struct<{
+    readonly kind: Schema.Literal<"timer">;
+    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    };
+}>;
+export declare const ExternalWait: Schema.Struct<{
+    readonly kind: Schema.Literal<"external">;
+    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    };
+    readonly mode: Schema.Literals<readonly ["reply", "event", "until", "child"]>;
+}>;
+export type Classification = typeof PermissionWait.Type | typeof ToolApprovalWait.Type | typeof ToolPlacementWait.Type | typeof ChildJoinWait.Type | typeof InboxWait.Type | typeof ReplyWait.Type | typeof TimerWait.Type | typeof ExternalWait.Type;
+export declare const Classification: Schema.Schema<Classification>;
+export interface ClassifyInput {
+    readonly wait_id: WaitId;
+    readonly mode: WaitMode;
+    readonly envelope_id?: EnvelopeId;
+    readonly correlation_key?: string;
+}
+/**
+ * Derives a wait's public kind from its persisted fields.
+ *
+ * Relay mints every runtime-owned wait id inside a reserved namespace, so the
+ * namespace is the classification authority; envelope anchoring and mode only
+ * classify what no namespace claims. Reconnecting clients and replay consumers
+ * get the same answer Relay does without interpreting internal metadata.
+ */
+export declare const classify: (input: ClassifyInput) => Classification;
+export declare const Resolver: Schema.Literals<readonly ["resolve_permission", "resolve_tool_approval", "wake"]>;
+export type Resolver = typeof Resolver.Type;
+/**
+ * Names the one public resolver a classification admits. Runtime-owned kinds
+ * (child joins, inbox parks, tool placement) return undefined: deliveries,
+ * child completion, and tool completion resolve them — callers never do.
+ */
+export declare const resolverFor: (classification: Classification) => Resolver | undefined;
+export declare const externallyResolvable: (classification: Classification) => boolean;