@relayfx/sdk 0.0.50 → 0.2.0

package/dist/types/relay/adapter-outbox.d.ts

@@ -1,11 +1,11 @@
 import { Context, Effect, Layer } from "effect";
-import { ClientError, Service as ClientService } from "./client";
+import { ClientError, Service as ClientService, WaitKindMismatch } from "./client";
 import { AckEnvelopeReadyInput, ClaimEnvelopeReadyInput, EnvelopeReadyAcked, EnvelopeReadyLease, EnvelopeReadyReleased, ReleaseEnvelopeReadyInput, SubmitInboundEnvelopeAccepted, SubmitInboundEnvelopeInput } from "./operation";
 export interface Interface {
     readonly claim: (input: ClaimEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyLease | null, ClientError>;
     readonly ack: (input: AckEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyAcked, ClientError>;
     readonly release: (input: ReleaseEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyReleased, ClientError>;
-    readonly submitInbound: (input: SubmitInboundEnvelopeInput) => Effect.Effect<SubmitInboundEnvelopeAccepted, ClientError>;
+    readonly submitInbound: (input: SubmitInboundEnvelopeInput) => Effect.Effect<SubmitInboundEnvelopeAccepted, WaitKindMismatch | ClientError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/AdapterOutbox", Interface>;
 export declare class Service extends Service_base {
@@ -15,5 +15,5 @@ export declare const testLayer: (implementation: Interface) => Layer.Layer<Servi
 export declare const claim: (input: ClaimEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyLease | null, ClientError, Service>;
 export declare const ack: (input: AckEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyAcked, ClientError, Service>;
 export declare const release: (input: ReleaseEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyReleased, ClientError, Service>;
-export declare const submitInbound: (input: SubmitInboundEnvelopeInput) => Effect.Effect<SubmitInboundEnvelopeAccepted, ClientError, Service>;
+export declare const submitInbound: (input: SubmitInboundEnvelopeInput) => Effect.Effect<SubmitInboundEnvelopeAccepted, ClientError | WaitKindMismatch, Service>;
 export {};

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

@@ -1,10 +1,16 @@
-import { AddressBook, AgentRegistry, EventLog, ExecutionService, SkillRegistry, ToolTransitionCoordinator, WaitService } from "../runtime/index";
+import { AddressBook, AgentRegistry, EventLog, EntityInstanceService, EntityRegistry, ExecutionWatch, ExecutionState, ExecutionService, EnvelopeService, PresenceService, SessionStream, SkillRegistry, ToolTransitionCoordinator, TopicService, WaitService } from "../runtime/index";
 import type { Agent as BatonAgent } from "@batonfx/core";
-import { Address, Agent, Content, Envelope, Execution, Ids, Shared, Skill, Tool } from "../schema/index";
-import { ChildExecutionRepository, ClusterRegistryRepository, EnvelopeRepository, ExecutionRepository, ScheduleRepository, SessionRepository, SteeringRepository, ToolCallRepository } from "../store-sql/index";
+import { Address, Agent, ChildOrchestration, Content, Entity, Envelope, Execution, Ids, Inbox, Presence, Shared, Skill, State, Tool, Workflow } from "../schema/index";
+import { ChildExecutionRepository, ChildFanOutRepository, ClusterRegistryRepository, EnvelopeRepository, ExecutionRepository, InboxRepository, ScheduleRepository, SessionRepository, SteeringRepository, ToolCallRepository, WorkflowDefinitionRepository } from "../store-sql/portable";
 import { Context, Effect, Layer, Schema, Stream } from "effect";
 import { Sharding, ShardingConfig } from "effect/unstable/cluster";
-import type { AckEnvelopeReadyInput, CancelExecutionAccepted, CancelExecutionInput, CancelScheduleInput, CancelScheduleResult, ClaimEnvelopeReadyInput, CreateScheduleInput, CreateScheduleResult, EnvelopeReadyAcked, EnvelopeReadyLease, EnvelopeReadyReleased, ExecutionInspection, GetSessionInput, GetSessionResult, ListExecutionsInput, ListExecutionsResult, ListPendingApprovalsInput, ListRunnersResult, ListSchedulesInput, ListSchedulesResult, ListSessionsInput, ListSessionsResult, ListWaitsInput, PendingToolApprovalList, PendingToolCallList, ListPendingToolCallsInput, FulfillToolCallInput, ClaimToolWorkInput, CompleteToolWorkInput, ReleaseToolWorkInput, ListToolAttemptsInput, ToolAttemptList, ToolOutcomeAccepted, ToolWorkLease, ToolWorkReleased, ReleaseEnvelopeReadyInput, ReplayExecutionInput, ReplayExecutionResult, ResolvePermissionInput, ResolveToolApprovalInput, RouteExecutionResult, StartExecutionInput, StartExecutionResult, SpawnChildRunInput, SteerAccepted, SteerInput, StreamExecutionInput, SubmitInboundEnvelopeAccepted, SubmitInboundEnvelopeInput, WaitView, WakeAccepted, WakeInput } from "./operation";
+import type { AckEnvelopeReadyInput, CancelExecutionAccepted, CancelExecutionInput, CancelScheduleInput, CancelScheduleResult, ClaimEnvelopeReadyInput, CreateScheduleInput, CreateScheduleResult, EnvelopeReadyAcked, EnvelopeReadyLease, EnvelopeReadyReleased, ExecutionInspection, ExecutionListChange, GetSessionInput, GetSessionResult, GetEntityStateInput, PutEntityStateInput, DeleteEntityStateInput, ListEntityStateInput, GetOrCreateEntityInput, GetEntityInput, DestroyEntityInput, ListEntitiesInput, ListExecutionsInput, ListExecutionsResult, ListInboxMessagesInput, ListTopicSubscriptionsInput, PublishTopicInput, SubscribeTopicInput, TopicPublishAccepted, TopicSubscription, UnsubscribeTopicInput, ListPendingApprovalsInput, SessionStreamItem, StreamSessionInput, WatchExecutionsInput, ListRunnersResult, ListSchedulesInput, ListSchedulesResult, ListSessionsInput, ListSessionsResult, ListWaitsInput, PendingToolApprovalList, PendingToolCallList, ListPendingToolCallsInput, FulfillToolCallInput, ClaimToolWorkInput, CompleteToolWorkInput, ReleaseToolWorkInput, ListToolAttemptsInput, ToolAttemptList, ToolOutcomeAccepted, ToolWorkLease, ToolWorkReleased, ReleaseEnvelopeReadyInput, ReplayExecutionInput, ReplayExecutionResult, ResolvePermissionInput, ResolveToolApprovalInput, RouteExecutionResult, StartExecutionInput, StartExecutionResult, SpawnChildRunInput, CancelChildFanOutInput, CancelChildFanOutResult, CreateChildFanOutInput, InspectChildFanOutInput, InspectChildFanOutResult, SteerAccepted, SteerInput, StreamExecutionInput, SubmitInboundEnvelopeAccepted, SubmitInboundEnvelopeInput, WaitView, WakeAccepted, WakeInput } from "./operation";
+import { EventLogCursorNotFound } from "./operation";
+export { EventLogCursorNotFound } from "./operation";
+import { AwaitWaitInput, WaitOutcome } from "./operation";
+import { FollowExecutionInput, FollowExecutionItem } from "./operation";
+import { CommandReplyInvalid, CommandTimedOut, EntityNotFound } from "./command";
+import type { Command } from "./command";
 declare const ClientError_base: Schema.Class<ClientError, Schema.TaggedStruct<"ClientError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -17,6 +23,31 @@ declare const ExecutionNotFound_base: Schema.Class<ExecutionNotFound, Schema.Tag
 }>, import("effect/Cause").YieldableError>;
 export declare class ExecutionNotFound extends ExecutionNotFound_base {
 }
+declare const EntityNamespaceReserved_base: Schema.Class<EntityNamespaceReserved, Schema.TaggedStruct<"EntityNamespaceReserved", {
+    readonly id: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EntityNamespaceReserved extends EntityNamespaceReserved_base {
+}
+declare const WaitKindMismatch_base: Schema.Class<WaitKindMismatch, Schema.TaggedStruct<"WaitKindMismatch", {
+    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 expected: Schema.String;
+    readonly actual: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class WaitKindMismatch extends WaitKindMismatch_base {
+}
+export interface AskEntityInput<Name extends string, I extends Schema.Top, O extends Schema.Top> {
+    readonly kind: Ids.EntityKindName;
+    readonly key: Ids.EntityKey;
+    readonly command: Command<Name, I, O>;
+    readonly input: I["Type"];
+    readonly from: Ids.AddressId;
+    readonly timeout?: string;
+    readonly metadata?: Shared.Metadata;
+}
 export interface StartExecutionByAddressInput {
     readonly address_id: Ids.AddressId;
     readonly session_id?: Ids.SessionId;
@@ -63,6 +94,18 @@ export interface RegisterBatonAgentInput {
 }
 export type RegisterAgentInput = RegisterDefinedAgentInput | RegisterBatonAgentInput;
 export interface Interface {
+    readonly registerEntityKind: (input: Entity.KindDefinition) => Effect.Effect<Entity.KindDefinition, ClientError>;
+    readonly getOrCreateEntity: (input: GetOrCreateEntityInput) => Effect.Effect<Entity.Instance, ClientError>;
+    readonly getEntity: (input: GetEntityInput) => Effect.Effect<Entity.Instance | undefined, ClientError>;
+    readonly destroyEntity: (input: DestroyEntityInput) => Effect.Effect<Entity.Instance, ClientError>;
+    readonly listEntities: (input: ListEntitiesInput) => Effect.Effect<ReadonlyArray<Entity.Instance>, ClientError>;
+    readonly registerWorkflowDefinition: (input: Workflow.RegisterDefinitionPayload) => Effect.Effect<Workflow.DefinitionRegistered, ClientError>;
+    readonly getWorkflowDefinitionRevision: (id: Ids.WorkflowDefinitionId, revision?: Workflow.DefinitionRevision) => Effect.Effect<Workflow.DefinitionRevisionRecord | undefined, ClientError>;
+    readonly listWorkflowDefinitionRevisions: (id: Ids.WorkflowDefinitionId) => Effect.Effect<Workflow.DefinitionRevisionList, ClientError>;
+    readonly startWorkflowRun: (input: Workflow.StartRunPayload) => Effect.Effect<Workflow.RunRecord, ClientError>;
+    readonly inspectWorkflowRun: (id: Ids.ExecutionId) => Effect.Effect<Workflow.RunRecord | undefined, ClientError>;
+    readonly replayWorkflowRun: (id: Ids.ExecutionId) => Effect.Effect<ReadonlyArray<Workflow.LifecycleEvent>, ClientError>;
+    readonly cancelWorkflowRun: (id: Ids.ExecutionId) => Effect.Effect<Workflow.RunRecord | undefined, ClientError>;
     readonly registerAgent: (input: RegisterAgentInput) => Effect.Effect<Agent.DefinitionRegistered, ClientError>;
     readonly registerAgentDefinition: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, ClientError>;
     readonly getAgentDefinition: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRecord | undefined, ClientError>;
@@ -71,17 +114,22 @@ export interface Interface {
     readonly getSkillDefinition: (id: Ids.SkillDefinitionId) => Effect.Effect<Skill.DefinitionRecord | undefined, ClientError>;
     readonly listSkillDefinitions: () => Effect.Effect<Skill.DefinitionList, ClientError>;
     readonly listSkillDefinitionRevisions: (id: Ids.SkillDefinitionId) => Effect.Effect<Skill.DefinitionRevisionList, ClientError>;
-    readonly registerAddressBookRoute: (input: Address.RegisterRoutePayload) => Effect.Effect<Address.RouteRegistered, ClientError>;
+    readonly registerAddressBookRoute: (input: Address.RegisterRoutePayload) => Effect.Effect<Address.RouteRegistered, EntityNamespaceReserved | ClientError>;
     readonly getAddressBookRoute: (id: Ids.AddressId) => Effect.Effect<Address.RouteRecord | undefined, ClientError>;
     readonly listAddressBookRoutes: () => Effect.Effect<Address.RouteList, ClientError>;
-    readonly startExecution: (input: StartExecutionInput) => Effect.Effect<StartExecutionResult, ClientError>;
-    readonly startExecutionByAddress: (input: StartExecutionByAddressInput) => Effect.Effect<StartExecutionResult, ClientError>;
-    readonly startExecutionByAgentDefinition: (input: StartExecutionByAgentDefinitionInput) => Effect.Effect<StartExecutionResult, ClientError>;
+    readonly startExecution: (input: StartExecutionInput) => Effect.Effect<StartExecutionResult, EntityNamespaceReserved | ClientError>;
+    readonly startExecutionByAddress: (input: StartExecutionByAddressInput) => Effect.Effect<StartExecutionResult, EntityNamespaceReserved | ClientError>;
+    readonly startExecutionByAgentDefinition: (input: StartExecutionByAgentDefinitionInput) => Effect.Effect<StartExecutionResult, EntityNamespaceReserved | ClientError>;
     readonly cancelExecution: (input: CancelExecutionInput) => Effect.Effect<CancelExecutionAccepted, ClientError>;
     readonly steer: (input: SteerInput) => Effect.Effect<SteerAccepted, ClientError>;
     readonly getExecution: (id: Ids.ExecutionId) => Effect.Effect<Execution.Execution | undefined, ClientError>;
     readonly inspectExecution: (executionId: Ids.ExecutionId) => Effect.Effect<ExecutionInspection, ExecutionNotFound | ClientError>;
     readonly listExecutions: (input: ListExecutionsInput) => Effect.Effect<ListExecutionsResult, ClientError>;
+    readonly listInboxMessages: (input: ListInboxMessagesInput) => Effect.Effect<ReadonlyArray<Inbox.Message>, ClientError>;
+    readonly subscribeTopic: (input: SubscribeTopicInput) => Effect.Effect<TopicSubscription, ClientError>;
+    readonly unsubscribeTopic: (input: UnsubscribeTopicInput) => Effect.Effect<void, ClientError>;
+    readonly publishTopic: (input: PublishTopicInput) => Effect.Effect<TopicPublishAccepted, ClientError>;
+    readonly listTopicSubscriptions: (input: ListTopicSubscriptionsInput) => Effect.Effect<ReadonlyArray<TopicSubscription>, ClientError>;
     readonly listSessions: (input: ListSessionsInput) => Effect.Effect<ListSessionsResult, ClientError>;
     readonly getSession: (input: GetSessionInput) => Effect.Effect<GetSessionResult, ClientError>;
     readonly listWaits: (input: ListWaitsInput) => Effect.Effect<ReadonlyArray<WaitView>, ClientError>;
@@ -89,19 +137,33 @@ export interface Interface {
     readonly listRunners: () => Effect.Effect<ListRunnersResult, ClientError>;
     readonly routeExecution: (executionId: Ids.ExecutionId) => Effect.Effect<RouteExecutionResult, ClientError>;
     readonly send: (input: Envelope.SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, ClientError>;
-    readonly streamExecution: (input: StreamExecutionInput) => Stream.Stream<Execution.ExecutionEvent, ClientError>;
-    readonly wake: (input: WakeInput) => Effect.Effect<WakeAccepted, ClientError>;
+    readonly askEntity: <Name extends string, I extends Schema.Top, O extends Schema.Top>(input: AskEntityInput<Name, I, O>) => Effect.Effect<O["Type"], CommandTimedOut | CommandReplyInvalid | EntityNotFound | ClientError, I["EncodingServices"] | O["DecodingServices"]>;
+    readonly awaitWait: (input: AwaitWaitInput) => Effect.Effect<WaitOutcome, ClientError>;
+    readonly streamExecution: (input: StreamExecutionInput) => Stream.Stream<Execution.ExecutionEvent, EventLogCursorNotFound | ClientError>;
+    readonly followExecution: (input: FollowExecutionInput) => Stream.Stream<FollowExecutionItem, EventLogCursorNotFound | ClientError>;
+    readonly streamSession: (input: StreamSessionInput) => Stream.Stream<SessionStreamItem, EventLogCursorNotFound | ClientError>;
+    readonly watchExecutions: (input: WatchExecutionsInput) => Stream.Stream<ExecutionListChange, ClientError>;
+    readonly getEntityState: (input: GetEntityStateInput) => Effect.Effect<State.StateRecordView | undefined, ClientError>;
+    readonly putEntityState: (input: PutEntityStateInput) => Effect.Effect<State.StateRecordView, ExecutionState.StateVersionConflict | ClientError>;
+    readonly deleteEntityState: (input: DeleteEntityStateInput) => Effect.Effect<State.StateRecordView | undefined, ExecutionState.StateVersionConflict | ClientError>;
+    readonly listEntityState: (input: ListEntityStateInput) => Effect.Effect<ReadonlyArray<State.StateRecordView>, ClientError>;
+    readonly getPresence: (scope: Presence.Scope) => Effect.Effect<Presence.View, ClientError>;
+    readonly watchPresence: (scope: Presence.Scope) => Stream.Stream<Presence.View, ClientError>;
+    readonly wake: (input: WakeInput) => Effect.Effect<WakeAccepted, WaitKindMismatch | ClientError>;
     readonly listPendingApprovals: (input: ListPendingApprovalsInput) => Effect.Effect<PendingToolApprovalList, ClientError>;
-    readonly resolveToolApproval: (input: ResolveToolApprovalInput) => Effect.Effect<WakeAccepted, ClientError>;
-    readonly resolvePermission: (input: ResolvePermissionInput) => Effect.Effect<WakeAccepted, ClientError>;
+    readonly resolveToolApproval: (input: ResolveToolApprovalInput) => Effect.Effect<WakeAccepted, WaitKindMismatch | ClientError>;
+    readonly resolvePermission: (input: ResolvePermissionInput) => Effect.Effect<WakeAccepted, WaitKindMismatch | ClientError>;
     readonly listPendingToolCalls: (input: ListPendingToolCallsInput) => Effect.Effect<PendingToolCallList, ClientError>;
     readonly fulfillToolCall: (input: FulfillToolCallInput) => Effect.Effect<ToolOutcomeAccepted, ClientError>;
     readonly claimToolWork: (input: ClaimToolWorkInput) => Effect.Effect<ToolWorkLease | null, ClientError>;
     readonly completeToolWork: (input: CompleteToolWorkInput) => Effect.Effect<ToolOutcomeAccepted, ClientError>;
     readonly releaseToolWork: (input: ReleaseToolWorkInput) => Effect.Effect<ToolWorkReleased, ClientError>;
     readonly listToolAttempts: (input: ListToolAttemptsInput) => Effect.Effect<ToolAttemptList, ClientError>;
-    readonly submitInboundEnvelope: (input: SubmitInboundEnvelopeInput) => Effect.Effect<SubmitInboundEnvelopeAccepted, ClientError>;
+    readonly submitInboundEnvelope: (input: SubmitInboundEnvelopeInput) => Effect.Effect<SubmitInboundEnvelopeAccepted, WaitKindMismatch | ClientError>;
     readonly spawnChildRun: (input: SpawnChildRunInput) => Effect.Effect<Execution.ChildRunAccepted, ClientError>;
+    readonly createChildFanOut: (input: CreateChildFanOutInput) => Effect.Effect<ChildOrchestration.FanOutState, ClientError>;
+    readonly cancelChildFanOut: (input: CancelChildFanOutInput) => Effect.Effect<CancelChildFanOutResult, ClientError>;
+    readonly inspectChildFanOut: (input: InspectChildFanOutInput) => Effect.Effect<InspectChildFanOutResult, ClientError>;
     readonly claimEnvelopeReady: (input: ClaimEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyLease | null, ClientError>;
     readonly ackEnvelopeReady: (input: AckEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyAcked, ClientError>;
     readonly releaseEnvelopeReady: (input: ReleaseEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyReleased, ClientError>;
@@ -112,9 +174,20 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/Client", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layerFromRuntime: Layer.Layer<Service, never, AgentRegistry.Service | AddressBook.Service | ExecutionService.Service | WaitService.Service | EventLog.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | ChildExecutionRepository.Service | SessionRepository.Service | SteeringRepository.Service | ClusterRegistryRepository.Service | ScheduleRepository.Service | SkillRegistry.Service | ToolTransitionCoordinator.Service | Sharding.Sharding | ShardingConfig.ShardingConfig>;
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export interface FollowExecutionDependencies {
+    readonly getExecution: (id: Ids.ExecutionId) => Effect.Effect<Execution.Execution | undefined, ClientError>;
+    readonly inspectExecution: (executionId: Ids.ExecutionId) => Effect.Effect<ExecutionInspection, ExecutionNotFound | ClientError>;
+    readonly streamExecution: (input: StreamExecutionInput) => Stream.Stream<Execution.ExecutionEvent, EventLogCursorNotFound | ClientError>;
+}
+export declare const followExecutionFrom: (dependencies: FollowExecutionDependencies) => (input: FollowExecutionInput) => Stream.Stream<FollowExecutionItem, EventLogCursorNotFound | ClientError>;
+export declare const layerFromRuntime: Layer.Layer<Service, never, AgentRegistry.Service | EntityRegistry.Service | EntityInstanceService.Service | AddressBook.Service | ExecutionService.Service | EnvelopeService.Service | WaitService.Service | EventLog.Service | SessionStream.Service | ExecutionWatch.Service | ExecutionState.Service | PresenceService.Service | EnvelopeRepository.Service | ExecutionRepository.Service | InboxRepository.Service | TopicService.Service | ToolCallRepository.Service | ChildExecutionRepository.Service | ChildFanOutRepository.Service | SessionRepository.Service | SteeringRepository.Service | ClusterRegistryRepository.Service | ScheduleRepository.Service | SkillRegistry.Service | ToolTransitionCoordinator.Service | WorkflowDefinitionRepository.Service | Sharding.Sharding | ShardingConfig.ShardingConfig>;
+export declare const testLayer: (implementation: Omit<Interface, "registerWorkflowDefinition" | "getWorkflowDefinitionRevision" | "listWorkflowDefinitionRevisions" | "startWorkflowRun" | "inspectWorkflowRun" | "replayWorkflowRun" | "cancelWorkflowRun" | "streamSession" | "watchExecutions" | "getPresence" | "watchPresence" | "registerEntityKind" | "getOrCreateEntity" | "getEntity" | "destroyEntity" | "listEntities" | "followExecution"> & Partial<Interface>) => Layer.Layer<Service, never, never>;
 export declare const registerAgentDefinition: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, ClientError, Service>;
+export declare const registerEntityKind: (input: Entity.KindDefinition) => Effect.Effect<Entity.KindDefinition, ClientError, Service>;
+export declare const getOrCreateEntity: (input: GetOrCreateEntityInput) => Effect.Effect<Entity.Instance, ClientError, Service>;
+export declare const getEntity: (input: GetEntityInput) => Effect.Effect<Entity.Instance | undefined, ClientError, Service>;
+export declare const destroyEntity: (input: DestroyEntityInput) => Effect.Effect<Entity.Instance, ClientError, Service>;
+export declare const listEntities: (input: ListEntitiesInput) => Effect.Effect<readonly Entity.Instance[], ClientError, Service>;
 export declare const registerAgent: (input: RegisterAgentInput) => Effect.Effect<Agent.DefinitionRegistered, ClientError, Service>;
 export declare const getAgentDefinition: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRecord | undefined, ClientError, Service>;
 export declare const listAgentDefinitions: () => Effect.Effect<Agent.DefinitionList, ClientError, Service>;
@@ -122,12 +195,12 @@ export declare const listAgentDefinitionRevisions: (id: string & import("effect/
 export declare const getSkillDefinition: (id: string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">) => Effect.Effect<Skill.DefinitionRecord | undefined, ClientError, Service>;
 export declare const listSkillDefinitions: () => Effect.Effect<Skill.DefinitionList, ClientError, Service>;
 export declare const listSkillDefinitionRevisions: (id: string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">) => Effect.Effect<Skill.DefinitionRevisionList, ClientError, Service>;
-export declare const registerAddressBookRoute: (input: Address.RegisterRoutePayload) => Effect.Effect<Address.RouteRegistered, ClientError, Service>;
+export declare const registerAddressBookRoute: (input: Address.RegisterRoutePayload) => Effect.Effect<Address.RouteRegistered, ClientError | EntityNamespaceReserved, Service>;
 export declare const getAddressBookRoute: (id: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<Address.RouteRecord | undefined, ClientError, Service>;
 export declare const listAddressBookRoutes: () => Effect.Effect<Address.RouteList, ClientError, Service>;
-export declare const startExecution: (input: StartExecutionInput) => Effect.Effect<StartExecutionResult, ClientError, Service>;
-export declare const startExecutionByAddress: (input: StartExecutionByAddressInput) => Effect.Effect<StartExecutionResult, ClientError, Service>;
-export declare const startExecutionByAgentDefinition: (input: StartExecutionByAgentDefinitionInput) => Effect.Effect<StartExecutionResult, ClientError, Service>;
+export declare const startExecution: (input: StartExecutionInput) => Effect.Effect<StartExecutionResult, ClientError | EntityNamespaceReserved, Service>;
+export declare const startExecutionByAddress: (input: StartExecutionByAddressInput) => Effect.Effect<StartExecutionResult, ClientError | EntityNamespaceReserved, Service>;
+export declare const startExecutionByAgentDefinition: (input: StartExecutionByAgentDefinitionInput) => Effect.Effect<StartExecutionResult, ClientError | EntityNamespaceReserved, Service>;
 export declare const cancelExecution: (input: CancelExecutionInput) => Effect.Effect<CancelExecutionAccepted, ClientError, Service>;
 export declare const steer: (input: SteerInput) => Effect.Effect<SteerAccepted, ClientError, Service>;
 export declare const getExecution: (id: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<Execution.Execution | undefined, ClientError, Service>;
@@ -138,25 +211,262 @@ export declare const listWaits: (input: ListWaitsInput) => Effect.Effect<readonl
 export declare const replayExecution: (input: ReplayExecutionInput) => Effect.Effect<ReplayExecutionResult, ClientError, Service>;
 export declare const listRunners: () => Effect.Effect<ListRunnersResult, ClientError, Service>;
 export declare const routeExecution: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<RouteExecutionResult, ClientError, Service>;
+export declare const subscribeTopic: (input: SubscribeTopicInput) => Effect.Effect<TopicSubscription, ClientError, Service>;
+export declare const unsubscribeTopic: (input: UnsubscribeTopicInput) => Effect.Effect<void, ClientError, Service>;
+export declare const publishTopic: (input: PublishTopicInput) => Effect.Effect<TopicPublishAccepted, ClientError, Service>;
+export declare const listTopicSubscriptions: (input: ListTopicSubscriptionsInput) => Effect.Effect<readonly TopicSubscription[], ClientError, Service>;
+export declare const listInboxMessages: (input: ListInboxMessagesInput) => Effect.Effect<readonly Inbox.Message[], ClientError, Service>;
 export declare const inspectExecution: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<ExecutionInspection, ClientError | ExecutionNotFound, Service>;
 export declare const send: (input: Envelope.SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, ClientError, Service>;
-export declare const streamExecution: (input: StreamExecutionInput) => Stream.Stream<Execution.ExecutionEvent, ClientError, Service>;
-export declare const wake: (input: WakeInput) => Effect.Effect<WakeAccepted, ClientError, Service>;
+export declare const streamExecution: (input: StreamExecutionInput) => Stream.Stream<Execution.ExecutionEvent, EventLogCursorNotFound | ClientError, Service>;
+export declare const followExecution: (input: FollowExecutionInput) => Stream.Stream<Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"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", "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<{
+            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;
+    }>;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"reconnecting">;
+    readonly message: Schema.String;
+    readonly attempt: Schema.Int;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"stopped">;
+    readonly reason: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"terminal">;
+        readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"actionable_wait">;
+        readonly wait: Schema.Struct<{
+            readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+            };
+            readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+            };
+            readonly envelope_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.EnvelopeId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeId">;
+            }>;
+            readonly kind: Schema.optionalKey<Schema.Literals<readonly ["permission", "tool_approval", "tool_placement", "child_join", "inbox", "reply", "timer", "external"]>>;
+            readonly mode: Schema.Literals<readonly ["reply", "event", "until", "child"]>;
+            readonly correlation_key: Schema.optionalKey<Schema.String>;
+            readonly state: Schema.Literals<readonly ["open", "resolved", "timed_out", "cancelled"]>;
+            readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly created_at: Schema.Int;
+            readonly resolved_at: Schema.optionalKey<Schema.Int>;
+        }>;
+    }>]>;
+    readonly cursor: Schema.NullOr<Schema.String>;
+}, "Type">, EventLogCursorNotFound | ClientError, Service>;
+export declare const streamSession: (input: StreamSessionInput) => Stream.Stream<Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"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;
+    }>;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"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", "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<{
+            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;
+    }>;
+}, "Type">, EventLogCursorNotFound | ClientError, Service>;
+export declare const watchExecutions: (input: WatchExecutionsInput) => Stream.Stream<{
+    readonly records: readonly {
+        readonly metadata: {
+            readonly [x: string]: Schema.Json;
+        };
+        readonly kind: "user-agent" | "agent-agent";
+        readonly created_at: number;
+        readonly updated_at: number;
+        readonly root_address_id: string & import("effect/Brand").Brand<"Relay.AddressId">;
+        readonly status: "waiting" | "running" | "completed" | "failed" | "queued" | "cancelled";
+        readonly execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+        readonly session_id?: string & import("effect/Brand").Brand<"Relay.SessionId">;
+        readonly agent_id?: string & import("effect/Brand").Brand<"Relay.AgentId">;
+    }[];
+    readonly _tag: "snapshot";
+    readonly next_cursor?: string;
+} | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"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;
+    }>;
+}, "Type">, ClientError, Service>;
+export declare const getPresence: (scope: Presence.Scope) => Effect.Effect<Presence.View, ClientError, Service>;
+export declare const watchPresence: (scope: Presence.Scope) => Stream.Stream<Presence.View, ClientError, Service>;
+export declare const wake: (input: WakeInput) => Effect.Effect<WakeAccepted, ClientError | WaitKindMismatch, Service>;
 export declare const listPendingApprovals: (input: ListPendingApprovalsInput) => Effect.Effect<PendingToolApprovalList, ClientError, Service>;
-export declare const resolveToolApproval: (input: ResolveToolApprovalInput) => Effect.Effect<WakeAccepted, ClientError, Service>;
-export declare const resolvePermission: (input: ResolvePermissionInput) => Effect.Effect<WakeAccepted, ClientError, Service>;
+export declare const resolveToolApproval: (input: ResolveToolApprovalInput) => Effect.Effect<WakeAccepted, ClientError | WaitKindMismatch, Service>;
+export declare const resolvePermission: (input: ResolvePermissionInput) => Effect.Effect<WakeAccepted, ClientError | WaitKindMismatch, Service>;
 export declare const listPendingToolCalls: (input: ListPendingToolCallsInput) => Effect.Effect<PendingToolCallList, ClientError, Service>;
 export declare const fulfillToolCall: (input: FulfillToolCallInput) => Effect.Effect<ToolOutcomeAccepted, ClientError, Service>;
 export declare const claimToolWork: (input: ClaimToolWorkInput) => Effect.Effect<ToolWorkLease | null, ClientError, Service>;
 export declare const completeToolWork: (input: CompleteToolWorkInput) => Effect.Effect<ToolOutcomeAccepted, ClientError, Service>;
 export declare const releaseToolWork: (input: ReleaseToolWorkInput) => Effect.Effect<ToolWorkReleased, ClientError, Service>;
 export declare const listToolAttempts: (input: ListToolAttemptsInput) => Effect.Effect<ToolAttemptList, ClientError, Service>;
-export declare const submitInboundEnvelope: (input: SubmitInboundEnvelopeInput) => Effect.Effect<SubmitInboundEnvelopeAccepted, ClientError, Service>;
+export declare const submitInboundEnvelope: (input: SubmitInboundEnvelopeInput) => Effect.Effect<SubmitInboundEnvelopeAccepted, ClientError | WaitKindMismatch, Service>;
 export declare const spawnChildRun: (input: SpawnChildRunInput) => Effect.Effect<Execution.ChildRunAccepted, ClientError, Service>;
+export declare const createChildFanOut: (input: CreateChildFanOutInput) => Effect.Effect<ChildOrchestration.FanOutState, ClientError, Service>;
+export declare const cancelChildFanOut: (input: CancelChildFanOutInput) => Effect.Effect<CancelChildFanOutResult, ClientError, Service>;
+export declare const inspectChildFanOut: (input: InspectChildFanOutInput) => Effect.Effect<InspectChildFanOutResult, ClientError, Service>;
 export declare const claimEnvelopeReady: (input: ClaimEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyLease | null, ClientError, Service>;
 export declare const ackEnvelopeReady: (input: AckEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyAcked, ClientError, Service>;
 export declare const releaseEnvelopeReady: (input: ReleaseEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyReleased, ClientError, Service>;
 export declare const createSchedule: (input: CreateScheduleInput) => Effect.Effect<CreateScheduleResult, ClientError, Service>;
 export declare const cancelSchedule: (input: CancelScheduleInput) => Effect.Effect<CancelScheduleResult, ClientError, Service>;
 export declare const listSchedules: (input: ListSchedulesInput) => Effect.Effect<ListSchedulesResult, ClientError, Service>;
-export {};
+export declare const askEntity: <Name extends string, I extends Schema.Top, O extends Schema.Top>(input: AskEntityInput<Name, I, O>) => Effect.Effect<O["Type"], CommandTimedOut | CommandReplyInvalid | EntityNotFound | ClientError, Service | I["EncodingServices"] | O["DecodingServices"]>;
+export declare const awaitWait: (input: AwaitWaitInput) => Effect.Effect<WaitOutcome, ClientError, Service>;

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

@@ -0,0 +1,41 @@
+import { Schema } from "effect";
+export interface Command<Name extends string, Input extends Schema.Top, Output extends Schema.Top> {
+    readonly name: Name;
+    readonly input: Input;
+    readonly output: Output;
+}
+export declare const make: <Name extends string, Input extends Schema.Top, Output extends Schema.Top>(name: Name, options: {
+    readonly input: Input;
+    readonly output: Output;
+}) => Command<Name, Input, Output>;
+export declare const inputSchemaRef: (name: string) => string;
+export declare const outputSchemaRef: (name: string) => string;
+declare const CommandTimedOut_base: Schema.Class<CommandTimedOut, Schema.TaggedStruct<"CommandTimedOut", {
+    readonly command: Schema.String;
+    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 timeout: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class CommandTimedOut extends CommandTimedOut_base {
+}
+declare const CommandReplyInvalid_base: Schema.Class<CommandReplyInvalid, Schema.TaggedStruct<"CommandReplyInvalid", {
+    readonly command: Schema.String;
+    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 message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class CommandReplyInvalid extends CommandReplyInvalid_base {
+}
+declare const EntityNotFound_base: Schema.Class<EntityNotFound, Schema.TaggedStruct<"EntityNotFound", {
+    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">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class EntityNotFound extends EntityNotFound_base {
+}
+export {};

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

@@ -5,6 +5,7 @@ export type PgTimestamp = Parameters<typeof Database.fromPgDate>[0];
 export type DatabaseError = Effect.Error<ReturnType<typeof Database.check>>;
 export type Dialect = typeof Database.Dialect.Type;
 export declare const Service: typeof Database.Service;
+export declare const PgClientLive: import("effect/Layer").Layer<import("effect/unstable/sql/SqlClient").SqlClient | import("@effect/sql-pg/PgClient").PgClient, import("effect/unstable/sql/SqlError").SqlError | import("effect/Config").ConfigError, never>;
 export declare const layerFromPgClient: import("effect/Layer").Layer<Database.Service, never, import("@effect/sql-pg/PgClient").PgClient>;
 export declare const testLayer: (db: Database.Drizzle) => import("effect/Layer").Layer<Database.Service, never, never>;
 export declare const check: () => Effect.Effect<void, import("drizzle-orm/effect-core").EffectDrizzleQueryError, Database.Service>;

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

@@ -1,10 +1,11 @@
 export * as AdapterOutbox from "./adapter-outbox";
 export * as Client from "./client";
+export * as Command from "./command";
 export * as Database from "./database";
 export * as Operation from "./operation";
 export * as ToolWorker from "./tool-worker";
-export { Address, Agent, Content, Envelope, Execution, Ids, Schedule, Shared, Skill, Tool } from "../schema/index";
-export { AddressBook, AddressResolution, AgentLoop, AgentRegistry, ActivityVersionRegistry, ArtifactStore, BlobStore, ChildRunService, EnvelopeService, EventLog, ExecutionEntity, ExecutionService, ExecutionWorkflow, LanguageModelService, ModelCallPolicy, PromptAssembler, SchedulerService, SchemaRegistry, SkillRegistry, ToolRuntime, WaitService, } from "../runtime/index";
+export { Address, Agent, Content, Entity, Envelope, Execution, Ids, Presence, Schedule, Shared, Skill, Tool, Waits, Workflow, } from "../schema/index";
+export { AddressBook, AddressResolution, AgentLoop, AgentRegistry, ActivityVersionRegistry, ArtifactStore, BlobStore, ChildRunService, ChildFanOutRuntime, EnvelopeService, EventLog, ExecutionEntity, ExecutionService, ExecutionWorkflow, LanguageModelService, ModelCallPolicy, PresenceService, PresenceTool, PromptAssembler, SchedulerService, SchemaRegistry, SkillRegistry, ToolRuntime, WaitService, WorkflowDefinitionRuntime, } from "../runtime/index";
 export { RunnerRuntime } from "../runtime/index";
 export { LanguageModelRegistration } from "../ai/index";
 export { RelaySchema, SkillDefinitionRepository } from "../store-sql/index";