@relayfx/test 0.1.0

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

@@ -0,0 +1,347 @@
+import { Schema } from "effect";
+import { Definition } from "./agent-schema";
+export declare const ExecutionStatus: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+export type ExecutionStatus = typeof ExecutionStatus.Type;
+export declare const Execution: Schema.Struct<{
+    readonly 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 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 agent_revision: Schema.optionalKey<Schema.Int>;
+    readonly agent_snapshot: Schema.optionalKey<Schema.Codec<Definition, {
+        readonly name: string;
+        readonly permissions: readonly {
+            readonly name: string;
+            readonly value: Schema.Json;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+        }[];
+        readonly model: {
+            readonly provider: string;
+            readonly model: string;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+            readonly registration_key?: string;
+            readonly request_options?: {
+                readonly [x: string]: Schema.Json;
+            };
+        };
+        readonly tool_names: readonly string[];
+        readonly metadata?: {
+            readonly [x: string]: Schema.Json;
+        };
+        readonly instructions?: string;
+        readonly output_schema_ref?: string;
+        readonly skill_definition_ids?: readonly string[];
+        readonly permission_rules?: {
+            readonly rules: readonly {
+                readonly pattern: string;
+                readonly level: "allow" | "deny" | "ask";
+                readonly reason?: string;
+            }[];
+            readonly fallback?: "allow" | "deny" | "ask";
+        };
+        readonly turn_policy?: import("./agent-schema").TurnPolicySnapshot;
+        readonly max_tool_turns?: number;
+        readonly max_wait_turns?: number;
+        readonly token_budget?: number;
+        readonly child_run_presets?: {
+            readonly [x: string]: {
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly permissions?: readonly string[];
+                readonly model?: {
+                    readonly provider: string;
+                    readonly model: string;
+                    readonly metadata?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                    readonly registration_key?: string;
+                    readonly request_options?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                };
+                readonly instructions?: string;
+                readonly tool_names?: readonly string[];
+                readonly workspace_policy?: {
+                    readonly mode: "share" | "fork";
+                    readonly fallback?: "fail" | "fresh";
+                };
+                readonly output_schema_ref?: string;
+            };
+        };
+        readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
+            readonly name: Schema.String;
+            readonly preset_name: Schema.String;
+        }, "Encoded">[];
+    }, never, never>>;
+    readonly agent_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, 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 Execution extends Schema.Schema.Type<typeof Execution> {
+}
+export declare const ExecutionEventSequence: Schema.Int;
+export type ExecutionEventSequence = typeof ExecutionEventSequence.Type;
+export declare const ChildRunContext: 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.$Array<Schema.String>;
+    readonly permissions: Schema.$Array<Schema.String>;
+    readonly output_schema_ref: Schema.optionalKey<Schema.String>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface ChildRunContext extends Schema.Schema.Type<typeof ChildRunContext> {
+}
+export declare const ChildRunOverride: 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>>>;
+}>;
+export interface ChildRunOverride extends Schema.Schema.Type<typeof ChildRunOverride> {
+}
+export declare const ChildRunPreset: 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>>>;
+}>;
+export interface ChildRunPreset extends Schema.Schema.Type<typeof ChildRunPreset> {
+}
+export declare const SpawnChildRunInput: 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 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 address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly parent_context: 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.$Array<Schema.String>;
+        readonly permissions: Schema.$Array<Schema.String>;
+        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 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 preset_name: Schema.optionalKey<Schema.String>;
+    readonly instructions: Schema.optionalKey<Schema.String>;
+    readonly model: Schema.optionalKey<Schema.Struct<{
+        readonly provider: Schema.String;
+        readonly model: Schema.String;
+        readonly registration_key: Schema.optionalKey<Schema.String>;
+        readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>;
+    readonly tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly workspace_policy: Schema.optionalKey<Schema.Struct<{
+        readonly mode: Schema.Literals<readonly ["share", "fork"]>;
+        readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["fail", "fresh"]>>;
+    }>>;
+    readonly output_schema_ref: Schema.optionalKey<Schema.String>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"structured">;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly schema_ref: Schema.optionalKey<Schema.String>;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"blob-reference">;
+        readonly uri: Schema.String;
+        readonly media_type: Schema.String;
+        readonly filename: Schema.optionalKey<Schema.String>;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"artifact-reference">;
+        readonly artifact_id: Schema.String;
+        readonly media_type: Schema.optionalKey<Schema.String>;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-call">;
+        readonly call: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+            };
+            readonly name: Schema.String;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-result">;
+        readonly result: Schema.Struct<{
+            readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+            };
+            readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly error: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>]>>>;
+    readonly wait: Schema.optionalKey<Schema.Boolean>;
+    readonly event_sequence: Schema.optionalKey<Schema.Int>;
+    readonly created_at: Schema.optionalKey<Schema.Int>;
+}>;
+export interface SpawnChildRunInput extends Schema.Schema.Type<typeof SpawnChildRunInput> {
+}
+export declare const ChildRunAccepted: Schema.Struct<{
+    readonly child_execution_id: Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
+    };
+    readonly 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 ChildRunAccepted extends Schema.Schema.Type<typeof ChildRunAccepted> {
+}
+export declare const ExecutionEventType: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.output.completed", "model.usage.reported", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "entity.created", "entity.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+export type ExecutionEventType = typeof ExecutionEventType.Type;
+export declare const ExecutionEvent: 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 interface ExecutionEvent extends Schema.Schema.Type<typeof ExecutionEvent> {
+}

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

@@ -0,0 +1,94 @@
+import { Schema } from "effect";
+export declare const AddressId: Schema.brand<Schema.String, "Relay.AddressId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+};
+export type AddressId = typeof AddressId.Type;
+export declare const TenantId: Schema.brand<Schema.String, "Relay.TenantId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.TenantId">;
+};
+export type TenantId = typeof TenantId.Type;
+export declare const SystemTenantId: string & import("effect/Brand").Brand<"Relay.TenantId">;
+export declare const AddressBookEntryId: Schema.brand<Schema.String, "Relay.AddressBookEntryId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressBookEntryId">;
+};
+export type AddressBookEntryId = typeof AddressBookEntryId.Type;
+export declare const AgentId: Schema.brand<Schema.String, "Relay.AgentId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
+};
+export type AgentId = typeof AgentId.Type;
+export declare const EntityKindName: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+};
+export type EntityKindName = typeof EntityKindName.Type;
+export declare const EntityKey: Schema.brand<Schema.String, "Relay.EntityKey"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
+};
+export type EntityKey = typeof EntityKey.Type;
+export declare const SkillDefinitionId: Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
+};
+export type SkillDefinitionId = typeof SkillDefinitionId.Type;
+export declare const EnvelopeId: Schema.brand<Schema.String, "Relay.EnvelopeId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeId">;
+};
+export type EnvelopeId = typeof EnvelopeId.Type;
+export declare const EnvelopeReadyId: Schema.brand<Schema.String, "Relay.EnvelopeReadyId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeReadyId">;
+};
+export type EnvelopeReadyId = typeof EnvelopeReadyId.Type;
+export declare const ExecutionId: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+};
+export type ExecutionId = typeof ExecutionId.Type;
+export declare const ChildExecutionId: Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
+};
+export type ChildExecutionId = typeof ChildExecutionId.Type;
+export declare const MemorySubjectId: Schema.brand<Schema.String, "Relay.MemorySubjectId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.MemorySubjectId">;
+};
+export type MemorySubjectId = typeof MemorySubjectId.Type;
+export declare const SessionId: Schema.brand<Schema.String, "Relay.SessionId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
+};
+export type SessionId = typeof SessionId.Type;
+export declare const SessionEntryId: Schema.brand<Schema.String, "Relay.SessionEntryId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionEntryId">;
+};
+export type SessionEntryId = typeof SessionEntryId.Type;
+export declare const WorkspaceLeaseId: Schema.brand<Schema.String, "Relay.WorkspaceLeaseId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceLeaseId">;
+};
+export type WorkspaceLeaseId = typeof WorkspaceLeaseId.Type;
+export declare const WorkspaceSnapshotId: Schema.brand<Schema.String, "Relay.WorkspaceSnapshotId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceSnapshotId">;
+};
+export type WorkspaceSnapshotId = typeof WorkspaceSnapshotId.Type;
+export declare const WorkspaceRef: Schema.brand<Schema.String, "Relay.WorkspaceRef"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceRef">;
+};
+export type WorkspaceRef = typeof WorkspaceRef.Type;
+export declare const SnapshotRef: Schema.brand<Schema.String, "Relay.SnapshotRef"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SnapshotRef">;
+};
+export type SnapshotRef = typeof SnapshotRef.Type;
+export declare const ToolCallId: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+};
+export type ToolCallId = typeof ToolCallId.Type;
+export declare const ToolAttemptId: Schema.brand<Schema.String, "Relay.ToolAttemptId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolAttemptId">;
+};
+export type ToolAttemptId = typeof ToolAttemptId.Type;
+export declare const WaitId: Schema.brand<Schema.String, "Relay.WaitId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+};
+export type WaitId = typeof WaitId.Type;
+export declare const ScheduleId: Schema.brand<Schema.String, "Relay.ScheduleId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ScheduleId">;
+};
+export type ScheduleId = typeof ScheduleId.Type;
+export declare const EventId: Schema.brand<Schema.String, "Relay.EventId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EventId">;
+};
+export type EventId = typeof EventId.Type;

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

@@ -0,0 +1,81 @@
+import { Schema } from "effect";
+export declare const MessageSequence: Schema.Int;
+export type MessageSequence = typeof MessageSequence.Type;
+export declare const Message: 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 sequence: Schema.Int;
+    readonly from: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    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 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 reply_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 correlation_key: Schema.optionalKey<Schema.String>;
+    readonly idempotency_key: Schema.optionalKey<Schema.String>;
+    readonly drain_id: Schema.optionalKey<Schema.String>;
+    readonly consumed_at: Schema.optionalKey<Schema.Int>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly created_at: Schema.Int;
+}>;
+export interface Message extends Schema.Schema.Type<typeof Message> {
+}
+export declare const InboxPolicy: Schema.Struct<{
+    readonly drain: Schema.Literals<readonly ["all", "one"]>;
+    readonly max_batch: Schema.optionalKey<Schema.Int>;
+}>;
+export interface InboxPolicy extends Schema.Schema.Type<typeof InboxPolicy> {
+}

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

@@ -0,0 +1,16 @@
+export * as Address from "./address-schema";
+export * as Agent from "./agent-schema";
+export * as Content from "./content-schema";
+export * as Envelope from "./envelope-schema";
+export * as Entity from "./entity-schema";
+export * as Execution from "./execution-schema";
+export * as Ids from "./ids-schema";
+export * as Inbox from "./inbox-schema";
+export * as Presence from "./presence-schema";
+export * as Schedule from "./schedule-schema";
+export * as Shared from "./shared-schema";
+export * as Skill from "./skill-schema";
+export * as State from "./state-schema";
+export * as Tool from "./tool-schema";
+export * as Workspace from "./workspace-schema";
+export declare const schemaPackage = "./index";

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

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+export declare const Scope: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["execution", "session"]>;
+    readonly id: Schema.String;
+}>;
+export interface Scope extends Schema.Schema.Type<typeof Scope> {
+}
+export declare const Entry: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly connected_at: Schema.Int;
+}>;
+export interface Entry extends Schema.Schema.Type<typeof Entry> {
+}
+export declare const View: Schema.Struct<{
+    readonly scope: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["execution", "session"]>;
+        readonly id: Schema.String;
+    }>;
+    readonly entries: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly connected_at: Schema.Int;
+    }>>;
+    readonly observed_at: Schema.Int;
+}>;
+export interface View extends Schema.Schema.Type<typeof View> {
+}