@relayfx/sdk 0.3.0 → 0.3.2

package/dist/index-pn652eef.js

@@ -1,2860 +0,0 @@
-// @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_fan_out_transition_service,
-  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_language_model_service,
-  exports_presence_service,
-  exports_runner_runtime_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_runtime_service,
-  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-c2skef55.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,
-  PageExecutionEventsResult: () => PageExecutionEventsResult,
-  PageExecutionEventsInput: () => PageExecutionEventsInput,
-  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,
-  ExecutionEventPageDirection: () => ExecutionEventPageDirection,
-  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),
-  compaction_policy: Schema.optionalKey(exports_agent_schema.CompactionPolicy),
-  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 ExecutionEventPageDirection = Schema.Literals(["forward", "backward"]).annotate({
-  identifier: "Relay.Operation.ExecutionEventPageDirection"
-});
-var PageExecutionEventsInput = Schema.Struct({
-  execution_id: exports_ids_schema.ExecutionId,
-  direction: ExecutionEventPageDirection,
-  after_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString),
-  before_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString),
-  limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(1000)))
-}).check(Schema.makeFilter((input) => {
-  if (input.direction === "forward") {
-    return input.before_cursor === undefined ? undefined : { path: ["before_cursor"], issue: "forward pages accept only after_cursor" };
-  }
-  return input.after_cursor === undefined ? undefined : { path: ["after_cursor"], issue: "backward pages accept only before_cursor" };
-})).annotate({ identifier: "Relay.Operation.PageExecutionEventsInput" });
-var PageExecutionEventsResult = Schema.Struct({
-  events: Schema.Array(exports_execution_schema.ExecutionEvent),
-  has_more: Schema.Boolean,
-  oldest_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString),
-  newest_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString)
-}).annotate({ identifier: "Relay.Operation.PageExecutionEventsResult" });
-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 { Function, Schema as Schema2 } from "effect";
-var make = Function.dual(2, (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,
-  pageExecutionEvents: () => pageExecutionEvents,
-  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: () => Service2,
-  ExecutionNotFound: () => ExecutionNotFound,
-  EventLogCursorNotFound: () => EventLogCursorNotFound,
-  EntityNamespaceReserved: () => EntityNamespaceReserved,
-  ClientError: () => ClientError
-});
-import { Clock, Context as Context2, Effect as Effect2, Layer as Layer2, Option, Random, Schema as Schema4, SchemaGetter, SchemaIssue, Stream } from "effect";
-import { EntityId, ShardId, Sharding, ShardingConfig } from "effect/unstable/cluster";
-// src/runtime-capability-policy.ts
-import { Context, Effect, Function as Function2, Layer, Schema as Schema3 } from "effect";
-
-class RuntimeCapabilityUnavailable extends Schema3.TaggedErrorClass()("RuntimeCapabilityUnavailable", {
-  capability: Schema3.Literals(["fan-out", "workflow-definition"]),
-  role: Schema3.Literals(["embedded", "runner", "client"]),
-  nextAction: Schema3.Literals(["enable-embedded-capability", "use-embedded-runtime"])
-}) {
-}
-
-class Service extends Context.Service()("@relayfx/sdk/runtime-capability-policy/Service") {
-}
-var layer = Function2.dual(2, (role, capabilities) => Layer.succeed(Service, {
-  admit: (capability) => {
-    const enabled = capability === "fan-out" ? capabilities.fanOut : capabilities.workflowDefinition;
-    return enabled ? Effect.void : Effect.fail(RuntimeCapabilityUnavailable.make({
-      capability,
-      role,
-      nextAction: role === "embedded" ? "enable-embedded-capability" : "use-embedded-runtime"
-    }));
-  }
-}));
-
-// src/client.ts
-class ClientError extends Schema4.TaggedErrorClass()("ClientError", {
-  message: Schema4.String
-}) {
-}
-
-class ExecutionNotFound extends Schema4.TaggedErrorClass()("ExecutionNotFound", {
-  execution_id: exports_ids_schema.ExecutionId
-}) {
-}
-
-class EntityNamespaceReserved extends Schema4.TaggedErrorClass()("EntityNamespaceReserved", { id: Schema4.String, message: Schema4.String }) {
-}
-
-class WaitKindMismatch extends Schema4.TaggedErrorClass()("WaitKindMismatch", {
-  wait_id: exports_ids_schema.WaitId,
-  expected: Schema4.String,
-  actual: Schema4.String,
-  message: Schema4.String
-}) {
-}
-
-class Service2 extends Context2.Service()("@relayfx/sdk/client/Service") {
-}
-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 = Effect2.suspend(() => dependencies.inspectExecution(input.execution_id)).pipe(Effect2.catchTag("ExecutionNotFound", (error) => ClientError.make({ message: `execution ${error.execution_id} not found` })));
-  const reconcile = (state, message) => Stream.unwrap(Effect2.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(ClientError.make({
-        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(Effect2.sleep(followReconnectDelayMillis(state.attempts))).pipe(Stream.drain)), Stream.concat(Stream.suspend(() => connect(state))));
-  }));
-  const itemsFor = (state, event) => Effect2.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(Effect2.catchTag("ExecutionNotFound", () => Effect2.void));
-        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(Effect2.gen(function* () {
-    const existing = yield* dependencies.getExecution(input.execution_id);
-    if (existing === undefined) {
-      return Stream.fail(ClientError.make({ 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) => ClientError.make({ message: errorMessage(error) });
-var rejectReserved = (id, prefix) => id.startsWith(prefix) ? Effect2.fail(EntityNamespaceReserved.make({ id, message: "start entities via Client.getOrCreateEntity" })) : Effect2.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(Schema4.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) => Effect2.gen(function* () {
-  const decoded = yield* Effect2.try({
-    try: () => globalThis.atob(wire),
-    catch: () => malformedCursor(wire)
-  });
-  const separator = decoded.indexOf(":");
-  if (separator === -1)
-    return yield* Effect2.fail(malformedCursor(wire));
-  const updatedAt = Number(decoded.slice(0, separator));
-  if (!Number.isFinite(updatedAt))
-    return yield* Effect2.fail(malformedCursor(wire));
-  return { updatedAt, id: decoded.slice(separator + 1) };
-});
-var ExecutionCursorFromString = exports_shared_schema.NonEmptyString.pipe(Schema4.decodeTo(Schema4.Struct({ updatedAt: Schema4.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) => Schema4.encodeEffect(ExecutionCursorFromString)(cursor).pipe(Effect2.mapError(toClientError));
-var SessionCursorFromString = exports_shared_schema.NonEmptyString.pipe(Schema4.decodeTo(Schema4.Struct({ updatedAt: Schema4.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.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) => Schema4.decodeUnknownEffect(exports_shared_schema.NonEmptyString)(name).pipe(Effect2.mapError(() => ClientError.make({ message: "Baton agent name must not be blank" })));
-var decodeBatonAgentMetadata = (metadata) => metadata === undefined ? Effect2.void : Schema4.decodeUnknownEffect(exports_shared_schema.Metadata)(metadata).pipe(Effect2.mapError(() => ClientError.make({ message: "Baton agent metadata must be JSON metadata" })));
-var decodeBatonMemorySubject = (subject) => Schema4.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect2.mapError(() => ClientError.make({ message: "Baton agent memory subject must be a MemorySubjectId" })));
-var metadataFromBatonAgent = Effect2.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 Effect2.succeed(input.model);
-  if (input.agent.model !== undefined)
-    return Effect2.succeed(modelSelectionFromBatonAgent(input.agent.model));
-  return Effect2.fail(ClientError.make({ message: "Client.registerAgent requires model or agent.model" }));
-};
-var batonTurnPolicyInvalid = (detail) => ClientError.make({ message: `Baton agent turn policy is not durably portable: ${detail}` });
-var turnPolicySnapshotFromBaton = Effect2.fn("Client.turnPolicySnapshotFromBaton")(function* (snapshot) {
-  let nodes = 0;
-  const visit = (current, depth) => Effect2.gen(function* () {
-    if (typeof current !== "object" || current === null || Array.isArray(current)) {
-      return yield* batonTurnPolicyInvalid("snapshot nodes must be objects");
-    }
-    const node = current;
-    nodes += 1;
-    if (depth > exports_agent_schema.maxTurnPolicySnapshotDepth) {
-      return yield* batonTurnPolicyInvalid(`depth exceeds ${exports_agent_schema.maxTurnPolicySnapshotDepth}`);
-    }
-    if (nodes > exports_agent_schema.maxTurnPolicySnapshotNodes) {
-      return yield* 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* 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* 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* batonTurnPolicyInvalid("snapshot tag is not recognized");
-    }
-  });
-  return yield* visit(snapshot, 1);
-});
-var turnPolicyFieldsFromRegisterInput = Effect2.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* batonTurnPolicyInvalid("opaque policies require an explicit max_tool_turns replacement");
-  }
-  const durable = yield* turnPolicySnapshotFromBaton(snapshot);
-  if (durable.kind === "recurs" && durable.count === 8)
-    return {};
-  if (durable.kind === "recurs" && durable.count > 0)
-    return { max_tool_turns: durable.count };
-  return { turn_policy: durable };
-});
-var registerAgentPayload = Effect2.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 },
-    ...input.compaction_policy === undefined ? {} : { compaction_policy: input.compaction_policy },
-    ...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 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) => Schema4.decodeUnknownEffect(exports_tool_schema.ExternalOutcome)(wait.metadata.external_outcome).pipe(Effect2.mapError(toClientError));
-var resolveToolOutcomeWait = Effect2.fn("Client.resolveToolOutcomeWait")(function* (waits, eventLog, call, outcome, completedAt) {
-  const waitId = call.waitId ?? toolWaitId(call.call.id);
-  const wait = yield* waits.get(waitId).pipe(Effect2.mapError(toClientError));
-  if (wait === undefined)
-    return yield* ClientError.make({ message: `Tool wait not found: ${waitId}` });
-  if (wait.executionId !== call.executionId) {
-    return yield* ClientError.make({ 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* ClientError.make({ message: `Tool outcome conflicts with accepted wait: ${call.call.id}` });
-    }
-    return wait;
-  }
-  if (wait.state !== "open") {
-    return yield* ClientError.make({ 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(Effect2.mapError(toClientError));
-  if (!resolved.transitioned) {
-    const accepted = yield* acceptedWaitOutcome(resolved.wait);
-    if (exports_shared_schema.canonicalString(accepted) !== exports_shared_schema.canonicalString(outcome)) {
-      return yield* ClientError.make({ message: `Tool outcome conflicts with accepted wait: ${call.call.id}` });
-    }
-  }
-  return resolved.wait;
-});
-var signalToolOutcome = Effect2.fn("Client.signalToolOutcome")(function* (executionRepository, makeExecutionClient, wait, signaledAt) {
-  yield* Effect2.mapError(Effect2.orDie(exports_wait_signal.signalWorkflowWait({
-    makeExecutionClient: typedWaitSignalClient(makeExecutionClient),
-    executionId: wait.executionId,
-    waitId: wait.id,
-    state: "resolved",
-    signaledAt
-  }).pipe(Effect2.provideService(exports_execution_repository.Service, executionRepository))), 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 typedWaitSignalClient = (makeExecutionClient) => (executionId) => {
-  const client = makeExecutionClient(executionId);
-  return {
-    signalWait: (input) => client.signalWait(input).pipe(Effect2.mapError((error) => exports_wait_signal.WaitSignalError.make({ message: String(error) })))
-  };
-};
-var nextEventSequence = Effect2.fn("Client.nextEventSequence")(function* (eventLog, executionId) {
-  const max = yield* eventLog.maxSequence(executionId).pipe(Effect2.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 = Effect2.fn("Client.wakeRuntime")(function* (waits, eventLog, executionRepository, makeExecutionClient, input, accepts) {
-  const wait = yield* waits.get(input.wait_id).pipe(Effect2.mapError(toClientError));
-  if (wait === undefined)
-    return yield* ClientError.make({ message: `Wait not found: ${input.wait_id}` });
-  const kind = waitSemanticKind(wait);
-  if (accepts !== undefined && kind !== accepts) {
-    return yield* WaitKindMismatch.make({
-      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* WaitKindMismatch.make({
-      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* ClientError.make({ 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(Effect2.mapError(toClientError)) : input.state === "timed_out" ? yield* waits.timeout({
-    waitId: input.wait_id,
-    timedOutAt: input.signaled_at,
-    eventSequence,
-    metadata: wakeMetadata(input)
-  }).pipe(Effect2.mapError(toClientError)) : yield* waits.cancel({
-    waitId: input.wait_id,
-    cancelledAt: input.signaled_at,
-    eventSequence,
-    metadata: wakeMetadata(input)
-  }).pipe(Effect2.mapError(toClientError));
-  if (result.transitioned) {
-    yield* Effect2.mapError(Effect2.orDie(exports_wait_signal.signalWorkflowWait({
-      makeExecutionClient: typedWaitSignalClient(makeExecutionClient),
-      executionId: result.wait.executionId,
-      waitId: result.wait.id,
-      state: input.state,
-      signaledAt: input.signaled_at
-    }).pipe(Effect2.provideService(exports_execution_repository.Service, executionRepository))), 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,
-  ...definition.compaction_policy === undefined ? {} : { compaction_policy: definition.compaction_policy },
-  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.compaction_policy === undefined ? {} : { compaction_policy: input.compaction_policy },
-  ...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 = Effect2.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(Effect2.mapError(toClientError));
-  return waitId;
-});
-var reconcileExistingChildSpawn = Effect2.fn("Client.reconcileExistingChildSpawn")(function* (childExecutions, waits, eventLog, input) {
-  const childExecutionId = childExecutionIdForSpawn(input);
-  const existing = yield* childExecutions.get(childExecutionId).pipe(Effect2.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* ClientError.make({ message: `Child execution conflicts: ${childExecutionId}` });
-  }
-  const spawned = yield* eventLog.findByCursor({
-    executionId: input.execution_id,
-    cursor: `${input.execution_id}:child:${childExecutionId}:spawned`
-  }).pipe(Effect2.mapError(toClientError));
-  if (Option.isNone(spawned)) {
-    return yield* ClientError.make({ message: `Child spawn event missing: ${childExecutionId}` });
-  }
-  const parentWaitId = input.wait === true ? childJoinWaitId(childExecutionId) : undefined;
-  if (parentWaitId !== undefined) {
-    const wait = yield* waits.get(parentWaitId).pipe(Effect2.mapError(toClientError));
-    if (wait === undefined) {
-      return yield* ClientError.make({ message: `Child join wait missing: ${childExecutionId}` });
-    }
-  }
-  return {
-    accepted: { child_execution_id: childExecutionId, execution_id: input.execution_id },
-    createdAt: existing.createdAt,
-    parentWaitId
-  };
-});
-var parentDefinitionPin = Effect2.fn("Client.parentDefinitionPin")(function* (executionRepository, executionId) {
-  const record = yield* executionRepository.get(executionId).pipe(Effect2.mapError(toClientError));
-  if (record === undefined) {
-    return yield* ClientError.make({ message: `Execution not found: ${executionId}` });
-  }
-  if (record.agentId === undefined || record.agentRevision === undefined || record.agentSnapshot === undefined) {
-    return yield* ClientError.make({ 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,
-  session_id: exports_execution_schema.childSessionId(accepted.child_execution_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 = Layer2.effect(Service2, Effect2.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* Effect2.serviceOption(exports_definition_runtime.Service);
-  const childFanOutRuntime = yield* Effect2.serviceOption(exports_child_fan_out_runtime.Service);
-  const runtimeCapabilityPolicy = yield* Effect2.serviceOption(Service);
-  const schemaRegistry = yield* Effect2.serviceOption(exports_schema_registry_service.Service);
-  const coordinateToolTransition = (effect) => toolTransitions.coordinate(effect).pipe(Effect2.mapError(toClientError));
-  const coordinateChildSpawn = (effect) => toolTransitions.coordinate(effect).pipe(Effect2.mapError(toClientError));
-  const cancelFanOut = Effect2.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(Effect2.mapError(toClientError));
-      if (fanOut === undefined)
-        return yield* ClientError.make({ 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(Effect2.mapError(toClientError));
-    if (result === undefined)
-      return yield* ClientError.make({ message: `Child fan-out not found: ${input.fan_out_id}` });
-    yield* Effect2.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(Effect2.mapError(toClientError)), { discard: true });
-    if (result.transitioned) {
-      const max = yield* eventLog.maxSequence(result.fanOut.parent_execution_id).pipe(Effect2.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(Effect2.mapError(toClientError));
-    }
-    return { fan_out: result.fanOut };
-  });
-  const sendEnvelope = Effect2.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(Effect2.mapError(toClientError));
-    return yield* envelopes.send({
-      envelopeId,
-      executionId,
-      input,
-      eventSequence: maxSequence === undefined ? 0 : maxSequence + 1,
-      createdAt
-    }).pipe(Effect2.mapError(toClientError));
-  });
-  const waitOutcomeFrom = Effect2.fn("Client.runtime.waitOutcome")(function* (wait) {
-    const reply = wait.state === "resolved" ? yield* envelopeReady.getEnvelope(exports_ids_schema.EnvelopeId.make(`envelope:reply:${wait.id}`)).pipe(Effect2.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 = Effect2.fn("Client.runtime.awaitWait")(function* (input) {
-    const current = yield* envelopeReady.getWait(input.wait_id).pipe(Effect2.mapError(toClientError));
-    if (current === undefined) {
-      return yield* ClientError.make({ 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, Effect2.mapError(toClientError));
-    const terminal = yield* envelopeReady.getWait(input.wait_id).pipe(Effect2.mapError(toClientError));
-    if (terminal === undefined || terminal.state === "open") {
-      return yield* ClientError.make({ message: `wait ${input.wait_id} did not reach a terminal state` });
-    }
-    return yield* waitOutcomeFrom(terminal);
-  });
-  const getExecutionOperation = Effect2.fn("Client.runtime.getExecution")(function* (id) {
-    const record = yield* executionRepository.get(id).pipe(Effect2.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 = Effect2.fn("Client.runtime.inspectExecution")(function* (executionId) {
-    const execution = yield* executionRepository.get(executionId).pipe(Effect2.mapError(toClientError));
-    if (execution === undefined)
-      return yield* ExecutionNotFound.make({ execution_id: executionId });
-    const openWaits = yield* envelopeReady.listAllWaits({ executionId, state: "open" }).pipe(Effect2.mapError(toClientError));
-    const calls = yield* toolCalls.listCalls(executionId).pipe(Effect2.mapError(toClientError));
-    const pendingChunks = yield* Effect2.forEach(calls, (call) => toolCalls.getResult(call.call.id).pipe(Effect2.mapError(toClientError), Effect2.map((result) => result === undefined ? [toToolCallSummary(call)] : [])));
-    const children = yield* childExecutions.listByExecution(executionId).pipe(Effect2.mapError(toClientError));
-    const maxSequence = yield* eventLog.maxSequence(executionId).pipe(Effect2.mapError(toClientError));
-    const lastEvent = maxSequence === undefined ? undefined : yield* eventLog.findBySequence({ executionId, sequence: maxSequence }).pipe(Effect2.mapError(toClientError), Effect2.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 Service2.of({
-    registerEntityKind: (input) => entityRegistry.registerKind(input).pipe(Effect2.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(Effect2.mapError(toClientError)),
-    getEntity: (input) => entities.get(input).pipe(Effect2.mapError(toClientError)),
-    destroyEntity: (input) => entities.destroy({
-      kind: input.kind,
-      key: input.key,
-      destroyedAt: input.destroyed_at,
-      ...input.reason === undefined ? {} : { reason: input.reason }
-    }).pipe(Effect2.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(Effect2.mapError(toClientError)),
-    registerWorkflowDefinition: Effect2.fn("Client.runtime.registerWorkflowDefinition")(function* (input) {
-      return { record: yield* workflows.register(input).pipe(Effect2.mapError(toClientError)) };
-    }),
-    getWorkflowDefinitionRevision: Effect2.fn("Client.runtime.getWorkflowDefinitionRevision")(function* (id, revision) {
-      return yield* workflows.get(id, revision).pipe(Effect2.mapError(toClientError));
-    }),
-    listWorkflowDefinitionRevisions: Effect2.fn("Client.runtime.listWorkflowDefinitionRevisions")(function* (id) {
-      return { records: yield* workflows.list(id).pipe(Effect2.mapError(toClientError)) };
-    }),
-    startWorkflowRun: Effect2.fn("Client.runtime.startWorkflowRun")(function* (input) {
-      if (Option.isSome(runtimeCapabilityPolicy))
-        yield* runtimeCapabilityPolicy.value.admit("workflow-definition");
-      return yield* Option.match(workflowRuntime, {
-        onNone: () => workflows.start(input),
-        onSome: (runtime) => runtime.start(input)
-      }).pipe(Effect2.mapError(toClientError));
-    }),
-    inspectWorkflowRun: Effect2.fn("Client.runtime.inspectWorkflowRun")(function* (id) {
-      return yield* Option.match(workflowRuntime, {
-        onNone: () => workflows.inspect(id),
-        onSome: (runtime) => runtime.inspect(id)
-      }).pipe(Effect2.mapError(toClientError));
-    }),
-    replayWorkflowRun: Effect2.fn("Client.runtime.replayWorkflowRun")(function* (id) {
-      return yield* Option.match(workflowRuntime, {
-        onNone: () => workflows.listLifecycle(id),
-        onSome: (runtime) => runtime.replay(id)
-      }).pipe(Effect2.mapError(toClientError));
-    }),
-    cancelWorkflowRun: Effect2.fn("Client.runtime.cancelWorkflowRun")(function* (id) {
-      return yield* Option.match(workflowRuntime, {
-        onNone: () => workflows.cancel(id).pipe(Effect2.map((result) => result.record)),
-        onSome: (runtime) => runtime.cancel(id)
-      }).pipe(Effect2.mapError(toClientError));
-    }),
-    registerAgent: Effect2.fn("Client.runtime.registerAgent")(function* (input) {
-      const payload = yield* registerAgentPayload(input);
-      const registered = yield* agentRegistry.register(payload).pipe(Effect2.mapError(toClientError));
-      if (input.address !== undefined) {
-        yield* addressBook.register(input.address, { kind: "local-agent", route_key: payload.id }).pipe(Effect2.mapError(toClientError));
-      }
-      return registered;
-    }),
-    registerAgentDefinition: Effect2.fn("Client.runtime.registerAgentDefinition")(function* (input) {
-      return yield* agentRegistry.register(input).pipe(Effect2.mapError(toClientError));
-    }),
-    getAgentDefinition: Effect2.fn("Client.runtime.getAgentDefinition")(function* (id) {
-      return yield* agentRegistry.get(id).pipe(Effect2.mapError(toClientError));
-    }),
-    listAgentDefinitions: Effect2.fn("Client.runtime.listAgentDefinitions")(function* (_) {
-      return yield* agentRegistry.list.pipe(Effect2.mapError(toClientError));
-    }),
-    listAgentDefinitionRevisions: Effect2.fn("Client.runtime.listAgentDefinitionRevisions")(function* (id) {
-      return yield* agentRegistry.listRevisions(id).pipe(Effect2.mapError(toClientError));
-    }),
-    getSkillDefinition: Effect2.fn("Client.runtime.getSkillDefinition")(function* (id) {
-      return yield* skillRegistry.get(id).pipe(Effect2.mapError(toClientError));
-    }),
-    listSkillDefinitions: Effect2.fn("Client.runtime.listSkillDefinitions")(function* (_) {
-      return yield* skillRegistry.list.pipe(Effect2.mapError(toClientError));
-    }),
-    listSkillDefinitionRevisions: Effect2.fn("Client.runtime.listSkillDefinitionRevisions")(function* (id) {
-      return yield* skillRegistry.listRevisions(id).pipe(Effect2.mapError(toClientError));
-    }),
-    registerAddressBookRoute: Effect2.fn("Client.runtime.registerAddressBookRoute")(function* (input) {
-      yield* rejectReserved(input.address_id, "address:entity:");
-      return yield* addressBook.register(input.address_id, input.route).pipe(Effect2.mapError(toClientError));
-    }),
-    getAddressBookRoute: Effect2.fn("Client.runtime.getAddressBookRoute")(function* (id) {
-      return yield* addressBook.get(id).pipe(Effect2.mapError(toClientError));
-    }),
-    listAddressBookRoutes: Effect2.fn("Client.runtime.listAddressBookRoutes")(function* (_) {
-      return yield* addressBook.list.pipe(Effect2.mapError(toClientError));
-    }),
-    startExecution: Effect2.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(Effect2.mapError(toClientError));
-    }),
-    startExecutionByAddress: Effect2.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(Effect2.mapError(toClientError));
-    }),
-    startExecutionByAgentDefinition: Effect2.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.getRevision({ id: input.agent_id, revision: input.agent_revision }).pipe(Effect2.mapError(toClientError));
-      if (definition === undefined) {
-        return yield* ClientError.make({
-          message: `Agent revision not found: ${input.agent_id}@${input.agent_revision}`
-        });
-      }
-      const payload = startExecutionByAgentDefinitionPayload(input, definition);
-      const client = makeExecutionClient(payload.execution_id);
-      return yield* client.start(payload).pipe(Effect2.mapError(toClientError));
-    }),
-    cancelExecution: Effect2.fn("Client.runtime.cancelExecution")(function* (input) {
-      const fanOuts = yield* childFanOuts.listNonTerminal(input.execution_id).pipe(Effect2.mapError(toClientError));
-      yield* Effect2.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(Effect2.mapError(toClientError));
-    }),
-    steer: Effect2.fn("Client.runtime.steer")(function* (input) {
-      const execution = yield* executionRepository.get(input.execution_id).pipe(Effect2.mapError(toClientError));
-      if (execution === undefined) {
-        return yield* ClientError.make({ message: `Execution not found: ${input.execution_id}` });
-      }
-      if (execution.status !== "running") {
-        return yield* ClientError.make({ 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(Effect2.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: Effect2.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(Effect2.mapError(toClientError));
-      return records.map(toWaitView);
-    }),
-    listExecutions: Effect2.fn("Client.runtime.listExecutions")(function* (input) {
-      const cursor = input.cursor === undefined ? undefined : yield* Schema4.decodeEffect(ExecutionCursorFromString)(input.cursor);
-      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 }
-      });
-      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema4.encodeEffect(ExecutionCursorFromString)(result.nextCursor);
-      return {
-        records: result.records.map(toConversationSummary),
-        ...nextCursor === undefined ? {} : { next_cursor: nextCursor }
-      };
-    }, Effect2.mapError(toClientError)),
-    subscribeTopic: Effect2.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(Effect2.mapError(toClientError));
-    }),
-    unsubscribeTopic: Effect2.fn("Client.runtime.unsubscribeTopic")(function* (input) {
-      return yield* topicService.unsubscribe({
-        topicAddressId: input.topic_address_id,
-        subscriberExecutionId: input.subscriber_execution_id
-      }).pipe(Effect2.mapError(toClientError));
-    }),
-    publishTopic: Effect2.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(Effect2.mapError(toClientError));
-    }),
-    listTopicSubscriptions: Effect2.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(Effect2.mapError(toClientError));
-    }),
-    listInboxMessages: Effect2.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(Effect2.mapError(toClientError));
-    }),
-    listSessions: Effect2.fn("Client.runtime.listSessions")(function* (input) {
-      const cursor = input.cursor === undefined ? undefined : yield* Schema4.decodeEffect(SessionCursorFromString)(input.cursor);
-      const result = yield* sessionRepository.list({
-        ...input.root_address_id === undefined ? {} : { rootAddressId: input.root_address_id },
-        ...input.limit === undefined ? {} : { limit: input.limit },
-        ...cursor === undefined ? {} : { cursor }
-      });
-      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema4.encodeEffect(SessionCursorFromString)(result.nextCursor);
-      return {
-        records: result.records.map(toSessionSummary),
-        ...nextCursor === undefined ? {} : { next_cursor: nextCursor }
-      };
-    }, Effect2.mapError(toClientError)),
-    getSession: Effect2.fn("Client.runtime.getSession")(function* (input) {
-      const session = yield* sessionRepository.get(input.session_id).pipe(Effect2.mapError(toClientError));
-      if (session === undefined)
-        return yield* ClientError.make({ message: `Session not found: ${input.session_id}` });
-      const cursor = input.cursor === undefined ? undefined : yield* Schema4.decodeEffect(ExecutionCursorFromString)(input.cursor).pipe(Effect2.mapError(toClientError));
-      const result = yield* executionRepository.list({
-        sessionId: input.session_id,
-        ...input.limit === undefined ? {} : { limit: input.limit },
-        ...cursor === undefined ? {} : { cursor }
-      }).pipe(Effect2.mapError(toClientError));
-      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema4.encodeEffect(ExecutionCursorFromString)(result.nextCursor).pipe(Effect2.mapError(toClientError));
-      return {
-        session: toSessionSummary(session),
-        executions: result.records.map(toConversationSummary),
-        ...nextCursor === undefined ? {} : { next_cursor: nextCursor }
-      };
-    }),
-    replayExecution: Effect2.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(Effect2.mapError(toClientError));
-      return { events };
-    }),
-    pageExecutionEvents: Effect2.fn("Client.runtime.pageExecutionEvents")(function* (input) {
-      const pageInput = input.direction === "forward" ? {
-        executionId: input.execution_id,
-        direction: "forward",
-        ...input.after_cursor === undefined ? {} : { afterCursor: input.after_cursor },
-        ...input.limit === undefined ? {} : { limit: input.limit }
-      } : {
-        executionId: input.execution_id,
-        direction: "backward",
-        ...input.before_cursor === undefined ? {} : { beforeCursor: input.before_cursor },
-        ...input.limit === undefined ? {} : { limit: input.limit }
-      };
-      const result = yield* eventLog.page(pageInput).pipe(Effect2.mapError(toStreamError));
-      return {
-        events: result.events,
-        has_more: result.hasMore,
-        ...result.oldestCursor === undefined ? {} : { oldest_cursor: result.oldestCursor },
-        ...result.newestCursor === undefined ? {} : { newest_cursor: result.newestCursor }
-      };
-    }),
-    listRunners: Effect2.fn("Client.runtime.listRunners")(function* (_) {
-      const runners = yield* clusterRegistry.listRunners().pipe(Effect2.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: Effect2.fn("Client.runtime.routeExecution")(function* (executionId) {
-      const shard = ShardId.toString(sharding.getShardId(EntityId.make(executionId), "execution"));
-      const owner = yield* clusterRegistry.lockOwner(shard).pipe(Effect2.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: Effect2.fn("Client.runtime.askEntity")(function* (input) {
-      const instance = yield* entities.get({ kind: input.kind, key: input.key }).pipe(Effect2.mapError(toClientError));
-      if (instance === undefined || instance.status === "destroyed") {
-        return yield* EntityNotFound.make({ kind: input.kind, key: input.key });
-      }
-      const encoded = yield* Schema4.encodeUnknownEffect(input.command.input)(input.input).pipe(Effect2.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}:${yield* Random.nextInt}`;
-      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* ClientError.make({ 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* CommandTimedOut.make({
-          command: input.command.name,
-          wait_id: outcome.wait_id,
-          timeout: input.timeout ?? "unspecified"
-        });
-      }
-      if (outcome.state === "cancelled") {
-        return yield* ClientError.make({ message: `reply wait ${outcome.wait_id} was cancelled` });
-      }
-      const replyValue = replyValueFrom(outcome.content);
-      if (replyValue._tag === "None") {
-        return yield* CommandReplyInvalid.make({
-          command: input.command.name,
-          wait_id: outcome.wait_id,
-          message: "reply carried no decodable content"
-        });
-      }
-      return yield* Schema4.decodeUnknownEffect(input.command.output)(replyValue.value).pipe(Effect2.mapError((issue) => CommandReplyInvalid.make({
-        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 ? Effect2.succeed({
-      _tag: "snapshot",
-      records: change.records.map(toConversationSummary)
-    }) : encodeExecutionCursor(change.nextCursor).pipe(Effect2.map((next_cursor) => ({
-      _tag: "snapshot",
-      records: change.records.map(toConversationSummary),
-      next_cursor
-    }))) : Effect2.succeed({
-      _tag: "upsert",
-      record: toConversationSummary(change.record)
-    })), Stream.mapError(toClientError)),
-    getEntityState: Effect2.fn("Client.runtime.getEntityState")((input) => executionState.getRecord(input.execution_id, input.key).pipe(Effect2.mapError(toClientError))),
-    putEntityState: Effect2.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(Effect2.mapError((error) => Schema4.is(exports_execution_state_service.StateVersionConflict)(error) ? error : toClientError(error)))),
-    deleteEntityState: Effect2.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(Effect2.mapError((error) => Schema4.is(exports_execution_state_service.StateVersionConflict)(error) ? error : toClientError(error)))),
-    listEntityState: Effect2.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(Effect2.mapError(toClientError))),
-    getPresence: (scope) => presence.list(scope).pipe(Effect2.mapError(toClientError)),
-    watchPresence: (scope) => presence.watch(scope).pipe(Stream.mapError(toClientError)),
-    wake: Effect2.fn("Client.runtime.wake")(function* (input) {
-      return yield* wakeRuntime(waits, eventLog, executionRepository, makeExecutionClient, input);
-    }),
-    listPendingApprovals: Effect2.fn("Client.runtime.listPendingApprovals")(function* (input) {
-      const records = yield* envelopeReady.listWaits({ executionId: input.execution_id, state: "open" }).pipe(Effect2.mapError(toClientError));
-      return { approvals: records.filter(isToolApprovalWait).map(toPendingToolApproval) };
-    }),
-    resolveToolApproval: Effect2.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: Effect2.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: Effect2.fn("Client.runtime.listPendingToolCalls")(function* (input) {
-      const openWaits = yield* envelopeReady.listAllWaits({
-        state: "open",
-        ...input.execution_id === undefined ? {} : { executionId: input.execution_id }
-      }).pipe(Effect2.mapError(toClientError));
-      const records = yield* Effect2.forEach(openWaits.filter((wait) => wait.metadata.kind === "tool-placement"), (wait) => toolCalls.getCall(exports_ids_schema.ToolCallId.make(String(wait.metadata.tool_call_id ?? ""))).pipe(Effect2.mapError(toClientError), Effect2.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: Effect2.fn("Client.runtime.fulfillToolCall")(function* (input) {
-      const coordinated = yield* coordinateToolTransition(Effect2.gen(function* () {
-        const call = yield* toolCalls.getCall(input.tool_call_id).pipe(Effect2.mapError(toClientError));
-        if (call === undefined || call.executionId !== input.execution_id || call.placement.kind !== "client") {
-          return yield* ClientError.make({ 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(Effect2.mapError(toClientError));
-        return { wait, accepted };
-      }));
-      yield* signalToolOutcome(executionRepository, makeExecutionClient, coordinated.wait, input.fulfilled_at);
-      return toToolOutcomeAccepted(coordinated.accepted);
-    }),
-    claimToolWork: Effect2.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(Effect2.mapError(toClientError)));
-      return lease === undefined ? null : toToolWorkLease(lease);
-    }),
-    completeToolWork: Effect2.fn("Client.runtime.completeToolWork")(function* (input) {
-      const coordinated = yield* coordinateToolTransition(Effect2.gen(function* () {
-        const call = yield* toolCalls.getCall(input.tool_call_id).pipe(Effect2.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* ClientError.make({ 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(Effect2.mapError(toClientError));
-        return { wait, accepted };
-      }));
-      yield* signalToolOutcome(executionRepository, makeExecutionClient, coordinated.wait, input.completed_at);
-      return toToolOutcomeAccepted(coordinated.accepted);
-    }),
-    releaseToolWork: Effect2.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(Effect2.mapError(toClientError)));
-      return {
-        tool_call_id: call.call.id,
-        state: "waiting",
-        next_available_at: call.availableAt
-      };
-    }),
-    listToolAttempts: Effect2.fn("Client.runtime.listToolAttempts")(function* (input) {
-      const attempts = yield* toolCalls.listAttempts(input.tool_call_id).pipe(Effect2.mapError(toClientError));
-      return { attempts: attempts.map(toToolAttempt) };
-    }),
-    submitInboundEnvelope: Effect2.fn("Client.runtime.submitInboundEnvelope")(function* (input) {
-      const envelope = yield* executions.send(input.envelope).pipe(Effect2.mapError(toClientError));
-      const wakeResult = yield* wakeRuntime(waits, eventLog, executionRepository, makeExecutionClient, input.wake);
-      return { envelope, wake: wakeResult };
-    }),
-    spawnChildRun: Effect2.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(Effect2.mapError((error) => ClientError.make({ message: error._tag })));
-      const definition = yield* exports_child_run_service.childDefinition(pin.agentSnapshot, context).pipe(Effect2.mapError((error) => ClientError.make({ message: error._tag })));
-      const coordinated = yield* coordinateChildSpawn(Effect2.gen(function* () {
-        const existing = yield* reconcileExistingChildSpawn(childExecutions, waits, eventLog, input);
-        if (existing !== undefined)
-          return existing;
-        const accepted = yield* executions.spawnChildRun(internal).pipe(Effect2.mapError(toClientError));
-        const parentWaitId = input.wait === true ? yield* createChildJoinWait(waits, eventLog, internal, accepted, createdAt) : undefined;
-        return { accepted, createdAt, parentWaitId };
-      })).pipe(Effect2.catch((error) => error.message === "DuplicateChildExecution" ? coordinateChildSpawn(reconcileExistingChildSpawn(childExecutions, waits, eventLog, input).pipe(Effect2.flatMap((existing) => existing === undefined ? Effect2.fail(ClientError.make({ message: `Child execution retry missing: ${input.execution_id}` })) : Effect2.succeed(existing)))) : Effect2.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(Effect2.mapError(toClientError));
-      return coordinated.accepted;
-    }),
-    createChildFanOut: Effect2.fn("Client.runtime.createChildFanOut")(function* (input) {
-      if (Option.isSome(runtimeCapabilityPolicy))
-        yield* runtimeCapabilityPolicy.value.admit("fan-out");
-      if (Option.isNone(childFanOutRuntime)) {
-        return yield* ClientError.make({
-          message: "Child fan-out runtime unavailable; provide ChildFanOutRuntime.Service to Client.layerFromRuntime"
-        });
-      }
-      return yield* childFanOutRuntime.value.create(input).pipe(Effect2.mapError(toClientError));
-    }),
-    cancelChildFanOut: Effect2.fn("Client.runtime.cancelChildFanOut")(function* (input) {
-      return yield* cancelFanOut(input);
-    }),
-    inspectChildFanOut: Effect2.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(Effect2.mapError(toClientError));
-      return { fan_out: fanOut ?? null };
-    }),
-    claimEnvelopeReady: Effect2.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(Effect2.map((record) => record === undefined ? null : toLease(record)), Effect2.mapError(toClientError));
-    }),
-    ackEnvelopeReady: Effect2.fn("Client.runtime.ackEnvelopeReady")(function* (input) {
-      return yield* envelopeReady.ackReady({
-        id: input.envelope_ready_id,
-        workerId: input.worker_id,
-        now: input.acknowledged_at
-      }).pipe(Effect2.map((record) => ({
-        envelope_ready_id: record.id,
-        state: "acknowledged",
-        acknowledged_at: record.acknowledgedAt ?? input.acknowledged_at
-      })), Effect2.mapError(toClientError));
-    }),
-    releaseEnvelopeReady: Effect2.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(Effect2.map((record) => ({
-        envelope_ready_id: record.id,
-        state: "ready",
-        next_available_at: record.availableAt
-      })), Effect2.mapError(toClientError));
-    }),
-    createSchedule: Effect2.fn("Client.runtime.createSchedule")(function* (input) {
-      if (input.cron_expr !== undefined) {
-        yield* exports_scheduler_service.parseCron(input.cron_expr).pipe(Effect2.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(Effect2.mapError(toClientError));
-      return { schedule };
-    }),
-    cancelSchedule: Effect2.fn("Client.runtime.cancelSchedule")(function* (input) {
-      const schedule = yield* schedules.cancel({ id: input.schedule_id, cancelledAt: input.cancelled_at }).pipe(Effect2.mapError(toClientError));
-      return { schedule };
-    }),
-    listSchedules: Effect2.fn("Client.runtime.listSchedules")(function* (input) {
-      const records = yield* schedules.list(input.state === undefined ? {} : { state: input.state }).pipe(Effect2.mapError(toClientError));
-      return { schedules: records };
-    })
-  });
-}));
-var testLayer = (implementation) => Layer2.succeed(Service2, Service2.of({
-  ...implementation,
-  followExecution: implementation.followExecution ?? followExecutionFrom({
-    getExecution: implementation.getExecution,
-    inspectExecution: implementation.inspectExecution,
-    streamExecution: implementation.streamExecution
-  }),
-  registerEntityKind: implementation.registerEntityKind ?? ((input) => Effect2.succeed(input)),
-  getOrCreateEntity: implementation.getOrCreateEntity ?? (() => Effect2.fail(ClientError.make({ message: "Entity service unavailable" }))),
-  getEntity: implementation.getEntity ?? (() => Effect2.void.pipe(Effect2.as(undefined))),
-  destroyEntity: implementation.destroyEntity ?? (() => Effect2.fail(ClientError.make({ message: "Entity service unavailable" }))),
-  listEntities: implementation.listEntities ?? (() => Effect2.succeed([])),
-  pageExecutionEvents: implementation.pageExecutionEvents ?? (() => Effect2.fail(ClientError.make({ message: "Execution event paging unavailable" }))),
-  streamSession: implementation.streamSession ?? (() => Stream.empty),
-  watchExecutions: implementation.watchExecutions ?? (() => Stream.empty),
-  getPresence: implementation.getPresence ?? ((scope) => Effect2.succeed({ scope, entries: [], observed_at: 0 })),
-  watchPresence: implementation.watchPresence ?? (() => Stream.empty),
-  registerWorkflowDefinition: implementation.registerWorkflowDefinition ?? (() => Effect2.die("registerWorkflowDefinition not implemented")),
-  getWorkflowDefinitionRevision: implementation.getWorkflowDefinitionRevision ?? (() => Effect2.die("getWorkflowDefinitionRevision not implemented")),
-  listWorkflowDefinitionRevisions: implementation.listWorkflowDefinitionRevisions ?? (() => Effect2.die("listWorkflowDefinitionRevisions not implemented")),
-  startWorkflowRun: implementation.startWorkflowRun ?? (() => Effect2.die("startWorkflowRun not implemented")),
-  inspectWorkflowRun: implementation.inspectWorkflowRun ?? (() => Effect2.die("inspectWorkflowRun not implemented")),
-  replayWorkflowRun: implementation.replayWorkflowRun ?? (() => Effect2.die("replayWorkflowRun not implemented")),
-  cancelWorkflowRun: implementation.cancelWorkflowRun ?? (() => Effect2.die("cancelWorkflowRun not implemented"))
-}));
-var registerAgentDefinition = Effect2.fn("Client.registerAgentDefinition.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.registerAgentDefinition(input);
-});
-var registerEntityKind = Effect2.fn("Client.registerEntityKind.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.registerEntityKind(input);
-});
-var getOrCreateEntity = Effect2.fn("Client.getOrCreateEntity.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.getOrCreateEntity(input);
-});
-var getEntity = Effect2.fn("Client.getEntity.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.getEntity(input);
-});
-var destroyEntity = Effect2.fn("Client.destroyEntity.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.destroyEntity(input);
-});
-var listEntities = Effect2.fn("Client.listEntities.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.listEntities(input);
-});
-var registerAgent = Effect2.fn("Client.registerAgent.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.registerAgent(input);
-});
-var getAgentDefinition = Effect2.fn("Client.getAgentDefinition.call")(function* (id) {
-  const service = yield* Service2;
-  return yield* service.getAgentDefinition(id);
-});
-var listAgentDefinitions = Effect2.fn("Client.listAgentDefinitions.call")(function* () {
-  const service = yield* Service2;
-  return yield* service.listAgentDefinitions();
-});
-var listAgentDefinitionRevisions = Effect2.fn("Client.listAgentDefinitionRevisions.call")(function* (id) {
-  const service = yield* Service2;
-  return yield* service.listAgentDefinitionRevisions(id);
-});
-var getSkillDefinition = Effect2.fn("Client.getSkillDefinition.call")(function* (id) {
-  const service = yield* Service2;
-  return yield* service.getSkillDefinition(id);
-});
-var listSkillDefinitions = Effect2.fn("Client.listSkillDefinitions.call")(function* () {
-  const service = yield* Service2;
-  return yield* service.listSkillDefinitions();
-});
-var listSkillDefinitionRevisions = Effect2.fn("Client.listSkillDefinitionRevisions.call")(function* (id) {
-  const service = yield* Service2;
-  return yield* service.listSkillDefinitionRevisions(id);
-});
-var registerAddressBookRoute = Effect2.fn("Client.registerAddressBookRoute.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.registerAddressBookRoute(input);
-});
-var getAddressBookRoute = Effect2.fn("Client.getAddressBookRoute.call")(function* (id) {
-  const service = yield* Service2;
-  return yield* service.getAddressBookRoute(id);
-});
-var listAddressBookRoutes = Effect2.fn("Client.listAddressBookRoutes.call")(function* () {
-  const service = yield* Service2;
-  return yield* service.listAddressBookRoutes();
-});
-var startExecution = Effect2.fn("Client.startExecution.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.startExecution(input);
-});
-var startExecutionByAddress = Effect2.fn("Client.startExecutionByAddress.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.startExecutionByAddress(input);
-});
-var startExecutionByAgentDefinition = Effect2.fn("Client.startExecutionByAgentDefinition.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.startExecutionByAgentDefinition(input);
-});
-var cancelExecution = Effect2.fn("Client.cancelExecution.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.cancelExecution(input);
-});
-var steer = Effect2.fn("Client.steer.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.steer(input);
-});
-var getExecution = Effect2.fn("Client.getExecution.call")(function* (id) {
-  const service = yield* Service2;
-  return yield* service.getExecution(id);
-});
-var listExecutions = Effect2.fn("Client.listExecutions.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.listExecutions(input);
-});
-var listSessions = Effect2.fn("Client.listSessions.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.listSessions(input);
-});
-var getSession = Effect2.fn("Client.getSession.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.getSession(input);
-});
-var listWaits = Effect2.fn("Client.listWaits.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.listWaits(input);
-});
-var replayExecution = Effect2.fn("Client.replayExecution.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.replayExecution(input);
-});
-var pageExecutionEvents = Effect2.fn("Client.pageExecutionEvents.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.pageExecutionEvents(input);
-});
-var listRunners = Effect2.fn("Client.listRunners.call")(function* () {
-  const service = yield* Service2;
-  return yield* service.listRunners();
-});
-var routeExecution = Effect2.fn("Client.routeExecution.call")(function* (executionId) {
-  const service = yield* Service2;
-  return yield* service.routeExecution(executionId);
-});
-var subscribeTopic = Effect2.fn("Client.subscribeTopic.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.subscribeTopic(input);
-});
-var unsubscribeTopic = Effect2.fn("Client.unsubscribeTopic.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.unsubscribeTopic(input);
-});
-var publishTopic = Effect2.fn("Client.publishTopic.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.publishTopic(input);
-});
-var listTopicSubscriptions = Effect2.fn("Client.listTopicSubscriptions.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.listTopicSubscriptions(input);
-});
-var listInboxMessages = Effect2.fn("Client.listInboxMessages.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.listInboxMessages(input);
-});
-var inspectExecution = Effect2.fn("Client.inspectExecution.call")(function* (executionId) {
-  const service = yield* Service2;
-  return yield* service.inspectExecution(executionId);
-});
-var send = Effect2.fn("Client.send.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.send(input);
-});
-var streamExecution = (input) => Stream.unwrap(Service2.pipe(Effect2.map((service) => service.streamExecution(input))));
-var followExecution = (input) => Stream.unwrap(Service2.pipe(Effect2.map((service) => service.followExecution(input))));
-var streamSession = (input) => Stream.unwrap(Service2.pipe(Effect2.map((service) => service.streamSession(input))));
-var watchExecutions = (input) => Stream.unwrap(Service2.pipe(Effect2.map((service) => service.watchExecutions(input))));
-var getPresence = Effect2.fn("Client.getPresence.call")(function* (scope) {
-  const service = yield* Service2;
-  return yield* service.getPresence(scope);
-});
-var watchPresence = (scope) => Stream.unwrap(Service2.pipe(Effect2.map((service) => service.watchPresence(scope))));
-var wake = Effect2.fn("Client.wake.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.wake(input);
-});
-var listPendingApprovals = Effect2.fn("Client.listPendingApprovals.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.listPendingApprovals(input);
-});
-var resolveToolApproval = Effect2.fn("Client.resolveToolApproval.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.resolveToolApproval(input);
-});
-var resolvePermission = Effect2.fn("Client.resolvePermission.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.resolvePermission(input);
-});
-var listPendingToolCalls = Effect2.fn("Client.listPendingToolCalls.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.listPendingToolCalls(input);
-});
-var fulfillToolCall = Effect2.fn("Client.fulfillToolCall.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.fulfillToolCall(input);
-});
-var claimToolWork = Effect2.fn("Client.claimToolWork.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.claimToolWork(input);
-});
-var completeToolWork = Effect2.fn("Client.completeToolWork.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.completeToolWork(input);
-});
-var releaseToolWork = Effect2.fn("Client.releaseToolWork.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.releaseToolWork(input);
-});
-var listToolAttempts = Effect2.fn("Client.listToolAttempts.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.listToolAttempts(input);
-});
-var submitInboundEnvelope = Effect2.fn("Client.submitInboundEnvelope.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.submitInboundEnvelope(input);
-});
-var spawnChildRun = Effect2.fn("Client.spawnChildRun.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.spawnChildRun(input);
-});
-var createChildFanOut = Effect2.fn("Client.createChildFanOut.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.createChildFanOut(input);
-});
-var cancelChildFanOut = Effect2.fn("Client.cancelChildFanOut.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.cancelChildFanOut(input);
-});
-var inspectChildFanOut = Effect2.fn("Client.inspectChildFanOut.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.inspectChildFanOut(input);
-});
-var claimEnvelopeReady = Effect2.fn("Client.claimEnvelopeReady.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.claimEnvelopeReady(input);
-});
-var ackEnvelopeReady = Effect2.fn("Client.ackEnvelopeReady.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.ackEnvelopeReady(input);
-});
-var releaseEnvelopeReady = Effect2.fn("Client.releaseEnvelopeReady.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.releaseEnvelopeReady(input);
-});
-var createSchedule = Effect2.fn("Client.createSchedule.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.createSchedule(input);
-});
-var cancelSchedule = Effect2.fn("Client.cancelSchedule.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.cancelSchedule(input);
-});
-var listSchedules = Effect2.fn("Client.listSchedules.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.listSchedules(input);
-});
-var askEntity = Effect2.fn("Client.askEntity.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.askEntity(input);
-});
-var awaitWait = Effect2.fn("Client.awaitWait.call")(function* (input) {
-  const service = yield* Service2;
-  return yield* service.awaitWait(input);
-});
-
-// src/runtime.ts
-var exports_runtime = {};
-__export(exports_runtime, {
-  makeDatabaseIdentity: () => makeDatabaseIdentity,
-  layerRunner: () => layerRunner,
-  layerEmbedded: () => layerEmbedded,
-  layerClient: () => layerClient,
-  UnsupportedTopology: () => UnsupportedTopology,
-  SqlFailure: () => SqlFailure,
-  SqlDialect: () => SqlDialect,
-  Service: () => Service4,
-  SchemaHeadMismatch: () => SchemaHeadMismatch,
-  RuntimeTopologyError: () => RuntimeTopologyError,
-  RuntimeTopologyCause: () => RuntimeTopologyCause,
-  RuntimeReadinessError: () => RuntimeReadinessError,
-  RuntimeReadinessCause: () => RuntimeReadinessCause,
-  RuntimeMigrationError: () => RuntimeMigrationError,
-  RuntimeMigrationCause: () => RuntimeMigrationCause,
-  RuntimeDatabase: () => exports_runtime_database,
-  RuntimeConfigurationError: () => RuntimeConfigurationError,
-  RuntimeConfigurationCause: () => RuntimeConfigurationCause,
-  RuntimeCapabilityUnavailable: () => RuntimeCapabilityUnavailable,
-  NotificationFailure: () => NotificationFailure,
-  MigratorError: () => MigratorError,
-  HostUnavailable: () => HostUnavailable,
-  HostLayerError: () => HostLayerError,
-  Dialect: () => Dialect,
-  DatabaseIdentity: () => DatabaseIdentity,
-  DatabaseDialectMismatch: () => DatabaseDialectMismatch,
-  DatabaseDialect: () => DatabaseDialect,
-  DatabaseAlreadyOwned: () => DatabaseAlreadyOwned,
-  ConfigFailure: () => ConfigFailure,
-  ClusterFailure: () => ClusterFailure
-});
-import { Cause, Context as Context4, Effect as Effect3, Layer as Layer3, Schema as Schema5 } from "effect";
-import { SqlClient } from "effect/unstable/sql/SqlClient";
-
-// src/runtime-database.ts
-var exports_runtime_database = {};
-__export(exports_runtime_database, {
-  Service: () => Service3,
-  Dialect: () => Dialect
-});
-import { Context as Context3 } from "effect";
-
-class Service3 extends Context3.Service()("@relayfx/sdk/runtime-database/Service") {
-}
-
-// src/runtime.ts
-var DatabaseIdentity = Schema5.NonEmptyString.pipe(Schema5.brand("@relayfx/sdk/DatabaseIdentity"));
-var decodeDatabaseIdentity = Schema5.decodeUnknownSync(DatabaseIdentity);
-var makeDatabaseIdentity = (input) => decodeDatabaseIdentity(input);
-var Dialect = Schema5.Literals(["pg", "mysql", "sqlite"]);
-var DatabaseDialect = Symbol("@relayfx/sdk/DatabaseDialect");
-
-class HostLayerError extends Schema5.TaggedErrorClass()("HostLayerError", {
-  service: Schema5.String,
-  reason: Schema5.String
-}) {
-}
-
-class ConfigFailure extends Schema5.TaggedErrorClass()("ConfigFailure", {
-  reason: Schema5.String
-}) {
-}
-
-class NotificationFailure extends Schema5.TaggedErrorClass()("NotificationFailure", {
-  reason: Schema5.String
-}) {
-}
-
-class ClusterFailure extends Schema5.TaggedErrorClass()("ClusterFailure", {
-  reason: Schema5.String
-}) {
-}
-
-class SqlFailure extends Schema5.TaggedErrorClass()("SqlFailure", {
-  category: Schema5.Literals(["connection", "statement", "unknown"]),
-  operation: Schema5.Literals(["acquire", "migrate", "verify", "notify", "readiness"]),
-  retryable: Schema5.Boolean
-}) {
-}
-var SqlDialect = Schema5.Literals(["sqlite", "pg", "mysql", "mssql", "clickhouse"]);
-
-class DatabaseDialectMismatch extends Schema5.TaggedErrorClass()("DatabaseDialectMismatch", { expected: Dialect, actual: SqlDialect }) {
-}
-
-class DatabaseAlreadyOwned extends Schema5.TaggedErrorClass()("DatabaseAlreadyOwned", {
-  databaseIdentity: DatabaseIdentity
-}) {
-}
-
-class UnsupportedTopology extends Schema5.TaggedErrorClass()("UnsupportedTopology", {
-  reason: Schema5.String
-}) {
-}
-
-class MigratorError extends Schema5.TaggedErrorClass()("MigratorError", {
-  reason: Schema5.String
-}) {
-}
-
-class SchemaHeadMismatch extends Schema5.TaggedErrorClass()("SchemaHeadMismatch", {
-  expected: Schema5.String,
-  actual: Schema5.String
-}) {
-}
-
-class HostUnavailable extends Schema5.TaggedErrorClass()("HostUnavailable", {
-  host: Schema5.String,
-  reason: Schema5.String
-}) {
-}
-var RuntimeConfigurationCause = Schema5.Union([
-  ConfigFailure,
-  HostLayerError
-]);
-var RuntimeTopologyCause = Schema5.Union([
-  ClusterFailure,
-  DatabaseDialectMismatch,
-  DatabaseAlreadyOwned,
-  UnsupportedTopology
-]);
-var RuntimeMigrationCause = Schema5.Union([
-  SqlFailure,
-  MigratorError,
-  SchemaHeadMismatch
-]);
-var RuntimeReadinessCause = Schema5.Union([
-  SqlFailure,
-  NotificationFailure,
-  ClusterFailure,
-  HostUnavailable
-]);
-
-class RuntimeConfigurationError extends Schema5.TaggedErrorClass()("RuntimeConfigurationError", {
-  setting: Schema5.String,
-  nextAction: Schema5.Literals(["provide-setting", "provide-host-layer"]),
-  cause: RuntimeConfigurationCause
-}) {
-}
-
-class RuntimeTopologyError extends Schema5.TaggedErrorClass()("RuntimeTopologyError", {
-  dialect: Dialect,
-  role: Schema5.Literals(["embedded", "runner", "client"]),
-  nextAction: Schema5.Literals([
-    "use-embedded",
-    "use-postgres-or-mysql",
-    "use-client-constructor",
-    "reuse-runtime",
-    "use-different-database"
-  ]),
-  cause: RuntimeTopologyCause
-}) {
-}
-
-class RuntimeMigrationError extends Schema5.TaggedErrorClass()("RuntimeMigrationError", {
-  dialect: Dialect,
-  phase: Schema5.Literals(["apply", "verify"]),
-  nextAction: Schema5.Literals(["retry", "inspect-schema", "run-compatible-release"]),
-  cause: RuntimeMigrationCause
-}) {
-}
-
-class RuntimeReadinessError extends Schema5.TaggedErrorClass()("RuntimeReadinessError", {
-  phase: Schema5.Literals(["database", "notification", "cluster", "hosts"]),
-  cause: RuntimeReadinessCause
-}) {
-}
-
-class Service4 extends Context4.Service()("@relayfx/sdk/runtime/Service") {
-}
-var embeddedOutput = (layer2) => layer2;
-var isAcquisitionError = (error) => typeof error === "object" && error !== null && ("_tag" in error) && (error._tag === "RuntimeConfigurationError" || error._tag === "RuntimeTopologyError" || error._tag === "RuntimeMigrationError");
-var normalizeHost = (layer2, role, dialect) => {
-  const normalize = (error) => {
-    if (isAcquisitionError(error))
-      return error;
-    if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "ClusterConfigMismatch") {
-      const clusterFailure = ClusterFailure.make({ reason: "cluster configuration is incompatible" });
-      Object.defineProperty(clusterFailure, "originalCause", { value: error, enumerable: false });
-      return RuntimeTopologyError.make({
-        dialect,
-        role,
-        nextAction: role === "embedded" ? "use-embedded" : "use-different-database",
-        cause: clusterFailure
-      });
-    }
-    const hostFailure = HostLayerError.make({
-      service: "Runtime host graph",
-      reason: "host layer acquisition failed"
-    });
-    Object.defineProperty(hostFailure, "originalCause", { value: error, enumerable: false });
-    return RuntimeConfigurationError.make({
-      setting: "host layers",
-      nextAction: "provide-host-layer",
-      cause: hostFailure
-    });
-  };
-  return layer2.pipe(Layer3.catchCause((cause) => {
-    if (Cause.hasInterrupts(cause))
-      return Layer3.unwrap(Effect3.failCause(Cause.map(cause, normalize)));
-    return Layer3.unwrap(Effect3.fail(normalize(Cause.squash(cause))));
-  }));
-};
-var actualDialect = (sql) => sql.onDialectOrElse({
-  sqlite: () => "sqlite",
-  pg: () => "pg",
-  mysql: () => "mysql",
-  mssql: () => "mssql",
-  clickhouse: () => "clickhouse",
-  orElse: () => "clickhouse"
-});
-var ambientDatabaseLayer = Layer3.effect(SqlClient, SqlClient);
-var validatedDatabase = (databaseLayer, role) => {
-  const validatedService = Layer3.effect(Service3, Effect3.gen(function* () {
-    const database = yield* Service3;
-    const sql = yield* SqlClient;
-    const actual = actualDialect(sql);
-    if (actual !== database.dialect) {
-      return yield* RuntimeTopologyError.make({
-        dialect: database.dialect,
-        role,
-        nextAction: role === "embedded" ? "use-different-database" : "use-postgres-or-mysql",
-        cause: DatabaseDialectMismatch.make({ expected: database.dialect, actual })
-      });
-    }
-    if (database.dialect === "sqlite") {
-      yield* database.acquireSchema;
-    } else {
-      yield* database.verifySchema;
-    }
-    return database;
-  }));
-  const sqlLayer = Layer3.effect(SqlClient, SqlClient);
-  return Layer3.merge(sqlLayer, validatedService).pipe(Layer3.provide(databaseLayer));
-};
-var runtimeServiceLayer = (role, capabilities) => Layer3.effect(Service4, Effect3.gen(function* () {
-  const database = yield* Service3;
-  const runner = yield* exports_runner_runtime_service.Service;
-  return Service4.of({
-    readiness: runner.check.pipe(Effect3.mapError((error) => {
-      const cause = SqlFailure.make({ category: "unknown", operation: "readiness", retryable: false });
-      Object.defineProperty(cause, "originalCause", { value: error, enumerable: false });
-      return RuntimeReadinessError.make({ phase: "database", cause });
-    }), Effect3.as({
-      ready: true,
-      role,
-      dialect: database.dialect,
-      databaseIdentity: database.databaseIdentity,
-      schemaHead: database.schemaHead,
-      notification: database.notification,
-      capabilities: {
-        fanOut: capabilities.fanOut ? { enabled: true, source: "local-host", health: "healthy" } : {
-          enabled: false,
-          source: role === "embedded" ? "local-host" : "role-unavailable",
-          health: "not-applicable"
-        },
-        workflowDefinition: capabilities.workflowDefinition ? { enabled: true, source: "local-host", health: "healthy" } : {
-          enabled: false,
-          source: role === "embedded" ? "local-host" : "role-unavailable",
-          health: "not-applicable"
-        }
-      }
-    }))
-  });
-}));
-var publicGraph = (runner, databaseLayer, role, capabilities = { fanOut: false, workflowDefinition: false }) => {
-  const database = validatedDatabase(databaseLayer, role);
-  const graph = runner.pipe(Layer3.provideMerge(database));
-  const policy = layer(role, capabilities);
-  return Layer3.merge(Layer3.fresh(layerFromRuntime).pipe(Layer3.provideMerge(policy)), runtimeServiceLayer(role, capabilities)).pipe(Layer3.provide(graph));
-};
-var withHosts = (runner, options) => {
-  const childHost = options.childFanOutHandlersLayer === undefined ? Layer3.empty : exports_child_fan_out_runtime.layerFromRuntime.pipe(Layer3.provide(options.childFanOutHandlersLayer), Layer3.provide(exports_child_fan_out_transition_service.layer), Layer3.provide(runner));
-  const workflowHost = options.workflowDefinitionHandlersLayer === undefined ? Layer3.empty : exports_definition_runtime.layerFromRuntime.pipe(Layer3.provide(options.workflowDefinitionHandlersLayer), Layer3.provideMerge(childHost), Layer3.provide(runner));
-  return Layer3.mergeAll(runner, childHost, workflowHost);
-};
-function layerEmbedded(options) {
-  const runner = exports_runner_runtime_service.layerWithServices({
-    databaseLayer: ambientDatabaseLayer,
-    languageModelLayer: options.languageModelLayer,
-    toolRuntimeLayer: options.toolRuntimeLayer,
-    embeddingModelLayer: options.embeddingModelLayer,
-    blobStoreLayer: options.blobStoreLayer,
-    artifactStoreLayer: options.artifactStoreLayer,
-    promptAssemblerLayer: options.promptAssemblerLayer,
-    schemaRegistryLayer: options.schemaRegistryLayer
-  });
-  const host = normalizeHost(publicGraph(withHosts(runner, options), options.databaseLayer, "embedded", {
-    fanOut: options.childFanOutHandlersLayer !== undefined,
-    workflowDefinition: options.workflowDefinitionHandlersLayer !== undefined
-  }), "embedded", options.databaseLayer[DatabaseDialect]);
-  return embeddedOutput(host);
-}
-var layerRunner = (options) => {
-  const runner = exports_runner_runtime_service.layerWithServicesMultiNode({
-    databaseLayer: ambientDatabaseLayer,
-    languageModelLayer: options.languageModelLayer,
-    toolRuntimeLayer: options.toolRuntimeLayer,
-    embeddingModelLayer: options.embeddingModelLayer,
-    blobStoreLayer: options.blobStoreLayer,
-    artifactStoreLayer: options.artifactStoreLayer,
-    promptAssemblerLayer: options.promptAssemblerLayer,
-    schemaRegistryLayer: options.schemaRegistryLayer,
-    cluster: options.cluster
-  });
-  return normalizeHost(publicGraph(runner, options.databaseLayer, "runner"), "runner", options.databaseLayer[DatabaseDialect]);
-};
-var layerClient = (options) => {
-  const runner = exports_runner_runtime_service.layerWithServicesMultiNodeClientOnly({
-    databaseLayer: ambientDatabaseLayer,
-    languageModelLayer: exports_language_model_service.layer(),
-    toolRuntimeLayer: exports_tool_runtime_service.layer(),
-    cluster: options.cluster
-  });
-  return normalizeHost(publicGraph(runner, options.databaseLayer, "client"), "client", options.databaseLayer[DatabaseDialect]);
-};
-
-export { exports_operation, exports_command, Service2 as Service, exports_client, exports_runtime_database, makeDatabaseIdentity, DatabaseDialect, ConfigFailure, SqlFailure, DatabaseAlreadyOwned, MigratorError, SchemaHeadMismatch, RuntimeConfigurationError, RuntimeTopologyError, RuntimeMigrationError, exports_runtime };