@relayfx/sdk 0.1.0 → 0.2.0

package/dist/{index-sms8x6cq.js → index-bcbbm5wt.js}

@@ -2,7 +2,7 @@
 import {
   __export,
   exports_model_registry
-} from "./index-q0z11q9m.js";
+} from "./index-2xztzkfr.js";
 
 // ../ai/src/language-model/language-model-registration.ts
 var exports_language_model_registration = {};

package/dist/{index-vbf5hcw8.js → index-qgt9z94q.js}

@@ -6,9 +6,13 @@ import {
   exports_agent_registry_service,
   exports_agent_schema,
   exports_child_execution_repository,
+  exports_child_fan_out_repository,
+  exports_child_fan_out_runtime,
+  exports_child_orchestration_schema,
   exports_child_run_service,
   exports_cluster_registry_repository,
   exports_content_schema,
+  exports_definition_runtime,
   exports_entity_instance_service,
   exports_entity_registry_service,
   exports_entity_schema,
@@ -40,9 +44,11 @@ import {
   exports_tool_schema,
   exports_tool_transition_coordinator,
   exports_topic_service,
+  exports_wait_schema,
   exports_wait_service,
-  exports_wait_signal
-} from "./index-q0z11q9m.js";
+  exports_wait_signal,
+  exports_workflow_definition_repository
+} from "./index-2xztzkfr.js";
 
 // src/operation.ts
 var exports_operation = {};
@@ -106,12 +112,17 @@ __export(exports_operation, {
   ListExecutionsInput: () => ListExecutionsInput,
   ListEntityStateInput: () => ListEntityStateInput,
   ListEntitiesInput: () => ListEntitiesInput,
+  InspectChildFanOutResult: () => InspectChildFanOutResult,
+  InspectChildFanOutInput: () => InspectChildFanOutInput,
   GetSessionResult: () => GetSessionResult,
   GetSessionInput: () => GetSessionInput,
   GetOrCreateEntityInput: () => GetOrCreateEntityInput,
   GetEntityStateInput: () => GetEntityStateInput,
   GetEntityInput: () => GetEntityInput,
   FulfillToolCallInput: () => FulfillToolCallInput,
+  FollowStopReason: () => FollowStopReason,
+  FollowExecutionItem: () => FollowExecutionItem,
+  FollowExecutionInput: () => FollowExecutionInput,
   ExecutionListChange: () => ExecutionListChange,
   ExecutionInspection: () => ExecutionInspection,
   ExecutionCursor: () => ExecutionCursor,
@@ -124,6 +135,7 @@ __export(exports_operation, {
   DeleteEntityStateInput: () => DeleteEntityStateInput,
   CreateScheduleResult: () => CreateScheduleResult,
   CreateScheduleInput: () => CreateScheduleInput,
+  CreateChildFanOutInput: () => CreateChildFanOutInput,
   ConversationSummary: () => ConversationSummary,
   ConversationKind: () => ConversationKind,
   CompleteToolWorkInput: () => CompleteToolWorkInput,
@@ -134,6 +146,8 @@ __export(exports_operation, {
   CancelScheduleInput: () => CancelScheduleInput,
   CancelExecutionInput: () => CancelExecutionInput,
   CancelExecutionAccepted: () => CancelExecutionAccepted,
+  CancelChildFanOutResult: () => CancelChildFanOutResult,
+  CancelChildFanOutInput: () => CancelChildFanOutInput,
   AwaitWaitInput: () => AwaitWaitInput,
   AckEnvelopeReadyInput: () => AckEnvelopeReadyInput
 });
@@ -272,6 +286,7 @@ var WaitView = Schema.Struct({
   wait_id: exports_ids_schema.WaitId,
   execution_id: exports_ids_schema.ExecutionId,
   envelope_id: Schema.optionalKey(exports_ids_schema.EnvelopeId),
+  kind: Schema.optionalKey(exports_wait_schema.WaitKind),
   mode: exports_envelope_schema.WaitMode,
   correlation_key: Schema.optionalKey(Schema.String),
   state: WaitState,
@@ -279,6 +294,25 @@ var WaitView = Schema.Struct({
   created_at: exports_shared_schema.TimestampMillis,
   resolved_at: Schema.optionalKey(exports_shared_schema.TimestampMillis)
 }).annotate({ identifier: "Relay.Operation.WaitView" });
+var FollowStopReason = Schema.Union([
+  Schema.Struct({ _tag: Schema.tag("terminal"), status: exports_execution_schema.ExecutionStatus }),
+  Schema.Struct({ _tag: Schema.tag("actionable_wait"), wait: WaitView })
+]).annotate({ identifier: "Relay.Operation.FollowStopReason" });
+var FollowExecutionItem = Schema.Union([
+  Schema.Struct({ _tag: Schema.tag("event"), event: exports_execution_schema.ExecutionEvent }),
+  Schema.Struct({ _tag: Schema.tag("reconnecting"), message: Schema.String, attempt: Schema.Int }),
+  Schema.Struct({
+    _tag: Schema.tag("stopped"),
+    reason: FollowStopReason,
+    cursor: Schema.NullOr(exports_shared_schema.NonEmptyString)
+  })
+]).annotate({ identifier: "Relay.Operation.FollowExecutionItem" });
+var FollowExecutionInput = Schema.Struct({
+  execution_id: exports_ids_schema.ExecutionId,
+  after_cursor: Schema.optionalKey(exports_shared_schema.NonEmptyString),
+  stop_on_wait_modes: Schema.optionalKey(Schema.Array(exports_envelope_schema.WaitMode)),
+  max_reconnects: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)))
+}).annotate({ identifier: "Relay.Operation.FollowExecutionInput" });
 var PendingToolApproval = Schema.Struct({
   wait_id: exports_ids_schema.WaitId,
   execution_id: exports_ids_schema.ExecutionId,
@@ -390,6 +424,23 @@ var SpawnChildRunInput = Schema.Struct({
   input: Schema.optionalKey(Schema.Array(exports_content_schema.Part)),
   wait: Schema.optionalKey(Schema.Boolean)
 }).annotate({ identifier: "Relay.Operation.SpawnChildRunInput" });
+var CreateChildFanOutInput = exports_child_orchestration_schema.FanOutDefinition.annotate({
+  identifier: "Relay.Operation.CreateChildFanOutInput"
+});
+var CancelChildFanOutInput = Schema.Struct({
+  fan_out_id: exports_ids_schema.ChildFanOutId,
+  cancelled_at: exports_shared_schema.TimestampMillis,
+  reason: Schema.optionalKey(Schema.String)
+}).annotate({ identifier: "Relay.Operation.CancelChildFanOutInput" });
+var CancelChildFanOutResult = Schema.Struct({
+  fan_out: exports_child_orchestration_schema.FanOutState
+}).annotate({ identifier: "Relay.Operation.CancelChildFanOutResult" });
+var InspectChildFanOutInput = Schema.Struct({
+  fan_out_id: exports_ids_schema.ChildFanOutId
+}).annotate({ identifier: "Relay.Operation.InspectChildFanOutInput" });
+var InspectChildFanOutResult = Schema.Struct({
+  fan_out: Schema.NullOr(exports_child_orchestration_schema.FanOutState)
+}).annotate({ identifier: "Relay.Operation.InspectChildFanOutResult" });
 var ResolveToolApprovalInput = Schema.Struct({
   wait_id: exports_ids_schema.WaitId,
   approved: Schema.Boolean,
@@ -718,6 +769,7 @@ __export(exports_client, {
   listAddressBookRoutes: () => listAddressBookRoutes,
   layerFromRuntime: () => layerFromRuntime,
   inspectExecution: () => inspectExecution,
+  inspectChildFanOut: () => inspectChildFanOut,
   getSkillDefinition: () => getSkillDefinition,
   getSession: () => getSession,
   getPresence: () => getPresence,
@@ -727,16 +779,21 @@ __export(exports_client, {
   getAgentDefinition: () => getAgentDefinition,
   getAddressBookRoute: () => getAddressBookRoute,
   fulfillToolCall: () => fulfillToolCall,
+  followExecutionFrom: () => followExecutionFrom,
+  followExecution: () => followExecution,
   destroyEntity: () => destroyEntity,
   createSchedule: () => createSchedule,
+  createChildFanOut: () => createChildFanOut,
   completeToolWork: () => completeToolWork,
   claimToolWork: () => claimToolWork,
   claimEnvelopeReady: () => claimEnvelopeReady,
   cancelSchedule: () => cancelSchedule,
   cancelExecution: () => cancelExecution,
+  cancelChildFanOut: () => cancelChildFanOut,
   awaitWait: () => awaitWait,
   askEntity: () => askEntity,
   ackEnvelopeReady: () => ackEnvelopeReady,
+  WaitKindMismatch: () => WaitKindMismatch,
   Service: () => Service,
   ExecutionNotFound: () => ExecutionNotFound,
   EventLogCursorNotFound: () => EventLogCursorNotFound,
@@ -758,8 +815,89 @@ class ExecutionNotFound extends Schema3.TaggedErrorClass()("ExecutionNotFound",
 class EntityNamespaceReserved extends Schema3.TaggedErrorClass()("EntityNamespaceReserved", { id: Schema3.String, message: Schema3.String }) {
 }
 
+class WaitKindMismatch extends Schema3.TaggedErrorClass()("WaitKindMismatch", {
+  wait_id: exports_ids_schema.WaitId,
+  expected: Schema3.String,
+  actual: Schema3.String,
+  message: Schema3.String
+}) {
+}
+
 class Service extends Context.Service()("@relayfx/sdk/Client") {
 }
+var followTerminalStatus = (type) => type === "execution.completed" ? "completed" : type === "execution.failed" ? "failed" : type === "execution.cancelled" ? "cancelled" : undefined;
+var followReconnectDelayMillis = (attempt) => Math.min(100 * 2 ** (attempt - 1), 5000);
+var followStopped = (reason, cursor) => ({
+  _tag: "stopped",
+  reason,
+  cursor: cursor ?? null
+});
+var followExecutionFrom = (dependencies) => (input) => {
+  const maxReconnects = input.max_reconnects ?? 10;
+  const stopModes = input.stop_on_wait_modes;
+  const inspect = Effect.suspend(() => dependencies.inspectExecution(input.execution_id)).pipe(Effect.catchTag("ExecutionNotFound", (error) => new ClientError({ message: `execution ${error.execution_id} not found` })));
+  const reconcile = (state, message) => Stream.unwrap(Effect.gen(function* () {
+    const inspection = yield* inspect;
+    const terminal = followTerminalStatus(`execution.${inspection.status}`);
+    if (terminal !== undefined) {
+      return Stream.make(followStopped({ _tag: "terminal", status: terminal }, state.cursor));
+    }
+    const actionable = stopModes === undefined ? undefined : inspection.waiting_on.find((wait) => wait.state === "open" && stopModes.includes(wait.mode));
+    if (actionable !== undefined) {
+      return Stream.make(followStopped({ _tag: "actionable_wait", wait: actionable }, state.cursor));
+    }
+    if (state.attempts >= maxReconnects) {
+      return Stream.fail(new ClientError({
+        message: `follow of ${input.execution_id} exhausted ${maxReconnects} reconnects: ${message}`
+      }));
+    }
+    state.attempts += 1;
+    const reconnecting = { _tag: "reconnecting", message, attempt: state.attempts };
+    return Stream.make(reconnecting).pipe(Stream.concat(Stream.fromEffect(Effect.sleep(followReconnectDelayMillis(state.attempts))).pipe(Stream.drain)), Stream.concat(Stream.suspend(() => connect(state))));
+  }));
+  const itemsFor = (state, event) => Effect.gen(function* () {
+    if (event.sequence <= state.sequence)
+      return [];
+    state.sequence = event.sequence;
+    state.cursor = event.cursor;
+    state.emitted = true;
+    state.attempts = 0;
+    const items = [{ _tag: "event", event }];
+    const terminal = followTerminalStatus(event.type);
+    if (terminal !== undefined) {
+      items.push(followStopped({ _tag: "terminal", status: terminal }, state.cursor));
+      return items;
+    }
+    if (stopModes !== undefined && event.type === "wait.created") {
+      const mode = event.data?.mode;
+      if (typeof mode === "string" && stopModes.includes(mode)) {
+        const inspection = yield* dependencies.inspectExecution(input.execution_id).pipe(Effect.catchTag("ExecutionNotFound", () => Effect.succeed(undefined)));
+        const actionable = inspection?.waiting_on.find((wait) => wait.state === "open" && wait.wait_id === event.data?.wait_id);
+        if (actionable !== undefined) {
+          items.push(followStopped({ _tag: "actionable_wait", wait: actionable }, state.cursor));
+        }
+      }
+    }
+    return items;
+  });
+  const connect = (state) => dependencies.streamExecution({
+    execution_id: input.execution_id,
+    ...state.cursor === undefined ? {} : { after_cursor: state.cursor }
+  }).pipe(Stream.flatMap((event) => Stream.fromEffect(itemsFor(state, event)).pipe(Stream.flatMap((items) => Stream.fromIterable(items)))), Stream.catchTag("EventLogCursorNotFound", (error) => !state.emitted && input.after_cursor !== undefined ? Stream.fail(error) : reconcile(state, `cursor ${error.cursor} was not found`)), Stream.catchTag("ClientError", (error) => reconcile(state, `stream failed: ${error.message}`)), Stream.concat(Stream.suspend(() => reconcile(state, "stream ended before a terminal event"))));
+  return Stream.unwrap(Effect.gen(function* () {
+    const existing = yield* dependencies.getExecution(input.execution_id);
+    if (existing === undefined) {
+      return Stream.fail(new ClientError({ message: `execution ${input.execution_id} not found` }));
+    }
+    const state = {
+      cursor: input.after_cursor,
+      sequence: -1,
+      attempts: 0,
+      emitted: false
+    };
+    return connect(state);
+  })).pipe(Stream.takeUntil((item) => item._tag === "stopped"));
+};
 var errorMessage = (error) => {
   if (error instanceof Error)
     return error.message;
@@ -844,6 +982,12 @@ var toWaitView = (record) => ({
   wait_id: record.id,
   execution_id: record.executionId,
   ...record.envelopeId === undefined ? {} : { envelope_id: record.envelopeId },
+  kind: exports_wait_schema.classify({
+    wait_id: record.id,
+    mode: record.mode,
+    ...record.envelopeId === undefined ? {} : { envelope_id: record.envelopeId },
+    ...record.correlationKey === undefined ? {} : { correlation_key: record.correlationKey }
+  }).kind,
   mode: record.mode,
   ...record.correlationKey === undefined ? {} : { correlation_key: record.correlationKey },
   state: record.state,
@@ -1125,10 +1269,32 @@ var nextEventSequence = Effect.fn("Client.nextEventSequence")(function* (eventLo
   const max = yield* eventLog.maxSequence(executionId).pipe(Effect.mapError(toClientError));
   return max === undefined ? 0 : max + 1;
 });
-var wakeRuntime = Effect.fn("Client.wakeRuntime")(function* (waits, eventLog, executionRepository, makeExecutionClient, input) {
+var waitSemanticKind = (wait) => wait.mode === "child" ? "child" : typeof wait.metadata.kind === "string" && wait.metadata.kind.length > 0 ? wait.metadata.kind : "general";
+var terminalChildStatus = (metadata) => {
+  const status = metadata?.child_status;
+  return status === "completed" || status === "failed" || status === "cancelled";
+};
+var wakeRuntime = Effect.fn("Client.wakeRuntime")(function* (waits, eventLog, executionRepository, makeExecutionClient, input, accepts) {
   const wait = yield* waits.get(input.wait_id).pipe(Effect.mapError(toClientError));
   if (wait === undefined)
     return yield* new ClientError({ message: `Wait not found: ${input.wait_id}` });
+  const kind = waitSemanticKind(wait);
+  if (accepts !== undefined && kind !== accepts) {
+    return yield* new WaitKindMismatch({
+      wait_id: input.wait_id,
+      expected: accepts,
+      actual: kind,
+      message: `Wait ${input.wait_id} is a ${kind} wait; this resolver mutates only ${accepts} waits`
+    });
+  }
+  if (accepts === undefined && kind === "child" && !terminalChildStatus(input.metadata)) {
+    return yield* new WaitKindMismatch({
+      wait_id: input.wait_id,
+      expected: 'child wake with terminal metadata.child_status ("completed" | "failed" | "cancelled")',
+      actual: kind,
+      message: `Wait ${input.wait_id} joins a child run; wake it with terminal metadata.child_status or let the child runtime complete it`
+    });
+  }
   if (input.state === "cancelled" && wait.metadata.kind === "tool-placement") {
     return yield* new ClientError({ message: "Tool placement waits must be cancelled through cancelExecution" });
   }
@@ -1293,6 +1459,7 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
   const topicService = yield* exports_topic_service.Service;
   const toolCalls = yield* exports_tool_call_repository.Service;
   const childExecutions = yield* exports_child_execution_repository.Service;
+  const childFanOuts = yield* exports_child_fan_out_repository.Service;
   const sessionRepository = yield* exports_session_repository.Service;
   const steering = yield* exports_steering_repository.Service;
   const agentRegistry = yield* exports_agent_registry_service.Service;
@@ -1305,9 +1472,41 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
   const schedules = yield* exports_schedule_repository.Service;
   const skillRegistry = yield* exports_skill_registry_service.Service;
   const toolTransitions = yield* exports_tool_transition_coordinator.Service;
+  const workflows = yield* exports_workflow_definition_repository.Service;
+  const workflowRuntime = yield* Effect.serviceOption(exports_definition_runtime.Service);
+  const childFanOutRuntime = yield* Effect.serviceOption(exports_child_fan_out_runtime.Service);
   const schemaRegistry = yield* Effect.serviceOption(exports_schema_registry_service.Service);
   const coordinateToolTransition = (effect) => toolTransitions.coordinate(effect).pipe(Effect.mapError(toClientError));
   const coordinateChildSpawn = (effect) => toolTransitions.coordinate(effect).pipe(Effect.mapError(toClientError));
+  const cancelFanOut = Effect.fn("Client.runtime.cancelFanOut")(function* (input) {
+    if (Option.isSome(childFanOutRuntime)) {
+      const fanOut = yield* childFanOutRuntime.value.cancel(input.fan_out_id, input.cancelled_at, input.reason ?? "child fan-out cancelled").pipe(Effect.mapError(toClientError));
+      if (fanOut === undefined)
+        return yield* new ClientError({ message: `Child fan-out not found: ${input.fan_out_id}` });
+      return { fan_out: fanOut };
+    }
+    const result = yield* childFanOuts.cancel(input.fan_out_id, input.cancelled_at).pipe(Effect.mapError(toClientError));
+    if (result === undefined)
+      return yield* new ClientError({ message: `Child fan-out not found: ${input.fan_out_id}` });
+    yield* Effect.forEach(result.activeChildExecutionIds, (childId) => makeExecutionClient(exports_ids_schema.ExecutionId.make(childId)).cancel({
+      execution_id: exports_ids_schema.ExecutionId.make(childId),
+      cancelled_at: input.cancelled_at,
+      reason: input.reason ?? "child fan-out cancelled"
+    }).pipe(Effect.mapError(toClientError)), { discard: true });
+    if (result.transitioned) {
+      const max = yield* eventLog.maxSequence(result.fanOut.parent_execution_id).pipe(Effect.mapError(toClientError));
+      yield* exports_event_log_service.appendIdempotentTo(eventLog, {
+        id: exports_ids_schema.EventId.make(`event:${result.fanOut.parent_execution_id}:fan-out:${input.fan_out_id}:terminal`),
+        execution_id: result.fanOut.parent_execution_id,
+        type: "child_fan_out.terminal",
+        sequence: exports_execution_schema.ExecutionEventSequence.make(max === undefined ? 0 : max + 1),
+        cursor: `${result.fanOut.parent_execution_id}:fan-out:${input.fan_out_id}:terminal`,
+        data: { fan_out_id: input.fan_out_id, state: "cancelled" },
+        created_at: input.cancelled_at
+      }).pipe(Effect.mapError(toClientError));
+    }
+    return { fan_out: result.fanOut };
+  });
   const sendEnvelope = Effect.fn("Client.runtime.send")(function* (input) {
     const identity = input.idempotency_key ?? input.correlation_key ?? `${input.from}:${input.to}`;
     const executionId = exports_ids_schema.ExecutionId.make(input.correlation_key ?? `execution:send:${identity}`);
@@ -1345,6 +1544,34 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
     }
     return yield* waitOutcomeFrom(terminal);
   });
+  const getExecutionOperation = Effect.fn("Client.runtime.getExecution")(function* (id) {
+    const record = yield* executionRepository.get(id).pipe(Effect.mapError(toClientError));
+    return record === undefined ? undefined : toExecutionView(record);
+  });
+  const streamExecutionOperation = (input) => executions.stream({
+    executionId: input.execution_id,
+    ...input.after_cursor === undefined ? {} : { afterCursor: input.after_cursor },
+    ...input.limit === undefined ? {} : { limit: input.limit }
+  }).pipe(Stream.mapError(toStreamError));
+  const inspectExecutionOperation = Effect.fn("Client.runtime.inspectExecution")(function* (executionId) {
+    const execution = yield* executionRepository.get(executionId).pipe(Effect.mapError(toClientError));
+    if (execution === undefined)
+      return yield* new ExecutionNotFound({ execution_id: executionId });
+    const openWaits = yield* envelopeReady.listAllWaits({ executionId, state: "open" }).pipe(Effect.mapError(toClientError));
+    const calls = yield* toolCalls.listCalls(executionId).pipe(Effect.mapError(toClientError));
+    const pendingChunks = yield* Effect.forEach(calls, (call) => toolCalls.getResult(call.call.id).pipe(Effect.mapError(toClientError), Effect.map((result) => result === undefined ? [toToolCallSummary(call)] : [])));
+    const children = yield* childExecutions.listByExecution(executionId).pipe(Effect.mapError(toClientError));
+    const maxSequence = yield* eventLog.maxSequence(executionId).pipe(Effect.mapError(toClientError));
+    const lastEvent = maxSequence === undefined ? undefined : yield* eventLog.findBySequence({ executionId, sequence: maxSequence }).pipe(Effect.mapError(toClientError), Effect.map(Option.getOrUndefined));
+    return {
+      execution_id: execution.id,
+      status: execution.status,
+      waiting_on: openWaits.map(toWaitView),
+      pending_tool_calls: pendingChunks.flat(),
+      child_runs: children.map(toChildRunSummary),
+      ...lastEvent === undefined ? {} : { last_event_cursor: lastEvent.cursor }
+    };
+  });
   return Service.of({
     registerEntityKind: (input) => entityRegistry.registerKind(input).pipe(Effect.mapError(toClientError)),
     getOrCreateEntity: (input) => entities.getOrCreate({
@@ -1367,6 +1594,39 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
       ...input.after_key === undefined ? {} : { afterKey: input.after_key },
       ...input.limit === undefined ? {} : { limit: input.limit }
     }).pipe(Effect.mapError(toClientError)),
+    registerWorkflowDefinition: Effect.fn("Client.runtime.registerWorkflowDefinition")(function* (input) {
+      return { record: yield* workflows.register(input).pipe(Effect.mapError(toClientError)) };
+    }),
+    getWorkflowDefinitionRevision: Effect.fn("Client.runtime.getWorkflowDefinitionRevision")(function* (id, revision) {
+      return yield* workflows.get(id, revision).pipe(Effect.mapError(toClientError));
+    }),
+    listWorkflowDefinitionRevisions: Effect.fn("Client.runtime.listWorkflowDefinitionRevisions")(function* (id) {
+      return { records: yield* workflows.list(id).pipe(Effect.mapError(toClientError)) };
+    }),
+    startWorkflowRun: Effect.fn("Client.runtime.startWorkflowRun")(function* (input) {
+      return yield* Option.match(workflowRuntime, {
+        onNone: () => workflows.start(input),
+        onSome: (runtime) => runtime.start(input)
+      }).pipe(Effect.mapError(toClientError));
+    }),
+    inspectWorkflowRun: Effect.fn("Client.runtime.inspectWorkflowRun")(function* (id) {
+      return yield* Option.match(workflowRuntime, {
+        onNone: () => workflows.inspect(id),
+        onSome: (runtime) => runtime.inspect(id)
+      }).pipe(Effect.mapError(toClientError));
+    }),
+    replayWorkflowRun: Effect.fn("Client.runtime.replayWorkflowRun")(function* (id) {
+      return yield* Option.match(workflowRuntime, {
+        onNone: () => workflows.listLifecycle(id),
+        onSome: (runtime) => runtime.replay(id)
+      }).pipe(Effect.mapError(toClientError));
+    }),
+    cancelWorkflowRun: Effect.fn("Client.runtime.cancelWorkflowRun")(function* (id) {
+      return yield* Option.match(workflowRuntime, {
+        onNone: () => workflows.cancel(id),
+        onSome: (runtime) => runtime.cancel(id)
+      }).pipe(Effect.mapError(toClientError));
+    }),
     registerAgent: Effect.fn("Client.runtime.registerAgent")(function* (input) {
       const payload = yield* registerAgentPayload(input);
       const registered = yield* agentRegistry.register(payload).pipe(Effect.mapError(toClientError));
@@ -1437,6 +1697,12 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
       return yield* client.start(payload).pipe(Effect.mapError(toClientError));
     }),
     cancelExecution: Effect.fn("Client.runtime.cancelExecution")(function* (input) {
+      const fanOuts = yield* childFanOuts.listNonTerminal(input.execution_id).pipe(Effect.mapError(toClientError));
+      yield* Effect.forEach(fanOuts, (fanOut) => cancelFanOut({
+        fan_out_id: fanOut.fan_out_id,
+        cancelled_at: input.cancelled_at,
+        ...input.reason === undefined ? {} : { reason: input.reason }
+      }), { discard: true });
       const client = makeExecutionClient(input.execution_id);
       return yield* client.cancel({
         execution_id: input.execution_id,
@@ -1460,28 +1726,12 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
       }).pipe(Effect.mapError(toClientError));
       return { execution_id: record.executionId, kind: record.kind, sequence: record.sequence };
     }),
-    getExecution: Effect.fn("Client.runtime.getExecution")(function* (id) {
-      const record = yield* executionRepository.get(id).pipe(Effect.mapError(toClientError));
-      return record === undefined ? undefined : toExecutionView(record);
-    }),
-    inspectExecution: Effect.fn("Client.runtime.inspectExecution")(function* (executionId) {
-      const execution = yield* executionRepository.get(executionId).pipe(Effect.mapError(toClientError));
-      if (execution === undefined)
-        return yield* new ExecutionNotFound({ execution_id: executionId });
-      const openWaits = yield* envelopeReady.listAllWaits({ executionId, state: "open" }).pipe(Effect.mapError(toClientError));
-      const calls = yield* toolCalls.listCalls(executionId).pipe(Effect.mapError(toClientError));
-      const pendingChunks = yield* Effect.forEach(calls, (call) => toolCalls.getResult(call.call.id).pipe(Effect.mapError(toClientError), Effect.map((result) => result === undefined ? [toToolCallSummary(call)] : [])));
-      const children = yield* childExecutions.listByExecution(executionId).pipe(Effect.mapError(toClientError));
-      const maxSequence = yield* eventLog.maxSequence(executionId).pipe(Effect.mapError(toClientError));
-      const lastEvent = maxSequence === undefined ? undefined : yield* eventLog.findBySequence({ executionId, sequence: maxSequence }).pipe(Effect.mapError(toClientError), Effect.map(Option.getOrUndefined));
-      return {
-        execution_id: execution.id,
-        status: execution.status,
-        waiting_on: openWaits.map(toWaitView),
-        pending_tool_calls: pendingChunks.flat(),
-        child_runs: children.map(toChildRunSummary),
-        ...lastEvent === undefined ? {} : { last_event_cursor: lastEvent.cursor }
-      };
+    getExecution: getExecutionOperation,
+    inspectExecution: inspectExecutionOperation,
+    followExecution: followExecutionFrom({
+      getExecution: getExecutionOperation,
+      inspectExecution: inspectExecutionOperation,
+      streamExecution: streamExecutionOperation
     }),
     listWaits: Effect.fn("Client.runtime.listWaits")(function* (input) {
       const records = yield* envelopeReady.listWaits({
@@ -1663,11 +1913,7 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
       })));
     }),
     awaitWait: awaitWaitOperation,
-    streamExecution: (input) => executions.stream({
-      executionId: input.execution_id,
-      ...input.after_cursor === undefined ? {} : { afterCursor: input.after_cursor },
-      ...input.limit === undefined ? {} : { limit: input.limit }
-    }).pipe(Stream.mapError(toStreamError)),
+    streamExecution: streamExecutionOperation,
     streamSession: (input) => sessionStream.stream({
       sessionId: input.session_id,
       ...input.resume === undefined ? {} : {
@@ -1733,7 +1979,7 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
           approved: input.approved,
           ...input.comment === undefined ? {} : { comment: input.comment }
         }
-      });
+      }, "tool-approval");
     }),
     resolvePermission: Effect.fn("Client.runtime.resolvePermission")(function* (input) {
       return yield* wakeRuntime(waits, eventLog, executionRepository, makeExecutionClient, {
@@ -1744,7 +1990,7 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
           answer: input.answer,
           ...input.reason === undefined ? {} : { reason: input.reason }
         }
-      });
+      }, "tool-permission");
     }),
     listPendingToolCalls: Effect.fn("Client.runtime.listPendingToolCalls")(function* (input) {
       const openWaits = yield* envelopeReady.listAllWaits({
@@ -1846,6 +2092,22 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
       yield* client.dispatch(startPayload).pipe(Effect.mapError(toClientError));
       return coordinated.accepted;
     }),
+    createChildFanOut: Effect.fn("Client.runtime.createChildFanOut")(function* (input) {
+      return yield* Option.match(childFanOutRuntime, {
+        onNone: () => childFanOuts.create(input),
+        onSome: (runtime) => runtime.create(input)
+      }).pipe(Effect.mapError(toClientError));
+    }),
+    cancelChildFanOut: Effect.fn("Client.runtime.cancelChildFanOut")(function* (input) {
+      return yield* cancelFanOut(input);
+    }),
+    inspectChildFanOut: Effect.fn("Client.runtime.inspectChildFanOut")(function* (input) {
+      const fanOut = yield* Option.match(childFanOutRuntime, {
+        onNone: () => childFanOuts.get(input.fan_out_id),
+        onSome: (runtime) => runtime.inspect(input.fan_out_id)
+      }).pipe(Effect.mapError(toClientError));
+      return { fan_out: fanOut ?? null };
+    }),
     claimEnvelopeReady: Effect.fn("Client.runtime.claimEnvelopeReady")(function* (input) {
       return yield* envelopeReady.claimReady({
         routeType: input.route_type,
@@ -1910,6 +2172,11 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
 }));
 var testLayer = (implementation) => Layer.succeed(Service, Service.of({
   ...implementation,
+  followExecution: implementation.followExecution ?? followExecutionFrom({
+    getExecution: implementation.getExecution,
+    inspectExecution: implementation.inspectExecution,
+    streamExecution: implementation.streamExecution
+  }),
   registerEntityKind: implementation.registerEntityKind ?? ((input) => Effect.succeed(input)),
   getOrCreateEntity: implementation.getOrCreateEntity ?? (() => Effect.fail(new ClientError({ message: "Entity service unavailable" }))),
   getEntity: implementation.getEntity ?? (() => Effect.succeed(undefined)),
@@ -1918,7 +2185,14 @@ var testLayer = (implementation) => Layer.succeed(Service, Service.of({
   streamSession: implementation.streamSession ?? (() => Stream.empty),
   watchExecutions: implementation.watchExecutions ?? (() => Stream.empty),
   getPresence: implementation.getPresence ?? ((scope) => Effect.succeed({ scope, entries: [], observed_at: 0 })),
-  watchPresence: implementation.watchPresence ?? (() => Stream.empty)
+  watchPresence: implementation.watchPresence ?? (() => Stream.empty),
+  registerWorkflowDefinition: implementation.registerWorkflowDefinition ?? (() => Effect.die("registerWorkflowDefinition not implemented")),
+  getWorkflowDefinitionRevision: implementation.getWorkflowDefinitionRevision ?? (() => Effect.die("getWorkflowDefinitionRevision not implemented")),
+  listWorkflowDefinitionRevisions: implementation.listWorkflowDefinitionRevisions ?? (() => Effect.die("listWorkflowDefinitionRevisions not implemented")),
+  startWorkflowRun: implementation.startWorkflowRun ?? (() => Effect.die("startWorkflowRun not implemented")),
+  inspectWorkflowRun: implementation.inspectWorkflowRun ?? (() => Effect.die("inspectWorkflowRun not implemented")),
+  replayWorkflowRun: implementation.replayWorkflowRun ?? (() => Effect.die("replayWorkflowRun not implemented")),
+  cancelWorkflowRun: implementation.cancelWorkflowRun ?? (() => Effect.die("cancelWorkflowRun not implemented"))
 }));
 var registerAgentDefinition = Effect.fn("Client.registerAgentDefinition.call")(function* (input) {
   const service = yield* Service;
@@ -2065,6 +2339,7 @@ var send = Effect.fn("Client.send.call")(function* (input) {
   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) {
@@ -2120,6 +2395,18 @@ 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);