@roll-agent/relay-protocol 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,1050 @@
+import { type JsonValue } from "@roll-agent/protocol";
+import { z } from "zod/v4";
+export declare const SUPPORTED_RELAY_PROTOCOL_VERSIONS: readonly ["1.0"];
+export type RelayProtocolVersion = (typeof SUPPORTED_RELAY_PROTOCOL_VERSIONS)[number];
+export declare const RELAY_PROTOCOL_VERSION: "1.0";
+/** @deprecated Use `RELAY_PROTOCOL_VERSION`. */
+export declare const COMPANION_RELAY_PROTOCOL_VERSION: "1.0";
+export declare const RELAY_MESSAGE_TYPES: {
+    readonly deviceConnect: "device.connect";
+    readonly runtimeRequest: "runtime.request";
+    readonly runtimeResponse: "runtime.response";
+    readonly runtimeEvent: "runtime.event";
+    readonly runtimeAck: "runtime.ack";
+    readonly runtimeGap: "runtime.gap";
+    readonly runtimeEncrypted: "runtime.encrypted";
+};
+export declare const RELAY_MESSAGE_TYPE_VALUES: readonly ["device.connect", "runtime.request", "runtime.response", "runtime.event", "runtime.ack", "runtime.gap", "runtime.encrypted"];
+/**
+ * Relay Wire 1.0 is intentionally independent from the latest Runtime registry.
+ * New Runtime methods never become remotely callable without a Relay version change.
+ */
+export declare const RELAY_REQUEST_METHODS: {
+    readonly initialize: "initialize";
+    readonly threadList: "thread.list";
+    readonly threadCreate: "thread.create";
+    readonly threadOpen: "thread.open";
+    readonly threadSnapshot: "thread.snapshot";
+    readonly threadRename: "thread.rename";
+    readonly threadDelete: "thread.delete";
+    readonly threadDetach: "thread.detach";
+    readonly threadCapabilities: "thread.capabilities";
+    readonly turnStart: "turn.start";
+    readonly turnCancel: "turn.cancel";
+    readonly approvalRespond: "approval.respond";
+    readonly operationGet: "operation.get";
+    readonly approvalCandidate: "approval.candidate";
+};
+export type RelayRequestMethod = (typeof RELAY_REQUEST_METHODS)[keyof typeof RELAY_REQUEST_METHODS];
+export declare const RELAY_REQUEST_METHOD_VALUES: readonly ["initialize", "thread.list", "thread.create", "thread.open", "thread.snapshot", "thread.rename", "thread.delete", "thread.detach", "thread.capabilities", "turn.start", "turn.cancel", "approval.respond", "operation.get", "approval.candidate"];
+export declare const RELAY_REQUEST_METHOD_DISPOSITIONS: {
+    readonly initialize: "local-only";
+    readonly "thread.list": "query";
+    readonly "thread.create": "mutation";
+    readonly "thread.open": "query";
+    readonly "thread.snapshot": "query";
+    readonly "thread.rename": "mutation";
+    readonly "thread.delete": "mutation";
+    readonly "thread.detach": "mutation";
+    readonly "thread.capabilities": "query";
+    readonly "turn.start": "mutation";
+    readonly "turn.cancel": "mutation";
+    readonly "approval.respond": "mutation";
+    readonly "operation.get": "query";
+    readonly "approval.candidate": "mutation";
+};
+export type RelayRequestMethodDisposition = (typeof RELAY_REQUEST_METHOD_DISPOSITIONS)[RelayRequestMethod];
+export declare const RELAY_MUTATION_REQUEST_METHODS: readonly ["thread.create", "thread.rename", "thread.delete", "thread.detach", "turn.start", "turn.cancel", "approval.respond", "approval.candidate"];
+export declare const RELAY_LOCAL_ONLY_REQUEST_METHODS: readonly ["initialize"];
+export declare const RELAY_ERROR_CODES: {
+    readonly protocolVersionUnsupported: "RELAY_PROTOCOL_VERSION_UNSUPPORTED";
+    readonly invalidFrame: "RELAY_INVALID_FRAME";
+    readonly invalidParams: "INVALID_PARAMS";
+    readonly requestIdConflict: "RELAY_REQUEST_ID_CONFLICT";
+    readonly workspaceNotFound: "WORKSPACE_NOT_FOUND";
+    readonly encryptionRequired: "RELAY_ENCRYPTION_REQUIRED";
+    readonly encryptedPayloadInvalid: "ENCRYPTED_PAYLOAD_INVALID";
+    readonly localApprovalDenied: "LocalApprovalDeniedError";
+    readonly localConfirmationRequired: "LocalConfirmationRequiredError";
+    readonly companionError: "COMPANION_ERROR";
+};
+export type RelayErrorCode = (typeof RELAY_ERROR_CODES)[keyof typeof RELAY_ERROR_CODES];
+export declare const RELAY_ERROR_RETRYABILITY: {
+    readonly RELAY_PROTOCOL_VERSION_UNSUPPORTED: false;
+    readonly RELAY_INVALID_FRAME: false;
+    readonly INVALID_PARAMS: false;
+    readonly RELAY_REQUEST_ID_CONFLICT: false;
+    readonly WORKSPACE_NOT_FOUND: false;
+    readonly RELAY_ENCRYPTION_REQUIRED: false;
+    readonly ENCRYPTED_PAYLOAD_INVALID: false;
+    readonly LocalApprovalDeniedError: false;
+    readonly LocalConfirmationRequiredError: false;
+    readonly COMPANION_ERROR: false;
+};
+export declare function getRelayErrorRetryability(code: RelayErrorCode): boolean;
+export declare const relayProtocolVersionSchema: z.ZodEnum<{
+    "1.0": "1.0";
+}>;
+export declare const deviceIdSchema: z.core.$ZodBranded<z.ZodString, "DeviceId">;
+export declare const workspaceIdSchema: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+export declare const relayRequestIdSchema: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+export declare const relayEnvelopeIdSchema: z.ZodString;
+export declare const relayApprovalCandidateParamsSchema: z.ZodReadonly<z.ZodObject<{
+    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+    approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+    decision: z.ZodEnum<{
+        approve: "approve";
+        reject: "reject";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;
+export declare const relayApprovalCandidateResultSchema: z.ZodReadonly<z.ZodObject<{
+    accepted: z.ZodLiteral<true>;
+}, z.core.$strict>>;
+export declare const relayRequestMethodSchemas: {
+    readonly initialize: {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            protocolVersions: z.ZodArray<z.ZodString>;
+            client: z.ZodReadonly<z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            protocolVersion: z.ZodEnum<{
+                1.1: "1.1";
+                "1.0": "1.0";
+            }>;
+            runtimeInstanceId: z.core.$ZodBranded<z.ZodString, "RuntimeInstanceId">;
+            server: z.ZodReadonly<z.ZodObject<{
+                runtimeVersion: z.ZodString;
+                name: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strict>>;
+            features: z.ZodArray<z.ZodEnum<{
+                "thread-management": "thread-management";
+                snapshots: "snapshots";
+                turns: "turns";
+                approvals: "approvals";
+                "tool-streaming": "tool-streaming";
+                "reasoning-summary": "reasoning-summary";
+                "operation-projection": "operation-projection";
+                "process-local-sequence": "process-local-sequence";
+            }>>;
+            limits: z.ZodReadonly<z.ZodObject<{
+                maxFrameBytes: z.ZodNumber;
+                maxPageSize: z.ZodNumber;
+                eventReplay: z.ZodLiteral<false>;
+                idempotencyCacheEntries: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.list": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            cursor: z.ZodOptional<z.ZodString>;
+            limit: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                title: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                messageCount: z.ZodNumber;
+            }, z.core.$strict>>>;
+            nextCursor: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.create": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            thread: z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                title: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                messageCount: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.open": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            thread: z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                title: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                messageCount: z.ZodNumber;
+            }, z.core.$strict>>;
+            messages: z.ZodReadonly<z.ZodObject<{
+                items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    sequence: z.ZodNumber;
+                    role: z.ZodEnum<{
+                        user: "user";
+                        assistant: "assistant";
+                    }>;
+                    createdAt: z.ZodString;
+                    parts: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        type: z.ZodLiteral<"text">;
+                        text: z.ZodString;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>>;
+                nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            operations: z.ZodReadonly<z.ZodObject<{
+                items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    id: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                    sequence: z.ZodNumber;
+                    toolCallId: z.ZodString;
+                    agentName: z.ZodString;
+                    toolName: z.ZodString;
+                    createdAt: z.ZodString;
+                    outcome: z.ZodReadonly<z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            success: "success";
+                            user_rejected: "user_rejected";
+                            policy_denied: "policy_denied";
+                            invalid_input: "invalid_input";
+                            cancelled: "cancelled";
+                            tool_failed: "tool_failed";
+                        }>;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    display: z.ZodJSONSchema;
+                }, z.core.$strict>>>;
+                nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            activeTurn: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                status: z.ZodEnum<{
+                    running: "running";
+                    cancelling: "cancelling";
+                }>;
+                startedAt: z.ZodString;
+            }, z.core.$strict>>>;
+            pendingApprovals: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                preview: z.ZodJSONSchema;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            transcriptCompleteness: z.ZodEnum<{
+                complete: "complete";
+                legacy_snapshot: "legacy_snapshot";
+            }>;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.snapshot": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            messageBeforeSequence: z.ZodOptional<z.ZodNumber>;
+            operationBeforeSequence: z.ZodOptional<z.ZodNumber>;
+            limit: z.ZodDefault<z.ZodNumber>;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            thread: z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                title: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                messageCount: z.ZodNumber;
+            }, z.core.$strict>>;
+            messages: z.ZodReadonly<z.ZodObject<{
+                items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    sequence: z.ZodNumber;
+                    role: z.ZodEnum<{
+                        user: "user";
+                        assistant: "assistant";
+                    }>;
+                    createdAt: z.ZodString;
+                    parts: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        type: z.ZodLiteral<"text">;
+                        text: z.ZodString;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>>;
+                nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            operations: z.ZodReadonly<z.ZodObject<{
+                items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    id: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                    sequence: z.ZodNumber;
+                    toolCallId: z.ZodString;
+                    agentName: z.ZodString;
+                    toolName: z.ZodString;
+                    createdAt: z.ZodString;
+                    outcome: z.ZodReadonly<z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            success: "success";
+                            user_rejected: "user_rejected";
+                            policy_denied: "policy_denied";
+                            invalid_input: "invalid_input";
+                            cancelled: "cancelled";
+                            tool_failed: "tool_failed";
+                        }>;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    display: z.ZodJSONSchema;
+                }, z.core.$strict>>>;
+                nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            activeTurn: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                status: z.ZodEnum<{
+                    running: "running";
+                    cancelling: "cancelling";
+                }>;
+                startedAt: z.ZodString;
+            }, z.core.$strict>>>;
+            pendingApprovals: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                preview: z.ZodJSONSchema;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            transcriptCompleteness: z.ZodEnum<{
+                complete: "complete";
+                legacy_snapshot: "legacy_snapshot";
+            }>;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.rename": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            title: z.ZodString;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            thread: z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                title: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                messageCount: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.delete": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            deleted: z.ZodLiteral<true>;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.detach": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            detached: z.ZodBoolean;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.capabilities": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            manifest: z.ZodJSONSchema;
+        }, z.core.$strict>>;
+    };
+    readonly "turn.start": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+            input: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+            }, z.core.$strict>>;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            accepted: z.ZodLiteral<true>;
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+        }, z.core.$strict>>;
+    };
+    readonly "turn.cancel": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            cancelling: z.ZodBoolean;
+        }, z.core.$strict>>;
+    };
+    readonly "approval.respond": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+            approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+            decision: z.ZodEnum<{
+                approve: "approve";
+                reject: "reject";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            resolved: z.ZodLiteral<true>;
+        }, z.core.$strict>>;
+    };
+    readonly "operation.get": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            operationId: z.core.$ZodBranded<z.ZodString, "OperationId">;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            operation: z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                sequence: z.ZodNumber;
+                toolCallId: z.ZodString;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                createdAt: z.ZodString;
+                outcome: z.ZodReadonly<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        success: "success";
+                        user_rejected: "user_rejected";
+                        policy_denied: "policy_denied";
+                        invalid_input: "invalid_input";
+                        cancelled: "cancelled";
+                        tool_failed: "tool_failed";
+                    }>;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                display: z.ZodJSONSchema;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    };
+    readonly "approval.candidate": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+            approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+            decision: z.ZodEnum<{
+                approve: "approve";
+                reject: "reject";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            accepted: z.ZodLiteral<true>;
+        }, z.core.$strict>>;
+    };
+};
+export type RelayRequestParams<TMethod extends RelayRequestMethod> = z.infer<(typeof relayRequestMethodSchemas)[TMethod]["params"]>;
+export type RelayRequestResult<TMethod extends RelayRequestMethod> = z.infer<(typeof relayRequestMethodSchemas)[TMethod]["result"]>;
+export declare function isRelayRequestMethod(value: string): value is RelayRequestMethod;
+export declare function getRelayRequestMethodDisposition(value: string): RelayRequestMethodDisposition | undefined;
+export declare function isRelayMutationRequestMethod(method: RelayRequestMethod): method is (typeof RELAY_MUTATION_REQUEST_METHODS)[number];
+export declare function parseRelayRequestParams<TMethod extends RelayRequestMethod>(method: TMethod, value: unknown): RelayRequestParams<TMethod>;
+export declare function parseRelayRequestResult<TMethod extends RelayRequestMethod>(method: TMethod, value: unknown): RelayRequestResult<TMethod>;
+export declare const relayDeviceConnectSchema: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"device.connect">;
+    protocolVersion: z.ZodLiteral<"1.0">;
+    deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
+    pairingToken: z.ZodString;
+}, z.core.$strict>>;
+export declare const relayRuntimeRequestSchema: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.request">;
+    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    method: z.ZodEnum<{
+        initialize: "initialize";
+        "thread.list": "thread.list";
+        "thread.create": "thread.create";
+        "thread.open": "thread.open";
+        "thread.snapshot": "thread.snapshot";
+        "thread.rename": "thread.rename";
+        "thread.delete": "thread.delete";
+        "thread.detach": "thread.detach";
+        "thread.capabilities": "thread.capabilities";
+        "turn.start": "turn.start";
+        "turn.cancel": "turn.cancel";
+        "approval.respond": "approval.respond";
+        "operation.get": "operation.get";
+        "approval.candidate": "approval.candidate";
+    }>;
+    params: z.ZodJSONSchema;
+}, z.core.$strict>>;
+export declare const relayErrorSchema: z.ZodReadonly<z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    retryable: z.ZodBoolean;
+}, z.core.$strict>>;
+/**
+ * This preserves the pre-freeze v1.0 shape: result/error are independently optional.
+ * A strict exactly-one response belongs in a later Relay Wire version.
+ */
+export declare const relayRuntimeResponseSchema: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.response">;
+    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    result: z.ZodOptional<z.ZodJSONSchema>;
+    error: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>;
+export declare const relayRuntimeEventSchema: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.event">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    relaySequence: z.ZodNumber;
+    event: z.ZodReadonly<z.ZodObject<{
+        protocolVersion: z.ZodEnum<{
+            1.1: "1.1";
+            "1.0": "1.0";
+        }>;
+        runtimeInstanceId: z.core.$ZodBranded<z.ZodString, "RuntimeInstanceId">;
+        sequence: z.ZodNumber;
+        timestamp: z.ZodString;
+        threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        turnId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TurnId">>;
+        event: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.started">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.started">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.delta">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.completed">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            text: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"reasoning.summary.delta">;
+            reasoningId: z.ZodString;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.started">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            input: z.ZodJSONSchema;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.output">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            stream: z.ZodEnum<{
+                stdout: "stdout";
+                stderr: "stderr";
+            }>;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.completed">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
+            outcome: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    success: "success";
+                    user_rejected: "user_rejected";
+                    policy_denied: "policy_denied";
+                    invalid_input: "invalid_input";
+                    cancelled: "cancelled";
+                    tool_failed: "tool_failed";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            display: z.ZodJSONSchema;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"approval.required">;
+            approval: z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                preview: z.ZodJSONSchema;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"approval.resolved">;
+            approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+            resolution: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"resolved">;
+                decision: z.ZodLiteral<"approve">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"resolved">;
+                decision: z.ZodLiteral<"reject">;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"cancelled">;
+                reason: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"expired">;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>]>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.completed">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.cancelled">;
+            reason: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.failed">;
+            stage: z.ZodEnum<{
+                bootstrap: "bootstrap";
+                plan: "plan";
+                execute: "execute";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"capabilities.changed">;
+        }, z.core.$strict>>]>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const relayAckSchema: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.ack">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    throughRelaySequence: z.ZodNumber;
+}, z.core.$strict>>;
+export declare const relayGapSchema: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.gap">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    fromRelaySequence: z.ZodNumber;
+    throughRelaySequence: z.ZodNumber;
+    recovery: z.ZodLiteral<"thread.snapshot">;
+}, z.core.$strict>>;
+/**
+ * This preserves the pre-freeze v1.0 metadata shape. Payload-kind-specific required
+ * fields must be introduced under a later Relay Wire version.
+ */
+export declare const relayEncryptedMessageSchema: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.encrypted">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    envelopeId: z.ZodString;
+    payloadKind: z.ZodEnum<{
+        event: "event";
+        request: "request";
+        response: "response";
+    }>;
+    requestId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RelayRequestId">>;
+    relaySequence: z.ZodOptional<z.ZodNumber>;
+    algorithm: z.ZodString;
+    nonce: z.ZodString;
+    ciphertext: z.ZodString;
+}, z.core.$strict>>;
+export declare const relayMessageSchemas: {
+    readonly "device.connect": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"device.connect">;
+        protocolVersion: z.ZodLiteral<"1.0">;
+        deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
+        pairingToken: z.ZodString;
+    }, z.core.$strict>>;
+    readonly "runtime.request": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.request">;
+        requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        method: z.ZodEnum<{
+            initialize: "initialize";
+            "thread.list": "thread.list";
+            "thread.create": "thread.create";
+            "thread.open": "thread.open";
+            "thread.snapshot": "thread.snapshot";
+            "thread.rename": "thread.rename";
+            "thread.delete": "thread.delete";
+            "thread.detach": "thread.detach";
+            "thread.capabilities": "thread.capabilities";
+            "turn.start": "turn.start";
+            "turn.cancel": "turn.cancel";
+            "approval.respond": "approval.respond";
+            "operation.get": "operation.get";
+            "approval.candidate": "approval.candidate";
+        }>;
+        params: z.ZodJSONSchema;
+    }, z.core.$strict>>;
+    readonly "runtime.response": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.response">;
+        requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        result: z.ZodOptional<z.ZodJSONSchema>;
+        error: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    readonly "runtime.event": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.event">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        relaySequence: z.ZodNumber;
+        event: z.ZodReadonly<z.ZodObject<{
+            protocolVersion: z.ZodEnum<{
+                1.1: "1.1";
+                "1.0": "1.0";
+            }>;
+            runtimeInstanceId: z.core.$ZodBranded<z.ZodString, "RuntimeInstanceId">;
+            sequence: z.ZodNumber;
+            timestamp: z.ZodString;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            turnId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TurnId">>;
+            event: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"turn.started">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"message.started">;
+                streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"message.delta">;
+                streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+                delta: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"message.completed">;
+                streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+                text: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"reasoning.summary.delta">;
+                reasoningId: z.ZodString;
+                delta: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"tool.started">;
+                toolCallId: z.ZodString;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                input: z.ZodJSONSchema;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"tool.output">;
+                toolCallId: z.ZodString;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                stream: z.ZodEnum<{
+                    stdout: "stdout";
+                    stderr: "stderr";
+                }>;
+                delta: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"tool.completed">;
+                toolCallId: z.ZodString;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
+                outcome: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        success: "success";
+                        user_rejected: "user_rejected";
+                        policy_denied: "policy_denied";
+                        invalid_input: "invalid_input";
+                        cancelled: "cancelled";
+                        tool_failed: "tool_failed";
+                    }>;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                display: z.ZodJSONSchema;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"approval.required">;
+                approval: z.ZodReadonly<z.ZodObject<{
+                    id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                    agentName: z.ZodString;
+                    toolName: z.ZodString;
+                    preview: z.ZodJSONSchema;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"approval.resolved">;
+                approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                resolution: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+                    status: z.ZodLiteral<"resolved">;
+                    decision: z.ZodLiteral<"approve">;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    status: z.ZodLiteral<"resolved">;
+                    decision: z.ZodLiteral<"reject">;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    status: z.ZodLiteral<"cancelled">;
+                    reason: z.ZodString;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    status: z.ZodLiteral<"expired">;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>]>;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"turn.completed">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"turn.cancelled">;
+                reason: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"turn.failed">;
+                stage: z.ZodEnum<{
+                    bootstrap: "bootstrap";
+                    plan: "plan";
+                    execute: "execute";
+                }>;
+                message: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"capabilities.changed">;
+            }, z.core.$strict>>]>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    readonly "runtime.ack": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.ack">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        throughRelaySequence: z.ZodNumber;
+    }, z.core.$strict>>;
+    readonly "runtime.gap": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.gap">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        fromRelaySequence: z.ZodNumber;
+        throughRelaySequence: z.ZodNumber;
+        recovery: z.ZodLiteral<"thread.snapshot">;
+    }, z.core.$strict>>;
+    readonly "runtime.encrypted": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.encrypted">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        envelopeId: z.ZodString;
+        payloadKind: z.ZodEnum<{
+            event: "event";
+            request: "request";
+            response: "response";
+        }>;
+        requestId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RelayRequestId">>;
+        relaySequence: z.ZodOptional<z.ZodNumber>;
+        algorithm: z.ZodString;
+        nonce: z.ZodString;
+        ciphertext: z.ZodString;
+    }, z.core.$strict>>;
+};
+export declare const relayMessageSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"device.connect">;
+    protocolVersion: z.ZodLiteral<"1.0">;
+    deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
+    pairingToken: z.ZodString;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.request">;
+    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    method: z.ZodEnum<{
+        initialize: "initialize";
+        "thread.list": "thread.list";
+        "thread.create": "thread.create";
+        "thread.open": "thread.open";
+        "thread.snapshot": "thread.snapshot";
+        "thread.rename": "thread.rename";
+        "thread.delete": "thread.delete";
+        "thread.detach": "thread.detach";
+        "thread.capabilities": "thread.capabilities";
+        "turn.start": "turn.start";
+        "turn.cancel": "turn.cancel";
+        "approval.respond": "approval.respond";
+        "operation.get": "operation.get";
+        "approval.candidate": "approval.candidate";
+    }>;
+    params: z.ZodJSONSchema;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.response">;
+    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    result: z.ZodOptional<z.ZodJSONSchema>;
+    error: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.event">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    relaySequence: z.ZodNumber;
+    event: z.ZodReadonly<z.ZodObject<{
+        protocolVersion: z.ZodEnum<{
+            1.1: "1.1";
+            "1.0": "1.0";
+        }>;
+        runtimeInstanceId: z.core.$ZodBranded<z.ZodString, "RuntimeInstanceId">;
+        sequence: z.ZodNumber;
+        timestamp: z.ZodString;
+        threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        turnId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TurnId">>;
+        event: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.started">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.started">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.delta">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.completed">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            text: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"reasoning.summary.delta">;
+            reasoningId: z.ZodString;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.started">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            input: z.ZodJSONSchema;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.output">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            stream: z.ZodEnum<{
+                stdout: "stdout";
+                stderr: "stderr";
+            }>;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.completed">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
+            outcome: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    success: "success";
+                    user_rejected: "user_rejected";
+                    policy_denied: "policy_denied";
+                    invalid_input: "invalid_input";
+                    cancelled: "cancelled";
+                    tool_failed: "tool_failed";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            display: z.ZodJSONSchema;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"approval.required">;
+            approval: z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                preview: z.ZodJSONSchema;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"approval.resolved">;
+            approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+            resolution: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"resolved">;
+                decision: z.ZodLiteral<"approve">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"resolved">;
+                decision: z.ZodLiteral<"reject">;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"cancelled">;
+                reason: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"expired">;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>]>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.completed">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.cancelled">;
+            reason: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.failed">;
+            stage: z.ZodEnum<{
+                bootstrap: "bootstrap";
+                plan: "plan";
+                execute: "execute";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"capabilities.changed">;
+        }, z.core.$strict>>]>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.ack">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    throughRelaySequence: z.ZodNumber;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.gap">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    fromRelaySequence: z.ZodNumber;
+    throughRelaySequence: z.ZodNumber;
+    recovery: z.ZodLiteral<"thread.snapshot">;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.encrypted">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    envelopeId: z.ZodString;
+    payloadKind: z.ZodEnum<{
+        event: "event";
+        request: "request";
+        response: "response";
+    }>;
+    requestId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RelayRequestId">>;
+    relaySequence: z.ZodOptional<z.ZodNumber>;
+    algorithm: z.ZodString;
+    nonce: z.ZodString;
+    ciphertext: z.ZodString;
+}, z.core.$strict>>]>;
+export interface RelayProtocolRegistry {
+    readonly messageTypes: readonly (typeof RELAY_MESSAGE_TYPE_VALUES)[number][];
+    readonly requestMethods: readonly RelayRequestMethod[];
+    readonly mutationMethods: readonly RelayRequestMethod[];
+    readonly localOnlyMethods: readonly RelayRequestMethod[];
+}
+export declare const RELAY_PROTOCOL_REGISTRY: {
+    readonly "1.0": {
+        readonly messageTypes: readonly ["device.connect", "runtime.request", "runtime.response", "runtime.event", "runtime.ack", "runtime.gap", "runtime.encrypted"];
+        readonly requestMethods: readonly ["initialize", "thread.list", "thread.create", "thread.open", "thread.snapshot", "thread.rename", "thread.delete", "thread.detach", "thread.capabilities", "turn.start", "turn.cancel", "approval.respond", "operation.get", "approval.candidate"];
+        readonly mutationMethods: readonly ["thread.create", "thread.rename", "thread.delete", "thread.detach", "turn.start", "turn.cancel", "approval.respond", "approval.candidate"];
+        readonly localOnlyMethods: readonly ["initialize"];
+    };
+};
+export declare function getRelayProtocolRegistry(version: RelayProtocolVersion): RelayProtocolRegistry;
+export declare function negotiateRelayProtocolVersion(peerVersions: readonly string[]): RelayProtocolVersion | undefined;
+export declare function canonicalizeRelayJson(value: JsonValue): string;
+export declare const RELAY_REQUEST_REPLAY_DISPOSITIONS: {
+    readonly new: "new";
+    readonly replay: "replay";
+    readonly conflict: "conflict";
+};
+export type RelayRequestReplayDisposition = (typeof RELAY_REQUEST_REPLAY_DISPOSITIONS)[keyof typeof RELAY_REQUEST_REPLAY_DISPOSITIONS];
+export type RelayRequestReplayClassification = {
+    readonly disposition: typeof RELAY_REQUEST_REPLAY_DISPOSITIONS.new | typeof RELAY_REQUEST_REPLAY_DISPOSITIONS.replay;
+} | {
+    readonly disposition: typeof RELAY_REQUEST_REPLAY_DISPOSITIONS.conflict;
+    readonly errorCode: typeof RELAY_ERROR_CODES.requestIdConflict;
+};
+export declare function classifyRelayRequestReplay(existing: RelayRuntimeRequest, candidate: RelayRuntimeRequest): RelayRequestReplayClassification;
+export interface RelayAckState {
+    readonly acknowledgedThrough: number;
+    /** Highest sequence the caller has proved was delivered without a preceding send hole. */
+    readonly advertisedThrough: number;
+    readonly incomingThrough: number;
+}
+export type RelayAckDisposition = "advance" | "duplicate" | "invalid";
+export declare function classifyRelayAck(state: RelayAckState): RelayAckDisposition;
+export type DeviceId = z.infer<typeof deviceIdSchema>;
+export type WorkspaceId = z.infer<typeof workspaceIdSchema>;
+export type RelayRequestId = z.infer<typeof relayRequestIdSchema>;
+export type RelayEnvelopeId = z.infer<typeof relayEnvelopeIdSchema>;
+export type RelayApprovalCandidateInput = z.input<typeof relayApprovalCandidateParamsSchema>;
+export type RelayApprovalCandidateParams = z.infer<typeof relayApprovalCandidateParamsSchema>;
+export type RelayApprovalCandidateResult = z.infer<typeof relayApprovalCandidateResultSchema>;
+export type RelayError = z.infer<typeof relayErrorSchema>;
+export type RelayMessage = z.infer<typeof relayMessageSchema>;
+export type RelayRuntimeRequest = z.infer<typeof relayRuntimeRequestSchema>;
+export type RelayRuntimeResponse = z.infer<typeof relayRuntimeResponseSchema>;
+export type RelayRuntimeEvent = z.infer<typeof relayRuntimeEventSchema>;
+export type RelayGap = z.infer<typeof relayGapSchema>;
+export type RelayEncryptedMessage = z.infer<typeof relayEncryptedMessageSchema>;