@relayfx/sdk 0.0.50 → 0.1.0

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

@@ -153,6 +153,119 @@ export declare const StartExecutionResult: Schema.Struct<{
 }>;
 export interface StartExecutionResult extends Schema.Schema.Type<typeof StartExecutionResult> {
 }
+export declare const GetOrCreateEntityInput: Schema.Struct<{
+    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+    };
+    readonly key: Schema.brand<Schema.String, "Relay.EntityKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
+    };
+    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 created_at: Schema.Int;
+}>;
+export interface GetOrCreateEntityInput extends Schema.Schema.Type<typeof GetOrCreateEntityInput> {
+}
+export declare const GetEntityInput: Schema.Struct<{
+    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+    };
+    readonly key: Schema.brand<Schema.String, "Relay.EntityKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
+    };
+}>;
+export interface GetEntityInput extends Schema.Schema.Type<typeof GetEntityInput> {
+}
+export declare const DestroyEntityInput: Schema.Struct<{
+    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+    };
+    readonly key: Schema.brand<Schema.String, "Relay.EntityKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
+    };
+    readonly reason: Schema.optionalKey<Schema.String>;
+    readonly destroyed_at: Schema.Int;
+}>;
+export interface DestroyEntityInput extends Schema.Schema.Type<typeof DestroyEntityInput> {
+}
+export declare const ListEntitiesInput: Schema.Struct<{
+    readonly kind: Schema.optionalKey<Schema.brand<Schema.String, "Relay.EntityKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+    }>;
+    readonly after_kind: Schema.optionalKey<Schema.brand<Schema.String, "Relay.EntityKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+    }>;
+    readonly after_key: Schema.optionalKey<Schema.String>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+export interface ListEntitiesInput extends Schema.Schema.Type<typeof ListEntitiesInput> {
+}
+export declare const EntityInstance: Schema.Struct<{
+    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+    };
+    readonly key: Schema.brand<Schema.String, "Relay.EntityKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
+    };
+    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 execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly generation: Schema.Int;
+    readonly status: Schema.Literals<readonly ["active", "destroyed"]>;
+    readonly created_at: Schema.Int;
+    readonly destroyed_at: Schema.optionalKey<Schema.Int>;
+}>;
 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">;
@@ -162,8 +275,117 @@ export declare const StreamExecutionInput: Schema.Struct<{
 }>;
 export interface StreamExecutionInput extends Schema.Schema.Type<typeof StreamExecutionInput> {
 }
+export declare const GetEntityStateInput: 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 key: Schema.String;
+}>;
+export interface GetEntityStateInput extends Schema.Schema.Type<typeof GetEntityStateInput> {
+}
+export declare const PutEntityStateInput: 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 key: Schema.String;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly expected_version: Schema.optionalKey<Schema.Int>;
+    readonly idempotency_key: Schema.optionalKey<Schema.String>;
+    readonly updated_at: Schema.Int;
+}>;
+export interface PutEntityStateInput extends Schema.Schema.Type<typeof PutEntityStateInput> {
+}
+export declare const DeleteEntityStateInput: 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 key: Schema.String;
+    readonly expected_version: Schema.optionalKey<Schema.Int>;
+    readonly idempotency_key: Schema.optionalKey<Schema.String>;
+    readonly removed_at: Schema.Int;
+}>;
+export interface DeleteEntityStateInput extends Schema.Schema.Type<typeof DeleteEntityStateInput> {
+}
+export declare const ListEntityStateInput: 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 prefix: Schema.optionalKey<Schema.String>;
+    readonly after_key: Schema.optionalKey<Schema.String>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+export interface ListEntityStateInput extends Schema.Schema.Type<typeof ListEntityStateInput> {
+}
 export declare const WaitTerminalState: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
 export type WaitTerminalState = typeof WaitTerminalState.Type;
+export declare const AwaitWaitInput: 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">;
+    };
+}>;
+export interface AwaitWaitInput extends Schema.Schema.Type<typeof AwaitWaitInput> {
+}
+export declare const WaitOutcome: 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 content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"structured">;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly schema_ref: Schema.optionalKey<Schema.String>;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"blob-reference">;
+        readonly uri: Schema.String;
+        readonly media_type: Schema.String;
+        readonly filename: Schema.optionalKey<Schema.String>;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"artifact-reference">;
+        readonly artifact_id: Schema.String;
+        readonly media_type: Schema.optionalKey<Schema.String>;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-call">;
+        readonly call: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+            };
+            readonly name: Schema.String;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-result">;
+        readonly result: Schema.Struct<{
+            readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+            };
+            readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly error: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>]>>>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface WaitOutcome extends Schema.Schema.Type<typeof WaitOutcome> {
+}
 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">;
@@ -856,6 +1078,7 @@ export declare const SubmitInboundEnvelopeInput: Schema.Struct<{
             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 idempotency_key: Schema.optionalKey<Schema.String>;
         readonly wait: Schema.optionalKey<Schema.Struct<{
             readonly mode: Schema.Literals<readonly ["reply", "event", "until", "child"]>;
             readonly timeout: Schema.optionalKey<Schema.String>;
@@ -952,7 +1175,7 @@ export declare const SubmitInboundEnvelopeAccepted: Schema.Struct<{
 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_type: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
     readonly route_key: Schema.optionalKey<Schema.String>;
     readonly worker_id: Schema.String;
     readonly now: Schema.Int;
@@ -1328,6 +1551,128 @@ export declare const ListExecutionsInput: Schema.Struct<{
 }>;
 export interface ListExecutionsInput extends Schema.Schema.Type<typeof ListExecutionsInput> {
 }
+export declare const SubscribeTopicInput: Schema.Struct<{
+    readonly topic_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly subscriber_execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface SubscribeTopicInput extends Schema.Schema.Type<typeof SubscribeTopicInput> {
+}
+export declare const TopicSubscription: Schema.Struct<{
+    readonly topic_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly subscriber_execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly created_at: Schema.Int;
+}>;
+export interface TopicSubscription extends Schema.Schema.Type<typeof TopicSubscription> {
+}
+export declare const PublishTopicInput: Schema.Struct<{
+    readonly topic_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly from: 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 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 idempotency_key: Schema.optionalKey<Schema.String>;
+}>;
+export interface PublishTopicInput extends Schema.Schema.Type<typeof PublishTopicInput> {
+}
+export declare const TopicPublishAccepted: 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 subscriber_count: Schema.Int;
+}>;
+export interface TopicPublishAccepted extends Schema.Schema.Type<typeof TopicPublishAccepted> {
+}
+export declare const UnsubscribeTopicInput: Schema.Struct<{
+    readonly topic_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly subscriber_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 UnsubscribeTopicInput extends Schema.Schema.Type<typeof UnsubscribeTopicInput> {
+}
+export declare const ListTopicSubscriptionsInput: Schema.Struct<{
+    readonly topic_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 subscriber_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">;
+    }>;
+}>;
+export interface ListTopicSubscriptionsInput extends Schema.Schema.Type<typeof ListTopicSubscriptionsInput> {
+}
+export declare const ListInboxMessagesInput: 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 include_consumed: Schema.optionalKey<Schema.Boolean>;
+    readonly after_sequence: Schema.optionalKey<Schema.Int>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+export interface ListInboxMessagesInput extends Schema.Schema.Type<typeof ListInboxMessagesInput> {
+}
 export declare const ConversationKind: Schema.Literals<readonly ["user-agent", "agent-agent"]>;
 export type ConversationKind = typeof ConversationKind.Type;
 export declare const ConversationSummary: Schema.Struct<{
@@ -1351,6 +1696,178 @@ export declare const ConversationSummary: Schema.Struct<{
 }>;
 export interface ConversationSummary extends Schema.Schema.Type<typeof ConversationSummary> {
 }
+export declare const ExecutionCursor: 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>;
+}>;
+export interface ExecutionCursor extends Schema.Schema.Type<typeof ExecutionCursor> {
+}
+declare const EventLogCursorNotFound_base: Schema.Class<EventLogCursorNotFound, Schema.TaggedStruct<"EventLogCursorNotFound", {
+    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 cursor: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EventLogCursorNotFound extends EventLogCursorNotFound_base {
+}
+export declare const StreamSessionInput: Schema.Struct<{
+    readonly session_id: Schema.brand<Schema.String, "Relay.SessionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
+    };
+    readonly resume: Schema.optionalKey<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 after_cursor: Schema.optionalKey<Schema.String>;
+    }>>>;
+}>;
+export interface StreamSessionInput extends Schema.Schema.Type<typeof StreamSessionInput> {
+}
+export declare const SessionStreamItem: Schema.Union<readonly [Schema.TaggedStruct<"execution_joined", {
+    readonly execution: 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 session_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.SessionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
+        }>;
+        readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+        readonly kind: Schema.Literals<readonly ["user-agent", "agent-agent"]>;
+        readonly agent_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
+        }>;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly created_at: Schema.Int;
+        readonly updated_at: Schema.Int;
+    }>;
+}>, Schema.TaggedStruct<"execution_event", {
+    readonly event: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Relay.EventId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EventId">;
+        };
+        readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+        };
+        readonly child_execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
+        }>;
+        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.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 sequence: Schema.Int;
+        readonly cursor: Schema.String;
+        readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+            readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"structured">;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly schema_ref: Schema.optionalKey<Schema.String>;
+            readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"blob-reference">;
+            readonly uri: Schema.String;
+            readonly media_type: Schema.String;
+            readonly filename: Schema.optionalKey<Schema.String>;
+            readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"artifact-reference">;
+            readonly artifact_id: Schema.String;
+            readonly media_type: Schema.optionalKey<Schema.String>;
+            readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"tool-call">;
+            readonly call: Schema.Struct<{
+                readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+                };
+                readonly name: Schema.String;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>;
+            readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"tool-result">;
+            readonly result: Schema.Struct<{
+                readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+                };
+                readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly error: Schema.optionalKey<Schema.String>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>;
+            readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>]>>>;
+        readonly data: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly created_at: Schema.Int;
+    }>;
+}>]>;
+export type SessionStreamItem = typeof SessionStreamItem.Type;
+export declare const WatchExecutionsInput: 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 session_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.SessionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
+    }>;
+    readonly status: Schema.optionalKey<Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+export interface WatchExecutionsInput extends Schema.Schema.Type<typeof WatchExecutionsInput> {
+}
+export declare const ExecutionListChange: Schema.Union<readonly [Schema.TaggedStruct<"snapshot", {
+    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 session_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.SessionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
+        }>;
+        readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+        readonly kind: Schema.Literals<readonly ["user-agent", "agent-agent"]>;
+        readonly agent_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
+        }>;
+        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>;
+}>, Schema.TaggedStruct<"upsert", {
+    readonly record: 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 session_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.SessionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
+        }>;
+        readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+        readonly kind: Schema.Literals<readonly ["user-agent", "agent-agent"]>;
+        readonly agent_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
+        }>;
+        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 type ExecutionListChange = typeof ExecutionListChange.Type;
 export declare const ToolCallSummary: Schema.Struct<{
     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">;
@@ -1549,7 +2066,7 @@ export declare const ReplayExecutionResult: 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", "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", "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<{
@@ -1636,3 +2153,4 @@ export declare const RouteExecutionResult: Schema.Struct<{
 }>;
 export interface RouteExecutionResult extends Schema.Schema.Type<typeof RouteExecutionResult> {
 }
+export {};

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

@@ -0,0 +1,39 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+export declare const migrations: readonly [{
+    readonly id: 1;
+    readonly name: "baseline";
+    readonly file: "0001_baseline.sql";
+    readonly source: string;
+}, {
+    readonly id: 2;
+    readonly name: "durable_tool_placement";
+    readonly file: "0002_durable_tool_placement.sql";
+    readonly source: string;
+}, {
+    readonly id: 3;
+    readonly name: "durable_inbox";
+    readonly file: "0003_durable_inbox.sql";
+    readonly source: string;
+}, {
+    readonly id: 4;
+    readonly name: "execution_state";
+    readonly file: "0004_execution_state.sql";
+    readonly source: string;
+}, {
+    readonly id: 5;
+    readonly name: "durable_entities";
+    readonly file: "0005_durable_entities.sql";
+    readonly source: string;
+}, {
+    readonly id: 6;
+    readonly name: "ephemeral_presence";
+    readonly file: "0006_ephemeral_presence.sql";
+    readonly source: string;
+}, {
+    readonly id: 7;
+    readonly name: "topic_subscriptions";
+    readonly file: "0007_topic_subscriptions.sql";
+    readonly source: string;
+}];
+export declare const loader: Effect.Effect<(readonly [1 | 2 | 6 | 3 | 4 | 7 | 5, "baseline" | "durable_tool_placement" | "durable_inbox" | "execution_state" | "durable_entities" | "ephemeral_presence" | "topic_subscriptions", Effect.Effect<Effect.Effect<void, import("effect/unstable/sql/SqlError").SqlError, SqlClient>, never, never>])[], never, never>;

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

@@ -0,0 +1,5 @@
+import { type SqliteClientConfig } from "@effect/sql-sqlite-bun/SqliteClient";
+import { Layer } from "effect";
+export declare const clientLayer: (options: SqliteClientConfig) => Layer.Layer<import("effect/unstable/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-bun/SqliteClient").SqliteClient, never, never>;
+export declare const migrationsLayer: Layer.Layer<never, import("effect/unstable/sql/SqlError").SqlError | import("@effect/sql-sqlite-bun/SqliteMigrator").MigrationError, import("effect/unstable/sql/SqlClient").SqlClient>;
+export declare const layer: (options: SqliteClientConfig) => Layer.Layer<import("effect/unstable/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-bun/SqliteClient").SqliteClient, import("effect/unstable/sql/SqlError").SqlError | import("@effect/sql-sqlite-bun/SqliteMigrator").MigrationError, never>;