@relayfx/sdk 0.0.48 → 0.0.50

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

@@ -1,3 +1,4 @@
+import { Agent } from "../schema/index";
 import { Schema } from "effect";
 export declare const StartExecutionInput: Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
@@ -65,61 +66,76 @@ export declare const StartExecutionInput: Schema.Struct<{
         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 agent_snapshot: Schema.optionalKey<Schema.Codec<Agent.Definition, {
+        readonly name: string;
+        readonly permissions: readonly {
+            readonly name: string;
+            readonly value: Schema.Json;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+        }[];
+        readonly model: {
+            readonly provider: string;
+            readonly model: string;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+            readonly registration_key?: string;
+            readonly request_options?: {
+                readonly [x: string]: Schema.Json;
+            };
+        };
+        readonly tool_names: readonly string[];
+        readonly metadata?: {
+            readonly [x: string]: Schema.Json;
+        };
+        readonly instructions?: string;
+        readonly output_schema_ref?: string;
+        readonly skill_definition_ids?: readonly string[];
+        readonly permission_rules?: {
+            readonly rules: readonly {
+                readonly pattern: string;
+                readonly level: "allow" | "deny" | "ask";
+                readonly reason?: string;
+            }[];
+            readonly fallback?: "allow" | "deny" | "ask";
+        };
+        readonly turn_policy?: Agent.TurnPolicySnapshot;
+        readonly max_tool_turns?: number;
+        readonly max_wait_turns?: number;
+        readonly token_budget?: number;
+        readonly child_run_presets?: {
+            readonly [x: string]: {
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly permissions?: readonly string[];
+                readonly model?: {
+                    readonly provider: string;
+                    readonly model: string;
+                    readonly metadata?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                    readonly registration_key?: string;
+                    readonly request_options?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                };
+                readonly instructions?: string;
+                readonly tool_names?: readonly string[];
+                readonly workspace_policy?: {
+                    readonly mode: "share" | "fork";
+                    readonly fallback?: "fail" | "fresh";
+                };
+                readonly output_schema_ref?: string;
+            };
+        };
+        readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
             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>>>;
-    }>>;
+        }, "Encoded">[];
+    }, 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">;
@@ -377,6 +393,390 @@ export declare const PendingToolApprovalList: Schema.Struct<{
 }>;
 export interface PendingToolApprovalList extends Schema.Schema.Type<typeof PendingToolApprovalList> {
 }
+export declare const PendingToolCall: 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 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 definition: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly description: Schema.String;
+        readonly input_schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly output_schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        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 requirements: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"workspace">;
+            readonly mode: Schema.Literals<readonly ["read", "write", "exec"]>;
+        }>]>>>;
+        readonly needs_approval: Schema.optionalKey<Schema.Boolean>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>;
+    readonly placement: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"local">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"client">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"remote">;
+        readonly queue: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"mcp">;
+        readonly server_id: Schema.String;
+    }>]>;
+    readonly state: Schema.Literals<readonly ["requested", "waiting", "running", "submitted", "completed", "failed"]>;
+    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 idempotency_key: Schema.String;
+    readonly requested_at: Schema.Int;
+}>;
+export interface PendingToolCall extends Schema.Schema.Type<typeof PendingToolCall> {
+}
+export declare const ListPendingToolCallsInput: Schema.Struct<{
+    readonly execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    }>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+export interface ListPendingToolCallsInput extends Schema.Schema.Type<typeof ListPendingToolCallsInput> {
+}
+export declare const PendingToolCallList: Schema.Struct<{
+    readonly tool_calls: Schema.$Array<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 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 definition: Schema.Struct<{
+            readonly name: Schema.String;
+            readonly description: Schema.String;
+            readonly input_schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly output_schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            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 requirements: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"workspace">;
+                readonly mode: Schema.Literals<readonly ["read", "write", "exec"]>;
+            }>]>>>;
+            readonly needs_approval: Schema.optionalKey<Schema.Boolean>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly placement: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"local">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"client">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"remote">;
+            readonly queue: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"mcp">;
+            readonly server_id: Schema.String;
+        }>]>;
+        readonly state: Schema.Literals<readonly ["requested", "waiting", "running", "submitted", "completed", "failed"]>;
+        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 idempotency_key: Schema.String;
+        readonly requested_at: Schema.Int;
+    }>>;
+}>;
+export interface PendingToolCallList extends Schema.Schema.Type<typeof PendingToolCallList> {
+}
+export declare const FulfillToolCallInput: 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 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 outcome: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"success">;
+        readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"failure">;
+        readonly message: Schema.String;
+    }>]>;
+    readonly fulfilled_at: Schema.Int;
+}>;
+export interface FulfillToolCallInput extends Schema.Schema.Type<typeof FulfillToolCallInput> {
+}
+export declare const ClaimToolWorkInput: Schema.Struct<{
+    readonly queue: Schema.String;
+    readonly worker_id: Schema.String;
+    readonly now: Schema.Int;
+    readonly claim_expires_at: Schema.Int;
+}>;
+export interface ClaimToolWorkInput extends Schema.Schema.Type<typeof ClaimToolWorkInput> {
+}
+export declare const CompleteToolWorkInput: 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">;
+    };
+    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 worker_id: Schema.String;
+    readonly outcome: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"success">;
+        readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"failure">;
+        readonly message: Schema.String;
+    }>]>;
+    readonly completed_at: Schema.Int;
+}>;
+export interface CompleteToolWorkInput extends Schema.Schema.Type<typeof CompleteToolWorkInput> {
+}
+export declare const ReleaseToolWorkInput: 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">;
+    };
+    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 worker_id: Schema.String;
+    readonly released_at: Schema.Int;
+    readonly next_available_at: Schema.Int;
+    readonly error: Schema.optionalKey<Schema.String>;
+}>;
+export interface ReleaseToolWorkInput extends Schema.Schema.Type<typeof ReleaseToolWorkInput> {
+}
+export declare const ListToolAttemptsInput: 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">;
+    };
+}>;
+export interface ListToolAttemptsInput extends Schema.Schema.Type<typeof ListToolAttemptsInput> {
+}
+export declare const ToolAttempt: 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>;
+}>;
+export interface ToolAttempt extends Schema.Schema.Type<typeof ToolAttempt> {
+}
+export declare const ToolAttemptList: Schema.Struct<{
+    readonly 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>;
+    }>>;
+}>;
+export interface ToolAttemptList extends Schema.Schema.Type<typeof ToolAttemptList> {
+}
+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">;
+    };
+    readonly attempt: 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 duplicate: Schema.Boolean;
+}>;
+export interface ToolOutcomeAccepted extends Schema.Schema.Type<typeof ToolOutcomeAccepted> {
+}
+export declare const ToolWorkLease: 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 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 definition: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly description: Schema.String;
+        readonly input_schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly output_schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        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 requirements: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"workspace">;
+            readonly mode: Schema.Literals<readonly ["read", "write", "exec"]>;
+        }>]>>>;
+        readonly needs_approval: Schema.optionalKey<Schema.Boolean>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>;
+    readonly placement: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"local">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"client">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"remote">;
+        readonly queue: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"mcp">;
+        readonly server_id: Schema.String;
+    }>]>;
+    readonly attempt: 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 queue: Schema.String;
+    readonly worker_id: Schema.String;
+    readonly claim_expires_at: Schema.Int;
+    readonly idempotency_key: Schema.String;
+}>;
+export interface ToolWorkLease extends Schema.Schema.Type<typeof ToolWorkLease> {
+}
+export declare const ToolWorkReleased: 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">;
+    };
+    readonly state: Schema.Literal<"waiting">;
+    readonly next_available_at: Schema.Int;
+}>;
+export interface ToolWorkReleased extends Schema.Schema.Type<typeof ToolWorkReleased> {
+}
+export declare const SpawnChildRunInput: 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 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 address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly preset_name: Schema.optionalKey<Schema.String>;
+    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 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 wait: Schema.optionalKey<Schema.Boolean>;
+}>;
+export interface SpawnChildRunInput extends Schema.Schema.Type<typeof SpawnChildRunInput> {
+}
 export declare const ResolveToolApprovalInput: 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">;
@@ -951,6 +1351,78 @@ export declare const ConversationSummary: Schema.Struct<{
 }>;
 export interface ConversationSummary extends Schema.Schema.Type<typeof ConversationSummary> {
 }
+export declare const ToolCallSummary: 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">;
+    };
+    readonly tool_name: Schema.String;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly requested_at: Schema.Int;
+}>;
+export interface ToolCallSummary extends Schema.Schema.Type<typeof ToolCallSummary> {
+}
+export declare const ChildRunSummary: 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 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 ChildRunSummary extends Schema.Schema.Type<typeof ChildRunSummary> {
+}
+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">;
+    };
+    readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+    readonly waiting_on: 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 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">;
+        };
+        readonly tool_name: Schema.String;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly requested_at: Schema.Int;
+    }>>;
+    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">;
+        };
+        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 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 last_event_cursor: Schema.optionalKey<Schema.String>;
+}>;
+export interface ExecutionInspection extends Schema.Schema.Type<typeof ExecutionInspection> {
+}
 export declare const ListExecutionsResult: Schema.Struct<{
     readonly records: Schema.$Array<Schema.Struct<{
         readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {

package/dist/types/relay/tool-worker.d.ts

@@ -0,0 +1,19 @@
+import { Shared, Tool } from "../schema/index";
+import { Duration, Effect } from "effect";
+import type { ClientError } from "./client";
+import type { ToolWorkLease } from "./operation";
+export interface HandlerContext {
+    readonly lease: ToolWorkLease;
+    readonly idempotencyKey: string;
+}
+export type Handler = (input: Shared.JsonValue, context: HandlerContext) => Effect.Effect<Shared.JsonValue, unknown, any>;
+export interface Options {
+    readonly queue: Tool.PlacementKey;
+    readonly workerId: Tool.WorkerId;
+    readonly leaseDuration: Duration.Input;
+    readonly pollInterval?: Duration.Input | undefined;
+    readonly handlers: Readonly<Record<string, Handler>>;
+}
+export declare const runOnce: (options: Options) => Effect.Effect<boolean, ClientError, any>;
+export declare const run: (options: Options) => Effect.Effect<never, ClientError, any>;
+export type Error = ClientError;