@relayfx/sdk 0.0.48 → 0.0.49

package/dist/types/runtime/cluster/execution-entity.d.ts

@@ -1,158 +1,14 @@
-import type { ChildExecutionRepository, ExecutionRepository } from "../../store-sql/index";
+import type { ChildExecutionRepository, EnvelopeRepository, ExecutionRepository, ToolCallRepository } from "../../store-sql/index";
 import { Entity } from "effect/unstable/cluster";
 import { Rpc } from "effect/unstable/rpc";
 import type { WorkflowEngine } from "effect/unstable/workflow";
 import { Schema } from "effect";
 import type { Effect } from "effect";
-import { ExecutionWorkflowFailed } from "../workflow/execution-workflow";
+import { ExecutionWorkflowFailed, StartInput, StartResult } from "../workflow/execution-workflow";
 import type { Service as EventLogService } from "../execution/event-log-service";
 import type { Service as WaitServiceService } from "../wait/wait-service";
-export declare const Start: Rpc.Rpc<"start", 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">;
-    };
-    readonly root_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-    };
-    readonly session_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.SessionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
-    }>;
-    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 event_sequence: Schema.Int;
-    readonly started_at: Schema.Int;
-    readonly completed_at: Schema.Int;
-    readonly agent_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
-    }>;
-    readonly agent_revision: Schema.optionalKey<Schema.Int>;
-    readonly agent_snapshot: Schema.optionalKey<Schema.Struct<{
-        readonly name: Schema.String;
-        readonly instructions: Schema.optionalKey<Schema.String>;
-        readonly model: 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.$Array<Schema.String>;
-        readonly permissions: Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly value: 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 skill_definition_ids: Schema.optionalKey<Schema.$Array<Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
-        }>>;
-        readonly permission_rules: Schema.optionalKey<Schema.Struct<{
-            readonly rules: Schema.$Array<Schema.Struct<{
-                readonly pattern: Schema.String;
-                readonly level: Schema.Literals<readonly ["allow", "deny", "ask"]>;
-                readonly reason: Schema.optionalKey<Schema.String>;
-            }>>;
-            readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
-        }>>;
-        readonly max_tool_turns: Schema.optionalKey<Schema.Int>;
-        readonly max_wait_turns: Schema.optionalKey<Schema.Int>;
-        readonly token_budget: Schema.optionalKey<Schema.Int>;
-        readonly child_run_presets: Schema.optionalKey<Schema.$Record<Schema.String, 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 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 handoff_targets: Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly preset_name: Schema.String;
-        }>>>;
-        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 agent_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-    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 resume_tool_call: Schema.optionalKey<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 workflow_generation: Schema.optionalKey<Schema.Int>;
-    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>, 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">;
-    };
-    readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
-    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 wait_state: Schema.optionalKey<Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>>;
-    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>, typeof ExecutionWorkflowFailed, never, never>;
+import type { Service as ToolTransitionCoordinatorService } from "../tool/tool-transition-coordinator";
+export declare const Start: Rpc.Rpc<"start", typeof StartInput, typeof StartResult, typeof ExecutionWorkflowFailed>;
 export declare const SignalWait: Rpc.Rpc<"signalWait", Schema.Struct<{
     readonly workflow_execution_id: Schema.String;
     readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
@@ -161,6 +17,7 @@ export declare const SignalWait: Rpc.Rpc<"signalWait", Schema.Struct<{
     readonly state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
     readonly signaled_at: Schema.Int;
 }>, Schema.Void, typeof ExecutionWorkflowFailed, never, never>;
+export declare const Dispatch: Rpc.Rpc<"dispatch", typeof StartInput, typeof Schema.Void, typeof ExecutionWorkflowFailed>;
 export declare const Cancel: Rpc.Rpc<"cancel", 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">;
@@ -173,332 +30,8 @@ export declare const Cancel: Rpc.Rpc<"cancel", Schema.Struct<{
     };
     readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
 }>, typeof ExecutionWorkflowFailed, never, never>;
-export declare const entity: Entity.Entity<"Relay/Execution", Rpc.Rpc<"start", 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">;
-    };
-    readonly root_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-    };
-    readonly session_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.SessionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
-    }>;
-    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 event_sequence: Schema.Int;
-    readonly started_at: Schema.Int;
-    readonly completed_at: Schema.Int;
-    readonly agent_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
-    }>;
-    readonly agent_revision: Schema.optionalKey<Schema.Int>;
-    readonly agent_snapshot: Schema.optionalKey<Schema.Struct<{
-        readonly name: Schema.String;
-        readonly instructions: Schema.optionalKey<Schema.String>;
-        readonly model: 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.$Array<Schema.String>;
-        readonly permissions: Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly value: 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 skill_definition_ids: Schema.optionalKey<Schema.$Array<Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
-        }>>;
-        readonly permission_rules: Schema.optionalKey<Schema.Struct<{
-            readonly rules: Schema.$Array<Schema.Struct<{
-                readonly pattern: Schema.String;
-                readonly level: Schema.Literals<readonly ["allow", "deny", "ask"]>;
-                readonly reason: Schema.optionalKey<Schema.String>;
-            }>>;
-            readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
-        }>>;
-        readonly max_tool_turns: Schema.optionalKey<Schema.Int>;
-        readonly max_wait_turns: Schema.optionalKey<Schema.Int>;
-        readonly token_budget: Schema.optionalKey<Schema.Int>;
-        readonly child_run_presets: Schema.optionalKey<Schema.$Record<Schema.String, 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 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 handoff_targets: Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly preset_name: Schema.String;
-        }>>>;
-        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 agent_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-    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 resume_tool_call: Schema.optionalKey<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 workflow_generation: Schema.optionalKey<Schema.Int>;
-    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>, 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">;
-    };
-    readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
-    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 wait_state: Schema.optionalKey<Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>>;
-    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>, typeof ExecutionWorkflowFailed, never, never> | Rpc.Rpc<"signalWait", Schema.Struct<{
-    readonly workflow_execution_id: Schema.String;
-    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 state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
-    readonly signaled_at: Schema.Int;
-}>, Schema.Void, typeof ExecutionWorkflowFailed, never, never> | Rpc.Rpc<"cancel", 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">;
-    };
-    readonly cancelled_at: Schema.Int;
-    readonly reason: Schema.optionalKey<Schema.String>;
-}>, 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">;
-    };
-    readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
-}>, typeof ExecutionWorkflowFailed, never, never>>;
-export declare const layer: import("effect/Layer").Layer<never, never, ChildExecutionRepository.Service | ExecutionRepository.Service | EventLogService | WaitServiceService | WorkflowEngine.WorkflowEngine | import("effect/unstable/cluster/Sharding").Sharding>;
-export declare const client: Effect.Effect<(entityId: string) => import("effect/unstable/rpc/RpcClient").RpcClient.From<Rpc.Rpc<"start", 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">;
-    };
-    readonly root_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-    };
-    readonly session_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.SessionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
-    }>;
-    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 event_sequence: Schema.Int;
-    readonly started_at: Schema.Int;
-    readonly completed_at: Schema.Int;
-    readonly agent_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
-    }>;
-    readonly agent_revision: Schema.optionalKey<Schema.Int>;
-    readonly agent_snapshot: Schema.optionalKey<Schema.Struct<{
-        readonly name: Schema.String;
-        readonly instructions: Schema.optionalKey<Schema.String>;
-        readonly model: 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.$Array<Schema.String>;
-        readonly permissions: Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly value: 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 skill_definition_ids: Schema.optionalKey<Schema.$Array<Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
-        }>>;
-        readonly permission_rules: Schema.optionalKey<Schema.Struct<{
-            readonly rules: Schema.$Array<Schema.Struct<{
-                readonly pattern: Schema.String;
-                readonly level: Schema.Literals<readonly ["allow", "deny", "ask"]>;
-                readonly reason: Schema.optionalKey<Schema.String>;
-            }>>;
-            readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
-        }>>;
-        readonly max_tool_turns: Schema.optionalKey<Schema.Int>;
-        readonly max_wait_turns: Schema.optionalKey<Schema.Int>;
-        readonly token_budget: Schema.optionalKey<Schema.Int>;
-        readonly child_run_presets: Schema.optionalKey<Schema.$Record<Schema.String, 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 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 handoff_targets: Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly preset_name: Schema.String;
-        }>>>;
-        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 agent_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-    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 resume_tool_call: Schema.optionalKey<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 workflow_generation: Schema.optionalKey<Schema.Int>;
-    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>, 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">;
-    };
-    readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
-    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 wait_state: Schema.optionalKey<Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>>;
-    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>, typeof ExecutionWorkflowFailed, never, never> | Rpc.Rpc<"signalWait", Schema.Struct<{
-    readonly workflow_execution_id: Schema.String;
-    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 state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
-    readonly signaled_at: Schema.Int;
-}>, Schema.Void, typeof ExecutionWorkflowFailed, never, never> | Rpc.Rpc<"cancel", 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">;
-    };
-    readonly cancelled_at: Schema.Int;
-    readonly reason: Schema.optionalKey<Schema.String>;
-}>, 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">;
-    };
-    readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
-}>, typeof ExecutionWorkflowFailed, never, never>, import("effect/unstable/cluster/ClusterError").MailboxFull | import("effect/unstable/cluster/ClusterError").AlreadyProcessingMessage | import("effect/unstable/cluster/ClusterError").PersistenceError>, never, import("effect/unstable/cluster/Sharding").Sharding>;
+type ExecutionRpc = typeof Start | typeof Dispatch | typeof SignalWait | typeof Cancel;
+export declare const entity: Entity.Entity<"Relay/Execution", ExecutionRpc>;
+export declare const layer: import("effect/Layer").Layer<never, never, ChildExecutionRepository.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | EventLogService | WaitServiceService | ToolTransitionCoordinatorService | WorkflowEngine.WorkflowEngine | import("effect/unstable/cluster/Sharding").Sharding>;
+export declare const client: Effect.Effect<(entityId: string) => import("effect/unstable/rpc/RpcClient").RpcClient.From<ExecutionRpc, import("effect/unstable/cluster/ClusterError").MailboxFull | import("effect/unstable/cluster/ClusterError").AlreadyProcessingMessage | import("effect/unstable/cluster/ClusterError").PersistenceError>, never, import("effect/unstable/cluster/Sharding").Sharding>;
+export {};

package/dist/types/runtime/execution/event-log-service.d.ts

@@ -28,6 +28,10 @@ export interface FindByCursorInput {
     readonly executionId: Ids.ExecutionId;
     readonly cursor: string;
 }
+export interface FindBySequenceInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly sequence: Execution.ExecutionEventSequence;
+}
 export interface FindFirstByTypeAfterSequenceInput {
     readonly executionId: Ids.ExecutionId;
     readonly type: Execution.ExecutionEventType;
@@ -39,6 +43,7 @@ export interface Interface {
     readonly stream: (input: ReplayInput) => Stream.Stream<Execution.ExecutionEvent, EventLogCursorNotFound | EventLogError>;
     readonly findBySequenceOrCursor: (input: FindBySequenceOrCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
     readonly findByCursor: (input: FindByCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
+    readonly findBySequence: (input: FindBySequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
     readonly findFirstByTypeAfterSequence: (input: FindFirstByTypeAfterSequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
     readonly maxSequence: (executionId: Ids.ExecutionId) => Effect.Effect<Execution.ExecutionEventSequence | undefined, EventLogError>;
     readonly sumUsage: (executionId: Ids.ExecutionId) => Effect.Effect<number, EventLogError>;
@@ -55,6 +60,7 @@ export declare const appendIdempotent: (input: Execution.ExecutionEvent) => Effe
 export declare const replay: (input: ReplayInput) => Effect.Effect<readonly Execution.ExecutionEvent[], EventLogCursorNotFound | EventLogError, Service>;
 export declare const findBySequenceOrCursor: (input: FindBySequenceOrCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError, Service>;
 export declare const findByCursor: (input: FindByCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError, Service>;
+export declare const findBySequence: (input: FindBySequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError, Service>;
 export declare const findFirstByTypeAfterSequence: (input: FindFirstByTypeAfterSequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError, Service>;
 export declare const maxSequence: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<number | undefined, EventLogError, Service>;
 export declare const sumUsage: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<number, EventLogError, Service>;

package/dist/types/runtime/index.d.ts

@@ -26,6 +26,7 @@ export * as SchemaRegistry from "./schema-registry/schema-registry-service";
 export * as RelaySessionStore from "./session/session-store-service";
 export * as SkillRegistry from "./skill/skill-registry-service";
 export * as ToolRuntime from "./tool/tool-runtime-service";
+export * as ToolTransitionCoordinator from "./tool/tool-transition-coordinator";
 export * as ToolInputSchemaDigest from "./tool/tool-input-schema-digest";
 export * as WaitService from "./wait/wait-service";
 export * as WaitSignal from "./wait/wait-signal";