@relayfx/sdk 0.7.2 → 0.7.4

package/dist/index.js

@@ -14,11 +14,11 @@ import {
   exports_tool_runtime,
   exports_workflow_definition_host,
   makeDatabaseIdentity
-} from "./index-sp77tb7c.js";
+} from "./index-8jjqgjhf.js";
 import {
   exports_context_overflow,
   exports_model_registry
-} from "./index-qa93yf6j.js";
+} from "./index-etc2cnk2.js";
 import {
   ClientError,
   EventLogCursorNotFound,
@@ -47,7 +47,7 @@ import {
   exports_wait_schema,
   exports_workflow_schema,
   followExecutionFrom
-} from "./index-q7xzf506.js";
+} from "./index-nb078xsy.js";
 import {
   __export
 } from "./index-nb39b5ae.js";
@@ -179,11 +179,11 @@ import { OpenAiLanguageModel as OpenAiLanguageModel3 } from "@effect/ai-openai";
 import { OpenAiLanguageModel as OpenAiCompatibleLanguageModel } from "@effect/ai-openai-compat";
 import { OpenRouterLanguageModel as OpenRouterLanguageModel2 } from "@effect/ai-openrouter";
 
-// ../../node_modules/.bun/@batonfx+providers@0.11.3+74997d64abff4185/node_modules/@batonfx/providers/dist/anthropic.js
+// ../../node_modules/.bun/@batonfx+providers@0.11.4+74997d64abff4185/node_modules/@batonfx/providers/dist/anthropic.js
 import { AnthropicClient, AnthropicLanguageModel } from "@effect/ai-anthropic";
 import { Config, Layer as Layer3, Redacted } from "effect";
 
-// ../../node_modules/.bun/@batonfx+providers@0.11.3+74997d64abff4185/node_modules/@batonfx/providers/dist/image-source.js
+// ../../node_modules/.bun/@batonfx+providers@0.11.4+74997d64abff4185/node_modules/@batonfx/providers/dist/image-source.js
 import { Effect as Effect3, Encoding, Layer as Layer2, Result, Stream } from "effect";
 import { AiError, LanguageModel, Prompt } from "effect/unstable/ai";
 var imageMediaTypes = new Set(["image/gif", "image/jpeg", "image/png", "image/webp"]);
@@ -252,7 +252,7 @@ var conformImageSourceModel = (model) => {
 };
 var layerImageSources = (layer2) => Layer2.effect(LanguageModel.LanguageModel, Effect3.map(LanguageModel.LanguageModel, conformImageSourceModel)).pipe(Layer2.provide(layer2));
 
-// ../../node_modules/.bun/@batonfx+providers@0.11.3+74997d64abff4185/node_modules/@batonfx/providers/dist/anthropic.js
+// ../../node_modules/.bun/@batonfx+providers@0.11.4+74997d64abff4185/node_modules/@batonfx/providers/dist/anthropic.js
 var classifyFailure = exports_context_overflow.classify;
 var layer2 = (input) => exports_model_registry.layer([
   exports_model_registry.registration({
@@ -269,13 +269,13 @@ var layer2 = (input) => exports_model_registry.layer([
 ]).pipe(Layer3.provide(AnthropicClient.layerConfig({ ...input.clientConfig, apiKey: input.apiKey })));
 var layerConfig = AnthropicClient.layerConfig;
 
-// ../../node_modules/.bun/@batonfx+providers@0.11.3+74997d64abff4185/node_modules/@batonfx/providers/dist/deterministic.js
+// ../../node_modules/.bun/@batonfx+providers@0.11.4+74997d64abff4185/node_modules/@batonfx/providers/dist/deterministic.js
 import { OpenAiClient as OpenAiClient2 } from "@effect/ai-openai";
 import { Config as Config3, Effect as Effect5, Layer as Layer5, Option as Option2, Stream as Stream3 } from "effect";
 import { LanguageModel as LanguageModel2, Response as Response2 } from "effect/unstable/ai";
 import { HttpClient as HttpClient2 } from "effect/unstable/http";
 
-// ../../node_modules/.bun/@batonfx+providers@0.11.3+74997d64abff4185/node_modules/@batonfx/providers/dist/openai.js
+// ../../node_modules/.bun/@batonfx+providers@0.11.4+74997d64abff4185/node_modules/@batonfx/providers/dist/openai.js
 import { OpenAiClient, OpenAiLanguageModel } from "@effect/ai-openai";
 import { Config as Config2, Effect as Effect4, Function, Layer as Layer4, Option, Redacted as Redacted2, Schema, Stream as Stream2 } from "effect";
 import { FetchHttpClient, Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
@@ -445,7 +445,7 @@ var registrationAccount = (input) => exports_model_registry.registration({
 });
 var layerAccount = (input) => exports_model_registry.layer([registrationAccount(input)]);
 
-// ../../node_modules/.bun/@batonfx+providers@0.11.3+74997d64abff4185/node_modules/@batonfx/providers/dist/deterministic.js
+// ../../node_modules/.bun/@batonfx+providers@0.11.4+74997d64abff4185/node_modules/@batonfx/providers/dist/deterministic.js
 var deterministicModelLayer = Layer5.effect(LanguageModel2.LanguageModel, LanguageModel2.make({
   generateText: () => Effect5.succeed([{ type: "text", text: "deterministic response" }]),
   streamText: () => Stream3.make(Response2.makePart("text-delta", { id: "text", delta: "deterministic response" }))
@@ -482,7 +482,7 @@ var layerOpenAi = (options) => Layer5.unwrap(Effect5.gen(function* () {
   ]);
 }));
 
-// ../../node_modules/.bun/@batonfx+providers@0.11.3+74997d64abff4185/node_modules/@batonfx/providers/dist/openai-compat.js
+// ../../node_modules/.bun/@batonfx+providers@0.11.4+74997d64abff4185/node_modules/@batonfx/providers/dist/openai-compat.js
 import { OpenAiClient as OpenAiClient3, OpenAiLanguageModel as OpenAiLanguageModel2 } from "@effect/ai-openai-compat";
 import { Config as Config4, Layer as Layer6, Redacted as Redacted3 } from "effect";
 var layer5 = (input) => exports_model_registry.layer([
@@ -504,7 +504,7 @@ var layer5 = (input) => exports_model_registry.layer([
 })));
 var layerConfig3 = OpenAiClient3.layerConfig;
 
-// ../../node_modules/.bun/@batonfx+providers@0.11.3+74997d64abff4185/node_modules/@batonfx/providers/dist/openrouter.js
+// ../../node_modules/.bun/@batonfx+providers@0.11.4+74997d64abff4185/node_modules/@batonfx/providers/dist/openrouter.js
 import { OpenRouterClient, OpenRouterLanguageModel } from "@effect/ai-openrouter";
 import { Config as Config5, Layer as Layer7, Redacted as Redacted4 } from "effect";
 var classifyFailure3 = exports_context_overflow.classify;

package/dist/mysql.js

@@ -2,14 +2,14 @@
 import {
   database,
   normalizeMigrationCause
-} from "./index-75gb7ftn.js";
+} from "./index-ex8w3c48.js";
 import {
   MigratorError,
   RuntimeMigrationError,
   SqlFailure
-} from "./index-sp77tb7c.js";
-import"./index-qa93yf6j.js";
-import"./index-q7xzf506.js";
+} from "./index-8jjqgjhf.js";
+import"./index-etc2cnk2.js";
+import"./index-nb078xsy.js";
 import"./index-nb39b5ae.js";
 
 // src/mysql.ts

package/dist/postgres.js

@@ -2,7 +2,7 @@
 import {
   database,
   normalizeMigrationCause
-} from "./index-75gb7ftn.js";
+} from "./index-ex8w3c48.js";
 import {
   Dialect,
   RuntimeMigrationError,
@@ -14,11 +14,11 @@ import {
   fromDbTimestamp,
   fromNullableDbTimestamp,
   timestampParam
-} from "./index-sp77tb7c.js";
-import"./index-qa93yf6j.js";
+} from "./index-8jjqgjhf.js";
+import"./index-etc2cnk2.js";
 import {
   exports_ids_schema
-} from "./index-q7xzf506.js";
+} from "./index-nb078xsy.js";
 import {
   __export
 } from "./index-nb39b5ae.js";

package/dist/sqlite.js

@@ -2,7 +2,7 @@
 import {
   database,
   normalizeMigrationCause
-} from "./index-75gb7ftn.js";
+} from "./index-ex8w3c48.js";
 import {
   DatabaseAlreadyOwned,
   RuntimeConfigurationError,
@@ -12,9 +12,9 @@ import {
   make,
   makeDatabaseIdentity,
   runtimeLayer
-} from "./index-sp77tb7c.js";
-import"./index-qa93yf6j.js";
-import"./index-q7xzf506.js";
+} from "./index-8jjqgjhf.js";
+import"./index-etc2cnk2.js";
+import"./index-nb078xsy.js";
 import"./index-nb39b5ae.js";
 
 // src/sqlite-runtime.ts

package/dist/types/relay/client-child-runs.d.ts

@@ -10,6 +10,7 @@ export interface ParentDefinitionPin {
     readonly agentRevision: Agent.DefinitionRevision;
     readonly agentSnapshot: Agent.Definition;
     readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
+    readonly origin?: Execution.ExecutionOrigin;
 }
 declare const internalSpawnChildRunInput: (input: SpawnChildRunInput, pin: ParentDefinitionPin, createdAt: number) => Execution.SpawnChildRunInput;
 export declare const createChildJoinWait: (waits: WaitServiceInterface, eventLog: EventLogInterface, input: Execution.SpawnChildRunInput, accepted: Execution.ChildRunAccepted, createdAt: number) => Effect.Effect<string & import("effect/Brand").Brand<"Relay.WaitId">, ClientError, never>;
@@ -26,6 +27,16 @@ export declare const parentDefinitionPin: (executionRepository: ExecutionReposit
     agentRevision: number;
     agentSnapshot: Agent.Definition;
     agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
+    origin?: {
+        readonly owner_kind: "service" | "system" | "user" | "workflow";
+        readonly owner: string;
+        readonly purpose: string;
+        readonly build?: {
+            readonly name: string;
+            readonly version?: string;
+            readonly commit?: string;
+        };
+    };
 }, ClientError, never>;
 declare const childStartInput: (input: Execution.SpawnChildRunInput, accepted: Execution.ChildRunAccepted, pin: ParentDefinitionPin, definition: Agent.Definition, createdAt: number, parentWaitId: Ids.WaitId | undefined) => StartExecutionInput;
 export declare const childRunInternals: {

package/dist/types/relay/client-public-executions.d.ts

@@ -31,7 +31,7 @@ export declare const followExecution: (input: FollowExecutionInput) => Stream.St
         readonly child_execution_id: import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Relay.ChildExecutionId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
         }>;
-        readonly type: import("effect/Schema").Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.started", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.delivered", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+        readonly type: import("effect/Schema").Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "model.call.started", "model.attempt.started", "model.attempt.first_output", "model.attempt.completed", "model.attempt.failed", "model.retry.scheduled", "model.call.completed", "model.call.failed", "agent.compaction.started", "agent.compaction.completed", "agent.compaction.failed", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.delivered", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
         readonly sequence: import("effect/Schema").Int;
         readonly cursor: import("effect/Schema").String;
         readonly content: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
@@ -151,7 +151,7 @@ export declare const streamSession: (input: StreamSessionInput) => Stream.Stream
         readonly child_execution_id: import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Relay.ChildExecutionId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
         }>;
-        readonly type: import("effect/Schema").Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.started", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.delivered", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+        readonly type: import("effect/Schema").Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "model.call.started", "model.attempt.started", "model.attempt.first_output", "model.attempt.completed", "model.attempt.failed", "model.retry.scheduled", "model.call.completed", "model.call.failed", "agent.compaction.started", "agent.compaction.completed", "agent.compaction.failed", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.delivered", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
         readonly sequence: import("effect/Schema").Int;
         readonly cursor: import("effect/Schema").String;
         readonly content: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{

package/dist/types/relay/client-public.d.ts

@@ -59,6 +59,7 @@ export interface StartExecutionByAddressInput {
     readonly started_at: Shared.TimestampMillis;
     readonly completed_at: Shared.TimestampMillis;
     readonly wait_id?: Ids.WaitId;
+    readonly origin?: Execution.ExecutionOrigin;
     readonly metadata?: Shared.Metadata;
 }
 export interface StartExecutionByAgentDefinitionInput {
@@ -73,6 +74,7 @@ export interface StartExecutionByAgentDefinitionInput {
     readonly started_at: Shared.TimestampMillis;
     readonly completed_at: Shared.TimestampMillis;
     readonly wait_id?: Ids.WaitId;
+    readonly origin?: Execution.ExecutionOrigin;
     readonly metadata?: Shared.Metadata;
 }
 export interface RegisterDefinedAgentInput extends Agent.DefineInput {

package/dist/types/relay/operation.d.ts

@@ -99,7 +99,7 @@ export declare const StartExecutionInput: Schema.Struct<{
         };
         readonly turn_policy?: Agent.TurnPolicySnapshot;
         readonly tool_execution?: Schema.Struct.ReadonlySide<{
-            readonly concurrency: Schema.Finite;
+            readonly concurrency: Schema.Union<readonly [Schema.Finite, Schema.Literal<"unbounded">]>;
         }, "Encoded">;
         readonly compaction_policy?: {
             readonly context_window: number;
@@ -175,6 +175,16 @@ export declare const StartExecutionInput: Schema.Struct<{
     readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
     }>;
+    readonly origin: Schema.optionalKey<Schema.Struct<{
+        readonly owner_kind: Schema.Literals<readonly ["service", "user", "workflow", "system"]>;
+        readonly owner: Schema.String;
+        readonly purpose: Schema.String;
+        readonly build: Schema.optionalKey<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly version: Schema.optionalKey<Schema.String>;
+            readonly commit: Schema.optionalKey<Schema.String>;
+        }>>;
+    }>>;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
 }>;
 export interface StartExecutionInput extends Schema.Schema.Type<typeof StartExecutionInput> {
@@ -650,7 +660,7 @@ export declare const FollowExecutionItem: Schema.Union<readonly [Schema.Struct<{
         readonly child_execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
         }>;
-        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.started", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.delivered", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "model.call.started", "model.attempt.started", "model.attempt.first_output", "model.attempt.completed", "model.attempt.failed", "model.retry.scheduled", "model.call.completed", "model.call.failed", "agent.compaction.started", "agent.compaction.completed", "agent.compaction.failed", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.delivered", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
         readonly sequence: Schema.Int;
         readonly cursor: Schema.String;
         readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
@@ -1008,6 +1018,25 @@ export declare const ToolAttemptList: Schema.Struct<{
 }>;
 export interface ToolAttemptList extends Schema.Schema.Type<typeof ToolAttemptList> {
 }
+export declare const ToolInvocation: Schema.Struct<{
+    readonly invocation_id: Schema.String;
+    readonly tool_call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+    };
+    readonly attempt_id: Schema.brand<Schema.String, "Relay.ToolAttemptId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolAttemptId">;
+    };
+    readonly placement: Schema.Literals<readonly ["local", "client", "remote", "mcp"]>;
+    readonly state: Schema.Literals<readonly ["running", "completed", "failed", "released", "expired", "abandoned"]>;
+    readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["success", "failure", "abandoned"]>>;
+    readonly failure_category: Schema.optionalKey<Schema.Literals<readonly ["handler", "worker", "abandoned", "unknown"]>>;
+    readonly started_at: Schema.Int;
+    readonly completed_at: Schema.optionalKey<Schema.Int>;
+    readonly claim_expires_at: Schema.optionalKey<Schema.Int>;
+    readonly worker_id: Schema.optionalKey<Schema.String>;
+}>;
+export interface ToolInvocation extends Schema.Schema.Type<typeof ToolInvocation> {
+}
 export declare const ToolOutcomeAccepted: Schema.Struct<{
     readonly tool_call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
@@ -2407,7 +2436,7 @@ export declare const SessionStreamItem: Schema.Union<readonly [Schema.TaggedStru
         readonly child_execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
         }>;
-        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.started", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.delivered", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "model.call.started", "model.attempt.started", "model.attempt.first_output", "model.attempt.completed", "model.attempt.failed", "model.retry.scheduled", "model.call.completed", "model.call.failed", "agent.compaction.started", "agent.compaction.completed", "agent.compaction.failed", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.delivered", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
         readonly sequence: Schema.Int;
         readonly cursor: Schema.String;
         readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
@@ -2544,6 +2573,24 @@ export declare const ChildRunSummary: Schema.Struct<{
 }>;
 export interface ChildRunSummary extends Schema.Schema.Type<typeof ChildRunSummary> {
 }
+export declare const ChildRunEdge: Schema.Struct<{
+    readonly parent_execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly child_execution_id: Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
+    };
+    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly depth: Schema.Int;
+    readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly created_at: Schema.Int;
+    readonly updated_at: Schema.Int;
+}>;
+export interface ChildRunEdge extends Schema.Schema.Type<typeof ChildRunEdge> {
+}
 export declare const ExecutionInspection: Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
@@ -2567,6 +2614,24 @@ export declare const ExecutionInspection: Schema.Struct<{
         readonly created_at: Schema.Int;
         readonly resolved_at: Schema.optionalKey<Schema.Int>;
     }>>;
+    readonly waits: Schema.$Array<Schema.Struct<{
+        readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+        };
+        readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+        };
+        readonly envelope_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.EnvelopeId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeId">;
+        }>;
+        readonly kind: Schema.optionalKey<Schema.Literals<readonly ["permission", "tool_approval", "tool_placement", "child_join", "inbox", "reply", "timer", "external"]>>;
+        readonly mode: Schema.Literals<readonly ["reply", "event", "until", "child"]>;
+        readonly correlation_key: Schema.optionalKey<Schema.String>;
+        readonly state: Schema.Literals<readonly ["open", "resolved", "timed_out", "cancelled"]>;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly created_at: Schema.Int;
+        readonly resolved_at: Schema.optionalKey<Schema.Int>;
+    }>>;
     readonly pending_tool_calls: Schema.$Array<Schema.Struct<{
         readonly tool_call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
@@ -2576,6 +2641,38 @@ export declare const ExecutionInspection: Schema.Struct<{
         readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
         readonly requested_at: Schema.Int;
     }>>;
+    readonly tool_attempts: Schema.$Array<Schema.Struct<{
+        readonly attempt_id: Schema.brand<Schema.String, "Relay.ToolAttemptId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolAttemptId">;
+        };
+        readonly tool_call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+        };
+        readonly attempt_number: Schema.Int;
+        readonly state: Schema.Literals<readonly ["running", "completed", "failed", "released", "expired", "abandoned"]>;
+        readonly worker_id: Schema.optionalKey<Schema.String>;
+        readonly claim_expires_at: Schema.optionalKey<Schema.Int>;
+        readonly error: Schema.optionalKey<Schema.String>;
+        readonly created_at: Schema.Int;
+        readonly completed_at: Schema.optionalKey<Schema.Int>;
+    }>>;
+    readonly tool_invocations: Schema.$Array<Schema.Struct<{
+        readonly invocation_id: Schema.String;
+        readonly tool_call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+        };
+        readonly attempt_id: Schema.brand<Schema.String, "Relay.ToolAttemptId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolAttemptId">;
+        };
+        readonly placement: Schema.Literals<readonly ["local", "client", "remote", "mcp"]>;
+        readonly state: Schema.Literals<readonly ["running", "completed", "failed", "released", "expired", "abandoned"]>;
+        readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["success", "failure", "abandoned"]>>;
+        readonly failure_category: Schema.optionalKey<Schema.Literals<readonly ["handler", "worker", "abandoned", "unknown"]>>;
+        readonly started_at: Schema.Int;
+        readonly completed_at: Schema.optionalKey<Schema.Int>;
+        readonly claim_expires_at: Schema.optionalKey<Schema.Int>;
+        readonly worker_id: Schema.optionalKey<Schema.String>;
+    }>>;
     readonly child_runs: Schema.$Array<Schema.Struct<{
         readonly child_execution_id: Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
@@ -2588,6 +2685,186 @@ export declare const ExecutionInspection: Schema.Struct<{
         readonly created_at: Schema.Int;
         readonly updated_at: Schema.Int;
     }>>;
+    readonly child_tree: Schema.$Array<Schema.Struct<{
+        readonly parent_execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+        };
+        readonly child_execution_id: Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
+        };
+        readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+        };
+        readonly depth: Schema.Int;
+        readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly created_at: Schema.Int;
+        readonly updated_at: Schema.Int;
+    }>>;
+    readonly fan_outs: Schema.$Array<Schema.Struct<{
+        readonly fan_out_id: Schema.brand<Schema.String, "Relay.ChildFanOutId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildFanOutId">;
+        };
+        readonly parent_execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+        };
+        readonly children: Schema.$Array<Schema.Struct<{
+            readonly child_execution_id: Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
+            };
+            readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+            };
+            readonly override: Schema.optionalKey<Schema.Struct<{
+                readonly instructions: Schema.optionalKey<Schema.String>;
+                readonly model: Schema.optionalKey<Schema.Struct<{
+                    readonly provider: Schema.String;
+                    readonly model: Schema.String;
+                    readonly registration_key: Schema.optionalKey<Schema.String>;
+                    readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                }>>;
+                readonly compaction_policy: Schema.optionalKey<Schema.Struct<{
+                    readonly context_window: Schema.Finite;
+                    readonly reserve_tokens: Schema.Finite;
+                    readonly keep_recent_tokens: Schema.Finite;
+                    readonly summary_model: Schema.optionalKey<Schema.Struct<{
+                        readonly provider: Schema.String;
+                        readonly model: Schema.String;
+                        readonly registration_key: Schema.optionalKey<Schema.String>;
+                        readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                    }>>;
+                }>>;
+                readonly tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly workspace_policy: Schema.optionalKey<Schema.Struct<{
+                    readonly mode: Schema.Literals<readonly ["share", "fork"]>;
+                    readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["fail", "fresh"]>>;
+                }>>;
+                readonly output_schema_ref: Schema.optionalKey<Schema.String>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>>;
+            readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"text">;
+                readonly text: Schema.String;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"structured">;
+                readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly schema_ref: Schema.optionalKey<Schema.String>;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"blob-reference">;
+                readonly uri: Schema.String;
+                readonly media_type: Schema.String;
+                readonly filename: Schema.optionalKey<Schema.String>;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"artifact-reference">;
+                readonly artifact_id: Schema.String;
+                readonly media_type: Schema.optionalKey<Schema.String>;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"tool-call">;
+                readonly call: Schema.Struct<{
+                    readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+                    };
+                    readonly name: Schema.String;
+                    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                }>;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"tool-result">;
+                readonly result: Schema.Struct<{
+                    readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+                    };
+                    readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly error: Schema.optionalKey<Schema.String>;
+                    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                }>;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>]>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>>;
+        readonly max_concurrency: Schema.Int;
+        readonly join: Schema.Union<readonly [Schema.TaggedStruct<"all", {}>, Schema.TaggedStruct<"first-success", {}>, Schema.TaggedStruct<"quorum", {
+            readonly count: Schema.Int;
+        }>, Schema.TaggedStruct<"best-effort", {}>]>;
+        readonly created_at: Schema.Int;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly state: Schema.Literals<readonly ["joining", "satisfied", "failed", "cancelled"]>;
+        readonly members: Schema.$Array<Schema.Struct<{
+            readonly child_execution_id: Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
+            };
+            readonly ordinal: Schema.Int;
+            readonly state: Schema.Literals<readonly ["queued", "running", "completed", "failed", "cancelled"]>;
+            readonly output: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"text">;
+                readonly text: Schema.String;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"structured">;
+                readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly schema_ref: Schema.optionalKey<Schema.String>;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"blob-reference">;
+                readonly uri: Schema.String;
+                readonly media_type: Schema.String;
+                readonly filename: Schema.optionalKey<Schema.String>;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"artifact-reference">;
+                readonly artifact_id: Schema.String;
+                readonly media_type: Schema.optionalKey<Schema.String>;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"tool-call">;
+                readonly call: Schema.Struct<{
+                    readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+                    };
+                    readonly name: Schema.String;
+                    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                }>;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"tool-result">;
+                readonly result: Schema.Struct<{
+                    readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+                    };
+                    readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly error: Schema.optionalKey<Schema.String>;
+                    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                }>;
+                readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>]>>>;
+            readonly error: Schema.optionalKey<Schema.String>;
+            readonly completed_at: Schema.optionalKey<Schema.Int>;
+        }>>;
+        readonly satisfied_at: Schema.optionalKey<Schema.Int>;
+        readonly failed_at: Schema.optionalKey<Schema.Int>;
+        readonly cancelled_at: Schema.optionalKey<Schema.Int>;
+    }>>;
     readonly last_event_cursor: Schema.optionalKey<Schema.String>;
 }>;
 export interface ExecutionInspection extends Schema.Schema.Type<typeof ExecutionInspection> {
@@ -2718,7 +2995,7 @@ export declare const ReplayExecutionResult: Schema.Struct<{
         readonly child_execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
         }>;
-        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.started", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.delivered", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "model.call.started", "model.attempt.started", "model.attempt.first_output", "model.attempt.completed", "model.attempt.failed", "model.retry.scheduled", "model.call.completed", "model.call.failed", "agent.compaction.started", "agent.compaction.completed", "agent.compaction.failed", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.delivered", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
         readonly sequence: Schema.Int;
         readonly cursor: Schema.String;
         readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
@@ -2800,7 +3077,7 @@ export declare const PageExecutionEventsResult: Schema.Struct<{
         readonly child_execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
         }>;
-        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.started", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.delivered", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "model.call.started", "model.attempt.started", "model.attempt.first_output", "model.attempt.completed", "model.attempt.failed", "model.retry.scheduled", "model.call.completed", "model.call.failed", "agent.compaction.started", "agent.compaction.completed", "agent.compaction.failed", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.delivered", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
         readonly sequence: Schema.Int;
         readonly cursor: Schema.String;
         readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{