@relayfx/sdk 0.7.3 → 0.7.5

package/dist/{index-5y7758mg.js → index-6rpm95kc.js}

@@ -17,7 +17,7 @@ import {
   exports_tool_executor,
   exports_tool_output,
   exports_turn_policy
-} from "./index-qa93yf6j.js";
+} from "./index-etc2cnk2.js";
 import {
   ClientError,
   EventLogCursorNotFound,
@@ -47,7 +47,7 @@ import {
   exports_workflow_schema,
   exports_workspace_schema,
   followExecutionFrom
-} from "./index-syx9q5v3.js";
+} from "./index-nb078xsy.js";
 import {
   __export
 } from "./index-nb39b5ae.js";
@@ -1066,6 +1066,16 @@ var encodePrompt = (prompt) => {
     content: encoded.content.map((message, messageIndex) => encodeMessage(prompt, message, messageIndex))
   });
 };
+var encodePromptMessage = (message) => {
+  const encoded = encodePrompt(Prompt2.fromMessages([message]));
+  if (typeof encoded !== "object" || encoded === null || !("content" in encoded) || !Array.isArray(encoded.content)) {
+    throw new TypeError("Encoded prompt did not contain a message");
+  }
+  const value = encoded.content[0];
+  if (value === undefined)
+    throw new TypeError("Encoded prompt did not contain a message");
+  return value;
+};
 var decodePrompt = (value) => {
   const content = typeof value === "object" && value !== null && !Array.isArray(value) && "content" in value ? value.content : undefined;
   const decodedContent = Array.isArray(content) ? content.map((message) => {
@@ -1078,6 +1088,8 @@ var decodePrompt = (value) => {
         if (typeof part !== "object" || part === null || Array.isArray(part) || part.type !== "file") {
           return part;
         }
+        if (typeof part.data === "string")
+          return part;
         const data = Schema14.decodeUnknownSync(FileDataWire)(part.data);
         return {
           ...part,
@@ -1088,6 +1100,12 @@ var decodePrompt = (value) => {
   }) : content;
   return Schema14.decodeUnknownSync(Prompt2.Prompt)({ content: decodedContent });
 };
+var decodePromptMessage = (value) => {
+  const message = decodePrompt({ content: [value] }).content[0];
+  if (message === undefined)
+    throw new TypeError("Decoded prompt did not contain a message");
+  return message;
+};
 
 // ../store-sql/src/chat/agent-chat-repository.ts
 class AgentChatRepositoryError extends Schema15.TaggedErrorClass()("AgentChatRepositoryError", {
@@ -1685,6 +1703,7 @@ __export(exports_child_fan_out_repository, {
   recordTerminal: () => recordTerminal,
   memoryLayer: () => memoryLayer10,
   listNonTerminal: () => listNonTerminal,
+  listByParent: () => listByParent,
   layer: () => layer12,
   get: () => get4,
   create: () => create2,
@@ -1885,7 +1904,18 @@ var layer12 = Layer16.effect(Service18, Effect17.gen(function* () {
     }
     return states;
   });
-  return Service18.of({ create: create2, get: get4, claimAdmissions, recordTerminal, cancel, listNonTerminal });
+  const listByParent = Effect17.fn("ChildFanOutRepository.listByParent")(function* (parentExecutionId) {
+    const tenantId = yield* current();
+    const rows = yield* sql`SELECT id FROM relay_child_fan_outs WHERE tenant_id = ${tenantId} AND parent_execution_id = ${parentExecutionId} ORDER BY created_at ASC, id ASC`.pipe(Effect17.mapError(repositoryError));
+    const states = [];
+    for (const row of rows) {
+      const state = yield* load(tenantId, exports_ids_schema.ChildFanOutId.make(String(row.id))).pipe(Effect17.mapError(repositoryError));
+      if (state !== undefined)
+        states.push(state);
+    }
+    return states;
+  });
+  return Service18.of({ create: create2, get: get4, claimAdmissions, recordTerminal, cancel, listNonTerminal, listByParent });
 }));
 var memoryLayer10 = Layer16.effect(Service18, Effect17.gen(function* () {
   const records = new Map;
@@ -1978,7 +2008,8 @@ var memoryLayer10 = Layer16.effect(Service18, Effect17.gen(function* () {
     return { fanOut: globalThis.structuredClone(fanOut), transitioned, activeChildExecutionIds };
   })));
   const listNonTerminal = Effect17.fn("ChildFanOutRepository.memory.listNonTerminal")((parentExecutionId) => Effect17.sync(() => [...records.values()].filter((state) => state.state === "joining" && (parentExecutionId === undefined || state.parent_execution_id === parentExecutionId)).toSorted((left, right) => left.created_at - right.created_at || left.fan_out_id.localeCompare(right.fan_out_id)).map((state) => globalThis.structuredClone(state))));
-  return Service18.of({ create: create2, get: get4, claimAdmissions, recordTerminal, cancel, listNonTerminal });
+  const listByParent = Effect17.fn("ChildFanOutRepository.memory.listByParent")((parentExecutionId) => Effect17.sync(() => [...records.values()].filter((state) => state.parent_execution_id === parentExecutionId).toSorted((left, right) => left.created_at - right.created_at || left.fan_out_id.localeCompare(right.fan_out_id)).map((state) => globalThis.structuredClone(state))));
+  return Service18.of({ create: create2, get: get4, claimAdmissions, recordTerminal, cancel, listNonTerminal, listByParent });
 }));
 var create2 = Effect17.fn("ChildFanOutRepository.create.call")(function* (definition) {
   const repository = yield* Service18;
@@ -2004,6 +2035,10 @@ var listNonTerminal = Effect17.fn("ChildFanOutRepository.listNonTerminal.call")(
   const repository = yield* Service18;
   return yield* repository.listNonTerminal(parentExecutionId);
 });
+var listByParent = Effect17.fn("ChildFanOutRepository.listByParent.call")(function* (parentExecutionId) {
+  const repository = yield* Service18;
+  return yield* repository.listByParent(parentExecutionId);
+});
 // ../store-sql/src/cluster/cluster-registry-repository.ts
 var exports_cluster_registry_repository = {};
 __export(exports_cluster_registry_repository, {
@@ -6376,7 +6411,7 @@ var makeSessionEntryRecords = (errors) => {
     switch (input._tag) {
       case "Message":
         return {
-          message: input.message,
+          message: encodePromptMessage(input.message),
           ...input.metadata === undefined ? {} : { metadata: input.metadata }
         };
       case "ToolCall":
@@ -6402,7 +6437,7 @@ var makeSessionEntryRecords = (errors) => {
         };
       case "Steering":
         return {
-          message: input.message,
+          message: encodePromptMessage(input.message),
           ...input.metadata === undefined ? {} : { metadata: input.metadata }
         };
       case "Handoff":
@@ -6442,10 +6477,13 @@ var makeSessionEntryRecords = (errors) => {
     };
     switch (row.tag) {
       case "Message":
-        return Effect39.succeed({
-          ...base,
-          _tag: "Message",
-          message: payload.message
+        return Effect39.try({
+          try: () => ({
+            ...base,
+            _tag: "Message",
+            message: decodePromptMessage(payload.message)
+          }),
+          catch: (error5) => SessionRepositoryError.make({ message: `Invalid Session message: ${String(error5)}` })
         });
       case "ToolCall":
         return Effect39.succeed({
@@ -6473,10 +6511,13 @@ var makeSessionEntryRecords = (errors) => {
           body: String(payload.body ?? "")
         });
       case "Steering":
-        return Effect39.succeed({
-          ...base,
-          _tag: "Steering",
-          message: payload.message
+        return Effect39.try({
+          try: () => ({
+            ...base,
+            _tag: "Steering",
+            message: decodePromptMessage(payload.message)
+          }),
+          catch: (error5) => SessionRepositoryError.make({ message: `Invalid Session steering message: ${String(error5)}` })
         });
       case "Handoff":
         return Effect39.succeed({
@@ -6880,6 +6921,9 @@ var makeSessionRepository = (errors) => Effect40.gen(function* () {
   });
   const appendCheckpoint = Effect40.fn("SessionRepository.appendCheckpoint")(function* (input) {
     const tenantId = yield* current();
+    if (input.compactionCommit !== undefined && input.compactionCommit.checkpointId !== input.id) {
+      return yield* conflict4("checkpoint-id-reused", "Compaction commit checkpoint does not match entry");
+    }
     return yield* mapRepositoryError(sql.withTransaction(Effect40.gen(function* () {
       yield* lockSession(tenantId, input.sessionId);
       const session = yield* requireSession(tenantId, input.sessionId);
@@ -7157,6 +7201,9 @@ var memoryLayer26 = Layer35.sync(Service35, () => {
       return cloneEntry(desired);
     }),
     appendCheckpoint: Effect41.fn("SessionRepository.memory.appendCheckpoint")(function* (input) {
+      if (input.compactionCommit !== undefined && input.compactionCommit.checkpointId !== input.id) {
+        return yield* conflict4("checkpoint-id-reused", "Compaction commit checkpoint does not match entry");
+      }
       const session = sessions.get(input.sessionId);
       if (session === undefined)
         return yield* missingSession(input.sessionId);
@@ -11655,7 +11702,7 @@ var listRevisions3 = Effect61.fn("AgentRegistry.listRevisions.call")(function* (
 });
 
 // ../runtime/src/agent/agent-loop-service.ts
-import { Cause as Cause2, Config as Config4, Context as Context64, Crypto as Crypto3, Effect as Effect93, HashSet as HashSet7, Layer as Layer75, Option as Option24, Ref as Ref19, Schema as Schema85, Stream as Stream13 } from "effect";
+import { Cause as Cause2, Clock as Clock17, Config as Config4, Context as Context64, Crypto as Crypto3, Effect as Effect93, HashSet as HashSet7, Layer as Layer75, Option as Option24, Ref as Ref19, Schema as Schema85, Stream as Stream13 } from "effect";
 import { AiError as AiError3, Chat, LanguageModel, Prompt as Prompt7, Tokenizer, Tool as AiTool2, Toolkit as Toolkit2 } from "effect/unstable/ai";
 
 // ../runtime/src/child/child-run-service.ts
@@ -11977,6 +12024,7 @@ var childDefinition = Function12.dual(2, (parentDefinition, context) => context.
   child_run_presets: {},
   ...context.compactionPolicy === undefined ? {} : { compaction_policy: context.compactionPolicy },
   ...parentDefinition.turn_policy === undefined ? {} : { turn_policy: parentDefinition.turn_policy },
+  ...parentDefinition.tool_execution === undefined ? {} : { tool_execution: parentDefinition.tool_execution },
   ...parentDefinition.max_tool_turns === undefined ? {} : { max_tool_turns: parentDefinition.max_tool_turns },
   ...parentDefinition.max_wait_turns === undefined ? {} : { max_wait_turns: parentDefinition.max_wait_turns },
   ...parentDefinition.token_budget === undefined ? {} : { token_budget: parentDefinition.token_budget },
@@ -12143,6 +12191,7 @@ var createJoinWait = Effect64.fn("SpawnChildRunTool.createJoinWait")(function* (
 var dispatchChild = Effect64.fn("SpawnChildRunTool.dispatchChild")(function* (config, input, id, definition, waitId2) {
   yield* config.dispatch({
     executionId: exports_ids_schema.ExecutionId.make(id),
+    ...config.origin === undefined ? {} : { origin: config.origin },
     rootAddressId: input.address_id,
     sessionId: exports_execution_schema.childSessionId(id),
     input: input.input ?? [],
@@ -12156,7 +12205,9 @@ var dispatchChild = Effect64.fn("SpawnChildRunTool.dispatchChild")(function* (co
     metadata: {
       parent_execution_id: input.execution_id,
       child_execution_id: id,
-      parent_wait_id: waitId2
+      parent_wait_id: waitId2,
+      child_purpose: "child-run",
+      ...input.preset_name === undefined ? {} : { child_profile: input.preset_name }
     }
   }).pipe(Effect64.mapError((error5) => ToolRuntimeError.make({ message: String(error5) })));
 });
@@ -13530,14 +13581,20 @@ var cancelledEvent = (input) => ({
   created_at: input.cancelledAt
 });
 var updateStatus2 = Effect74.fn("ExecutionService.updateStatus")(function* (repository, id, status, updatedAt, metadata11) {
+  const current2 = yield* repository.get(id);
+  const origin = current2?.metadata[exports_execution_schema.executionOriginMetadataKey];
+  const nextMetadata = metadata11 === undefined ? undefined : {
+    ...metadata11,
+    ...origin === undefined ? {} : { [exports_execution_schema.executionOriginMetadataKey]: origin }
+  };
   const record2 = yield* repository.transition({
     id,
     status,
     updatedAt,
-    ...metadata11 === undefined ? {} : { metadata: metadata11 }
-  }).pipe(Effect74.mapError(mapRepositoryError7));
+    ...nextMetadata === undefined ? {} : { metadata: nextMetadata }
+  });
   return toExecution(record2);
-});
+}, Effect74.mapError(mapRepositoryError7));
 var layer46 = Layer61.effect(Service56, Effect74.gen(function* () {
   const repository = yield* exports_execution_repository.Service;
   const eventLog = yield* Service41;
@@ -14124,6 +14181,7 @@ var StartInput = Schema74.Struct({
   wait_id: Schema74.optionalKey(exports_ids_schema.WaitId),
   resume_suspension: Schema74.optionalKey(exports_agent_event.AgentSuspended),
   workflow_generation: Schema74.optionalKey(Schema74.Int.check(Schema74.isGreaterThanOrEqualTo(0))),
+  origin: Schema74.optionalKey(exports_execution_schema.ExecutionOrigin),
   metadata: Schema74.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.StartInput" });
 var WaitSignalState = Schema74.Literals(["resolved", "timed_out", "cancelled"]).annotate({
@@ -14277,7 +14335,12 @@ var acceptExecution = (input) => Activity.make({
       ...input.agent_revision === undefined ? {} : { agentRevision: input.agent_revision },
       ...input.agent_snapshot === undefined ? {} : { agentSnapshot: input.agent_snapshot },
       ...input.agent_tool_input_schema_digests === undefined ? {} : { agentToolInputSchemaDigests: input.agent_tool_input_schema_digests },
-      ...input.metadata === undefined ? {} : { metadata: input.metadata }
+      ...input.metadata === undefined && input.origin === undefined ? {} : {
+        metadata: {
+          ...Object.fromEntries(Object.entries(input.metadata ?? {}).filter(([key4]) => key4 !== exports_execution_schema.executionOriginMetadataKey)),
+          ...input.origin === undefined ? {} : { [exports_execution_schema.executionOriginMetadataKey]: input.origin }
+        }
+      }
     }).pipe(Effect79.mapError(mapExecutionError));
     const skillDefinitionIds = input.agent_snapshot?.skill_definition_ids ?? [];
     if (skillDefinitionIds.length > 0) {
@@ -14565,6 +14628,7 @@ var completeExecution = (input, waitId2, waitState, workspaceRuntimeLayer, turn,
     const skillDefinitionIds = input.agent_snapshot.skill_definition_ids ?? [];
     const loopProgram = agentLoop.run({
       executionId: input.execution_id,
+      ...input.origin === undefined ? {} : { origin: input.origin },
       ...input.session_id === undefined ? {} : {
         sessionId: input.session_id,
         sessionEntryScope: sessionEntryScope(input, turn)
@@ -14593,6 +14657,7 @@ var completeExecution = (input, waitId2, waitState, workspaceRuntimeLayer, turn,
         agent_revision: child.agentRevision,
         agent_snapshot: child.agentSnapshot,
         ...child.agentToolInputSchemaDigests === undefined ? {} : { agent_tool_input_schema_digests: child.agentToolInputSchemaDigests },
+        ...child.origin === undefined ? {} : { origin: child.origin },
         metadata: child.metadata
       }, { discard: true }).pipe(Effect79.provideService(WorkflowEngine.WorkflowEngine, workflowEngine), Effect79.asVoid)
     });
@@ -15987,12 +16052,169 @@ var modelMetadata = (agent) => ({
   model: agent.model.model,
   ...agent.model.registration_key === undefined ? {} : { registration_key: agent.model.registration_key }
 });
-var serviceTier = (part) => {
-  const openai = part.metadata.openai;
-  if (openai === null || typeof openai !== "object" || Array.isArray(openai))
-    return;
-  const value = openai.serviceTier;
-  return typeof value === "string" ? value : undefined;
+var usage = (value) => ({
+  input_tokens: value.inputTokens.total ?? null,
+  input_tokens_uncached: value.inputTokens.uncached ?? null,
+  input_tokens_cache_read: value.inputTokens.cacheRead ?? null,
+  input_tokens_cache_write: value.inputTokens.cacheWrite ?? null,
+  output_tokens: value.outputTokens.total ?? null,
+  output_tokens_reasoning: value.outputTokens.reasoning ?? null,
+  output_tokens_text: value.outputTokens.text ?? null
+});
+var legacyTelemetryIdentity = (event) => {
+  switch (event._tag) {
+    case "ModelAttemptStarted":
+    case "ModelAttemptCompleted":
+    case "ModelAttemptFailed":
+      return event.modelAttemptId;
+    case "ModelAttemptFirstOutput":
+      return `${event.modelAttemptId}:${event.kind}`;
+    case "ModelRetryScheduled":
+      return `${event.modelCallId}:${event.attempt}`;
+    case "CompactionStarted":
+    case "CompactionCompleted":
+    case "CompactionFailed":
+      return event.compactionId;
+    default:
+      return event.modelCallId;
+  }
+};
+var legacyTelemetryCursor = (input, event) => `${input.executionId}:telemetry:${event._tag}:${legacyTelemetryIdentity(event)}`;
+var legacyUsageCursor = (input, event) => `${input.executionId}:model-usage:${event.modelCallId}:${event.modelAttemptId}`;
+var telemetryEvent = (input, sessionId, event, sequence, createdAt) => {
+  const type = {
+    ModelCallStarted: "model.call.started",
+    ModelAttemptStarted: "model.attempt.started",
+    ModelAttemptFirstOutput: "model.attempt.first_output",
+    ModelAttemptCompleted: "model.attempt.completed",
+    ModelAttemptFailed: "model.attempt.failed",
+    ModelRetryScheduled: "model.retry.scheduled",
+    ModelCallCompleted: "model.call.completed",
+    ModelCallFailed: "model.call.failed",
+    CompactionStarted: "agent.compaction.started",
+    CompactionCompleted: "agent.compaction.completed",
+    CompactionFailed: "agent.compaction.failed"
+  }[event._tag];
+  const common = "modelCallId" in event ? {
+    turn: event.turn,
+    model_call_id: event.modelCallId,
+    telemetry_session_id: sessionId,
+    delivery_id: event.deliveryId
+  } : {
+    turn: event.turn,
+    compaction_id: event.compactionId,
+    telemetry_session_id: sessionId,
+    delivery_id: event.deliveryId
+  };
+  let data;
+  switch (event._tag) {
+    case "ModelCallStarted":
+      data = {
+        ...common,
+        purpose: event.purpose,
+        started_at: event.startedAt,
+        ...event.provider === undefined ? {} : { provider: event.provider },
+        ...event.model === undefined ? {} : { model: event.model },
+        ...event.compactionId === undefined ? {} : { compaction_id: event.compactionId }
+      };
+      break;
+    case "ModelAttemptStarted":
+      data = { ...common, model_attempt_id: event.modelAttemptId, attempt: event.attempt, started_at: event.startedAt };
+      break;
+    case "ModelAttemptFirstOutput":
+      data = {
+        ...common,
+        model_attempt_id: event.modelAttemptId,
+        attempt: event.attempt,
+        kind: event.kind,
+        at: event.at
+      };
+      break;
+    case "ModelAttemptCompleted":
+      data = {
+        ...common,
+        model_attempt_id: event.modelAttemptId,
+        attempt: event.attempt,
+        completed_at: event.completedAt,
+        ...event.usage === undefined ? {} : { usage: usage(event.usage) },
+        ...event.usageAt === undefined ? {} : { usage_at: event.usageAt },
+        ...event.finishReason === undefined ? {} : { finish_reason: event.finishReason },
+        ...event.requestId === undefined ? {} : { request_id: event.requestId },
+        ...event.responseModel === undefined ? {} : { response_model: event.responseModel },
+        ...event.serviceTier === undefined ? {} : { service_tier: event.serviceTier },
+        ...event.cost === undefined ? {} : { cost: event.cost }
+      };
+      break;
+    case "ModelAttemptFailed":
+      data = {
+        ...common,
+        model_attempt_id: event.modelAttemptId,
+        attempt: event.attempt,
+        failed_at: event.failedAt,
+        category: event.category,
+        classification: event.classification
+      };
+      break;
+    case "ModelRetryScheduled":
+      data = {
+        ...common,
+        attempt: event.attempt,
+        reason: event.reason,
+        category: event.category,
+        delay_millis: event.delayMillis,
+        at: event.at
+      };
+      break;
+    case "ModelCallCompleted":
+      data = {
+        ...common,
+        purpose: event.purpose,
+        attempts: event.attempts,
+        completed_at: event.completedAt,
+        ...event.usage === undefined ? {} : { usage: usage(event.usage) },
+        ...event.finishReason === undefined ? {} : { finish_reason: event.finishReason }
+      };
+      break;
+    case "ModelCallFailed":
+      data = {
+        ...common,
+        purpose: event.purpose,
+        attempts: event.attempts,
+        failed_at: event.failedAt,
+        category: event.category
+      };
+      break;
+    case "CompactionStarted":
+      data = {
+        ...common,
+        trigger: event.trigger,
+        started_at: event.startedAt,
+        ...event.contextTokensBefore === undefined ? {} : { context_tokens_before: event.contextTokensBefore },
+        ...event.entriesBefore === undefined ? {} : { entries_before: event.entriesBefore }
+      };
+      break;
+    case "CompactionCompleted":
+      data = {
+        ...common,
+        kind: event.kind,
+        completed_at: event.completedAt,
+        ...event.summaryModelCallId === undefined ? {} : { summary_model_call_id: event.summaryModelCallId }
+      };
+      break;
+    case "CompactionFailed":
+      data = { ...common, failed_at: event.failedAt };
+      break;
+  }
+  const cursor = `${input.executionId}:telemetry:${sessionId}:${event.deliveryId}`;
+  return {
+    id: exports_ids_schema.EventId.make(`event:${cursor}`),
+    execution_id: input.executionId,
+    type,
+    sequence,
+    cursor,
+    data,
+    created_at: createdAt
+  };
 };
 var inputPreparedEvent = (input, definitions2) => ({
   id: exports_ids_schema.EventId.make(`event:${input.executionId}:model:${input.eventSequence}:input-prepared`),
@@ -16009,28 +16231,31 @@ var inputPreparedEvent = (input, definitions2) => ({
   },
   created_at: input.startedAt
 });
-var usageReportedEvent = (input, part, modelSnapshot, sequence) => {
-  const tier = serviceTier(part);
+var usageReportedEvent = (input, sessionId, event, sequence, createdAt) => {
+  const cursor = `${input.executionId}:model-usage:${sessionId}:${event.deliveryId}`;
+  const reported = event.usage;
   return {
-    id: exports_ids_schema.EventId.make(`event:${input.executionId}:model:${sequence}:usage`),
+    id: exports_ids_schema.EventId.make(`event:${cursor}`),
     execution_id: input.executionId,
     type: "model.usage.reported",
     sequence,
-    cursor: `${input.executionId}:model:${sequence}:usage`,
+    cursor,
     data: {
+      turn: event.turn,
+      model_call_id: event.modelCallId,
+      model_attempt_id: event.modelAttemptId,
+      attempt: event.attempt,
+      telemetry_session_id: sessionId,
+      delivery_id: event.deliveryId,
       provider: input.agent.model.provider,
       model: input.agent.model.model,
-      ...modelSnapshot === undefined ? {} : { model_snapshot: modelSnapshot },
-      ...tier === undefined ? {} : { service_tier: tier },
-      finish_reason: part.reason,
-      input_tokens: part.usage.inputTokens.total ?? null,
-      input_tokens_uncached: part.usage.inputTokens.uncached ?? null,
-      input_tokens_cache_read: part.usage.inputTokens.cacheRead ?? null,
-      input_tokens_cache_write: part.usage.inputTokens.cacheWrite ?? null,
-      output_tokens: part.usage.outputTokens.total ?? null,
-      output_tokens_reasoning: part.usage.outputTokens.reasoning ?? null
+      ...event.responseModel === undefined ? {} : { model_snapshot: event.responseModel },
+      ...event.serviceTier === undefined ? {} : { service_tier: event.serviceTier },
+      ...event.finishReason === undefined ? {} : { finish_reason: event.finishReason },
+      usage_at: event.usageAt ?? event.completedAt,
+      ...usage(reported)
     },
-    created_at: input.startedAt + (sequence - input.eventSequence)
+    created_at: createdAt
   };
 };
 var budgetExceededEvent = (input, tokensUsed, tokenBudget, sequence) => ({
@@ -16049,7 +16274,7 @@ var budgetExceededEvent = (input, tokensUsed, tokenBudget, sequence) => ({
   created_at: input.startedAt + (sequence - input.eventSequence)
 });
 var outputCompletedCursor = (input, sequence) => `${input.executionId}:model:${sequence}:output-completed`;
-var outputDeltaEvent = (input, part, deltaIndex) => {
+var outputDeltaEvent = (input, modelPart, part, deltaIndex, createdAt) => {
   const sequence = input.eventSequence + 1 + deltaIndex;
   return {
     id: exports_ids_schema.EventId.make(`event:${input.executionId}:model:${sequence}:output-delta:${deltaIndex}`),
@@ -16058,12 +16283,19 @@ var outputDeltaEvent = (input, part, deltaIndex) => {
     sequence,
     cursor: `${input.executionId}:model:${sequence}:output-delta:${deltaIndex}`,
     content: [exports_content_schema.text(part.delta)],
-    data: { delta: part.delta, delta_index: deltaIndex, part_id: part.id },
-    created_at: input.startedAt + deltaIndex + 1
+    data: {
+      delta: part.delta,
+      delta_index: deltaIndex,
+      part_id: part.id,
+      model_call_id: modelPart.modelCallId,
+      model_attempt_id: modelPart.modelAttemptId,
+      attempt: modelPart.attempt
+    },
+    created_at: createdAt
   };
 };
 var reasoningText = (part) => part.type === "reasoning" ? part.text : part.delta;
-var reasoningDeltaEvent = (input, part, deltaIndex) => {
+var reasoningDeltaEvent = (input, modelPart, part, deltaIndex, createdAt) => {
   const sequence = input.eventSequence + 1 + deltaIndex;
   const delta = reasoningText(part);
   return {
@@ -16076,12 +16308,15 @@ var reasoningDeltaEvent = (input, part, deltaIndex) => {
     data: {
       delta,
       delta_index: deltaIndex,
-      ...part.type === "reasoning-delta" ? { part_id: part.id } : {}
+      ...part.type === "reasoning-delta" ? { part_id: part.id } : {},
+      model_call_id: modelPart.modelCallId,
+      model_attempt_id: modelPart.modelAttemptId,
+      attempt: modelPart.attempt
     },
-    created_at: input.startedAt + deltaIndex + 1
+    created_at: createdAt
   };
 };
-var toolCallDeltaEvent = (input, part, toolCallName, sequence, deltaIndex) => ({
+var toolCallDeltaEvent = (input, modelPart, part, toolCallName, sequence, deltaIndex, createdAt) => ({
   id: exports_ids_schema.EventId.make(`event:${input.executionId}:model:${sequence}:toolcall-delta:${part.id}:${deltaIndex}`),
   execution_id: input.executionId,
   type: "model.toolcall.delta",
@@ -16091,11 +16326,14 @@ var toolCallDeltaEvent = (input, part, toolCallName, sequence, deltaIndex) => ({
     tool_call_id: part.id,
     ...toolCallName === undefined ? {} : { tool_name: toolCallName },
     delta: part.delta,
-    delta_index: deltaIndex
+    delta_index: deltaIndex,
+    model_call_id: modelPart.modelCallId,
+    model_attempt_id: modelPart.modelAttemptId,
+    attempt: modelPart.attempt
   },
-  created_at: input.startedAt + (sequence - input.eventSequence)
+  created_at: createdAt
 });
-var outputCompletedEvent = (input, content, outputText, sequence, structuredOutput) => ({
+var outputCompletedEvent = (input, content, outputText, sequence, structuredOutput, structuredIdentity) => ({
   id: exports_ids_schema.EventId.make(`event:${input.executionId}:model:${sequence}:output-completed`),
   execution_id: input.executionId,
   type: "model.output.completed",
@@ -16104,7 +16342,12 @@ var outputCompletedEvent = (input, content, outputText, sequence, structuredOutp
   content,
   data: {
     model_output: outputText,
-    ...structuredOutput === undefined ? {} : { structured_output: structuredOutput }
+    ...structuredOutput === undefined ? {} : { structured_output: structuredOutput },
+    ...structuredIdentity === undefined ? {} : {
+      structured_output_model_call_id: structuredIdentity.modelCallId,
+      structured_output_model_attempt_id: structuredIdentity.modelAttemptId,
+      structured_output_attempt: structuredIdentity.attempt
+    }
   },
   created_at: input.completedAt
 });
@@ -16121,11 +16364,14 @@ var AgentLoopEvents = {
   budgetExceededEvent,
   completedContent,
   inputPreparedEvent,
+  legacyTelemetryCursor,
+  legacyUsageCursor,
   modelOutputMetadata,
   outputCompletedEvent,
   outputDeltaEvent,
   reasoningDeltaEvent,
   toolCallDeltaEvent,
+  telemetryEvent,
   usageReportedEvent
 };
 
@@ -16134,11 +16380,14 @@ var {
   budgetExceededEvent: budgetExceededEvent2,
   completedContent: completedContent2,
   inputPreparedEvent: inputPreparedEvent2,
+  legacyTelemetryCursor: legacyTelemetryCursor2,
+  legacyUsageCursor: legacyUsageCursor2,
   modelOutputMetadata: modelOutputMetadata2,
   outputCompletedEvent: outputCompletedEvent2,
   outputDeltaEvent: outputDeltaEvent2,
   reasoningDeltaEvent: reasoningDeltaEvent2,
   toolCallDeltaEvent: toolCallDeltaEvent2,
+  telemetryEvent: telemetryEvent2,
   usageReportedEvent: usageReportedEvent2
 } = AgentLoopEvents;
 
@@ -16212,6 +16461,7 @@ var childRunCoreTools = (input, childRuns, eventLog, waits) => {
   return Effect93.succeed([
     registeredTool({
       agent: input.agent,
+      ...input.origin === undefined ? {} : { origin: input.origin },
       agentId: input.agentId,
       agentRevision: input.agentRevision,
       ...input.agentToolInputSchemaDigests === undefined ? {} : { agentToolInputSchemaDigests: input.agentToolInputSchemaDigests },
@@ -16222,6 +16472,7 @@ var childRunCoreTools = (input, childRuns, eventLog, waits) => {
     }),
     ...transferTools({
       agent: input.agent,
+      ...input.origin === undefined ? {} : { origin: input.origin },
       agentId: input.agentId,
       agentRevision: input.agentRevision,
       ...input.agentToolInputSchemaDigests === undefined ? {} : { agentToolInputSchemaDigests: input.agentToolInputSchemaDigests },
@@ -16238,59 +16489,79 @@ var existingOutput = (eventLog, input) => eventLog.findFirstByTypeAfterSequence(
   afterSequence: input.eventSequence
 }).pipe(Effect93.map(Option24.getOrUndefined), Effect93.mapError((error5) => loopError(error5, input.eventSequence + 2)));
 var STRUCTURED_TURN_PROMPT = "Return the final structured output for the task above.";
-var runStructuredTurn = Effect93.fn("AgentLoop.runStructuredTurn")(function* (languageModels, schemas, chat, input, schemaRef, sequence) {
-  const registration = yield* schemas.resolve(schemaRef).pipe(Effect93.mapError((error5) => loopError(error5, sequence)));
-  const response = yield* languageModels.provideForAgent(input.agent, chat.generateObject({
-    prompt: STRUCTURED_TURN_PROMPT,
-    schema: registration.schema,
-    objectName: "output"
-  })).pipe(Effect93.mapError((error5) => Schema85.is(AgentLoopError)(error5) ? error5 : loopError(error5, sequence)));
-  return jsonValue6(response.value);
-});
 var loopError = (error5, nextEventSequence5) => AgentLoopError.make({
   message: error5 instanceof Error ? `${error5.name}: ${error5.message}` : String(error5),
   next_event_sequence: nextEventSequence5
 });
 var appendEvent = (eventLog, allocator, event, nextEventSequence5) => appendIdempotentTo(eventLog, event).pipe(Effect93.tap((appended) => allocator.advanceTo(appended.sequence + 1)), Effect93.mapError((error5) => loopError(error5, nextEventSequence5)));
-var compactionCommittedCursor = (executionId, checkpointId2) => `execution:${executionId}:agent-compaction:${checkpointId2}:committed`;
-var appendCompactionStartedEvent = Effect93.fn("AgentLoop.appendCompactionStartedEvent")(function* (eventLog, allocator, input, info) {
-  const cursor = `execution:${input.executionId}:agent-compaction:turn:${info.turn}:started`;
-  const existing = yield* eventLog.findByCursor({ executionId: input.executionId, cursor }).pipe(Effect93.mapError((error5) => loopError(error5, input.eventSequence + 1)));
-  if (Option24.isSome(existing))
-    return;
-  const sequence = yield* allocator.allocate(1);
-  const data = { turn: info.turn, overflow: info.overflow };
-  yield* appendEvent(eventLog, allocator, {
-    id: exports_ids_schema.EventId.make(`event:${input.executionId}:agent-compaction:turn:${info.turn}:started`),
-    execution_id: input.executionId,
-    type: "agent.compaction.started",
-    sequence,
-    cursor,
-    data,
-    created_at: input.startedAt + (sequence - input.eventSequence)
-  }, sequence + 1);
+var deliverTelemetry = Effect93.fn("AgentLoop.deliverTelemetry")(function* (eventLog, allocator, input, batch) {
+  for (const event of batch.events) {
+    const createdAt = yield* Clock17.currentTimeMillis;
+    const candidate = telemetryEvent2(input, batch.sessionId, event, 0, createdAt);
+    const existing = yield* eventLog.findByCursor({ executionId: input.executionId, cursor: candidate.cursor });
+    const legacy = yield* eventLog.findByCursor({
+      executionId: input.executionId,
+      cursor: legacyTelemetryCursor2(input, event)
+    });
+    if (Option24.isNone(existing) && Option24.isNone(legacy)) {
+      const sequence = yield* allocator.allocate(1);
+      yield* appendEvent(eventLog, allocator, { ...candidate, sequence }, sequence + 1);
+    }
+    if (event._tag === "ModelAttemptCompleted" && event.usage !== undefined) {
+      const usageCreatedAt = yield* Clock17.currentTimeMillis;
+      const usageCandidate = usageReportedEvent2(input, batch.sessionId, event, 0, usageCreatedAt);
+      const existingUsage = yield* eventLog.findByCursor({
+        executionId: input.executionId,
+        cursor: usageCandidate.cursor
+      });
+      const legacyUsage = yield* eventLog.findByCursor({
+        executionId: input.executionId,
+        cursor: legacyUsageCursor2(input, event)
+      });
+      if (Option24.isNone(existingUsage) && Option24.isNone(legacyUsage)) {
+        const sequence = yield* allocator.allocate(1);
+        yield* appendEvent(eventLog, allocator, { ...usageCandidate, sequence }, sequence + 1);
+      }
+    }
+  }
+});
+var telemetryDelivery = (eventLog, allocator, input) => exports_model_telemetry.Delivery.of({
+  deliver: (batch) => deliverTelemetry(eventLog, allocator, input, batch).pipe(Effect93.mapError((error5) => exports_model_telemetry.DeliveryFailed.make({
+    message: "Relay could not durably project model telemetry",
+    cause: error5
+  })))
 });
+var compactionCommittedCursor = (executionId, checkpointId2) => `execution:${executionId}:agent-compaction-commit:v2:${checkpointId2}`;
 var appendCompactionCommittedEvent = Effect93.fn("AgentLoop.appendCompactionCommittedEvent")(function* (eventLog, allocator, input, checkpoint) {
   if (input.sessionId === undefined)
     return;
-  const cursor = compactionCommittedCursor(input.executionId, checkpoint.id);
+  const commit = checkpoint.compactionCommit;
+  if (commit === undefined)
+    return;
+  const cursor = compactionCommittedCursor(input.executionId, exports_ids_schema.SessionEntryId.make(commit.checkpointId));
   const existing = yield* eventLog.findByCursor({ executionId: input.executionId, cursor }).pipe(Effect93.mapError((error5) => loopError(error5, input.eventSequence + 1)));
   if (Option24.isSome(existing))
     return;
   const sequence = yield* allocator.allocate(1);
+  const createdAt = yield* Clock17.currentTimeMillis;
   const data = {
-    checkpoint_id: exports_ids_schema.SessionEntryId.make(checkpoint.id),
+    checkpoint_id: exports_ids_schema.SessionEntryId.make(commit.checkpointId),
     session_id: input.sessionId,
-    summary_present: checkpoint.summary !== undefined
+    compaction_id: commit.compactionId,
+    ...commit.summaryModelCallId === undefined ? {} : { summary_model_call_id: commit.summaryModelCallId },
+    ...commit.contextTokensBefore === undefined ? {} : { context_tokens_before: commit.contextTokensBefore },
+    ...commit.contextTokensAfter === undefined ? {} : { context_tokens_after: commit.contextTokensAfter },
+    ...commit.entriesBefore === undefined ? {} : { entries_before: commit.entriesBefore },
+    ...commit.entriesAfter === undefined ? {} : { entries_after: commit.entriesAfter }
   };
   yield* appendEvent(eventLog, allocator, {
-    id: exports_ids_schema.EventId.make(`event:${input.executionId}:agent-compaction:${checkpoint.id}:committed`),
+    id: exports_ids_schema.EventId.make(`event:${input.executionId}:agent-compaction-commit:v2:${commit.checkpointId}`),
     execution_id: input.executionId,
     type: "agent.compaction.committed",
     sequence,
     cursor,
     data,
-    created_at: input.startedAt + (sequence - input.eventSequence)
+    created_at: createdAt
   }, sequence + 1);
 });
 var toolFromDefinition = (definition) => AiTool2.dynamic(definition.name, {
@@ -16327,7 +16598,7 @@ var restoreHistory = Effect93.fn("AgentLoop.restoreHistory")(function* (chats, i
   return history;
 });
 var promptEquivalence = Schema85.toEquivalence(Prompt7.Prompt);
-var reconcileCompactionCheckpoint = Effect93.fn("AgentLoop.reconcileCompactionCheckpoint")(function* (sessions, chats, input, restoredHistory, onCheckpointCommitted, failOnMismatch = false) {
+var reconcileCompactionCheckpoint = Effect93.fn("AgentLoop.reconcileCompactionCheckpoint")(function* (sessions, chats, eventLog, allocator, input, restoredHistory, onCheckpointCommitted, failOnMismatch = false) {
   if (input.sessionId === undefined)
     return restoredHistory;
   const path2 = yield* sessions.path({ sessionId: input.sessionId }).pipe(Effect93.mapError((error5) => loopError(error5, input.eventSequence + 1)));
@@ -16342,6 +16613,10 @@ var reconcileCompactionCheckpoint = Effect93.fn("AgentLoop.reconcileCompactionCh
     checkpoint,
     leafId: checkpoint.id
   };
+  yield* deliverTelemetry(eventLog, allocator, input, {
+    sessionId: input.sessionId,
+    events: checkpoint.telemetry
+  }).pipe(Effect93.mapError((error5) => loopError(error5, input.eventSequence + 1)));
   const repaired = exports_session.buildContext(path2);
   if (restoredHistory === undefined) {
     yield* persistTranscript(chats, input, repaired);
@@ -16603,7 +16878,7 @@ var make12 = (layerOptions) => Effect93.gen(function* () {
       };
       const storedHistory = resumeToolCall === undefined ? yield* loadStoredHistory(chats, input) : yield* restoreHistory(chats, input);
       const onCheckpointCommitted = (result) => appendCompactionCommittedEvent(eventLog, allocator, input, result.checkpoint).pipe(Effect93.andThen(layerOptions?.onCheckpointCommitted?.(result) ?? Effect93.void));
-      const durableHistory = Option24.isNone(sessionRepository) ? storedHistory : yield* reconcileCompactionCheckpoint(sessionRepository.value, chats, input, storedHistory, onCheckpointCommitted, resumeSuspension === undefined);
+      const durableHistory = Option24.isNone(sessionRepository) ? storedHistory : yield* reconcileCompactionCheckpoint(sessionRepository.value, chats, eventLog, allocator, input, storedHistory, onCheckpointCommitted, resumeSuspension === undefined);
       const continuingDurableHistory = durableHistory !== undefined;
       const permissionsLayer = input.agent.permission_rules === undefined ? Layer75.empty : Option24.isNone(permissionRules) || Option24.isNone(waits) ? yield* AgentLoopError.make({
         message: "Execution permission rules require PermissionRuleRepository and WaitService in context",
@@ -16693,11 +16968,20 @@ var make12 = (layerOptions) => Effect93.gen(function* () {
           next_event_sequence: input.eventSequence + 1
         });
       }
+      const schemaRef = input.agent.output_schema_ref;
+      const structuredRegistration = schemaRef === undefined ? undefined : yield* schemas.resolve(schemaRef).pipe(Effect93.mapError((error5) => loopError(error5, input.eventSequence + 1)));
       const batonCompaction = compactionPolicy === undefined ? undefined : { contextWindow: compactionPolicy.context_window };
       const batonOptions = {
         ...options,
         ...toolOutputMaxBytes === undefined ? {} : { toolOutputMaxBytes },
-        ...batonCompaction === undefined ? {} : { compaction: batonCompaction }
+        ...batonCompaction === undefined ? {} : { compaction: batonCompaction },
+        ...structuredRegistration === undefined ? {} : {
+          output: {
+            schema: structuredRegistration.schema,
+            name: "output",
+            prompt: STRUCTURED_TURN_PROMPT
+          }
+        }
       };
       const batonMemory = memory === undefined || Option24.isNone(durableMemory) ? undefined : recallOnlyMemory(durableMemory.value);
       const executorLayer = layer56({
@@ -16717,8 +17001,7 @@ var make12 = (layerOptions) => Effect93.gen(function* () {
       const compactionService = activeCompactionOptions === undefined ? undefined : exports_compaction.Compaction.of(make8({
         executionId: input.executionId,
         repository: activeCompactionRepository,
-        options: activeCompactionOptions,
-        onSummarizeStarted: (info) => appendCompactionStartedEvent(eventLog, allocator, input, info).pipe(Effect93.mapError((error5) => exports_compaction.CompactionError.make({ message: error5.message, cause: error5 })))
+        options: activeCompactionOptions
       }));
       if (memory !== undefined && Option24.isNone(durableMemory)) {
         return yield* AgentLoopError.make({
@@ -16738,18 +17021,55 @@ var make12 = (layerOptions) => Effect93.gen(function* () {
       });
       const foldEvent = (state, event) => Effect93.gen(function* () {
         switch (event._tag) {
+          case "ModelCallStarted":
+          case "ModelAttemptStarted":
+          case "ModelAttemptFirstOutput":
+          case "ModelAttemptCompleted":
+          case "ModelAttemptFailed":
+          case "ModelRetryScheduled":
+          case "ModelCallCompleted":
+          case "ModelCallFailed":
+          case "CompactionStarted":
+          case "CompactionCompleted":
+          case "CompactionFailed": {
+            const createdAt = yield* Clock17.currentTimeMillis;
+            const candidate = telemetryEvent2(input, input.sessionId ?? input.executionId, event, 0, createdAt);
+            const existingTelemetry = yield* eventLog.findByCursor({
+              executionId: input.executionId,
+              cursor: candidate.cursor
+            });
+            if (Option24.isNone(existingTelemetry)) {
+              const sequence = yield* allocator.allocate(1);
+              yield* appendEvent(eventLog, allocator, { ...candidate, sequence }, sequence + 1);
+            }
+            if (event._tag === "ModelAttemptCompleted" && event.usage !== undefined) {
+              const usageCreatedAt = yield* Clock17.currentTimeMillis;
+              const usageCandidate = usageReportedEvent2(input, input.sessionId ?? input.executionId, event, 0, usageCreatedAt);
+              const existingUsage = yield* eventLog.findByCursor({
+                executionId: input.executionId,
+                cursor: usageCandidate.cursor
+              });
+              if (Option24.isNone(existingUsage)) {
+                const usageSequence = yield* allocator.allocate(1);
+                yield* appendEvent(eventLog, allocator, { ...usageCandidate, sequence: usageSequence }, usageSequence + 1);
+              }
+            }
+            return state;
+          }
           case "ModelPart": {
             const part = event.part;
             if (part.type === "text-delta") {
               const sequence = yield* allocator.allocate(1);
               const deltaIndex = sequence - input.eventSequence - 1;
-              yield* appendEvent(eventLog, allocator, outputDeltaEvent2(input, part, deltaIndex), sequence + 1);
+              const createdAt = yield* Clock17.currentTimeMillis;
+              yield* appendEvent(eventLog, allocator, outputDeltaEvent2(input, event, part, deltaIndex, createdAt), sequence + 1);
               return { ...state, text: `${state.text}${part.delta}` };
             }
             if (part.type === "reasoning" || part.type === "reasoning-delta") {
               const sequence = yield* allocator.allocate(1);
               const deltaIndex = sequence - input.eventSequence - 1;
-              yield* appendEvent(eventLog, allocator, reasoningDeltaEvent2(input, part, deltaIndex), sequence + 1);
+              const createdAt = yield* Clock17.currentTimeMillis;
+              yield* appendEvent(eventLog, allocator, reasoningDeltaEvent2(input, event, part, deltaIndex, createdAt), sequence + 1);
               return state;
             }
             if (part.type === "tool-params-start") {
@@ -16760,7 +17080,8 @@ var make12 = (layerOptions) => Effect93.gen(function* () {
             if (part.type === "tool-params-delta") {
               const sequence = yield* allocator.allocate(1);
               const deltaIndex = state.toolCallDeltaIndexes[part.id] ?? 0;
-              yield* appendEvent(eventLog, allocator, toolCallDeltaEvent2(input, part, state.toolCallNames[part.id], sequence, deltaIndex), sequence + 1);
+              const createdAt = yield* Clock17.currentTimeMillis;
+              yield* appendEvent(eventLog, allocator, toolCallDeltaEvent2(input, event, part, state.toolCallNames[part.id], sequence, deltaIndex, createdAt), sequence + 1);
               return {
                 ...state,
                 toolCallDeltaIndexes: { ...state.toolCallDeltaIndexes, [part.id]: deltaIndex + 1 }
@@ -16768,8 +17089,6 @@ var make12 = (layerOptions) => Effect93.gen(function* () {
             }
             if (part.type === "finish") {
               const finish = part;
-              const sequence = yield* allocator.allocate(1);
-              yield* appendEvent(eventLog, allocator, usageReportedEvent2(input, finish, state.modelId, sequence), sequence + 1);
               yield* recordModelUsage({
                 provider: input.agent.model.provider,
                 model: input.agent.model.model,
@@ -16798,6 +17117,17 @@ var make12 = (layerOptions) => Effect93.gen(function* () {
           case "Completed": {
             return { ...state, text: event.text, transcript: event.transcript, turn: event.turns - 1 };
           }
+          case "StructuredOutput": {
+            return {
+              ...state,
+              structuredOutput: jsonValue6(event.value),
+              structuredIdentity: {
+                modelCallId: event.modelCallId,
+                modelAttemptId: event.modelAttemptId,
+                attempt: event.attempt
+              }
+            };
+          }
           default:
             return state;
         }
@@ -16809,7 +17139,7 @@ var make12 = (layerOptions) => Effect93.gen(function* () {
           onCheckpointCommitted: (result) => onCheckpointCommitted(result).pipe(Effect93.orDie),
           ...sessionWriter === undefined ? {} : { writer: sessionWriter }
         }).pipe(Effect93.provideService(exports_session_repository.Service, sessionRepository.value)) : undefined;
-        const foldContext = yield* Layer75.build(Layer75.mergeAll(executorLayer, handlerLayer, approvalsLayer, exports_model_middleware.layerIdentity, instructionsLayer, permissionsLayer, steeringLayer));
+        const foldContext = yield* Layer75.build(Layer75.mergeAll(executorLayer, handlerLayer, approvalsLayer, exports_model_middleware.layerIdentity, instructionsLayer, permissionsLayer, steeringLayer, Layer75.succeed(exports_model_telemetry.Delivery, telemetryDelivery(eventLog, allocator, input))));
         const folded = exports_agent.stream(agent, batonOptions).pipe(Stream13.runFoldEffect(() => ({
           text: "",
           transcript: undefined,
@@ -16837,10 +17167,9 @@ var make12 = (layerOptions) => Effect93.gen(function* () {
           yield* durableMemory.value.remember({ key: memory.key, turn: finalState.turn ?? 0, transcript, terminal: true }).pipe(Effect93.mapError((error5) => loopError(error5, completedSequence + 1)));
         }
       }
-      const schemaRef = input.agent.output_schema_ref;
-      const structuredOutput = schemaRef === undefined || finalState.transcript === undefined ? undefined : yield* Chat.fromPrompt(finalState.transcript).pipe(Effect93.flatMap((chat) => runStructuredTurn(languageModels, schemas, chat, input, schemaRef, completedSequence + 1)));
+      const structuredOutput = finalState.structuredOutput;
       const structuredPart = structuredOutput === undefined || schemaRef === undefined ? [] : [{ type: "structured", value: structuredOutput, schema_ref: schemaRef }];
-      yield* appendEvent(eventLog, allocator, outputCompletedEvent2(input, [...completedContent2(finalState.text), ...structuredPart], finalState.text, completedSequence, structuredOutput), completedSequence + 1);
+      yield* appendEvent(eventLog, allocator, outputCompletedEvent2(input, [...completedContent2(finalState.text), ...structuredPart], finalState.text, completedSequence, structuredOutput, finalState.structuredIdentity), completedSequence + 1);
       return {
         metadata: {
           model_output: finalState.text,
@@ -17145,7 +17474,7 @@ var layerFromServices2 = Layer79.effect(Service68, Effect97.gen(function* () {
 }));
 
 // ../runtime/src/schedule/scheduler-service.ts
-import { Clock as Clock17, Config as Config7, Context as Context69, Cron, DateTime as DateTime2, Duration as Duration6, Effect as Effect98, Layer as Layer80, Option as Option25, Random as Random3, Result as Result3, Schema as Schema91 } from "effect";
+import { Clock as Clock18, Config as Config7, Context as Context69, Cron, DateTime as DateTime2, Duration as Duration6, Effect as Effect98, Layer as Layer80, Option as Option25, Random as Random3, Result as Result3, Schema as Schema91 } from "effect";
 class SchedulerError extends Schema91.TaggedErrorClass()("SchedulerError", {
   message: Schema91.String
 }) {
@@ -17270,7 +17599,7 @@ var make13 = Effect98.gen(function* () {
   const runOnce2 = Effect98.gen(function* () {
     let dispatched = 0;
     while (true) {
-      const now = yield* Clock17.currentTimeMillis;
+      const now = yield* Clock18.currentTimeMillis;
       const claimed = yield* schedules.claimDue({ workerId, now, claimExpiresAt: now + claimTtlMillis }).pipe(Effect98.mapError(toSchedulerError));
       if (claimed === undefined)
         return dispatched;
@@ -17671,7 +18000,7 @@ var check = Effect99.fn("RunnerRuntime.check.call")(function* () {
 });
 
 // ../runtime/src/workflow/definition-runtime.ts
-import { Cause as Cause3, Clock as Clock18, Context as Context71, Effect as Effect100, Exit as Exit2, FiberMap as FiberMap2, Layer as Layer82, Option as Option27, Schema as Schema93 } from "effect";
+import { Cause as Cause3, Clock as Clock19, Context as Context71, Effect as Effect100, Exit as Exit2, FiberMap as FiberMap2, Layer as Layer82, Option as Option27, Schema as Schema93 } from "effect";
 import { dual as dual2 } from "effect/Function";
 
 class UnsupportedOperation extends Schema93.TaggedErrorClass()("UnsupportedWorkflowOperation", { operation_id: exports_ids_schema.WorkflowOperationId, kind: Schema93.String }) {
@@ -17736,7 +18065,7 @@ var run6 = Effect100.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
     yield* repository.appendLifecycle({
       execution_id: executionId,
       type: "workflow.started",
-      created_at: yield* Clock18.currentTimeMillis
+      created_at: yield* Clock19.currentTimeMillis
     });
   const byId = new Map(revision.definition.operations.map((operation) => [operation.id, operation]));
   const execute = (id) => Effect100.gen(function* () {
@@ -17749,7 +18078,7 @@ var run6 = Effect100.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
     const operation = byId.get(id);
     if (operation === undefined)
       return yield* Effect100.die(new Error(`validated workflow operation missing: ${id}`));
-    const startedAt = persisted?.started_at ?? (yield* Clock18.currentTimeMillis);
+    const startedAt = persisted?.started_at ?? (yield* Clock19.currentTimeMillis);
     const sideEffectContext = {
       execution_id: executionId,
       operation_id: id,
@@ -17791,7 +18120,7 @@ var run6 = Effect100.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
           return yield* UnsupportedOperation.make({ operation_id: operation.id, kind: operation.kind });
         const fanOutId = persisted?.fan_out_id ?? fanOutIdFor(executionId, operation.fan_out_key);
         if (persisted?.fan_out_id === undefined) {
-          const now = yield* Clock18.currentTimeMillis;
+          const now = yield* Clock19.currentTimeMillis;
           yield* repository.putOperation({
             execution_id: executionId,
             operation_id: id,
@@ -17849,7 +18178,7 @@ var run6 = Effect100.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
           return yield* Effect100.die(new Error(`workflow fan-out state missing: ${operation.parallel_operation}`));
         const fanOut = yield* handlers.inspectChildFanOut(parallelState.fan_out_id);
         if (fanOut === undefined || fanOut.state === "joining") {
-          const now = yield* Clock18.currentTimeMillis;
+          const now = yield* Clock19.currentTimeMillis;
           yield* repository.putOperation({
             execution_id: executionId,
             operation_id: id,
@@ -17892,7 +18221,7 @@ var run6 = Effect100.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
         break;
       case "branch": {
         const decision = persisted?.decision ?? (yield* handlers.branch(executionId, operation, sideEffectContext));
-        const now = yield* Clock18.currentTimeMillis;
+        const now = yield* Clock19.currentTimeMillis;
         yield* repository.putOperation({
           execution_id: executionId,
           operation_id: id,
@@ -17911,7 +18240,7 @@ var run6 = Effect100.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
         let attempt = persisted?.attempt ?? 0;
         while (attempt < operation.max_attempts) {
           if (persisted?.backoff_until !== undefined) {
-            const remaining = persisted.backoff_until - (yield* Clock18.currentTimeMillis);
+            const remaining = persisted.backoff_until - (yield* Clock19.currentTimeMillis);
             if (remaining > 0)
               yield* Effect100.sleep(`${remaining} millis`);
           }
@@ -17923,7 +18252,7 @@ var run6 = Effect100.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
           attempt += 1;
           if (attempt >= operation.max_attempts)
             return yield* result2;
-          const now = yield* Clock18.currentTimeMillis;
+          const now = yield* Clock19.currentTimeMillis;
           const backoffUntil = now + attempt * 1000;
           yield* repository.putOperation({
             execution_id: executionId,
@@ -17946,9 +18275,9 @@ var run6 = Effect100.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
       }
       case "budget": {
         const states = yield* repository.listOperations(executionId);
-        const used = operation.unit === "milliseconds" ? (yield* Clock18.currentTimeMillis) - startedAt : states.filter((state) => state.status === "completed").length;
+        const used = operation.unit === "milliseconds" ? (yield* Clock19.currentTimeMillis) - startedAt : states.filter((state) => state.status === "completed").length;
         if (used >= operation.limit) {
-          const now = yield* Clock18.currentTimeMillis;
+          const now = yield* Clock19.currentTimeMillis;
           yield* repository.appendLifecycle({
             execution_id: executionId,
             operation_id: id,
@@ -17973,18 +18302,18 @@ var run6 = Effect100.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
           ...output2 === undefined ? {} : { output: output2 },
           compensation_operation_id: operation.compensate_with,
           started_at: startedAt,
-          updated_at: yield* Clock18.currentTimeMillis
+          updated_at: yield* Clock19.currentTimeMillis
         });
         yield* repository.appendLifecycle({
           execution_id: executionId,
           operation_id: id,
           type: "compensation.recorded",
           data: { compensate_with: operation.compensate_with },
-          created_at: yield* Clock18.currentTimeMillis
+          created_at: yield* Clock19.currentTimeMillis
         });
         break;
     }
-    const completedAt = yield* Clock18.currentTimeMillis;
+    const completedAt = yield* Clock19.currentTimeMillis;
     const current2 = yield* repository.getOperation(executionId, id);
     yield* repository.putOperation({
       execution_id: executionId,
@@ -18020,15 +18349,15 @@ var run6 = Effect100.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
     for (const state of compensationStack) {
       if (state.compensation_operation_id === undefined || state.status === "compensated")
         continue;
-      yield* repository.putOperation({ ...state, status: "compensating", updated_at: yield* Clock18.currentTimeMillis });
+      yield* repository.putOperation({ ...state, status: "compensating", updated_at: yield* Clock19.currentTimeMillis });
       yield* repository.appendLifecycle({
         execution_id: executionId,
         operation_id: state.operation_id,
         type: "compensation.started",
-        created_at: yield* Clock18.currentTimeMillis
+        created_at: yield* Clock19.currentTimeMillis
       });
       yield* execute(state.compensation_operation_id);
-      const completedAt = yield* Clock18.currentTimeMillis;
+      const completedAt = yield* Clock19.currentTimeMillis;
       yield* repository.putOperation({
         ...state,
         status: "compensated",
@@ -18080,7 +18409,7 @@ var layerFromRuntime2 = Layer82.effect(Service71, Effect100.gen(function* () {
 }));
 
 // src/runtime.ts
-import { Cause as Cause5, Context as Context74, Effect as Effect112, Layer as Layer86, Option as Option31, Schema as Schema101 } from "effect";
+import { Cause as Cause5, Context as Context74, Effect as Effect112, Layer as Layer86, Option as Option32, Schema as Schema103 } from "effect";
 import { SqlClient as SqlClient31 } from "effect/unstable/sql/SqlClient";
 
 // src/runtime-acquisition-error.ts
@@ -18162,7 +18491,7 @@ var renderConfigurationError = (error5) => {
   return `Runtime configuration error [${error5.category}/${error5.scope}]: ${remediation}; causes=${reasons}${error5.cause.truncated ? ",truncated" : ""}`;
 };
 // src/internal-client.ts
-import { Clock as Clock19, Effect as Effect109, Layer as Layer84, Option as Option30, Random as Random4, Schema as Schema100, Stream as Stream17 } from "effect";
+import { Clock as Clock20, Effect as Effect109, Layer as Layer84, Option as Option31, Random as Random4, Schema as Schema102, Stream as Stream17 } from "effect";
 import { EntityId, ShardId, Sharding as Sharding2, ShardingConfig as ShardingConfig3 } from "effect/unstable/cluster";
 
 // src/runtime-capability-policy.ts
@@ -18302,7 +18631,7 @@ var registerAgentPayload = Effect102.fn("Client.agents.registerPayload")(functio
 });
 
 // src/client-child-runs.ts
-import { Effect as Effect104, Option as Option29 } from "effect";
+import { Effect as Effect104, Option as Option29, Schema as Schema98 } from "effect";
 
 // src/client-event-sequence.ts
 import { Effect as Effect103 } from "effect";
@@ -18418,7 +18747,8 @@ var parentDefinitionPin = Effect104.fn("Client.parentDefinitionPin")(function* (
     agentId: record2.agentId,
     agentRevision: record2.agentRevision,
     agentSnapshot: record2.agentSnapshot,
-    ...record2.agentToolInputSchemaDigests === undefined ? {} : { agentToolInputSchemaDigests: record2.agentToolInputSchemaDigests }
+    ...record2.agentToolInputSchemaDigests === undefined ? {} : { agentToolInputSchemaDigests: record2.agentToolInputSchemaDigests },
+    ...Schema98.decodeUnknownOption(exports_execution_schema.ExecutionOrigin)(record2.metadata[exports_execution_schema.executionOriginMetadataKey]).pipe(Option29.match({ onNone: () => ({}), onSome: (origin) => ({ origin }) }))
   };
 });
 var childStartInput = (input, accepted2, pin, definition, createdAt, parentWaitId) => ({
@@ -18433,21 +18763,27 @@ var childStartInput = (input, accepted2, pin, definition, createdAt, parentWaitI
   agent_revision: pin.agentRevision,
   agent_snapshot: definition,
   ...pin.agentToolInputSchemaDigests === undefined ? {} : { agent_tool_input_schema_digests: pin.agentToolInputSchemaDigests },
+  ...pin.origin === undefined ? {} : { origin: pin.origin },
   metadata: {
+    ...input.metadata,
     parent_execution_id: input.execution_id,
     child_execution_id: accepted2.child_execution_id,
+    child_purpose: "child-run",
+    ...input.preset_name === undefined ? {} : { child_profile: input.preset_name },
+    ...pin.origin === undefined ? {} : { [exports_execution_schema.executionOriginMetadataKey]: pin.origin },
     ...parentWaitId === undefined ? {} : { parent_wait_id: parentWaitId }
   }
 });
 var childRunInternals = { childStartInput, internalSpawnChildRunInput };
 
 // src/client-execution-payloads.ts
-import { Effect as Effect105, Schema as Schema98 } from "effect";
-var encodeExecutionCursor = (cursor) => Schema98.encodeEffect(exports_pagination_schema.ExecutionCursorCodec)({ id: cursor.id, at: cursor.updatedAt }).pipe(Effect105.mapError(toClientError));
+import { Effect as Effect105, Schema as Schema99 } from "effect";
+var encodeExecutionCursor = (cursor) => Schema99.encodeEffect(exports_pagination_schema.ExecutionCursorCodec)({ id: cursor.id, at: cursor.updatedAt }).pipe(Effect105.mapError(toClientError));
 var executionIdFromIdempotencyKey = (idempotencyKey) => exports_ids_schema.ExecutionId.make(`execution:${idempotencyKey}`);
-var metadataWithIdempotencyKey = (metadata11, idempotencyKey) => ({
+var metadataWithIdempotencyKey = (metadata11, idempotencyKey, origin) => ({
   ...metadata11,
-  idempotency_key: idempotencyKey
+  idempotency_key: idempotencyKey,
+  ...origin === undefined ? {} : { [exports_execution_schema.executionOriginMetadataKey]: origin }
 });
 var startExecutionByAddressPayload = (input) => ({
   execution_id: input.execution_id ?? executionIdFromIdempotencyKey(input.idempotency_key),
@@ -18458,7 +18794,8 @@ var startExecutionByAddressPayload = (input) => ({
   started_at: input.started_at,
   completed_at: input.completed_at,
   ...input.wait_id === undefined ? {} : { wait_id: input.wait_id },
-  metadata: metadataWithIdempotencyKey(input.metadata, input.idempotency_key)
+  ...input.origin === undefined ? {} : { origin: input.origin },
+  metadata: metadataWithIdempotencyKey(input.metadata, input.idempotency_key, input.origin)
 });
 var startExecutionByAgentDefinitionPayload = (input, definition) => ({
   execution_id: input.execution_id ?? executionIdFromIdempotencyKey(input.idempotency_key),
@@ -18473,7 +18810,8 @@ var startExecutionByAgentDefinitionPayload = (input, definition) => ({
   agent_snapshot: definition.definition,
   ...definition.tool_input_schema_digests === undefined ? {} : { agent_tool_input_schema_digests: definition.tool_input_schema_digests },
   ...input.wait_id === undefined ? {} : { wait_id: input.wait_id },
-  metadata: metadataWithIdempotencyKey(input.metadata, input.idempotency_key)
+  ...input.origin === undefined ? {} : { origin: input.origin },
+  metadata: metadataWithIdempotencyKey(input.metadata, input.idempotency_key, input.origin)
 });
 var executionPayloadInternals = { startExecutionByAgentDefinitionPayload };
 
@@ -18560,9 +18898,9 @@ var wakeRuntime = Effect107.fn("Client.waits.wakeRuntime")(function* (waits, eve
 var runtimeWakeInternals = { wakeRuntime };
 
 // src/client-tool-outcome.ts
-import { Effect as Effect108, Schema as Schema99 } from "effect";
+import { Effect as Effect108, Schema as Schema100 } from "effect";
 var toolWaitId = (executionId, callId) => Identifiers.waitId("tool", executionId, callId);
-var acceptedWaitOutcome = (wait) => Schema99.decodeUnknownEffect(exports_tool_schema.ExternalOutcome)(wait.metadata.external_outcome).pipe(Effect108.mapError(toClientError));
+var acceptedWaitOutcome = (wait) => Schema100.decodeUnknownEffect(exports_tool_schema.ExternalOutcome)(wait.metadata.external_outcome).pipe(Effect108.mapError(toClientError));
 var resolveToolOutcomeWait = Effect108.fn("Client.resolveToolOutcomeWait")(function* (waits, eventLog, call, outcome, completedAt) {
   const waitId2 = call.waitId ?? toolWaitId(call.executionId, call.call.id);
   const wait = yield* waits.get(waitId2).pipe(Effect108.mapError(toClientError));
@@ -18608,6 +18946,7 @@ var signalToolOutcome = Effect108.fn("Client.signalToolOutcome")(function* (exec
 var toolOutcomeInternals = { signalToolOutcome };
 
 // src/client-view-mappers.ts
+import { Option as Option30, Schema as Schema101 } from "effect";
 var conversationKind = (metadata11) => metadata11.kind === "agent-agent" ? "agent-agent" : "user-agent";
 var toConversationSummary = (record2) => ({
   execution_id: record2.id,
@@ -18629,6 +18968,7 @@ var toExecutionView = (record2) => ({
   ...record2.agentRevision === undefined ? {} : { agent_revision: record2.agentRevision },
   ...record2.agentSnapshot === undefined ? {} : { agent_snapshot: record2.agentSnapshot },
   ...record2.agentToolInputSchemaDigests === undefined ? {} : { agent_tool_input_schema_digests: record2.agentToolInputSchemaDigests },
+  ...Schema101.decodeUnknownOption(exports_execution_schema.ExecutionOrigin)(record2.metadata[exports_execution_schema.executionOriginMetadataKey]).pipe(Option30.match({ onNone: () => ({}), onSome: (origin) => ({ origin }) })),
   metadata: record2.metadata,
   created_at: record2.createdAt,
   updated_at: record2.updatedAt
@@ -18836,14 +19176,14 @@ var groupImplementation = (implementation) => ({
 var rejectReserved = (id, prefix) => id.startsWith(prefix) ? Effect109.fail(ResidentNamespaceReserved.make({ id, message: "start residents via Client.residents.spawn" })) : Effect109.void;
 var replyValueFrom = (content) => {
   if (content === undefined || content.length === 0)
-    return Option30.none();
+    return Option31.none();
   const structured = content.find((part) => part.type === "structured");
   if (structured !== undefined)
-    return Option30.some(structured.value);
+    return Option31.some(structured.value);
   const text = content.filter((part) => part.type === "text").map((part) => part.text).join("");
   if (text.length === 0)
-    return Option30.none();
-  return Schema100.decodeUnknownOption(Schema100.UnknownFromJsonString)(text);
+    return Option31.none();
+  return Schema102.decodeUnknownOption(Schema102.UnknownFromJsonString)(text);
 };
 var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
   const makeExecutionClient = yield* client;
@@ -18882,7 +19222,7 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
   const coordinateToolTransition = (effect) => toolTransitions.coordinate(effect).pipe(Effect109.mapError(toClientError));
   const coordinateChildSpawn = (effect) => toolTransitions.coordinate(effect).pipe(Effect109.mapError(toClientError));
   const cancelFanOut = Effect109.fn("Client.runtime.cancelFanOut")(function* (input) {
-    if (Option30.isSome(childFanOutRuntime)) {
+    if (Option31.isSome(childFanOutRuntime)) {
       const fanOut = yield* childFanOutRuntime.value.cancel(input.fan_out_id, input.cancelled_at, input.reason ?? "child fan-out cancelled").pipe(Effect109.mapError(toClientError));
       if (fanOut === undefined)
         return yield* ClientError.make({ message: `Child fan-out not found: ${input.fan_out_id}` });
@@ -18914,7 +19254,7 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
     const identity2 = input.idempotency_key ?? input.correlation_key ?? `${input.from}:${input.to}`;
     const executionId = exports_ids_schema.ExecutionId.make(input.correlation_key ?? `execution:send:${identity2}`);
     const envelopeId = exports_ids_schema.EnvelopeId.make(`${executionId}:envelope:${identity2}`);
-    const createdAt = yield* Clock19.currentTimeMillis;
+    const createdAt = yield* Clock20.currentTimeMillis;
     const execution = yield* executionRepository.get(executionId).pipe(Effect109.mapError(toClientError));
     if (execution === undefined) {
       yield* executionRepository.create({
@@ -18923,7 +19263,7 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
         status: "queued",
         metadata: { operation: "envelope-send" },
         createdAt
-      }).pipe(Effect109.catchIf(Schema100.is(exports_execution_repository.DuplicateExecution), () => Effect109.void), Effect109.mapError(toClientError));
+      }).pipe(Effect109.catchIf(Schema102.is(exports_execution_repository.DuplicateExecution), () => Effect109.void), Effect109.mapError(toClientError));
     }
     const maxSequence3 = yield* eventLog.maxSequence(executionId).pipe(Effect109.mapError(toClientError));
     return yield* envelopes.send({
@@ -18970,18 +19310,73 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
     const execution = yield* executionRepository.get(executionId).pipe(Effect109.mapError(toClientError));
     if (execution === undefined)
       return yield* ExecutionNotFound.make({ execution_id: executionId });
-    const openWaits = yield* envelopeReady.listAllWaits({ executionId, state: "open" }).pipe(Effect109.mapError(toClientError));
+    const waitRecords = yield* envelopeReady.listAllWaits({ executionId }).pipe(Effect109.mapError(toClientError));
+    const openWaits = waitRecords.filter((wait) => wait.state === "open");
     const calls = yield* toolCalls2.listCalls(executionId).pipe(Effect109.mapError(toClientError));
+    const attemptsByCall = yield* Effect109.forEach(calls, (call) => toolCalls2.listAttempts(executionId, call.call.id).pipe(Effect109.mapError(toClientError), Effect109.map((attempts) => ({ call, attempts }))));
     const pendingChunks = yield* Effect109.forEach(calls, (call) => toolCalls2.getResult(call.executionId, call.call.id).pipe(Effect109.mapError(toClientError), Effect109.map((result) => result === undefined ? [toToolCallSummary(call)] : [])));
     const children = yield* childExecutions.listByExecution(executionId).pipe(Effect109.mapError(toClientError));
+    const childTree = [];
+    const queue = [{ executionId, depth: 1 }];
+    const expanded = new Set;
+    const edges = new Set;
+    while (queue.length > 0) {
+      const parent = queue.shift();
+      if (expanded.has(parent.executionId))
+        continue;
+      expanded.add(parent.executionId);
+      const descendants = yield* childExecutions.listByExecution(parent.executionId).pipe(Effect109.mapError(toClientError));
+      for (const child of descendants) {
+        const edge = `${parent.executionId}:${child.id}`;
+        if (edges.has(edge))
+          continue;
+        edges.add(edge);
+        if (edges.size > 1000) {
+          return yield* ClientError.make({ message: "Execution child tree exceeds the 1000 edge inspection limit" });
+        }
+        childTree.push({
+          parent_execution_id: parent.executionId,
+          child_execution_id: child.id,
+          address_id: child.addressId,
+          depth: parent.depth,
+          status: child.status,
+          metadata: child.metadata,
+          created_at: child.createdAt,
+          updated_at: child.updatedAt
+        });
+        const childExecutionId3 = exports_ids_schema.ExecutionId.make(child.id);
+        if (!expanded.has(childExecutionId3))
+          queue.push({ executionId: childExecutionId3, depth: parent.depth + 1 });
+      }
+    }
+    const fanOuts = yield* childFanOuts.listByParent(executionId).pipe(Effect109.mapError(toClientError));
     const maxSequence3 = yield* eventLog.maxSequence(executionId).pipe(Effect109.mapError(toClientError));
-    const lastEvent = maxSequence3 === undefined ? undefined : yield* eventLog.findBySequence({ executionId, sequence: maxSequence3 }).pipe(Effect109.mapError(toClientError), Effect109.map(Option30.getOrUndefined));
+    const lastEvent = maxSequence3 === undefined ? undefined : yield* eventLog.findBySequence({ executionId, sequence: maxSequence3 }).pipe(Effect109.mapError(toClientError), Effect109.map(Option31.getOrUndefined));
     return {
       execution_id: execution.id,
       status: execution.status,
       waiting_on: openWaits.map(toWaitView),
+      waits: waitRecords.map(toWaitView),
       pending_tool_calls: pendingChunks.flat(),
+      tool_attempts: attemptsByCall.flatMap(({ attempts }) => attempts.map(toToolAttempt)),
+      tool_invocations: attemptsByCall.flatMap(({ call, attempts }) => call.placement.kind !== "local" && call.placement.kind !== "mcp" ? [] : attempts.map((attempt) => ({
+        invocation_id: `tool-invocation:${executionId}:${call.call.id}:${attempt.id}`,
+        tool_call_id: call.call.id,
+        attempt_id: attempt.id,
+        placement: call.placement.kind,
+        state: attempt.state,
+        ...attempt.state === "completed" ? { outcome: "success" } : attempt.state === "failed" ? {
+          outcome: "failure",
+          failure_category: "handler"
+        } : attempt.state === "abandoned" ? { outcome: "abandoned", failure_category: "abandoned" } : {},
+        started_at: attempt.createdAt,
+        ...attempt.completedAt === undefined ? {} : { completed_at: attempt.completedAt },
+        ...attempt.claimExpiresAt === undefined ? {} : { claim_expires_at: attempt.claimExpiresAt },
+        ...call.placement.kind !== "remote" || attempt.workerId === undefined ? {} : { worker_id: exports_tool_schema.WorkerId.make(attempt.workerId) }
+      }))),
       child_runs: children.map(toChildRunSummary),
+      child_tree: childTree,
+      fan_outs: fanOuts,
       ...lastEvent === undefined ? {} : { last_event_cursor: lastEvent.cursor }
     };
   });
@@ -19017,27 +19412,27 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
       return { records: yield* workflows.list(id).pipe(Effect109.mapError(toClientError)) };
     }),
     startWorkflowRun: Effect109.fn("Client.runtime.startWorkflowRun")(function* (input) {
-      if (Option30.isSome(runtimeCapabilityPolicy))
+      if (Option31.isSome(runtimeCapabilityPolicy))
         yield* runtimeCapabilityPolicy.value.admit("workflow-definition");
-      return yield* Option30.match(workflowRuntime, {
+      return yield* Option31.match(workflowRuntime, {
         onNone: () => workflows.start(input),
         onSome: (runtime) => runtime.start(input)
       }).pipe(Effect109.mapError(toClientError));
     }),
     inspectWorkflowRun: Effect109.fn("Client.runtime.inspectWorkflowRun")(function* (id) {
-      return yield* Option30.match(workflowRuntime, {
+      return yield* Option31.match(workflowRuntime, {
         onNone: () => workflows.inspect(id),
         onSome: (runtime) => runtime.inspect(id)
       }).pipe(Effect109.mapError(toClientError));
     }),
     replayWorkflowRun: Effect109.fn("Client.runtime.replayWorkflowRun")(function* (id) {
-      return yield* Option30.match(workflowRuntime, {
+      return yield* Option31.match(workflowRuntime, {
         onNone: () => workflows.listLifecycle(id),
         onSome: (runtime) => runtime.replay(id)
       }).pipe(Effect109.mapError(toClientError));
     }),
     cancelWorkflowRun: Effect109.fn("Client.runtime.cancelWorkflowRun")(function* (id) {
-      return yield* Option30.match(workflowRuntime, {
+      return yield* Option31.match(workflowRuntime, {
         onNone: () => workflows.cancel(id).pipe(Effect109.map((result) => result.record)),
         onSome: (runtime) => runtime.cancel(id)
       }).pipe(Effect109.mapError(toClientError));
@@ -19169,7 +19564,7 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
       return records.map(toWaitView);
     }),
     listExecutions: Effect109.fn("Client.runtime.listExecutions")(function* (input) {
-      const cursor = input.cursor === undefined ? undefined : yield* Schema100.decodeEffect(exports_pagination_schema.ExecutionCursorCodec)(input.cursor).pipe(Effect109.map(({ id, at }) => ({ id, updatedAt: at })));
+      const cursor = input.cursor === undefined ? undefined : yield* Schema102.decodeEffect(exports_pagination_schema.ExecutionCursorCodec)(input.cursor).pipe(Effect109.map(({ id, at }) => ({ id, updatedAt: at })));
       const result = yield* executionRepository.list({
         ...input.root_address_id === undefined ? {} : { rootAddressId: input.root_address_id },
         ...input.status === undefined ? {} : { status: input.status },
@@ -19219,13 +19614,13 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
       }).pipe(Effect109.mapError(toClientError));
     }),
     listSessions: Effect109.fn("Client.runtime.listSessions")(function* (input) {
-      const cursor = input.cursor === undefined ? undefined : yield* Schema100.decodeEffect(exports_pagination_schema.SessionCursorCodec)(input.cursor).pipe(Effect109.map(({ id, at }) => ({ id, updatedAt: at })));
+      const cursor = input.cursor === undefined ? undefined : yield* Schema102.decodeEffect(exports_pagination_schema.SessionCursorCodec)(input.cursor).pipe(Effect109.map(({ id, at }) => ({ id, updatedAt: at })));
       const result = yield* sessionRepository.list({
         ...input.root_address_id === undefined ? {} : { rootAddressId: input.root_address_id },
         ...input.limit === undefined ? {} : { limit: input.limit },
         ...cursor === undefined ? {} : { cursor }
       });
-      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema100.encodeEffect(exports_pagination_schema.SessionCursorCodec)({
+      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema102.encodeEffect(exports_pagination_schema.SessionCursorCodec)({
         id: result.nextCursor.id,
         at: result.nextCursor.updatedAt
       });
@@ -19238,7 +19633,7 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
       const session = yield* sessionRepository.get(input.session_id).pipe(Effect109.mapError(toClientError));
       if (session === undefined)
         return yield* ClientError.make({ message: `Session not found: ${input.session_id}` });
-      const cursor = input.cursor === undefined ? undefined : yield* Schema100.decodeEffect(exports_pagination_schema.ExecutionCursorCodec)(input.cursor).pipe(Effect109.map(({ id, at }) => ({ id, updatedAt: at })), Effect109.mapError(toClientError));
+      const cursor = input.cursor === undefined ? undefined : yield* Schema102.decodeEffect(exports_pagination_schema.ExecutionCursorCodec)(input.cursor).pipe(Effect109.map(({ id, at }) => ({ id, updatedAt: at })), Effect109.mapError(toClientError));
       const result = yield* executionRepository.list({
         sessionId: input.session_id,
         ...input.limit === undefined ? {} : { limit: input.limit },
@@ -19295,12 +19690,12 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
       const shard = ShardId.toString(sharding.getShardId(EntityId.make(executionId), "execution"));
       const owner = yield* clusterRegistry.lockOwner(shard).pipe(Effect109.mapError(toClientError));
       const runnerAddress = owner ?? null;
-      const self = Option30.map(shardingConfig2.runnerAddress, (address) => `${address.host}:${address.port}`);
+      const self = Option31.map(shardingConfig2.runnerAddress, (address) => `${address.host}:${address.port}`);
       return {
         execution_id: executionId,
         shard,
         runner_address: runnerAddress,
-        owned: runnerAddress !== null && Option30.getOrNull(self) === runnerAddress
+        owned: runnerAddress !== null && Option31.getOrNull(self) === runnerAddress
       };
     }),
     send: sendEnvelope,
@@ -19309,10 +19704,10 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
       if (instance === undefined || instance.status === "destroyed") {
         return yield* ResidentNotFound.make({ kind: input.kind, key: input.key });
       }
-      const encoded = yield* Schema100.encodeUnknownEffect(input.command.input)(input.input).pipe(Effect109.mapError(toClientError));
+      const encoded = yield* Schema102.encodeUnknownEffect(input.command.input)(input.input).pipe(Effect109.mapError(toClientError));
       const inputRef = inputSchemaRef(input.command.name);
       const outputRef = outputSchemaRef(input.command.name);
-      if (Option30.isSome(schemaRegistry)) {
+      if (Option31.isSome(schemaRegistry)) {
         yield* schemaRegistry.value.register({ ref: inputRef, schema: input.command.input });
         yield* schemaRegistry.value.register({ ref: outputRef, schema: input.command.output });
       }
@@ -19356,7 +19751,7 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
           message: "reply carried no decodable content"
         });
       }
-      return yield* Schema100.decodeUnknownEffect(input.command.output)(replyValue.value).pipe(Effect109.mapError((issue) => CommandReplyInvalid.make({
+      return yield* Schema102.decodeUnknownEffect(input.command.output)(replyValue.value).pipe(Effect109.mapError((issue) => CommandReplyInvalid.make({
         command: input.command.name,
         wait_id: outcome.wait_id,
         message: errorMessage2(issue)
@@ -19397,14 +19792,14 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
       ...input.expected_version === undefined ? {} : { expectedVersion: input.expected_version },
       ...input.idempotency_key === undefined ? {} : { idempotencyKey: input.idempotency_key },
       updatedAt: input.updated_at
-    }).pipe(Effect109.mapError((error5) => Schema100.is(StateVersionConflict3)(error5) ? StateVersionConflict.make(error5) : toClientError(error5)))),
+    }).pipe(Effect109.mapError((error5) => Schema102.is(StateVersionConflict3)(error5) ? StateVersionConflict.make(error5) : toClientError(error5)))),
     deleteResidentState: Effect109.fn("Client.runtime.deleteResidentState")((input) => executionState.remove({
       executionId: input.execution_id,
       key: input.key,
       ...input.expected_version === undefined ? {} : { expectedVersion: input.expected_version },
       ...input.idempotency_key === undefined ? {} : { idempotencyKey: input.idempotency_key },
       removedAt: input.removed_at
-    }).pipe(Effect109.mapError((error5) => Schema100.is(StateVersionConflict3)(error5) ? StateVersionConflict.make(error5) : toClientError(error5)))),
+    }).pipe(Effect109.mapError((error5) => Schema102.is(StateVersionConflict3)(error5) ? StateVersionConflict.make(error5) : toClientError(error5)))),
     listResidentState: Effect109.fn("Client.runtime.listResidentState")((input) => executionState.list({
       executionId: input.execution_id,
       ...input.prefix === undefined ? {} : { prefix: input.prefix },
@@ -19527,7 +19922,7 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
     }),
     spawnChildRun: Effect109.fn("Client.runtime.spawnChildRun")(function* (input) {
       const pin = yield* parentDefinitionPin(executionRepository, input.execution_id);
-      const createdAt = yield* Clock19.currentTimeMillis;
+      const createdAt = yield* Clock20.currentTimeMillis;
       const internal = childRunInternals.internalSpawnChildRunInput(input, pin, createdAt);
       const context = yield* resolveForDispatch(internal).pipe(Effect109.mapError((error5) => ClientError.make({ message: error5._tag })));
       const definition = yield* childDefinition(pin.agentSnapshot, context).pipe(Effect109.mapError((error5) => ClientError.make({ message: error5._tag })));
@@ -19545,9 +19940,9 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
       return coordinated.accepted;
     }),
     createChildFanOut: Effect109.fn("Client.runtime.createChildFanOut")(function* (input) {
-      if (Option30.isSome(runtimeCapabilityPolicy))
+      if (Option31.isSome(runtimeCapabilityPolicy))
         yield* runtimeCapabilityPolicy.value.admit("fan-out");
-      if (Option30.isNone(childFanOutRuntime)) {
+      if (Option31.isNone(childFanOutRuntime)) {
         return yield* ClientError.make({
           message: "Child fan-out runtime unavailable"
         });
@@ -19558,7 +19953,7 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
       return yield* cancelFanOut(input);
     }),
     inspectChildFanOut: Effect109.fn("Client.runtime.inspectChildFanOut")(function* (input) {
-      const fanOut = yield* Option30.match(childFanOutRuntime, {
+      const fanOut = yield* Option31.match(childFanOutRuntime, {
         onNone: () => childFanOuts.get(input.fan_out_id),
         onSome: (runtime) => runtime.inspect(input.fan_out_id)
       }).pipe(Effect109.mapError(toClientError));
@@ -19600,7 +19995,7 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
       if (input.cron_expr !== undefined) {
         yield* parseCron(input.cron_expr).pipe(Effect109.mapError(toClientError));
       }
-      const createdAt = yield* Clock19.currentTimeMillis;
+      const createdAt = yield* Clock20.currentTimeMillis;
       const schedule = yield* schedules.create({
         id: input.schedule_id,
         kind: input.kind,
@@ -19663,77 +20058,77 @@ import { Effect as Effect111 } from "effect";
 var recoverPersistedFanOut = (recover) => recover().pipe(Effect111.mapError((error5) => WorkflowRuntimeError.make({ message: error5._tag })), Effect111.asVoid);
 
 // src/runtime.ts
-var Dialect2 = Schema101.Literals(["pg", "mysql", "sqlite"]);
+var Dialect2 = Schema103.Literals(["pg", "mysql", "sqlite"]);
 
-class NotificationFailure extends Schema101.TaggedErrorClass()("NotificationFailure", {
-  reason: Schema101.String
+class NotificationFailure extends Schema103.TaggedErrorClass()("NotificationFailure", {
+  reason: Schema103.String
 }) {
 }
 
-class ClusterFailure extends Schema101.TaggedErrorClass()("ClusterFailure", {
-  reason: Schema101.String
+class ClusterFailure extends Schema103.TaggedErrorClass()("ClusterFailure", {
+  reason: Schema103.String
 }) {
 }
 
-class SqlFailure extends Schema101.TaggedErrorClass()("SqlFailure", {
-  category: Schema101.Literals(["connection", "statement", "unknown"]),
-  operation: Schema101.Literals(["acquire", "migrate", "verify", "notify", "readiness"]),
-  retryable: Schema101.Boolean
+class SqlFailure extends Schema103.TaggedErrorClass()("SqlFailure", {
+  category: Schema103.Literals(["connection", "statement", "unknown"]),
+  operation: Schema103.Literals(["acquire", "migrate", "verify", "notify", "readiness"]),
+  retryable: Schema103.Boolean
 }) {
 }
-var SqlDialect = Schema101.Literals(["sqlite", "pg", "mysql", "mssql", "clickhouse"]);
+var SqlDialect = Schema103.Literals(["sqlite", "pg", "mysql", "mssql", "clickhouse"]);
 
-class DatabaseDialectMismatch extends Schema101.TaggedErrorClass()("DatabaseDialectMismatch", { expected: Dialect2, actual: SqlDialect }) {
+class DatabaseDialectMismatch extends Schema103.TaggedErrorClass()("DatabaseDialectMismatch", { expected: Dialect2, actual: SqlDialect }) {
 }
 
-class DatabaseAlreadyOwned extends Schema101.TaggedErrorClass()("DatabaseAlreadyOwned", {
+class DatabaseAlreadyOwned extends Schema103.TaggedErrorClass()("DatabaseAlreadyOwned", {
   databaseIdentity: DatabaseIdentity
 }) {
 }
 
-class UnsupportedTopology extends Schema101.TaggedErrorClass()("UnsupportedTopology", {
-  reason: Schema101.String
+class UnsupportedTopology extends Schema103.TaggedErrorClass()("UnsupportedTopology", {
+  reason: Schema103.String
 }) {
 }
 
-class MigratorError extends Schema101.TaggedErrorClass()("MigratorError", {
-  reason: Schema101.String
+class MigratorError extends Schema103.TaggedErrorClass()("MigratorError", {
+  reason: Schema103.String
 }) {
 }
 
-class SchemaHeadMismatch extends Schema101.TaggedErrorClass()("SchemaHeadMismatch", {
-  expected: Schema101.String,
-  actual: Schema101.String
+class SchemaHeadMismatch extends Schema103.TaggedErrorClass()("SchemaHeadMismatch", {
+  expected: Schema103.String,
+  actual: Schema103.String
 }) {
 }
 
-class HostUnavailable extends Schema101.TaggedErrorClass()("HostUnavailable", {
-  host: Schema101.String,
-  reason: Schema101.String
+class HostUnavailable extends Schema103.TaggedErrorClass()("HostUnavailable", {
+  host: Schema103.String,
+  reason: Schema103.String
 }) {
 }
-var RuntimeTopologyCause = Schema101.Union([
+var RuntimeTopologyCause = Schema103.Union([
   ClusterFailure,
   DatabaseDialectMismatch,
   DatabaseAlreadyOwned,
   UnsupportedTopology
 ]);
-var RuntimeMigrationCause = Schema101.Union([
+var RuntimeMigrationCause = Schema103.Union([
   SqlFailure,
   MigratorError,
   SchemaHeadMismatch
 ]);
-var RuntimeReadinessCause = Schema101.Union([
+var RuntimeReadinessCause = Schema103.Union([
   SqlFailure,
   NotificationFailure,
   ClusterFailure,
   HostUnavailable
 ]);
 
-class RuntimeTopologyError extends Schema101.TaggedErrorClass()("RuntimeTopologyError", {
+class RuntimeTopologyError extends Schema103.TaggedErrorClass()("RuntimeTopologyError", {
   dialect: Dialect2,
-  role: Schema101.Literals(["embedded", "runner", "client"]),
-  nextAction: Schema101.Literals([
+  role: Schema103.Literals(["embedded", "runner", "client"]),
+  nextAction: Schema103.Literals([
     "use-embedded",
     "use-postgres-or-mysql",
     "use-client-constructor",
@@ -19744,39 +20139,39 @@ class RuntimeTopologyError extends Schema101.TaggedErrorClass()("RuntimeTopology
 }) {
 }
 
-class RuntimeMigrationError extends Schema101.TaggedErrorClass()("RuntimeMigrationError", {
+class RuntimeMigrationError extends Schema103.TaggedErrorClass()("RuntimeMigrationError", {
   dialect: Dialect2,
-  phase: Schema101.Literals(["apply", "verify"]),
-  nextAction: Schema101.Literals(["retry", "inspect-schema", "run-compatible-release"]),
+  phase: Schema103.Literals(["apply", "verify"]),
+  nextAction: Schema103.Literals(["retry", "inspect-schema", "run-compatible-release"]),
   cause: RuntimeMigrationCause
 }) {
 }
 
-class RuntimeReadinessError extends Schema101.TaggedErrorClass()("RuntimeReadinessError", {
-  phase: Schema101.Literals(["database", "notification", "cluster", "hosts"]),
+class RuntimeReadinessError extends Schema103.TaggedErrorClass()("RuntimeReadinessError", {
+  phase: Schema103.Literals(["database", "notification", "cluster", "hosts"]),
   cause: RuntimeReadinessCause
 }) {
 }
-var RuntimeCapabilityStatus = Schema101.Union([
-  Schema101.Struct({
-    enabled: Schema101.Literal(false),
-    source: Schema101.Literals(["local-host", "role-unavailable"]),
-    health: Schema101.Literal("not-applicable")
+var RuntimeCapabilityStatus = Schema103.Union([
+  Schema103.Struct({
+    enabled: Schema103.Literal(false),
+    source: Schema103.Literals(["local-host", "role-unavailable"]),
+    health: Schema103.Literal("not-applicable")
   }),
-  Schema101.Struct({
-    enabled: Schema101.Literal(true),
-    source: Schema101.Literal("local-host"),
-    health: Schema101.Literals(["healthy", "unhealthy"])
+  Schema103.Struct({
+    enabled: Schema103.Literal(true),
+    source: Schema103.Literal("local-host"),
+    health: Schema103.Literals(["healthy", "unhealthy"])
   })
 ]);
-var ReadinessStatus2 = Schema101.Struct({
-  ready: Schema101.Literal(true),
-  role: Schema101.Literals(["embedded", "runner", "client"]),
+var ReadinessStatus2 = Schema103.Struct({
+  ready: Schema103.Literal(true),
+  role: Schema103.Literals(["embedded", "runner", "client"]),
   dialect: Dialect2,
   databaseIdentity: DatabaseIdentity,
-  schemaHead: Schema101.String,
-  notification: Schema101.Literals(["pg-listen-notify", "polling", "in-process"]),
-  capabilities: Schema101.Struct({
+  schemaHead: Schema103.String,
+  notification: Schema103.Literals(["pg-listen-notify", "polling", "in-process"]),
+  capabilities: Schema103.Struct({
     fanOut: RuntimeCapabilityStatus,
     workflowDefinition: RuntimeCapabilityStatus
   })
@@ -19790,7 +20185,7 @@ var normalizeHost = (layer65, _role, _dialect) => layer65.pipe(Layer86.catchCaus
   role: _role,
   nextAction: _role === "embedded" ? "use-embedded" : "use-different-database",
   cause: ClusterFailure.make({ reason: "cluster configuration is incompatible" })
-}) : error5), "host-layer", (error5) => Schema101.is(RuntimeConfigurationError)(error5) || Schema101.is(RuntimeTopologyError)(error5) || Schema101.is(RuntimeMigrationError)(error5))))));
+}) : error5), "host-layer", (error5) => Schema103.is(RuntimeConfigurationError)(error5) || Schema103.is(RuntimeTopologyError)(error5) || Schema103.is(RuntimeMigrationError)(error5))))));
 var actualDialect = (sql) => sql.onDialectOrElse({
   sqlite: () => "sqlite",
   pg: () => "pg",
@@ -19883,7 +20278,7 @@ var withHosts = (runner, options) => {
     const childFanOut = yield* Effect112.serviceOption(Service44);
     const mapError2 = (effect) => effect.pipe(Effect112.mapError((error5) => WorkflowRuntimeError.make({ message: error5.message })));
     return HandlerService2.of({
-      ...Option31.isNone(childFanOut) ? {} : {
+      ...Option32.isNone(childFanOut) ? {} : {
         createChildFanOut: (definition) => childFanOut.value.create(definition).pipe(Effect112.mapError((error5) => WorkflowRuntimeError.make({ message: error5._tag }))),
         admitChildFanOut: () => recoverPersistedFanOut(childFanOut.value.recover),
         inspectChildFanOut: (fanOutId) => childFanOut.value.inspect(fanOutId).pipe(Effect112.mapError((error5) => WorkflowRuntimeError.make({ message: error5._tag })))