@relayfx/sdk 0.0.50 → 0.2.0

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

@@ -0,0 +1,40 @@
+import { Schema } from "effect";
+export declare const KindDefinition: 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 agent_id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
+    };
+    readonly inbox: Schema.optionalKey<Schema.Struct<{
+        readonly drain: Schema.Literals<readonly ["all", "one"]>;
+        readonly max_batch: Schema.optionalKey<Schema.Int>;
+    }>>;
+    readonly state_enabled: Schema.optionalKey<Schema.Boolean>;
+    readonly continue_as_new_after_turns: Schema.optionalKey<Schema.Int>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface KindDefinition extends Schema.Schema.Type<typeof KindDefinition> {
+}
+export declare const InstanceStatus: Schema.Literals<readonly ["active", "destroyed"]>;
+export type InstanceStatus = typeof InstanceStatus.Type;
+export declare const Instance: 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 interface Instance extends Schema.Schema.Type<typeof Instance> {
+}

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

@@ -139,6 +139,7 @@ export declare const SendInput: 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>;

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

@@ -276,7 +276,7 @@ export declare const ChildRunAccepted: Schema.Struct<{
 }>;
 export interface ChildRunAccepted extends Schema.Schema.Type<typeof ChildRunAccepted> {
 }
-export declare const ExecutionEventType: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.output.completed", "model.usage.reported", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+export declare const ExecutionEventType: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.output.completed", "model.usage.reported", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "entity.created", "entity.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
 export type ExecutionEventType = typeof ExecutionEventType.Type;
 export declare const ExecutionEvent: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Relay.EventId"> & {
@@ -288,7 +288,7 @@ export declare const ExecutionEvent: Schema.Struct<{
     readonly child_execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
     }>;
-    readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.output.completed", "model.usage.reported", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+    readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.output.completed", "model.usage.reported", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "entity.created", "entity.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
     readonly sequence: Schema.Int;
     readonly cursor: Schema.String;
     readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{

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

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

package/dist/types/schema/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

@@ -1,12 +1,19 @@
 export * as Address from "./address-schema";
 export * as Agent from "./agent-schema";
+export * as ChildOrchestration from "./child-orchestration-schema";
 export * as Content from "./content-schema";
 export * as Envelope from "./envelope-schema";
+export * as Entity from "./entity-schema";
 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 Waits from "./wait-schema";
+export * as Workflow from "./workflow-schema";
 export * as Workspace from "./workspace-schema";
 export declare const schemaPackage = "./index";

package/dist/types/schema/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> {
+}

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

@@ -0,0 +1,35 @@
+import { Schema } from "effect";
+export declare const StateKey: Schema.String;
+export type StateKey = typeof StateKey.Type;
+export declare const StateIdempotencyKey: Schema.String;
+export type StateIdempotencyKey = typeof StateIdempotencyKey.Type;
+export declare const StateVersion: Schema.Int;
+export type StateVersion = typeof StateVersion.Type;
+export declare const StateRecordView: 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 version: Schema.Int;
+    readonly created_at: Schema.Int;
+    readonly updated_at: Schema.Int;
+}>;
+export interface StateRecordView extends Schema.Schema.Type<typeof StateRecordView> {
+}
+export declare const StateUpdatedEventData: Schema.Union<readonly [Schema.Struct<{
+    readonly key: Schema.String;
+    readonly version: Schema.Int;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly key: Schema.String;
+    readonly version: Schema.Int;
+    readonly blob_ref: Schema.String;
+}>]>;
+export type StateUpdatedEventData = typeof StateUpdatedEventData.Type;
+export declare const StateDeletedEventData: Schema.Struct<{
+    readonly key: Schema.String;
+    readonly version: Schema.Int;
+}>;
+export interface StateDeletedEventData extends Schema.Schema.Type<typeof StateDeletedEventData> {
+}

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

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