@relayfx/sdk 0.3.6 → 0.4.0

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

@@ -1,15 +1,15 @@
 import { StateVersionConflict } from "./state-version-conflict";
 export { StateVersionConflict } from "./state-version-conflict";
 import type { Agent as BatonAgent } from "@batonfx/core";
-import { Address, Agent, ChildOrchestration, Content, Entity, Envelope, Execution, Ids, Inbox, Presence, Shared, Skill, State, Tool, Workflow } from "../schema/index";
+import { Address, Agent, ChildOrchestration, Content, Resident, Envelope, Execution, Ids, Inbox, Presence, Shared, Skill, State, Tool, Workflow } from "../schema/index";
 import { Context, Effect, Schema, Stream } from "effect";
 import type { Tool as BatonTool } from "effect/unstable/ai";
-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, PageExecutionEventsInput, PageExecutionEventsResult, ReplayExecutionInput, ReplayExecutionResult, ResolvePermissionInput, ResolveToolApprovalInput, RouteExecutionResult, StartExecutionInput, StartExecutionResult, SpawnChildRunInput, CancelChildFanOutInput, CancelChildFanOutResult, CreateChildFanOutInput, InspectChildFanOutInput, InspectChildFanOutResult, 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, GetResidentStateInput, PutResidentStateInput, DeleteResidentStateInput, ListResidentStateInput, SpawnResidentInput, GetResidentInput, DestroyResidentInput, ListResidentsInput, 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, PageExecutionEventsInput, PageExecutionEventsResult, 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 { CommandReplyInvalid, CommandTimedOut, ResidentNotFound } from "./command";
 import type { Command } from "./command";
 import { type RuntimeCapabilityUnavailable } from "./runtime-capability-policy";
 declare const ClientError_base: Schema.Class<ClientError, Schema.TaggedStruct<"ClientError", {
@@ -24,11 +24,11 @@ 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", {
+declare const ResidentNamespaceReserved_base: Schema.Class<ResidentNamespaceReserved, Schema.TaggedStruct<"ResidentNamespaceReserved", {
     readonly id: Schema.String;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
-export declare class EntityNamespaceReserved extends EntityNamespaceReserved_base {
+export declare class ResidentNamespaceReserved extends ResidentNamespaceReserved_base {
 }
 declare const WaitKindMismatch_base: Schema.Class<WaitKindMismatch, Schema.TaggedStruct<"WaitKindMismatch", {
     readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
@@ -40,9 +40,9 @@ declare const WaitKindMismatch_base: Schema.Class<WaitKindMismatch, Schema.Tagge
 }>, 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;
+export interface AskResidentInput<Name extends string, I extends Schema.Top, O extends Schema.Top> {
+    readonly kind: Ids.ResidentKindName;
+    readonly key: Ids.ResidentKey;
     readonly command: Command<Name, I, O>;
     readonly input: I["Type"];
     readonly from: Ids.AddressId;
@@ -100,12 +100,12 @@ export interface RegisterAgent {
     <Tools extends Record<string, BatonTool.Any>, Requirements>(input: RegisterBatonAgentInput<Tools, Requirements>): Effect.Effect<Agent.DefinitionRegistered, ClientError>;
     (input: RegisterDefinedAgentInput): Effect.Effect<Agent.DefinitionRegistered, ClientError>;
 }
-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>;
+export interface FlatInterface {
+    readonly registerResidentKind: (input: Resident.KindDefinition) => Effect.Effect<Resident.KindDefinition, ClientError>;
+    readonly spawnResident: (input: SpawnResidentInput) => Effect.Effect<Resident.Instance, ClientError>;
+    readonly getResident: (input: GetResidentInput) => Effect.Effect<Resident.Instance | undefined, ClientError>;
+    readonly destroyResident: (input: DestroyResidentInput) => Effect.Effect<Resident.Instance, ClientError>;
+    readonly listResidents: (input: ListResidentsInput) => Effect.Effect<ReadonlyArray<Resident.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>;
@@ -121,12 +121,12 @@ export interface Interface {
     readonly getSkillDefinition: (id: Ids.SkillDefinitionId) => Effect.Effect<Skill.DefinitionRecord | undefined, ClientError>;
     readonly listSkillDefinitions: (_?: void) => Effect.Effect<Skill.DefinitionList, ClientError>;
     readonly listSkillDefinitionRevisions: (id: Ids.SkillDefinitionId) => Effect.Effect<Skill.DefinitionRevisionList, ClientError>;
-    readonly registerAddressBookRoute: (input: Address.RegisterRoutePayload) => Effect.Effect<Address.RouteRegistered, EntityNamespaceReserved | ClientError>;
+    readonly registerAddressBookRoute: (input: Address.RegisterRoutePayload) => Effect.Effect<Address.RouteRegistered, ResidentNamespaceReserved | ClientError>;
     readonly getAddressBookRoute: (id: Ids.AddressId) => Effect.Effect<Address.RouteRecord | undefined, ClientError>;
     readonly listAddressBookRoutes: (_?: void) => Effect.Effect<Address.RouteList, 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 startExecution: (input: StartExecutionInput) => Effect.Effect<StartExecutionResult, ResidentNamespaceReserved | ClientError>;
+    readonly startExecutionByAddress: (input: StartExecutionByAddressInput) => Effect.Effect<StartExecutionResult, ResidentNamespaceReserved | ClientError>;
+    readonly startExecutionByAgentDefinition: (input: StartExecutionByAgentDefinitionInput) => Effect.Effect<StartExecutionResult, ResidentNamespaceReserved | 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>;
@@ -145,16 +145,16 @@ export interface Interface {
     readonly listRunners: (_?: void) => Effect.Effect<ListRunnersResult, ClientError>;
     readonly routeExecution: (executionId: Ids.ExecutionId) => Effect.Effect<RouteExecutionResult, ClientError>;
     readonly send: (input: Envelope.SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, 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 askResident: <Name extends string, I extends Schema.Top, O extends Schema.Top>(input: AskResidentInput<Name, I, O>) => Effect.Effect<O["Type"], CommandTimedOut | CommandReplyInvalid | ResidentNotFound | 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, StateVersionConflict | ClientError>;
-    readonly deleteEntityState: (input: DeleteEntityStateInput) => Effect.Effect<State.StateRecordView | undefined, StateVersionConflict | ClientError>;
-    readonly listEntityState: (input: ListEntityStateInput) => Effect.Effect<ReadonlyArray<State.StateRecordView>, ClientError>;
+    readonly getResidentState: (input: GetResidentStateInput) => Effect.Effect<State.StateRecordView | undefined, ClientError>;
+    readonly putResidentState: (input: PutResidentStateInput) => Effect.Effect<State.StateRecordView, StateVersionConflict | ClientError>;
+    readonly deleteResidentState: (input: DeleteResidentStateInput) => Effect.Effect<State.StateRecordView | undefined, StateVersionConflict | ClientError>;
+    readonly listResidentState: (input: ListResidentStateInput) => 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>;
@@ -179,6 +179,116 @@ export interface Interface {
     readonly cancelSchedule: (input: CancelScheduleInput) => Effect.Effect<CancelScheduleResult, ClientError>;
     readonly listSchedules: (input: ListSchedulesInput) => Effect.Effect<ListSchedulesResult, ClientError>;
 }
+export interface Interface {
+    readonly executions: {
+        readonly start: FlatInterface["startExecution"];
+        readonly startByAddress: FlatInterface["startExecutionByAddress"];
+        readonly startByAgentDefinition: FlatInterface["startExecutionByAgentDefinition"];
+        readonly cancel: FlatInterface["cancelExecution"];
+        readonly get: FlatInterface["getExecution"];
+        readonly list: FlatInterface["listExecutions"];
+        readonly replay: FlatInterface["replayExecution"];
+        readonly pageEvents: FlatInterface["pageExecutionEvents"];
+        readonly inspect: FlatInterface["inspectExecution"];
+        readonly route: FlatInterface["routeExecution"];
+        readonly steer: FlatInterface["steer"];
+        readonly stream: FlatInterface["streamExecution"];
+        readonly follow: FlatInterface["followExecution"];
+        readonly watch: FlatInterface["watchExecutions"];
+    };
+    readonly residents: {
+        readonly spawn: FlatInterface["spawnResident"];
+        readonly get: FlatInterface["getResident"];
+        readonly destroy: FlatInterface["destroyResident"];
+        readonly list: FlatInterface["listResidents"];
+        readonly ask: FlatInterface["askResident"];
+        readonly registerKind: FlatInterface["registerResidentKind"];
+        readonly getState: FlatInterface["getResidentState"];
+        readonly putState: FlatInterface["putResidentState"];
+        readonly deleteState: FlatInterface["deleteResidentState"];
+        readonly listState: FlatInterface["listResidentState"];
+    };
+    readonly agents: {
+        readonly register: FlatInterface["registerAgent"];
+        readonly registerDefinition: FlatInterface["registerAgentDefinition"];
+        readonly getDefinition: FlatInterface["getAgentDefinition"];
+        readonly listDefinitions: FlatInterface["listAgentDefinitions"];
+        readonly listDefinitionRevisions: FlatInterface["listAgentDefinitionRevisions"];
+    };
+    readonly skills: {
+        readonly getDefinition: FlatInterface["getSkillDefinition"];
+        readonly listDefinitions: FlatInterface["listSkillDefinitions"];
+        readonly listDefinitionRevisions: FlatInterface["listSkillDefinitionRevisions"];
+    };
+    readonly sessions: {
+        readonly get: FlatInterface["getSession"];
+        readonly list: FlatInterface["listSessions"];
+        readonly stream: FlatInterface["streamSession"];
+    };
+    readonly waits: {
+        readonly list: FlatInterface["listWaits"];
+        readonly await: FlatInterface["awaitWait"];
+        readonly wake: FlatInterface["wake"];
+    };
+    readonly envelopes: {
+        readonly send: FlatInterface["send"];
+        readonly submitInbound: FlatInterface["submitInboundEnvelope"];
+        readonly listInbox: FlatInterface["listInboxMessages"];
+        readonly claimReady: FlatInterface["claimEnvelopeReady"];
+        readonly ackReady: FlatInterface["ackEnvelopeReady"];
+        readonly releaseReady: FlatInterface["releaseEnvelopeReady"];
+    };
+    readonly tools: {
+        readonly listPending: FlatInterface["listPendingToolCalls"];
+        readonly fulfill: FlatInterface["fulfillToolCall"];
+        readonly claimWork: FlatInterface["claimToolWork"];
+        readonly completeWork: FlatInterface["completeToolWork"];
+        readonly releaseWork: FlatInterface["releaseToolWork"];
+        readonly listAttempts: FlatInterface["listToolAttempts"];
+        readonly listPendingApprovals: FlatInterface["listPendingApprovals"];
+        readonly resolveApproval: FlatInterface["resolveToolApproval"];
+        readonly resolvePermission: FlatInterface["resolvePermission"];
+    };
+    readonly topics: {
+        readonly subscribe: FlatInterface["subscribeTopic"];
+        readonly unsubscribe: FlatInterface["unsubscribeTopic"];
+        readonly publish: FlatInterface["publishTopic"];
+        readonly listSubscriptions: FlatInterface["listTopicSubscriptions"];
+    };
+    readonly childRuns: {
+        readonly spawn: FlatInterface["spawnChildRun"];
+        readonly createFanOut: FlatInterface["createChildFanOut"];
+        readonly cancelFanOut: FlatInterface["cancelChildFanOut"];
+        readonly inspectFanOut: FlatInterface["inspectChildFanOut"];
+    };
+    readonly schedules: {
+        readonly create: FlatInterface["createSchedule"];
+        readonly cancel: FlatInterface["cancelSchedule"];
+        readonly list: FlatInterface["listSchedules"];
+    };
+    readonly workflows: {
+        readonly registerDefinition: FlatInterface["registerWorkflowDefinition"];
+        readonly getDefinitionRevision: FlatInterface["getWorkflowDefinitionRevision"];
+        readonly listDefinitionRevisions: FlatInterface["listWorkflowDefinitionRevisions"];
+        readonly startRun: FlatInterface["startWorkflowRun"];
+        readonly cancelRun: FlatInterface["cancelWorkflowRun"];
+        readonly replayRun: FlatInterface["replayWorkflowRun"];
+        readonly inspectRun: FlatInterface["inspectWorkflowRun"];
+    };
+    readonly addressBook: {
+        readonly register: FlatInterface["registerAddressBookRoute"];
+        readonly get: FlatInterface["getAddressBookRoute"];
+        readonly list: FlatInterface["listAddressBookRoutes"];
+    };
+    readonly presence: {
+        readonly get: FlatInterface["getPresence"];
+        readonly watch: FlatInterface["watchPresence"];
+    };
+    readonly runners: {
+        readonly list: FlatInterface["listRunners"];
+    };
+}
+export type PublicOperation<Operation> = Operation extends (...args: infer Args) => Effect.Effect<infer A, infer E, infer R> ? (...args: Args) => Effect.Effect<A, E, R | Service> : Operation extends (...args: infer Args) => Stream.Stream<infer A, infer E, infer R> ? (...args: Args) => Stream.Stream<A, E, R | Service> : never;
 export type Identifier = "@relayfx/sdk/client-public/Service";
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/client-public/Service", Interface>;
 export declare class Service extends Service_base {
@@ -189,293 +299,3 @@ export interface FollowExecutionDependencies {
     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 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 function registerAgent<Tools extends Record<string, BatonTool.Any>, Requirements>(input: RegisterBatonAgentInput<Tools, Requirements>): Effect.Effect<Agent.DefinitionRegistered, ClientError, Service>;
-export declare function registerAgent(input: RegisterDefinedAgentInput): 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>;
-export declare const listAgentDefinitionRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRevisionList, ClientError, Service>;
-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 | 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 | 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>;
-export declare const listExecutions: (input: ListExecutionsInput) => Effect.Effect<ListExecutionsResult, ClientError, Service>;
-export declare const listSessions: (input: ListSessionsInput) => Effect.Effect<ListSessionsResult, ClientError, Service>;
-export declare const getSession: (input: GetSessionInput) => Effect.Effect<GetSessionResult, ClientError, Service>;
-export declare const listWaits: (input: ListWaitsInput) => Effect.Effect<readonly WaitView[], ClientError, Service>;
-export declare const replayExecution: (input: ReplayExecutionInput) => Effect.Effect<ReplayExecutionResult, ClientError, Service>;
-export declare const pageExecutionEvents: (input: PageExecutionEventsInput) => Effect.Effect<PageExecutionEventsResult, ClientError | EventLogCursorNotFound, 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 | EventLogCursorNotFound, 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.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.committed", "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">, ClientError | EventLogCursorNotFound, 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.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.committed", "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">, ClientError | EventLogCursorNotFound, Service>;
-export declare const watchExecutions: (input: WatchExecutionsInput) => Stream.Stream<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"> | {
-    readonly _tag: "snapshot";
-    readonly records: readonly {
-        readonly execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-        readonly root_address_id: string & import("effect/Brand").Brand<"Relay.AddressId">;
-        readonly session_id?: string & import("effect/Brand").Brand<"Relay.SessionId">;
-        readonly status: "cancelled" | "completed" | "failed" | "queued" | "running" | "waiting";
-        readonly kind: "agent-agent" | "user-agent";
-        readonly agent_id?: string & import("effect/Brand").Brand<"Relay.AgentId">;
-        readonly metadata: {
-            readonly [x: string]: Schema.Json;
-        };
-        readonly created_at: number;
-        readonly updated_at: number;
-    }[];
-    readonly next_cursor?: string;
-}, 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 | 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 | 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 | RuntimeCapabilityUnavailable, 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 declare const askEntity: <Name extends string, I extends Schema.Top, O extends Schema.Top>(input: AskEntityInput<Name, I, O>) => Effect.Effect<O["Type"], ClientError | CommandReplyInvalid | CommandTimedOut | EntityNotFound, Service | I["EncodingServices"] | O["DecodingServices"]>;
-export declare const awaitWait: (input: AwaitWaitInput) => Effect.Effect<WaitOutcome, ClientError, Service>;

package/dist/types/relay/client-runtime-wake.d.ts

@@ -0,0 +1,10 @@
+import type { Interface as EventLogInterface } from "../runtime/execution/event-log-service";
+import type { Interface as WaitServiceInterface } from "../runtime/wait/wait-service";
+import { ExecutionRepository } from "../store-sql/portable";
+import { Effect } from "effect";
+import { ClientError, WaitKindMismatch } from "./client-public";
+import type { WakeAccepted, WakeInput } from "./operation";
+import { type ExecutionClientFactory } from "./client-wait-signal";
+export declare const runtimeWakeInternals: {
+    wakeRuntime: (waits: WaitServiceInterface, eventLog: EventLogInterface, executionRepository: ExecutionRepository.Interface, makeExecutionClient: ExecutionClientFactory, input: WakeInput, accepts?: "tool-permission" | "tool-approval") => Effect.Effect<WakeAccepted, ClientError | WaitKindMismatch>;
+};

package/dist/types/relay/client-tool-outcome.d.ts

@@ -0,0 +1,16 @@
+import type { Interface as EventLogInterface } from "../runtime/execution/event-log-service";
+import type { Interface as WaitServiceInterface } from "../runtime/wait/wait-service";
+import { EnvelopeRepository, ExecutionRepository, ToolCallRepository } from "../store-sql/portable";
+import { Effect, Schema } from "effect";
+import { ClientError } from "./client-public";
+import { type ExecutionClientFactory } from "./client-wait-signal";
+export declare const resolveToolOutcomeWait: (waits: WaitServiceInterface, eventLog: EventLogInterface, call: ToolCallRepository.ToolCallRecord, outcome: Schema.Struct.ReadonlySide<{
+    readonly kind: Schema.Literal<"success">;
+    readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly kind: Schema.Literal<"failure">;
+    readonly message: Schema.String;
+}, "Type">, completedAt: number) => Effect.Effect<EnvelopeRepository.WaitRecord, ClientError, never>;
+export declare const toolOutcomeInternals: {
+    signalToolOutcome: (executionRepository: ExecutionRepository.Interface, makeExecutionClient: ExecutionClientFactory, wait: EnvelopeRepository.WaitRecord, signaledAt: number) => Effect.Effect<void, ClientError>;
+};

package/dist/types/relay/client-view-mappers.d.ts

@@ -0,0 +1,16 @@
+import { Execution } from "../schema/index";
+import { ChildExecutionRepository, EnvelopeRepository, ExecutionRepository, SessionRepository, ToolCallRepository } from "../store-sql/portable";
+import type { ChildRunSummary, ConversationSummary, EnvelopeReadyLease, PendingToolApproval, PendingToolCall, SessionSummary, ToolAttempt, ToolCallSummary, ToolOutcomeAccepted, ToolWorkLease, WaitView } from "./operation";
+export declare const toConversationSummary: (record: ExecutionRepository.ExecutionRecord) => ConversationSummary;
+export declare const toExecutionView: (record: ExecutionRepository.ExecutionRecord) => Execution.Execution;
+export declare const toWaitView: (record: EnvelopeRepository.WaitRecord) => WaitView;
+export declare const toSessionSummary: (record: SessionRepository.SessionRecord) => SessionSummary;
+export declare const toToolCallSummary: (record: ToolCallRepository.ToolCallRecord) => ToolCallSummary;
+export declare const toChildRunSummary: (record: ChildExecutionRepository.ChildExecutionRecord) => ChildRunSummary;
+export declare const toPendingToolApproval: (record: EnvelopeRepository.WaitRecord) => PendingToolApproval;
+export declare const isToolApprovalWait: (record: EnvelopeRepository.WaitRecord) => boolean;
+export declare const toToolAttempt: (record: ToolCallRepository.ToolAttemptRecord) => ToolAttempt;
+export declare const toPendingToolCall: (record: ToolCallRepository.ToolCallRecord) => PendingToolCall | undefined;
+export declare const toToolOutcomeAccepted: (accepted: ToolCallRepository.AcceptedOutcome) => ToolOutcomeAccepted;
+export declare const toToolWorkLease: (lease: ToolCallRepository.ToolWorkLease) => ToolWorkLease;
+export declare const toLease: (record: EnvelopeRepository.EnvelopeReadyRecord) => EnvelopeReadyLease;

package/dist/types/relay/client-wait-signal.d.ts

@@ -0,0 +1,5 @@
+import { client as ExecutionEntityclient } from "../runtime/cluster/execution-entity";
+import { type ExecutionClientFactory as WaitSignalExecutionClientFactory } from "../runtime/wait/wait-signal";
+import { Effect } from "effect";
+export type ExecutionClientFactory = Effect.Success<typeof ExecutionEntityclient>;
+export declare const typedWaitSignalClient: (makeExecutionClient: ExecutionClientFactory) => WaitSignalExecutionClientFactory;