@relayfx/sdk 0.0.50 → 0.2.0

package/dist/index-qgt9z94q.js

@@ -0,0 +1,2443 @@
+// @bun
+import {
+  __export,
+  exports_address_book_service,
+  exports_address_schema,
+  exports_agent_registry_service,
+  exports_agent_schema,
+  exports_child_execution_repository,
+  exports_child_fan_out_repository,
+  exports_child_fan_out_runtime,
+  exports_child_orchestration_schema,
+  exports_child_run_service,
+  exports_cluster_registry_repository,
+  exports_content_schema,
+  exports_definition_runtime,
+  exports_entity_instance_service,
+  exports_entity_registry_service,
+  exports_entity_schema,
+  exports_envelope_repository,
+  exports_envelope_schema,
+  exports_envelope_service,
+  exports_event_log_service,
+  exports_execution_entity,
+  exports_execution_repository,
+  exports_execution_schema,
+  exports_execution_service,
+  exports_execution_state_service,
+  exports_execution_watch_service,
+  exports_ids_schema,
+  exports_inbox_repository,
+  exports_inbox_schema,
+  exports_presence_service,
+  exports_schedule_repository,
+  exports_schedule_schema,
+  exports_scheduler_service,
+  exports_schema_registry_service,
+  exports_session_repository,
+  exports_session_stream_service,
+  exports_shared_schema,
+  exports_skill_registry_service,
+  exports_state_schema,
+  exports_steering_repository,
+  exports_tool_call_repository,
+  exports_tool_schema,
+  exports_tool_transition_coordinator,
+  exports_topic_service,
+  exports_wait_schema,
+  exports_wait_service,
+  exports_wait_signal,
+  exports_workflow_definition_repository
+} from "./index-2xztzkfr.js";
+
+// src/operation.ts
+var exports_operation = {};
+__export(exports_operation, {
+  WatchExecutionsInput: () => WatchExecutionsInput,
+  WakeInput: () => WakeInput,
+  WakeAccepted: () => WakeAccepted,
+  WaitView: () => WaitView,
+  WaitTerminalState: () => WaitTerminalState,
+  WaitState: () => WaitState,
+  WaitOutcome: () => WaitOutcome,
+  UnsubscribeTopicInput: () => UnsubscribeTopicInput,
+  TopicSubscription: () => TopicSubscription,
+  TopicPublishAccepted: () => TopicPublishAccepted,
+  ToolWorkReleased: () => ToolWorkReleased,
+  ToolWorkLease: () => ToolWorkLease,
+  ToolOutcomeAccepted: () => ToolOutcomeAccepted,
+  ToolCallSummary: () => ToolCallSummary,
+  ToolAttemptList: () => ToolAttemptList,
+  ToolAttempt: () => ToolAttempt,
+  SubscribeTopicInput: () => SubscribeTopicInput,
+  SubmitInboundEnvelopeInput: () => SubmitInboundEnvelopeInput,
+  SubmitInboundEnvelopeAccepted: () => SubmitInboundEnvelopeAccepted,
+  StreamSessionInput: () => StreamSessionInput,
+  StreamExecutionInput: () => StreamExecutionInput,
+  SteeringKind: () => SteeringKind,
+  SteerInput: () => SteerInput,
+  SteerAccepted: () => SteerAccepted,
+  StartExecutionResult: () => StartExecutionResult,
+  StartExecutionInput: () => StartExecutionInput,
+  SpawnChildRunInput: () => SpawnChildRunInput,
+  SessionSummary: () => SessionSummary,
+  SessionStreamItem: () => SessionStreamItem,
+  RunnerSummary: () => RunnerSummary,
+  RouteExecutionResult: () => RouteExecutionResult,
+  ResolveToolApprovalInput: () => ResolveToolApprovalInput,
+  ResolvePermissionInput: () => ResolvePermissionInput,
+  ReplayExecutionResult: () => ReplayExecutionResult,
+  ReplayExecutionInput: () => ReplayExecutionInput,
+  ReleaseToolWorkInput: () => ReleaseToolWorkInput,
+  ReleaseEnvelopeReadyInput: () => ReleaseEnvelopeReadyInput,
+  PutEntityStateInput: () => PutEntityStateInput,
+  PublishTopicInput: () => PublishTopicInput,
+  PermissionAnswer: () => PermissionAnswer,
+  PendingToolCallList: () => PendingToolCallList,
+  PendingToolCall: () => PendingToolCall,
+  PendingToolApprovalList: () => PendingToolApprovalList,
+  PendingToolApproval: () => PendingToolApproval,
+  ListWaitsInput: () => ListWaitsInput,
+  ListTopicSubscriptionsInput: () => ListTopicSubscriptionsInput,
+  ListToolAttemptsInput: () => ListToolAttemptsInput,
+  ListSessionsResult: () => ListSessionsResult,
+  ListSessionsInput: () => ListSessionsInput,
+  ListSchedulesResult: () => ListSchedulesResult,
+  ListSchedulesInput: () => ListSchedulesInput,
+  ListRunnersResult: () => ListRunnersResult,
+  ListPendingToolCallsInput: () => ListPendingToolCallsInput,
+  ListPendingApprovalsInput: () => ListPendingApprovalsInput,
+  ListInboxMessagesInput: () => ListInboxMessagesInput,
+  ListExecutionsResult: () => ListExecutionsResult,
+  ListExecutionsInput: () => ListExecutionsInput,
+  ListEntityStateInput: () => ListEntityStateInput,
+  ListEntitiesInput: () => ListEntitiesInput,
+  InspectChildFanOutResult: () => InspectChildFanOutResult,
+  InspectChildFanOutInput: () => InspectChildFanOutInput,
+  GetSessionResult: () => GetSessionResult,
+  GetSessionInput: () => GetSessionInput,
+  GetOrCreateEntityInput: () => GetOrCreateEntityInput,
+  GetEntityStateInput: () => GetEntityStateInput,
+  GetEntityInput: () => GetEntityInput,
+  FulfillToolCallInput: () => FulfillToolCallInput,
+  FollowStopReason: () => FollowStopReason,
+  FollowExecutionItem: () => FollowExecutionItem,
+  FollowExecutionInput: () => FollowExecutionInput,
+  ExecutionListChange: () => ExecutionListChange,
+  ExecutionInspection: () => ExecutionInspection,
+  ExecutionCursor: () => ExecutionCursor,
+  EventLogCursorNotFound: () => EventLogCursorNotFound,
+  EnvelopeReadyReleased: () => EnvelopeReadyReleased,
+  EnvelopeReadyLease: () => EnvelopeReadyLease,
+  EnvelopeReadyAcked: () => EnvelopeReadyAcked,
+  EntityInstance: () => EntityInstance,
+  DestroyEntityInput: () => DestroyEntityInput,
+  DeleteEntityStateInput: () => DeleteEntityStateInput,
+  CreateScheduleResult: () => CreateScheduleResult,
+  CreateScheduleInput: () => CreateScheduleInput,
+  CreateChildFanOutInput: () => CreateChildFanOutInput,
+  ConversationSummary: () => ConversationSummary,
+  ConversationKind: () => ConversationKind,
+  CompleteToolWorkInput: () => CompleteToolWorkInput,
+  ClaimToolWorkInput: () => ClaimToolWorkInput,
+  ClaimEnvelopeReadyInput: () => ClaimEnvelopeReadyInput,
+  ChildRunSummary: () => ChildRunSummary,
+  CancelScheduleResult: () => CancelScheduleResult,
+  CancelScheduleInput: () => CancelScheduleInput,
+  CancelExecutionInput: () => CancelExecutionInput,
+  CancelExecutionAccepted: () => CancelExecutionAccepted,
+  CancelChildFanOutResult: () => CancelChildFanOutResult,
+  CancelChildFanOutInput: () => CancelChildFanOutInput,
+  AwaitWaitInput: () => AwaitWaitInput,
+  AckEnvelopeReadyInput: () => AckEnvelopeReadyInput
+});
+import { Schema } from "effect";
+var StartExecutionInput = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  root_address_id: exports_ids_schema.AddressId,
+  session_id: Schema.optionalKey(exports_ids_schema.SessionId),
+  input: Schema.optionalKey(Schema.Array(exports_content_schema.Part)),
+  event_sequence: exports_execution_schema.ExecutionEventSequence,
+  started_at: exports_shared_schema.TimestampMillis,
+  completed_at: exports_shared_schema.TimestampMillis,
+  agent_id: Schema.optionalKey(exports_ids_schema.AgentId),
+  agent_revision: Schema.optionalKey(exports_agent_schema.DefinitionRevision),
+  agent_snapshot: Schema.optionalKey(exports_agent_schema.Definition),
+  agent_tool_input_schema_digests: Schema.optionalKey(exports_agent_schema.ToolInputSchemaDigests),
+  wait_id: Schema.optionalKey(exports_ids_schema.WaitId),
+  metadata: Schema.optionalKey(exports_shared_schema.Metadata)
+}).annotate({ identifier: "Relay.Operation.StartExecutionInput" });
+var StartExecutionResult = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  status: exports_execution_schema.ExecutionStatus,
+  metadata: Schema.optionalKey(exports_shared_schema.Metadata)
+}).annotate({ identifier: "Relay.Operation.StartExecutionResult" });
+var GetOrCreateEntityInput = Schema.Struct({
+  kind: exports_ids_schema.EntityKindName,
+  key: exports_ids_schema.EntityKey,
+  input: Schema.optionalKey(Schema.Array(exports_content_schema.Part)),
+  metadata: Schema.optionalKey(exports_shared_schema.Metadata),
+  created_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.GetOrCreateEntityInput" });
+var GetEntityInput = Schema.Struct({ kind: exports_ids_schema.EntityKindName, key: exports_ids_schema.EntityKey }).annotate({
+  identifier: "Relay.Operation.GetEntityInput"
+});
+var DestroyEntityInput = Schema.Struct({
+  kind: exports_ids_schema.EntityKindName,
+  key: exports_ids_schema.EntityKey,
+  reason: Schema.optionalKey(Schema.String),
+  destroyed_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.DestroyEntityInput" });
+var ListEntitiesInput = Schema.Struct({
+  kind: Schema.optionalKey(exports_ids_schema.EntityKindName),
+  after_kind: Schema.optionalKey(exports_ids_schema.EntityKindName),
+  after_key: Schema.optionalKey(Schema.String),
+  limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0)))
+}).annotate({ identifier: "Relay.Operation.ListEntitiesInput" });
+var EntityInstance = exports_entity_schema.Instance;
+var StreamExecutionInput = Schema.Struct({
+  execution_id: exports_execution_schema.Execution.fields.id,
+  after_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString),
+  limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0)))
+}).annotate({ identifier: "Relay.Operation.StreamExecutionInput" });
+var GetEntityStateInput = Schema.Struct({ execution_id: exports_ids_schema.ExecutionId, key: exports_state_schema.StateKey }).annotate({
+  identifier: "Relay.Operation.GetEntityStateInput"
+});
+var PutEntityStateInput = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  key: exports_state_schema.StateKey,
+  value: exports_shared_schema.JsonValue,
+  expected_version: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
+  idempotency_key: Schema.optionalKey(exports_state_schema.StateIdempotencyKey.check(Schema.makeFilter((value) => !value.startsWith("relay:internal:")))),
+  updated_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.PutEntityStateInput" });
+var DeleteEntityStateInput = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  key: exports_state_schema.StateKey,
+  expected_version: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
+  idempotency_key: Schema.optionalKey(exports_state_schema.StateIdempotencyKey.check(Schema.makeFilter((value) => !value.startsWith("relay:internal:")))),
+  removed_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.DeleteEntityStateInput" });
+var ListEntityStateInput = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  prefix: Schema.optionalKey(Schema.String),
+  after_key: Schema.optionalKey(Schema.String),
+  limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0)))
+}).annotate({ identifier: "Relay.Operation.ListEntityStateInput" });
+var WaitTerminalState = Schema.Literals(["resolved", "timed_out", "cancelled"]).annotate({
+  identifier: "Relay.Operation.WaitTerminalState"
+});
+var AwaitWaitInput = Schema.Struct({
+  wait_id: exports_ids_schema.WaitId,
+  execution_id: exports_ids_schema.ExecutionId
+}).annotate({ identifier: "Relay.Operation.AwaitWaitInput" });
+var WaitOutcome = Schema.Struct({
+  wait_id: exports_ids_schema.WaitId,
+  state: WaitTerminalState,
+  content: Schema.optionalKey(Schema.Array(exports_content_schema.Part)),
+  metadata: Schema.optionalKey(exports_shared_schema.Metadata)
+}).annotate({ identifier: "Relay.Operation.WaitOutcome" });
+var CancelExecutionInput = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  cancelled_at: exports_shared_schema.TimestampMillis,
+  reason: Schema.optionalKey(Schema.String)
+}).annotate({ identifier: "Relay.Operation.CancelExecutionInput" });
+var CancelExecutionAccepted = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  status: exports_execution_schema.ExecutionStatus
+}).annotate({ identifier: "Relay.Operation.CancelExecutionAccepted" });
+var SteeringKind = Schema.Literals(["steering", "follow_up"]).annotate({
+  identifier: "Relay.Operation.SteeringKind"
+});
+var SteerInput = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  kind: SteeringKind,
+  content: Schema.Array(exports_content_schema.Part),
+  created_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.SteerInput" });
+var SteerAccepted = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  kind: SteeringKind,
+  sequence: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+}).annotate({ identifier: "Relay.Operation.SteerAccepted" });
+var WakeInput = Schema.Struct({
+  wait_id: exports_ids_schema.WaitId,
+  state: WaitTerminalState,
+  signaled_at: exports_shared_schema.TimestampMillis,
+  from: Schema.optionalKey(exports_ids_schema.AddressId),
+  content: Schema.optionalKey(Schema.Array(exports_content_schema.Part)),
+  correlation_key: Schema.optionalKey(Schema.String),
+  metadata: Schema.optionalKey(exports_shared_schema.Metadata)
+}).annotate({ identifier: "Relay.Operation.WakeInput" });
+var WakeAccepted = Schema.Struct({
+  wait_id: exports_ids_schema.WaitId,
+  state: WaitTerminalState,
+  signaled_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.WakeAccepted" });
+var WaitState = Schema.Literals(["open", "resolved", "timed_out", "cancelled"]).annotate({
+  identifier: "Relay.Operation.WaitState"
+});
+var ListWaitsInput = Schema.Struct({
+  state: Schema.optionalKey(WaitState),
+  execution_id: Schema.optionalKey(exports_ids_schema.ExecutionId),
+  limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0)))
+}).annotate({ identifier: "Relay.Operation.ListWaitsInput" });
+var WaitView = Schema.Struct({
+  wait_id: exports_ids_schema.WaitId,
+  execution_id: exports_ids_schema.ExecutionId,
+  envelope_id: Schema.optionalKey(exports_ids_schema.EnvelopeId),
+  kind: Schema.optionalKey(exports_wait_schema.WaitKind),
+  mode: exports_envelope_schema.WaitMode,
+  correlation_key: Schema.optionalKey(Schema.String),
+  state: WaitState,
+  metadata: exports_shared_schema.Metadata,
+  created_at: exports_shared_schema.TimestampMillis,
+  resolved_at: Schema.optionalKey(exports_shared_schema.TimestampMillis)
+}).annotate({ identifier: "Relay.Operation.WaitView" });
+var FollowStopReason = Schema.Union([
+  Schema.Struct({ _tag: Schema.tag("terminal"), status: exports_execution_schema.ExecutionStatus }),
+  Schema.Struct({ _tag: Schema.tag("actionable_wait"), wait: WaitView })
+]).annotate({ identifier: "Relay.Operation.FollowStopReason" });
+var FollowExecutionItem = Schema.Union([
+  Schema.Struct({ _tag: Schema.tag("event"), event: exports_execution_schema.ExecutionEvent }),
+  Schema.Struct({ _tag: Schema.tag("reconnecting"), message: Schema.String, attempt: Schema.Int }),
+  Schema.Struct({
+    _tag: Schema.tag("stopped"),
+    reason: FollowStopReason,
+    cursor: Schema.NullOr(exports_shared_schema.NonEmptyString)
+  })
+]).annotate({ identifier: "Relay.Operation.FollowExecutionItem" });
+var FollowExecutionInput = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  after_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString),
+  stop_on_wait_modes: Schema.optionalKey(Schema.Array(exports_envelope_schema.WaitMode)),
+  max_reconnects: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)))
+}).annotate({ identifier: "Relay.Operation.FollowExecutionInput" });
+var PendingToolApproval = Schema.Struct({
+  wait_id: exports_ids_schema.WaitId,
+  execution_id: exports_ids_schema.ExecutionId,
+  tool_call_id: exports_ids_schema.ToolCallId,
+  tool_name: exports_shared_schema.NonEmptyString,
+  input: exports_shared_schema.JsonValue,
+  requested_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.PendingToolApproval" });
+var ListPendingApprovalsInput = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId
+}).annotate({ identifier: "Relay.Operation.ListPendingApprovalsInput" });
+var PendingToolApprovalList = Schema.Struct({
+  approvals: Schema.Array(PendingToolApproval)
+}).annotate({ identifier: "Relay.Operation.PendingToolApprovalList" });
+var PendingToolCall = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  call: exports_tool_schema.Call,
+  definition: exports_tool_schema.Definition,
+  placement: exports_tool_schema.Placement,
+  state: exports_tool_schema.CallState,
+  wait_id: exports_ids_schema.WaitId,
+  idempotency_key: Schema.String,
+  requested_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.PendingToolCall" });
+var ListPendingToolCallsInput = Schema.Struct({
+  execution_id: Schema.optionalKey(exports_ids_schema.ExecutionId),
+  limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0)))
+}).annotate({ identifier: "Relay.Operation.ListPendingToolCallsInput" });
+var PendingToolCallList = Schema.Struct({
+  tool_calls: Schema.Array(PendingToolCall)
+}).annotate({ identifier: "Relay.Operation.PendingToolCallList" });
+var FulfillToolCallInput = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  tool_call_id: exports_ids_schema.ToolCallId,
+  outcome: exports_tool_schema.ExternalOutcome,
+  fulfilled_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.FulfillToolCallInput" });
+var ClaimToolWorkInput = Schema.Struct({
+  queue: exports_tool_schema.PlacementKey,
+  worker_id: exports_tool_schema.WorkerId,
+  now: exports_shared_schema.TimestampMillis,
+  claim_expires_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.ClaimToolWorkInput" });
+var CompleteToolWorkInput = Schema.Struct({
+  tool_call_id: exports_ids_schema.ToolCallId,
+  attempt_id: exports_ids_schema.ToolAttemptId,
+  worker_id: exports_tool_schema.WorkerId,
+  outcome: exports_tool_schema.ExternalOutcome,
+  completed_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.CompleteToolWorkInput" });
+var ReleaseToolWorkInput = Schema.Struct({
+  tool_call_id: exports_ids_schema.ToolCallId,
+  attempt_id: exports_ids_schema.ToolAttemptId,
+  worker_id: exports_tool_schema.WorkerId,
+  released_at: exports_shared_schema.TimestampMillis,
+  next_available_at: exports_shared_schema.TimestampMillis,
+  error: Schema.optionalKey(Schema.String)
+}).annotate({ identifier: "Relay.Operation.ReleaseToolWorkInput" });
+var ListToolAttemptsInput = Schema.Struct({
+  tool_call_id: exports_ids_schema.ToolCallId
+}).annotate({ identifier: "Relay.Operation.ListToolAttemptsInput" });
+var ToolAttempt = Schema.Struct({
+  attempt_id: exports_ids_schema.ToolAttemptId,
+  tool_call_id: exports_ids_schema.ToolCallId,
+  attempt_number: Schema.Int.check(Schema.isGreaterThan(0)),
+  state: exports_tool_schema.AttemptState,
+  worker_id: Schema.optionalKey(Schema.String),
+  claim_expires_at: Schema.optionalKey(exports_shared_schema.TimestampMillis),
+  error: Schema.optionalKey(Schema.String),
+  created_at: exports_shared_schema.TimestampMillis,
+  completed_at: Schema.optionalKey(exports_shared_schema.TimestampMillis)
+}).annotate({ identifier: "Relay.Operation.ToolAttempt" });
+var ToolAttemptList = Schema.Struct({
+  attempts: Schema.Array(ToolAttempt)
+}).annotate({ identifier: "Relay.Operation.ToolAttemptList" });
+var ToolOutcomeAccepted = Schema.Struct({
+  tool_call_id: exports_ids_schema.ToolCallId,
+  attempt: ToolAttempt,
+  duplicate: Schema.Boolean
+}).annotate({ identifier: "Relay.Operation.ToolOutcomeAccepted" });
+var ToolWorkLease = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  call: exports_tool_schema.Call,
+  definition: exports_tool_schema.Definition,
+  placement: exports_tool_schema.Placement,
+  attempt: ToolAttempt,
+  queue: exports_tool_schema.PlacementKey,
+  worker_id: exports_tool_schema.WorkerId,
+  claim_expires_at: exports_shared_schema.TimestampMillis,
+  idempotency_key: Schema.String
+}).annotate({ identifier: "Relay.Operation.ToolWorkLease" });
+var ToolWorkReleased = Schema.Struct({
+  tool_call_id: exports_ids_schema.ToolCallId,
+  state: Schema.Literal("waiting"),
+  next_available_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.ToolWorkReleased" });
+var SpawnChildRunInput = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  child_execution_id: Schema.optionalKey(exports_ids_schema.ChildExecutionId),
+  address_id: exports_ids_schema.AddressId,
+  preset_name: Schema.optionalKey(exports_shared_schema.NonEmptyString),
+  instructions: Schema.optionalKey(Schema.String),
+  model: Schema.optionalKey(exports_agent_schema.ModelSelection),
+  tool_names: Schema.optionalKey(Schema.Array(Schema.String)),
+  permissions: Schema.optionalKey(Schema.Array(Schema.String)),
+  workspace_policy: Schema.optionalKey(exports_agent_schema.ChildRunWorkspacePolicy),
+  output_schema_ref: Schema.optionalKey(Schema.String),
+  metadata: Schema.optionalKey(exports_shared_schema.Metadata),
+  input: Schema.optionalKey(Schema.Array(exports_content_schema.Part)),
+  wait: Schema.optionalKey(Schema.Boolean)
+}).annotate({ identifier: "Relay.Operation.SpawnChildRunInput" });
+var CreateChildFanOutInput = exports_child_orchestration_schema.FanOutDefinition.annotate({
+  identifier: "Relay.Operation.CreateChildFanOutInput"
+});
+var CancelChildFanOutInput = Schema.Struct({
+  fan_out_id: exports_ids_schema.ChildFanOutId,
+  cancelled_at: exports_shared_schema.TimestampMillis,
+  reason: Schema.optionalKey(Schema.String)
+}).annotate({ identifier: "Relay.Operation.CancelChildFanOutInput" });
+var CancelChildFanOutResult = Schema.Struct({
+  fan_out: exports_child_orchestration_schema.FanOutState
+}).annotate({ identifier: "Relay.Operation.CancelChildFanOutResult" });
+var InspectChildFanOutInput = Schema.Struct({
+  fan_out_id: exports_ids_schema.ChildFanOutId
+}).annotate({ identifier: "Relay.Operation.InspectChildFanOutInput" });
+var InspectChildFanOutResult = Schema.Struct({
+  fan_out: Schema.NullOr(exports_child_orchestration_schema.FanOutState)
+}).annotate({ identifier: "Relay.Operation.InspectChildFanOutResult" });
+var ResolveToolApprovalInput = Schema.Struct({
+  wait_id: exports_ids_schema.WaitId,
+  approved: Schema.Boolean,
+  comment: Schema.optionalKey(Schema.String),
+  resolved_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.ResolveToolApprovalInput" });
+var PermissionAnswer = Schema.Literals(["Approved", "Denied", "Always"]).annotate({
+  identifier: "Relay.Operation.PermissionAnswer"
+});
+var ResolvePermissionInput = Schema.Struct({
+  wait_id: exports_ids_schema.WaitId,
+  answer: PermissionAnswer,
+  reason: Schema.optionalKey(Schema.String),
+  resolved_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.ResolvePermissionInput" });
+var SubmitInboundEnvelopeInput = Schema.Struct({
+  envelope: exports_envelope_schema.SendInput,
+  wake: WakeInput
+}).annotate({ identifier: "Relay.Operation.SubmitInboundEnvelopeInput" });
+var SubmitInboundEnvelopeAccepted = Schema.Struct({
+  envelope: exports_envelope_schema.EnvelopeAccepted,
+  wake: WakeAccepted
+}).annotate({ identifier: "Relay.Operation.SubmitInboundEnvelopeAccepted" });
+var ClaimEnvelopeReadyInput = Schema.Struct({
+  route_type: exports_address_schema.RouteKind,
+  route_key: Schema.optionalKey(Schema.String),
+  worker_id: exports_shared_schema.NonEmptyString,
+  now: exports_shared_schema.TimestampMillis,
+  claim_expires_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.ClaimEnvelopeReadyInput" });
+var EnvelopeReadyLease = Schema.Struct({
+  ready: exports_envelope_schema.EnvelopeReady,
+  worker_id: exports_shared_schema.NonEmptyString,
+  claim_expires_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.EnvelopeReadyLease" });
+var AckEnvelopeReadyInput = Schema.Struct({
+  envelope_ready_id: exports_ids_schema.EnvelopeReadyId,
+  worker_id: exports_shared_schema.NonEmptyString,
+  acknowledged_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.AckEnvelopeReadyInput" });
+var EnvelopeReadyAcked = Schema.Struct({
+  envelope_ready_id: exports_ids_schema.EnvelopeReadyId,
+  state: Schema.Literal("acknowledged"),
+  acknowledged_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.EnvelopeReadyAcked" });
+var ReleaseEnvelopeReadyInput = Schema.Struct({
+  envelope_ready_id: exports_ids_schema.EnvelopeReadyId,
+  worker_id: exports_shared_schema.NonEmptyString,
+  next_available_at: exports_shared_schema.TimestampMillis,
+  error: Schema.optionalKey(Schema.String)
+}).annotate({ identifier: "Relay.Operation.ReleaseEnvelopeReadyInput" });
+var EnvelopeReadyReleased = Schema.Struct({
+  envelope_ready_id: exports_ids_schema.EnvelopeReadyId,
+  state: Schema.Literal("ready"),
+  next_available_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.EnvelopeReadyReleased" });
+var CreateScheduleInput = Schema.Struct({
+  schedule_id: exports_ids_schema.ScheduleId,
+  kind: exports_schedule_schema.ScheduleKind,
+  target_kind: exports_schedule_schema.ScheduleTargetKind,
+  address_id: Schema.optionalKey(exports_ids_schema.AddressId),
+  wait_id: Schema.optionalKey(exports_ids_schema.WaitId),
+  cron_expr: Schema.optionalKey(exports_shared_schema.NonEmptyString),
+  input: Schema.optionalKey(Schema.Array(exports_content_schema.Part)),
+  next_run_at: exports_shared_schema.TimestampMillis,
+  idempotency_key: Schema.optionalKey(exports_shared_schema.NonEmptyString),
+  metadata: Schema.optionalKey(exports_shared_schema.Metadata)
+}).annotate({ identifier: "Relay.Operation.CreateScheduleInput" });
+var CreateScheduleResult = Schema.Struct({
+  schedule: exports_schedule_schema.ScheduleRecord
+}).annotate({ identifier: "Relay.Operation.CreateScheduleResult" });
+var CancelScheduleInput = Schema.Struct({
+  schedule_id: exports_ids_schema.ScheduleId,
+  cancelled_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.CancelScheduleInput" });
+var CancelScheduleResult = Schema.Struct({
+  schedule: exports_schedule_schema.ScheduleRecord
+}).annotate({ identifier: "Relay.Operation.CancelScheduleResult" });
+var ListSchedulesInput = Schema.Struct({
+  state: Schema.optionalKey(exports_schedule_schema.ScheduleState)
+}).annotate({ identifier: "Relay.Operation.ListSchedulesInput" });
+var ListSchedulesResult = Schema.Struct({
+  schedules: Schema.Array(exports_schedule_schema.ScheduleRecord)
+}).annotate({ identifier: "Relay.Operation.ListSchedulesResult" });
+var ListExecutionsInput = Schema.Struct({
+  root_address_id: Schema.optionalKey(exports_ids_schema.AddressId),
+  status: Schema.optionalKey(exports_execution_schema.ExecutionStatus),
+  limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0))),
+  cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString)
+}).annotate({ identifier: "Relay.Operation.ListExecutionsInput" });
+var SubscribeTopicInput = Schema.Struct({
+  topic_address_id: exports_ids_schema.AddressId,
+  subscriber_execution_id: exports_ids_schema.ExecutionId,
+  metadata: Schema.optionalKey(exports_shared_schema.Metadata)
+}).annotate({ identifier: "Relay.Operation.SubscribeTopicInput" });
+var TopicSubscription = Schema.Struct({
+  topic_address_id: exports_ids_schema.AddressId,
+  subscriber_execution_id: exports_ids_schema.ExecutionId,
+  metadata: Schema.optionalKey(exports_shared_schema.Metadata),
+  created_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.TopicSubscription" });
+var PublishTopicInput = Schema.Struct({
+  topic_address_id: exports_ids_schema.AddressId,
+  from: exports_ids_schema.AddressId,
+  content: Schema.Array(exports_content_schema.Part),
+  metadata: Schema.optionalKey(exports_shared_schema.Metadata),
+  idempotency_key: Schema.optionalKey(exports_shared_schema.NonEmptyString)
+}).annotate({ identifier: "Relay.Operation.PublishTopicInput" });
+var TopicPublishAccepted = Schema.Struct({
+  envelope_id: exports_ids_schema.EnvelopeId,
+  subscriber_count: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+}).annotate({ identifier: "Relay.Operation.TopicPublishAccepted" });
+var UnsubscribeTopicInput = Schema.Struct({
+  topic_address_id: exports_ids_schema.AddressId,
+  subscriber_execution_id: exports_ids_schema.ExecutionId
+}).annotate({ identifier: "Relay.Operation.UnsubscribeTopicInput" });
+var ListTopicSubscriptionsInput = Schema.Struct({
+  topic_address_id: Schema.optionalKey(exports_ids_schema.AddressId),
+  subscriber_execution_id: Schema.optionalKey(exports_ids_schema.ExecutionId)
+}).annotate({ identifier: "Relay.Operation.ListTopicSubscriptionsInput" });
+var ListInboxMessagesInput = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  include_consumed: Schema.optionalKey(Schema.Boolean),
+  after_sequence: Schema.optionalKey(exports_inbox_schema.MessageSequence),
+  limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0)))
+}).annotate({ identifier: "Relay.Operation.ListInboxMessagesInput" });
+var ConversationKind = Schema.Literals(["user-agent", "agent-agent"]).annotate({
+  identifier: "Relay.Operation.ConversationKind"
+});
+var ConversationSummary = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  root_address_id: exports_ids_schema.AddressId,
+  session_id: Schema.optionalKey(exports_ids_schema.SessionId),
+  status: exports_execution_schema.ExecutionStatus,
+  kind: ConversationKind,
+  agent_id: Schema.optionalKey(exports_ids_schema.AgentId),
+  metadata: exports_shared_schema.Metadata,
+  created_at: exports_shared_schema.TimestampMillis,
+  updated_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.ConversationSummary" });
+var ExecutionCursor = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  after_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString)
+}).annotate({ identifier: "Relay.Operation.ExecutionCursor" });
+
+class EventLogCursorNotFound extends Schema.TaggedErrorClass()("EventLogCursorNotFound", { execution_id: exports_ids_schema.ExecutionId, cursor: exports_shared_schema.NonEmptyString }) {
+}
+var StreamSessionInput = Schema.Struct({
+  session_id: exports_ids_schema.SessionId,
+  resume: Schema.optionalKey(Schema.Array(ExecutionCursor))
+}).annotate({ identifier: "Relay.Operation.StreamSessionInput" });
+var SessionStreamItem = Schema.Union([
+  Schema.TaggedStruct("execution_joined", { execution: ConversationSummary }),
+  Schema.TaggedStruct("execution_event", { event: exports_execution_schema.ExecutionEvent })
+]).annotate({ identifier: "Relay.Operation.SessionStreamItem" });
+var WatchExecutionsInput = Schema.Struct({
+  root_address_id: Schema.optionalKey(exports_ids_schema.AddressId),
+  session_id: Schema.optionalKey(exports_ids_schema.SessionId),
+  status: Schema.optionalKey(exports_execution_schema.ExecutionStatus),
+  limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0)))
+}).annotate({ identifier: "Relay.Operation.WatchExecutionsInput" });
+var ExecutionListChange = Schema.Union([
+  Schema.TaggedStruct("snapshot", {
+    records: Schema.Array(ConversationSummary),
+    next_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString)
+  }),
+  Schema.TaggedStruct("upsert", { record: ConversationSummary })
+]).annotate({ identifier: "Relay.Operation.ExecutionListChange" });
+var ToolCallSummary = Schema.Struct({
+  tool_call_id: exports_ids_schema.ToolCallId,
+  tool_name: exports_shared_schema.NonEmptyString,
+  input: exports_shared_schema.JsonValue,
+  metadata: exports_shared_schema.Metadata,
+  requested_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.ToolCallSummary" });
+var ChildRunSummary = Schema.Struct({
+  child_execution_id: exports_ids_schema.ChildExecutionId,
+  address_id: exports_ids_schema.AddressId,
+  status: exports_execution_schema.ExecutionStatus,
+  metadata: exports_shared_schema.Metadata,
+  created_at: exports_shared_schema.TimestampMillis,
+  updated_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.ChildRunSummary" });
+var ExecutionInspection = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  status: exports_execution_schema.ExecutionStatus,
+  waiting_on: Schema.Array(WaitView),
+  pending_tool_calls: Schema.Array(ToolCallSummary),
+  child_runs: Schema.Array(ChildRunSummary),
+  last_event_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString)
+}).annotate({ identifier: "Relay.Operation.ExecutionInspection" });
+var ListExecutionsResult = Schema.Struct({
+  records: Schema.Array(ConversationSummary),
+  next_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString)
+}).annotate({ identifier: "Relay.Operation.ListExecutionsResult" });
+var ListSessionsInput = Schema.Struct({
+  root_address_id: Schema.optionalKey(exports_ids_schema.AddressId),
+  limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0))),
+  cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString)
+}).annotate({ identifier: "Relay.Operation.ListSessionsInput" });
+var SessionSummary = Schema.Struct({
+  session_id: exports_ids_schema.SessionId,
+  root_address_id: exports_ids_schema.AddressId,
+  metadata: exports_shared_schema.Metadata,
+  created_at: exports_shared_schema.TimestampMillis,
+  updated_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.SessionSummary" });
+var ListSessionsResult = Schema.Struct({
+  records: Schema.Array(SessionSummary),
+  next_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString)
+}).annotate({ identifier: "Relay.Operation.ListSessionsResult" });
+var GetSessionInput = Schema.Struct({
+  session_id: exports_ids_schema.SessionId,
+  limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0))),
+  cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString)
+}).annotate({ identifier: "Relay.Operation.GetSessionInput" });
+var GetSessionResult = Schema.Struct({
+  session: SessionSummary,
+  executions: Schema.Array(ConversationSummary),
+  next_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString)
+}).annotate({ identifier: "Relay.Operation.GetSessionResult" });
+var ReplayExecutionInput = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  after_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString),
+  limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0)))
+}).annotate({ identifier: "Relay.Operation.ReplayExecutionInput" });
+var ReplayExecutionResult = Schema.Struct({
+  events: Schema.Array(exports_execution_schema.ExecutionEvent)
+}).annotate({ identifier: "Relay.Operation.ReplayExecutionResult" });
+var RunnerSummary = Schema.Struct({
+  address: Schema.String,
+  healthy: Schema.Boolean,
+  last_heartbeat: exports_shared_schema.TimestampMillis,
+  owned_shards: Schema.Int
+}).annotate({ identifier: "Relay.Operation.RunnerSummary" });
+var ListRunnersResult = Schema.Struct({
+  runners: Schema.Array(RunnerSummary),
+  total_shards: Schema.Int
+}).annotate({ identifier: "Relay.Operation.ListRunnersResult" });
+var RouteExecutionResult = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  shard: Schema.String,
+  runner_address: Schema.NullOr(Schema.String),
+  owned: Schema.Boolean
+}).annotate({ identifier: "Relay.Operation.RouteExecutionResult" });
+
+// src/command.ts
+var exports_command = {};
+__export(exports_command, {
+  outputSchemaRef: () => outputSchemaRef,
+  make: () => make,
+  inputSchemaRef: () => inputSchemaRef,
+  EntityNotFound: () => EntityNotFound,
+  CommandTimedOut: () => CommandTimedOut,
+  CommandReplyInvalid: () => CommandReplyInvalid
+});
+import { Schema as Schema2 } from "effect";
+var make = (name, options) => ({ name, ...options });
+var inputSchemaRef = (name) => `relay/command/${name}/input`;
+var outputSchemaRef = (name) => `relay/command/${name}/output`;
+
+class CommandTimedOut extends Schema2.TaggedErrorClass()("CommandTimedOut", {
+  command: exports_shared_schema.NonEmptyString,
+  wait_id: exports_ids_schema.WaitId,
+  timeout: Schema2.String
+}) {
+}
+
+class CommandReplyInvalid extends Schema2.TaggedErrorClass()("CommandReplyInvalid", {
+  command: exports_shared_schema.NonEmptyString,
+  wait_id: exports_ids_schema.WaitId,
+  message: Schema2.String
+}) {
+}
+
+class EntityNotFound extends Schema2.TaggedErrorClass()("EntityNotFound", {
+  kind: exports_ids_schema.EntityKindName,
+  key: exports_ids_schema.EntityKey
+}) {
+}
+
+// src/client.ts
+var exports_client = {};
+__export(exports_client, {
+  watchPresence: () => watchPresence,
+  watchExecutions: () => watchExecutions,
+  wake: () => wake,
+  unsubscribeTopic: () => unsubscribeTopic,
+  testLayer: () => testLayer,
+  subscribeTopic: () => subscribeTopic,
+  submitInboundEnvelope: () => submitInboundEnvelope,
+  streamSession: () => streamSession,
+  streamExecution: () => streamExecution,
+  steer: () => steer,
+  startExecutionByAgentDefinition: () => startExecutionByAgentDefinition,
+  startExecutionByAddress: () => startExecutionByAddress,
+  startExecution: () => startExecution,
+  spawnChildRun: () => spawnChildRun,
+  send: () => send,
+  routeExecution: () => routeExecution,
+  resolveToolApproval: () => resolveToolApproval,
+  resolvePermission: () => resolvePermission,
+  replayExecution: () => replayExecution,
+  releaseToolWork: () => releaseToolWork,
+  releaseEnvelopeReady: () => releaseEnvelopeReady,
+  registerEntityKind: () => registerEntityKind,
+  registerAgentDefinition: () => registerAgentDefinition,
+  registerAgent: () => registerAgent,
+  registerAddressBookRoute: () => registerAddressBookRoute,
+  publishTopic: () => publishTopic,
+  listWaits: () => listWaits,
+  listTopicSubscriptions: () => listTopicSubscriptions,
+  listToolAttempts: () => listToolAttempts,
+  listSkillDefinitions: () => listSkillDefinitions,
+  listSkillDefinitionRevisions: () => listSkillDefinitionRevisions,
+  listSessions: () => listSessions,
+  listSchedules: () => listSchedules,
+  listRunners: () => listRunners,
+  listPendingToolCalls: () => listPendingToolCalls,
+  listPendingApprovals: () => listPendingApprovals,
+  listInboxMessages: () => listInboxMessages,
+  listExecutions: () => listExecutions,
+  listEntities: () => listEntities,
+  listAgentDefinitions: () => listAgentDefinitions,
+  listAgentDefinitionRevisions: () => listAgentDefinitionRevisions,
+  listAddressBookRoutes: () => listAddressBookRoutes,
+  layerFromRuntime: () => layerFromRuntime,
+  inspectExecution: () => inspectExecution,
+  inspectChildFanOut: () => inspectChildFanOut,
+  getSkillDefinition: () => getSkillDefinition,
+  getSession: () => getSession,
+  getPresence: () => getPresence,
+  getOrCreateEntity: () => getOrCreateEntity,
+  getExecution: () => getExecution,
+  getEntity: () => getEntity,
+  getAgentDefinition: () => getAgentDefinition,
+  getAddressBookRoute: () => getAddressBookRoute,
+  fulfillToolCall: () => fulfillToolCall,
+  followExecutionFrom: () => followExecutionFrom,
+  followExecution: () => followExecution,
+  destroyEntity: () => destroyEntity,
+  createSchedule: () => createSchedule,
+  createChildFanOut: () => createChildFanOut,
+  completeToolWork: () => completeToolWork,
+  claimToolWork: () => claimToolWork,
+  claimEnvelopeReady: () => claimEnvelopeReady,
+  cancelSchedule: () => cancelSchedule,
+  cancelExecution: () => cancelExecution,
+  cancelChildFanOut: () => cancelChildFanOut,
+  awaitWait: () => awaitWait,
+  askEntity: () => askEntity,
+  ackEnvelopeReady: () => ackEnvelopeReady,
+  WaitKindMismatch: () => WaitKindMismatch,
+  Service: () => Service,
+  ExecutionNotFound: () => ExecutionNotFound,
+  EventLogCursorNotFound: () => EventLogCursorNotFound,
+  EntityNamespaceReserved: () => EntityNamespaceReserved,
+  ClientError: () => ClientError
+});
+import { Clock, Context, Effect, Layer, Option, Schema as Schema3, SchemaGetter, SchemaIssue, Stream } from "effect";
+import { EntityId, ShardId, Sharding, ShardingConfig } from "effect/unstable/cluster";
+class ClientError extends Schema3.TaggedErrorClass()("ClientError", {
+  message: Schema3.String
+}) {
+}
+
+class ExecutionNotFound extends Schema3.TaggedErrorClass()("ExecutionNotFound", {
+  execution_id: exports_ids_schema.ExecutionId
+}) {
+}
+
+class EntityNamespaceReserved extends Schema3.TaggedErrorClass()("EntityNamespaceReserved", { id: Schema3.String, message: Schema3.String }) {
+}
+
+class WaitKindMismatch extends Schema3.TaggedErrorClass()("WaitKindMismatch", {
+  wait_id: exports_ids_schema.WaitId,
+  expected: Schema3.String,
+  actual: Schema3.String,
+  message: Schema3.String
+}) {
+}
+
+class Service extends Context.Service()("@relayfx/sdk/Client") {
+}
+var followTerminalStatus = (type) => type === "execution.completed" ? "completed" : type === "execution.failed" ? "failed" : type === "execution.cancelled" ? "cancelled" : undefined;
+var followReconnectDelayMillis = (attempt) => Math.min(100 * 2 ** (attempt - 1), 5000);
+var followStopped = (reason, cursor) => ({
+  _tag: "stopped",
+  reason,
+  cursor: cursor ?? null
+});
+var followExecutionFrom = (dependencies) => (input) => {
+  const maxReconnects = input.max_reconnects ?? 10;
+  const stopModes = input.stop_on_wait_modes;
+  const inspect = Effect.suspend(() => dependencies.inspectExecution(input.execution_id)).pipe(Effect.catchTag("ExecutionNotFound", (error) => new ClientError({ message: `execution ${error.execution_id} not found` })));
+  const reconcile = (state, message) => Stream.unwrap(Effect.gen(function* () {
+    const inspection = yield* inspect;
+    const terminal = followTerminalStatus(`execution.${inspection.status}`);
+    if (terminal !== undefined) {
+      return Stream.make(followStopped({ _tag: "terminal", status: terminal }, state.cursor));
+    }
+    const actionable = stopModes === undefined ? undefined : inspection.waiting_on.find((wait) => wait.state === "open" && stopModes.includes(wait.mode));
+    if (actionable !== undefined) {
+      return Stream.make(followStopped({ _tag: "actionable_wait", wait: actionable }, state.cursor));
+    }
+    if (state.attempts >= maxReconnects) {
+      return Stream.fail(new ClientError({
+        message: `follow of ${input.execution_id} exhausted ${maxReconnects} reconnects: ${message}`
+      }));
+    }
+    state.attempts += 1;
+    const reconnecting = { _tag: "reconnecting", message, attempt: state.attempts };
+    return Stream.make(reconnecting).pipe(Stream.concat(Stream.fromEffect(Effect.sleep(followReconnectDelayMillis(state.attempts))).pipe(Stream.drain)), Stream.concat(Stream.suspend(() => connect(state))));
+  }));
+  const itemsFor = (state, event) => Effect.gen(function* () {
+    if (event.sequence <= state.sequence)
+      return [];
+    state.sequence = event.sequence;
+    state.cursor = event.cursor;
+    state.emitted = true;
+    state.attempts = 0;
+    const items = [{ _tag: "event", event }];
+    const terminal = followTerminalStatus(event.type);
+    if (terminal !== undefined) {
+      items.push(followStopped({ _tag: "terminal", status: terminal }, state.cursor));
+      return items;
+    }
+    if (stopModes !== undefined && event.type === "wait.created") {
+      const mode = event.data?.mode;
+      if (typeof mode === "string" && stopModes.includes(mode)) {
+        const inspection = yield* dependencies.inspectExecution(input.execution_id).pipe(Effect.catchTag("ExecutionNotFound", () => Effect.succeed(undefined)));
+        const actionable = inspection?.waiting_on.find((wait) => wait.state === "open" && wait.wait_id === event.data?.wait_id);
+        if (actionable !== undefined) {
+          items.push(followStopped({ _tag: "actionable_wait", wait: actionable }, state.cursor));
+        }
+      }
+    }
+    return items;
+  });
+  const connect = (state) => dependencies.streamExecution({
+    execution_id: input.execution_id,
+    ...state.cursor === undefined ? {} : { after_cursor: state.cursor }
+  }).pipe(Stream.flatMap((event) => Stream.fromEffect(itemsFor(state, event)).pipe(Stream.flatMap((items) => Stream.fromIterable(items)))), Stream.catchTag("EventLogCursorNotFound", (error) => !state.emitted && input.after_cursor !== undefined ? Stream.fail(error) : reconcile(state, `cursor ${error.cursor} was not found`)), Stream.catchTag("ClientError", (error) => reconcile(state, `stream failed: ${error.message}`)), Stream.concat(Stream.suspend(() => reconcile(state, "stream ended before a terminal event"))));
+  return Stream.unwrap(Effect.gen(function* () {
+    const existing = yield* dependencies.getExecution(input.execution_id);
+    if (existing === undefined) {
+      return Stream.fail(new ClientError({ message: `execution ${input.execution_id} not found` }));
+    }
+    const state = {
+      cursor: input.after_cursor,
+      sequence: -1,
+      attempts: 0,
+      emitted: false
+    };
+    return connect(state);
+  })).pipe(Stream.takeUntil((item) => item._tag === "stopped"));
+};
+var errorMessage = (error) => {
+  if (error instanceof Error)
+    return error.message;
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  if (typeof error === "object" && error !== null && "_tag" in error && typeof error._tag === "string") {
+    return error._tag;
+  }
+  return String(error);
+};
+var toClientError = (error) => new ClientError({ message: errorMessage(error) });
+var rejectReserved = (id, prefix) => id.startsWith(prefix) ? Effect.fail(new EntityNamespaceReserved({ id, message: "start entities via Client.getOrCreateEntity" })) : Effect.void;
+var replyValueFrom = (content) => {
+  if (content === undefined || content.length === 0)
+    return Option.none();
+  const structured = content.find((part) => part.type === "structured");
+  if (structured !== undefined)
+    return Option.some(structured.value);
+  const text = content.filter((part) => part.type === "text").map((part) => part.text).join("");
+  if (text.length === 0)
+    return Option.none();
+  try {
+    return Option.some(JSON.parse(text));
+  } catch {
+    return Option.none();
+  }
+};
+var toStreamError = (error) => Option.match(Schema3.decodeUnknownOption(EventLogCursorNotFound)(error), {
+  onNone: () => toClientError(error),
+  onSome: (cursorError) => cursorError
+});
+var malformedCursor = (wire) => new SchemaIssue.InvalidValue(Option.some(wire), { message: "Malformed pagination cursor" });
+var decodeCursorFields = (wire) => Effect.gen(function* () {
+  const decoded = yield* Effect.try({
+    try: () => globalThis.atob(wire),
+    catch: () => malformedCursor(wire)
+  });
+  const separator = decoded.indexOf(":");
+  if (separator === -1)
+    return yield* Effect.fail(malformedCursor(wire));
+  const updatedAt = Number(decoded.slice(0, separator));
+  if (!Number.isFinite(updatedAt))
+    return yield* Effect.fail(malformedCursor(wire));
+  return { updatedAt, id: decoded.slice(separator + 1) };
+});
+var ExecutionCursorFromString = exports_shared_schema.NonEmptyString.pipe(Schema3.decodeTo(Schema3.Struct({ updatedAt: Schema3.Int, id: exports_ids_schema.ExecutionId }), {
+  decode: SchemaGetter.transformOrFail((wire) => decodeCursorFields(wire)),
+  encode: SchemaGetter.transform((cursor) => globalThis.btoa(`${cursor.updatedAt}:${cursor.id}`))
+})).annotate({ identifier: "Relay.Client.ExecutionCursor" });
+var encodeExecutionCursor = (cursor) => Schema3.encodeEffect(ExecutionCursorFromString)(cursor).pipe(Effect.mapError(toClientError));
+var SessionCursorFromString = exports_shared_schema.NonEmptyString.pipe(Schema3.decodeTo(Schema3.Struct({ updatedAt: Schema3.Int, id: exports_ids_schema.SessionId }), {
+  decode: SchemaGetter.transformOrFail((wire) => decodeCursorFields(wire)),
+  encode: SchemaGetter.transform((cursor) => globalThis.btoa(`${cursor.updatedAt}:${cursor.id}`))
+})).annotate({ identifier: "Relay.Client.SessionCursor" });
+var conversationKind = (metadata) => metadata.kind === "agent-agent" ? "agent-agent" : "user-agent";
+var toConversationSummary = (record) => ({
+  execution_id: record.id,
+  root_address_id: record.rootAddressId,
+  ...record.sessionId === undefined ? {} : { session_id: record.sessionId },
+  status: record.status,
+  kind: conversationKind(record.metadata),
+  ...record.agentId === undefined ? {} : { agent_id: record.agentId },
+  metadata: record.metadata,
+  created_at: record.createdAt,
+  updated_at: record.updatedAt
+});
+var toExecutionView = (record) => ({
+  id: record.id,
+  root_address_id: record.rootAddressId,
+  ...record.sessionId === undefined ? {} : { session_id: record.sessionId },
+  status: record.status,
+  ...record.agentId === undefined ? {} : { agent_id: record.agentId },
+  ...record.agentRevision === undefined ? {} : { agent_revision: record.agentRevision },
+  ...record.agentSnapshot === undefined ? {} : { agent_snapshot: record.agentSnapshot },
+  ...record.agentToolInputSchemaDigests === undefined ? {} : { agent_tool_input_schema_digests: record.agentToolInputSchemaDigests },
+  metadata: record.metadata,
+  created_at: record.createdAt,
+  updated_at: record.updatedAt
+});
+var toWaitView = (record) => ({
+  wait_id: record.id,
+  execution_id: record.executionId,
+  ...record.envelopeId === undefined ? {} : { envelope_id: record.envelopeId },
+  kind: exports_wait_schema.classify({
+    wait_id: record.id,
+    mode: record.mode,
+    ...record.envelopeId === undefined ? {} : { envelope_id: record.envelopeId },
+    ...record.correlationKey === undefined ? {} : { correlation_key: record.correlationKey }
+  }).kind,
+  mode: record.mode,
+  ...record.correlationKey === undefined ? {} : { correlation_key: record.correlationKey },
+  state: record.state,
+  metadata: record.metadata,
+  created_at: record.createdAt,
+  ...record.resolvedAt === undefined ? {} : { resolved_at: record.resolvedAt }
+});
+var toSessionSummary = (record) => ({
+  session_id: record.id,
+  root_address_id: record.rootAddressId,
+  metadata: record.metadata,
+  created_at: record.createdAt,
+  updated_at: record.updatedAt
+});
+var toToolCallSummary = (record) => ({
+  tool_call_id: record.call.id,
+  tool_name: record.call.name,
+  input: record.call.input,
+  metadata: record.call.metadata ?? {},
+  requested_at: record.createdAt
+});
+var toChildRunSummary = (record) => ({
+  child_execution_id: record.id,
+  address_id: record.addressId,
+  status: record.status,
+  metadata: record.metadata,
+  created_at: record.createdAt,
+  updated_at: record.updatedAt
+});
+var executionIdFromIdempotencyKey = (idempotencyKey) => exports_ids_schema.ExecutionId.make(`execution:${idempotencyKey}`);
+var metadataWithIdempotencyKey = (metadata, idempotencyKey) => ({
+  ...metadata,
+  idempotency_key: idempotencyKey
+});
+var startExecutionByAddressPayload = (input) => ({
+  execution_id: input.execution_id ?? executionIdFromIdempotencyKey(input.idempotency_key),
+  root_address_id: input.address_id,
+  ...input.session_id === undefined ? {} : { session_id: input.session_id },
+  ...input.input === undefined ? {} : { input: [...input.input] },
+  event_sequence: input.event_sequence ?? 0,
+  started_at: input.started_at,
+  completed_at: input.completed_at,
+  ...input.wait_id === undefined ? {} : { wait_id: input.wait_id },
+  metadata: metadataWithIdempotencyKey(input.metadata, input.idempotency_key)
+});
+var startExecutionByAgentDefinitionPayload = (input, definition) => ({
+  execution_id: input.execution_id ?? executionIdFromIdempotencyKey(input.idempotency_key),
+  root_address_id: input.root_address_id,
+  ...input.session_id === undefined ? {} : { session_id: input.session_id },
+  ...input.input === undefined ? {} : { input: [...input.input] },
+  event_sequence: input.event_sequence ?? 0,
+  started_at: input.started_at,
+  completed_at: input.completed_at,
+  agent_id: input.agent_id,
+  agent_revision: definition.current_revision,
+  agent_snapshot: definition.definition,
+  ...definition.tool_input_schema_digests === undefined ? {} : { agent_tool_input_schema_digests: definition.tool_input_schema_digests },
+  ...input.wait_id === undefined ? {} : { wait_id: input.wait_id },
+  metadata: metadataWithIdempotencyKey(input.metadata, input.idempotency_key)
+});
+var isRegisterBatonAgentInput = (input) => ("agent" in input);
+var toolRefsFromBatonAgent = (agent) => {
+  const tools = agent.toolkit.tools;
+  return Object.values(tools).map((tool) => ({ name: tool.name }));
+};
+var modelSelectionFromBatonAgent = (selection) => ({
+  provider: selection.provider,
+  model: selection.model,
+  ...selection.registrationKey === undefined ? {} : { registration_key: selection.registrationKey }
+});
+var decodeBatonAgentName = (name) => Schema3.decodeUnknownEffect(exports_shared_schema.NonEmptyString)(name).pipe(Effect.mapError(() => new ClientError({ message: "Baton agent name must not be blank" })));
+var decodeBatonAgentMetadata = (metadata) => metadata === undefined ? Effect.succeed(undefined) : Schema3.decodeUnknownEffect(exports_shared_schema.Metadata)(metadata).pipe(Effect.mapError(() => new ClientError({ message: "Baton agent metadata must be JSON metadata" })));
+var decodeBatonMemorySubject = (subject) => Schema3.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect.mapError(() => new ClientError({ message: "Baton agent memory subject must be a MemorySubjectId" })));
+var metadataFromBatonAgent = Effect.fn("Client.metadataFromBatonAgent")(function* (input) {
+  const agentMetadata = yield* decodeBatonAgentMetadata(input.agent.metadata);
+  const memorySubject = input.agent.memory === undefined ? undefined : yield* decodeBatonMemorySubject(input.agent.memory.subject);
+  const metadata = {
+    ...agentMetadata,
+    ...memorySubject === undefined ? {} : { memory_subject_id: memorySubject },
+    ...input.metadata
+  };
+  return Object.keys(metadata).length === 0 ? undefined : metadata;
+});
+var modelSelectionFromRegisterInput = (input) => {
+  if (input.model !== undefined)
+    return Effect.succeed(input.model);
+  if (input.agent.model !== undefined)
+    return Effect.succeed(modelSelectionFromBatonAgent(input.agent.model));
+  return Effect.fail(new ClientError({ message: "Client.registerAgent requires model or agent.model" }));
+};
+var batonTurnPolicyInvalid = (detail) => new ClientError({ message: `Baton agent turn policy is not durably portable: ${detail}` });
+var turnPolicySnapshotFromBaton = Effect.fn("Client.turnPolicySnapshotFromBaton")(function* (snapshot) {
+  let nodes = 0;
+  const visit = (current, depth) => Effect.gen(function* () {
+    if (typeof current !== "object" || current === null || Array.isArray(current)) {
+      return yield* Effect.fail(batonTurnPolicyInvalid("snapshot nodes must be objects"));
+    }
+    const node = current;
+    nodes += 1;
+    if (depth > exports_agent_schema.maxTurnPolicySnapshotDepth) {
+      return yield* Effect.fail(batonTurnPolicyInvalid(`depth exceeds ${exports_agent_schema.maxTurnPolicySnapshotDepth}`));
+    }
+    if (nodes > exports_agent_schema.maxTurnPolicySnapshotNodes) {
+      return yield* Effect.fail(batonTurnPolicyInvalid(`node count exceeds ${exports_agent_schema.maxTurnPolicySnapshotNodes}`));
+    }
+    switch (node._tag) {
+      case "Recurs":
+        if (typeof node.count !== "number" || !Number.isInteger(node.count) || node.count < 0) {
+          return yield* Effect.fail(batonTurnPolicyInvalid("recurs count must be a non-negative integer"));
+        }
+        return { kind: "recurs", count: node.count };
+      case "UntilToolCall":
+        if (typeof node.name !== "string" || node.name.trim().length === 0) {
+          return yield* Effect.fail(batonTurnPolicyInvalid("until-tool-call name must not be blank"));
+        }
+        return { kind: "until-tool-call", name: node.name };
+      case "Both":
+        return {
+          kind: "both",
+          first: yield* visit(node.first, depth + 1),
+          second: yield* visit(node.second, depth + 1)
+        };
+      default:
+        return yield* Effect.fail(batonTurnPolicyInvalid("snapshot tag is not recognized"));
+    }
+  });
+  return yield* visit(snapshot, 1);
+});
+var turnPolicyFieldsFromRegisterInput = Effect.fn("Client.turnPolicyFieldsFromRegisterInput")(function* (input) {
+  if (input.max_tool_turns !== undefined)
+    return { max_tool_turns: input.max_tool_turns };
+  const snapshot = input.agent.policy.snapshot;
+  if (snapshot === undefined) {
+    return yield* Effect.fail(batonTurnPolicyInvalid("opaque policies require an explicit max_tool_turns replacement"));
+  }
+  const durable = yield* turnPolicySnapshotFromBaton(snapshot);
+  if (durable.kind === "recurs" && durable.count === exports_agent_schema.defaultMaxToolTurns)
+    return {};
+  if (durable.kind === "recurs" && durable.count > 0)
+    return { max_tool_turns: durable.count };
+  return { turn_policy: durable };
+});
+var registerAgentPayload = Effect.fn("Client.registerAgentPayload")(function* (input) {
+  if (!isRegisterBatonAgentInput(input))
+    return exports_agent_schema.define(input);
+  const name = yield* decodeBatonAgentName(input.agent.name);
+  const model = yield* modelSelectionFromRegisterInput(input);
+  const metadata = yield* metadataFromBatonAgent(input);
+  const turnPolicy = yield* turnPolicyFieldsFromRegisterInput(input);
+  return exports_agent_schema.define({
+    id: input.id,
+    name,
+    ...input.agent.instructions === undefined ? {} : { instructions: input.agent.instructions },
+    model,
+    tools: toolRefsFromBatonAgent(input.agent),
+    permissions: input.permissions ?? [],
+    ...input.skill_definition_ids === undefined ? {} : { skill_definition_ids: input.skill_definition_ids },
+    ...input.permission_rules === undefined ? {} : { permission_rules: input.permission_rules },
+    ...turnPolicy,
+    ...input.max_wait_turns === undefined ? {} : { max_wait_turns: input.max_wait_turns },
+    ...input.token_budget === undefined ? {} : { token_budget: input.token_budget },
+    ...input.child_run_presets === undefined ? {} : { child_run_presets: input.child_run_presets },
+    ...input.handoff_targets === undefined ? {} : { handoff_targets: input.handoff_targets },
+    ...input.output_schema_ref === undefined ? {} : { output_schema_ref: input.output_schema_ref },
+    ...metadata === undefined ? {} : { metadata }
+  });
+});
+var agentDefinitionNotFound = (id) => new ClientError({ message: `Agent not found: ${id}` });
+var wakeMetadata = (input) => ({
+  ...input.metadata,
+  ...input.from === undefined ? {} : { from: input.from },
+  ...input.content === undefined ? {} : { content: input.content },
+  ...input.correlation_key === undefined ? {} : { correlation_key: input.correlation_key }
+});
+var toPendingToolApproval = (record) => ({
+  wait_id: record.id,
+  execution_id: record.executionId,
+  tool_call_id: exports_ids_schema.ToolCallId.make(String(record.metadata.tool_call_id ?? "")),
+  tool_name: String(record.metadata.tool_name ?? ""),
+  input: record.metadata.input ?? null,
+  requested_at: record.createdAt
+});
+var isToolApprovalWait = (record) => record.metadata.kind === "tool-approval";
+var toToolAttempt = (record) => ({
+  attempt_id: record.id,
+  tool_call_id: record.callId,
+  attempt_number: record.attemptNumber,
+  state: record.state,
+  ...record.workerId === undefined ? {} : { worker_id: record.workerId },
+  ...record.claimExpiresAt === undefined ? {} : { claim_expires_at: record.claimExpiresAt },
+  ...record.error === undefined ? {} : { error: record.error },
+  created_at: record.createdAt,
+  ...record.completedAt === undefined ? {} : { completed_at: record.completedAt }
+});
+var toPendingToolCall = (record) => record.definition === undefined || record.waitId === undefined ? undefined : {
+  execution_id: record.executionId,
+  call: record.call,
+  definition: record.definition,
+  placement: record.placement,
+  state: record.state,
+  wait_id: record.waitId,
+  idempotency_key: record.idempotencyKey,
+  requested_at: record.createdAt
+};
+var toToolOutcomeAccepted = (accepted) => ({
+  tool_call_id: accepted.call.call.id,
+  attempt: toToolAttempt(accepted.attempt),
+  duplicate: accepted.duplicate
+});
+var toToolWorkLease = (lease) => ({
+  execution_id: lease.call.executionId,
+  call: lease.call.call,
+  definition: lease.call.definition,
+  placement: lease.call.placement,
+  attempt: toToolAttempt(lease.attempt),
+  queue: lease.queue,
+  worker_id: lease.workerId,
+  claim_expires_at: lease.claimExpiresAt,
+  idempotency_key: lease.idempotencyKey
+});
+var toolWaitId = (callId) => exports_ids_schema.WaitId.make(`wait:tool:${callId}`);
+var acceptedWaitOutcome = (wait) => Schema3.decodeUnknownEffect(exports_tool_schema.ExternalOutcome)(wait.metadata.external_outcome).pipe(Effect.mapError(toClientError));
+var resolveToolOutcomeWait = Effect.fn("Client.resolveToolOutcomeWait")(function* (waits, eventLog, call, outcome, completedAt) {
+  const waitId = call.waitId ?? toolWaitId(call.call.id);
+  const wait = yield* waits.get(waitId).pipe(Effect.mapError(toClientError));
+  if (wait === undefined)
+    return yield* new ClientError({ message: `Tool wait not found: ${waitId}` });
+  if (wait.executionId !== call.executionId) {
+    return yield* new ClientError({ message: `Tool wait does not match call: ${call.call.id}` });
+  }
+  if (wait.state === "resolved") {
+    const accepted = yield* acceptedWaitOutcome(wait);
+    if (exports_shared_schema.canonicalString(accepted) !== exports_shared_schema.canonicalString(outcome)) {
+      return yield* new ClientError({ message: `Tool outcome conflicts with accepted wait: ${call.call.id}` });
+    }
+    return wait;
+  }
+  if (wait.state !== "open") {
+    return yield* new ClientError({ message: `Tool wait is ${wait.state}: ${call.call.id}` });
+  }
+  const eventSequence = yield* nextEventSequence(eventLog, call.executionId);
+  const resolved = yield* waits.wake({
+    waitId,
+    resolvedAt: completedAt,
+    eventSequence,
+    metadata: { kind: "tool-placement", external_outcome: outcome }
+  }).pipe(Effect.mapError(toClientError));
+  if (!resolved.transitioned) {
+    const accepted = yield* acceptedWaitOutcome(resolved.wait);
+    if (exports_shared_schema.canonicalString(accepted) !== exports_shared_schema.canonicalString(outcome)) {
+      return yield* new ClientError({ message: `Tool outcome conflicts with accepted wait: ${call.call.id}` });
+    }
+  }
+  return resolved.wait;
+});
+var signalToolOutcome = Effect.fn("Client.signalToolOutcome")(function* (executionRepository, makeExecutionClient, wait, signaledAt) {
+  yield* exports_wait_signal.signalWorkflowWait({
+    makeExecutionClient,
+    executionId: wait.executionId,
+    waitId: wait.id,
+    state: "resolved",
+    signaledAt
+  }).pipe(Effect.provideService(exports_execution_repository.Service, executionRepository), Effect.mapError(toClientError));
+});
+var toReady = (record) => ({
+  id: record.id,
+  envelope_id: record.envelopeId,
+  route_key: record.routeKey,
+  available_at: record.availableAt,
+  attempt: record.attempt,
+  metadata: record.metadata
+});
+var toLease = (record) => ({
+  ready: toReady(record),
+  worker_id: record.claimOwner ?? "unclaimed",
+  claim_expires_at: record.claimExpiresAt ?? record.updatedAt
+});
+var nextEventSequence = Effect.fn("Client.nextEventSequence")(function* (eventLog, executionId) {
+  const max = yield* eventLog.maxSequence(executionId).pipe(Effect.mapError(toClientError));
+  return max === undefined ? 0 : max + 1;
+});
+var waitSemanticKind = (wait) => wait.mode === "child" ? "child" : typeof wait.metadata.kind === "string" && wait.metadata.kind.length > 0 ? wait.metadata.kind : "general";
+var terminalChildStatus = (metadata) => {
+  const status = metadata?.child_status;
+  return status === "completed" || status === "failed" || status === "cancelled";
+};
+var wakeRuntime = Effect.fn("Client.wakeRuntime")(function* (waits, eventLog, executionRepository, makeExecutionClient, input, accepts) {
+  const wait = yield* waits.get(input.wait_id).pipe(Effect.mapError(toClientError));
+  if (wait === undefined)
+    return yield* new ClientError({ message: `Wait not found: ${input.wait_id}` });
+  const kind = waitSemanticKind(wait);
+  if (accepts !== undefined && kind !== accepts) {
+    return yield* new WaitKindMismatch({
+      wait_id: input.wait_id,
+      expected: accepts,
+      actual: kind,
+      message: `Wait ${input.wait_id} is a ${kind} wait; this resolver mutates only ${accepts} waits`
+    });
+  }
+  if (accepts === undefined && kind === "child" && !terminalChildStatus(input.metadata)) {
+    return yield* new WaitKindMismatch({
+      wait_id: input.wait_id,
+      expected: 'child wake with terminal metadata.child_status ("completed" | "failed" | "cancelled")',
+      actual: kind,
+      message: `Wait ${input.wait_id} joins a child run; wake it with terminal metadata.child_status or let the child runtime complete it`
+    });
+  }
+  if (input.state === "cancelled" && wait.metadata.kind === "tool-placement") {
+    return yield* new ClientError({ message: "Tool placement waits must be cancelled through cancelExecution" });
+  }
+  const eventSequence = yield* nextEventSequence(eventLog, wait.executionId);
+  const result = input.state === "resolved" ? yield* waits.wake({
+    waitId: input.wait_id,
+    resolvedAt: input.signaled_at,
+    eventSequence,
+    metadata: wakeMetadata(input)
+  }).pipe(Effect.mapError(toClientError)) : input.state === "timed_out" ? yield* waits.timeout({
+    waitId: input.wait_id,
+    timedOutAt: input.signaled_at,
+    eventSequence,
+    metadata: wakeMetadata(input)
+  }).pipe(Effect.mapError(toClientError)) : yield* waits.cancel({
+    waitId: input.wait_id,
+    cancelledAt: input.signaled_at,
+    eventSequence,
+    metadata: wakeMetadata(input)
+  }).pipe(Effect.mapError(toClientError));
+  if (result.transitioned) {
+    yield* exports_wait_signal.signalWorkflowWait({
+      makeExecutionClient,
+      executionId: result.wait.executionId,
+      waitId: result.wait.id,
+      state: input.state,
+      signaledAt: input.signaled_at
+    }).pipe(Effect.provideService(exports_execution_repository.Service, executionRepository), Effect.mapError(toClientError));
+  }
+  return {
+    wait_id: result.wait.id,
+    state: input.state,
+    signaled_at: input.signaled_at
+  };
+});
+var childJoinWaitId = (childExecutionId) => exports_ids_schema.WaitId.make(`wait:child:${childExecutionId}`);
+var childSpawnFingerprintKey = "relay_child_spawn_fingerprint";
+var childExecutionIdForSpawn = (input) => input.child_execution_id ?? exports_ids_schema.ChildExecutionId.make(`${input.execution_id}:child:${input.address_id}`);
+var parentContextFromDefinition = (definition, fingerprint) => ({
+  ...definition.instructions === undefined ? {} : { instructions: definition.instructions },
+  model: definition.model,
+  tool_names: definition.tool_names,
+  permissions: definition.permissions.map((permission) => permission.name),
+  ...definition.output_schema_ref === undefined ? {} : { output_schema_ref: definition.output_schema_ref },
+  metadata: { ...definition.metadata, [childSpawnFingerprintKey]: fingerprint }
+});
+var internalSpawnChildRunInput = (input, pin, createdAt) => ({
+  execution_id: input.execution_id,
+  child_execution_id: childExecutionIdForSpawn(input),
+  address_id: input.address_id,
+  parent_context: parentContextFromDefinition(pin.agentSnapshot, exports_shared_schema.canonicalString(input)),
+  ...pin.agentSnapshot.child_run_presets === undefined ? {} : { presets: pin.agentSnapshot.child_run_presets },
+  ...input.preset_name === undefined ? {} : { preset_name: input.preset_name },
+  ...input.instructions === undefined ? {} : { instructions: input.instructions },
+  ...input.model === undefined ? {} : { model: input.model },
+  ...input.tool_names === undefined ? {} : { tool_names: input.tool_names },
+  ...input.permissions === undefined ? {} : { permissions: input.permissions },
+  ...input.workspace_policy === undefined ? {} : { workspace_policy: input.workspace_policy },
+  ...input.output_schema_ref === undefined ? {} : { output_schema_ref: input.output_schema_ref },
+  ...input.metadata === undefined ? {} : { metadata: input.metadata },
+  ...input.input === undefined ? {} : { input: input.input },
+  ...input.wait === undefined ? {} : { wait: input.wait },
+  created_at: createdAt
+});
+var childSpawnFingerprint = (record) => {
+  const parentMetadata = record.metadata.parent_metadata;
+  if (parentMetadata === null || typeof parentMetadata !== "object" || Array.isArray(parentMetadata))
+    return;
+  const fingerprint = parentMetadata[childSpawnFingerprintKey];
+  return typeof fingerprint === "string" ? fingerprint : undefined;
+};
+var createChildJoinWait = Effect.fn("Client.createChildJoinWait")(function* (waits, eventLog, input, accepted, createdAt) {
+  const waitId = childJoinWaitId(accepted.child_execution_id);
+  const eventSequence = yield* nextEventSequence(eventLog, input.execution_id);
+  yield* waits.createDetached({
+    waitId,
+    executionId: input.execution_id,
+    mode: "child",
+    correlationKey: accepted.child_execution_id,
+    metadata: {
+      parent_execution_id: input.execution_id,
+      child_execution_id: accepted.child_execution_id
+    },
+    eventSequence,
+    createdAt
+  }).pipe(Effect.mapError(toClientError));
+  return waitId;
+});
+var reconcileExistingChildSpawn = Effect.fn("Client.reconcileExistingChildSpawn")(function* (childExecutions, waits, eventLog, input) {
+  const childExecutionId = childExecutionIdForSpawn(input);
+  const existing = yield* childExecutions.get(childExecutionId).pipe(Effect.mapError(toClientError));
+  if (existing === undefined)
+    return;
+  if (existing.executionId !== input.execution_id || existing.addressId !== input.address_id || childSpawnFingerprint(existing) !== exports_shared_schema.canonicalString(input)) {
+    return yield* new ClientError({ message: `Child execution conflicts: ${childExecutionId}` });
+  }
+  const spawned = yield* eventLog.findByCursor({
+    executionId: input.execution_id,
+    cursor: `${input.execution_id}:child:${childExecutionId}:spawned`
+  }).pipe(Effect.mapError(toClientError));
+  if (Option.isNone(spawned)) {
+    return yield* new ClientError({ message: `Child spawn event missing: ${childExecutionId}` });
+  }
+  const parentWaitId = input.wait === true ? childJoinWaitId(childExecutionId) : undefined;
+  if (parentWaitId !== undefined) {
+    const wait = yield* waits.get(parentWaitId).pipe(Effect.mapError(toClientError));
+    if (wait === undefined) {
+      return yield* new ClientError({ message: `Child join wait missing: ${childExecutionId}` });
+    }
+  }
+  return {
+    accepted: { child_execution_id: childExecutionId, execution_id: input.execution_id },
+    createdAt: existing.createdAt,
+    parentWaitId
+  };
+});
+var parentDefinitionPin = Effect.fn("Client.parentDefinitionPin")(function* (executionRepository, executionId) {
+  const record = yield* executionRepository.get(executionId).pipe(Effect.mapError(toClientError));
+  if (record === undefined) {
+    return yield* new ClientError({ message: `Execution not found: ${executionId}` });
+  }
+  if (record.agentId === undefined || record.agentRevision === undefined || record.agentSnapshot === undefined) {
+    return yield* new ClientError({ message: `Parent execution is not pinned to an agent: ${executionId}` });
+  }
+  return {
+    agentId: record.agentId,
+    agentRevision: record.agentRevision,
+    agentSnapshot: record.agentSnapshot,
+    ...record.agentToolInputSchemaDigests === undefined ? {} : { agentToolInputSchemaDigests: record.agentToolInputSchemaDigests }
+  };
+});
+var childStartInput = (input, accepted, pin, definition, createdAt, parentWaitId) => ({
+  execution_id: exports_ids_schema.ExecutionId.make(accepted.child_execution_id),
+  root_address_id: input.address_id,
+  input: input.input === undefined ? [] : [...input.input],
+  event_sequence: 0,
+  started_at: createdAt,
+  completed_at: createdAt,
+  agent_id: pin.agentId,
+  agent_revision: pin.agentRevision,
+  agent_snapshot: definition,
+  ...pin.agentToolInputSchemaDigests === undefined ? {} : { agent_tool_input_schema_digests: pin.agentToolInputSchemaDigests },
+  metadata: {
+    parent_execution_id: input.execution_id,
+    child_execution_id: accepted.child_execution_id,
+    ...parentWaitId === undefined ? {} : { parent_wait_id: parentWaitId }
+  }
+});
+var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
+  const makeExecutionClient = yield* exports_execution_entity.client;
+  const executions = yield* exports_execution_service.Service;
+  const envelopes = yield* exports_envelope_service.Service;
+  const waits = yield* exports_wait_service.Service;
+  const eventLog = yield* exports_event_log_service.Service;
+  const sessionStream = yield* exports_session_stream_service.Service;
+  const executionWatch = yield* exports_execution_watch_service.Service;
+  const executionState = yield* exports_execution_state_service.Service;
+  const presence = yield* exports_presence_service.Service;
+  const envelopeReady = yield* exports_envelope_repository.Service;
+  const executionRepository = yield* exports_execution_repository.Service;
+  const inboxRepository = yield* exports_inbox_repository.Service;
+  const topicService = yield* exports_topic_service.Service;
+  const toolCalls = yield* exports_tool_call_repository.Service;
+  const childExecutions = yield* exports_child_execution_repository.Service;
+  const childFanOuts = yield* exports_child_fan_out_repository.Service;
+  const sessionRepository = yield* exports_session_repository.Service;
+  const steering = yield* exports_steering_repository.Service;
+  const agentRegistry = yield* exports_agent_registry_service.Service;
+  const entityRegistry = yield* exports_entity_registry_service.Service;
+  const entities = yield* exports_entity_instance_service.Service;
+  const addressBook = yield* exports_address_book_service.Service;
+  const sharding = yield* Sharding.Sharding;
+  const shardingConfig = yield* ShardingConfig.ShardingConfig;
+  const clusterRegistry = yield* exports_cluster_registry_repository.Service;
+  const schedules = yield* exports_schedule_repository.Service;
+  const skillRegistry = yield* exports_skill_registry_service.Service;
+  const toolTransitions = yield* exports_tool_transition_coordinator.Service;
+  const workflows = yield* exports_workflow_definition_repository.Service;
+  const workflowRuntime = yield* Effect.serviceOption(exports_definition_runtime.Service);
+  const childFanOutRuntime = yield* Effect.serviceOption(exports_child_fan_out_runtime.Service);
+  const schemaRegistry = yield* Effect.serviceOption(exports_schema_registry_service.Service);
+  const coordinateToolTransition = (effect) => toolTransitions.coordinate(effect).pipe(Effect.mapError(toClientError));
+  const coordinateChildSpawn = (effect) => toolTransitions.coordinate(effect).pipe(Effect.mapError(toClientError));
+  const cancelFanOut = Effect.fn("Client.runtime.cancelFanOut")(function* (input) {
+    if (Option.isSome(childFanOutRuntime)) {
+      const fanOut = yield* childFanOutRuntime.value.cancel(input.fan_out_id, input.cancelled_at, input.reason ?? "child fan-out cancelled").pipe(Effect.mapError(toClientError));
+      if (fanOut === undefined)
+        return yield* new ClientError({ message: `Child fan-out not found: ${input.fan_out_id}` });
+      return { fan_out: fanOut };
+    }
+    const result = yield* childFanOuts.cancel(input.fan_out_id, input.cancelled_at).pipe(Effect.mapError(toClientError));
+    if (result === undefined)
+      return yield* new ClientError({ message: `Child fan-out not found: ${input.fan_out_id}` });
+    yield* Effect.forEach(result.activeChildExecutionIds, (childId) => makeExecutionClient(exports_ids_schema.ExecutionId.make(childId)).cancel({
+      execution_id: exports_ids_schema.ExecutionId.make(childId),
+      cancelled_at: input.cancelled_at,
+      reason: input.reason ?? "child fan-out cancelled"
+    }).pipe(Effect.mapError(toClientError)), { discard: true });
+    if (result.transitioned) {
+      const max = yield* eventLog.maxSequence(result.fanOut.parent_execution_id).pipe(Effect.mapError(toClientError));
+      yield* exports_event_log_service.appendIdempotentTo(eventLog, {
+        id: exports_ids_schema.EventId.make(`event:${result.fanOut.parent_execution_id}:fan-out:${input.fan_out_id}:terminal`),
+        execution_id: result.fanOut.parent_execution_id,
+        type: "child_fan_out.terminal",
+        sequence: exports_execution_schema.ExecutionEventSequence.make(max === undefined ? 0 : max + 1),
+        cursor: `${result.fanOut.parent_execution_id}:fan-out:${input.fan_out_id}:terminal`,
+        data: { fan_out_id: input.fan_out_id, state: "cancelled" },
+        created_at: input.cancelled_at
+      }).pipe(Effect.mapError(toClientError));
+    }
+    return { fan_out: result.fanOut };
+  });
+  const sendEnvelope = Effect.fn("Client.runtime.send")(function* (input) {
+    const identity = input.idempotency_key ?? input.correlation_key ?? `${input.from}:${input.to}`;
+    const executionId = exports_ids_schema.ExecutionId.make(input.correlation_key ?? `execution:send:${identity}`);
+    const envelopeId = exports_ids_schema.EnvelopeId.make(`${executionId}:envelope:${identity}`);
+    const createdAt = yield* Clock.currentTimeMillis;
+    const maxSequence = yield* eventLog.maxSequence(executionId).pipe(Effect.mapError(toClientError));
+    return yield* envelopes.send({
+      envelopeId,
+      executionId,
+      input,
+      eventSequence: maxSequence === undefined ? 0 : maxSequence + 1,
+      createdAt
+    }).pipe(Effect.mapError(toClientError));
+  });
+  const waitOutcomeFrom = Effect.fn("Client.runtime.waitOutcome")(function* (wait) {
+    const reply = wait.state === "resolved" ? yield* envelopeReady.getEnvelope(exports_ids_schema.EnvelopeId.make(`envelope:reply:${wait.id}`)).pipe(Effect.mapError(toClientError)) : undefined;
+    return {
+      wait_id: wait.id,
+      state: wait.state,
+      ...reply === undefined ? {} : { content: reply.content },
+      ...Object.keys(wait.metadata).length === 0 ? {} : { metadata: wait.metadata }
+    };
+  });
+  const awaitWaitOperation = Effect.fn("Client.runtime.awaitWait")(function* (input) {
+    const current = yield* envelopeReady.getWait(input.wait_id).pipe(Effect.mapError(toClientError));
+    if (current === undefined) {
+      return yield* new ClientError({ message: `wait ${input.wait_id} not found` });
+    }
+    if (current.state !== "open")
+      return yield* waitOutcomeFrom(current);
+    yield* eventLog.stream({ executionId: input.execution_id }).pipe(Stream.filter((event) => (event.type === "wait.woken" || event.type === "wait.timed_out" || event.type === "wait.cancelled") && event.data?.wait_id === input.wait_id), Stream.take(1), Stream.runDrain, Effect.mapError(toClientError));
+    const terminal = yield* envelopeReady.getWait(input.wait_id).pipe(Effect.mapError(toClientError));
+    if (terminal === undefined || terminal.state === "open") {
+      return yield* new ClientError({ message: `wait ${input.wait_id} did not reach a terminal state` });
+    }
+    return yield* waitOutcomeFrom(terminal);
+  });
+  const getExecutionOperation = Effect.fn("Client.runtime.getExecution")(function* (id) {
+    const record = yield* executionRepository.get(id).pipe(Effect.mapError(toClientError));
+    return record === undefined ? undefined : toExecutionView(record);
+  });
+  const streamExecutionOperation = (input) => executions.stream({
+    executionId: input.execution_id,
+    ...input.after_cursor === undefined ? {} : { afterCursor: input.after_cursor },
+    ...input.limit === undefined ? {} : { limit: input.limit }
+  }).pipe(Stream.mapError(toStreamError));
+  const inspectExecutionOperation = Effect.fn("Client.runtime.inspectExecution")(function* (executionId) {
+    const execution = yield* executionRepository.get(executionId).pipe(Effect.mapError(toClientError));
+    if (execution === undefined)
+      return yield* new ExecutionNotFound({ execution_id: executionId });
+    const openWaits = yield* envelopeReady.listAllWaits({ executionId, state: "open" }).pipe(Effect.mapError(toClientError));
+    const calls = yield* toolCalls.listCalls(executionId).pipe(Effect.mapError(toClientError));
+    const pendingChunks = yield* Effect.forEach(calls, (call) => toolCalls.getResult(call.call.id).pipe(Effect.mapError(toClientError), Effect.map((result) => result === undefined ? [toToolCallSummary(call)] : [])));
+    const children = yield* childExecutions.listByExecution(executionId).pipe(Effect.mapError(toClientError));
+    const maxSequence = yield* eventLog.maxSequence(executionId).pipe(Effect.mapError(toClientError));
+    const lastEvent = maxSequence === undefined ? undefined : yield* eventLog.findBySequence({ executionId, sequence: maxSequence }).pipe(Effect.mapError(toClientError), Effect.map(Option.getOrUndefined));
+    return {
+      execution_id: execution.id,
+      status: execution.status,
+      waiting_on: openWaits.map(toWaitView),
+      pending_tool_calls: pendingChunks.flat(),
+      child_runs: children.map(toChildRunSummary),
+      ...lastEvent === undefined ? {} : { last_event_cursor: lastEvent.cursor }
+    };
+  });
+  return Service.of({
+    registerEntityKind: (input) => entityRegistry.registerKind(input).pipe(Effect.mapError(toClientError)),
+    getOrCreateEntity: (input) => entities.getOrCreate({
+      kind: input.kind,
+      key: input.key,
+      createdAt: input.created_at,
+      ...input.input === undefined ? {} : { input: input.input },
+      ...input.metadata === undefined ? {} : { metadata: input.metadata }
+    }).pipe(Effect.mapError(toClientError)),
+    getEntity: (input) => entities.get(input).pipe(Effect.mapError(toClientError)),
+    destroyEntity: (input) => entities.destroy({
+      kind: input.kind,
+      key: input.key,
+      destroyedAt: input.destroyed_at,
+      ...input.reason === undefined ? {} : { reason: input.reason }
+    }).pipe(Effect.mapError(toClientError)),
+    listEntities: (input) => entities.list({
+      ...input.kind === undefined ? {} : { kind: input.kind },
+      ...input.after_kind === undefined ? {} : { afterKind: input.after_kind },
+      ...input.after_key === undefined ? {} : { afterKey: input.after_key },
+      ...input.limit === undefined ? {} : { limit: input.limit }
+    }).pipe(Effect.mapError(toClientError)),
+    registerWorkflowDefinition: Effect.fn("Client.runtime.registerWorkflowDefinition")(function* (input) {
+      return { record: yield* workflows.register(input).pipe(Effect.mapError(toClientError)) };
+    }),
+    getWorkflowDefinitionRevision: Effect.fn("Client.runtime.getWorkflowDefinitionRevision")(function* (id, revision) {
+      return yield* workflows.get(id, revision).pipe(Effect.mapError(toClientError));
+    }),
+    listWorkflowDefinitionRevisions: Effect.fn("Client.runtime.listWorkflowDefinitionRevisions")(function* (id) {
+      return { records: yield* workflows.list(id).pipe(Effect.mapError(toClientError)) };
+    }),
+    startWorkflowRun: Effect.fn("Client.runtime.startWorkflowRun")(function* (input) {
+      return yield* Option.match(workflowRuntime, {
+        onNone: () => workflows.start(input),
+        onSome: (runtime) => runtime.start(input)
+      }).pipe(Effect.mapError(toClientError));
+    }),
+    inspectWorkflowRun: Effect.fn("Client.runtime.inspectWorkflowRun")(function* (id) {
+      return yield* Option.match(workflowRuntime, {
+        onNone: () => workflows.inspect(id),
+        onSome: (runtime) => runtime.inspect(id)
+      }).pipe(Effect.mapError(toClientError));
+    }),
+    replayWorkflowRun: Effect.fn("Client.runtime.replayWorkflowRun")(function* (id) {
+      return yield* Option.match(workflowRuntime, {
+        onNone: () => workflows.listLifecycle(id),
+        onSome: (runtime) => runtime.replay(id)
+      }).pipe(Effect.mapError(toClientError));
+    }),
+    cancelWorkflowRun: Effect.fn("Client.runtime.cancelWorkflowRun")(function* (id) {
+      return yield* Option.match(workflowRuntime, {
+        onNone: () => workflows.cancel(id),
+        onSome: (runtime) => runtime.cancel(id)
+      }).pipe(Effect.mapError(toClientError));
+    }),
+    registerAgent: Effect.fn("Client.runtime.registerAgent")(function* (input) {
+      const payload = yield* registerAgentPayload(input);
+      const registered = yield* agentRegistry.register(payload).pipe(Effect.mapError(toClientError));
+      if (input.address !== undefined) {
+        yield* addressBook.register(input.address, { kind: "local-agent", route_key: payload.id }).pipe(Effect.mapError(toClientError));
+      }
+      return registered;
+    }),
+    registerAgentDefinition: Effect.fn("Client.runtime.registerAgentDefinition")(function* (input) {
+      return yield* agentRegistry.register(input).pipe(Effect.mapError(toClientError));
+    }),
+    getAgentDefinition: Effect.fn("Client.runtime.getAgentDefinition")(function* (id) {
+      return yield* agentRegistry.get(id).pipe(Effect.mapError(toClientError));
+    }),
+    listAgentDefinitions: Effect.fn("Client.runtime.listAgentDefinitions")(function* () {
+      return yield* agentRegistry.list().pipe(Effect.mapError(toClientError));
+    }),
+    listAgentDefinitionRevisions: Effect.fn("Client.runtime.listAgentDefinitionRevisions")(function* (id) {
+      return yield* agentRegistry.listRevisions(id).pipe(Effect.mapError(toClientError));
+    }),
+    getSkillDefinition: Effect.fn("Client.runtime.getSkillDefinition")(function* (id) {
+      return yield* skillRegistry.get(id).pipe(Effect.mapError(toClientError));
+    }),
+    listSkillDefinitions: Effect.fn("Client.runtime.listSkillDefinitions")(function* () {
+      return yield* skillRegistry.list().pipe(Effect.mapError(toClientError));
+    }),
+    listSkillDefinitionRevisions: Effect.fn("Client.runtime.listSkillDefinitionRevisions")(function* (id) {
+      return yield* skillRegistry.listRevisions(id).pipe(Effect.mapError(toClientError));
+    }),
+    registerAddressBookRoute: Effect.fn("Client.runtime.registerAddressBookRoute")(function* (input) {
+      yield* rejectReserved(input.address_id, "address:entity:");
+      return yield* addressBook.register(input.address_id, input.route).pipe(Effect.mapError(toClientError));
+    }),
+    getAddressBookRoute: Effect.fn("Client.runtime.getAddressBookRoute")(function* (id) {
+      return yield* addressBook.get(id).pipe(Effect.mapError(toClientError));
+    }),
+    listAddressBookRoutes: Effect.fn("Client.runtime.listAddressBookRoutes")(function* () {
+      return yield* addressBook.list().pipe(Effect.mapError(toClientError));
+    }),
+    startExecution: Effect.fn("Client.runtime.startExecution")(function* (input) {
+      yield* rejectReserved(input.execution_id, "execution:entity:");
+      if (input.session_id !== undefined)
+        yield* rejectReserved(input.session_id, "session:entity:");
+      const client = makeExecutionClient(input.execution_id);
+      return yield* client.start(input).pipe(Effect.mapError(toClientError));
+    }),
+    startExecutionByAddress: Effect.fn("Client.runtime.startExecutionByAddress")(function* (input) {
+      yield* rejectReserved(input.idempotency_key, "entity:");
+      if (input.execution_id !== undefined)
+        yield* rejectReserved(input.execution_id, "execution:entity:");
+      if (input.session_id !== undefined)
+        yield* rejectReserved(input.session_id, "session:entity:");
+      const payload = startExecutionByAddressPayload(input);
+      const client = makeExecutionClient(payload.execution_id);
+      return yield* client.start(payload).pipe(Effect.mapError(toClientError));
+    }),
+    startExecutionByAgentDefinition: Effect.fn("Client.runtime.startExecutionByAgentDefinition")(function* (input) {
+      yield* rejectReserved(input.idempotency_key, "entity:");
+      if (input.execution_id !== undefined)
+        yield* rejectReserved(input.execution_id, "execution:entity:");
+      if (input.session_id !== undefined)
+        yield* rejectReserved(input.session_id, "session:entity:");
+      const definition = yield* agentRegistry.get(input.agent_id).pipe(Effect.mapError(toClientError));
+      if (definition === undefined)
+        return yield* Effect.fail(agentDefinitionNotFound(input.agent_id));
+      const payload = startExecutionByAgentDefinitionPayload(input, definition);
+      const client = makeExecutionClient(payload.execution_id);
+      return yield* client.start(payload).pipe(Effect.mapError(toClientError));
+    }),
+    cancelExecution: Effect.fn("Client.runtime.cancelExecution")(function* (input) {
+      const fanOuts = yield* childFanOuts.listNonTerminal(input.execution_id).pipe(Effect.mapError(toClientError));
+      yield* Effect.forEach(fanOuts, (fanOut) => cancelFanOut({
+        fan_out_id: fanOut.fan_out_id,
+        cancelled_at: input.cancelled_at,
+        ...input.reason === undefined ? {} : { reason: input.reason }
+      }), { discard: true });
+      const client = makeExecutionClient(input.execution_id);
+      return yield* client.cancel({
+        execution_id: input.execution_id,
+        cancelled_at: input.cancelled_at,
+        ...input.reason === undefined ? {} : { reason: input.reason }
+      }).pipe(Effect.mapError(toClientError));
+    }),
+    steer: Effect.fn("Client.runtime.steer")(function* (input) {
+      const execution = yield* executionRepository.get(input.execution_id).pipe(Effect.mapError(toClientError));
+      if (execution === undefined) {
+        return yield* new ClientError({ message: `Execution not found: ${input.execution_id}` });
+      }
+      if (execution.status !== "running") {
+        return yield* new ClientError({ message: `Execution is not running: ${input.execution_id}` });
+      }
+      const record = yield* steering.appendForRunning({
+        executionId: input.execution_id,
+        kind: input.kind,
+        content: input.content,
+        createdAt: input.created_at
+      }).pipe(Effect.mapError(toClientError));
+      return { execution_id: record.executionId, kind: record.kind, sequence: record.sequence };
+    }),
+    getExecution: getExecutionOperation,
+    inspectExecution: inspectExecutionOperation,
+    followExecution: followExecutionFrom({
+      getExecution: getExecutionOperation,
+      inspectExecution: inspectExecutionOperation,
+      streamExecution: streamExecutionOperation
+    }),
+    listWaits: Effect.fn("Client.runtime.listWaits")(function* (input) {
+      const records = yield* envelopeReady.listWaits({
+        ...input.state === undefined ? {} : { state: input.state },
+        ...input.execution_id === undefined ? {} : { executionId: input.execution_id },
+        ...input.limit === undefined ? {} : { limit: input.limit }
+      }).pipe(Effect.mapError(toClientError));
+      return records.map(toWaitView);
+    }),
+    listExecutions: Effect.fn("Client.runtime.listExecutions")(function* (input) {
+      const cursor = input.cursor === undefined ? undefined : yield* Schema3.decodeEffect(ExecutionCursorFromString)(input.cursor).pipe(Effect.mapError(toClientError));
+      const result = yield* executionRepository.list({
+        ...input.root_address_id === undefined ? {} : { rootAddressId: input.root_address_id },
+        ...input.status === undefined ? {} : { status: input.status },
+        ...input.limit === undefined ? {} : { limit: input.limit },
+        ...cursor === undefined ? {} : { cursor }
+      }).pipe(Effect.mapError(toClientError));
+      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema3.encodeEffect(ExecutionCursorFromString)(result.nextCursor).pipe(Effect.mapError(toClientError));
+      return {
+        records: result.records.map(toConversationSummary),
+        ...nextCursor === undefined ? {} : { next_cursor: nextCursor }
+      };
+    }),
+    subscribeTopic: Effect.fn("Client.runtime.subscribeTopic")(function* (input) {
+      return yield* topicService.subscribe({
+        topicAddressId: input.topic_address_id,
+        subscriberExecutionId: input.subscriber_execution_id,
+        ...input.metadata === undefined ? {} : { metadata: input.metadata }
+      }).pipe(Effect.mapError(toClientError));
+    }),
+    unsubscribeTopic: Effect.fn("Client.runtime.unsubscribeTopic")(function* (input) {
+      return yield* topicService.unsubscribe({
+        topicAddressId: input.topic_address_id,
+        subscriberExecutionId: input.subscriber_execution_id
+      }).pipe(Effect.mapError(toClientError));
+    }),
+    publishTopic: Effect.fn("Client.runtime.publishTopic")(function* (input) {
+      return yield* topicService.publish({
+        topicAddressId: input.topic_address_id,
+        from: input.from,
+        content: input.content,
+        ...input.metadata === undefined ? {} : { metadata: input.metadata },
+        ...input.idempotency_key === undefined ? {} : { idempotencyKey: input.idempotency_key }
+      }).pipe(Effect.mapError(toClientError));
+    }),
+    listTopicSubscriptions: Effect.fn("Client.runtime.listTopicSubscriptions")(function* (input) {
+      return yield* topicService.list({
+        ...input.topic_address_id === undefined ? {} : { topicAddressId: input.topic_address_id },
+        ...input.subscriber_execution_id === undefined ? {} : { subscriberExecutionId: input.subscriber_execution_id }
+      }).pipe(Effect.mapError(toClientError));
+    }),
+    listInboxMessages: Effect.fn("Client.runtime.listInboxMessages")(function* (input) {
+      return yield* inboxRepository.list({
+        executionId: input.execution_id,
+        ...input.include_consumed === undefined ? {} : { includeConsumed: input.include_consumed },
+        ...input.after_sequence === undefined ? {} : { afterSequence: input.after_sequence },
+        ...input.limit === undefined ? {} : { limit: input.limit }
+      }).pipe(Effect.mapError(toClientError));
+    }),
+    listSessions: Effect.fn("Client.runtime.listSessions")(function* (input) {
+      const cursor = input.cursor === undefined ? undefined : yield* Schema3.decodeEffect(SessionCursorFromString)(input.cursor).pipe(Effect.mapError(toClientError));
+      const result = yield* sessionRepository.list({
+        ...input.root_address_id === undefined ? {} : { rootAddressId: input.root_address_id },
+        ...input.limit === undefined ? {} : { limit: input.limit },
+        ...cursor === undefined ? {} : { cursor }
+      }).pipe(Effect.mapError(toClientError));
+      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema3.encodeEffect(SessionCursorFromString)(result.nextCursor).pipe(Effect.mapError(toClientError));
+      return {
+        records: result.records.map(toSessionSummary),
+        ...nextCursor === undefined ? {} : { next_cursor: nextCursor }
+      };
+    }),
+    getSession: Effect.fn("Client.runtime.getSession")(function* (input) {
+      const session = yield* sessionRepository.get(input.session_id).pipe(Effect.mapError(toClientError));
+      if (session === undefined)
+        return yield* new ClientError({ message: `Session not found: ${input.session_id}` });
+      const cursor = input.cursor === undefined ? undefined : yield* Schema3.decodeEffect(ExecutionCursorFromString)(input.cursor).pipe(Effect.mapError(toClientError));
+      const result = yield* executionRepository.list({
+        sessionId: input.session_id,
+        ...input.limit === undefined ? {} : { limit: input.limit },
+        ...cursor === undefined ? {} : { cursor }
+      }).pipe(Effect.mapError(toClientError));
+      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema3.encodeEffect(ExecutionCursorFromString)(result.nextCursor).pipe(Effect.mapError(toClientError));
+      return {
+        session: toSessionSummary(session),
+        executions: result.records.map(toConversationSummary),
+        ...nextCursor === undefined ? {} : { next_cursor: nextCursor }
+      };
+    }),
+    replayExecution: Effect.fn("Client.runtime.replayExecution")(function* (input) {
+      const events = yield* eventLog.replay({
+        executionId: input.execution_id,
+        ...input.after_cursor === undefined ? {} : { afterCursor: input.after_cursor },
+        ...input.limit === undefined ? {} : { limit: input.limit }
+      }).pipe(Effect.mapError(toClientError));
+      return { events };
+    }),
+    listRunners: Effect.fn("Client.runtime.listRunners")(function* () {
+      const runners = yield* clusterRegistry.listRunners().pipe(Effect.mapError(toClientError));
+      return {
+        runners: runners.map((runner) => ({
+          address: runner.address,
+          healthy: runner.healthy,
+          last_heartbeat: runner.lastHeartbeat,
+          owned_shards: runner.ownedShards
+        })),
+        total_shards: shardingConfig.shardsPerGroup * shardingConfig.availableShardGroups.length
+      };
+    }),
+    routeExecution: Effect.fn("Client.runtime.routeExecution")(function* (executionId) {
+      const shard = ShardId.toString(sharding.getShardId(EntityId.make(executionId), "execution"));
+      const owner = yield* clusterRegistry.lockOwner(shard).pipe(Effect.mapError(toClientError));
+      const runnerAddress = owner ?? null;
+      const self = Option.map(shardingConfig.runnerAddress, (address) => `${address.host}:${address.port}`);
+      return {
+        execution_id: executionId,
+        shard,
+        runner_address: runnerAddress,
+        owned: runnerAddress !== null && Option.getOrNull(self) === runnerAddress
+      };
+    }),
+    send: sendEnvelope,
+    askEntity: Effect.fn("Client.runtime.askEntity")(function* (input) {
+      const instance = yield* entities.get({ kind: input.kind, key: input.key }).pipe(Effect.mapError(toClientError));
+      if (instance === undefined || instance.status === "destroyed") {
+        return yield* new EntityNotFound({ kind: input.kind, key: input.key });
+      }
+      const encoded = yield* Schema3.encodeUnknownEffect(input.command.input)(input.input).pipe(Effect.mapError(toClientError));
+      const inputRef = inputSchemaRef(input.command.name);
+      const outputRef = outputSchemaRef(input.command.name);
+      if (Option.isSome(schemaRegistry)) {
+        yield* schemaRegistry.value.register({ ref: inputRef, schema: input.command.input });
+        yield* schemaRegistry.value.register({ ref: outputRef, schema: input.command.output });
+      }
+      const correlation = `command:${input.command.name}:${globalThis.crypto.randomUUID()}`;
+      const accepted = yield* sendEnvelope({
+        from: input.from,
+        to: instance.address_id,
+        content: [{ type: "structured", value: encoded, schema_ref: inputRef }],
+        idempotency_key: correlation,
+        wait: {
+          mode: "reply",
+          correlation_key: correlation,
+          ...input.timeout === undefined ? {} : { timeout: input.timeout }
+        },
+        metadata: {
+          ...input.metadata,
+          command: input.command.name,
+          command_input_schema_ref: inputRef,
+          command_output_schema_ref: outputRef
+        }
+      });
+      if (accepted.wait_id === undefined) {
+        return yield* new ClientError({ message: "askEntity send did not create a reply wait" });
+      }
+      const outcome = yield* awaitWaitOperation({ wait_id: accepted.wait_id, execution_id: accepted.execution_id });
+      if (outcome.state === "timed_out") {
+        return yield* new CommandTimedOut({
+          command: input.command.name,
+          wait_id: outcome.wait_id,
+          timeout: input.timeout ?? "unspecified"
+        });
+      }
+      if (outcome.state === "cancelled") {
+        return yield* new ClientError({ message: `reply wait ${outcome.wait_id} was cancelled` });
+      }
+      const replyValue = replyValueFrom(outcome.content);
+      if (replyValue._tag === "None") {
+        return yield* new CommandReplyInvalid({
+          command: input.command.name,
+          wait_id: outcome.wait_id,
+          message: "reply carried no decodable content"
+        });
+      }
+      return yield* Schema3.decodeUnknownEffect(input.command.output)(replyValue.value).pipe(Effect.mapError((issue) => new CommandReplyInvalid({
+        command: input.command.name,
+        wait_id: outcome.wait_id,
+        message: errorMessage(issue)
+      })));
+    }),
+    awaitWait: awaitWaitOperation,
+    streamExecution: streamExecutionOperation,
+    streamSession: (input) => sessionStream.stream({
+      sessionId: input.session_id,
+      ...input.resume === undefined ? {} : {
+        resume: input.resume.map((item) => ({
+          executionId: item.execution_id,
+          ...item.after_cursor === undefined ? {} : { afterCursor: item.after_cursor }
+        }))
+      }
+    }).pipe(Stream.map((item) => item._tag === "execution_joined" ? { _tag: "execution_joined", execution: toConversationSummary(item.record) } : item), Stream.mapError(toStreamError)),
+    watchExecutions: (input) => executionWatch.watch({
+      ...input.root_address_id === undefined ? {} : { rootAddressId: input.root_address_id },
+      ...input.session_id === undefined ? {} : { sessionId: input.session_id },
+      ...input.status === undefined ? {} : { status: input.status },
+      ...input.limit === undefined ? {} : { limit: input.limit }
+    }).pipe(Stream.mapEffect((change) => change._tag === "snapshot" ? change.nextCursor === undefined ? Effect.succeed({
+      _tag: "snapshot",
+      records: change.records.map(toConversationSummary)
+    }) : encodeExecutionCursor(change.nextCursor).pipe(Effect.map((next_cursor) => ({
+      _tag: "snapshot",
+      records: change.records.map(toConversationSummary),
+      next_cursor
+    }))) : Effect.succeed({
+      _tag: "upsert",
+      record: toConversationSummary(change.record)
+    })), Stream.mapError(toClientError)),
+    getEntityState: Effect.fn("Client.runtime.getEntityState")((input) => executionState.getRecord(input.execution_id, input.key).pipe(Effect.mapError(toClientError))),
+    putEntityState: Effect.fn("Client.runtime.putEntityState")((input) => executionState.put({
+      executionId: input.execution_id,
+      key: exports_execution_state_service.key(input.key, exports_shared_schema.JsonValue),
+      value: input.value,
+      ...input.expected_version === undefined ? {} : { expectedVersion: input.expected_version },
+      ...input.idempotency_key === undefined ? {} : { idempotencyKey: input.idempotency_key },
+      updatedAt: input.updated_at
+    }).pipe(Effect.mapError((error) => error instanceof exports_execution_state_service.StateVersionConflict ? error : toClientError(error)))),
+    deleteEntityState: Effect.fn("Client.runtime.deleteEntityState")((input) => executionState.remove({
+      executionId: input.execution_id,
+      key: input.key,
+      ...input.expected_version === undefined ? {} : { expectedVersion: input.expected_version },
+      ...input.idempotency_key === undefined ? {} : { idempotencyKey: input.idempotency_key },
+      removedAt: input.removed_at
+    }).pipe(Effect.mapError((error) => error instanceof exports_execution_state_service.StateVersionConflict ? error : toClientError(error)))),
+    listEntityState: Effect.fn("Client.runtime.listEntityState")((input) => executionState.list({
+      executionId: input.execution_id,
+      ...input.prefix === undefined ? {} : { prefix: input.prefix },
+      ...input.after_key === undefined ? {} : { afterKey: input.after_key },
+      ...input.limit === undefined ? {} : { limit: input.limit }
+    }).pipe(Effect.mapError(toClientError))),
+    getPresence: (scope) => presence.list(scope).pipe(Effect.mapError(toClientError)),
+    watchPresence: (scope) => presence.watch(scope).pipe(Stream.mapError(toClientError)),
+    wake: Effect.fn("Client.runtime.wake")(function* (input) {
+      return yield* wakeRuntime(waits, eventLog, executionRepository, makeExecutionClient, input);
+    }),
+    listPendingApprovals: Effect.fn("Client.runtime.listPendingApprovals")(function* (input) {
+      const records = yield* envelopeReady.listWaits({ executionId: input.execution_id, state: "open" }).pipe(Effect.mapError(toClientError));
+      return { approvals: records.filter(isToolApprovalWait).map(toPendingToolApproval) };
+    }),
+    resolveToolApproval: Effect.fn("Client.runtime.resolveToolApproval")(function* (input) {
+      return yield* wakeRuntime(waits, eventLog, executionRepository, makeExecutionClient, {
+        wait_id: input.wait_id,
+        state: "resolved",
+        signaled_at: input.resolved_at,
+        metadata: {
+          approved: input.approved,
+          ...input.comment === undefined ? {} : { comment: input.comment }
+        }
+      }, "tool-approval");
+    }),
+    resolvePermission: Effect.fn("Client.runtime.resolvePermission")(function* (input) {
+      return yield* wakeRuntime(waits, eventLog, executionRepository, makeExecutionClient, {
+        wait_id: input.wait_id,
+        state: "resolved",
+        signaled_at: input.resolved_at,
+        metadata: {
+          answer: input.answer,
+          ...input.reason === undefined ? {} : { reason: input.reason }
+        }
+      }, "tool-permission");
+    }),
+    listPendingToolCalls: Effect.fn("Client.runtime.listPendingToolCalls")(function* (input) {
+      const openWaits = yield* envelopeReady.listAllWaits({
+        state: "open",
+        ...input.execution_id === undefined ? {} : { executionId: input.execution_id }
+      }).pipe(Effect.mapError(toClientError));
+      const records = yield* Effect.forEach(openWaits.filter((wait) => wait.metadata.kind === "tool-placement"), (wait) => toolCalls.getCall(exports_ids_schema.ToolCallId.make(String(wait.metadata.tool_call_id ?? ""))).pipe(Effect.mapError(toClientError), Effect.map((call) => call?.placement.kind === "client" && call.state === "waiting" ? toPendingToolCall(call) : undefined)));
+      const sorted = records.filter((record) => record !== undefined).toSorted((left, right) => left.requested_at - right.requested_at || left.call.id.localeCompare(right.call.id));
+      return { tool_calls: input.limit === undefined ? sorted : sorted.slice(0, input.limit) };
+    }),
+    fulfillToolCall: Effect.fn("Client.runtime.fulfillToolCall")(function* (input) {
+      const coordinated = yield* coordinateToolTransition(Effect.gen(function* () {
+        const call = yield* toolCalls.getCall(input.tool_call_id).pipe(Effect.mapError(toClientError));
+        if (call === undefined || call.executionId !== input.execution_id || call.placement.kind !== "client") {
+          return yield* new ClientError({ message: `Client tool call not found: ${input.tool_call_id}` });
+        }
+        const wait = yield* resolveToolOutcomeWait(waits, eventLog, call, input.outcome, input.fulfilled_at);
+        const accepted = yield* toolCalls.acceptClientOutcome({
+          executionId: input.execution_id,
+          callId: input.tool_call_id,
+          outcome: input.outcome,
+          submittedAt: input.fulfilled_at
+        }).pipe(Effect.mapError(toClientError));
+        return { wait, accepted };
+      }));
+      yield* signalToolOutcome(executionRepository, makeExecutionClient, coordinated.wait, input.fulfilled_at);
+      return toToolOutcomeAccepted(coordinated.accepted);
+    }),
+    claimToolWork: Effect.fn("Client.runtime.claimToolWork")(function* (input) {
+      const lease = yield* coordinateToolTransition(toolCalls.claimRemote({
+        queue: input.queue,
+        workerId: input.worker_id,
+        now: input.now,
+        claimExpiresAt: input.claim_expires_at
+      }).pipe(Effect.mapError(toClientError)));
+      return lease === undefined ? null : toToolWorkLease(lease);
+    }),
+    completeToolWork: Effect.fn("Client.runtime.completeToolWork")(function* (input) {
+      const coordinated = yield* coordinateToolTransition(Effect.gen(function* () {
+        const call = yield* toolCalls.getCall(input.tool_call_id).pipe(Effect.mapError(toClientError));
+        const active = call !== undefined && call.placement.kind === "remote" && call.state === "running" && call.activeAttemptId === input.attempt_id && call.claimOwner === input.worker_id && call.claimExpiresAt !== undefined && call.claimExpiresAt > input.completed_at;
+        const acceptedRetry = call !== undefined && call.placement.kind === "remote" && call.state === "submitted" && call.activeAttemptId === input.attempt_id && call.externalOutcome !== undefined;
+        if (call === undefined || !active && !acceptedRetry) {
+          return yield* new ClientError({ message: `Remote tool claim is not active: ${input.tool_call_id}` });
+        }
+        const wait = yield* resolveToolOutcomeWait(waits, eventLog, call, input.outcome, input.completed_at);
+        const accepted = yield* toolCalls.acceptRemoteOutcome({
+          callId: input.tool_call_id,
+          attemptId: input.attempt_id,
+          workerId: input.worker_id,
+          outcome: input.outcome,
+          submittedAt: input.completed_at
+        }).pipe(Effect.mapError(toClientError));
+        return { wait, accepted };
+      }));
+      yield* signalToolOutcome(executionRepository, makeExecutionClient, coordinated.wait, input.completed_at);
+      return toToolOutcomeAccepted(coordinated.accepted);
+    }),
+    releaseToolWork: Effect.fn("Client.runtime.releaseToolWork")(function* (input) {
+      const call = yield* coordinateToolTransition(toolCalls.releaseRemote({
+        callId: input.tool_call_id,
+        attemptId: input.attempt_id,
+        workerId: input.worker_id,
+        releasedAt: input.released_at,
+        nextAvailableAt: input.next_available_at,
+        ...input.error === undefined ? {} : { error: input.error }
+      }).pipe(Effect.mapError(toClientError)));
+      return {
+        tool_call_id: call.call.id,
+        state: "waiting",
+        next_available_at: call.availableAt
+      };
+    }),
+    listToolAttempts: Effect.fn("Client.runtime.listToolAttempts")(function* (input) {
+      const attempts = yield* toolCalls.listAttempts(input.tool_call_id).pipe(Effect.mapError(toClientError));
+      return { attempts: attempts.map(toToolAttempt) };
+    }),
+    submitInboundEnvelope: Effect.fn("Client.runtime.submitInboundEnvelope")(function* (input) {
+      const envelope = yield* executions.send(input.envelope).pipe(Effect.mapError(toClientError));
+      const wakeResult = yield* wakeRuntime(waits, eventLog, executionRepository, makeExecutionClient, input.wake);
+      return { envelope, wake: wakeResult };
+    }),
+    spawnChildRun: Effect.fn("Client.runtime.spawnChildRun")(function* (input) {
+      const pin = yield* parentDefinitionPin(executionRepository, input.execution_id);
+      const createdAt = yield* Clock.currentTimeMillis;
+      const internal = internalSpawnChildRunInput(input, pin, createdAt);
+      const context = yield* exports_child_run_service.resolveForDispatch(internal).pipe(Effect.mapError((error) => new ClientError({ message: error._tag })));
+      const definition = yield* exports_child_run_service.childDefinition(pin.agentSnapshot, context).pipe(Effect.mapError((error) => new ClientError({ message: error._tag })));
+      const coordinated = yield* coordinateChildSpawn(Effect.gen(function* () {
+        const existing = yield* reconcileExistingChildSpawn(childExecutions, waits, eventLog, input);
+        if (existing !== undefined)
+          return existing;
+        const accepted = yield* executions.spawnChildRun(internal).pipe(Effect.mapError(toClientError));
+        const parentWaitId = input.wait === true ? yield* createChildJoinWait(waits, eventLog, internal, accepted, createdAt) : undefined;
+        return { accepted, createdAt, parentWaitId };
+      })).pipe(Effect.catch((error) => error.message === "DuplicateChildExecution" ? coordinateChildSpawn(reconcileExistingChildSpawn(childExecutions, waits, eventLog, input).pipe(Effect.flatMap((existing) => existing === undefined ? Effect.fail(new ClientError({ message: `Child execution retry missing: ${input.execution_id}` })) : Effect.succeed(existing)))) : Effect.fail(error)));
+      const startPayload = childStartInput(internal, coordinated.accepted, pin, definition, coordinated.createdAt, coordinated.parentWaitId);
+      const client = makeExecutionClient(startPayload.execution_id);
+      yield* client.dispatch(startPayload).pipe(Effect.mapError(toClientError));
+      return coordinated.accepted;
+    }),
+    createChildFanOut: Effect.fn("Client.runtime.createChildFanOut")(function* (input) {
+      return yield* Option.match(childFanOutRuntime, {
+        onNone: () => childFanOuts.create(input),
+        onSome: (runtime) => runtime.create(input)
+      }).pipe(Effect.mapError(toClientError));
+    }),
+    cancelChildFanOut: Effect.fn("Client.runtime.cancelChildFanOut")(function* (input) {
+      return yield* cancelFanOut(input);
+    }),
+    inspectChildFanOut: Effect.fn("Client.runtime.inspectChildFanOut")(function* (input) {
+      const fanOut = yield* Option.match(childFanOutRuntime, {
+        onNone: () => childFanOuts.get(input.fan_out_id),
+        onSome: (runtime) => runtime.inspect(input.fan_out_id)
+      }).pipe(Effect.mapError(toClientError));
+      return { fan_out: fanOut ?? null };
+    }),
+    claimEnvelopeReady: Effect.fn("Client.runtime.claimEnvelopeReady")(function* (input) {
+      return yield* envelopeReady.claimReady({
+        routeType: input.route_type,
+        ...input.route_key === undefined ? {} : { routeKey: input.route_key },
+        workerId: input.worker_id,
+        now: input.now,
+        claimExpiresAt: input.claim_expires_at
+      }).pipe(Effect.map((record) => record === undefined ? null : toLease(record)), Effect.mapError(toClientError));
+    }),
+    ackEnvelopeReady: Effect.fn("Client.runtime.ackEnvelopeReady")(function* (input) {
+      return yield* envelopeReady.ackReady({
+        id: input.envelope_ready_id,
+        workerId: input.worker_id,
+        now: input.acknowledged_at
+      }).pipe(Effect.map((record) => ({
+        envelope_ready_id: record.id,
+        state: "acknowledged",
+        acknowledged_at: record.acknowledgedAt ?? input.acknowledged_at
+      })), Effect.mapError(toClientError));
+    }),
+    releaseEnvelopeReady: Effect.fn("Client.runtime.releaseEnvelopeReady")(function* (input) {
+      return yield* envelopeReady.releaseReady({
+        id: input.envelope_ready_id,
+        workerId: input.worker_id,
+        nextAvailableAt: input.next_available_at,
+        ...input.error === undefined ? {} : { error: input.error }
+      }).pipe(Effect.map((record) => ({
+        envelope_ready_id: record.id,
+        state: "ready",
+        next_available_at: record.availableAt
+      })), Effect.mapError(toClientError));
+    }),
+    createSchedule: Effect.fn("Client.runtime.createSchedule")(function* (input) {
+      if (input.cron_expr !== undefined) {
+        yield* exports_scheduler_service.parseCron(input.cron_expr).pipe(Effect.mapError(toClientError));
+      }
+      const createdAt = yield* Clock.currentTimeMillis;
+      const schedule = yield* schedules.create({
+        id: input.schedule_id,
+        kind: input.kind,
+        targetKind: input.target_kind,
+        nextRunAt: input.next_run_at,
+        createdAt,
+        ...input.address_id === undefined ? {} : { addressId: input.address_id },
+        ...input.wait_id === undefined ? {} : { waitId: input.wait_id },
+        ...input.cron_expr === undefined ? {} : { cronExpr: input.cron_expr },
+        ...input.input === undefined ? {} : { input: input.input },
+        ...input.idempotency_key === undefined ? {} : { idempotencyKey: input.idempotency_key },
+        ...input.metadata === undefined ? {} : { metadata: input.metadata }
+      }).pipe(Effect.mapError(toClientError));
+      return { schedule };
+    }),
+    cancelSchedule: Effect.fn("Client.runtime.cancelSchedule")(function* (input) {
+      const schedule = yield* schedules.cancel({ id: input.schedule_id, cancelledAt: input.cancelled_at }).pipe(Effect.mapError(toClientError));
+      return { schedule };
+    }),
+    listSchedules: Effect.fn("Client.runtime.listSchedules")(function* (input) {
+      const records = yield* schedules.list(input.state === undefined ? {} : { state: input.state }).pipe(Effect.mapError(toClientError));
+      return { schedules: records };
+    })
+  });
+}));
+var testLayer = (implementation) => Layer.succeed(Service, Service.of({
+  ...implementation,
+  followExecution: implementation.followExecution ?? followExecutionFrom({
+    getExecution: implementation.getExecution,
+    inspectExecution: implementation.inspectExecution,
+    streamExecution: implementation.streamExecution
+  }),
+  registerEntityKind: implementation.registerEntityKind ?? ((input) => Effect.succeed(input)),
+  getOrCreateEntity: implementation.getOrCreateEntity ?? (() => Effect.fail(new ClientError({ message: "Entity service unavailable" }))),
+  getEntity: implementation.getEntity ?? (() => Effect.succeed(undefined)),
+  destroyEntity: implementation.destroyEntity ?? (() => Effect.fail(new ClientError({ message: "Entity service unavailable" }))),
+  listEntities: implementation.listEntities ?? (() => Effect.succeed([])),
+  streamSession: implementation.streamSession ?? (() => Stream.empty),
+  watchExecutions: implementation.watchExecutions ?? (() => Stream.empty),
+  getPresence: implementation.getPresence ?? ((scope) => Effect.succeed({ scope, entries: [], observed_at: 0 })),
+  watchPresence: implementation.watchPresence ?? (() => Stream.empty),
+  registerWorkflowDefinition: implementation.registerWorkflowDefinition ?? (() => Effect.die("registerWorkflowDefinition not implemented")),
+  getWorkflowDefinitionRevision: implementation.getWorkflowDefinitionRevision ?? (() => Effect.die("getWorkflowDefinitionRevision not implemented")),
+  listWorkflowDefinitionRevisions: implementation.listWorkflowDefinitionRevisions ?? (() => Effect.die("listWorkflowDefinitionRevisions not implemented")),
+  startWorkflowRun: implementation.startWorkflowRun ?? (() => Effect.die("startWorkflowRun not implemented")),
+  inspectWorkflowRun: implementation.inspectWorkflowRun ?? (() => Effect.die("inspectWorkflowRun not implemented")),
+  replayWorkflowRun: implementation.replayWorkflowRun ?? (() => Effect.die("replayWorkflowRun not implemented")),
+  cancelWorkflowRun: implementation.cancelWorkflowRun ?? (() => Effect.die("cancelWorkflowRun not implemented"))
+}));
+var registerAgentDefinition = Effect.fn("Client.registerAgentDefinition.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.registerAgentDefinition(input);
+});
+var registerEntityKind = Effect.fn("Client.registerEntityKind.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.registerEntityKind(input);
+});
+var getOrCreateEntity = Effect.fn("Client.getOrCreateEntity.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.getOrCreateEntity(input);
+});
+var getEntity = Effect.fn("Client.getEntity.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.getEntity(input);
+});
+var destroyEntity = Effect.fn("Client.destroyEntity.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.destroyEntity(input);
+});
+var listEntities = Effect.fn("Client.listEntities.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listEntities(input);
+});
+var registerAgent = Effect.fn("Client.registerAgent.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.registerAgent(input);
+});
+var getAgentDefinition = Effect.fn("Client.getAgentDefinition.call")(function* (id) {
+  const service = yield* Service;
+  return yield* service.getAgentDefinition(id);
+});
+var listAgentDefinitions = Effect.fn("Client.listAgentDefinitions.call")(function* () {
+  const service = yield* Service;
+  return yield* service.listAgentDefinitions();
+});
+var listAgentDefinitionRevisions = Effect.fn("Client.listAgentDefinitionRevisions.call")(function* (id) {
+  const service = yield* Service;
+  return yield* service.listAgentDefinitionRevisions(id);
+});
+var getSkillDefinition = Effect.fn("Client.getSkillDefinition.call")(function* (id) {
+  const service = yield* Service;
+  return yield* service.getSkillDefinition(id);
+});
+var listSkillDefinitions = Effect.fn("Client.listSkillDefinitions.call")(function* () {
+  const service = yield* Service;
+  return yield* service.listSkillDefinitions();
+});
+var listSkillDefinitionRevisions = Effect.fn("Client.listSkillDefinitionRevisions.call")(function* (id) {
+  const service = yield* Service;
+  return yield* service.listSkillDefinitionRevisions(id);
+});
+var registerAddressBookRoute = Effect.fn("Client.registerAddressBookRoute.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.registerAddressBookRoute(input);
+});
+var getAddressBookRoute = Effect.fn("Client.getAddressBookRoute.call")(function* (id) {
+  const service = yield* Service;
+  return yield* service.getAddressBookRoute(id);
+});
+var listAddressBookRoutes = Effect.fn("Client.listAddressBookRoutes.call")(function* () {
+  const service = yield* Service;
+  return yield* service.listAddressBookRoutes();
+});
+var startExecution = Effect.fn("Client.startExecution.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.startExecution(input);
+});
+var startExecutionByAddress = Effect.fn("Client.startExecutionByAddress.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.startExecutionByAddress(input);
+});
+var startExecutionByAgentDefinition = Effect.fn("Client.startExecutionByAgentDefinition.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.startExecutionByAgentDefinition(input);
+});
+var cancelExecution = Effect.fn("Client.cancelExecution.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.cancelExecution(input);
+});
+var steer = Effect.fn("Client.steer.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.steer(input);
+});
+var getExecution = Effect.fn("Client.getExecution.call")(function* (id) {
+  const service = yield* Service;
+  return yield* service.getExecution(id);
+});
+var listExecutions = Effect.fn("Client.listExecutions.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listExecutions(input);
+});
+var listSessions = Effect.fn("Client.listSessions.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listSessions(input);
+});
+var getSession = Effect.fn("Client.getSession.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.getSession(input);
+});
+var listWaits = Effect.fn("Client.listWaits.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listWaits(input);
+});
+var replayExecution = Effect.fn("Client.replayExecution.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.replayExecution(input);
+});
+var listRunners = Effect.fn("Client.listRunners.call")(function* () {
+  const service = yield* Service;
+  return yield* service.listRunners();
+});
+var routeExecution = Effect.fn("Client.routeExecution.call")(function* (executionId) {
+  const service = yield* Service;
+  return yield* service.routeExecution(executionId);
+});
+var subscribeTopic = Effect.fn("Client.subscribeTopic.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.subscribeTopic(input);
+});
+var unsubscribeTopic = Effect.fn("Client.unsubscribeTopic.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.unsubscribeTopic(input);
+});
+var publishTopic = Effect.fn("Client.publishTopic.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.publishTopic(input);
+});
+var listTopicSubscriptions = Effect.fn("Client.listTopicSubscriptions.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listTopicSubscriptions(input);
+});
+var listInboxMessages = Effect.fn("Client.listInboxMessages.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listInboxMessages(input);
+});
+var inspectExecution = Effect.fn("Client.inspectExecution.call")(function* (executionId) {
+  const service = yield* Service;
+  return yield* service.inspectExecution(executionId);
+});
+var send = Effect.fn("Client.send.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.send(input);
+});
+var streamExecution = (input) => Stream.unwrap(Service.pipe(Effect.map((service) => service.streamExecution(input))));
+var followExecution = (input) => Stream.unwrap(Service.pipe(Effect.map((service) => service.followExecution(input))));
+var streamSession = (input) => Stream.unwrap(Service.pipe(Effect.map((service) => service.streamSession(input))));
+var watchExecutions = (input) => Stream.unwrap(Service.pipe(Effect.map((service) => service.watchExecutions(input))));
+var getPresence = Effect.fn("Client.getPresence.call")(function* (scope) {
+  const service = yield* Service;
+  return yield* service.getPresence(scope);
+});
+var watchPresence = (scope) => Stream.unwrap(Service.pipe(Effect.map((service) => service.watchPresence(scope))));
+var wake = Effect.fn("Client.wake.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.wake(input);
+});
+var listPendingApprovals = Effect.fn("Client.listPendingApprovals.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listPendingApprovals(input);
+});
+var resolveToolApproval = Effect.fn("Client.resolveToolApproval.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.resolveToolApproval(input);
+});
+var resolvePermission = Effect.fn("Client.resolvePermission.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.resolvePermission(input);
+});
+var listPendingToolCalls = Effect.fn("Client.listPendingToolCalls.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listPendingToolCalls(input);
+});
+var fulfillToolCall = Effect.fn("Client.fulfillToolCall.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.fulfillToolCall(input);
+});
+var claimToolWork = Effect.fn("Client.claimToolWork.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.claimToolWork(input);
+});
+var completeToolWork = Effect.fn("Client.completeToolWork.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.completeToolWork(input);
+});
+var releaseToolWork = Effect.fn("Client.releaseToolWork.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.releaseToolWork(input);
+});
+var listToolAttempts = Effect.fn("Client.listToolAttempts.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listToolAttempts(input);
+});
+var submitInboundEnvelope = Effect.fn("Client.submitInboundEnvelope.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.submitInboundEnvelope(input);
+});
+var spawnChildRun = Effect.fn("Client.spawnChildRun.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.spawnChildRun(input);
+});
+var createChildFanOut = Effect.fn("Client.createChildFanOut.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.createChildFanOut(input);
+});
+var cancelChildFanOut = Effect.fn("Client.cancelChildFanOut.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.cancelChildFanOut(input);
+});
+var inspectChildFanOut = Effect.fn("Client.inspectChildFanOut.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.inspectChildFanOut(input);
+});
+var claimEnvelopeReady = Effect.fn("Client.claimEnvelopeReady.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.claimEnvelopeReady(input);
+});
+var ackEnvelopeReady = Effect.fn("Client.ackEnvelopeReady.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.ackEnvelopeReady(input);
+});
+var releaseEnvelopeReady = Effect.fn("Client.releaseEnvelopeReady.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.releaseEnvelopeReady(input);
+});
+var createSchedule = Effect.fn("Client.createSchedule.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.createSchedule(input);
+});
+var cancelSchedule = Effect.fn("Client.cancelSchedule.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.cancelSchedule(input);
+});
+var listSchedules = Effect.fn("Client.listSchedules.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listSchedules(input);
+});
+var askEntity = Effect.fn("Client.askEntity.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.askEntity(input);
+});
+var awaitWait = Effect.fn("Client.awaitWait.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.awaitWait(input);
+});
+
+export { exports_operation, exports_command, Service, exports_client };