@relayfx/sdk 0.0.1

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

@@ -0,0 +1,921 @@
+import { Schema } from "effect";
+export declare const StartExecutionInput: 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 root_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        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 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 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 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 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 metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>]>>>;
+    readonly event_sequence: Schema.Int;
+    readonly started_at: Schema.Int;
+    readonly completed_at: Schema.Int;
+    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    }>;
+    readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
+    readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly instructions: Schema.optionalKey<Schema.String>;
+        readonly model: 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.$Array<Schema.String>;
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly value: 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 child_run_presets: Schema.optionalKey<Schema.$Record<Schema.String, 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 output_schema_ref: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>;
+    readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    }>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface StartExecutionInput extends Schema.Schema.Type<typeof StartExecutionInput> {
+}
+export declare const StartExecutionResult: 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 status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface StartExecutionResult extends Schema.Schema.Type<typeof StartExecutionResult> {
+}
+export declare const StreamExecutionInput: 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 after_cursor: Schema.optionalKey<Schema.String>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+export interface StreamExecutionInput extends Schema.Schema.Type<typeof StreamExecutionInput> {
+}
+export declare const WaitTerminalState: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
+export type WaitTerminalState = typeof WaitTerminalState.Type;
+export declare const CancelExecutionInput: 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 cancelled_at: Schema.Int;
+    readonly reason: Schema.optionalKey<Schema.String>;
+}>;
+export interface CancelExecutionInput extends Schema.Schema.Type<typeof CancelExecutionInput> {
+}
+export declare const CancelExecutionAccepted: 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 status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+}>;
+export interface CancelExecutionAccepted extends Schema.Schema.Type<typeof CancelExecutionAccepted> {
+}
+export declare const WakeInput: Schema.Struct<{
+    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 state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
+    readonly signaled_at: Schema.Int;
+    readonly from: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    }>;
+    readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        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 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 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 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 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 metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>]>>>;
+    readonly correlation_key: Schema.optionalKey<Schema.String>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface WakeInput extends Schema.Schema.Type<typeof WakeInput> {
+}
+export declare const WakeAccepted: Schema.Struct<{
+    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 state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
+    readonly signaled_at: Schema.Int;
+}>;
+export interface WakeAccepted extends Schema.Schema.Type<typeof WakeAccepted> {
+}
+export declare const WaitState: Schema.Literals<readonly ["open", "resolved", "timed_out", "cancelled"]>;
+export type WaitState = typeof WaitState.Type;
+export declare const ListWaitsInput: Schema.Struct<{
+    readonly state: Schema.optionalKey<Schema.Literals<readonly ["open", "resolved", "timed_out", "cancelled"]>>;
+    readonly execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    }>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+export interface ListWaitsInput extends Schema.Schema.Type<typeof ListWaitsInput> {
+}
+export declare const WaitView: Schema.Struct<{
+    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 execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    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">;
+    }>;
+    readonly mode: Schema.Literals<readonly ["reply", "event", "until", "child"]>;
+    readonly correlation_key: Schema.optionalKey<Schema.String>;
+    readonly state: Schema.Literals<readonly ["open", "resolved", "timed_out", "cancelled"]>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly created_at: Schema.Int;
+    readonly resolved_at: Schema.optionalKey<Schema.Int>;
+}>;
+export interface WaitView extends Schema.Schema.Type<typeof WaitView> {
+}
+export declare const PendingToolApproval: Schema.Struct<{
+    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 execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    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">;
+    };
+    readonly tool_name: Schema.String;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly requested_at: Schema.Int;
+}>;
+export interface PendingToolApproval extends Schema.Schema.Type<typeof PendingToolApproval> {
+}
+export declare const ListPendingApprovalsInput: 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">;
+    };
+}>;
+export interface ListPendingApprovalsInput extends Schema.Schema.Type<typeof ListPendingApprovalsInput> {
+}
+export declare const PendingToolApprovalList: Schema.Struct<{
+    readonly approvals: Schema.$Array<Schema.Struct<{
+        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 execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+        };
+        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">;
+        };
+        readonly tool_name: Schema.String;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly requested_at: Schema.Int;
+    }>>;
+}>;
+export interface PendingToolApprovalList extends Schema.Schema.Type<typeof PendingToolApprovalList> {
+}
+export declare const ResolveToolApprovalInput: Schema.Struct<{
+    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 approved: Schema.Boolean;
+    readonly comment: Schema.optionalKey<Schema.String>;
+    readonly resolved_at: Schema.Int;
+}>;
+export interface ResolveToolApprovalInput extends Schema.Schema.Type<typeof ResolveToolApprovalInput> {
+}
+export declare const SubmitInboundEnvelopeInput: Schema.Struct<{
+    readonly envelope: Schema.Struct<{
+        readonly from: Schema.brand<Schema.String, "Relay.AddressId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+        };
+        readonly to: Schema.brand<Schema.String, "Relay.AddressId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+        };
+        readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+            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 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 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 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 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 metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>]>>;
+        readonly wait: Schema.optionalKey<Schema.Struct<{
+            readonly mode: Schema.Literals<readonly ["reply", "event", "until", "child"]>;
+            readonly timeout: Schema.optionalKey<Schema.String>;
+            readonly correlation_key: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>>;
+        readonly correlation_key: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>;
+    readonly wake: Schema.Struct<{
+        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 state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
+        readonly signaled_at: Schema.Int;
+        readonly from: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AddressId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+        }>;
+        readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+            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 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 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 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 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 metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>]>>>;
+        readonly correlation_key: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>;
+}>;
+export interface SubmitInboundEnvelopeInput extends Schema.Schema.Type<typeof SubmitInboundEnvelopeInput> {
+}
+export declare const SubmitInboundEnvelopeAccepted: Schema.Struct<{
+    readonly envelope: Schema.Struct<{
+        readonly envelope_id: Schema.brand<Schema.String, "Relay.EnvelopeId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeId">;
+        };
+        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 wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+        }>;
+    }>;
+    readonly wake: Schema.Struct<{
+        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 state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
+        readonly signaled_at: Schema.Int;
+    }>;
+}>;
+export interface SubmitInboundEnvelopeAccepted extends Schema.Schema.Type<typeof SubmitInboundEnvelopeAccepted> {
+}
+export declare const ClaimEnvelopeReadyInput: Schema.Struct<{
+    readonly route_type: Schema.Literals<readonly ["local-agent", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+    readonly route_key: Schema.optionalKey<Schema.String>;
+    readonly worker_id: Schema.String;
+    readonly now: Schema.Int;
+    readonly claim_expires_at: Schema.Int;
+}>;
+export interface ClaimEnvelopeReadyInput extends Schema.Schema.Type<typeof ClaimEnvelopeReadyInput> {
+}
+export declare const EnvelopeReadyLease: Schema.Struct<{
+    readonly ready: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Relay.EnvelopeReadyId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeReadyId">;
+        };
+        readonly envelope_id: Schema.brand<Schema.String, "Relay.EnvelopeId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeId">;
+        };
+        readonly route_key: Schema.String;
+        readonly available_at: Schema.Int;
+        readonly attempt: Schema.Int;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>;
+    readonly worker_id: Schema.String;
+    readonly claim_expires_at: Schema.Int;
+}>;
+export interface EnvelopeReadyLease extends Schema.Schema.Type<typeof EnvelopeReadyLease> {
+}
+export declare const AckEnvelopeReadyInput: Schema.Struct<{
+    readonly envelope_ready_id: Schema.brand<Schema.String, "Relay.EnvelopeReadyId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeReadyId">;
+    };
+    readonly worker_id: Schema.String;
+    readonly acknowledged_at: Schema.Int;
+}>;
+export interface AckEnvelopeReadyInput extends Schema.Schema.Type<typeof AckEnvelopeReadyInput> {
+}
+export declare const EnvelopeReadyAcked: Schema.Struct<{
+    readonly envelope_ready_id: Schema.brand<Schema.String, "Relay.EnvelopeReadyId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeReadyId">;
+    };
+    readonly state: Schema.Literal<"acknowledged">;
+    readonly acknowledged_at: Schema.Int;
+}>;
+export interface EnvelopeReadyAcked extends Schema.Schema.Type<typeof EnvelopeReadyAcked> {
+}
+export declare const ReleaseEnvelopeReadyInput: Schema.Struct<{
+    readonly envelope_ready_id: Schema.brand<Schema.String, "Relay.EnvelopeReadyId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeReadyId">;
+    };
+    readonly worker_id: Schema.String;
+    readonly next_available_at: Schema.Int;
+    readonly error: Schema.optionalKey<Schema.String>;
+}>;
+export interface ReleaseEnvelopeReadyInput extends Schema.Schema.Type<typeof ReleaseEnvelopeReadyInput> {
+}
+export declare const EnvelopeReadyReleased: Schema.Struct<{
+    readonly envelope_ready_id: Schema.brand<Schema.String, "Relay.EnvelopeReadyId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeReadyId">;
+    };
+    readonly state: Schema.Literal<"ready">;
+    readonly next_available_at: Schema.Int;
+}>;
+export interface EnvelopeReadyReleased extends Schema.Schema.Type<typeof EnvelopeReadyReleased> {
+}
+export declare const CreateScheduleInput: Schema.Struct<{
+    readonly schedule_id: Schema.brand<Schema.String, "Relay.ScheduleId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ScheduleId">;
+    };
+    readonly kind: Schema.Literals<readonly ["once", "cron"]>;
+    readonly target_kind: Schema.Literals<readonly ["start-execution", "wake-wait", "timeout-wait"]>;
+    readonly address_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    }>;
+    readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    }>;
+    readonly cron_expr: Schema.optionalKey<Schema.String>;
+    readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        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 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 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 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 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 metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>]>>>;
+    readonly next_run_at: Schema.Int;
+    readonly idempotency_key: Schema.optionalKey<Schema.String>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface CreateScheduleInput extends Schema.Schema.Type<typeof CreateScheduleInput> {
+}
+export declare const CreateScheduleResult: Schema.Struct<{
+    readonly schedule: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Relay.ScheduleId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ScheduleId">;
+        };
+        readonly kind: Schema.Literals<readonly ["once", "cron"]>;
+        readonly target_kind: Schema.Literals<readonly ["start-execution", "wake-wait", "timeout-wait"]>;
+        readonly address_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AddressId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+        }>;
+        readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+        }>;
+        readonly cron_expr: Schema.optionalKey<Schema.String>;
+        readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+            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 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 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 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 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 metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>]>>>;
+        readonly state: Schema.Literals<readonly ["active", "claimed", "completed", "cancelled", "failed"]>;
+        readonly next_run_at: Schema.Int;
+        readonly attempt: Schema.Int;
+        readonly last_error: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly created_at: Schema.Int;
+        readonly updated_at: Schema.Int;
+    }>;
+}>;
+export interface CreateScheduleResult extends Schema.Schema.Type<typeof CreateScheduleResult> {
+}
+export declare const CancelScheduleInput: Schema.Struct<{
+    readonly schedule_id: Schema.brand<Schema.String, "Relay.ScheduleId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ScheduleId">;
+    };
+    readonly cancelled_at: Schema.Int;
+}>;
+export interface CancelScheduleInput extends Schema.Schema.Type<typeof CancelScheduleInput> {
+}
+export declare const CancelScheduleResult: Schema.Struct<{
+    readonly schedule: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Relay.ScheduleId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ScheduleId">;
+        };
+        readonly kind: Schema.Literals<readonly ["once", "cron"]>;
+        readonly target_kind: Schema.Literals<readonly ["start-execution", "wake-wait", "timeout-wait"]>;
+        readonly address_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AddressId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+        }>;
+        readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+        }>;
+        readonly cron_expr: Schema.optionalKey<Schema.String>;
+        readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+            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 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 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 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 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 metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>]>>>;
+        readonly state: Schema.Literals<readonly ["active", "claimed", "completed", "cancelled", "failed"]>;
+        readonly next_run_at: Schema.Int;
+        readonly attempt: Schema.Int;
+        readonly last_error: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly created_at: Schema.Int;
+        readonly updated_at: Schema.Int;
+    }>;
+}>;
+export interface CancelScheduleResult extends Schema.Schema.Type<typeof CancelScheduleResult> {
+}
+export declare const ListSchedulesInput: Schema.Struct<{
+    readonly state: Schema.optionalKey<Schema.Literals<readonly ["active", "claimed", "completed", "cancelled", "failed"]>>;
+}>;
+export interface ListSchedulesInput extends Schema.Schema.Type<typeof ListSchedulesInput> {
+}
+export declare const ListSchedulesResult: Schema.Struct<{
+    readonly schedules: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Relay.ScheduleId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ScheduleId">;
+        };
+        readonly kind: Schema.Literals<readonly ["once", "cron"]>;
+        readonly target_kind: Schema.Literals<readonly ["start-execution", "wake-wait", "timeout-wait"]>;
+        readonly address_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AddressId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+        }>;
+        readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+        }>;
+        readonly cron_expr: Schema.optionalKey<Schema.String>;
+        readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+            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 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 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 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 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 metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>]>>>;
+        readonly state: Schema.Literals<readonly ["active", "claimed", "completed", "cancelled", "failed"]>;
+        readonly next_run_at: Schema.Int;
+        readonly attempt: Schema.Int;
+        readonly last_error: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly created_at: Schema.Int;
+        readonly updated_at: Schema.Int;
+    }>>;
+}>;
+export interface ListSchedulesResult extends Schema.Schema.Type<typeof ListSchedulesResult> {
+}
+export declare const ListExecutionsInput: Schema.Struct<{
+    readonly root_address_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    }>;
+    readonly status: Schema.optionalKey<Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+    readonly cursor: Schema.optionalKey<Schema.String>;
+}>;
+export interface ListExecutionsInput extends Schema.Schema.Type<typeof ListExecutionsInput> {
+}
+export declare const ConversationKind: Schema.Literals<readonly ["user-agent", "agent-agent"]>;
+export type ConversationKind = typeof ConversationKind.Type;
+export declare const ConversationSummary: 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 root_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+    readonly kind: Schema.Literals<readonly ["user-agent", "agent-agent"]>;
+    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    }>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly created_at: Schema.Int;
+    readonly updated_at: Schema.Int;
+}>;
+export interface ConversationSummary extends Schema.Schema.Type<typeof ConversationSummary> {
+}
+export declare const ListExecutionsResult: Schema.Struct<{
+    readonly records: Schema.$Array<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 root_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+        };
+        readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+        readonly kind: Schema.Literals<readonly ["user-agent", "agent-agent"]>;
+        readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+        }>;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly created_at: Schema.Int;
+        readonly updated_at: Schema.Int;
+    }>>;
+    readonly next_cursor: Schema.optionalKey<Schema.String>;
+}>;
+export interface ListExecutionsResult extends Schema.Schema.Type<typeof ListExecutionsResult> {
+}
+export declare const ReplayExecutionInput: 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 after_cursor: Schema.optionalKey<Schema.String>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+export interface ReplayExecutionInput extends Schema.Schema.Type<typeof ReplayExecutionInput> {
+}
+export declare const ReplayExecutionResult: 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.output.completed", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "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 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 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 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 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 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 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 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;
+    }>>;
+}>;
+export interface ReplayExecutionResult extends Schema.Schema.Type<typeof ReplayExecutionResult> {
+}
+export declare const RunnerSummary: Schema.Struct<{
+    readonly address: Schema.String;
+    readonly healthy: Schema.Boolean;
+    readonly last_heartbeat: Schema.Int;
+    readonly owned_shards: Schema.Int;
+}>;
+export interface RunnerSummary extends Schema.Schema.Type<typeof RunnerSummary> {
+}
+export declare const ListRunnersResult: Schema.Struct<{
+    readonly runners: Schema.$Array<Schema.Struct<{
+        readonly address: Schema.String;
+        readonly healthy: Schema.Boolean;
+        readonly last_heartbeat: Schema.Int;
+        readonly owned_shards: Schema.Int;
+    }>>;
+    readonly total_shards: Schema.Int;
+}>;
+export interface ListRunnersResult extends Schema.Schema.Type<typeof ListRunnersResult> {
+}
+export declare const RouteExecutionResult: 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 shard: Schema.String;
+    readonly runner_address: Schema.NullOr<Schema.String>;
+    readonly owned: Schema.Boolean;
+}>;
+export interface RouteExecutionResult extends Schema.Schema.Type<typeof RouteExecutionResult> {
+}