@relayfx/sdk 0.3.1 → 0.3.3

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

@@ -0,0 +1,481 @@
+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 { 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 { 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";
+import { type RuntimeCapabilityUnavailable } from "./runtime-capability-policy";
+declare const ClientError_base: Schema.Class<ClientError, Schema.TaggedStruct<"ClientError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ClientError extends ClientError_base {
+}
+declare const ExecutionNotFound_base: Schema.Class<ExecutionNotFound, Schema.TaggedStruct<"ExecutionNotFound", {
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+}>, 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;
+    readonly input?: ReadonlyArray<Content.Part>;
+    readonly idempotency_key: Shared.NonEmptyString;
+    readonly execution_id?: Ids.ExecutionId;
+    readonly event_sequence?: Execution.ExecutionEventSequence;
+    readonly started_at: Shared.TimestampMillis;
+    readonly completed_at: Shared.TimestampMillis;
+    readonly wait_id?: Ids.WaitId;
+    readonly metadata?: Shared.Metadata;
+}
+export interface StartExecutionByAgentDefinitionInput {
+    readonly root_address_id: Ids.AddressId;
+    readonly session_id?: Ids.SessionId;
+    readonly agent_id: Ids.AgentId;
+    readonly agent_revision: Agent.DefinitionRevision;
+    readonly input?: ReadonlyArray<Content.Part>;
+    readonly idempotency_key: Shared.NonEmptyString;
+    readonly execution_id?: Ids.ExecutionId;
+    readonly event_sequence?: Execution.ExecutionEventSequence;
+    readonly started_at: Shared.TimestampMillis;
+    readonly completed_at: Shared.TimestampMillis;
+    readonly wait_id?: Ids.WaitId;
+    readonly metadata?: Shared.Metadata;
+}
+export interface RegisterDefinedAgentInput extends Agent.DefineInput {
+    readonly address?: Ids.AddressId;
+}
+export interface RegisterBatonAgentInput<Tools extends Record<string, BatonTool.Any>, Requirements> {
+    readonly id: Ids.AgentId;
+    readonly address?: Ids.AddressId;
+    readonly agent: BatonAgent.Agent<Tools, Requirements>;
+    readonly model?: Agent.ModelSelection;
+    readonly permissions?: ReadonlyArray<Tool.Permission>;
+    readonly skill_definition_ids?: ReadonlyArray<Ids.SkillDefinitionId>;
+    readonly permission_rules?: Agent.PermissionRuleset;
+    readonly compaction_policy?: Agent.CompactionPolicy;
+    readonly max_tool_turns?: number;
+    readonly max_wait_turns?: number;
+    readonly token_budget?: number;
+    readonly child_run_presets?: Readonly<Record<string, Agent.ChildRunPreset>>;
+    readonly handoff_targets?: ReadonlyArray<Agent.HandoffTarget>;
+    readonly output_schema_ref?: string;
+    readonly metadata?: Shared.Metadata;
+}
+export type RegisterAgentInput<Tools extends Record<string, BatonTool.Any>, Requirements> = RegisterDefinedAgentInput | RegisterBatonAgentInput<Tools, Requirements>;
+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>;
+    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 | RuntimeCapabilityUnavailable>;
+    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: RegisterAgent;
+    readonly registerAgentDefinition: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, ClientError>;
+    readonly getAgentDefinition: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRecord | undefined, ClientError>;
+    readonly listAgentDefinitions: (_?: void) => Effect.Effect<Agent.DefinitionList, ClientError>;
+    readonly listAgentDefinitionRevisions: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRevisionList, ClientError>;
+    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 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 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>;
+    readonly replayExecution: (input: ReplayExecutionInput) => Effect.Effect<ReplayExecutionResult, ClientError>;
+    readonly pageExecutionEvents: (input: PageExecutionEventsInput) => Effect.Effect<PageExecutionEventsResult, EventLogCursorNotFound | ClientError>;
+    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 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 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, 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, WaitKindMismatch | ClientError>;
+    readonly spawnChildRun: (input: SpawnChildRunInput) => Effect.Effect<Execution.ChildRunAccepted, ClientError>;
+    readonly createChildFanOut: (input: CreateChildFanOutInput) => Effect.Effect<ChildOrchestration.FanOutState, ClientError | RuntimeCapabilityUnavailable>;
+    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>;
+    readonly createSchedule: (input: CreateScheduleInput) => Effect.Effect<CreateScheduleResult, ClientError>;
+    readonly cancelSchedule: (input: CancelScheduleInput) => Effect.Effect<CancelScheduleResult, ClientError>;
+    readonly listSchedules: (input: ListSchedulesInput) => Effect.Effect<ListSchedulesResult, ClientError>;
+}
+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 {
+}
+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 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>;