@relayfx/sdk 0.7.3 → 0.7.5

package/dist/{index-syx9q5v3.js → index-nb078xsy.js}

@@ -10,20 +10,21 @@ import { Equal, Schema as Schema2 } from "effect";
 import { dual } from "effect/Function";
 import { Schema as Schema5 } from "effect";
 import { JsonSchema, Schema as Schema4, SchemaRepresentation } from "effect";
+import { Schema as Schema9 } from "effect";
 import { Schema as Schema8 } from "effect";
-import { Schema as Schema7 } from "effect";
 import { Schema as Schema6 } from "effect";
-import { Schema as Schema9 } from "effect";
-import { Schema as Schema11 } from "effect";
+import { Schema as Schema7 } from "effect";
 import { Schema as Schema10 } from "effect";
 import { Schema as Schema12 } from "effect";
+import { Schema as Schema11 } from "effect";
 import { Schema as Schema13 } from "effect";
 import { Schema as Schema14 } from "effect";
 import { Schema as Schema15 } from "effect";
 import { Schema as Schema16 } from "effect";
 import { Schema as Schema17 } from "effect";
-import { Encoding, Schema as Schema18 } from "effect";
-import { Schema as Schema19 } from "effect";
+import { Schema as Schema18 } from "effect";
+import { Encoding, Schema as Schema19 } from "effect";
+import { Schema as Schema20 } from "effect";
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -343,6 +344,7 @@ var ModelSelection = Schema5.Struct({
   metadata: Schema5.optionalKey(Metadata)
 }).annotate({ identifier: "Relay.Agent.ModelSelection" });
 var PositiveSafeInteger = Schema5.Finite.check(Schema5.makeFilter((value) => Number.isSafeInteger(value) && value > 0 ? undefined : "must be a positive safe integer"));
+var ToolExecutionConcurrency = Schema5.Union([PositiveSafeInteger, Schema5.Literal("unbounded")]);
 var CompactionPolicy = Schema5.Struct({
   context_window: PositiveSafeInteger,
   reserve_tokens: PositiveSafeInteger,
@@ -449,7 +451,7 @@ var DefinitionSchema = Schema5.Struct({
   permission_rules: Schema5.optionalKey(PermissionRuleset),
   turn_policy: Schema5.optionalKey(TurnPolicySnapshot),
   tool_execution: Schema5.optionalKey(Schema5.Struct({
-    concurrency: PositiveSafeInteger
+    concurrency: ToolExecutionConcurrency
   })),
   compaction_policy: Schema5.optionalKey(CompactionPolicy),
   max_tool_turns: Schema5.optionalKey(Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(1))),
@@ -524,19 +526,43 @@ __export2(exports_child_orchestration_schema, {
 var exports_execution_schema = {};
 __export2(exports_execution_schema, {
   steeringMessageId: () => steeringMessageId,
+  executionOriginMetadataKey: () => executionOriginMetadataKey,
   childSessionId: () => childSessionId,
   SpawnChildRunInput: () => SpawnChildRunInput,
+  ModelUsageReportedEventData: () => ModelUsageReportedEventData,
+  ModelUsage: () => ModelUsage,
+  ModelRetryScheduledEventData: () => ModelRetryScheduledEventData,
+  ModelRetryReason: () => ModelRetryReason,
+  ModelFirstOutputKind: () => ModelFirstOutputKind,
+  ModelFinishReason: () => ModelFinishReason,
+  ModelFailureClassification: () => ModelFailureClassification,
+  ModelFailureCategory: () => ModelFailureCategory,
+  ModelCallStartedEventData: () => ModelCallStartedEventData,
+  ModelCallPurpose: () => ModelCallPurpose,
+  ModelCallFailedEventData: () => ModelCallFailedEventData,
+  ModelCallCompletedEventData: () => ModelCallCompletedEventData,
+  ModelAttemptStartedEventData: () => ModelAttemptStartedEventData,
+  ModelAttemptFirstOutputEventData: () => ModelAttemptFirstOutputEventData,
+  ModelAttemptFailedEventData: () => ModelAttemptFailedEventData,
+  ModelAttemptCompletedEventData: () => ModelAttemptCompletedEventData,
   ExecutionStatus: () => ExecutionStatus,
+  ExecutionOriginBuild: () => ExecutionOriginBuild,
+  ExecutionOrigin: () => ExecutionOrigin,
   ExecutionEventType: () => ExecutionEventType,
   ExecutionEventSequence: () => ExecutionEventSequence,
   ExecutionEvent: () => ExecutionEvent,
   Execution: () => Execution,
+  CompactionTrigger: () => CompactionTrigger,
   CompactionStartedEventData: () => CompactionStartedEventData,
+  CompactionKind: () => CompactionKind,
+  CompactionFailedEventData: () => CompactionFailedEventData,
+  CompactionCompletedEventData: () => CompactionCompletedEventData,
   CompactionCommittedEventData: () => CompactionCommittedEventData,
   ChildRunPreset: () => ChildRunPreset2,
   ChildRunOverride: () => ChildRunOverride,
   ChildRunContext: () => ChildRunContext,
-  ChildRunAccepted: () => ChildRunAccepted
+  ChildRunAccepted: () => ChildRunAccepted,
+  AnalyticalExecutionEvent: () => AnalyticalExecutionEvent
 });
 var exports_content_schema = {};
 __export2(exports_content_schema, {
@@ -598,7 +624,174 @@ var Part = Schema6.Union([
   ToolResultPart
 ]).pipe(Schema6.toTaggedUnion("type")).annotate({ identifier: "Relay.Content.Part" });
 var text = (value) => ({ type: "text", text: value });
-var ExecutionStatus = Schema7.Literals([
+var ModelCallPurpose = Schema7.Literals(["conversation", "structured-output", "compaction-summary"]);
+var ModelFailureCategory = Schema7.Literals([
+  "authentication",
+  "rate-limit",
+  "transport",
+  "provider-response",
+  "stream-decode",
+  "context-overflow",
+  "invalid-tool-call",
+  "token-budget",
+  "timeout",
+  "cancellation",
+  "unknown"
+]);
+var ModelFailureClassification = Schema7.Literals(["transient", "terminal"]);
+var ModelRetryReason = Schema7.Literals(["provider-resilience", "invalid-tool-call-correction"]);
+var ModelFirstOutputKind = Schema7.Literals(["reasoning", "text", "tool-call"]);
+var ModelFinishReason = Schema7.Literals([
+  "stop",
+  "length",
+  "content-filter",
+  "tool-calls",
+  "error",
+  "pause",
+  "other",
+  "unknown"
+]);
+var CompactionTrigger = Schema7.Literals(["threshold", "overflow"]);
+var CompactionKind = Schema7.Literals(["microcompact", "summarize", "unchanged"]);
+var turn = Schema7.Int.check(Schema7.isGreaterThanOrEqualTo(0));
+var attempt = Schema7.Int.check(Schema7.isGreaterThanOrEqualTo(0));
+var nullableCount = Schema7.NullOr(Schema7.Int.check(Schema7.isGreaterThanOrEqualTo(0)));
+var ModelUsage = Schema7.Struct({
+  input_tokens: nullableCount,
+  input_tokens_uncached: nullableCount,
+  input_tokens_cache_read: nullableCount,
+  input_tokens_cache_write: nullableCount,
+  output_tokens: nullableCount,
+  output_tokens_reasoning: nullableCount,
+  output_tokens_text: Schema7.optionalKey(nullableCount)
+}).annotate({ identifier: "Relay.ModelUsage" });
+var delivery = {
+  telemetry_session_id: Schema7.optionalKey(NonEmptyString),
+  delivery_id: Schema7.optionalKey(NonEmptyString)
+};
+var call = { turn, model_call_id: NonEmptyString, ...delivery };
+var modelAttempt = { ...call, model_attempt_id: NonEmptyString, attempt };
+var ModelCallStartedEventData = Schema7.Struct({
+  ...call,
+  purpose: ModelCallPurpose,
+  provider: Schema7.optionalKey(Schema7.String),
+  model: Schema7.optionalKey(Schema7.String),
+  compaction_id: Schema7.optionalKey(NonEmptyString),
+  started_at: TimestampMillis
+});
+var ModelAttemptStartedEventData = Schema7.Struct({ ...modelAttempt, started_at: TimestampMillis });
+var ModelAttemptFirstOutputEventData = Schema7.Struct({
+  ...modelAttempt,
+  kind: ModelFirstOutputKind,
+  at: TimestampMillis
+});
+var ModelAttemptCompletedEventData = Schema7.Struct({
+  ...modelAttempt,
+  completed_at: TimestampMillis,
+  usage: Schema7.optionalKey(ModelUsage),
+  usage_at: Schema7.optionalKey(TimestampMillis),
+  finish_reason: Schema7.optionalKey(ModelFinishReason),
+  request_id: Schema7.optionalKey(Schema7.String),
+  response_model: Schema7.optionalKey(Schema7.String),
+  service_tier: Schema7.optionalKey(Schema7.String),
+  cost: Schema7.optionalKey(Schema7.Struct({ amount: Schema7.Finite, currency: Schema7.String }))
+});
+var ModelAttemptFailedEventData = Schema7.Struct({
+  ...modelAttempt,
+  failed_at: TimestampMillis,
+  category: ModelFailureCategory,
+  classification: ModelFailureClassification
+});
+var ModelRetryScheduledEventData = Schema7.Struct({
+  ...call,
+  attempt,
+  reason: ModelRetryReason,
+  category: ModelFailureCategory,
+  delay_millis: Schema7.Finite.check(Schema7.isGreaterThanOrEqualTo(0)),
+  at: TimestampMillis
+});
+var ModelCallCompletedEventData = Schema7.Struct({
+  ...call,
+  purpose: ModelCallPurpose,
+  attempts: attempt,
+  completed_at: TimestampMillis,
+  usage: Schema7.optionalKey(ModelUsage),
+  finish_reason: Schema7.optionalKey(ModelFinishReason)
+});
+var ModelCallFailedEventData = Schema7.Struct({
+  ...call,
+  purpose: ModelCallPurpose,
+  attempts: attempt,
+  failed_at: TimestampMillis,
+  category: ModelFailureCategory
+});
+var CompactionStartedEventData = Schema7.Struct({
+  turn,
+  compaction_id: NonEmptyString,
+  ...delivery,
+  trigger: CompactionTrigger,
+  started_at: TimestampMillis,
+  context_tokens_before: Schema7.optionalKey(Schema7.Finite),
+  entries_before: Schema7.optionalKey(Schema7.Finite)
+});
+var CompactionCompletedEventData = Schema7.Struct({
+  turn,
+  compaction_id: NonEmptyString,
+  ...delivery,
+  kind: CompactionKind,
+  completed_at: TimestampMillis,
+  summary_model_call_id: Schema7.optionalKey(NonEmptyString)
+});
+var CompactionFailedEventData = Schema7.Struct({
+  turn,
+  compaction_id: NonEmptyString,
+  ...delivery,
+  failed_at: TimestampMillis
+});
+var CompactionCommittedEventData = Schema7.Struct({
+  checkpoint_id: SessionEntryId,
+  session_id: SessionId,
+  compaction_id: NonEmptyString,
+  summary_model_call_id: Schema7.optionalKey(NonEmptyString),
+  context_tokens_before: Schema7.optionalKey(Schema7.Finite),
+  context_tokens_after: Schema7.optionalKey(Schema7.Finite),
+  entries_before: Schema7.optionalKey(Schema7.Finite),
+  entries_after: Schema7.optionalKey(Schema7.Finite)
+}).annotate({ identifier: "Relay.CompactionCommittedEventData" });
+var ModelUsageReportedEventData = Schema7.Struct({
+  ...modelAttempt,
+  provider: NonEmptyString,
+  model: NonEmptyString,
+  model_snapshot: Schema7.optionalKey(NonEmptyString),
+  service_tier: Schema7.optionalKey(NonEmptyString),
+  finish_reason: Schema7.optionalKey(ModelFinishReason),
+  usage_at: TimestampMillis,
+  ...ModelUsage.fields
+}).annotate({ identifier: "Relay.ModelUsageReportedEventData" });
+var envelope = {
+  id: EventId,
+  execution_id: ExecutionId,
+  sequence: Schema7.Int.check(Schema7.isGreaterThanOrEqualTo(0)),
+  cursor: NonEmptyString,
+  created_at: TimestampMillis
+};
+var analytical = (type, data) => Schema7.Struct({ ...envelope, type: Schema7.Literal(type), data });
+var AnalyticalExecutionEvent = Schema7.Union([
+  analytical("model.call.started", ModelCallStartedEventData),
+  analytical("model.attempt.started", ModelAttemptStartedEventData),
+  analytical("model.attempt.first_output", ModelAttemptFirstOutputEventData),
+  analytical("model.attempt.completed", ModelAttemptCompletedEventData),
+  analytical("model.attempt.failed", ModelAttemptFailedEventData),
+  analytical("model.retry.scheduled", ModelRetryScheduledEventData),
+  analytical("model.call.completed", ModelCallCompletedEventData),
+  analytical("model.call.failed", ModelCallFailedEventData),
+  analytical("agent.compaction.started", CompactionStartedEventData),
+  analytical("agent.compaction.completed", CompactionCompletedEventData),
+  analytical("agent.compaction.failed", CompactionFailedEventData),
+  analytical("agent.compaction.committed", CompactionCommittedEventData),
+  analytical("model.usage.reported", ModelUsageReportedEventData)
+]).annotate({ identifier: "Relay.AnalyticalExecutionEvent" });
+var ExecutionStatus = Schema8.Literals([
   "queued",
   "running",
   "waiting",
@@ -606,69 +799,83 @@ var ExecutionStatus = Schema7.Literals([
   "failed",
   "cancelled"
 ]).annotate({ identifier: "Relay.ExecutionStatus" });
-var Execution = Schema7.Struct({
+var boundedIdentity = (maxLength) => NonEmptyString.check(Schema8.isMaxLength(maxLength));
+var ExecutionOriginBuild = Schema8.Struct({
+  name: boundedIdentity(128),
+  version: Schema8.optionalKey(boundedIdentity(128)),
+  commit: Schema8.optionalKey(boundedIdentity(256))
+}).annotate({ identifier: "Relay.ExecutionOriginBuild" });
+var ExecutionOrigin = Schema8.Struct({
+  owner_kind: Schema8.Literals(["service", "user", "workflow", "system"]),
+  owner: boundedIdentity(256),
+  purpose: boundedIdentity(256),
+  build: Schema8.optionalKey(ExecutionOriginBuild)
+}).annotate({ identifier: "Relay.ExecutionOrigin" });
+var executionOriginMetadataKey = "relay_origin";
+var Execution = Schema8.Struct({
   id: ExecutionId,
   root_address_id: AddressId,
-  session_id: Schema7.optionalKey(SessionId),
+  session_id: Schema8.optionalKey(SessionId),
   status: ExecutionStatus,
-  agent_id: Schema7.optionalKey(AgentId),
-  agent_revision: Schema7.optionalKey(DefinitionRevision),
-  agent_snapshot: Schema7.optionalKey(Definition2),
-  agent_tool_input_schema_digests: Schema7.optionalKey(ToolInputSchemaDigests),
-  metadata: Schema7.optionalKey(Metadata),
+  agent_id: Schema8.optionalKey(AgentId),
+  agent_revision: Schema8.optionalKey(DefinitionRevision),
+  agent_snapshot: Schema8.optionalKey(Definition2),
+  agent_tool_input_schema_digests: Schema8.optionalKey(ToolInputSchemaDigests),
+  origin: Schema8.optionalKey(ExecutionOrigin),
+  metadata: Schema8.optionalKey(Metadata),
   created_at: TimestampMillis,
   updated_at: TimestampMillis
 }).annotate({ identifier: "Relay.Execution" });
-var ExecutionEventSequence = Schema7.Int.check(Schema7.isGreaterThanOrEqualTo(0)).annotate({
+var ExecutionEventSequence = Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(0)).annotate({
   identifier: "Relay.ExecutionEventSequence"
 });
-var ChildRunContext = Schema7.Struct({
-  instructions: Schema7.optionalKey(Schema7.String),
-  model: Schema7.optionalKey(ModelSelection),
-  compaction_policy: Schema7.optionalKey(CompactionPolicy),
-  tool_names: Schema7.Array(Schema7.String),
-  permissions: Schema7.Array(Schema7.String),
-  output_schema_ref: Schema7.optionalKey(Schema7.String),
-  metadata: Schema7.optionalKey(Metadata)
+var ChildRunContext = Schema8.Struct({
+  instructions: Schema8.optionalKey(Schema8.String),
+  model: Schema8.optionalKey(ModelSelection),
+  compaction_policy: Schema8.optionalKey(CompactionPolicy),
+  tool_names: Schema8.Array(Schema8.String),
+  permissions: Schema8.Array(Schema8.String),
+  output_schema_ref: Schema8.optionalKey(Schema8.String),
+  metadata: Schema8.optionalKey(Metadata)
 }).annotate({ identifier: "Relay.ChildRunContext" });
-var ChildRunOverride = Schema7.Struct({
-  instructions: Schema7.optionalKey(Schema7.String),
-  model: Schema7.optionalKey(ModelSelection),
-  compaction_policy: Schema7.optionalKey(CompactionPolicy),
-  tool_names: Schema7.optionalKey(Schema7.Array(Schema7.String)),
-  permissions: Schema7.optionalKey(Schema7.Array(Schema7.String)),
-  workspace_policy: Schema7.optionalKey(ChildRunWorkspacePolicy),
-  output_schema_ref: Schema7.optionalKey(Schema7.String),
-  metadata: Schema7.optionalKey(Metadata)
+var ChildRunOverride = Schema8.Struct({
+  instructions: Schema8.optionalKey(Schema8.String),
+  model: Schema8.optionalKey(ModelSelection),
+  compaction_policy: Schema8.optionalKey(CompactionPolicy),
+  tool_names: Schema8.optionalKey(Schema8.Array(Schema8.String)),
+  permissions: Schema8.optionalKey(Schema8.Array(Schema8.String)),
+  workspace_policy: Schema8.optionalKey(ChildRunWorkspacePolicy),
+  output_schema_ref: Schema8.optionalKey(Schema8.String),
+  metadata: Schema8.optionalKey(Metadata)
 }).annotate({ identifier: "Relay.ChildRunOverride" });
 var ChildRunPreset2 = ChildRunOverride.annotate({ identifier: "Relay.ChildRunPreset" });
-var SpawnChildRunInput = Schema7.Struct({
+var SpawnChildRunInput = Schema8.Struct({
   execution_id: ExecutionId,
-  child_execution_id: Schema7.optionalKey(ChildExecutionId),
+  child_execution_id: Schema8.optionalKey(ChildExecutionId),
   address_id: AddressId,
   parent_context: ChildRunContext,
-  presets: Schema7.optionalKey(Schema7.Record(Schema7.String, ChildRunPreset2)),
-  preset_name: Schema7.optionalKey(NonEmptyString),
-  instructions: Schema7.optionalKey(Schema7.String),
-  model: Schema7.optionalKey(ModelSelection),
-  compaction_policy: Schema7.optionalKey(CompactionPolicy),
-  tool_names: Schema7.optionalKey(Schema7.Array(Schema7.String)),
-  permissions: Schema7.optionalKey(Schema7.Array(Schema7.String)),
-  workspace_policy: Schema7.optionalKey(ChildRunWorkspacePolicy),
-  output_schema_ref: Schema7.optionalKey(Schema7.String),
-  metadata: Schema7.optionalKey(Metadata),
-  input: Schema7.optionalKey(Schema7.Array(Part)),
-  wait: Schema7.optionalKey(Schema7.Boolean),
-  event_sequence: Schema7.optionalKey(ExecutionEventSequence),
-  created_at: Schema7.optionalKey(TimestampMillis)
+  presets: Schema8.optionalKey(Schema8.Record(Schema8.String, ChildRunPreset2)),
+  preset_name: Schema8.optionalKey(NonEmptyString),
+  instructions: Schema8.optionalKey(Schema8.String),
+  model: Schema8.optionalKey(ModelSelection),
+  compaction_policy: Schema8.optionalKey(CompactionPolicy),
+  tool_names: Schema8.optionalKey(Schema8.Array(Schema8.String)),
+  permissions: Schema8.optionalKey(Schema8.Array(Schema8.String)),
+  workspace_policy: Schema8.optionalKey(ChildRunWorkspacePolicy),
+  output_schema_ref: Schema8.optionalKey(Schema8.String),
+  metadata: Schema8.optionalKey(Metadata),
+  input: Schema8.optionalKey(Schema8.Array(Part)),
+  wait: Schema8.optionalKey(Schema8.Boolean),
+  event_sequence: Schema8.optionalKey(ExecutionEventSequence),
+  created_at: Schema8.optionalKey(TimestampMillis)
 }).annotate({ identifier: "Relay.SpawnChildRunInput" });
-var ChildRunAccepted = Schema7.Struct({
+var ChildRunAccepted = Schema8.Struct({
   child_execution_id: ChildExecutionId,
   execution_id: ExecutionId
 }).annotate({ identifier: "Relay.ChildRunAccepted" });
 var childSessionId = (childExecutionId) => SessionId.make(`session:child:${childExecutionId}`);
 var steeringMessageId = (input) => SteeringMessageId.make(`steering:${input.execution_id}:${input.kind}:${input.sequence}`);
-var ExecutionEventType = Schema7.Literals([
+var ExecutionEventType = Schema8.Literals([
   "execution.accepted",
   "execution.started",
   "execution.completed",
@@ -680,7 +887,17 @@ var ExecutionEventType = Schema7.Literals([
   "model.toolcall.delta",
   "model.output.completed",
   "model.usage.reported",
+  "model.call.started",
+  "model.attempt.started",
+  "model.attempt.first_output",
+  "model.attempt.completed",
+  "model.attempt.failed",
+  "model.retry.scheduled",
+  "model.call.completed",
+  "model.call.failed",
   "agent.compaction.started",
+  "agent.compaction.completed",
+  "agent.compaction.failed",
   "agent.compaction.committed",
   "budget.exceeded",
   "tool.call.requested",
@@ -718,69 +935,60 @@ var ExecutionEventType = Schema7.Literals([
   "workspace.lease.released",
   "workspace.lease.failed"
 ]).annotate({ identifier: "Relay.ExecutionEventType" });
-var CompactionStartedEventData = Schema7.Struct({
-  turn: Schema7.Finite,
-  overflow: Schema7.Boolean
-}).annotate({ identifier: "Relay.CompactionStartedEventData" });
-var CompactionCommittedEventData = Schema7.Struct({
-  checkpoint_id: SessionEntryId,
-  session_id: SessionId,
-  summary_present: Schema7.Boolean
-}).annotate({ identifier: "Relay.CompactionCommittedEventData" });
-var ExecutionEvent = Schema7.Struct({
+var ExecutionEvent = Schema8.Struct({
   id: EventId,
   execution_id: ExecutionId,
-  child_execution_id: Schema7.optionalKey(ChildExecutionId),
+  child_execution_id: Schema8.optionalKey(ChildExecutionId),
   type: ExecutionEventType,
   sequence: ExecutionEventSequence,
   cursor: NonEmptyString,
-  content: Schema7.optionalKey(Schema7.Array(Part)),
-  data: Schema7.optionalKey(Metadata),
+  content: Schema8.optionalKey(Schema8.Array(Part)),
+  data: Schema8.optionalKey(Metadata),
   created_at: TimestampMillis
 }).annotate({ identifier: "Relay.ExecutionEvent" });
-var JoinPolicy = Schema8.Union([
-  Schema8.TaggedStruct("all", {}),
-  Schema8.TaggedStruct("first-success", {}),
-  Schema8.TaggedStruct("quorum", { count: Schema8.Int.check(Schema8.isGreaterThan(0)) }),
-  Schema8.TaggedStruct("best-effort", {})
+var JoinPolicy = Schema9.Union([
+  Schema9.TaggedStruct("all", {}),
+  Schema9.TaggedStruct("first-success", {}),
+  Schema9.TaggedStruct("quorum", { count: Schema9.Int.check(Schema9.isGreaterThan(0)) }),
+  Schema9.TaggedStruct("best-effort", {})
 ]).annotate({ identifier: "Relay.ChildOrchestration.JoinPolicy" });
-var FanOutChild = Schema8.Struct({
+var FanOutChild = Schema9.Struct({
   child_execution_id: ChildExecutionId,
   address_id: AddressId,
-  override: Schema8.optionalKey(ChildRunOverride),
-  input: Schema8.optionalKey(Schema8.Array(Part)),
-  metadata: Schema8.optionalKey(Metadata)
+  override: Schema9.optionalKey(ChildRunOverride),
+  input: Schema9.optionalKey(Schema9.Array(Part)),
+  metadata: Schema9.optionalKey(Metadata)
 }).annotate({ identifier: "Relay.ChildOrchestration.FanOutChild" });
-var FanOutDefinition = Schema8.Struct({
+var FanOutDefinition = Schema9.Struct({
   fan_out_id: ChildFanOutId,
   parent_execution_id: ExecutionId,
-  children: Schema8.Array(FanOutChild).check(Schema8.isMinLength(1)),
-  max_concurrency: Schema8.Int.check(Schema8.isGreaterThan(0)),
+  children: Schema9.Array(FanOutChild).check(Schema9.isMinLength(1)),
+  max_concurrency: Schema9.Int.check(Schema9.isGreaterThan(0)),
   join: JoinPolicy,
   created_at: TimestampMillis,
-  metadata: Schema8.optionalKey(Metadata)
+  metadata: Schema9.optionalKey(Metadata)
 }).annotate({ identifier: "Relay.ChildOrchestration.FanOutDefinition" });
-var MemberState = Schema8.Literals(["queued", "running", "completed", "failed", "cancelled"]).annotate({
+var MemberState = Schema9.Literals(["queued", "running", "completed", "failed", "cancelled"]).annotate({
   identifier: "Relay.ChildOrchestration.MemberState"
 });
-var AggregateState = Schema8.Literals(["joining", "satisfied", "failed", "cancelled"]).annotate({
+var AggregateState = Schema9.Literals(["joining", "satisfied", "failed", "cancelled"]).annotate({
   identifier: "Relay.ChildOrchestration.AggregateState"
 });
-var FanOutMember = Schema8.Struct({
+var FanOutMember = Schema9.Struct({
   child_execution_id: ChildExecutionId,
-  ordinal: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(0)),
+  ordinal: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(0)),
   state: MemberState,
-  output: Schema8.optionalKey(Schema8.Array(Part)),
-  error: Schema8.optionalKey(Schema8.String),
-  completed_at: Schema8.optionalKey(TimestampMillis)
+  output: Schema9.optionalKey(Schema9.Array(Part)),
+  error: Schema9.optionalKey(Schema9.String),
+  completed_at: Schema9.optionalKey(TimestampMillis)
 }).annotate({ identifier: "Relay.ChildOrchestration.FanOutMember" });
-var FanOutState = Schema8.Struct({
+var FanOutState = Schema9.Struct({
   ...FanOutDefinition.fields,
   state: AggregateState,
-  members: Schema8.Array(FanOutMember),
-  satisfied_at: Schema8.optionalKey(TimestampMillis),
-  failed_at: Schema8.optionalKey(TimestampMillis),
-  cancelled_at: Schema8.optionalKey(TimestampMillis)
+  members: Schema9.Array(FanOutMember),
+  satisfied_at: Schema9.optionalKey(TimestampMillis),
+  failed_at: Schema9.optionalKey(TimestampMillis),
+  cancelled_at: Schema9.optionalKey(TimestampMillis)
 }).annotate({ identifier: "Relay.ChildOrchestration.FanOutState" });
 var exports_envelope_schema = {};
 __export2(exports_envelope_schema, {
@@ -791,45 +999,45 @@ __export2(exports_envelope_schema, {
   EnvelopeAccepted: () => EnvelopeAccepted,
   Envelope: () => Envelope
 });
-var WaitMode = Schema9.Literals(["reply", "event", "until", "child"]).annotate({ identifier: "Relay.WaitMode" });
-var Wait = Schema9.Struct({
+var WaitMode = Schema10.Literals(["reply", "event", "until", "child"]).annotate({ identifier: "Relay.WaitMode" });
+var Wait = Schema10.Struct({
   mode: WaitMode,
-  timeout: Schema9.optionalKey(Schema9.String),
-  correlation_key: Schema9.optionalKey(Schema9.String),
-  metadata: Schema9.optionalKey(Metadata)
+  timeout: Schema10.optionalKey(Schema10.String),
+  correlation_key: Schema10.optionalKey(Schema10.String),
+  metadata: Schema10.optionalKey(Metadata)
 }).annotate({ identifier: "Relay.Wait" });
-var Envelope = Schema9.Struct({
+var Envelope = Schema10.Struct({
   id: EnvelopeId,
   execution_id: ExecutionId,
   from: AddressId,
   to: AddressId,
-  content: Schema9.Array(Part),
-  wait: Schema9.optionalKey(Wait),
-  correlation_key: Schema9.optionalKey(Schema9.String),
-  metadata: Schema9.optionalKey(Metadata),
+  content: Schema10.Array(Part),
+  wait: Schema10.optionalKey(Wait),
+  correlation_key: Schema10.optionalKey(Schema10.String),
+  metadata: Schema10.optionalKey(Metadata),
   created_at: TimestampMillis
 }).annotate({ identifier: "Relay.Envelope" });
-var SendInput = Schema9.Struct({
+var SendInput = Schema10.Struct({
   from: AddressId,
   to: AddressId,
-  content: Schema9.Array(Part),
-  idempotency_key: Schema9.optionalKey(Schema9.String),
-  wait: Schema9.optionalKey(Wait),
-  correlation_key: Schema9.optionalKey(Schema9.String),
-  metadata: Schema9.optionalKey(Metadata)
+  content: Schema10.Array(Part),
+  idempotency_key: Schema10.optionalKey(Schema10.String),
+  wait: Schema10.optionalKey(Wait),
+  correlation_key: Schema10.optionalKey(Schema10.String),
+  metadata: Schema10.optionalKey(Metadata)
 }).annotate({ identifier: "Relay.SendInput" });
-var EnvelopeAccepted = Schema9.Struct({
+var EnvelopeAccepted = Schema10.Struct({
   envelope_id: EnvelopeId,
   execution_id: ExecutionId,
-  wait_id: Schema9.optionalKey(WaitId)
+  wait_id: Schema10.optionalKey(WaitId)
 }).annotate({ identifier: "Relay.EnvelopeAccepted" });
-var EnvelopeReady = Schema9.Struct({
+var EnvelopeReady = Schema10.Struct({
   id: EnvelopeReadyId,
   envelope_id: EnvelopeId,
-  route_key: Schema9.String,
+  route_key: Schema10.String,
   available_at: TimestampMillis,
-  attempt: Schema9.Int,
-  metadata: Schema9.optionalKey(Metadata)
+  attempt: Schema10.Int,
+  metadata: Schema10.optionalKey(Metadata)
 }).annotate({ identifier: "Relay.EnvelopeReady" });
 var exports_resident_schema = {};
 __export2(exports_resident_schema, {
@@ -843,47 +1051,47 @@ __export2(exports_inbox_schema, {
   Message: () => Message,
   InboxPolicy: () => InboxPolicy
 });
-var MessageSequence = Schema10.Int.check(Schema10.isGreaterThanOrEqualTo(0)).annotate({
+var MessageSequence = Schema11.Int.check(Schema11.isGreaterThanOrEqualTo(0)).annotate({
   identifier: "Relay.Inbox.MessageSequence"
 });
-var Message = Schema10.Struct({
+var Message = Schema11.Struct({
   execution_id: ExecutionId,
   sequence: MessageSequence,
   from: AddressId,
-  envelope_id: Schema10.optionalKey(EnvelopeId),
-  content: Schema10.Array(Part),
-  reply_wait_id: Schema10.optionalKey(WaitId),
-  correlation_key: Schema10.optionalKey(Schema10.String),
-  idempotency_key: Schema10.optionalKey(Schema10.String),
-  drain_id: Schema10.optionalKey(Schema10.String),
-  consumed_at: Schema10.optionalKey(TimestampMillis),
-  metadata: Schema10.optionalKey(Metadata),
+  envelope_id: Schema11.optionalKey(EnvelopeId),
+  content: Schema11.Array(Part),
+  reply_wait_id: Schema11.optionalKey(WaitId),
+  correlation_key: Schema11.optionalKey(Schema11.String),
+  idempotency_key: Schema11.optionalKey(Schema11.String),
+  drain_id: Schema11.optionalKey(Schema11.String),
+  consumed_at: Schema11.optionalKey(TimestampMillis),
+  metadata: Schema11.optionalKey(Metadata),
   created_at: TimestampMillis
 }).annotate({ identifier: "Relay.Inbox.Message" });
-var InboxPolicy = Schema10.Struct({
-  drain: Schema10.Literals(["all", "one"]),
-  max_batch: Schema10.optionalKey(Schema10.Int.check(Schema10.isGreaterThan(0)))
+var InboxPolicy = Schema11.Struct({
+  drain: Schema11.Literals(["all", "one"]),
+  max_batch: Schema11.optionalKey(Schema11.Int.check(Schema11.isGreaterThan(0)))
 }).annotate({ identifier: "Relay.Inbox.InboxPolicy" });
-var KindDefinition = Schema11.Struct({
+var KindDefinition = Schema12.Struct({
   kind: ResidentKindName,
   agent_id: AgentId,
-  inbox: Schema11.optionalKey(InboxPolicy),
-  state_enabled: Schema11.optionalKey(Schema11.Boolean),
-  continue_as_new_after_turns: Schema11.optionalKey(Schema11.Int.check(Schema11.isGreaterThan(0))),
-  metadata: Schema11.optionalKey(Metadata)
+  inbox: Schema12.optionalKey(InboxPolicy),
+  state_enabled: Schema12.optionalKey(Schema12.Boolean),
+  continue_as_new_after_turns: Schema12.optionalKey(Schema12.Int.check(Schema12.isGreaterThan(0))),
+  metadata: Schema12.optionalKey(Metadata)
 }).annotate({ identifier: "Relay.Resident.KindDefinition" });
-var InstanceStatus = Schema11.Literals(["active", "destroyed"]).annotate({
+var InstanceStatus = Schema12.Literals(["active", "destroyed"]).annotate({
   identifier: "Relay.Resident.InstanceStatus"
 });
-var Instance = Schema11.Struct({
+var Instance = Schema12.Struct({
   kind: ResidentKindName,
   key: ResidentKey,
   address_id: AddressId,
   execution_id: ExecutionId,
-  generation: Schema11.Int.check(Schema11.isGreaterThanOrEqualTo(0)),
+  generation: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(0)),
   status: InstanceStatus,
   created_at: TimestampMillis,
-  destroyed_at: Schema11.optionalKey(TimestampMillis)
+  destroyed_at: Schema12.optionalKey(TimestampMillis)
 }).annotate({ identifier: "Relay.Resident.Instance" });
 var exports_pagination_schema = {};
 __export2(exports_pagination_schema, {
@@ -892,11 +1100,11 @@ __export2(exports_pagination_schema, {
   ExecutionCursorCodec: () => ExecutionCursorCodec,
   ExecutionCursor: () => ExecutionCursor
 });
-var codec = (id2, identifier) => Schema12.StringFromBase64Url.pipe(Schema12.decodeTo(Schema12.fromJsonString(Schema12.Struct({
+var codec = (id2, identifier) => Schema13.StringFromBase64Url.pipe(Schema13.decodeTo(Schema13.fromJsonString(Schema13.Struct({
   id: id2,
   at: TimestampMillis
 })))).annotate({ identifier });
-var opaque = (schema, identifier) => Schema12.String.check(Schema12.makeFilter((value) => Schema12.decodeUnknownOption(schema)(value)._tag === "Some" ? undefined : "invalid pagination cursor")).annotate({ identifier });
+var opaque = (schema, identifier) => Schema13.String.check(Schema13.makeFilter((value) => Schema13.decodeUnknownOption(schema)(value)._tag === "Some" ? undefined : "invalid pagination cursor")).annotate({ identifier });
 var ExecutionCursorCodec = codec(ExecutionId, "Relay.Pagination.ExecutionCursorCodec");
 var ExecutionCursor = opaque(ExecutionCursorCodec, "Relay.Pagination.ExecutionCursor");
 var SessionCursorCodec = codec(SessionId, "Relay.Pagination.SessionCursorCodec");
@@ -907,18 +1115,18 @@ __export2(exports_presence_schema, {
   Scope: () => Scope,
   Entry: () => Entry
 });
-var Scope = Schema13.Struct({
-  kind: Schema13.Literals(["execution", "session"]),
+var Scope = Schema14.Struct({
+  kind: Schema14.Literals(["execution", "session"]),
   id: NonEmptyString
 }).annotate({ identifier: "Relay.Presence.Scope" });
-var Entry = Schema13.Struct({
+var Entry = Schema14.Struct({
   id: NonEmptyString,
   metadata: Metadata,
   connected_at: TimestampMillis
 }).annotate({ identifier: "Relay.Presence.Entry" });
-var View = Schema13.Struct({
+var View = Schema14.Struct({
   scope: Scope,
-  entries: Schema13.Array(Entry),
+  entries: Schema14.Array(Entry),
   observed_at: TimestampMillis
 }).annotate({ identifier: "Relay.Presence.View" });
 var exports_schedule_schema = {};
@@ -928,26 +1136,26 @@ __export2(exports_schedule_schema, {
   ScheduleRecord: () => ScheduleRecord,
   ScheduleKind: () => ScheduleKind
 });
-var ScheduleKind = Schema14.Literals(["once", "cron"]).annotate({ identifier: "Relay.ScheduleKind" });
-var ScheduleTargetKind = Schema14.Literals(["start-execution", "wake-wait", "timeout-wait"]).annotate({
+var ScheduleKind = Schema15.Literals(["once", "cron"]).annotate({ identifier: "Relay.ScheduleKind" });
+var ScheduleTargetKind = Schema15.Literals(["start-execution", "wake-wait", "timeout-wait"]).annotate({
   identifier: "Relay.ScheduleTargetKind"
 });
-var ScheduleState = Schema14.Literals(["active", "claimed", "completed", "cancelled", "failed"]).annotate({
+var ScheduleState = Schema15.Literals(["active", "claimed", "completed", "cancelled", "failed"]).annotate({
   identifier: "Relay.ScheduleState"
 });
-var ScheduleRecord = Schema14.Struct({
+var ScheduleRecord = Schema15.Struct({
   id: ScheduleId,
   kind: ScheduleKind,
   target_kind: ScheduleTargetKind,
-  address_id: Schema14.optionalKey(AddressId),
-  wait_id: Schema14.optionalKey(WaitId),
-  cron_expr: Schema14.optionalKey(NonEmptyString),
-  input: Schema14.optionalKey(Schema14.Array(Part)),
+  address_id: Schema15.optionalKey(AddressId),
+  wait_id: Schema15.optionalKey(WaitId),
+  cron_expr: Schema15.optionalKey(NonEmptyString),
+  input: Schema15.optionalKey(Schema15.Array(Part)),
   state: ScheduleState,
   next_run_at: TimestampMillis,
-  attempt: Schema14.Int,
-  last_error: Schema14.optionalKey(Schema14.String),
-  metadata: Schema14.optionalKey(Metadata),
+  attempt: Schema15.Int,
+  last_error: Schema15.optionalKey(Schema15.String),
+  metadata: Schema15.optionalKey(Metadata),
   created_at: TimestampMillis,
   updated_at: TimestampMillis
 }).annotate({ identifier: "Relay.ScheduleRecord" });
@@ -965,62 +1173,62 @@ __export2(exports_skill_schema, {
   DefinitionList: () => DefinitionList2,
   Definition: () => Definition3
 });
-var DefinitionRevision2 = Schema15.Int.check(Schema15.isGreaterThanOrEqualTo(1)).annotate({
+var DefinitionRevision2 = Schema16.Int.check(Schema16.isGreaterThanOrEqualTo(1)).annotate({
   identifier: "Relay.Skill.DefinitionRevision"
 });
-var Frontmatter = Schema15.Struct({
+var Frontmatter = Schema16.Struct({
   name: NonEmptyString,
-  description: Schema15.String,
-  when_to_use: Schema15.optionalKey(Schema15.String),
-  allowed_tools: Schema15.optionalKey(Schema15.Array(Schema15.String)),
-  disable_model_invocation: Schema15.optionalKey(Schema15.Boolean),
-  user_invocable: Schema15.optionalKey(Schema15.Boolean),
-  context_fork: Schema15.optionalKey(Schema15.Boolean),
-  agent: Schema15.optionalKey(Schema15.String),
-  model: Schema15.optionalKey(Schema15.String),
-  paths: Schema15.optionalKey(Schema15.Array(Schema15.String)),
-  metadata: Schema15.optionalKey(Metadata)
+  description: Schema16.String,
+  when_to_use: Schema16.optionalKey(Schema16.String),
+  allowed_tools: Schema16.optionalKey(Schema16.Array(Schema16.String)),
+  disable_model_invocation: Schema16.optionalKey(Schema16.Boolean),
+  user_invocable: Schema16.optionalKey(Schema16.Boolean),
+  context_fork: Schema16.optionalKey(Schema16.Boolean),
+  agent: Schema16.optionalKey(Schema16.String),
+  model: Schema16.optionalKey(Schema16.String),
+  paths: Schema16.optionalKey(Schema16.Array(Schema16.String)),
+  metadata: Schema16.optionalKey(Metadata)
 }).annotate({ identifier: "Relay.Skill.Frontmatter" });
-var Definition3 = Schema15.Struct({
+var Definition3 = Schema16.Struct({
   frontmatter: Frontmatter,
-  body: Schema15.String,
-  metadata: Schema15.optionalKey(Metadata)
+  body: Schema16.String,
+  metadata: Schema16.optionalKey(Metadata)
 }).annotate({ identifier: "Relay.Skill.Definition" });
-var DefinitionRecord2 = Schema15.Struct({
+var DefinitionRecord2 = Schema16.Struct({
   id: SkillDefinitionId,
   current_revision: DefinitionRevision2,
   definition: Definition3,
   created_at: TimestampMillis,
   updated_at: TimestampMillis
 }).annotate({ identifier: "Relay.Skill.DefinitionRecord" });
-var DefinitionRevisionRecord2 = Schema15.Struct({
+var DefinitionRevisionRecord2 = Schema16.Struct({
   id: SkillDefinitionId,
   revision: DefinitionRevision2,
   definition: Definition3,
   created_at: TimestampMillis
 }).annotate({ identifier: "Relay.Skill.DefinitionRevisionRecord" });
-var ExecutionPinRecord = Schema15.Struct({
+var ExecutionPinRecord = Schema16.Struct({
   execution_id: ExecutionId,
   skill_definition_id: SkillDefinitionId,
   skill_definition_revision: DefinitionRevision2,
   skill_definition_snapshot: Definition3,
   created_at: TimestampMillis
 }).annotate({ identifier: "Relay.Skill.ExecutionPinRecord" });
-var RegisterDefinitionPayload2 = Schema15.Struct({
+var RegisterDefinitionPayload2 = Schema16.Struct({
   id: SkillDefinitionId,
   definition: Definition3
 }).annotate({ identifier: "Relay.Skill.RegisterDefinitionPayload" });
-var DefinitionRegistered2 = Schema15.Struct({
+var DefinitionRegistered2 = Schema16.Struct({
   record: DefinitionRecord2
 }).annotate({ identifier: "Relay.Skill.DefinitionRegistered" });
-var DefinitionList2 = Schema15.Struct({
-  records: Schema15.Array(DefinitionRecord2)
+var DefinitionList2 = Schema16.Struct({
+  records: Schema16.Array(DefinitionRecord2)
 }).annotate({ identifier: "Relay.Skill.DefinitionList" });
-var DefinitionRevisionList2 = Schema15.Struct({
-  records: Schema15.Array(DefinitionRevisionRecord2)
+var DefinitionRevisionList2 = Schema16.Struct({
+  records: Schema16.Array(DefinitionRevisionRecord2)
 }).annotate({ identifier: "Relay.Skill.DefinitionRevisionList" });
-var ExecutionPinList = Schema15.Struct({
-  records: Schema15.Array(ExecutionPinRecord)
+var ExecutionPinList = Schema16.Struct({
+  records: Schema16.Array(ExecutionPinRecord)
 }).annotate({ identifier: "Relay.Skill.ExecutionPinList" });
 var exports_state_schema = {};
 __export2(exports_state_schema, {
@@ -1031,16 +1239,16 @@ __export2(exports_state_schema, {
   StateIdempotencyKey: () => StateIdempotencyKey,
   StateDeletedEventData: () => StateDeletedEventData
 });
-var StateKey = NonEmptyString.check(Schema16.isMaxLength(191)).annotate({
+var StateKey = NonEmptyString.check(Schema17.isMaxLength(191)).annotate({
   identifier: "Relay.State.StateKey"
 });
-var StateIdempotencyKey = NonEmptyString.check(Schema16.isMaxLength(191)).annotate({
+var StateIdempotencyKey = NonEmptyString.check(Schema17.isMaxLength(191)).annotate({
   identifier: "Relay.State.StateIdempotencyKey"
 });
-var StateVersion = Schema16.Int.check(Schema16.isGreaterThanOrEqualTo(1)).annotate({
+var StateVersion = Schema17.Int.check(Schema17.isGreaterThanOrEqualTo(1)).annotate({
   identifier: "Relay.State.StateVersion"
 });
-var StateRecordView = Schema16.Struct({
+var StateRecordView = Schema17.Struct({
   execution_id: ExecutionId,
   key: StateKey,
   value: JsonValue,
@@ -1048,11 +1256,11 @@ var StateRecordView = Schema16.Struct({
   created_at: TimestampMillis,
   updated_at: TimestampMillis
 }).annotate({ identifier: "Relay.State.StateRecordView" });
-var StateUpdatedEventData = Schema16.Union([
-  Schema16.Struct({ key: StateKey, version: StateVersion, value: JsonValue }),
-  Schema16.Struct({ key: StateKey, version: StateVersion, blob_ref: NonEmptyString })
+var StateUpdatedEventData = Schema17.Union([
+  Schema17.Struct({ key: StateKey, version: StateVersion, value: JsonValue }),
+  Schema17.Struct({ key: StateKey, version: StateVersion, blob_ref: NonEmptyString })
 ]).annotate({ identifier: "Relay.State.StateUpdatedEventData" });
-var StateDeletedEventData = Schema16.Struct({
+var StateDeletedEventData = Schema17.Struct({
   key: StateKey,
   version: StateVersion
 }).annotate({ identifier: "Relay.State.StateDeletedEventData" });
@@ -1073,7 +1281,7 @@ __export2(exports_wait_schema, {
   Classification: () => Classification,
   ChildJoinWait: () => ChildJoinWait
 });
-var WaitKind = Schema17.Literals([
+var WaitKind = Schema18.Literals([
   "permission",
   "tool_approval",
   "tool_placement",
@@ -1083,46 +1291,46 @@ var WaitKind = Schema17.Literals([
   "timer",
   "external"
 ]).annotate({ identifier: "Relay.WaitKind" });
-var PermissionWait = Schema17.Struct({
-  kind: Schema17.Literal("permission"),
+var PermissionWait = Schema18.Struct({
+  kind: Schema18.Literal("permission"),
   wait_id: WaitId,
   tool_call_id: ToolCallId
 }).annotate({ identifier: "Relay.PermissionWait" });
-var ToolApprovalWait = Schema17.Struct({
-  kind: Schema17.Literal("tool_approval"),
+var ToolApprovalWait = Schema18.Struct({
+  kind: Schema18.Literal("tool_approval"),
   wait_id: WaitId,
   tool_call_id: ToolCallId
 }).annotate({ identifier: "Relay.ToolApprovalWait" });
-var ToolPlacementWait = Schema17.Struct({
-  kind: Schema17.Literal("tool_placement"),
+var ToolPlacementWait = Schema18.Struct({
+  kind: Schema18.Literal("tool_placement"),
   wait_id: WaitId,
   tool_call_id: ToolCallId
 }).annotate({ identifier: "Relay.ToolPlacementWait" });
-var ChildJoinWait = Schema17.Struct({
-  kind: Schema17.Literal("child_join"),
+var ChildJoinWait = Schema18.Struct({
+  kind: Schema18.Literal("child_join"),
   wait_id: WaitId,
   child_execution_id: ChildExecutionId
 }).annotate({ identifier: "Relay.ChildJoinWait" });
-var InboxWait = Schema17.Struct({
-  kind: Schema17.Literal("inbox"),
+var InboxWait = Schema18.Struct({
+  kind: Schema18.Literal("inbox"),
   wait_id: WaitId,
   tool_call_id: ToolCallId
 }).annotate({ identifier: "Relay.InboxWait" });
-var ReplyWait = Schema17.Struct({
-  kind: Schema17.Literal("reply"),
+var ReplyWait = Schema18.Struct({
+  kind: Schema18.Literal("reply"),
   wait_id: WaitId,
-  envelope_id: Schema17.optionalKey(EnvelopeId)
+  envelope_id: Schema18.optionalKey(EnvelopeId)
 }).annotate({ identifier: "Relay.ReplyWait" });
-var TimerWait = Schema17.Struct({
-  kind: Schema17.Literal("timer"),
+var TimerWait = Schema18.Struct({
+  kind: Schema18.Literal("timer"),
   wait_id: WaitId
 }).annotate({ identifier: "Relay.TimerWait" });
-var ExternalWait = Schema17.Struct({
-  kind: Schema17.Literal("external"),
+var ExternalWait = Schema18.Struct({
+  kind: Schema18.Literal("external"),
   wait_id: WaitId,
   mode: WaitMode
 }).annotate({ identifier: "Relay.ExternalWait" });
-var Classification = Schema17.Union([
+var Classification = Schema18.Union([
   PermissionWait,
   ToolApprovalWait,
   ToolPlacementWait,
@@ -1185,7 +1393,7 @@ var classify = (input) => {
     return { kind: "timer", wait_id: waitId };
   return { kind: "external", wait_id: waitId, mode: input.mode };
 };
-var Resolver = Schema17.Literals(["resolve_permission", "resolve_tool_approval", "wake"]).annotate({
+var Resolver = Schema18.Literals(["resolve_permission", "resolve_tool_approval", "wake"]).annotate({
   identifier: "Relay.WaitResolver"
 });
 var resolverFor = (classification) => {
@@ -1245,112 +1453,112 @@ __export2(exports_workflow_schema, {
   BranchOperation: () => BranchOperation,
   ApprovalOperation: () => ApprovalOperation
 });
-var DefinitionRevision3 = Schema18.Int.check(Schema18.isGreaterThanOrEqualTo(1)).annotate({
+var DefinitionRevision3 = Schema19.Int.check(Schema19.isGreaterThanOrEqualTo(1)).annotate({
   identifier: "Relay.WorkflowDefinitionRevision"
 });
-var DefinitionDigest = Schema18.String.check(Schema18.isPattern(/^sha256:[0-9a-f]{64}$/)).annotate({
+var DefinitionDigest = Schema19.String.check(Schema19.isPattern(/^sha256:[0-9a-f]{64}$/)).annotate({
   identifier: "Relay.WorkflowDefinitionDigest"
 });
 var OperationRef = WorkflowOperationId;
 var base = { id: WorkflowOperationId };
-var SequenceOperation = Schema18.Struct({
+var SequenceOperation = Schema19.Struct({
   ...base,
-  kind: Schema18.Literal("sequence"),
-  operations: Schema18.Array(OperationRef)
+  kind: Schema19.Literal("sequence"),
+  operations: Schema19.Array(OperationRef)
 });
-var ChildOperation = Schema18.Struct({
+var ChildOperation = Schema19.Struct({
   ...base,
-  kind: Schema18.Literal("child"),
+  kind: Schema19.Literal("child"),
   workflow_id: WorkflowDefinitionId,
-  input: Schema18.optionalKey(JsonValue)
+  input: Schema19.optionalKey(JsonValue)
 });
-var DispatchableChildOperation = Schema18.Struct({
+var DispatchableChildOperation = Schema19.Struct({
   ...base,
-  kind: Schema18.Literal("child"),
+  kind: Schema19.Literal("child"),
   address_id: AddressId,
-  preset_name: Schema18.optionalKey(NonEmptyString),
-  input: Schema18.optionalKey(JsonValue)
+  preset_name: Schema19.optionalKey(NonEmptyString),
+  input: Schema19.optionalKey(JsonValue)
 });
-var ToolOperation = Schema18.Struct({
+var ToolOperation = Schema19.Struct({
   ...base,
-  kind: Schema18.Literal("tool"),
+  kind: Schema19.Literal("tool"),
   tool_name: NonEmptyString,
-  input: Schema18.optionalKey(JsonValue)
+  input: Schema19.optionalKey(JsonValue)
 });
-var ApprovalOperation = Schema18.Struct({ ...base, kind: Schema18.Literal("approval"), prompt: NonEmptyString });
-var TimerOperation = Schema18.Struct({
+var ApprovalOperation = Schema19.Struct({ ...base, kind: Schema19.Literal("approval"), prompt: NonEmptyString });
+var TimerOperation = Schema19.Struct({
   ...base,
-  kind: Schema18.Literal("timer"),
-  duration_ms: Schema18.Int.check(Schema18.isGreaterThanOrEqualTo(0))
+  kind: Schema19.Literal("timer"),
+  duration_ms: Schema19.Int.check(Schema19.isGreaterThanOrEqualTo(0))
 });
-var BranchOperation = Schema18.Struct({
+var BranchOperation = Schema19.Struct({
   ...base,
-  kind: Schema18.Literal("branch"),
+  kind: Schema19.Literal("branch"),
   condition: NonEmptyString,
   when_true: OperationRef,
   when_false: OperationRef
 });
-var ParallelOperation = Schema18.Struct({
+var ParallelOperation = Schema19.Struct({
   ...base,
-  kind: Schema18.Literal("parallel"),
-  operations: Schema18.Array(OperationRef)
+  kind: Schema19.Literal("parallel"),
+  operations: Schema19.Array(OperationRef)
 });
-var JoinOperation = Schema18.Struct({
+var JoinOperation = Schema19.Struct({
   ...base,
-  kind: Schema18.Literal("join"),
-  operations: Schema18.Array(OperationRef)
+  kind: Schema19.Literal("join"),
+  operations: Schema19.Array(OperationRef)
 });
-var ParallelOperationV2 = Schema18.Struct({
+var ParallelOperationV2 = Schema19.Struct({
   ...base,
-  kind: Schema18.Literal("parallel"),
+  kind: Schema19.Literal("parallel"),
   fan_out_key: NonEmptyString,
-  operations: Schema18.Array(OperationRef).check(Schema18.isMinLength(1)),
-  max_concurrency: Schema18.Int.check(Schema18.isGreaterThan(0))
+  operations: Schema19.Array(OperationRef).check(Schema19.isMinLength(1)),
+  max_concurrency: Schema19.Int.check(Schema19.isGreaterThan(0))
 });
-var JoinOperationV2 = Schema18.Struct({
+var JoinOperationV2 = Schema19.Struct({
   ...base,
-  kind: Schema18.Literal("join"),
+  kind: Schema19.Literal("join"),
   parallel_operation: OperationRef,
-  members: Schema18.Array(OperationRef).check(Schema18.isMinLength(1)),
-  policy: Schema18.Union([
-    Schema18.TaggedStruct("all", {}),
-    Schema18.TaggedStruct("first-success", {}),
-    Schema18.TaggedStruct("quorum", { count: Schema18.Int.check(Schema18.isGreaterThan(0)) }),
-    Schema18.TaggedStruct("best-effort", {})
+  members: Schema19.Array(OperationRef).check(Schema19.isMinLength(1)),
+  policy: Schema19.Union([
+    Schema19.TaggedStruct("all", {}),
+    Schema19.TaggedStruct("first-success", {}),
+    Schema19.TaggedStruct("quorum", { count: Schema19.Int.check(Schema19.isGreaterThan(0)) }),
+    Schema19.TaggedStruct("best-effort", {})
   ])
 });
-var RetryOperation = Schema18.Struct({
+var RetryOperation = Schema19.Struct({
   ...base,
-  kind: Schema18.Literal("retry"),
+  kind: Schema19.Literal("retry"),
   operation: OperationRef,
-  max_attempts: Schema18.Int.check(Schema18.isGreaterThanOrEqualTo(1))
+  max_attempts: Schema19.Int.check(Schema19.isGreaterThanOrEqualTo(1))
 });
-var BudgetOperation = Schema18.Struct({
+var BudgetOperation = Schema19.Struct({
   ...base,
-  kind: Schema18.Literal("budget"),
+  kind: Schema19.Literal("budget"),
   operation: OperationRef,
-  limit: Schema18.Int.check(Schema18.isGreaterThanOrEqualTo(1)),
-  unit: Schema18.Literals(["tokens", "milliseconds", "operations"])
+  limit: Schema19.Int.check(Schema19.isGreaterThanOrEqualTo(1)),
+  unit: Schema19.Literals(["tokens", "milliseconds", "operations"])
 });
-var CancellationOperation = Schema18.Struct({
+var CancellationOperation = Schema19.Struct({
   ...base,
-  kind: Schema18.Literal("cancellation"),
+  kind: Schema19.Literal("cancellation"),
   operation: OperationRef,
-  on_cancel: Schema18.optionalKey(OperationRef)
+  on_cancel: Schema19.optionalKey(OperationRef)
 });
-var CompensationOperation = Schema18.Struct({
+var CompensationOperation = Schema19.Struct({
   ...base,
-  kind: Schema18.Literal("compensation"),
+  kind: Schema19.Literal("compensation"),
   operation: OperationRef,
   compensate_with: OperationRef
 });
-var StructuredCompletionOperation = Schema18.Struct({
+var StructuredCompletionOperation = Schema19.Struct({
   ...base,
-  kind: Schema18.Literal("structured-completion"),
+  kind: Schema19.Literal("structured-completion"),
   schema_ref: NonEmptyString,
   value_from: OperationRef
 });
-var Operation = Schema18.Union([
+var Operation = Schema19.Union([
   SequenceOperation,
   ChildOperation,
   ToolOperation,
@@ -1365,7 +1573,7 @@ var Operation = Schema18.Union([
   CompensationOperation,
   StructuredCompletionOperation
 ]).annotate({ identifier: "Relay.WorkflowOperation" });
-var OperationV2 = Schema18.Union([
+var OperationV2 = Schema19.Union([
   SequenceOperation,
   DispatchableChildOperation,
   ToolOperation,
@@ -1404,7 +1612,7 @@ var references = (operation) => {
       return [];
   }
 };
-var validGraph = Schema18.makeFilter((definition) => {
+var validGraph = Schema19.makeFilter((definition) => {
   const ids = new Set(definition.operations.map((operation) => operation.id));
   if (ids.size !== definition.operations.length)
     return "workflow operation ids must be unique";
@@ -1421,7 +1629,7 @@ var referencesV2 = (operation) => {
     return [operation.parallel_operation, ...operation.members];
   return references(operation);
 };
-var validGraphV2 = Schema18.makeFilter((definition) => {
+var validGraphV2 = Schema19.makeFilter((definition) => {
   const operations = new Map(definition.operations.map((operation) => [operation.id, operation]));
   if (operations.size !== definition.operations.length)
     return "workflow operation ids must be unique";
@@ -1450,21 +1658,21 @@ var validGraphV2 = Schema18.makeFilter((definition) => {
   }
   return;
 });
-var DefinitionV1 = Schema18.Struct({
-  version: Schema18.Literal(1),
+var DefinitionV1 = Schema19.Struct({
+  version: Schema19.Literal(1),
   name: NonEmptyString,
   entry_operation_id: WorkflowOperationId,
-  operations: Schema18.Array(Operation).check(Schema18.isMinLength(1)),
-  metadata: Schema18.optionalKey(Metadata)
+  operations: Schema19.Array(Operation).check(Schema19.isMinLength(1)),
+  metadata: Schema19.optionalKey(Metadata)
 }).check(validGraph).annotate({ identifier: "Relay.WorkflowDefinitionV1" });
-var DefinitionV2 = Schema18.Struct({
-  version: Schema18.Literal(2),
+var DefinitionV2 = Schema19.Struct({
+  version: Schema19.Literal(2),
   name: NonEmptyString,
   entry_operation_id: WorkflowOperationId,
-  operations: Schema18.Array(OperationV2).check(Schema18.isMinLength(1)),
-  metadata: Schema18.optionalKey(Metadata)
+  operations: Schema19.Array(OperationV2).check(Schema19.isMinLength(1)),
+  metadata: Schema19.optionalKey(Metadata)
 }).check(validGraphV2).annotate({ identifier: "Relay.WorkflowDefinitionV2" });
-var Definition4 = Schema18.Union([DefinitionV1, DefinitionV2]).annotate({
+var Definition4 = Schema19.Union([DefinitionV1, DefinitionV2]).annotate({
   identifier: "Relay.WorkflowDefinition"
 });
 var canonicalDefinition = (definition) => canonicalString(definition);
@@ -1574,36 +1782,36 @@ var sha256 = (value) => {
   }
   return hash.map((part) => (part >>> 0).toString(16).padStart(8, "0")).join("");
 };
-var digestDefinition = (definition) => Schema18.decodeUnknownSync(DefinitionDigest)(`sha256:${sha256(canonicalDefinition(definition))}`);
-var DefinitionRevisionRecord3 = Schema18.Struct({
+var digestDefinition = (definition) => Schema19.decodeUnknownSync(DefinitionDigest)(`sha256:${sha256(canonicalDefinition(definition))}`);
+var DefinitionRevisionRecord3 = Schema19.Struct({
   id: WorkflowDefinitionId,
   revision: DefinitionRevision3,
   digest: DefinitionDigest,
   definition: Definition4,
   created_at: TimestampMillis
 }).annotate({ identifier: "Relay.WorkflowDefinitionRevisionRecord" });
-var RunPin = Schema18.Struct({
+var RunPin = Schema19.Struct({
   workflow_definition_id: WorkflowDefinitionId,
   workflow_definition_revision: DefinitionRevision3,
   workflow_definition_digest: DefinitionDigest
 }).annotate({ identifier: "Relay.WorkflowRunPin" });
-var RegisterDefinitionPayload3 = Schema18.Struct({ id: WorkflowDefinitionId, definition: Definition4 });
-var DefinitionRegistered3 = Schema18.Struct({ record: DefinitionRevisionRecord3 });
-var DefinitionRevisionList3 = Schema18.Struct({ records: Schema18.Array(DefinitionRevisionRecord3) });
-var RunStatus = Schema18.Literals(["running", "completed", "failed", "cancelled"]);
-var RunRecord = Schema18.Struct({
+var RegisterDefinitionPayload3 = Schema19.Struct({ id: WorkflowDefinitionId, definition: Definition4 });
+var DefinitionRegistered3 = Schema19.Struct({ record: DefinitionRevisionRecord3 });
+var DefinitionRevisionList3 = Schema19.Struct({ records: Schema19.Array(DefinitionRevisionRecord3) });
+var RunStatus = Schema19.Literals(["running", "completed", "failed", "cancelled"]);
+var RunRecord = Schema19.Struct({
   execution_id: ExecutionId,
   pin: RunPin,
   status: RunStatus,
   created_at: TimestampMillis,
   updated_at: TimestampMillis
 });
-var StartRunPayload = Schema18.Struct({
+var StartRunPayload = Schema19.Struct({
   execution_id: ExecutionId,
   workflow_definition_id: WorkflowDefinitionId,
-  revision: Schema18.optionalKey(DefinitionRevision3)
+  revision: Schema19.optionalKey(DefinitionRevision3)
 });
-var OperationStatus = Schema18.Literals([
+var OperationStatus = Schema19.Literals([
   "pending",
   "started",
   "waiting",
@@ -1612,21 +1820,21 @@ var OperationStatus = Schema18.Literals([
   "compensating",
   "compensated"
 ]);
-var OperationState = Schema18.Struct({
+var OperationState = Schema19.Struct({
   execution_id: ExecutionId,
   operation_id: WorkflowOperationId,
   status: OperationStatus,
-  fan_out_id: Schema18.optionalKey(ChildFanOutId),
-  decision: Schema18.optionalKey(Schema18.Boolean),
-  output: Schema18.optionalKey(JsonValue),
-  attempt: Schema18.optionalKey(Schema18.Int.check(Schema18.isGreaterThanOrEqualTo(0))),
-  backoff_until: Schema18.optionalKey(TimestampMillis),
-  compensation_operation_id: Schema18.optionalKey(WorkflowOperationId),
-  started_at: Schema18.optionalKey(TimestampMillis),
-  completed_at: Schema18.optionalKey(TimestampMillis),
+  fan_out_id: Schema19.optionalKey(ChildFanOutId),
+  decision: Schema19.optionalKey(Schema19.Boolean),
+  output: Schema19.optionalKey(JsonValue),
+  attempt: Schema19.optionalKey(Schema19.Int.check(Schema19.isGreaterThanOrEqualTo(0))),
+  backoff_until: Schema19.optionalKey(TimestampMillis),
+  compensation_operation_id: Schema19.optionalKey(WorkflowOperationId),
+  started_at: Schema19.optionalKey(TimestampMillis),
+  completed_at: Schema19.optionalKey(TimestampMillis),
   updated_at: TimestampMillis
 });
-var LifecycleEventType = Schema18.Literals([
+var LifecycleEventType = Schema19.Literals([
   "workflow.started",
   "operation.started",
   "operation.waiting",
@@ -1642,12 +1850,12 @@ var LifecycleEventType = Schema18.Literals([
   "workflow.completed",
   "workflow.failed"
 ]);
-var LifecycleEvent = Schema18.Struct({
+var LifecycleEvent = Schema19.Struct({
   execution_id: ExecutionId,
-  sequence: Schema18.Int.check(Schema18.isGreaterThanOrEqualTo(1)),
+  sequence: Schema19.Int.check(Schema19.isGreaterThanOrEqualTo(1)),
   type: LifecycleEventType,
-  operation_id: Schema18.optionalKey(WorkflowOperationId),
-  data: Schema18.optionalKey(JsonValue),
+  operation_id: Schema19.optionalKey(WorkflowOperationId),
+  data: Schema19.optionalKey(JsonValue),
   created_at: TimestampMillis
 });
 var exports_workspace_schema = {};
@@ -1662,7 +1870,7 @@ __export2(exports_workspace_schema, {
   WorkspaceCapabilities: () => WorkspaceCapabilities
 });
 var WorkspaceProviderKey = NonEmptyString.annotate({ identifier: "Relay.WorkspaceProviderKey" });
-var WorkspaceLeaseStatus = Schema19.Literals([
+var WorkspaceLeaseStatus = Schema20.Literals([
   "planned",
   "running",
   "suspended",
@@ -1671,59 +1879,59 @@ var WorkspaceLeaseStatus = Schema19.Literals([
   "released",
   "failed"
 ]).annotate({ identifier: "Relay.WorkspaceLeaseStatus" });
-var WorkspaceResumeStrategy = Schema19.Literals(["reattach", "restore_snapshot"]).annotate({
+var WorkspaceResumeStrategy = Schema20.Literals(["reattach", "restore_snapshot"]).annotate({
   identifier: "Relay.WorkspaceResumeStrategy"
 });
-var WorkspaceCapabilities = Schema19.Struct({
-  can_suspend: Schema19.Boolean,
-  can_snapshot: Schema19.Boolean,
-  can_fork: Schema19.Boolean,
-  persistent_by_default: Schema19.Boolean,
-  suspend_granularity: Schema19.Literals(["memory", "filesystem", "none"]),
-  max_suspend_duration_ms: Schema19.optionalKey(Schema19.Finite),
-  reattach_by_ref: Schema19.Boolean
+var WorkspaceCapabilities = Schema20.Struct({
+  can_suspend: Schema20.Boolean,
+  can_snapshot: Schema20.Boolean,
+  can_fork: Schema20.Boolean,
+  persistent_by_default: Schema20.Boolean,
+  suspend_granularity: Schema20.Literals(["memory", "filesystem", "none"]),
+  max_suspend_duration_ms: Schema20.optionalKey(Schema20.Finite),
+  reattach_by_ref: Schema20.Boolean
 }).annotate({ identifier: "Relay.WorkspaceCapabilities" });
-var WorkspaceRequest = Schema19.Struct({
-  provider_key: Schema19.optionalKey(WorkspaceProviderKey),
-  resume_snapshot_ref: Schema19.optionalKey(SnapshotRef),
-  metadata: Schema19.optionalKey(Metadata)
+var WorkspaceRequest = Schema20.Struct({
+  provider_key: Schema20.optionalKey(WorkspaceProviderKey),
+  resume_snapshot_ref: Schema20.optionalKey(SnapshotRef),
+  metadata: Schema20.optionalKey(Metadata)
 }).annotate({ identifier: "Relay.WorkspaceRequest" });
-var WorkspaceLeaseRecord = Schema19.Struct({
+var WorkspaceLeaseRecord = Schema20.Struct({
   id: WorkspaceLeaseId,
   execution_id: ExecutionId,
   provider_key: WorkspaceProviderKey,
-  sandbox_ref: Schema19.optionalKey(WorkspaceRef),
-  latest_snapshot_ref: Schema19.optionalKey(SnapshotRef),
+  sandbox_ref: Schema20.optionalKey(WorkspaceRef),
+  latest_snapshot_ref: Schema20.optionalKey(SnapshotRef),
   status: WorkspaceLeaseStatus,
   resume_strategy: WorkspaceResumeStrategy,
-  region: Schema19.optionalKey(NonEmptyString),
-  request: Schema19.optionalKey(WorkspaceRequest),
-  metadata: Schema19.optionalKey(Metadata),
+  region: Schema20.optionalKey(NonEmptyString),
+  request: Schema20.optionalKey(WorkspaceRequest),
+  metadata: Schema20.optionalKey(Metadata),
   created_at: TimestampMillis,
   updated_at: TimestampMillis
 }).annotate({ identifier: "Relay.WorkspaceLeaseRecord" });
-var WorkspaceSnapshotReason = Schema19.Literals([
+var WorkspaceSnapshotReason = Schema20.Literals([
   "before_wait",
   "before_child_fork",
   "on_complete",
   "on_failure",
   "manual"
 ]).annotate({ identifier: "Relay.WorkspaceSnapshotReason" });
-var WorkspaceSnapshotRecord = Schema19.Struct({
+var WorkspaceSnapshotRecord = Schema20.Struct({
   id: WorkspaceSnapshotId,
   lease_id: WorkspaceLeaseId,
   execution_id: ExecutionId,
   reason: WorkspaceSnapshotReason,
   snapshot_ref: SnapshotRef,
-  metadata: Schema19.optionalKey(Metadata),
+  metadata: Schema20.optionalKey(Metadata),
   created_at: TimestampMillis
 }).annotate({ identifier: "Relay.WorkspaceSnapshotRecord" });
 
 // src/state-version-conflict.ts
-import { Schema as Schema20 } from "effect";
-var NonNegativeStateVersion = Schema20.Int.check(Schema20.isGreaterThanOrEqualTo(0));
+import { Schema as Schema21 } from "effect";
+var NonNegativeStateVersion = Schema21.Int.check(Schema21.isGreaterThanOrEqualTo(0));
 
-class StateVersionConflict extends Schema20.TaggedErrorClass()("StateVersionConflict", {
+class StateVersionConflict extends Schema21.TaggedErrorClass()("StateVersionConflict", {
   execution_id: exports_ids_schema.ExecutionId,
   key: exports_state_schema.StateKey,
   expected_version: NonNegativeStateVersion,
@@ -1747,6 +1955,7 @@ __export(exports_operation, {
   ToolWorkReleased: () => ToolWorkReleased,
   ToolWorkLease: () => ToolWorkLease,
   ToolOutcomeAccepted: () => ToolOutcomeAccepted,
+  ToolInvocation: () => ToolInvocation,
   ToolCallSummary: () => ToolCallSummary,
   ToolAttemptList: () => ToolAttemptList,
   ToolAttempt: () => ToolAttempt,
@@ -1826,6 +2035,7 @@ __export(exports_operation, {
   ClaimToolWorkInput: () => ClaimToolWorkInput,
   ClaimEnvelopeReadyInput: () => ClaimEnvelopeReadyInput,
   ChildRunSummary: () => ChildRunSummary,
+  ChildRunEdge: () => ChildRunEdge,
   CancelScheduleResult: () => CancelScheduleResult,
   CancelScheduleInput: () => CancelScheduleInput,
   CancelExecutionInput: () => CancelExecutionInput,
@@ -1835,170 +2045,171 @@ __export(exports_operation, {
   AwaitWaitInput: () => AwaitWaitInput,
   AckEnvelopeReadyInput: () => AckEnvelopeReadyInput
 });
-import { Schema as Schema22 } from "effect";
-var StartExecutionInput = Schema22.Struct({
+import { Schema as Schema23 } from "effect";
+var StartExecutionInput = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   root_address_id: exports_ids_schema.AddressId,
-  session_id: Schema22.optionalKey(exports_ids_schema.SessionId),
-  input: Schema22.optionalKey(Schema22.Array(exports_content_schema.Part)),
+  session_id: Schema23.optionalKey(exports_ids_schema.SessionId),
+  input: Schema23.optionalKey(Schema23.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: Schema22.optionalKey(exports_ids_schema.AgentId),
-  agent_revision: Schema22.optionalKey(exports_agent_schema.DefinitionRevision),
-  agent_snapshot: Schema22.optionalKey(exports_agent_schema.Definition),
-  agent_tool_input_schema_digests: Schema22.optionalKey(exports_agent_schema.ToolInputSchemaDigests),
-  wait_id: Schema22.optionalKey(exports_ids_schema.WaitId),
-  metadata: Schema22.optionalKey(exports_shared_schema.Metadata)
+  agent_id: Schema23.optionalKey(exports_ids_schema.AgentId),
+  agent_revision: Schema23.optionalKey(exports_agent_schema.DefinitionRevision),
+  agent_snapshot: Schema23.optionalKey(exports_agent_schema.Definition),
+  agent_tool_input_schema_digests: Schema23.optionalKey(exports_agent_schema.ToolInputSchemaDigests),
+  wait_id: Schema23.optionalKey(exports_ids_schema.WaitId),
+  origin: Schema23.optionalKey(exports_execution_schema.ExecutionOrigin),
+  metadata: Schema23.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.Operation.StartExecutionInput" });
-var StartExecutionResult = Schema22.Struct({
+var StartExecutionResult = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   status: exports_execution_schema.ExecutionStatus,
-  metadata: Schema22.optionalKey(exports_shared_schema.Metadata)
+  metadata: Schema23.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.Operation.StartExecutionResult" });
-var SpawnResidentInput = Schema22.Struct({
+var SpawnResidentInput = Schema23.Struct({
   kind: exports_ids_schema.ResidentKindName,
   key: exports_ids_schema.ResidentKey,
-  input: Schema22.optionalKey(Schema22.Array(exports_content_schema.Part)),
-  metadata: Schema22.optionalKey(exports_shared_schema.Metadata),
+  input: Schema23.optionalKey(Schema23.Array(exports_content_schema.Part)),
+  metadata: Schema23.optionalKey(exports_shared_schema.Metadata),
   created_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.SpawnResidentInput" });
-var GetResidentInput = Schema22.Struct({ kind: exports_ids_schema.ResidentKindName, key: exports_ids_schema.ResidentKey }).annotate({
+var GetResidentInput = Schema23.Struct({ kind: exports_ids_schema.ResidentKindName, key: exports_ids_schema.ResidentKey }).annotate({
   identifier: "Relay.Operation.GetResidentInput"
 });
-var DestroyResidentInput = Schema22.Struct({
+var DestroyResidentInput = Schema23.Struct({
   kind: exports_ids_schema.ResidentKindName,
   key: exports_ids_schema.ResidentKey,
-  reason: Schema22.optionalKey(Schema22.String),
+  reason: Schema23.optionalKey(Schema23.String),
   destroyed_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.DestroyResidentInput" });
-var ListResidentsInput = Schema22.Struct({
-  kind: Schema22.optionalKey(exports_ids_schema.ResidentKindName),
-  after_kind: Schema22.optionalKey(exports_ids_schema.ResidentKindName),
-  after_key: Schema22.optionalKey(Schema22.String),
-  limit: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThan(0)))
+var ListResidentsInput = Schema23.Struct({
+  kind: Schema23.optionalKey(exports_ids_schema.ResidentKindName),
+  after_kind: Schema23.optionalKey(exports_ids_schema.ResidentKindName),
+  after_key: Schema23.optionalKey(Schema23.String),
+  limit: Schema23.optionalKey(Schema23.Int.check(Schema23.isGreaterThan(0)))
 }).annotate({ identifier: "Relay.Operation.ListResidentsInput" });
 var ResidentInstance = exports_resident_schema.Instance;
-var StreamExecutionInput = Schema22.Struct({
+var StreamExecutionInput = Schema23.Struct({
   execution_id: exports_execution_schema.Execution.fields.id,
-  after_cursor: Schema22.optionalKey(exports_shared_schema.NonEmptyString),
-  limit: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThan(0)))
+  after_cursor: Schema23.optionalKey(exports_shared_schema.NonEmptyString),
+  limit: Schema23.optionalKey(Schema23.Int.check(Schema23.isGreaterThan(0)))
 }).annotate({ identifier: "Relay.Operation.StreamExecutionInput" });
-var GetResidentStateInput = Schema22.Struct({ execution_id: exports_ids_schema.ExecutionId, key: exports_state_schema.StateKey }).annotate({
+var GetResidentStateInput = Schema23.Struct({ execution_id: exports_ids_schema.ExecutionId, key: exports_state_schema.StateKey }).annotate({
   identifier: "Relay.Operation.GetResidentStateInput"
 });
-var PutResidentStateInput = Schema22.Struct({
+var PutResidentStateInput = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   key: exports_state_schema.StateKey,
   value: exports_shared_schema.JsonValue,
-  expected_version: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThanOrEqualTo(0))),
-  idempotency_key: Schema22.optionalKey(exports_state_schema.StateIdempotencyKey.check(Schema22.makeFilter((value) => !value.startsWith("relay:internal:")))),
+  expected_version: Schema23.optionalKey(Schema23.Int.check(Schema23.isGreaterThanOrEqualTo(0))),
+  idempotency_key: Schema23.optionalKey(exports_state_schema.StateIdempotencyKey.check(Schema23.makeFilter((value) => !value.startsWith("relay:internal:")))),
   updated_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.PutResidentStateInput" });
-var DeleteResidentStateInput = Schema22.Struct({
+var DeleteResidentStateInput = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   key: exports_state_schema.StateKey,
-  expected_version: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThanOrEqualTo(0))),
-  idempotency_key: Schema22.optionalKey(exports_state_schema.StateIdempotencyKey.check(Schema22.makeFilter((value) => !value.startsWith("relay:internal:")))),
+  expected_version: Schema23.optionalKey(Schema23.Int.check(Schema23.isGreaterThanOrEqualTo(0))),
+  idempotency_key: Schema23.optionalKey(exports_state_schema.StateIdempotencyKey.check(Schema23.makeFilter((value) => !value.startsWith("relay:internal:")))),
   removed_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.DeleteResidentStateInput" });
-var ListResidentStateInput = Schema22.Struct({
+var ListResidentStateInput = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
-  prefix: Schema22.optionalKey(Schema22.String),
-  after_key: Schema22.optionalKey(Schema22.String),
-  limit: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThan(0)))
+  prefix: Schema23.optionalKey(Schema23.String),
+  after_key: Schema23.optionalKey(Schema23.String),
+  limit: Schema23.optionalKey(Schema23.Int.check(Schema23.isGreaterThan(0)))
 }).annotate({ identifier: "Relay.Operation.ListResidentStateInput" });
-var WaitTerminalState = Schema22.Literals(["resolved", "timed_out", "cancelled"]).annotate({
+var WaitTerminalState = Schema23.Literals(["resolved", "timed_out", "cancelled"]).annotate({
   identifier: "Relay.Operation.WaitTerminalState"
 });
-var AwaitWaitInput = Schema22.Struct({
+var AwaitWaitInput = Schema23.Struct({
   wait_id: exports_ids_schema.WaitId,
   execution_id: exports_ids_schema.ExecutionId
 }).annotate({ identifier: "Relay.Operation.AwaitWaitInput" });
-var WaitOutcome = Schema22.Struct({
+var WaitOutcome = Schema23.Struct({
   wait_id: exports_ids_schema.WaitId,
   state: WaitTerminalState,
-  content: Schema22.optionalKey(Schema22.Array(exports_content_schema.Part)),
-  metadata: Schema22.optionalKey(exports_shared_schema.Metadata)
+  content: Schema23.optionalKey(Schema23.Array(exports_content_schema.Part)),
+  metadata: Schema23.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.Operation.WaitOutcome" });
-var CancelExecutionInput = Schema22.Struct({
+var CancelExecutionInput = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   cancelled_at: exports_shared_schema.TimestampMillis,
-  reason: Schema22.optionalKey(Schema22.String)
+  reason: Schema23.optionalKey(Schema23.String)
 }).annotate({ identifier: "Relay.Operation.CancelExecutionInput" });
-var CancelExecutionAccepted = Schema22.Struct({
+var CancelExecutionAccepted = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   status: exports_execution_schema.ExecutionStatus
 }).annotate({ identifier: "Relay.Operation.CancelExecutionAccepted" });
-var SteeringKind = Schema22.Literals(["steering", "follow_up"]).annotate({
+var SteeringKind = Schema23.Literals(["steering", "follow_up"]).annotate({
   identifier: "Relay.Operation.SteeringKind"
 });
-var SteerInput = Schema22.Struct({
+var SteerInput = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   kind: SteeringKind,
-  content: Schema22.Array(exports_content_schema.Part),
+  content: Schema23.Array(exports_content_schema.Part),
   created_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.SteerInput" });
-var SteerAccepted = Schema22.Struct({
+var SteerAccepted = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   kind: SteeringKind,
-  sequence: Schema22.Int.check(Schema22.isGreaterThanOrEqualTo(0)),
+  sequence: Schema23.Int.check(Schema23.isGreaterThanOrEqualTo(0)),
   steering_message_id: exports_ids_schema.SteeringMessageId
 }).annotate({ identifier: "Relay.Operation.SteerAccepted" });
-var WakeInput = Schema22.Struct({
+var WakeInput = Schema23.Struct({
   wait_id: exports_ids_schema.WaitId,
   state: WaitTerminalState,
   signaled_at: exports_shared_schema.TimestampMillis,
-  from: Schema22.optionalKey(exports_ids_schema.AddressId),
-  content: Schema22.optionalKey(Schema22.Array(exports_content_schema.Part)),
-  correlation_key: Schema22.optionalKey(Schema22.String),
-  metadata: Schema22.optionalKey(exports_shared_schema.Metadata)
+  from: Schema23.optionalKey(exports_ids_schema.AddressId),
+  content: Schema23.optionalKey(Schema23.Array(exports_content_schema.Part)),
+  correlation_key: Schema23.optionalKey(Schema23.String),
+  metadata: Schema23.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.Operation.WakeInput" });
-var WakeAccepted = Schema22.Struct({
+var WakeAccepted = Schema23.Struct({
   wait_id: exports_ids_schema.WaitId,
   state: WaitTerminalState,
   signaled_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.WakeAccepted" });
-var WaitState = Schema22.Literals(["open", "resolved", "timed_out", "cancelled"]).annotate({
+var WaitState = Schema23.Literals(["open", "resolved", "timed_out", "cancelled"]).annotate({
   identifier: "Relay.Operation.WaitState"
 });
-var ListWaitsInput = Schema22.Struct({
-  state: Schema22.optionalKey(WaitState),
-  execution_id: Schema22.optionalKey(exports_ids_schema.ExecutionId),
-  limit: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThan(0)))
+var ListWaitsInput = Schema23.Struct({
+  state: Schema23.optionalKey(WaitState),
+  execution_id: Schema23.optionalKey(exports_ids_schema.ExecutionId),
+  limit: Schema23.optionalKey(Schema23.Int.check(Schema23.isGreaterThan(0)))
 }).annotate({ identifier: "Relay.Operation.ListWaitsInput" });
-var WaitView = Schema22.Struct({
+var WaitView = Schema23.Struct({
   wait_id: exports_ids_schema.WaitId,
   execution_id: exports_ids_schema.ExecutionId,
-  envelope_id: Schema22.optionalKey(exports_ids_schema.EnvelopeId),
-  kind: Schema22.optionalKey(exports_wait_schema.WaitKind),
+  envelope_id: Schema23.optionalKey(exports_ids_schema.EnvelopeId),
+  kind: Schema23.optionalKey(exports_wait_schema.WaitKind),
   mode: exports_envelope_schema.WaitMode,
-  correlation_key: Schema22.optionalKey(Schema22.String),
+  correlation_key: Schema23.optionalKey(Schema23.String),
   state: WaitState,
   metadata: exports_shared_schema.Metadata,
   created_at: exports_shared_schema.TimestampMillis,
-  resolved_at: Schema22.optionalKey(exports_shared_schema.TimestampMillis)
+  resolved_at: Schema23.optionalKey(exports_shared_schema.TimestampMillis)
 }).annotate({ identifier: "Relay.Operation.WaitView" });
-var FollowStopReason = Schema22.Union([
-  Schema22.Struct({ _tag: Schema22.tag("terminal"), status: exports_execution_schema.ExecutionStatus }),
-  Schema22.Struct({ _tag: Schema22.tag("actionable_wait"), wait: WaitView })
+var FollowStopReason = Schema23.Union([
+  Schema23.Struct({ _tag: Schema23.tag("terminal"), status: exports_execution_schema.ExecutionStatus }),
+  Schema23.Struct({ _tag: Schema23.tag("actionable_wait"), wait: WaitView })
 ]).annotate({ identifier: "Relay.Operation.FollowStopReason" });
-var FollowExecutionItem = Schema22.Union([
-  Schema22.Struct({ _tag: Schema22.tag("event"), event: exports_execution_schema.ExecutionEvent }),
-  Schema22.Struct({ _tag: Schema22.tag("reconnecting"), message: Schema22.String, attempt: Schema22.Int }),
-  Schema22.Struct({
-    _tag: Schema22.tag("stopped"),
+var FollowExecutionItem = Schema23.Union([
+  Schema23.Struct({ _tag: Schema23.tag("event"), event: exports_execution_schema.ExecutionEvent }),
+  Schema23.Struct({ _tag: Schema23.tag("reconnecting"), message: Schema23.String, attempt: Schema23.Int }),
+  Schema23.Struct({
+    _tag: Schema23.tag("stopped"),
     reason: FollowStopReason,
-    cursor: Schema22.NullOr(exports_shared_schema.NonEmptyString)
+    cursor: Schema23.NullOr(exports_shared_schema.NonEmptyString)
   })
 ]).annotate({ identifier: "Relay.Operation.FollowExecutionItem" });
-var FollowExecutionInput = Schema22.Struct({
+var FollowExecutionInput = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
-  after_cursor: Schema22.optionalKey(exports_shared_schema.NonEmptyString),
-  stop_on_wait_modes: Schema22.optionalKey(Schema22.Array(exports_envelope_schema.WaitMode)),
-  max_reconnects: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThanOrEqualTo(0)))
+  after_cursor: Schema23.optionalKey(exports_shared_schema.NonEmptyString),
+  stop_on_wait_modes: Schema23.optionalKey(Schema23.Array(exports_envelope_schema.WaitMode)),
+  max_reconnects: Schema23.optionalKey(Schema23.Int.check(Schema23.isGreaterThanOrEqualTo(0)))
 }).annotate({ identifier: "Relay.Operation.FollowExecutionInput" });
-var PendingToolApproval = Schema22.Struct({
+var PendingToolApproval = Schema23.Struct({
   wait_id: exports_ids_schema.WaitId,
   execution_id: exports_ids_schema.ExecutionId,
   tool_call_id: exports_ids_schema.ToolCallId,
@@ -2006,42 +2217,42 @@ var PendingToolApproval = Schema22.Struct({
   input: exports_shared_schema.JsonValue,
   requested_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.PendingToolApproval" });
-var ListPendingApprovalsInput = Schema22.Struct({
+var ListPendingApprovalsInput = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId
 }).annotate({ identifier: "Relay.Operation.ListPendingApprovalsInput" });
-var PendingToolApprovalList = Schema22.Struct({
-  approvals: Schema22.Array(PendingToolApproval)
+var PendingToolApprovalList = Schema23.Struct({
+  approvals: Schema23.Array(PendingToolApproval)
 }).annotate({ identifier: "Relay.Operation.PendingToolApprovalList" });
-var PendingToolCall = Schema22.Struct({
+var PendingToolCall = Schema23.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: Schema22.String,
+  idempotency_key: Schema23.String,
   requested_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.PendingToolCall" });
-var ListPendingToolCallsInput = Schema22.Struct({
-  execution_id: Schema22.optionalKey(exports_ids_schema.ExecutionId),
-  limit: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThan(0)))
+var ListPendingToolCallsInput = Schema23.Struct({
+  execution_id: Schema23.optionalKey(exports_ids_schema.ExecutionId),
+  limit: Schema23.optionalKey(Schema23.Int.check(Schema23.isGreaterThan(0)))
 }).annotate({ identifier: "Relay.Operation.ListPendingToolCallsInput" });
-var PendingToolCallList = Schema22.Struct({
-  tool_calls: Schema22.Array(PendingToolCall)
+var PendingToolCallList = Schema23.Struct({
+  tool_calls: Schema23.Array(PendingToolCall)
 }).annotate({ identifier: "Relay.Operation.PendingToolCallList" });
-var FulfillToolCallInput = Schema22.Struct({
+var FulfillToolCallInput = Schema23.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 = Schema22.Struct({
+var ClaimToolWorkInput = Schema23.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 = Schema22.Struct({
+var CompleteToolWorkInput = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   tool_call_id: exports_ids_schema.ToolCallId,
   attempt_id: exports_ids_schema.ToolAttemptId,
@@ -2049,39 +2260,52 @@ var CompleteToolWorkInput = Schema22.Struct({
   outcome: exports_tool_schema.ExternalOutcome,
   completed_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.CompleteToolWorkInput" });
-var ReleaseToolWorkInput = Schema22.Struct({
+var ReleaseToolWorkInput = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   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: Schema22.optionalKey(Schema22.String)
+  error: Schema23.optionalKey(Schema23.String)
 }).annotate({ identifier: "Relay.Operation.ReleaseToolWorkInput" });
-var ListToolAttemptsInput = Schema22.Struct({
+var ListToolAttemptsInput = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   tool_call_id: exports_ids_schema.ToolCallId
 }).annotate({ identifier: "Relay.Operation.ListToolAttemptsInput" });
-var ToolAttempt = Schema22.Struct({
+var ToolAttempt = Schema23.Struct({
   attempt_id: exports_ids_schema.ToolAttemptId,
   tool_call_id: exports_ids_schema.ToolCallId,
-  attempt_number: Schema22.Int.check(Schema22.isGreaterThan(0)),
+  attempt_number: Schema23.Int.check(Schema23.isGreaterThan(0)),
   state: exports_tool_schema.AttemptState,
-  worker_id: Schema22.optionalKey(Schema22.String),
-  claim_expires_at: Schema22.optionalKey(exports_shared_schema.TimestampMillis),
-  error: Schema22.optionalKey(Schema22.String),
+  worker_id: Schema23.optionalKey(Schema23.String),
+  claim_expires_at: Schema23.optionalKey(exports_shared_schema.TimestampMillis),
+  error: Schema23.optionalKey(Schema23.String),
   created_at: exports_shared_schema.TimestampMillis,
-  completed_at: Schema22.optionalKey(exports_shared_schema.TimestampMillis)
+  completed_at: Schema23.optionalKey(exports_shared_schema.TimestampMillis)
 }).annotate({ identifier: "Relay.Operation.ToolAttempt" });
-var ToolAttemptList = Schema22.Struct({
-  attempts: Schema22.Array(ToolAttempt)
+var ToolAttemptList = Schema23.Struct({
+  attempts: Schema23.Array(ToolAttempt)
 }).annotate({ identifier: "Relay.Operation.ToolAttemptList" });
-var ToolOutcomeAccepted = Schema22.Struct({
+var ToolInvocation = Schema23.Struct({
+  invocation_id: exports_shared_schema.NonEmptyString,
+  tool_call_id: exports_ids_schema.ToolCallId,
+  attempt_id: exports_ids_schema.ToolAttemptId,
+  placement: Schema23.Literals(["local", "client", "remote", "mcp"]),
+  state: exports_tool_schema.AttemptState,
+  outcome: Schema23.optionalKey(Schema23.Literals(["success", "failure", "abandoned"])),
+  failure_category: Schema23.optionalKey(Schema23.Literals(["handler", "worker", "abandoned", "unknown"])),
+  started_at: exports_shared_schema.TimestampMillis,
+  completed_at: Schema23.optionalKey(exports_shared_schema.TimestampMillis),
+  claim_expires_at: Schema23.optionalKey(exports_shared_schema.TimestampMillis),
+  worker_id: Schema23.optionalKey(exports_tool_schema.WorkerId)
+}).annotate({ identifier: "Relay.Operation.ToolInvocation" });
+var ToolOutcomeAccepted = Schema23.Struct({
   tool_call_id: exports_ids_schema.ToolCallId,
   attempt: ToolAttempt,
-  duplicate: Schema22.Boolean
+  duplicate: Schema23.Boolean
 }).annotate({ identifier: "Relay.Operation.ToolOutcomeAccepted" });
-var ToolWorkLease = Schema22.Struct({
+var ToolWorkLease = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   call: exports_tool_schema.Call,
   definition: exports_tool_schema.Definition,
@@ -2090,222 +2314,222 @@ var ToolWorkLease = Schema22.Struct({
   queue: exports_tool_schema.PlacementKey,
   worker_id: exports_tool_schema.WorkerId,
   claim_expires_at: exports_shared_schema.TimestampMillis,
-  idempotency_key: Schema22.String
+  idempotency_key: Schema23.String
 }).annotate({ identifier: "Relay.Operation.ToolWorkLease" });
-var ToolWorkReleased = Schema22.Struct({
+var ToolWorkReleased = Schema23.Struct({
   tool_call_id: exports_ids_schema.ToolCallId,
-  state: Schema22.Literal("waiting"),
+  state: Schema23.Literal("waiting"),
   next_available_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.ToolWorkReleased" });
-var SpawnChildRunInput2 = Schema22.Struct({
+var SpawnChildRunInput2 = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
-  child_execution_id: Schema22.optionalKey(exports_ids_schema.ChildExecutionId),
+  child_execution_id: Schema23.optionalKey(exports_ids_schema.ChildExecutionId),
   address_id: exports_ids_schema.AddressId,
-  preset_name: Schema22.optionalKey(exports_shared_schema.NonEmptyString),
-  instructions: Schema22.optionalKey(Schema22.String),
-  model: Schema22.optionalKey(exports_agent_schema.ModelSelection),
-  compaction_policy: Schema22.optionalKey(exports_agent_schema.CompactionPolicy),
-  tool_names: Schema22.optionalKey(Schema22.Array(Schema22.String)),
-  permissions: Schema22.optionalKey(Schema22.Array(Schema22.String)),
-  workspace_policy: Schema22.optionalKey(exports_agent_schema.ChildRunWorkspacePolicy),
-  output_schema_ref: Schema22.optionalKey(Schema22.String),
-  metadata: Schema22.optionalKey(exports_shared_schema.Metadata),
-  input: Schema22.optionalKey(Schema22.Array(exports_content_schema.Part)),
-  wait: Schema22.optionalKey(Schema22.Boolean)
+  preset_name: Schema23.optionalKey(exports_shared_schema.NonEmptyString),
+  instructions: Schema23.optionalKey(Schema23.String),
+  model: Schema23.optionalKey(exports_agent_schema.ModelSelection),
+  compaction_policy: Schema23.optionalKey(exports_agent_schema.CompactionPolicy),
+  tool_names: Schema23.optionalKey(Schema23.Array(Schema23.String)),
+  permissions: Schema23.optionalKey(Schema23.Array(Schema23.String)),
+  workspace_policy: Schema23.optionalKey(exports_agent_schema.ChildRunWorkspacePolicy),
+  output_schema_ref: Schema23.optionalKey(Schema23.String),
+  metadata: Schema23.optionalKey(exports_shared_schema.Metadata),
+  input: Schema23.optionalKey(Schema23.Array(exports_content_schema.Part)),
+  wait: Schema23.optionalKey(Schema23.Boolean)
 }).annotate({ identifier: "Relay.Operation.SpawnChildRunInput" });
 var CreateChildFanOutInput = exports_child_orchestration_schema.FanOutDefinition.annotate({
   identifier: "Relay.Operation.CreateChildFanOutInput"
 });
-var CancelChildFanOutInput = Schema22.Struct({
+var CancelChildFanOutInput = Schema23.Struct({
   fan_out_id: exports_ids_schema.ChildFanOutId,
   cancelled_at: exports_shared_schema.TimestampMillis,
-  reason: Schema22.optionalKey(Schema22.String)
+  reason: Schema23.optionalKey(Schema23.String)
 }).annotate({ identifier: "Relay.Operation.CancelChildFanOutInput" });
-var CancelChildFanOutResult = Schema22.Struct({
+var CancelChildFanOutResult = Schema23.Struct({
   fan_out: exports_child_orchestration_schema.FanOutState
 }).annotate({ identifier: "Relay.Operation.CancelChildFanOutResult" });
-var InspectChildFanOutInput = Schema22.Struct({
+var InspectChildFanOutInput = Schema23.Struct({
   fan_out_id: exports_ids_schema.ChildFanOutId
 }).annotate({ identifier: "Relay.Operation.InspectChildFanOutInput" });
-var InspectChildFanOutResult = Schema22.Struct({
-  fan_out: Schema22.NullOr(exports_child_orchestration_schema.FanOutState)
+var InspectChildFanOutResult = Schema23.Struct({
+  fan_out: Schema23.NullOr(exports_child_orchestration_schema.FanOutState)
 }).annotate({ identifier: "Relay.Operation.InspectChildFanOutResult" });
-var ResolveToolApprovalInput = Schema22.Struct({
+var ResolveToolApprovalInput = Schema23.Struct({
   wait_id: exports_ids_schema.WaitId,
-  approved: Schema22.Boolean,
-  comment: Schema22.optionalKey(Schema22.String),
+  approved: Schema23.Boolean,
+  comment: Schema23.optionalKey(Schema23.String),
   resolved_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.ResolveToolApprovalInput" });
-var PermissionAnswer = Schema22.Literals(["Approved", "Denied", "Always"]).annotate({
+var PermissionAnswer = Schema23.Literals(["Approved", "Denied", "Always"]).annotate({
   identifier: "Relay.Operation.PermissionAnswer"
 });
-var ResolvePermissionInput = Schema22.Struct({
+var ResolvePermissionInput = Schema23.Struct({
   wait_id: exports_ids_schema.WaitId,
   answer: PermissionAnswer,
-  reason: Schema22.optionalKey(Schema22.String),
+  reason: Schema23.optionalKey(Schema23.String),
   resolved_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.ResolvePermissionInput" });
-var SubmitInboundEnvelopeInput = Schema22.Struct({
+var SubmitInboundEnvelopeInput = Schema23.Struct({
   envelope: exports_envelope_schema.SendInput,
   wake: WakeInput
 }).annotate({ identifier: "Relay.Operation.SubmitInboundEnvelopeInput" });
-var SubmitInboundEnvelopeAccepted = Schema22.Struct({
+var SubmitInboundEnvelopeAccepted = Schema23.Struct({
   envelope: exports_envelope_schema.EnvelopeAccepted,
   wake: WakeAccepted
 }).annotate({ identifier: "Relay.Operation.SubmitInboundEnvelopeAccepted" });
-var ClaimEnvelopeReadyInput = Schema22.Struct({
+var ClaimEnvelopeReadyInput = Schema23.Struct({
   route_type: exports_address_schema.RouteKind,
-  route_key: Schema22.optionalKey(Schema22.String),
+  route_key: Schema23.optionalKey(Schema23.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 = Schema22.Struct({
+var EnvelopeReadyLease = Schema23.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 = Schema22.Struct({
+var AckEnvelopeReadyInput = Schema23.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 = Schema22.Struct({
+var EnvelopeReadyAcked = Schema23.Struct({
   envelope_ready_id: exports_ids_schema.EnvelopeReadyId,
-  state: Schema22.Literal("acknowledged"),
+  state: Schema23.Literal("acknowledged"),
   acknowledged_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.EnvelopeReadyAcked" });
-var ReleaseEnvelopeReadyInput = Schema22.Struct({
+var ReleaseEnvelopeReadyInput = Schema23.Struct({
   envelope_ready_id: exports_ids_schema.EnvelopeReadyId,
   worker_id: exports_shared_schema.NonEmptyString,
   next_available_at: exports_shared_schema.TimestampMillis,
-  error: Schema22.optionalKey(Schema22.String)
+  error: Schema23.optionalKey(Schema23.String)
 }).annotate({ identifier: "Relay.Operation.ReleaseEnvelopeReadyInput" });
-var EnvelopeReadyReleased = Schema22.Struct({
+var EnvelopeReadyReleased = Schema23.Struct({
   envelope_ready_id: exports_ids_schema.EnvelopeReadyId,
-  state: Schema22.Literal("ready"),
+  state: Schema23.Literal("ready"),
   next_available_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.EnvelopeReadyReleased" });
-var CreateScheduleInput = Schema22.Struct({
+var CreateScheduleInput = Schema23.Struct({
   schedule_id: exports_ids_schema.ScheduleId,
   kind: exports_schedule_schema.ScheduleKind,
   target_kind: exports_schedule_schema.ScheduleTargetKind,
-  address_id: Schema22.optionalKey(exports_ids_schema.AddressId),
-  wait_id: Schema22.optionalKey(exports_ids_schema.WaitId),
-  cron_expr: Schema22.optionalKey(exports_shared_schema.NonEmptyString),
-  input: Schema22.optionalKey(Schema22.Array(exports_content_schema.Part)),
+  address_id: Schema23.optionalKey(exports_ids_schema.AddressId),
+  wait_id: Schema23.optionalKey(exports_ids_schema.WaitId),
+  cron_expr: Schema23.optionalKey(exports_shared_schema.NonEmptyString),
+  input: Schema23.optionalKey(Schema23.Array(exports_content_schema.Part)),
   next_run_at: exports_shared_schema.TimestampMillis,
-  idempotency_key: Schema22.optionalKey(exports_shared_schema.NonEmptyString),
-  metadata: Schema22.optionalKey(exports_shared_schema.Metadata)
+  idempotency_key: Schema23.optionalKey(exports_shared_schema.NonEmptyString),
+  metadata: Schema23.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.Operation.CreateScheduleInput" });
-var CreateScheduleResult = Schema22.Struct({
+var CreateScheduleResult = Schema23.Struct({
   schedule: exports_schedule_schema.ScheduleRecord
 }).annotate({ identifier: "Relay.Operation.CreateScheduleResult" });
-var CancelScheduleInput = Schema22.Struct({
+var CancelScheduleInput = Schema23.Struct({
   schedule_id: exports_ids_schema.ScheduleId,
   cancelled_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.CancelScheduleInput" });
-var CancelScheduleResult = Schema22.Struct({
+var CancelScheduleResult = Schema23.Struct({
   schedule: exports_schedule_schema.ScheduleRecord
 }).annotate({ identifier: "Relay.Operation.CancelScheduleResult" });
-var ListSchedulesInput = Schema22.Struct({
-  state: Schema22.optionalKey(exports_schedule_schema.ScheduleState)
+var ListSchedulesInput = Schema23.Struct({
+  state: Schema23.optionalKey(exports_schedule_schema.ScheduleState)
 }).annotate({ identifier: "Relay.Operation.ListSchedulesInput" });
-var ListSchedulesResult = Schema22.Struct({
-  schedules: Schema22.Array(exports_schedule_schema.ScheduleRecord)
+var ListSchedulesResult = Schema23.Struct({
+  schedules: Schema23.Array(exports_schedule_schema.ScheduleRecord)
 }).annotate({ identifier: "Relay.Operation.ListSchedulesResult" });
-var ListExecutionsInput = Schema22.Struct({
-  root_address_id: Schema22.optionalKey(exports_ids_schema.AddressId),
-  status: Schema22.optionalKey(exports_execution_schema.ExecutionStatus),
-  limit: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThan(0))),
-  cursor: Schema22.optionalKey(exports_pagination_schema.ExecutionCursor)
+var ListExecutionsInput = Schema23.Struct({
+  root_address_id: Schema23.optionalKey(exports_ids_schema.AddressId),
+  status: Schema23.optionalKey(exports_execution_schema.ExecutionStatus),
+  limit: Schema23.optionalKey(Schema23.Int.check(Schema23.isGreaterThan(0))),
+  cursor: Schema23.optionalKey(exports_pagination_schema.ExecutionCursor)
 }).annotate({ identifier: "Relay.Operation.ListExecutionsInput" });
-var SubscribeTopicInput = Schema22.Struct({
+var SubscribeTopicInput = Schema23.Struct({
   topic_address_id: exports_ids_schema.AddressId,
   subscriber_execution_id: exports_ids_schema.ExecutionId,
-  metadata: Schema22.optionalKey(exports_shared_schema.Metadata)
+  metadata: Schema23.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.Operation.SubscribeTopicInput" });
-var TopicSubscription = Schema22.Struct({
+var TopicSubscription = Schema23.Struct({
   topic_address_id: exports_ids_schema.AddressId,
   subscriber_execution_id: exports_ids_schema.ExecutionId,
-  metadata: Schema22.optionalKey(exports_shared_schema.Metadata),
+  metadata: Schema23.optionalKey(exports_shared_schema.Metadata),
   created_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.TopicSubscription" });
-var PublishTopicInput = Schema22.Struct({
+var PublishTopicInput = Schema23.Struct({
   topic_address_id: exports_ids_schema.AddressId,
   from: exports_ids_schema.AddressId,
-  content: Schema22.Array(exports_content_schema.Part),
-  metadata: Schema22.optionalKey(exports_shared_schema.Metadata),
-  idempotency_key: Schema22.optionalKey(exports_shared_schema.NonEmptyString)
+  content: Schema23.Array(exports_content_schema.Part),
+  metadata: Schema23.optionalKey(exports_shared_schema.Metadata),
+  idempotency_key: Schema23.optionalKey(exports_shared_schema.NonEmptyString)
 }).annotate({ identifier: "Relay.Operation.PublishTopicInput" });
-var TopicPublishAccepted = Schema22.Struct({
+var TopicPublishAccepted = Schema23.Struct({
   envelope_id: exports_ids_schema.EnvelopeId,
-  subscriber_count: Schema22.Int.check(Schema22.isGreaterThanOrEqualTo(0))
+  subscriber_count: Schema23.Int.check(Schema23.isGreaterThanOrEqualTo(0))
 }).annotate({ identifier: "Relay.Operation.TopicPublishAccepted" });
-var UnsubscribeTopicInput = Schema22.Struct({
+var UnsubscribeTopicInput = Schema23.Struct({
   topic_address_id: exports_ids_schema.AddressId,
   subscriber_execution_id: exports_ids_schema.ExecutionId
 }).annotate({ identifier: "Relay.Operation.UnsubscribeTopicInput" });
-var ListTopicSubscriptionsInput = Schema22.Struct({
-  topic_address_id: Schema22.optionalKey(exports_ids_schema.AddressId),
-  subscriber_execution_id: Schema22.optionalKey(exports_ids_schema.ExecutionId)
+var ListTopicSubscriptionsInput = Schema23.Struct({
+  topic_address_id: Schema23.optionalKey(exports_ids_schema.AddressId),
+  subscriber_execution_id: Schema23.optionalKey(exports_ids_schema.ExecutionId)
 }).annotate({ identifier: "Relay.Operation.ListTopicSubscriptionsInput" });
-var ListInboxMessagesInput = Schema22.Struct({
+var ListInboxMessagesInput = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
-  include_consumed: Schema22.optionalKey(Schema22.Boolean),
-  after_sequence: Schema22.optionalKey(exports_inbox_schema.MessageSequence),
-  limit: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThan(0)))
+  include_consumed: Schema23.optionalKey(Schema23.Boolean),
+  after_sequence: Schema23.optionalKey(exports_inbox_schema.MessageSequence),
+  limit: Schema23.optionalKey(Schema23.Int.check(Schema23.isGreaterThan(0)))
 }).annotate({ identifier: "Relay.Operation.ListInboxMessagesInput" });
-var ConversationKind = Schema22.Literals(["user-agent", "agent-agent"]).annotate({
+var ConversationKind = Schema23.Literals(["user-agent", "agent-agent"]).annotate({
   identifier: "Relay.Operation.ConversationKind"
 });
-var ConversationSummary = Schema22.Struct({
+var ConversationSummary = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   root_address_id: exports_ids_schema.AddressId,
-  session_id: Schema22.optionalKey(exports_ids_schema.SessionId),
+  session_id: Schema23.optionalKey(exports_ids_schema.SessionId),
   status: exports_execution_schema.ExecutionStatus,
   kind: ConversationKind,
-  agent_id: Schema22.optionalKey(exports_ids_schema.AgentId),
+  agent_id: Schema23.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 ExecutionCursor2 = Schema22.Struct({
+var ExecutionCursor2 = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
-  after_cursor: Schema22.optionalKey(exports_shared_schema.NonEmptyString)
+  after_cursor: Schema23.optionalKey(exports_shared_schema.NonEmptyString)
 }).annotate({ identifier: "Relay.Operation.ExecutionCursor" });
 
-class EventLogCursorNotFound extends Schema22.TaggedErrorClass()("EventLogCursorNotFound", { execution_id: exports_ids_schema.ExecutionId, cursor: exports_shared_schema.NonEmptyString }) {
+class EventLogCursorNotFound extends Schema23.TaggedErrorClass()("EventLogCursorNotFound", { execution_id: exports_ids_schema.ExecutionId, cursor: exports_shared_schema.NonEmptyString }) {
 }
-var StreamSessionInput = Schema22.Struct({
+var StreamSessionInput = Schema23.Struct({
   session_id: exports_ids_schema.SessionId,
-  resume: Schema22.optionalKey(Schema22.Array(ExecutionCursor2))
+  resume: Schema23.optionalKey(Schema23.Array(ExecutionCursor2))
 }).annotate({ identifier: "Relay.Operation.StreamSessionInput" });
-var SessionStreamItem = Schema22.Union([
-  Schema22.TaggedStruct("execution_joined", { execution: ConversationSummary }),
-  Schema22.TaggedStruct("execution_event", { event: exports_execution_schema.ExecutionEvent })
+var SessionStreamItem = Schema23.Union([
+  Schema23.TaggedStruct("execution_joined", { execution: ConversationSummary }),
+  Schema23.TaggedStruct("execution_event", { event: exports_execution_schema.ExecutionEvent })
 ]).annotate({ identifier: "Relay.Operation.SessionStreamItem" });
-var WatchExecutionsInput = Schema22.Struct({
-  root_address_id: Schema22.optionalKey(exports_ids_schema.AddressId),
-  session_id: Schema22.optionalKey(exports_ids_schema.SessionId),
-  status: Schema22.optionalKey(exports_execution_schema.ExecutionStatus),
-  limit: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThan(0)))
+var WatchExecutionsInput = Schema23.Struct({
+  root_address_id: Schema23.optionalKey(exports_ids_schema.AddressId),
+  session_id: Schema23.optionalKey(exports_ids_schema.SessionId),
+  status: Schema23.optionalKey(exports_execution_schema.ExecutionStatus),
+  limit: Schema23.optionalKey(Schema23.Int.check(Schema23.isGreaterThan(0)))
 }).annotate({ identifier: "Relay.Operation.WatchExecutionsInput" });
-var ExecutionListChange = Schema22.Union([
-  Schema22.TaggedStruct("snapshot", {
-    records: Schema22.Array(ConversationSummary),
-    next_cursor: Schema22.optionalKey(exports_pagination_schema.ExecutionCursor)
+var ExecutionListChange = Schema23.Union([
+  Schema23.TaggedStruct("snapshot", {
+    records: Schema23.Array(ConversationSummary),
+    next_cursor: Schema23.optionalKey(exports_pagination_schema.ExecutionCursor)
   }),
-  Schema22.TaggedStruct("upsert", { record: ConversationSummary })
+  Schema23.TaggedStruct("upsert", { record: ConversationSummary })
 ]).annotate({ identifier: "Relay.Operation.ExecutionListChange" });
-var ToolCallSummary = Schema22.Struct({
+var ToolCallSummary = Schema23.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 = Schema22.Struct({
+var ChildRunSummary = Schema23.Struct({
   child_execution_id: exports_ids_schema.ChildExecutionId,
   address_id: exports_ids_schema.AddressId,
   status: exports_execution_schema.ExecutionStatus,
@@ -2313,117 +2537,132 @@ var ChildRunSummary = Schema22.Struct({
   created_at: exports_shared_schema.TimestampMillis,
   updated_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.Operation.ChildRunSummary" });
-var ExecutionInspection = Schema22.Struct({
+var ChildRunEdge = Schema23.Struct({
+  parent_execution_id: exports_ids_schema.ExecutionId,
+  child_execution_id: exports_ids_schema.ChildExecutionId,
+  address_id: exports_ids_schema.AddressId,
+  depth: Schema23.Int.check(Schema23.isGreaterThan(0)),
+  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.ChildRunEdge" });
+var ExecutionInspection = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   status: exports_execution_schema.ExecutionStatus,
-  waiting_on: Schema22.Array(WaitView),
-  pending_tool_calls: Schema22.Array(ToolCallSummary),
-  child_runs: Schema22.Array(ChildRunSummary),
-  last_event_cursor: Schema22.optionalKey(exports_shared_schema.NonEmptyString)
+  waiting_on: Schema23.Array(WaitView),
+  waits: Schema23.Array(WaitView),
+  pending_tool_calls: Schema23.Array(ToolCallSummary),
+  tool_attempts: Schema23.Array(ToolAttempt),
+  tool_invocations: Schema23.Array(ToolInvocation),
+  child_runs: Schema23.Array(ChildRunSummary),
+  child_tree: Schema23.Array(ChildRunEdge),
+  fan_outs: Schema23.Array(exports_child_orchestration_schema.FanOutState),
+  last_event_cursor: Schema23.optionalKey(exports_shared_schema.NonEmptyString)
 }).annotate({ identifier: "Relay.Operation.ExecutionInspection" });
-var ListExecutionsResult = Schema22.Struct({
-  records: Schema22.Array(ConversationSummary),
-  next_cursor: Schema22.optionalKey(exports_pagination_schema.ExecutionCursor)
+var ListExecutionsResult = Schema23.Struct({
+  records: Schema23.Array(ConversationSummary),
+  next_cursor: Schema23.optionalKey(exports_pagination_schema.ExecutionCursor)
 }).annotate({ identifier: "Relay.Operation.ListExecutionsResult" });
-var ListSessionsInput = Schema22.Struct({
-  root_address_id: Schema22.optionalKey(exports_ids_schema.AddressId),
-  limit: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThan(0))),
-  cursor: Schema22.optionalKey(exports_pagination_schema.SessionCursor)
+var ListSessionsInput = Schema23.Struct({
+  root_address_id: Schema23.optionalKey(exports_ids_schema.AddressId),
+  limit: Schema23.optionalKey(Schema23.Int.check(Schema23.isGreaterThan(0))),
+  cursor: Schema23.optionalKey(exports_pagination_schema.SessionCursor)
 }).annotate({ identifier: "Relay.Operation.ListSessionsInput" });
-var SessionSummary = Schema22.Struct({
+var SessionSummary = Schema23.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 = Schema22.Struct({
-  records: Schema22.Array(SessionSummary),
-  next_cursor: Schema22.optionalKey(exports_pagination_schema.SessionCursor)
+var ListSessionsResult = Schema23.Struct({
+  records: Schema23.Array(SessionSummary),
+  next_cursor: Schema23.optionalKey(exports_pagination_schema.SessionCursor)
 }).annotate({ identifier: "Relay.Operation.ListSessionsResult" });
-var GetSessionInput = Schema22.Struct({
+var GetSessionInput = Schema23.Struct({
   session_id: exports_ids_schema.SessionId,
-  limit: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThan(0))),
-  cursor: Schema22.optionalKey(exports_pagination_schema.ExecutionCursor)
+  limit: Schema23.optionalKey(Schema23.Int.check(Schema23.isGreaterThan(0))),
+  cursor: Schema23.optionalKey(exports_pagination_schema.ExecutionCursor)
 }).annotate({ identifier: "Relay.Operation.GetSessionInput" });
-var GetSessionResult = Schema22.Struct({
+var GetSessionResult = Schema23.Struct({
   session: SessionSummary,
-  executions: Schema22.Array(ConversationSummary),
-  next_cursor: Schema22.optionalKey(exports_pagination_schema.ExecutionCursor)
+  executions: Schema23.Array(ConversationSummary),
+  next_cursor: Schema23.optionalKey(exports_pagination_schema.ExecutionCursor)
 }).annotate({ identifier: "Relay.Operation.GetSessionResult" });
-var ReplayExecutionInput = Schema22.Struct({
+var ReplayExecutionInput = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
-  after_cursor: Schema22.optionalKey(exports_shared_schema.NonEmptyString),
-  limit: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThan(0)))
+  after_cursor: Schema23.optionalKey(exports_shared_schema.NonEmptyString),
+  limit: Schema23.optionalKey(Schema23.Int.check(Schema23.isGreaterThan(0)))
 }).annotate({ identifier: "Relay.Operation.ReplayExecutionInput" });
-var ReplayExecutionResult = Schema22.Struct({
-  events: Schema22.Array(exports_execution_schema.ExecutionEvent)
+var ReplayExecutionResult = Schema23.Struct({
+  events: Schema23.Array(exports_execution_schema.ExecutionEvent)
 }).annotate({ identifier: "Relay.Operation.ReplayExecutionResult" });
-var ExecutionEventPageDirection = Schema22.Literals(["forward", "backward"]).annotate({
+var ExecutionEventPageDirection = Schema23.Literals(["forward", "backward"]).annotate({
   identifier: "Relay.Operation.ExecutionEventPageDirection"
 });
-var PageExecutionEventsInput = Schema22.Struct({
+var PageExecutionEventsInput = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   direction: ExecutionEventPageDirection,
-  after_cursor: Schema22.optionalKey(exports_shared_schema.NonEmptyString),
-  before_cursor: Schema22.optionalKey(exports_shared_schema.NonEmptyString),
-  limit: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThan(0), Schema22.isLessThanOrEqualTo(1000)))
-}).check(Schema22.makeFilter((input) => {
+  after_cursor: Schema23.optionalKey(exports_shared_schema.NonEmptyString),
+  before_cursor: Schema23.optionalKey(exports_shared_schema.NonEmptyString),
+  limit: Schema23.optionalKey(Schema23.Int.check(Schema23.isGreaterThan(0), Schema23.isLessThanOrEqualTo(1000)))
+}).check(Schema23.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 = Schema22.Struct({
-  events: Schema22.Array(exports_execution_schema.ExecutionEvent),
-  has_more: Schema22.Boolean,
-  oldest_cursor: Schema22.optionalKey(exports_shared_schema.NonEmptyString),
-  newest_cursor: Schema22.optionalKey(exports_shared_schema.NonEmptyString)
+var PageExecutionEventsResult = Schema23.Struct({
+  events: Schema23.Array(exports_execution_schema.ExecutionEvent),
+  has_more: Schema23.Boolean,
+  oldest_cursor: Schema23.optionalKey(exports_shared_schema.NonEmptyString),
+  newest_cursor: Schema23.optionalKey(exports_shared_schema.NonEmptyString)
 }).annotate({ identifier: "Relay.Operation.PageExecutionEventsResult" });
-var RunnerSummary = Schema22.Struct({
-  address: Schema22.String,
-  healthy: Schema22.Boolean,
+var RunnerSummary = Schema23.Struct({
+  address: Schema23.String,
+  healthy: Schema23.Boolean,
   last_heartbeat: exports_shared_schema.TimestampMillis,
-  owned_shards: Schema22.Int
+  owned_shards: Schema23.Int
 }).annotate({ identifier: "Relay.Operation.RunnerSummary" });
-var ListRunnersResult = Schema22.Struct({
-  runners: Schema22.Array(RunnerSummary),
-  total_shards: Schema22.Int
+var ListRunnersResult = Schema23.Struct({
+  runners: Schema23.Array(RunnerSummary),
+  total_shards: Schema23.Int
 }).annotate({ identifier: "Relay.Operation.ListRunnersResult" });
-var RouteExecutionResult = Schema22.Struct({
+var RouteExecutionResult = Schema23.Struct({
   execution_id: exports_ids_schema.ExecutionId,
-  shard: Schema22.String,
-  runner_address: Schema22.NullOr(Schema22.String),
-  owned: Schema22.Boolean
+  shard: Schema23.String,
+  runner_address: Schema23.NullOr(Schema23.String),
+  owned: Schema23.Boolean
 }).annotate({ identifier: "Relay.Operation.RouteExecutionResult" });
 // src/client-public.ts
-import { Context, Effect, Schema as Schema23, Stream } from "effect";
+import { Context, Effect, Schema as Schema24, Stream } from "effect";
 
-class ClientError extends Schema23.TaggedErrorClass()("ClientError", {
-  message: Schema23.String
+class ClientError extends Schema24.TaggedErrorClass()("ClientError", {
+  message: Schema24.String
 }) {
 }
 
-class ExecutionNotFound extends Schema23.TaggedErrorClass()("ExecutionNotFound", {
+class ExecutionNotFound extends Schema24.TaggedErrorClass()("ExecutionNotFound", {
   execution_id: exports_ids_schema.ExecutionId
 }) {
 }
 
-class ResidentNamespaceReserved extends Schema23.TaggedErrorClass()("ResidentNamespaceReserved", { id: Schema23.String, message: Schema23.String }) {
+class ResidentNamespaceReserved extends Schema24.TaggedErrorClass()("ResidentNamespaceReserved", { id: Schema24.String, message: Schema24.String }) {
 }
 
-class WaitKindMismatch extends Schema23.TaggedErrorClass()("WaitKindMismatch", {
+class WaitKindMismatch extends Schema24.TaggedErrorClass()("WaitKindMismatch", {
   wait_id: exports_ids_schema.WaitId,
-  expected: Schema23.String,
-  actual: Schema23.String,
-  message: Schema23.String
+  expected: Schema24.String,
+  actual: Schema24.String,
+  message: Schema24.String
 }) {
 }
 
 class Service extends Context.Service()("@relayfx/sdk/client-public/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 followReconnectDelayMillis = (attempt2) => Math.min(100 * 2 ** (attempt2 - 1), 5000);
 var followStopped = (reason, cursor) => ({
   _tag: "stopped",
   reason,
@@ -2497,10 +2736,10 @@ var followExecutionFrom = (dependencies) => (input) => {
 };
 
 // ../runtime/src/presence/presence-contract.ts
-import { Context as Context2, Schema as Schema24 } from "effect";
+import { Context as Context2, Schema as Schema25 } from "effect";
 
-class PresenceError extends Schema24.TaggedErrorClass()("PresenceError", {
-  message: Schema24.String
+class PresenceError extends Schema25.TaggedErrorClass()("PresenceError", {
+  message: Schema25.String
 }) {
 }