@relayfx/sdk 0.3.1 → 0.3.3

package/dist/index-cphmds30.js

@@ -0,0 +1,2852 @@
+// @bun
+import {
+  __export
+} from "./index-nb39b5ae.js";
+
+// ../schema/dist/index.js
+import { Schema as Schema3 } from "effect";
+import { Schema } from "effect";
+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 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 Schema10 } from "effect";
+import { Schema as Schema12 } 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";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export2 = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var exports_address_schema = {};
+__export2(exports_address_schema, {
+  RouteRegistered: () => RouteRegistered,
+  RouteRecord: () => RouteRecord,
+  RouteList: () => RouteList,
+  RouteKind: () => RouteKind,
+  Route: () => Route,
+  RegisterRoutePayload: () => RegisterRoutePayload
+});
+var exports_ids_schema = {};
+__export2(exports_ids_schema, {
+  WorkspaceSnapshotId: () => WorkspaceSnapshotId,
+  WorkspaceRef: () => WorkspaceRef,
+  WorkspaceLeaseId: () => WorkspaceLeaseId,
+  WorkflowOperationId: () => WorkflowOperationId,
+  WorkflowDefinitionId: () => WorkflowDefinitionId,
+  WaitId: () => WaitId,
+  ToolCallId: () => ToolCallId,
+  ToolAttemptId: () => ToolAttemptId,
+  TenantId: () => TenantId,
+  SystemTenantId: () => SystemTenantId,
+  SnapshotRef: () => SnapshotRef,
+  SkillDefinitionId: () => SkillDefinitionId,
+  SessionId: () => SessionId,
+  SessionEntryId: () => SessionEntryId,
+  ScheduleId: () => ScheduleId,
+  MemorySubjectId: () => MemorySubjectId,
+  ExecutionId: () => ExecutionId,
+  EventId: () => EventId,
+  EnvelopeReadyId: () => EnvelopeReadyId,
+  EnvelopeId: () => EnvelopeId,
+  EntityKindName: () => EntityKindName,
+  EntityKey: () => EntityKey,
+  ChildFanOutId: () => ChildFanOutId,
+  ChildExecutionId: () => ChildExecutionId,
+  AgentId: () => AgentId,
+  AddressId: () => AddressId,
+  AddressBookEntryId: () => AddressBookEntryId
+});
+var id = (name) => {
+  const schema = Schema.String.check(Schema.isMinLength(1)).pipe(Schema.brand(name)).annotate({ identifier: name });
+  return Object.assign(schema, {
+    make: Schema.decodeUnknownSync(schema)
+  });
+};
+var AddressId = id("Relay.AddressId");
+var TenantId = id("Relay.TenantId");
+var SystemTenantId = TenantId.make("system");
+var AddressBookEntryId = id("Relay.AddressBookEntryId");
+var AgentId = id("Relay.AgentId");
+var WorkflowDefinitionId = id("Relay.WorkflowDefinitionId");
+var WorkflowOperationId = id("Relay.WorkflowOperationId");
+var EntityKindName = id("Relay.EntityKindName");
+var EntityKey = id("Relay.EntityKey");
+var SkillDefinitionId = id("Relay.SkillDefinitionId");
+var EnvelopeId = id("Relay.EnvelopeId");
+var EnvelopeReadyId = id("Relay.EnvelopeReadyId");
+var ExecutionId = id("Relay.ExecutionId");
+var ChildExecutionId = id("Relay.ChildExecutionId");
+var ChildFanOutId = id("Relay.ChildFanOutId");
+var MemorySubjectId = id("Relay.MemorySubjectId");
+var SessionId = id("Relay.SessionId");
+var SessionEntryId = id("Relay.SessionEntryId");
+var WorkspaceLeaseId = id("Relay.WorkspaceLeaseId");
+var WorkspaceSnapshotId = id("Relay.WorkspaceSnapshotId");
+var WorkspaceRef = id("Relay.WorkspaceRef");
+var SnapshotRef = id("Relay.SnapshotRef");
+var ToolCallId = id("Relay.ToolCallId");
+var ToolAttemptId = id("Relay.ToolAttemptId");
+var WaitId = id("Relay.WaitId");
+var ScheduleId = id("Relay.ScheduleId");
+var EventId = id("Relay.EventId");
+var exports_shared_schema = {};
+__export2(exports_shared_schema, {
+  canonicalValue: () => canonicalValue,
+  canonicalString: () => canonicalString,
+  canonicalEquals: () => canonicalEquals,
+  TimestampMillis: () => TimestampMillis,
+  ProtocolVersion: () => ProtocolVersion,
+  NonEmptyString: () => NonEmptyString,
+  Metadata: () => Metadata,
+  JsonValue: () => JsonValue
+});
+var ProtocolVersion = Schema2.Literal(1).annotate({ identifier: "Relay.ProtocolVersion" });
+var JsonValue = Schema2.Json.annotate({ identifier: "Relay.JsonValue" });
+var Metadata = Schema2.Record(Schema2.String, JsonValue).annotate({ identifier: "Relay.Metadata" });
+var TimestampMillis = Schema2.Int.annotate({ identifier: "Relay.TimestampMillis" });
+var NonEmptyString = Schema2.String.check(Schema2.isMinLength(1)).annotate({
+  identifier: "Relay.NonEmptyString"
+});
+var canonicalValue = (value) => {
+  if (Array.isArray(value))
+    return value.map(canonicalValue);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined).toSorted(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalValue(item)]));
+  }
+  return value;
+};
+var canonicalString = (value) => JSON.stringify(canonicalValue(value));
+var canonicalEquals = dual(2, (left, right) => Equal.equals(canonicalValue(left), canonicalValue(right)));
+var RouteKind = Schema3.Literals([
+  "local-agent",
+  "local-execution",
+  "remote-relay",
+  "local-adapter",
+  "unavailable",
+  "deferred-retry"
+]).annotate({ identifier: "Relay.Address.RouteKind" });
+var Route = Schema3.Struct({
+  kind: RouteKind,
+  route_key: NonEmptyString,
+  metadata: Schema3.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.Address.Route" });
+var RouteRecord = Schema3.Struct({
+  id: AddressBookEntryId,
+  address_id: AddressId,
+  route: Route,
+  created_at: TimestampMillis,
+  updated_at: TimestampMillis
+}).annotate({ identifier: "Relay.Address.RouteRecord" });
+var RegisterRoutePayload = Schema3.Struct({
+  address_id: AddressId,
+  route: Route
+}).annotate({ identifier: "Relay.Address.RegisterRoutePayload" });
+var RouteRegistered = Schema3.Struct({
+  record: RouteRecord
+}).annotate({ identifier: "Relay.Address.RouteRegistered" });
+var RouteList = Schema3.Struct({
+  records: Schema3.Array(RouteRecord)
+}).annotate({ identifier: "Relay.Address.RouteList" });
+var exports_agent_schema = {};
+__export2(exports_agent_schema, {
+  maxTurnPolicySnapshotNodes: () => maxTurnPolicySnapshotNodes,
+  maxTurnPolicySnapshotDepth: () => maxTurnPolicySnapshotDepth,
+  define: () => define,
+  defaultMaxWaitTurns: () => defaultMaxWaitTurns,
+  defaultMaxToolTurns: () => defaultMaxToolTurns,
+  TurnPolicySnapshot: () => TurnPolicySnapshot,
+  ToolInputSchemaDigests: () => ToolInputSchemaDigests,
+  RegisterDefinitionPayload: () => RegisterDefinitionPayload,
+  PermissionRuleset: () => PermissionRuleset,
+  PermissionRule: () => PermissionRule,
+  PermissionLevel: () => PermissionLevel,
+  ModelSelection: () => ModelSelection,
+  HandoffTarget: () => HandoffTarget,
+  DefinitionRevisionRecord: () => DefinitionRevisionRecord,
+  DefinitionRevisionList: () => DefinitionRevisionList,
+  DefinitionRevision: () => DefinitionRevision,
+  DefinitionRegistered: () => DefinitionRegistered,
+  DefinitionRecord: () => DefinitionRecord,
+  DefinitionList: () => DefinitionList,
+  Definition: () => Definition2,
+  CompactionPolicy: () => CompactionPolicy,
+  ChildRunWorkspacePolicy: () => ChildRunWorkspacePolicy,
+  ChildRunPreset: () => ChildRunPreset
+});
+var exports_tool_schema = {};
+__export2(exports_tool_schema, {
+  resultSchema: () => resultSchema,
+  parametersSchema: () => parametersSchema,
+  WorkerId: () => WorkerId,
+  RuntimeRequirement: () => RuntimeRequirement,
+  Result: () => Result,
+  PlacementKey: () => PlacementKey,
+  Placement: () => Placement,
+  Permission: () => Permission,
+  ExternalOutcome: () => ExternalOutcome,
+  Definition: () => Definition,
+  CallState: () => CallState,
+  Call: () => Call,
+  AttemptState: () => AttemptState
+});
+var Permission = Schema4.Struct({
+  name: NonEmptyString,
+  value: JsonValue,
+  metadata: Schema4.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.Tool.Permission" });
+var RuntimeRequirement = Schema4.Union([
+  Schema4.Struct({
+    type: Schema4.Literal("workspace"),
+    mode: Schema4.Literals(["read", "write", "exec"])
+  })
+]).annotate({ identifier: "Relay.Tool.RuntimeRequirement" });
+var PlacementKey = NonEmptyString.check(Schema4.isMaxLength(191)).annotate({
+  identifier: "Relay.Tool.PlacementKey"
+});
+var WorkerId = NonEmptyString.check(Schema4.isMaxLength(191)).annotate({
+  identifier: "Relay.Tool.WorkerId"
+});
+var Placement = Schema4.Union([
+  Schema4.Struct({ kind: Schema4.Literal("local") }),
+  Schema4.Struct({ kind: Schema4.Literal("client") }),
+  Schema4.Struct({ kind: Schema4.Literal("remote"), queue: PlacementKey }),
+  Schema4.Struct({ kind: Schema4.Literal("mcp"), server_id: PlacementKey })
+]).annotate({ identifier: "Relay.Tool.Placement" });
+var ExternalOutcome = Schema4.Union([
+  Schema4.Struct({ kind: Schema4.Literal("success"), output: JsonValue }),
+  Schema4.Struct({ kind: Schema4.Literal("failure"), message: Schema4.String })
+]).annotate({ identifier: "Relay.Tool.ExternalOutcome" });
+var CallState = Schema4.Literals([
+  "requested",
+  "waiting",
+  "running",
+  "submitted",
+  "completed",
+  "failed"
+]).annotate({ identifier: "Relay.Tool.CallState" });
+var AttemptState = Schema4.Literals([
+  "running",
+  "completed",
+  "failed",
+  "released",
+  "expired",
+  "abandoned"
+]).annotate({ identifier: "Relay.Tool.AttemptState" });
+var Definition = Schema4.Struct({
+  name: NonEmptyString,
+  description: Schema4.String,
+  input_schema: JsonValue,
+  output_schema: JsonValue,
+  permissions: Schema4.Array(Permission),
+  requirements: Schema4.optionalKey(Schema4.Array(RuntimeRequirement)),
+  needs_approval: Schema4.optionalKey(Schema4.Boolean),
+  metadata: Schema4.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.Tool.Definition" });
+var Call = Schema4.Struct({
+  id: ToolCallId,
+  name: NonEmptyString,
+  input: JsonValue,
+  metadata: Schema4.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.Tool.Call" });
+var Result = Schema4.Struct({
+  call_id: ToolCallId,
+  output: JsonValue,
+  error: Schema4.optionalKey(Schema4.String),
+  metadata: Schema4.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.Tool.Result" });
+var objectInferenceKeys = [
+  "properties",
+  "required",
+  "additionalProperties",
+  "patternProperties",
+  "propertyNames",
+  "minProperties",
+  "maxProperties"
+];
+var jsonSchemaTypes = new Set(["null", "string", "number", "integer", "boolean", "object", "array"]);
+var emptyObjectSchema = { type: "object", properties: {} };
+var isJsonObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var hasObjectInferenceKey = (js) => objectInferenceKeys.some((key) => js[key] !== undefined);
+var hasLiteralJsonSchemaType = (type) => typeof type === "string" && jsonSchemaTypes.has(type);
+var isObjectNode = (js) => {
+  const type = js.type;
+  if (type === "object")
+    return true;
+  if (hasLiteralJsonSchemaType(type))
+    return false;
+  return hasObjectInferenceKey(js);
+};
+var closeObjectNodes = (js) => {
+  if (!isJsonObject(js))
+    return js;
+  const node = Object.keys(js).length === 0 ? emptyObjectSchema : js;
+  return isObjectNode(node) && node.additionalProperties === undefined ? { ...node, additionalProperties: false } : node;
+};
+var parametersSchema = (inputSchema) => {
+  try {
+    const schema = SchemaRepresentation.toSchema(SchemaRepresentation.fromJsonSchemaDocument(JsonSchema.fromSchemaDraft2020_12(closeObjectNodes(inputSchema)), {
+      onEnter: closeObjectNodes
+    }));
+    return schema.ast._tag === "Unknown" ? Schema4.Struct({}) : schema;
+  } catch {
+    return Schema4.Unknown;
+  }
+};
+var resultSchema = (outputSchema) => {
+  if (outputSchema === true || isJsonObject(outputSchema) && Object.keys(outputSchema).length === 0) {
+    return Schema4.Unknown;
+  }
+  if (outputSchema === false)
+    return Schema4.Never;
+  try {
+    const schema = SchemaRepresentation.toSchema(SchemaRepresentation.fromJsonSchemaDocument(JsonSchema.fromSchemaDraft2020_12(outputSchema)));
+    return schema.ast._tag === "Unknown" ? Schema4.Never : schema;
+  } catch {
+    return Schema4.Never;
+  }
+};
+var DefinitionRevision = Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(1)).annotate({
+  identifier: "Relay.Agent.DefinitionRevision"
+});
+var ModelSelection = Schema5.Struct({
+  provider: NonEmptyString,
+  model: NonEmptyString,
+  registration_key: Schema5.optionalKey(NonEmptyString),
+  request_options: Schema5.optionalKey(Metadata),
+  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 CompactionPolicy = Schema5.Struct({
+  context_window: PositiveSafeInteger,
+  reserve_tokens: PositiveSafeInteger,
+  keep_recent_tokens: PositiveSafeInteger,
+  summary_model: Schema5.optionalKey(ModelSelection)
+}).check(Schema5.makeFilter((policy) => policy.reserve_tokens + policy.keep_recent_tokens < policy.context_window ? undefined : "reserve_tokens + keep_recent_tokens must be less than context_window")).annotate({ identifier: "Relay.Agent.CompactionPolicy" });
+var ChildRunWorkspacePolicy = Schema5.Struct({
+  mode: Schema5.Literals(["share", "fork"]),
+  fallback: Schema5.optionalKey(Schema5.Literals(["fail", "fresh"]))
+}).annotate({ identifier: "Relay.Agent.ChildRunWorkspacePolicy" });
+var ChildRunPreset = Schema5.Struct({
+  instructions: Schema5.optionalKey(Schema5.String),
+  model: Schema5.optionalKey(ModelSelection),
+  compaction_policy: Schema5.optionalKey(CompactionPolicy),
+  tool_names: Schema5.optionalKey(Schema5.Array(Schema5.String)),
+  permissions: Schema5.optionalKey(Schema5.Array(Schema5.String)),
+  workspace_policy: Schema5.optionalKey(ChildRunWorkspacePolicy),
+  output_schema_ref: Schema5.optionalKey(Schema5.String),
+  metadata: Schema5.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.Agent.ChildRunPreset" });
+var HandoffTarget = Schema5.Struct({
+  name: NonEmptyString,
+  preset_name: NonEmptyString
+}).annotate({ identifier: "Relay.Agent.HandoffTarget" });
+var PermissionLevel = Schema5.Literals(["allow", "deny", "ask"]).annotate({
+  identifier: "Relay.Agent.PermissionLevel"
+});
+var PermissionRule = Schema5.Struct({
+  pattern: NonEmptyString,
+  level: PermissionLevel,
+  reason: Schema5.optionalKey(Schema5.String)
+}).annotate({ identifier: "Relay.Agent.PermissionRule" });
+var PermissionRuleset = Schema5.Struct({
+  rules: Schema5.Array(PermissionRule),
+  fallback: Schema5.optionalKey(PermissionLevel)
+}).annotate({ identifier: "Relay.Agent.PermissionRuleset" });
+var ToolInputSchemaDigests = Schema5.Record(Schema5.String, Schema5.String).annotate({
+  identifier: "Relay.Agent.ToolInputSchemaDigests"
+});
+var ForeverTurnPolicySnapshot = Schema5.Struct({
+  kind: Schema5.Literals(["forever"])
+});
+var RecursTurnPolicySnapshot = Schema5.Struct({
+  kind: Schema5.Literals(["recurs"]),
+  count: Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(0))
+});
+var UntilToolCallTurnPolicySnapshot = Schema5.Struct({
+  kind: Schema5.Literals(["until-tool-call"]),
+  name: NonEmptyString
+});
+var maxTurnPolicySnapshotDepth = 16;
+var maxTurnPolicySnapshotNodes = 64;
+var turnPolicySnapshotNodeCount = Schema5.makeFilter((input) => {
+  let nodes = 0;
+  const pending = [input];
+  while (pending.length > 0) {
+    const snapshot = pending.pop();
+    if (snapshot === undefined)
+      continue;
+    nodes += 1;
+    if (nodes > maxTurnPolicySnapshotNodes) {
+      return `turn policy snapshot node count exceeds ${maxTurnPolicySnapshotNodes}`;
+    }
+    if (snapshot.kind === "both")
+      pending.push(snapshot.second, snapshot.first);
+  }
+  return;
+});
+var turnPolicySnapshotLeaf = Schema5.Union([
+  ForeverTurnPolicySnapshot,
+  RecursTurnPolicySnapshot,
+  UntilToolCallTurnPolicySnapshot
+]);
+var makeTurnPolicySnapshotTree = () => {
+  let tree = turnPolicySnapshotLeaf;
+  for (let depth = 2;depth <= maxTurnPolicySnapshotDepth; depth += 1) {
+    const child = tree;
+    tree = Schema5.Union([
+      ForeverTurnPolicySnapshot,
+      RecursTurnPolicySnapshot,
+      UntilToolCallTurnPolicySnapshot,
+      Schema5.Struct({
+        kind: Schema5.Literals(["both"]),
+        first: child,
+        second: child
+      })
+    ]);
+    if (depth < maxTurnPolicySnapshotDepth) {
+      tree = tree.annotate({ identifier: `Relay.Agent.TurnPolicySnapshot.Depth${depth}` });
+    }
+  }
+  return tree;
+};
+var TurnPolicySnapshot = makeTurnPolicySnapshotTree().check(turnPolicySnapshotNodeCount).annotate({ identifier: "Relay.Agent.TurnPolicySnapshot" });
+var defaultMaxToolTurns = Number.POSITIVE_INFINITY;
+var defaultMaxWaitTurns = Number.POSITIVE_INFINITY;
+var DefinitionSchema = Schema5.Struct({
+  name: NonEmptyString,
+  instructions: Schema5.optionalKey(Schema5.String),
+  model: ModelSelection,
+  tool_names: Schema5.Array(Schema5.String),
+  permissions: Schema5.Array(Permission),
+  skill_definition_ids: Schema5.optionalKey(Schema5.Array(SkillDefinitionId)),
+  permission_rules: Schema5.optionalKey(PermissionRuleset),
+  turn_policy: Schema5.optionalKey(TurnPolicySnapshot),
+  compaction_policy: Schema5.optionalKey(CompactionPolicy),
+  max_tool_turns: Schema5.optionalKey(Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(1))),
+  max_wait_turns: Schema5.optionalKey(Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(0))),
+  token_budget: Schema5.optionalKey(Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(1))),
+  child_run_presets: Schema5.optionalKey(Schema5.Record(Schema5.String, ChildRunPreset)),
+  handoff_targets: Schema5.optionalKey(Schema5.Array(HandoffTarget)),
+  output_schema_ref: Schema5.optionalKey(Schema5.String),
+  metadata: Schema5.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.Agent.Definition" });
+var Definition2 = DefinitionSchema;
+var define = (input) => ({
+  id: input.id,
+  definition: {
+    name: input.name,
+    ...input.instructions === undefined ? {} : { instructions: input.instructions },
+    model: input.model,
+    tool_names: input.tools?.map((tool) => tool.name) ?? [],
+    permissions: input.permissions,
+    ...input.skill_definition_ids === undefined ? {} : { skill_definition_ids: input.skill_definition_ids },
+    ...input.permission_rules === undefined ? {} : { permission_rules: input.permission_rules },
+    ...input.turn_policy === undefined ? {} : { turn_policy: input.turn_policy },
+    ...input.compaction_policy === undefined ? {} : { compaction_policy: input.compaction_policy },
+    ...input.max_tool_turns === undefined ? {} : { max_tool_turns: input.max_tool_turns },
+    ...input.max_wait_turns === undefined ? {} : { max_wait_turns: input.max_wait_turns },
+    ...input.token_budget === undefined ? {} : { token_budget: input.token_budget },
+    ...input.child_run_presets === undefined ? {} : { child_run_presets: input.child_run_presets },
+    ...input.handoff_targets === undefined ? {} : { handoff_targets: input.handoff_targets },
+    ...input.output_schema_ref === undefined ? {} : { output_schema_ref: input.output_schema_ref },
+    ...input.metadata === undefined ? {} : { metadata: input.metadata }
+  }
+});
+var DefinitionRecord = Schema5.Struct({
+  id: AgentId,
+  current_revision: DefinitionRevision,
+  definition: Definition2,
+  tool_input_schema_digests: Schema5.optionalKey(ToolInputSchemaDigests),
+  created_at: TimestampMillis,
+  updated_at: TimestampMillis
+}).annotate({ identifier: "Relay.Agent.DefinitionRecord" });
+var DefinitionRevisionRecord = Schema5.Struct({
+  id: AgentId,
+  revision: DefinitionRevision,
+  definition: Definition2,
+  tool_input_schema_digests: Schema5.optionalKey(ToolInputSchemaDigests),
+  created_at: TimestampMillis
+}).annotate({ identifier: "Relay.Agent.DefinitionRevisionRecord" });
+var RegisterDefinitionPayload = Schema5.Struct({
+  id: AgentId,
+  definition: Definition2
+}).annotate({ identifier: "Relay.Agent.RegisterDefinitionPayload" });
+var DefinitionRegistered = Schema5.Struct({
+  record: DefinitionRecord
+}).annotate({ identifier: "Relay.Agent.DefinitionRegistered" });
+var DefinitionList = Schema5.Struct({
+  records: Schema5.Array(DefinitionRecord)
+}).annotate({ identifier: "Relay.Agent.DefinitionList" });
+var DefinitionRevisionList = Schema5.Struct({
+  records: Schema5.Array(DefinitionRevisionRecord)
+}).annotate({ identifier: "Relay.Agent.DefinitionRevisionList" });
+var exports_child_orchestration_schema = {};
+__export2(exports_child_orchestration_schema, {
+  MemberState: () => MemberState,
+  JoinPolicy: () => JoinPolicy,
+  FanOutState: () => FanOutState,
+  FanOutMember: () => FanOutMember,
+  FanOutDefinition: () => FanOutDefinition,
+  FanOutChild: () => FanOutChild,
+  AggregateState: () => AggregateState
+});
+var exports_execution_schema = {};
+__export2(exports_execution_schema, {
+  childSessionId: () => childSessionId,
+  SpawnChildRunInput: () => SpawnChildRunInput,
+  ExecutionStatus: () => ExecutionStatus,
+  ExecutionEventType: () => ExecutionEventType,
+  ExecutionEventSequence: () => ExecutionEventSequence,
+  ExecutionEvent: () => ExecutionEvent,
+  Execution: () => Execution,
+  CompactionCommittedEventData: () => CompactionCommittedEventData,
+  ChildRunPreset: () => ChildRunPreset2,
+  ChildRunOverride: () => ChildRunOverride,
+  ChildRunContext: () => ChildRunContext,
+  ChildRunAccepted: () => ChildRunAccepted
+});
+var exports_content_schema = {};
+__export2(exports_content_schema, {
+  text: () => text,
+  ToolResultPart: () => ToolResultPart,
+  ToolCallPart: () => ToolCallPart,
+  TextPart: () => TextPart,
+  StructuredPart: () => StructuredPart,
+  Part: () => Part,
+  BlobReferencePart: () => BlobReferencePart,
+  ArtifactReferencePart: () => ArtifactReferencePart
+});
+var TextPart = Schema6.Struct({
+  type: Schema6.Literal("text"),
+  text: Schema6.String,
+  provider_options: Schema6.optionalKey(Metadata),
+  metadata: Schema6.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.Content.TextPart" });
+var StructuredPart = Schema6.Struct({
+  type: Schema6.Literal("structured"),
+  value: JsonValue,
+  schema_ref: Schema6.optionalKey(Schema6.String),
+  provider_options: Schema6.optionalKey(Metadata),
+  metadata: Schema6.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.Content.StructuredPart" });
+var BlobReferencePart = Schema6.Struct({
+  type: Schema6.Literal("blob-reference"),
+  uri: Schema6.String,
+  media_type: Schema6.String,
+  filename: Schema6.optionalKey(Schema6.String),
+  provider_options: Schema6.optionalKey(Metadata),
+  metadata: Schema6.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.Content.BlobReferencePart" });
+var ArtifactReferencePart = Schema6.Struct({
+  type: Schema6.Literal("artifact-reference"),
+  artifact_id: Schema6.String,
+  media_type: Schema6.optionalKey(Schema6.String),
+  provider_options: Schema6.optionalKey(Metadata),
+  metadata: Schema6.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.Content.ArtifactReferencePart" });
+var ToolCallPart = Schema6.Struct({
+  type: Schema6.Literal("tool-call"),
+  call: Call,
+  provider_options: Schema6.optionalKey(Metadata),
+  metadata: Schema6.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.Content.ToolCallPart" });
+var ToolResultPart = Schema6.Struct({
+  type: Schema6.Literal("tool-result"),
+  result: Result,
+  provider_options: Schema6.optionalKey(Metadata),
+  metadata: Schema6.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.Content.ToolResultPart" });
+var Part = Schema6.Union([
+  TextPart,
+  StructuredPart,
+  BlobReferencePart,
+  ArtifactReferencePart,
+  ToolCallPart,
+  ToolResultPart
+]).pipe(Schema6.toTaggedUnion("type")).annotate({ identifier: "Relay.Content.Part" });
+var text = (value) => ({ type: "text", text: value });
+var ExecutionStatus = Schema7.Literals([
+  "queued",
+  "running",
+  "waiting",
+  "completed",
+  "failed",
+  "cancelled"
+]).annotate({ identifier: "Relay.ExecutionStatus" });
+var Execution = Schema7.Struct({
+  id: ExecutionId,
+  root_address_id: AddressId,
+  session_id: Schema7.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),
+  created_at: TimestampMillis,
+  updated_at: TimestampMillis
+}).annotate({ identifier: "Relay.Execution" });
+var ExecutionEventSequence = Schema7.Int.check(Schema7.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)
+}).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)
+}).annotate({ identifier: "Relay.ChildRunOverride" });
+var ChildRunPreset2 = ChildRunOverride.annotate({ identifier: "Relay.ChildRunPreset" });
+var SpawnChildRunInput = Schema7.Struct({
+  execution_id: ExecutionId,
+  child_execution_id: Schema7.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)
+}).annotate({ identifier: "Relay.SpawnChildRunInput" });
+var ChildRunAccepted = Schema7.Struct({
+  child_execution_id: ChildExecutionId,
+  execution_id: ExecutionId
+}).annotate({ identifier: "Relay.ChildRunAccepted" });
+var childSessionId = (childExecutionId) => SessionId.make(`session:child:${childExecutionId}`);
+var ExecutionEventType = Schema7.Literals([
+  "execution.accepted",
+  "execution.started",
+  "execution.completed",
+  "execution.failed",
+  "execution.cancelled",
+  "model.input.prepared",
+  "model.output.delta",
+  "model.reasoning.delta",
+  "model.toolcall.delta",
+  "model.output.completed",
+  "model.usage.reported",
+  "agent.compaction.committed",
+  "budget.exceeded",
+  "tool.call.requested",
+  "tool.result.received",
+  "tool.approval.requested",
+  "tool.approval.resolved",
+  "permission.ask.requested",
+  "permission.ask.resolved",
+  "steering.received",
+  "state.updated",
+  "state.deleted",
+  "inbox.enqueued",
+  "inbox.drained",
+  "entity.created",
+  "entity.destroyed",
+  "envelope.accepted",
+  "envelope.routed",
+  "envelope.ready",
+  "delivery.attempt",
+  "wait.created",
+  "wait.woken",
+  "wait.timed_out",
+  "wait.cancelled",
+  "child_run.spawned",
+  "child_run.event",
+  "child_fan_out.created",
+  "child_fan_out.member.admitted",
+  "child_fan_out.member.terminal",
+  "child_fan_out.terminal",
+  "workspace.lease.planned",
+  "workspace.lease.acquired",
+  "workspace.suspended",
+  "workspace.resumed",
+  "workspace.snapshot.created",
+  "workspace.lease.released",
+  "workspace.lease.failed"
+]).annotate({ identifier: "Relay.ExecutionEventType" });
+var CompactionCommittedEventData = Schema7.Struct({
+  checkpoint_id: SessionEntryId,
+  session_id: SessionId,
+  summary_present: Schema7.Boolean
+}).annotate({ identifier: "Relay.CompactionCommittedEventData" });
+var ExecutionEvent = Schema7.Struct({
+  id: EventId,
+  execution_id: ExecutionId,
+  child_execution_id: Schema7.optionalKey(ChildExecutionId),
+  type: ExecutionEventType,
+  sequence: ExecutionEventSequence,
+  cursor: NonEmptyString,
+  content: Schema7.optionalKey(Schema7.Array(Part)),
+  data: Schema7.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", {})
+]).annotate({ identifier: "Relay.ChildOrchestration.JoinPolicy" });
+var FanOutChild = Schema8.Struct({
+  child_execution_id: ChildExecutionId,
+  address_id: AddressId,
+  override: Schema8.optionalKey(ChildRunOverride),
+  input: Schema8.optionalKey(Schema8.Array(Part)),
+  metadata: Schema8.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.ChildOrchestration.FanOutChild" });
+var FanOutDefinition = Schema8.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)),
+  join: JoinPolicy,
+  created_at: TimestampMillis,
+  metadata: Schema8.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.ChildOrchestration.FanOutDefinition" });
+var MemberState = Schema8.Literals(["queued", "running", "completed", "failed", "cancelled"]).annotate({
+  identifier: "Relay.ChildOrchestration.MemberState"
+});
+var AggregateState = Schema8.Literals(["joining", "satisfied", "failed", "cancelled"]).annotate({
+  identifier: "Relay.ChildOrchestration.AggregateState"
+});
+var FanOutMember = Schema8.Struct({
+  child_execution_id: ChildExecutionId,
+  ordinal: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(0)),
+  state: MemberState,
+  output: Schema8.optionalKey(Schema8.Array(Part)),
+  error: Schema8.optionalKey(Schema8.String),
+  completed_at: Schema8.optionalKey(TimestampMillis)
+}).annotate({ identifier: "Relay.ChildOrchestration.FanOutMember" });
+var FanOutState = Schema8.Struct({
+  ...FanOutDefinition.fields,
+  state: AggregateState,
+  members: Schema8.Array(FanOutMember),
+  satisfied_at: Schema8.optionalKey(TimestampMillis),
+  failed_at: Schema8.optionalKey(TimestampMillis),
+  cancelled_at: Schema8.optionalKey(TimestampMillis)
+}).annotate({ identifier: "Relay.ChildOrchestration.FanOutState" });
+var exports_envelope_schema = {};
+__export2(exports_envelope_schema, {
+  WaitMode: () => WaitMode,
+  Wait: () => Wait,
+  SendInput: () => SendInput,
+  EnvelopeReady: () => EnvelopeReady,
+  EnvelopeAccepted: () => EnvelopeAccepted,
+  Envelope: () => Envelope
+});
+var WaitMode = Schema9.Literals(["reply", "event", "until", "child"]).annotate({ identifier: "Relay.WaitMode" });
+var Wait = Schema9.Struct({
+  mode: WaitMode,
+  timeout: Schema9.optionalKey(Schema9.String),
+  correlation_key: Schema9.optionalKey(Schema9.String),
+  metadata: Schema9.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.Wait" });
+var Envelope = Schema9.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),
+  created_at: TimestampMillis
+}).annotate({ identifier: "Relay.Envelope" });
+var SendInput = Schema9.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)
+}).annotate({ identifier: "Relay.SendInput" });
+var EnvelopeAccepted = Schema9.Struct({
+  envelope_id: EnvelopeId,
+  execution_id: ExecutionId,
+  wait_id: Schema9.optionalKey(WaitId)
+}).annotate({ identifier: "Relay.EnvelopeAccepted" });
+var EnvelopeReady = Schema9.Struct({
+  id: EnvelopeReadyId,
+  envelope_id: EnvelopeId,
+  route_key: Schema9.String,
+  available_at: TimestampMillis,
+  attempt: Schema9.Int,
+  metadata: Schema9.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.EnvelopeReady" });
+var exports_entity_schema = {};
+__export2(exports_entity_schema, {
+  KindDefinition: () => KindDefinition,
+  InstanceStatus: () => InstanceStatus,
+  Instance: () => Instance
+});
+var exports_inbox_schema = {};
+__export2(exports_inbox_schema, {
+  MessageSequence: () => MessageSequence,
+  Message: () => Message,
+  InboxPolicy: () => InboxPolicy
+});
+var MessageSequence = Schema10.Int.check(Schema10.isGreaterThanOrEqualTo(0)).annotate({
+  identifier: "Relay.Inbox.MessageSequence"
+});
+var Message = Schema10.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),
+  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)))
+}).annotate({ identifier: "Relay.Inbox.InboxPolicy" });
+var KindDefinition = Schema11.Struct({
+  kind: EntityKindName,
+  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)
+}).annotate({ identifier: "Relay.Entity.KindDefinition" });
+var InstanceStatus = Schema11.Literals(["active", "destroyed"]).annotate({
+  identifier: "Relay.Entity.InstanceStatus"
+});
+var Instance = Schema11.Struct({
+  kind: EntityKindName,
+  key: EntityKey,
+  address_id: AddressId,
+  execution_id: ExecutionId,
+  generation: Schema11.Int.check(Schema11.isGreaterThanOrEqualTo(0)),
+  status: InstanceStatus,
+  created_at: TimestampMillis,
+  destroyed_at: Schema11.optionalKey(TimestampMillis)
+}).annotate({ identifier: "Relay.Entity.Instance" });
+var exports_pagination_schema = {};
+__export2(exports_pagination_schema, {
+  SessionCursorCodec: () => SessionCursorCodec,
+  SessionCursor: () => SessionCursor,
+  ExecutionCursorCodec: () => ExecutionCursorCodec,
+  ExecutionCursor: () => ExecutionCursor
+});
+var codec = (id2, identifier) => Schema12.StringFromBase64Url.pipe(Schema12.decodeTo(Schema12.fromJsonString(Schema12.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 ExecutionCursorCodec = codec(ExecutionId, "Relay.Pagination.ExecutionCursorCodec");
+var ExecutionCursor = opaque(ExecutionCursorCodec, "Relay.Pagination.ExecutionCursor");
+var SessionCursorCodec = codec(SessionId, "Relay.Pagination.SessionCursorCodec");
+var SessionCursor = opaque(SessionCursorCodec, "Relay.Pagination.SessionCursor");
+var exports_presence_schema = {};
+__export2(exports_presence_schema, {
+  View: () => View,
+  Scope: () => Scope,
+  Entry: () => Entry
+});
+var Scope = Schema13.Struct({
+  kind: Schema13.Literals(["execution", "session"]),
+  id: NonEmptyString
+}).annotate({ identifier: "Relay.Presence.Scope" });
+var Entry = Schema13.Struct({
+  id: NonEmptyString,
+  metadata: Metadata,
+  connected_at: TimestampMillis
+}).annotate({ identifier: "Relay.Presence.Entry" });
+var View = Schema13.Struct({
+  scope: Scope,
+  entries: Schema13.Array(Entry),
+  observed_at: TimestampMillis
+}).annotate({ identifier: "Relay.Presence.View" });
+var exports_schedule_schema = {};
+__export2(exports_schedule_schema, {
+  ScheduleTargetKind: () => ScheduleTargetKind,
+  ScheduleState: () => ScheduleState,
+  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({
+  identifier: "Relay.ScheduleTargetKind"
+});
+var ScheduleState = Schema14.Literals(["active", "claimed", "completed", "cancelled", "failed"]).annotate({
+  identifier: "Relay.ScheduleState"
+});
+var ScheduleRecord = Schema14.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)),
+  state: ScheduleState,
+  next_run_at: TimestampMillis,
+  attempt: Schema14.Int,
+  last_error: Schema14.optionalKey(Schema14.String),
+  metadata: Schema14.optionalKey(Metadata),
+  created_at: TimestampMillis,
+  updated_at: TimestampMillis
+}).annotate({ identifier: "Relay.ScheduleRecord" });
+var exports_skill_schema = {};
+__export2(exports_skill_schema, {
+  RegisterDefinitionPayload: () => RegisterDefinitionPayload2,
+  Frontmatter: () => Frontmatter,
+  ExecutionPinRecord: () => ExecutionPinRecord,
+  ExecutionPinList: () => ExecutionPinList,
+  DefinitionRevisionRecord: () => DefinitionRevisionRecord2,
+  DefinitionRevisionList: () => DefinitionRevisionList2,
+  DefinitionRevision: () => DefinitionRevision2,
+  DefinitionRegistered: () => DefinitionRegistered2,
+  DefinitionRecord: () => DefinitionRecord2,
+  DefinitionList: () => DefinitionList2,
+  Definition: () => Definition3
+});
+var DefinitionRevision2 = Schema15.Int.check(Schema15.isGreaterThanOrEqualTo(1)).annotate({
+  identifier: "Relay.Skill.DefinitionRevision"
+});
+var Frontmatter = Schema15.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)
+}).annotate({ identifier: "Relay.Skill.Frontmatter" });
+var Definition3 = Schema15.Struct({
+  frontmatter: Frontmatter,
+  body: Schema15.String,
+  metadata: Schema15.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.Skill.Definition" });
+var DefinitionRecord2 = Schema15.Struct({
+  id: SkillDefinitionId,
+  current_revision: DefinitionRevision2,
+  definition: Definition3,
+  created_at: TimestampMillis,
+  updated_at: TimestampMillis
+}).annotate({ identifier: "Relay.Skill.DefinitionRecord" });
+var DefinitionRevisionRecord2 = Schema15.Struct({
+  id: SkillDefinitionId,
+  revision: DefinitionRevision2,
+  definition: Definition3,
+  created_at: TimestampMillis
+}).annotate({ identifier: "Relay.Skill.DefinitionRevisionRecord" });
+var ExecutionPinRecord = Schema15.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({
+  id: SkillDefinitionId,
+  definition: Definition3
+}).annotate({ identifier: "Relay.Skill.RegisterDefinitionPayload" });
+var DefinitionRegistered2 = Schema15.Struct({
+  record: DefinitionRecord2
+}).annotate({ identifier: "Relay.Skill.DefinitionRegistered" });
+var DefinitionList2 = Schema15.Struct({
+  records: Schema15.Array(DefinitionRecord2)
+}).annotate({ identifier: "Relay.Skill.DefinitionList" });
+var DefinitionRevisionList2 = Schema15.Struct({
+  records: Schema15.Array(DefinitionRevisionRecord2)
+}).annotate({ identifier: "Relay.Skill.DefinitionRevisionList" });
+var ExecutionPinList = Schema15.Struct({
+  records: Schema15.Array(ExecutionPinRecord)
+}).annotate({ identifier: "Relay.Skill.ExecutionPinList" });
+var exports_state_schema = {};
+__export2(exports_state_schema, {
+  StateVersion: () => StateVersion,
+  StateUpdatedEventData: () => StateUpdatedEventData,
+  StateRecordView: () => StateRecordView,
+  StateKey: () => StateKey,
+  StateIdempotencyKey: () => StateIdempotencyKey,
+  StateDeletedEventData: () => StateDeletedEventData
+});
+var StateKey = NonEmptyString.check(Schema16.isMaxLength(191)).annotate({
+  identifier: "Relay.State.StateKey"
+});
+var StateIdempotencyKey = NonEmptyString.check(Schema16.isMaxLength(191)).annotate({
+  identifier: "Relay.State.StateIdempotencyKey"
+});
+var StateVersion = Schema16.Int.check(Schema16.isGreaterThanOrEqualTo(1)).annotate({
+  identifier: "Relay.State.StateVersion"
+});
+var StateRecordView = Schema16.Struct({
+  execution_id: ExecutionId,
+  key: StateKey,
+  value: JsonValue,
+  version: StateVersion,
+  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 })
+]).annotate({ identifier: "Relay.State.StateUpdatedEventData" });
+var StateDeletedEventData = Schema16.Struct({
+  key: StateKey,
+  version: StateVersion
+}).annotate({ identifier: "Relay.State.StateDeletedEventData" });
+var exports_wait_schema = {};
+__export2(exports_wait_schema, {
+  resolverFor: () => resolverFor,
+  externallyResolvable: () => externallyResolvable,
+  classify: () => classify,
+  WaitKind: () => WaitKind,
+  ToolPlacementWait: () => ToolPlacementWait,
+  ToolApprovalWait: () => ToolApprovalWait,
+  TimerWait: () => TimerWait,
+  Resolver: () => Resolver,
+  ReplyWait: () => ReplyWait,
+  PermissionWait: () => PermissionWait,
+  InboxWait: () => InboxWait,
+  ExternalWait: () => ExternalWait,
+  Classification: () => Classification,
+  ChildJoinWait: () => ChildJoinWait
+});
+var WaitKind = Schema17.Literals([
+  "permission",
+  "tool_approval",
+  "tool_placement",
+  "child_join",
+  "inbox",
+  "reply",
+  "timer",
+  "external"
+]).annotate({ identifier: "Relay.WaitKind" });
+var PermissionWait = Schema17.Struct({
+  kind: Schema17.Literal("permission"),
+  wait_id: WaitId,
+  tool_call_id: ToolCallId
+}).annotate({ identifier: "Relay.PermissionWait" });
+var ToolApprovalWait = Schema17.Struct({
+  kind: Schema17.Literal("tool_approval"),
+  wait_id: WaitId,
+  tool_call_id: ToolCallId
+}).annotate({ identifier: "Relay.ToolApprovalWait" });
+var ToolPlacementWait = Schema17.Struct({
+  kind: Schema17.Literal("tool_placement"),
+  wait_id: WaitId,
+  tool_call_id: ToolCallId
+}).annotate({ identifier: "Relay.ToolPlacementWait" });
+var ChildJoinWait = Schema17.Struct({
+  kind: Schema17.Literal("child_join"),
+  wait_id: WaitId,
+  child_execution_id: ChildExecutionId
+}).annotate({ identifier: "Relay.ChildJoinWait" });
+var InboxWait = Schema17.Struct({
+  kind: Schema17.Literal("inbox"),
+  wait_id: WaitId,
+  tool_call_id: ToolCallId
+}).annotate({ identifier: "Relay.InboxWait" });
+var ReplyWait = Schema17.Struct({
+  kind: Schema17.Literal("reply"),
+  wait_id: WaitId,
+  envelope_id: Schema17.optionalKey(EnvelopeId)
+}).annotate({ identifier: "Relay.ReplyWait" });
+var TimerWait = Schema17.Struct({
+  kind: Schema17.Literal("timer"),
+  wait_id: WaitId
+}).annotate({ identifier: "Relay.TimerWait" });
+var ExternalWait = Schema17.Struct({
+  kind: Schema17.Literal("external"),
+  wait_id: WaitId,
+  mode: WaitMode
+}).annotate({ identifier: "Relay.ExternalWait" });
+var Classification = Schema17.Union([
+  PermissionWait,
+  ToolApprovalWait,
+  ToolPlacementWait,
+  ChildJoinWait,
+  InboxWait,
+  ReplyWait,
+  TimerWait,
+  ExternalWait
+]).annotate({ identifier: "Relay.WaitClassification" });
+var suffixAfter = (waitId, namespace) => waitId.slice(namespace.length);
+var classify = (input) => {
+  const waitId = input.wait_id;
+  if (waitId.startsWith("wait:permission:")) {
+    return {
+      kind: "permission",
+      wait_id: waitId,
+      tool_call_id: ToolCallId.make(suffixAfter(waitId, "wait:permission:"))
+    };
+  }
+  if (waitId.startsWith("wait:approval:")) {
+    return {
+      kind: "tool_approval",
+      wait_id: waitId,
+      tool_call_id: ToolCallId.make(suffixAfter(waitId, "wait:approval:"))
+    };
+  }
+  if (waitId.startsWith("wait:child:")) {
+    return {
+      kind: "child_join",
+      wait_id: waitId,
+      child_execution_id: ChildExecutionId.make(suffixAfter(waitId, "wait:child:"))
+    };
+  }
+  if (waitId.startsWith("wait:inbox:")) {
+    return {
+      kind: "inbox",
+      wait_id: waitId,
+      tool_call_id: ToolCallId.make(suffixAfter(waitId, "wait:inbox:"))
+    };
+  }
+  if (waitId.startsWith("wait:tool:")) {
+    return {
+      kind: "tool_placement",
+      wait_id: waitId,
+      tool_call_id: ToolCallId.make(suffixAfter(waitId, "wait:tool:"))
+    };
+  }
+  if (waitId.startsWith("wait:reply:") || input.envelope_id !== undefined && input.mode === "reply") {
+    return {
+      kind: "reply",
+      wait_id: waitId,
+      ...input.envelope_id === undefined ? {} : { envelope_id: input.envelope_id }
+    };
+  }
+  if (input.mode === "until")
+    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({
+  identifier: "Relay.WaitResolver"
+});
+var resolverFor = (classification) => {
+  switch (classification.kind) {
+    case "permission":
+      return "resolve_permission";
+    case "tool_approval":
+      return "resolve_tool_approval";
+    case "reply":
+    case "timer":
+    case "external":
+      return "wake";
+    case "tool_placement":
+    case "child_join":
+    case "inbox":
+      return;
+  }
+};
+var externallyResolvable = (classification) => resolverFor(classification) !== undefined;
+var exports_workflow_schema = {};
+__export2(exports_workflow_schema, {
+  digestDefinition: () => digestDefinition,
+  canonicalDefinition: () => canonicalDefinition,
+  ToolOperation: () => ToolOperation,
+  TimerOperation: () => TimerOperation,
+  StructuredCompletionOperation: () => StructuredCompletionOperation,
+  StartRunPayload: () => StartRunPayload,
+  SequenceOperation: () => SequenceOperation,
+  RunStatus: () => RunStatus,
+  RunRecord: () => RunRecord,
+  RunPin: () => RunPin,
+  RetryOperation: () => RetryOperation,
+  RegisterDefinitionPayload: () => RegisterDefinitionPayload3,
+  ParallelOperationV2: () => ParallelOperationV2,
+  ParallelOperation: () => ParallelOperation,
+  OperationV2: () => OperationV2,
+  OperationStatus: () => OperationStatus,
+  OperationState: () => OperationState,
+  Operation: () => Operation,
+  LifecycleEventType: () => LifecycleEventType,
+  LifecycleEvent: () => LifecycleEvent,
+  JoinOperationV2: () => JoinOperationV2,
+  JoinOperation: () => JoinOperation,
+  DispatchableChildOperation: () => DispatchableChildOperation,
+  DefinitionV2: () => DefinitionV2,
+  DefinitionV1: () => DefinitionV1,
+  DefinitionRevisionRecord: () => DefinitionRevisionRecord3,
+  DefinitionRevisionList: () => DefinitionRevisionList3,
+  DefinitionRevision: () => DefinitionRevision3,
+  DefinitionRegistered: () => DefinitionRegistered3,
+  DefinitionDigest: () => DefinitionDigest,
+  Definition: () => Definition4,
+  CompensationOperation: () => CompensationOperation,
+  ChildOperation: () => ChildOperation,
+  CancellationOperation: () => CancellationOperation,
+  BudgetOperation: () => BudgetOperation,
+  BranchOperation: () => BranchOperation,
+  ApprovalOperation: () => ApprovalOperation
+});
+var DefinitionRevision3 = Schema18.Int.check(Schema18.isGreaterThanOrEqualTo(1)).annotate({
+  identifier: "Relay.WorkflowDefinitionRevision"
+});
+var DefinitionDigest = Schema18.String.check(Schema18.isPattern(/^sha256:[0-9a-f]{64}$/)).annotate({
+  identifier: "Relay.WorkflowDefinitionDigest"
+});
+var OperationRef = WorkflowOperationId;
+var base = { id: WorkflowOperationId };
+var SequenceOperation = Schema18.Struct({
+  ...base,
+  kind: Schema18.Literal("sequence"),
+  operations: Schema18.Array(OperationRef)
+});
+var ChildOperation = Schema18.Struct({
+  ...base,
+  kind: Schema18.Literal("child"),
+  workflow_id: WorkflowDefinitionId,
+  input: Schema18.optionalKey(JsonValue)
+});
+var DispatchableChildOperation = Schema18.Struct({
+  ...base,
+  kind: Schema18.Literal("child"),
+  address_id: AddressId,
+  preset_name: Schema18.optionalKey(NonEmptyString),
+  input: Schema18.optionalKey(JsonValue)
+});
+var ToolOperation = Schema18.Struct({
+  ...base,
+  kind: Schema18.Literal("tool"),
+  tool_name: NonEmptyString,
+  input: Schema18.optionalKey(JsonValue)
+});
+var ApprovalOperation = Schema18.Struct({ ...base, kind: Schema18.Literal("approval"), prompt: NonEmptyString });
+var TimerOperation = Schema18.Struct({
+  ...base,
+  kind: Schema18.Literal("timer"),
+  duration_ms: Schema18.Int.check(Schema18.isGreaterThanOrEqualTo(0))
+});
+var BranchOperation = Schema18.Struct({
+  ...base,
+  kind: Schema18.Literal("branch"),
+  condition: NonEmptyString,
+  when_true: OperationRef,
+  when_false: OperationRef
+});
+var ParallelOperation = Schema18.Struct({
+  ...base,
+  kind: Schema18.Literal("parallel"),
+  operations: Schema18.Array(OperationRef)
+});
+var JoinOperation = Schema18.Struct({
+  ...base,
+  kind: Schema18.Literal("join"),
+  operations: Schema18.Array(OperationRef)
+});
+var ParallelOperationV2 = Schema18.Struct({
+  ...base,
+  kind: Schema18.Literal("parallel"),
+  fan_out_key: NonEmptyString,
+  operations: Schema18.Array(OperationRef).check(Schema18.isMinLength(1)),
+  max_concurrency: Schema18.Int.check(Schema18.isGreaterThan(0))
+});
+var JoinOperationV2 = Schema18.Struct({
+  ...base,
+  kind: Schema18.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", {})
+  ])
+});
+var RetryOperation = Schema18.Struct({
+  ...base,
+  kind: Schema18.Literal("retry"),
+  operation: OperationRef,
+  max_attempts: Schema18.Int.check(Schema18.isGreaterThanOrEqualTo(1))
+});
+var BudgetOperation = Schema18.Struct({
+  ...base,
+  kind: Schema18.Literal("budget"),
+  operation: OperationRef,
+  limit: Schema18.Int.check(Schema18.isGreaterThanOrEqualTo(1)),
+  unit: Schema18.Literals(["tokens", "milliseconds", "operations"])
+});
+var CancellationOperation = Schema18.Struct({
+  ...base,
+  kind: Schema18.Literal("cancellation"),
+  operation: OperationRef,
+  on_cancel: Schema18.optionalKey(OperationRef)
+});
+var CompensationOperation = Schema18.Struct({
+  ...base,
+  kind: Schema18.Literal("compensation"),
+  operation: OperationRef,
+  compensate_with: OperationRef
+});
+var StructuredCompletionOperation = Schema18.Struct({
+  ...base,
+  kind: Schema18.Literal("structured-completion"),
+  schema_ref: NonEmptyString,
+  value_from: OperationRef
+});
+var Operation = Schema18.Union([
+  SequenceOperation,
+  ChildOperation,
+  ToolOperation,
+  ApprovalOperation,
+  TimerOperation,
+  BranchOperation,
+  ParallelOperation,
+  JoinOperation,
+  RetryOperation,
+  BudgetOperation,
+  CancellationOperation,
+  CompensationOperation,
+  StructuredCompletionOperation
+]).annotate({ identifier: "Relay.WorkflowOperation" });
+var OperationV2 = Schema18.Union([
+  SequenceOperation,
+  DispatchableChildOperation,
+  ToolOperation,
+  ApprovalOperation,
+  TimerOperation,
+  BranchOperation,
+  ParallelOperationV2,
+  JoinOperationV2,
+  RetryOperation,
+  BudgetOperation,
+  CancellationOperation,
+  CompensationOperation,
+  StructuredCompletionOperation
+]).annotate({ identifier: "Relay.WorkflowOperationV2" });
+var references = (operation) => {
+  switch (operation.kind) {
+    case "sequence":
+    case "parallel":
+    case "join":
+      return operation.operations;
+    case "branch":
+      return [operation.when_true, operation.when_false];
+    case "retry":
+    case "budget":
+      return [operation.operation];
+    case "cancellation":
+      return operation.on_cancel === undefined ? [operation.operation] : [operation.operation, operation.on_cancel];
+    case "compensation":
+      return [operation.operation, operation.compensate_with];
+    case "structured-completion":
+      return [operation.value_from];
+    case "child":
+    case "tool":
+    case "approval":
+    case "timer":
+      return [];
+  }
+};
+var validGraph = Schema18.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";
+  if (!ids.has(definition.entry_operation_id))
+    return "entry_operation_id must reference an operation";
+  for (const operation of definition.operations) {
+    if (references(operation).some((reference) => !ids.has(reference)))
+      return `operation ${operation.id} contains an unknown reference`;
+  }
+  return;
+});
+var referencesV2 = (operation) => {
+  if (operation.kind === "join")
+    return [operation.parallel_operation, ...operation.members];
+  return references(operation);
+};
+var validGraphV2 = Schema18.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";
+  if (!operations.has(definition.entry_operation_id))
+    return "entry_operation_id must reference an operation";
+  const fanOutKeys = new Set;
+  for (const operation of definition.operations) {
+    if (referencesV2(operation).some((reference) => !operations.has(reference)))
+      return `operation ${operation.id} contains an unknown reference`;
+    if (operation.kind === "parallel") {
+      if (fanOutKeys.has(operation.fan_out_key))
+        return "parallel fan_out_key values must be unique";
+      fanOutKeys.add(operation.fan_out_key);
+      if (operation.operations.some((reference) => operations.get(reference)?.kind !== "child"))
+        return `parallel operation ${operation.id} may reference only child operations`;
+    }
+    if (operation.kind === "join") {
+      const parallel = operations.get(operation.parallel_operation);
+      if (parallel?.kind !== "parallel")
+        return `join operation ${operation.id} must reference a parallel operation`;
+      if (operation.members.length !== new Set(operation.members).size || operation.members.some((member) => !parallel.operations.includes(member)))
+        return `join operation ${operation.id} contains invalid member references`;
+      if (operation.policy._tag === "quorum" && operation.policy.count > operation.members.length)
+        return `join operation ${operation.id} quorum exceeds its member count`;
+    }
+  }
+  return;
+});
+var DefinitionV1 = Schema18.Struct({
+  version: Schema18.Literal(1),
+  name: NonEmptyString,
+  entry_operation_id: WorkflowOperationId,
+  operations: Schema18.Array(Operation).check(Schema18.isMinLength(1)),
+  metadata: Schema18.optionalKey(Metadata)
+}).check(validGraph).annotate({ identifier: "Relay.WorkflowDefinitionV1" });
+var DefinitionV2 = Schema18.Struct({
+  version: Schema18.Literal(2),
+  name: NonEmptyString,
+  entry_operation_id: WorkflowOperationId,
+  operations: Schema18.Array(OperationV2).check(Schema18.isMinLength(1)),
+  metadata: Schema18.optionalKey(Metadata)
+}).check(validGraphV2).annotate({ identifier: "Relay.WorkflowDefinitionV2" });
+var Definition4 = Schema18.Union([DefinitionV1, DefinitionV2]).annotate({
+  identifier: "Relay.WorkflowDefinition"
+});
+var canonicalDefinition = (definition) => canonicalString(definition);
+var sha256Constants = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+var rotateRight = (value, count) => value >>> count | value << 32 - count;
+var sha256 = (value) => {
+  const encoded = Encoding.encodeHex(value);
+  const bytes = Array.from({ length: encoded.length / 2 }, (_, index) => Number.parseInt(encoded.slice(index * 2, index * 2 + 2), 16));
+  const bitLength = bytes.length * 8;
+  bytes.push(128);
+  while (bytes.length % 64 !== 56)
+    bytes.push(0);
+  for (let shift = 56;shift >= 0; shift -= 8)
+    bytes.push(Math.floor(bitLength / 2 ** shift) & 255);
+  const hash = [1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225];
+  const words = Array.from({ length: 64 }).fill(0);
+  for (let offset = 0;offset < bytes.length; offset += 64) {
+    for (let index = 0;index < 16; index++) {
+      const position = offset + index * 4;
+      words[index] = (bytes[position] ?? 0) << 24 | (bytes[position + 1] ?? 0) << 16 | (bytes[position + 2] ?? 0) << 8 | (bytes[position + 3] ?? 0);
+    }
+    for (let index = 16;index < 64; index++) {
+      const previous15 = words[index - 15] ?? 0;
+      const previous2 = words[index - 2] ?? 0;
+      const sigma0 = rotateRight(previous15, 7) ^ rotateRight(previous15, 18) ^ previous15 >>> 3;
+      const sigma1 = rotateRight(previous2, 17) ^ rotateRight(previous2, 19) ^ previous2 >>> 10;
+      words[index] = (words[index - 16] ?? 0) + sigma0 + (words[index - 7] ?? 0) + sigma1 | 0;
+    }
+    let [a, b, c, d, e, f, g, h] = hash;
+    for (let index = 0;index < 64; index++) {
+      const sum1 = rotateRight(e ?? 0, 6) ^ rotateRight(e ?? 0, 11) ^ rotateRight(e ?? 0, 25);
+      const choice = (e ?? 0) & (f ?? 0) ^ ~(e ?? 0) & (g ?? 0);
+      const temporary1 = (h ?? 0) + sum1 + choice + sha256Constants[index] + (words[index] ?? 0) | 0;
+      const sum0 = rotateRight(a ?? 0, 2) ^ rotateRight(a ?? 0, 13) ^ rotateRight(a ?? 0, 22);
+      const majority = (a ?? 0) & (b ?? 0) ^ (a ?? 0) & (c ?? 0) ^ (b ?? 0) & (c ?? 0);
+      const temporary2 = sum0 + majority | 0;
+      [a, b, c, d, e, f, g, h] = [temporary1 + temporary2, a, b, c, (d ?? 0) + temporary1, e, f, g];
+    }
+    [a, b, c, d, e, f, g, h].forEach((part, index) => {
+      hash[index] = (hash[index] ?? 0) + (part ?? 0) | 0;
+    });
+  }
+  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({
+  id: WorkflowDefinitionId,
+  revision: DefinitionRevision3,
+  digest: DefinitionDigest,
+  definition: Definition4,
+  created_at: TimestampMillis
+}).annotate({ identifier: "Relay.WorkflowDefinitionRevisionRecord" });
+var RunPin = Schema18.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({
+  execution_id: ExecutionId,
+  pin: RunPin,
+  status: RunStatus,
+  created_at: TimestampMillis,
+  updated_at: TimestampMillis
+});
+var StartRunPayload = Schema18.Struct({
+  execution_id: ExecutionId,
+  workflow_definition_id: WorkflowDefinitionId,
+  revision: Schema18.optionalKey(DefinitionRevision3)
+});
+var OperationStatus = Schema18.Literals([
+  "pending",
+  "started",
+  "waiting",
+  "completed",
+  "failed",
+  "compensating",
+  "compensated"
+]);
+var OperationState = Schema18.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),
+  updated_at: TimestampMillis
+});
+var LifecycleEventType = Schema18.Literals([
+  "workflow.started",
+  "operation.started",
+  "operation.waiting",
+  "operation.completed",
+  "operation.failed",
+  "operation.retry_scheduled",
+  "operation.budget_exhausted",
+  "operation.cancelled",
+  "compensation.recorded",
+  "compensation.started",
+  "compensation.completed",
+  "workflow.cancelled",
+  "workflow.completed",
+  "workflow.failed"
+]);
+var LifecycleEvent = Schema18.Struct({
+  execution_id: ExecutionId,
+  sequence: Schema18.Int.check(Schema18.isGreaterThanOrEqualTo(1)),
+  type: LifecycleEventType,
+  operation_id: Schema18.optionalKey(WorkflowOperationId),
+  data: Schema18.optionalKey(JsonValue),
+  created_at: TimestampMillis
+});
+var exports_workspace_schema = {};
+__export2(exports_workspace_schema, {
+  WorkspaceSnapshotRecord: () => WorkspaceSnapshotRecord,
+  WorkspaceSnapshotReason: () => WorkspaceSnapshotReason,
+  WorkspaceResumeStrategy: () => WorkspaceResumeStrategy,
+  WorkspaceRequest: () => WorkspaceRequest,
+  WorkspaceProviderKey: () => WorkspaceProviderKey,
+  WorkspaceLeaseStatus: () => WorkspaceLeaseStatus,
+  WorkspaceLeaseRecord: () => WorkspaceLeaseRecord,
+  WorkspaceCapabilities: () => WorkspaceCapabilities
+});
+var WorkspaceProviderKey = NonEmptyString.annotate({ identifier: "Relay.WorkspaceProviderKey" });
+var WorkspaceLeaseStatus = Schema19.Literals([
+  "planned",
+  "running",
+  "suspended",
+  "snapshotted",
+  "archived",
+  "released",
+  "failed"
+]).annotate({ identifier: "Relay.WorkspaceLeaseStatus" });
+var WorkspaceResumeStrategy = Schema19.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
+}).annotate({ identifier: "Relay.WorkspaceCapabilities" });
+var WorkspaceRequest = Schema19.Struct({
+  provider_key: Schema19.optionalKey(WorkspaceProviderKey),
+  resume_snapshot_ref: Schema19.optionalKey(SnapshotRef),
+  metadata: Schema19.optionalKey(Metadata)
+}).annotate({ identifier: "Relay.WorkspaceRequest" });
+var WorkspaceLeaseRecord = Schema19.Struct({
+  id: WorkspaceLeaseId,
+  execution_id: ExecutionId,
+  provider_key: WorkspaceProviderKey,
+  sandbox_ref: Schema19.optionalKey(WorkspaceRef),
+  latest_snapshot_ref: Schema19.optionalKey(SnapshotRef),
+  status: WorkspaceLeaseStatus,
+  resume_strategy: WorkspaceResumeStrategy,
+  region: Schema19.optionalKey(NonEmptyString),
+  request: Schema19.optionalKey(WorkspaceRequest),
+  metadata: Schema19.optionalKey(Metadata),
+  created_at: TimestampMillis,
+  updated_at: TimestampMillis
+}).annotate({ identifier: "Relay.WorkspaceLeaseRecord" });
+var WorkspaceSnapshotReason = Schema19.Literals([
+  "before_wait",
+  "before_child_fork",
+  "on_complete",
+  "on_failure",
+  "manual"
+]).annotate({ identifier: "Relay.WorkspaceSnapshotReason" });
+var WorkspaceSnapshotRecord = Schema19.Struct({
+  id: WorkspaceSnapshotId,
+  lease_id: WorkspaceLeaseId,
+  execution_id: ExecutionId,
+  reason: WorkspaceSnapshotReason,
+  snapshot_ref: SnapshotRef,
+  metadata: Schema19.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));
+
+class StateVersionConflict extends Schema20.TaggedErrorClass()("StateVersionConflict", {
+  execution_id: exports_ids_schema.ExecutionId,
+  key: exports_state_schema.StateKey,
+  expected_version: NonNegativeStateVersion,
+  actual_version: NonNegativeStateVersion
+}) {
+}
+
+// src/operation.ts
+var exports_operation = {};
+__export(exports_operation, {
+  WatchExecutionsInput: () => WatchExecutionsInput,
+  WakeInput: () => WakeInput,
+  WakeAccepted: () => WakeAccepted,
+  WaitView: () => WaitView,
+  WaitTerminalState: () => WaitTerminalState,
+  WaitState: () => WaitState,
+  WaitOutcome: () => WaitOutcome,
+  UnsubscribeTopicInput: () => UnsubscribeTopicInput,
+  TopicSubscription: () => TopicSubscription,
+  TopicPublishAccepted: () => TopicPublishAccepted,
+  ToolWorkReleased: () => ToolWorkReleased,
+  ToolWorkLease: () => ToolWorkLease,
+  ToolOutcomeAccepted: () => ToolOutcomeAccepted,
+  ToolCallSummary: () => ToolCallSummary,
+  ToolAttemptList: () => ToolAttemptList,
+  ToolAttempt: () => ToolAttempt,
+  SubscribeTopicInput: () => SubscribeTopicInput,
+  SubmitInboundEnvelopeInput: () => SubmitInboundEnvelopeInput,
+  SubmitInboundEnvelopeAccepted: () => SubmitInboundEnvelopeAccepted,
+  StreamSessionInput: () => StreamSessionInput,
+  StreamExecutionInput: () => StreamExecutionInput,
+  SteeringKind: () => SteeringKind,
+  SteerInput: () => SteerInput,
+  SteerAccepted: () => SteerAccepted,
+  StartExecutionResult: () => StartExecutionResult,
+  StartExecutionInput: () => StartExecutionInput,
+  SpawnChildRunInput: () => SpawnChildRunInput2,
+  SessionSummary: () => SessionSummary,
+  SessionStreamItem: () => SessionStreamItem,
+  RunnerSummary: () => RunnerSummary,
+  RouteExecutionResult: () => RouteExecutionResult,
+  ResolveToolApprovalInput: () => ResolveToolApprovalInput,
+  ResolvePermissionInput: () => ResolvePermissionInput,
+  ReplayExecutionResult: () => ReplayExecutionResult,
+  ReplayExecutionInput: () => ReplayExecutionInput,
+  ReleaseToolWorkInput: () => ReleaseToolWorkInput,
+  ReleaseEnvelopeReadyInput: () => ReleaseEnvelopeReadyInput,
+  PutEntityStateInput: () => PutEntityStateInput,
+  PublishTopicInput: () => PublishTopicInput,
+  PermissionAnswer: () => PermissionAnswer,
+  PendingToolCallList: () => PendingToolCallList,
+  PendingToolCall: () => PendingToolCall,
+  PendingToolApprovalList: () => PendingToolApprovalList,
+  PendingToolApproval: () => PendingToolApproval,
+  PageExecutionEventsResult: () => PageExecutionEventsResult,
+  PageExecutionEventsInput: () => PageExecutionEventsInput,
+  ListWaitsInput: () => ListWaitsInput,
+  ListTopicSubscriptionsInput: () => ListTopicSubscriptionsInput,
+  ListToolAttemptsInput: () => ListToolAttemptsInput,
+  ListSessionsResult: () => ListSessionsResult,
+  ListSessionsInput: () => ListSessionsInput,
+  ListSchedulesResult: () => ListSchedulesResult,
+  ListSchedulesInput: () => ListSchedulesInput,
+  ListRunnersResult: () => ListRunnersResult,
+  ListPendingToolCallsInput: () => ListPendingToolCallsInput,
+  ListPendingApprovalsInput: () => ListPendingApprovalsInput,
+  ListInboxMessagesInput: () => ListInboxMessagesInput,
+  ListExecutionsResult: () => ListExecutionsResult,
+  ListExecutionsInput: () => ListExecutionsInput,
+  ListEntityStateInput: () => ListEntityStateInput,
+  ListEntitiesInput: () => ListEntitiesInput,
+  InspectChildFanOutResult: () => InspectChildFanOutResult,
+  InspectChildFanOutInput: () => InspectChildFanOutInput,
+  GetSessionResult: () => GetSessionResult,
+  GetSessionInput: () => GetSessionInput,
+  GetOrCreateEntityInput: () => GetOrCreateEntityInput,
+  GetEntityStateInput: () => GetEntityStateInput,
+  GetEntityInput: () => GetEntityInput,
+  FulfillToolCallInput: () => FulfillToolCallInput,
+  FollowStopReason: () => FollowStopReason,
+  FollowExecutionItem: () => FollowExecutionItem,
+  FollowExecutionInput: () => FollowExecutionInput,
+  ExecutionListChange: () => ExecutionListChange,
+  ExecutionInspection: () => ExecutionInspection,
+  ExecutionEventPageDirection: () => ExecutionEventPageDirection,
+  ExecutionCursor: () => ExecutionCursor2,
+  EventLogCursorNotFound: () => EventLogCursorNotFound,
+  EnvelopeReadyReleased: () => EnvelopeReadyReleased,
+  EnvelopeReadyLease: () => EnvelopeReadyLease,
+  EnvelopeReadyAcked: () => EnvelopeReadyAcked,
+  EntityInstance: () => EntityInstance,
+  DestroyEntityInput: () => DestroyEntityInput,
+  DeleteEntityStateInput: () => DeleteEntityStateInput,
+  CreateScheduleResult: () => CreateScheduleResult,
+  CreateScheduleInput: () => CreateScheduleInput,
+  CreateChildFanOutInput: () => CreateChildFanOutInput,
+  ConversationSummary: () => ConversationSummary,
+  ConversationKind: () => ConversationKind,
+  CompleteToolWorkInput: () => CompleteToolWorkInput,
+  ClaimToolWorkInput: () => ClaimToolWorkInput,
+  ClaimEnvelopeReadyInput: () => ClaimEnvelopeReadyInput,
+  ChildRunSummary: () => ChildRunSummary,
+  CancelScheduleResult: () => CancelScheduleResult,
+  CancelScheduleInput: () => CancelScheduleInput,
+  CancelExecutionInput: () => CancelExecutionInput,
+  CancelExecutionAccepted: () => CancelExecutionAccepted,
+  CancelChildFanOutResult: () => CancelChildFanOutResult,
+  CancelChildFanOutInput: () => CancelChildFanOutInput,
+  AwaitWaitInput: () => AwaitWaitInput,
+  AckEnvelopeReadyInput: () => AckEnvelopeReadyInput
+});
+import { Schema as Schema22 } from "effect";
+var StartExecutionInput = Schema22.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)),
+  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)
+}).annotate({ identifier: "Relay.Operation.StartExecutionInput" });
+var StartExecutionResult = Schema22.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  status: exports_execution_schema.ExecutionStatus,
+  metadata: Schema22.optionalKey(exports_shared_schema.Metadata)
+}).annotate({ identifier: "Relay.Operation.StartExecutionResult" });
+var GetOrCreateEntityInput = Schema22.Struct({
+  kind: exports_ids_schema.EntityKindName,
+  key: exports_ids_schema.EntityKey,
+  input: Schema22.optionalKey(Schema22.Array(exports_content_schema.Part)),
+  metadata: Schema22.optionalKey(exports_shared_schema.Metadata),
+  created_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.GetOrCreateEntityInput" });
+var GetEntityInput = Schema22.Struct({ kind: exports_ids_schema.EntityKindName, key: exports_ids_schema.EntityKey }).annotate({
+  identifier: "Relay.Operation.GetEntityInput"
+});
+var DestroyEntityInput = Schema22.Struct({
+  kind: exports_ids_schema.EntityKindName,
+  key: exports_ids_schema.EntityKey,
+  reason: Schema22.optionalKey(Schema22.String),
+  destroyed_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.DestroyEntityInput" });
+var ListEntitiesInput = Schema22.Struct({
+  kind: Schema22.optionalKey(exports_ids_schema.EntityKindName),
+  after_kind: Schema22.optionalKey(exports_ids_schema.EntityKindName),
+  after_key: Schema22.optionalKey(Schema22.String),
+  limit: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThan(0)))
+}).annotate({ identifier: "Relay.Operation.ListEntitiesInput" });
+var EntityInstance = exports_entity_schema.Instance;
+var StreamExecutionInput = Schema22.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)))
+}).annotate({ identifier: "Relay.Operation.StreamExecutionInput" });
+var GetEntityStateInput = Schema22.Struct({ execution_id: exports_ids_schema.ExecutionId, key: exports_state_schema.StateKey }).annotate({
+  identifier: "Relay.Operation.GetEntityStateInput"
+});
+var PutEntityStateInput = Schema22.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:")))),
+  updated_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.PutEntityStateInput" });
+var DeleteEntityStateInput = Schema22.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:")))),
+  removed_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.DeleteEntityStateInput" });
+var ListEntityStateInput = Schema22.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)))
+}).annotate({ identifier: "Relay.Operation.ListEntityStateInput" });
+var WaitTerminalState = Schema22.Literals(["resolved", "timed_out", "cancelled"]).annotate({
+  identifier: "Relay.Operation.WaitTerminalState"
+});
+var AwaitWaitInput = Schema22.Struct({
+  wait_id: exports_ids_schema.WaitId,
+  execution_id: exports_ids_schema.ExecutionId
+}).annotate({ identifier: "Relay.Operation.AwaitWaitInput" });
+var WaitOutcome = Schema22.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)
+}).annotate({ identifier: "Relay.Operation.WaitOutcome" });
+var CancelExecutionInput = Schema22.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  cancelled_at: exports_shared_schema.TimestampMillis,
+  reason: Schema22.optionalKey(Schema22.String)
+}).annotate({ identifier: "Relay.Operation.CancelExecutionInput" });
+var CancelExecutionAccepted = Schema22.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({
+  identifier: "Relay.Operation.SteeringKind"
+});
+var SteerInput = Schema22.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  kind: SteeringKind,
+  content: Schema22.Array(exports_content_schema.Part),
+  created_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.SteerInput" });
+var SteerAccepted = Schema22.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  kind: SteeringKind,
+  sequence: Schema22.Int.check(Schema22.isGreaterThanOrEqualTo(0))
+}).annotate({ identifier: "Relay.Operation.SteerAccepted" });
+var WakeInput = Schema22.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)
+}).annotate({ identifier: "Relay.Operation.WakeInput" });
+var WakeAccepted = Schema22.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({
+  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)))
+}).annotate({ identifier: "Relay.Operation.ListWaitsInput" });
+var WaitView = Schema22.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),
+  mode: exports_envelope_schema.WaitMode,
+  correlation_key: Schema22.optionalKey(Schema22.String),
+  state: WaitState,
+  metadata: exports_shared_schema.Metadata,
+  created_at: exports_shared_schema.TimestampMillis,
+  resolved_at: Schema22.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 })
+]).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"),
+    reason: FollowStopReason,
+    cursor: Schema22.NullOr(exports_shared_schema.NonEmptyString)
+  })
+]).annotate({ identifier: "Relay.Operation.FollowExecutionItem" });
+var FollowExecutionInput = Schema22.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)))
+}).annotate({ identifier: "Relay.Operation.FollowExecutionInput" });
+var PendingToolApproval = Schema22.Struct({
+  wait_id: exports_ids_schema.WaitId,
+  execution_id: exports_ids_schema.ExecutionId,
+  tool_call_id: exports_ids_schema.ToolCallId,
+  tool_name: exports_shared_schema.NonEmptyString,
+  input: exports_shared_schema.JsonValue,
+  requested_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.PendingToolApproval" });
+var ListPendingApprovalsInput = Schema22.Struct({
+  execution_id: exports_ids_schema.ExecutionId
+}).annotate({ identifier: "Relay.Operation.ListPendingApprovalsInput" });
+var PendingToolApprovalList = Schema22.Struct({
+  approvals: Schema22.Array(PendingToolApproval)
+}).annotate({ identifier: "Relay.Operation.PendingToolApprovalList" });
+var PendingToolCall = Schema22.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,
+  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)))
+}).annotate({ identifier: "Relay.Operation.ListPendingToolCallsInput" });
+var PendingToolCallList = Schema22.Struct({
+  tool_calls: Schema22.Array(PendingToolCall)
+}).annotate({ identifier: "Relay.Operation.PendingToolCallList" });
+var FulfillToolCallInput = Schema22.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({
+  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({
+  tool_call_id: exports_ids_schema.ToolCallId,
+  attempt_id: exports_ids_schema.ToolAttemptId,
+  worker_id: exports_tool_schema.WorkerId,
+  outcome: exports_tool_schema.ExternalOutcome,
+  completed_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.CompleteToolWorkInput" });
+var ReleaseToolWorkInput = Schema22.Struct({
+  tool_call_id: exports_ids_schema.ToolCallId,
+  attempt_id: exports_ids_schema.ToolAttemptId,
+  worker_id: exports_tool_schema.WorkerId,
+  released_at: exports_shared_schema.TimestampMillis,
+  next_available_at: exports_shared_schema.TimestampMillis,
+  error: Schema22.optionalKey(Schema22.String)
+}).annotate({ identifier: "Relay.Operation.ReleaseToolWorkInput" });
+var ListToolAttemptsInput = Schema22.Struct({
+  tool_call_id: exports_ids_schema.ToolCallId
+}).annotate({ identifier: "Relay.Operation.ListToolAttemptsInput" });
+var ToolAttempt = Schema22.Struct({
+  attempt_id: exports_ids_schema.ToolAttemptId,
+  tool_call_id: exports_ids_schema.ToolCallId,
+  attempt_number: Schema22.Int.check(Schema22.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),
+  created_at: exports_shared_schema.TimestampMillis,
+  completed_at: Schema22.optionalKey(exports_shared_schema.TimestampMillis)
+}).annotate({ identifier: "Relay.Operation.ToolAttempt" });
+var ToolAttemptList = Schema22.Struct({
+  attempts: Schema22.Array(ToolAttempt)
+}).annotate({ identifier: "Relay.Operation.ToolAttemptList" });
+var ToolOutcomeAccepted = Schema22.Struct({
+  tool_call_id: exports_ids_schema.ToolCallId,
+  attempt: ToolAttempt,
+  duplicate: Schema22.Boolean
+}).annotate({ identifier: "Relay.Operation.ToolOutcomeAccepted" });
+var ToolWorkLease = Schema22.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  call: exports_tool_schema.Call,
+  definition: exports_tool_schema.Definition,
+  placement: exports_tool_schema.Placement,
+  attempt: ToolAttempt,
+  queue: exports_tool_schema.PlacementKey,
+  worker_id: exports_tool_schema.WorkerId,
+  claim_expires_at: exports_shared_schema.TimestampMillis,
+  idempotency_key: Schema22.String
+}).annotate({ identifier: "Relay.Operation.ToolWorkLease" });
+var ToolWorkReleased = Schema22.Struct({
+  tool_call_id: exports_ids_schema.ToolCallId,
+  state: Schema22.Literal("waiting"),
+  next_available_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.ToolWorkReleased" });
+var SpawnChildRunInput2 = Schema22.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  child_execution_id: Schema22.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)
+}).annotate({ identifier: "Relay.Operation.SpawnChildRunInput" });
+var CreateChildFanOutInput = exports_child_orchestration_schema.FanOutDefinition.annotate({
+  identifier: "Relay.Operation.CreateChildFanOutInput"
+});
+var CancelChildFanOutInput = Schema22.Struct({
+  fan_out_id: exports_ids_schema.ChildFanOutId,
+  cancelled_at: exports_shared_schema.TimestampMillis,
+  reason: Schema22.optionalKey(Schema22.String)
+}).annotate({ identifier: "Relay.Operation.CancelChildFanOutInput" });
+var CancelChildFanOutResult = Schema22.Struct({
+  fan_out: exports_child_orchestration_schema.FanOutState
+}).annotate({ identifier: "Relay.Operation.CancelChildFanOutResult" });
+var InspectChildFanOutInput = Schema22.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)
+}).annotate({ identifier: "Relay.Operation.InspectChildFanOutResult" });
+var ResolveToolApprovalInput = Schema22.Struct({
+  wait_id: exports_ids_schema.WaitId,
+  approved: Schema22.Boolean,
+  comment: Schema22.optionalKey(Schema22.String),
+  resolved_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.ResolveToolApprovalInput" });
+var PermissionAnswer = Schema22.Literals(["Approved", "Denied", "Always"]).annotate({
+  identifier: "Relay.Operation.PermissionAnswer"
+});
+var ResolvePermissionInput = Schema22.Struct({
+  wait_id: exports_ids_schema.WaitId,
+  answer: PermissionAnswer,
+  reason: Schema22.optionalKey(Schema22.String),
+  resolved_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.ResolvePermissionInput" });
+var SubmitInboundEnvelopeInput = Schema22.Struct({
+  envelope: exports_envelope_schema.SendInput,
+  wake: WakeInput
+}).annotate({ identifier: "Relay.Operation.SubmitInboundEnvelopeInput" });
+var SubmitInboundEnvelopeAccepted = Schema22.Struct({
+  envelope: exports_envelope_schema.EnvelopeAccepted,
+  wake: WakeAccepted
+}).annotate({ identifier: "Relay.Operation.SubmitInboundEnvelopeAccepted" });
+var ClaimEnvelopeReadyInput = Schema22.Struct({
+  route_type: exports_address_schema.RouteKind,
+  route_key: Schema22.optionalKey(Schema22.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({
+  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({
+  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({
+  envelope_ready_id: exports_ids_schema.EnvelopeReadyId,
+  state: Schema22.Literal("acknowledged"),
+  acknowledged_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.EnvelopeReadyAcked" });
+var ReleaseEnvelopeReadyInput = Schema22.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)
+}).annotate({ identifier: "Relay.Operation.ReleaseEnvelopeReadyInput" });
+var EnvelopeReadyReleased = Schema22.Struct({
+  envelope_ready_id: exports_ids_schema.EnvelopeReadyId,
+  state: Schema22.Literal("ready"),
+  next_available_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.EnvelopeReadyReleased" });
+var CreateScheduleInput = Schema22.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)),
+  next_run_at: exports_shared_schema.TimestampMillis,
+  idempotency_key: Schema22.optionalKey(exports_shared_schema.NonEmptyString),
+  metadata: Schema22.optionalKey(exports_shared_schema.Metadata)
+}).annotate({ identifier: "Relay.Operation.CreateScheduleInput" });
+var CreateScheduleResult = Schema22.Struct({
+  schedule: exports_schedule_schema.ScheduleRecord
+}).annotate({ identifier: "Relay.Operation.CreateScheduleResult" });
+var CancelScheduleInput = Schema22.Struct({
+  schedule_id: exports_ids_schema.ScheduleId,
+  cancelled_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.CancelScheduleInput" });
+var CancelScheduleResult = Schema22.Struct({
+  schedule: exports_schedule_schema.ScheduleRecord
+}).annotate({ identifier: "Relay.Operation.CancelScheduleResult" });
+var ListSchedulesInput = Schema22.Struct({
+  state: Schema22.optionalKey(exports_schedule_schema.ScheduleState)
+}).annotate({ identifier: "Relay.Operation.ListSchedulesInput" });
+var ListSchedulesResult = Schema22.Struct({
+  schedules: Schema22.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)
+}).annotate({ identifier: "Relay.Operation.ListExecutionsInput" });
+var SubscribeTopicInput = Schema22.Struct({
+  topic_address_id: exports_ids_schema.AddressId,
+  subscriber_execution_id: exports_ids_schema.ExecutionId,
+  metadata: Schema22.optionalKey(exports_shared_schema.Metadata)
+}).annotate({ identifier: "Relay.Operation.SubscribeTopicInput" });
+var TopicSubscription = Schema22.Struct({
+  topic_address_id: exports_ids_schema.AddressId,
+  subscriber_execution_id: exports_ids_schema.ExecutionId,
+  metadata: Schema22.optionalKey(exports_shared_schema.Metadata),
+  created_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.TopicSubscription" });
+var PublishTopicInput = Schema22.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)
+}).annotate({ identifier: "Relay.Operation.PublishTopicInput" });
+var TopicPublishAccepted = Schema22.Struct({
+  envelope_id: exports_ids_schema.EnvelopeId,
+  subscriber_count: Schema22.Int.check(Schema22.isGreaterThanOrEqualTo(0))
+}).annotate({ identifier: "Relay.Operation.TopicPublishAccepted" });
+var UnsubscribeTopicInput = Schema22.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)
+}).annotate({ identifier: "Relay.Operation.ListTopicSubscriptionsInput" });
+var ListInboxMessagesInput = Schema22.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)))
+}).annotate({ identifier: "Relay.Operation.ListInboxMessagesInput" });
+var ConversationKind = Schema22.Literals(["user-agent", "agent-agent"]).annotate({
+  identifier: "Relay.Operation.ConversationKind"
+});
+var ConversationSummary = Schema22.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  root_address_id: exports_ids_schema.AddressId,
+  session_id: Schema22.optionalKey(exports_ids_schema.SessionId),
+  status: exports_execution_schema.ExecutionStatus,
+  kind: ConversationKind,
+  agent_id: Schema22.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({
+  execution_id: exports_ids_schema.ExecutionId,
+  after_cursor: Schema22.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 }) {
+}
+var StreamSessionInput = Schema22.Struct({
+  session_id: exports_ids_schema.SessionId,
+  resume: Schema22.optionalKey(Schema22.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 })
+]).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)))
+}).annotate({ identifier: "Relay.Operation.WatchExecutionsInput" });
+var ExecutionListChange = Schema22.Union([
+  Schema22.TaggedStruct("snapshot", {
+    records: Schema22.Array(ConversationSummary),
+    next_cursor: Schema22.optionalKey(exports_pagination_schema.ExecutionCursor)
+  }),
+  Schema22.TaggedStruct("upsert", { record: ConversationSummary })
+]).annotate({ identifier: "Relay.Operation.ExecutionListChange" });
+var ToolCallSummary = Schema22.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({
+  child_execution_id: exports_ids_schema.ChildExecutionId,
+  address_id: exports_ids_schema.AddressId,
+  status: exports_execution_schema.ExecutionStatus,
+  metadata: exports_shared_schema.Metadata,
+  created_at: exports_shared_schema.TimestampMillis,
+  updated_at: exports_shared_schema.TimestampMillis
+}).annotate({ identifier: "Relay.Operation.ChildRunSummary" });
+var ExecutionInspection = Schema22.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)
+}).annotate({ identifier: "Relay.Operation.ExecutionInspection" });
+var ListExecutionsResult = Schema22.Struct({
+  records: Schema22.Array(ConversationSummary),
+  next_cursor: Schema22.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)
+}).annotate({ identifier: "Relay.Operation.ListSessionsInput" });
+var SessionSummary = Schema22.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)
+}).annotate({ identifier: "Relay.Operation.ListSessionsResult" });
+var GetSessionInput = Schema22.Struct({
+  session_id: exports_ids_schema.SessionId,
+  limit: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThan(0))),
+  cursor: Schema22.optionalKey(exports_pagination_schema.ExecutionCursor)
+}).annotate({ identifier: "Relay.Operation.GetSessionInput" });
+var GetSessionResult = Schema22.Struct({
+  session: SessionSummary,
+  executions: Schema22.Array(ConversationSummary),
+  next_cursor: Schema22.optionalKey(exports_pagination_schema.ExecutionCursor)
+}).annotate({ identifier: "Relay.Operation.GetSessionResult" });
+var ReplayExecutionInput = Schema22.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  after_cursor: Schema22.optionalKey(exports_shared_schema.NonEmptyString),
+  limit: Schema22.optionalKey(Schema22.Int.check(Schema22.isGreaterThan(0)))
+}).annotate({ identifier: "Relay.Operation.ReplayExecutionInput" });
+var ReplayExecutionResult = Schema22.Struct({
+  events: Schema22.Array(exports_execution_schema.ExecutionEvent)
+}).annotate({ identifier: "Relay.Operation.ReplayExecutionResult" });
+var ExecutionEventPageDirection = Schema22.Literals(["forward", "backward"]).annotate({
+  identifier: "Relay.Operation.ExecutionEventPageDirection"
+});
+var PageExecutionEventsInput = Schema22.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) => {
+  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)
+}).annotate({ identifier: "Relay.Operation.PageExecutionEventsResult" });
+var RunnerSummary = Schema22.Struct({
+  address: Schema22.String,
+  healthy: Schema22.Boolean,
+  last_heartbeat: exports_shared_schema.TimestampMillis,
+  owned_shards: Schema22.Int
+}).annotate({ identifier: "Relay.Operation.RunnerSummary" });
+var ListRunnersResult = Schema22.Struct({
+  runners: Schema22.Array(RunnerSummary),
+  total_shards: Schema22.Int
+}).annotate({ identifier: "Relay.Operation.ListRunnersResult" });
+var RouteExecutionResult = Schema22.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  shard: Schema22.String,
+  runner_address: Schema22.NullOr(Schema22.String),
+  owned: Schema22.Boolean
+}).annotate({ identifier: "Relay.Operation.RouteExecutionResult" });
+
+// src/command.ts
+var exports_command = {};
+__export(exports_command, {
+  outputSchemaRef: () => outputSchemaRef,
+  make: () => make,
+  inputSchemaRef: () => inputSchemaRef,
+  EntityNotFound: () => EntityNotFound,
+  CommandTimedOut: () => CommandTimedOut,
+  CommandReplyInvalid: () => CommandReplyInvalid
+});
+import { Function, Schema as Schema23 } from "effect";
+var make = Function.dual(2, (name, options) => ({ name, ...options }));
+var inputSchemaRef = (name) => `relay/command/${name}/input`;
+var outputSchemaRef = (name) => `relay/command/${name}/output`;
+
+class CommandTimedOut extends Schema23.TaggedErrorClass()("CommandTimedOut", {
+  command: exports_shared_schema.NonEmptyString,
+  wait_id: exports_ids_schema.WaitId,
+  timeout: Schema23.String
+}) {
+}
+
+class CommandReplyInvalid extends Schema23.TaggedErrorClass()("CommandReplyInvalid", {
+  command: exports_shared_schema.NonEmptyString,
+  wait_id: exports_ids_schema.WaitId,
+  message: Schema23.String
+}) {
+}
+
+class EntityNotFound extends Schema23.TaggedErrorClass()("EntityNotFound", {
+  kind: exports_ids_schema.EntityKindName,
+  key: exports_ids_schema.EntityKey
+}) {
+}
+
+// src/client-public.ts
+var exports_client_public = {};
+__export(exports_client_public, {
+  watchPresence: () => watchPresence,
+  watchExecutions: () => watchExecutions,
+  wake: () => wake,
+  unsubscribeTopic: () => unsubscribeTopic,
+  subscribeTopic: () => subscribeTopic,
+  submitInboundEnvelope: () => submitInboundEnvelope,
+  streamSession: () => streamSession,
+  streamExecution: () => streamExecution,
+  steer: () => steer,
+  startExecutionByAgentDefinition: () => startExecutionByAgentDefinition,
+  startExecutionByAddress: () => startExecutionByAddress,
+  startExecution: () => startExecution,
+  spawnChildRun: () => spawnChildRun,
+  send: () => send,
+  routeExecution: () => routeExecution,
+  resolveToolApproval: () => resolveToolApproval,
+  resolvePermission: () => resolvePermission,
+  replayExecution: () => replayExecution,
+  releaseToolWork: () => releaseToolWork,
+  releaseEnvelopeReady: () => releaseEnvelopeReady,
+  registerEntityKind: () => registerEntityKind,
+  registerAgentDefinition: () => registerAgentDefinition,
+  registerAgent: () => registerAgent,
+  registerAddressBookRoute: () => registerAddressBookRoute,
+  publishTopic: () => publishTopic,
+  pageExecutionEvents: () => pageExecutionEvents,
+  listWaits: () => listWaits,
+  listTopicSubscriptions: () => listTopicSubscriptions,
+  listToolAttempts: () => listToolAttempts,
+  listSkillDefinitions: () => listSkillDefinitions,
+  listSkillDefinitionRevisions: () => listSkillDefinitionRevisions,
+  listSessions: () => listSessions,
+  listSchedules: () => listSchedules,
+  listRunners: () => listRunners,
+  listPendingToolCalls: () => listPendingToolCalls,
+  listPendingApprovals: () => listPendingApprovals,
+  listInboxMessages: () => listInboxMessages,
+  listExecutions: () => listExecutions,
+  listEntities: () => listEntities,
+  listAgentDefinitions: () => listAgentDefinitions,
+  listAgentDefinitionRevisions: () => listAgentDefinitionRevisions,
+  listAddressBookRoutes: () => listAddressBookRoutes,
+  inspectExecution: () => inspectExecution,
+  inspectChildFanOut: () => inspectChildFanOut,
+  getSkillDefinition: () => getSkillDefinition,
+  getSession: () => getSession,
+  getPresence: () => getPresence,
+  getOrCreateEntity: () => getOrCreateEntity,
+  getExecution: () => getExecution,
+  getEntity: () => getEntity,
+  getAgentDefinition: () => getAgentDefinition,
+  getAddressBookRoute: () => getAddressBookRoute,
+  fulfillToolCall: () => fulfillToolCall,
+  followExecutionFrom: () => followExecutionFrom,
+  followExecution: () => followExecution,
+  destroyEntity: () => destroyEntity,
+  createSchedule: () => createSchedule,
+  createChildFanOut: () => createChildFanOut,
+  completeToolWork: () => completeToolWork,
+  claimToolWork: () => claimToolWork,
+  claimEnvelopeReady: () => claimEnvelopeReady,
+  cancelSchedule: () => cancelSchedule,
+  cancelExecution: () => cancelExecution,
+  cancelChildFanOut: () => cancelChildFanOut,
+  awaitWait: () => awaitWait,
+  askEntity: () => askEntity,
+  ackEnvelopeReady: () => ackEnvelopeReady,
+  WaitKindMismatch: () => WaitKindMismatch,
+  StateVersionConflict: () => StateVersionConflict,
+  Service: () => Service,
+  ExecutionNotFound: () => ExecutionNotFound,
+  EventLogCursorNotFound: () => EventLogCursorNotFound,
+  EntityNamespaceReserved: () => EntityNamespaceReserved,
+  ClientError: () => ClientError
+});
+import { Context, Effect, Schema as Schema24, Stream } from "effect";
+
+class ClientError extends Schema24.TaggedErrorClass()("ClientError", {
+  message: Schema24.String
+}) {
+}
+
+class ExecutionNotFound extends Schema24.TaggedErrorClass()("ExecutionNotFound", {
+  execution_id: exports_ids_schema.ExecutionId
+}) {
+}
+
+class EntityNamespaceReserved extends Schema24.TaggedErrorClass()("EntityNamespaceReserved", { id: Schema24.String, message: Schema24.String }) {
+}
+
+class WaitKindMismatch extends Schema24.TaggedErrorClass()("WaitKindMismatch", {
+  wait_id: exports_ids_schema.WaitId,
+  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 followStopped = (reason, cursor) => ({
+  _tag: "stopped",
+  reason,
+  cursor: cursor ?? null
+});
+var followExecutionFrom = (dependencies) => (input) => {
+  const maxReconnects = input.max_reconnects ?? 10;
+  const stopModes = input.stop_on_wait_modes;
+  const inspect = Effect.suspend(() => dependencies.inspectExecution(input.execution_id)).pipe(Effect.catchTag("ExecutionNotFound", (error) => ClientError.make({ message: `execution ${error.execution_id} not found` })));
+  const reconcile = (state, message) => Stream.unwrap(Effect.gen(function* () {
+    const inspection = yield* inspect;
+    const terminal = followTerminalStatus(`execution.${inspection.status}`);
+    if (terminal !== undefined) {
+      return Stream.make(followStopped({ _tag: "terminal", status: terminal }, state.cursor));
+    }
+    const actionable = stopModes === undefined ? undefined : inspection.waiting_on.find((wait) => wait.state === "open" && stopModes.includes(wait.mode));
+    if (actionable !== undefined) {
+      return Stream.make(followStopped({ _tag: "actionable_wait", wait: actionable }, state.cursor));
+    }
+    if (state.attempts >= maxReconnects) {
+      return Stream.fail(ClientError.make({
+        message: `follow of ${input.execution_id} exhausted ${maxReconnects} reconnects: ${message}`
+      }));
+    }
+    state.attempts += 1;
+    const reconnecting = { _tag: "reconnecting", message, attempt: state.attempts };
+    return Stream.make(reconnecting).pipe(Stream.concat(Stream.fromEffect(Effect.sleep(followReconnectDelayMillis(state.attempts))).pipe(Stream.drain)), Stream.concat(Stream.suspend(() => connect(state))));
+  }));
+  const itemsFor = (state, event) => Effect.gen(function* () {
+    if (event.sequence <= state.sequence)
+      return [];
+    state.sequence = event.sequence;
+    state.cursor = event.cursor;
+    state.emitted = true;
+    state.attempts = 0;
+    const items = [{ _tag: "event", event }];
+    const terminal = followTerminalStatus(event.type);
+    if (terminal !== undefined) {
+      items.push(followStopped({ _tag: "terminal", status: terminal }, state.cursor));
+      return items;
+    }
+    if (stopModes !== undefined && event.type === "wait.created") {
+      const mode = event.data?.mode;
+      if (typeof mode === "string" && stopModes.includes(mode)) {
+        const inspection = yield* dependencies.inspectExecution(input.execution_id).pipe(Effect.catchTag("ExecutionNotFound", () => Effect.void));
+        const actionable = inspection?.waiting_on.find((wait) => wait.state === "open" && wait.wait_id === event.data?.wait_id);
+        if (actionable !== undefined) {
+          items.push(followStopped({ _tag: "actionable_wait", wait: actionable }, state.cursor));
+        }
+      }
+    }
+    return items;
+  });
+  const connect = (state) => dependencies.streamExecution({
+    execution_id: input.execution_id,
+    ...state.cursor === undefined ? {} : { after_cursor: state.cursor }
+  }).pipe(Stream.flatMap((event) => Stream.fromEffect(itemsFor(state, event)).pipe(Stream.flatMap((items) => Stream.fromIterable(items)))), Stream.catchTag("EventLogCursorNotFound", (error) => !state.emitted && input.after_cursor !== undefined ? Stream.fail(error) : reconcile(state, `cursor ${error.cursor} was not found`)), Stream.catchTag("ClientError", (error) => reconcile(state, `stream failed: ${error.message}`)), Stream.concat(Stream.suspend(() => reconcile(state, "stream ended before a terminal event"))));
+  return Stream.unwrap(Effect.gen(function* () {
+    const existing = yield* dependencies.getExecution(input.execution_id);
+    if (existing === undefined) {
+      return Stream.fail(ClientError.make({ message: `execution ${input.execution_id} not found` }));
+    }
+    const state = {
+      cursor: input.after_cursor,
+      sequence: -1,
+      attempts: 0,
+      emitted: false
+    };
+    return connect(state);
+  })).pipe(Stream.takeUntil((item) => item._tag === "stopped"));
+};
+var registerAgentDefinition = Effect.fn("Client.registerAgentDefinition.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.registerAgentDefinition(input);
+});
+var registerEntityKind = Effect.fn("Client.registerEntityKind.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.registerEntityKind(input);
+});
+var getOrCreateEntity = Effect.fn("Client.getOrCreateEntity.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.getOrCreateEntity(input);
+});
+var getEntity = Effect.fn("Client.getEntity.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.getEntity(input);
+});
+var destroyEntity = Effect.fn("Client.destroyEntity.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.destroyEntity(input);
+});
+var listEntities = Effect.fn("Client.listEntities.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listEntities(input);
+});
+function registerAgent(input) {
+  return Effect.gen(function* () {
+    const service = yield* Service;
+    if (isRegisterBatonAgentInput(input))
+      return yield* service.registerAgent(input);
+    return yield* service.registerAgent(input);
+  }).pipe(Effect.withSpan("Client.registerAgent.call"));
+}
+var isRegisterBatonAgentInput = (input) => ("agent" in input);
+var getAgentDefinition = Effect.fn("Client.getAgentDefinition.call")(function* (id2) {
+  const service = yield* Service;
+  return yield* service.getAgentDefinition(id2);
+});
+var listAgentDefinitions = Effect.fn("Client.listAgentDefinitions.call")(function* () {
+  const service = yield* Service;
+  return yield* service.listAgentDefinitions();
+});
+var listAgentDefinitionRevisions = Effect.fn("Client.listAgentDefinitionRevisions.call")(function* (id2) {
+  const service = yield* Service;
+  return yield* service.listAgentDefinitionRevisions(id2);
+});
+var getSkillDefinition = Effect.fn("Client.getSkillDefinition.call")(function* (id2) {
+  const service = yield* Service;
+  return yield* service.getSkillDefinition(id2);
+});
+var listSkillDefinitions = Effect.fn("Client.listSkillDefinitions.call")(function* () {
+  const service = yield* Service;
+  return yield* service.listSkillDefinitions();
+});
+var listSkillDefinitionRevisions = Effect.fn("Client.listSkillDefinitionRevisions.call")(function* (id2) {
+  const service = yield* Service;
+  return yield* service.listSkillDefinitionRevisions(id2);
+});
+var registerAddressBookRoute = Effect.fn("Client.registerAddressBookRoute.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.registerAddressBookRoute(input);
+});
+var getAddressBookRoute = Effect.fn("Client.getAddressBookRoute.call")(function* (id2) {
+  const service = yield* Service;
+  return yield* service.getAddressBookRoute(id2);
+});
+var listAddressBookRoutes = Effect.fn("Client.listAddressBookRoutes.call")(function* () {
+  const service = yield* Service;
+  return yield* service.listAddressBookRoutes();
+});
+var startExecution = Effect.fn("Client.startExecution.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.startExecution(input);
+});
+var startExecutionByAddress = Effect.fn("Client.startExecutionByAddress.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.startExecutionByAddress(input);
+});
+var startExecutionByAgentDefinition = Effect.fn("Client.startExecutionByAgentDefinition.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.startExecutionByAgentDefinition(input);
+});
+var cancelExecution = Effect.fn("Client.cancelExecution.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.cancelExecution(input);
+});
+var steer = Effect.fn("Client.steer.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.steer(input);
+});
+var getExecution = Effect.fn("Client.getExecution.call")(function* (id2) {
+  const service = yield* Service;
+  return yield* service.getExecution(id2);
+});
+var listExecutions = Effect.fn("Client.listExecutions.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listExecutions(input);
+});
+var listSessions = Effect.fn("Client.listSessions.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listSessions(input);
+});
+var getSession = Effect.fn("Client.getSession.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.getSession(input);
+});
+var listWaits = Effect.fn("Client.listWaits.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listWaits(input);
+});
+var replayExecution = Effect.fn("Client.replayExecution.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.replayExecution(input);
+});
+var pageExecutionEvents = Effect.fn("Client.pageExecutionEvents.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.pageExecutionEvents(input);
+});
+var listRunners = Effect.fn("Client.listRunners.call")(function* () {
+  const service = yield* Service;
+  return yield* service.listRunners();
+});
+var routeExecution = Effect.fn("Client.routeExecution.call")(function* (executionId) {
+  const service = yield* Service;
+  return yield* service.routeExecution(executionId);
+});
+var subscribeTopic = Effect.fn("Client.subscribeTopic.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.subscribeTopic(input);
+});
+var unsubscribeTopic = Effect.fn("Client.unsubscribeTopic.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.unsubscribeTopic(input);
+});
+var publishTopic = Effect.fn("Client.publishTopic.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.publishTopic(input);
+});
+var listTopicSubscriptions = Effect.fn("Client.listTopicSubscriptions.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listTopicSubscriptions(input);
+});
+var listInboxMessages = Effect.fn("Client.listInboxMessages.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listInboxMessages(input);
+});
+var inspectExecution = Effect.fn("Client.inspectExecution.call")(function* (executionId) {
+  const service = yield* Service;
+  return yield* service.inspectExecution(executionId);
+});
+var send = Effect.fn("Client.send.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.send(input);
+});
+var streamExecution = (input) => Stream.unwrap(Service.pipe(Effect.map((service) => service.streamExecution(input))));
+var followExecution = (input) => Stream.unwrap(Service.pipe(Effect.map((service) => service.followExecution(input))));
+var streamSession = (input) => Stream.unwrap(Service.pipe(Effect.map((service) => service.streamSession(input))));
+var watchExecutions = (input) => Stream.unwrap(Service.pipe(Effect.map((service) => service.watchExecutions(input))));
+var getPresence = Effect.fn("Client.getPresence.call")(function* (scope) {
+  const service = yield* Service;
+  return yield* service.getPresence(scope);
+});
+var watchPresence = (scope) => Stream.unwrap(Service.pipe(Effect.map((service) => service.watchPresence(scope))));
+var wake = Effect.fn("Client.wake.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.wake(input);
+});
+var listPendingApprovals = Effect.fn("Client.listPendingApprovals.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listPendingApprovals(input);
+});
+var resolveToolApproval = Effect.fn("Client.resolveToolApproval.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.resolveToolApproval(input);
+});
+var resolvePermission = Effect.fn("Client.resolvePermission.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.resolvePermission(input);
+});
+var listPendingToolCalls = Effect.fn("Client.listPendingToolCalls.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listPendingToolCalls(input);
+});
+var fulfillToolCall = Effect.fn("Client.fulfillToolCall.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.fulfillToolCall(input);
+});
+var claimToolWork = Effect.fn("Client.claimToolWork.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.claimToolWork(input);
+});
+var completeToolWork = Effect.fn("Client.completeToolWork.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.completeToolWork(input);
+});
+var releaseToolWork = Effect.fn("Client.releaseToolWork.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.releaseToolWork(input);
+});
+var listToolAttempts = Effect.fn("Client.listToolAttempts.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listToolAttempts(input);
+});
+var submitInboundEnvelope = Effect.fn("Client.submitInboundEnvelope.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.submitInboundEnvelope(input);
+});
+var spawnChildRun = Effect.fn("Client.spawnChildRun.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.spawnChildRun(input);
+});
+var createChildFanOut = Effect.fn("Client.createChildFanOut.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.createChildFanOut(input);
+});
+var cancelChildFanOut = Effect.fn("Client.cancelChildFanOut.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.cancelChildFanOut(input);
+});
+var inspectChildFanOut = Effect.fn("Client.inspectChildFanOut.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.inspectChildFanOut(input);
+});
+var claimEnvelopeReady = Effect.fn("Client.claimEnvelopeReady.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.claimEnvelopeReady(input);
+});
+var ackEnvelopeReady = Effect.fn("Client.ackEnvelopeReady.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.ackEnvelopeReady(input);
+});
+var releaseEnvelopeReady = Effect.fn("Client.releaseEnvelopeReady.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.releaseEnvelopeReady(input);
+});
+var createSchedule = Effect.fn("Client.createSchedule.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.createSchedule(input);
+});
+var cancelSchedule = Effect.fn("Client.cancelSchedule.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.cancelSchedule(input);
+});
+var listSchedules = Effect.fn("Client.listSchedules.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.listSchedules(input);
+});
+var askEntity = Effect.fn("Client.askEntity.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.askEntity(input);
+});
+var awaitWait = Effect.fn("Client.awaitWait.call")(function* (input) {
+  const service = yield* Service;
+  return yield* service.awaitWait(input);
+});
+
+// ../runtime/src/presence/presence-contract.ts
+import { Context as Context2, Schema as Schema25 } from "effect";
+
+class PresenceError extends Schema25.TaggedErrorClass()("PresenceError", {
+  message: Schema25.String
+}) {
+}
+
+class Service2 extends Context2.Service()("@relayfx/runtime/presence/presence-contract/Service") {
+}
+var PresenceIdentity = Context2.Reference("@relayfx/runtime/PresenceIdentity", { defaultValue: () => ({}) });
+
+export { exports_address_schema, exports_ids_schema, exports_shared_schema, exports_agent_schema, exports_tool_schema, exports_child_orchestration_schema, exports_execution_schema, exports_content_schema, exports_envelope_schema, exports_entity_schema, exports_inbox_schema, exports_pagination_schema, exports_presence_schema, exports_schedule_schema, exports_skill_schema, exports_state_schema, exports_wait_schema, exports_workflow_schema, exports_workspace_schema, StateVersionConflict, EventLogCursorNotFound, exports_operation, inputSchemaRef, outputSchemaRef, CommandTimedOut, CommandReplyInvalid, EntityNotFound, exports_command, ClientError, ExecutionNotFound, EntityNamespaceReserved, WaitKindMismatch, Service, followExecutionFrom, exports_client_public, PresenceError, Service2 as Service1, PresenceIdentity };