npm - @roll-agent/relay-protocol - Versions diffs - 0.3.3 → 0.4.0 - Mend

@roll-agent/relay-protocol 0.3.3 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (32) hide show

package/dist/index.d.ts CHANGED Viewed

@@ -1,8 +1,8 @@
 import { operationGetResultSchema, type JsonValue, type ThreadSnapshotV11 } from "@roll-agent/protocol";
 import { z } from "zod/v4";
-export declare const SUPPORTED_RELAY_PROTOCOL_VERSIONS: readonly ["1.1", "1.0"];
+export declare const SUPPORTED_RELAY_PROTOCOL_VERSIONS: readonly ["1.2", "1.1", "1.0"];
 export type RelayProtocolVersion = (typeof SUPPORTED_RELAY_PROTOCOL_VERSIONS)[number];
-export declare const LATEST_RELAY_PROTOCOL_VERSION: "1.1";
+export declare const LATEST_RELAY_PROTOCOL_VERSION: "1.2";
 /** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
 export declare const RELAY_PROTOCOL_VERSION: "1.0";
 /** @deprecated The one-argument Companion connection API remains pinned to Wire 1.0. */
@@ -214,6 +214,7 @@ export declare function getRelayErrorRetryabilityV11(code: RelayErrorCodeV11): b
 export declare const relayProtocolVersionSchema: z.ZodEnum<{
     1.1: "1.1";
     "1.0": "1.0";
+    1.2: "1.2";
 }>;
 export declare const deviceIdSchema: z.core.$ZodBranded<z.ZodString, "DeviceId">;
 export declare const workspaceIdSchema: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
@@ -3505,7 +3506,1971 @@ export interface RelayProtocolRegistry {
     readonly mutationMethods: readonly string[];
     readonly localOnlyMethods: readonly string[];
 }
+/** Wire 1.2 carries complete App results only through an explicit query. */
+export declare const RELAY_REQUEST_METHODS_V12: {
+    readonly operationResultGet: "operation.result.get";
+    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 operationGet: "operation.get";
+    readonly interactionCandidate: "interaction.candidate";
+};
+export declare const RELAY_REQUEST_METHOD_VALUES_V12: readonly ["initialize", "thread.list", "thread.create", "thread.open", "thread.snapshot", "thread.rename", "thread.delete", "thread.detach", "thread.capabilities", "turn.start", "turn.cancel", "operation.get", "interaction.candidate", "operation.result.get"];
+export declare const RELAY_REQUEST_METHOD_DISPOSITIONS_V12: {
+    readonly "operation.result.get": "query";
+    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 "operation.get": "query";
+    readonly "interaction.candidate": "mutation";
+};
+export declare const relayOperationViewSchemaV12: 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;
+    appOutput: z.ZodOptional<z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        status: z.ZodLiteral<"rejected">;
+        reason: z.ZodEnum<{
+            credential_field: "credential_field";
+            credential_value: "credential_value";
+        }>;
+        field: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>, z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        schemaId: z.ZodString;
+        schemaVersion: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodEnum<{
+            not_provided: "not_provided";
+            invalid: "invalid";
+            too_large: "too_large";
+            expired: "expired";
+            denied: "denied";
+        }>;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>>;
+export declare const relayThreadSnapshotSchemaV12: 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>>;
+    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";
+    }>;
+    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;
+            appOutput: z.ZodOptional<z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"rejected">;
+                reason: z.ZodEnum<{
+                    credential_field: "credential_field";
+                    credential_value: "credential_value";
+                }>;
+                field: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>, z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                schemaId: z.ZodString;
+                schemaVersion: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodEnum<{
+                    not_provided: "not_provided";
+                    invalid: "invalid";
+                    too_large: "too_large";
+                    expired: "expired";
+                    denied: "denied";
+                }>;
+            }, z.core.$strict>]>>>;
+        }, z.core.$strict>>>;
+        nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const relayRequestMethodSchemasV12: {
+    readonly "thread.open": {
+        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>>;
+            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";
+            }>;
+            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;
+                    appOutput: z.ZodOptional<z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                        status: z.ZodLiteral<"rejected">;
+                        reason: z.ZodEnum<{
+                            credential_field: "credential_field";
+                            credential_value: "credential_value";
+                        }>;
+                        field: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>, z.ZodObject<{
+                        status: z.ZodLiteral<"available">;
+                        schemaId: z.ZodString;
+                        schemaVersion: z.ZodNumber;
+                    }, z.core.$strict>, z.ZodObject<{
+                        status: z.ZodEnum<{
+                            not_provided: "not_provided";
+                            invalid: "invalid";
+                            too_large: "too_large";
+                            expired: "expired";
+                            denied: "denied";
+                        }>;
+                    }, z.core.$strict>]>>>;
+                }, z.core.$strict>>>;
+                nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.snapshot": {
+        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>>;
+            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";
+            }>;
+            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;
+                    appOutput: z.ZodOptional<z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                        status: z.ZodLiteral<"rejected">;
+                        reason: z.ZodEnum<{
+                            credential_field: "credential_field";
+                            credential_value: "credential_value";
+                        }>;
+                        field: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>, z.ZodObject<{
+                        status: z.ZodLiteral<"available">;
+                        schemaId: z.ZodString;
+                        schemaVersion: z.ZodNumber;
+                    }, z.core.$strict>, z.ZodObject<{
+                        status: z.ZodEnum<{
+                            not_provided: "not_provided";
+                            invalid: "invalid";
+                            too_large: "too_large";
+                            expired: "expired";
+                            denied: "denied";
+                        }>;
+                    }, z.core.$strict>]>>>;
+                }, z.core.$strict>>>;
+                nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        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 "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 "operation.get": {
+        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;
+                appOutput: z.ZodOptional<z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                    status: z.ZodLiteral<"rejected">;
+                    reason: z.ZodEnum<{
+                        credential_field: "credential_field";
+                        credential_value: "credential_value";
+                    }>;
+                    field: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>, z.ZodObject<{
+                    status: z.ZodLiteral<"available">;
+                    schemaId: z.ZodString;
+                    schemaVersion: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    status: z.ZodEnum<{
+                        not_provided: "not_provided";
+                        invalid: "invalid";
+                        too_large: "too_large";
+                        expired: "expired";
+                        denied: "denied";
+                    }>;
+                }, z.core.$strict>]>>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            operationId: z.core.$ZodBranded<z.ZodString, "OperationId">;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        }, z.core.$strict>>;
+    };
+    readonly "operation.result.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<{
+            result: z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+                threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                operationId: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                createdAt: z.ZodString;
+                output: z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                    status: z.ZodLiteral<"rejected">;
+                    reason: z.ZodEnum<{
+                        credential_field: "credential_field";
+                        credential_value: "credential_value";
+                    }>;
+                    field: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>, z.ZodObject<{
+                    status: z.ZodLiteral<"available">;
+                    schemaId: z.ZodString;
+                    schemaVersion: z.ZodNumber;
+                    remoteReadable: z.ZodBoolean;
+                    data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+                    fallbackText: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    status: z.ZodEnum<{
+                        not_provided: "not_provided";
+                        invalid: "invalid";
+                        too_large: "too_large";
+                        expired: "expired";
+                        denied: "denied";
+                    }>;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    };
+    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<{
+            limits: z.ZodReadonly<z.ZodObject<{
+                maxFrameBytes: z.ZodNumber;
+                maxPageSize: z.ZodNumber;
+                eventReplay: z.ZodLiteral<false>;
+                idempotencyCacheEntries: z.ZodNumber;
+            }, z.core.$strict>>;
+            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";
+            }>>;
+            protocolVersion: z.ZodEnum<{
+                1.1: "1.1";
+                "1.0": "1.0";
+            }>;
+        }, 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.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 "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 "interaction.candidate": {
+        readonly params: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            method: z.ZodLiteral<"approval.request">;
+            candidate: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                decision: z.ZodLiteral<"approve">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                decision: z.ZodLiteral<"reject">;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>]>;
+            interactionId: z.core.$ZodBranded<z.ZodString, "InteractionId">;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            method: z.ZodLiteral<"userInput.request">;
+            candidate: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"submitted">;
+                values: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    id: z.ZodString;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"cancelled">;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>]>;
+            interactionId: z.core.$ZodBranded<z.ZodString, "InteractionId">;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+        }, z.core.$strict>>]>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            accepted: z.ZodLiteral<true>;
+        }, z.core.$strict>>;
+    };
+};
+export declare const relayToolCompletedSchemaV12: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"tool.completed">;
+    toolCallId: z.ZodString;
+    agentName: z.ZodString;
+    toolName: z.ZodString;
+    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";
+        }>;
+    }, z.core.$strict>>>;
+    appOutput: z.ZodOptional<z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        status: z.ZodLiteral<"rejected">;
+        reason: z.ZodEnum<{
+            credential_field: "credential_field";
+            credential_value: "credential_value";
+        }>;
+        field: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>, z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        schemaId: z.ZodString;
+        schemaVersion: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodEnum<{
+            not_provided: "not_provided";
+            invalid: "invalid";
+            too_large: "too_large";
+            expired: "expired";
+            denied: "denied";
+        }>;
+    }, z.core.$strict>]>>>;
+    operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
+}, z.core.$strict>>;
+export declare const relayRuntimeEventEnvelopeSchemaV12: 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.ZodUnion<readonly [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;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"tool.completed">;
+        toolCallId: z.ZodString;
+        agentName: z.ZodString;
+        toolName: z.ZodString;
+        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";
+            }>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"approval.required">;
+        approval: z.ZodReadonly<z.ZodObject<{
+            approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            explanation: 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.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            status: z.ZodLiteral<"resolved">;
+            decision: z.ZodEnum<{
+                approve: "approve";
+                reject: "reject";
+            }>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            status: z.ZodLiteral<"cancelled">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            status: z.ZodLiteral<"expired">;
+        }, 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">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"turn.failed">;
+        stage: z.ZodEnum<{
+            bootstrap: "bootstrap";
+            plan: "plan";
+            execute: "execute";
+        }>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"capabilities.changed">;
+    }, z.core.$strict>>]>, z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"tool.completed">;
+        toolCallId: z.ZodString;
+        agentName: z.ZodString;
+        toolName: z.ZodString;
+        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";
+            }>;
+        }, z.core.$strict>>>;
+        appOutput: z.ZodOptional<z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            status: z.ZodLiteral<"rejected">;
+            reason: z.ZodEnum<{
+                credential_field: "credential_field";
+                credential_value: "credential_value";
+            }>;
+            field: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>, z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            schemaId: z.ZodString;
+            schemaVersion: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                not_provided: "not_provided";
+                invalid: "invalid";
+                too_large: "too_large";
+                expired: "expired";
+                denied: "denied";
+            }>;
+        }, z.core.$strict>]>>>;
+        operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
+    }, z.core.$strict>>]>;
+}, z.core.$strict>>;
+export declare const relayDeviceConnectSchemaV12: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"device.connect">;
+    deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
+    pairingToken: z.ZodString;
+    protocolVersion: z.ZodLiteral<"1.2">;
+}, z.core.$strict>>;
+export declare const relayRuntimeRequestSchemaV12: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.request">;
+    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    params: z.ZodJSONSchema;
+    method: z.ZodEnum<{
+        "operation.result.get": "operation.result.get";
+        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";
+        "operation.get": "operation.get";
+        "interaction.candidate": "interaction.candidate";
+    }>;
+}, z.core.$strict>>;
+export declare const relayRuntimeEventSchemaV12: 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.ZodUnion<readonly [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;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.completed">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            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";
+                }>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"approval.required">;
+            approval: z.ZodReadonly<z.ZodObject<{
+                approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                explanation: 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.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"resolved">;
+                decision: z.ZodEnum<{
+                    approve: "approve";
+                    reject: "reject";
+                }>;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"cancelled">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"expired">;
+            }, 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">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.failed">;
+            stage: z.ZodEnum<{
+                bootstrap: "bootstrap";
+                plan: "plan";
+                execute: "execute";
+            }>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"capabilities.changed">;
+        }, z.core.$strict>>]>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.completed">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            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";
+                }>;
+            }, z.core.$strict>>>;
+            appOutput: z.ZodOptional<z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"rejected">;
+                reason: z.ZodEnum<{
+                    credential_field: "credential_field";
+                    credential_value: "credential_value";
+                }>;
+                field: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>, z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                schemaId: z.ZodString;
+                schemaVersion: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodEnum<{
+                    not_provided: "not_provided";
+                    invalid: "invalid";
+                    too_large: "too_large";
+                    expired: "expired";
+                    denied: "denied";
+                }>;
+            }, z.core.$strict>]>>>;
+            operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
+        }, z.core.$strict>>]>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const relayMessageSchemaV12: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"device.connect">;
+    deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
+    pairingToken: z.ZodString;
+    protocolVersion: z.ZodLiteral<"1.2">;
+}, 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">;
+    params: z.ZodJSONSchema;
+    method: z.ZodEnum<{
+        "operation.result.get": "operation.result.get";
+        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";
+        "operation.get": "operation.get";
+        "interaction.candidate": "interaction.candidate";
+    }>;
+}, 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.ZodUnion<readonly [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;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.completed">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            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";
+                }>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"approval.required">;
+            approval: z.ZodReadonly<z.ZodObject<{
+                approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                explanation: 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.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"resolved">;
+                decision: z.ZodEnum<{
+                    approve: "approve";
+                    reject: "reject";
+                }>;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"cancelled">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"expired">;
+            }, 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">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.failed">;
+            stage: z.ZodEnum<{
+                bootstrap: "bootstrap";
+                plan: "plan";
+                execute: "execute";
+            }>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"capabilities.changed">;
+        }, z.core.$strict>>]>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.completed">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            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";
+                }>;
+            }, z.core.$strict>>>;
+            appOutput: z.ZodOptional<z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"rejected">;
+                reason: z.ZodEnum<{
+                    credential_field: "credential_field";
+                    credential_value: "credential_value";
+                }>;
+                field: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>, z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                schemaId: z.ZodString;
+                schemaVersion: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodEnum<{
+                    not_provided: "not_provided";
+                    invalid: "invalid";
+                    too_large: "too_large";
+                    expired: "expired";
+                    denied: "denied";
+                }>;
+            }, z.core.$strict>]>>>;
+            operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
+        }, 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<{
+        interaction: "interaction";
+        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>>, z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    method: z.ZodLiteral<"approval.request">;
+    projection: z.ZodReadonly<z.ZodObject<{
+        approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+        agentName: z.ZodString;
+        toolName: z.ZodString;
+        explanation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    relaySequence: z.ZodNumber;
+    interactionId: z.core.$ZodBranded<z.ZodString, "InteractionId">;
+    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+    expiresAt: z.ZodString;
+    sensitivity: z.ZodLiteral<"normal">;
+    type: z.ZodLiteral<"interaction.request">;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    method: z.ZodLiteral<"userInput.request">;
+    projection: z.ZodReadonly<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        controls: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            minLength: z.ZodOptional<z.ZodNumber>;
+            maxLength: z.ZodOptional<z.ZodNumber>;
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodBoolean;
+            type: z.ZodLiteral<"text">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            minLength: z.ZodOptional<z.ZodNumber>;
+            maxLength: z.ZodOptional<z.ZodNumber>;
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodBoolean;
+            type: z.ZodLiteral<"multiline">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            integer: z.ZodOptional<z.ZodBoolean>;
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodBoolean;
+            type: z.ZodLiteral<"number">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodBoolean;
+            type: z.ZodLiteral<"boolean">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            multiple: z.ZodBoolean;
+            options: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            minSelections: z.ZodOptional<z.ZodNumber>;
+            maxSelections: z.ZodOptional<z.ZodNumber>;
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodBoolean;
+            type: z.ZodLiteral<"choice">;
+        }, z.core.$strict>>]>>;
+    }, z.core.$strict>>;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    relaySequence: z.ZodNumber;
+    interactionId: z.core.$ZodBranded<z.ZodString, "InteractionId">;
+    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+    expiresAt: z.ZodString;
+    sensitivity: z.ZodLiteral<"normal">;
+    type: z.ZodLiteral<"interaction.request">;
+}, z.core.$strict>>]>, z.ZodReadonly<z.ZodObject<{
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    relaySequence: z.ZodNumber;
+    interactionId: z.core.$ZodBranded<z.ZodString, "InteractionId">;
+    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+    method: z.ZodEnum<{
+        "approval.request": "approval.request";
+        "userInput.request": "userInput.request";
+    }>;
+    type: z.ZodLiteral<"interaction.resolved">;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    relaySequence: z.ZodNumber;
+    interactionId: z.core.$ZodBranded<z.ZodString, "InteractionId">;
+    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+    method: z.ZodEnum<{
+        "approval.request": "approval.request";
+        "userInput.request": "userInput.request";
+    }>;
+    type: z.ZodLiteral<"interaction.cancelled">;
+}, z.core.$strict>>]>;
+export type RelayMessageV12 = z.output<typeof relayMessageSchemaV12>;
+export type RelayRuntimeRequestV12 = z.output<typeof relayRuntimeRequestSchemaV12>;
+export type RelayRuntimeEventV12 = z.output<typeof relayRuntimeEventSchemaV12>;
+export type RelayRuntimeEventEnvelopeV12 = z.output<typeof relayRuntimeEventEnvelopeSchemaV12>;
+export type RelayRequestMethodV12 = (typeof RELAY_REQUEST_METHOD_VALUES_V12)[number];
+export declare function projectRelayThreadSnapshotV12(value: unknown): z.output<typeof relayThreadSnapshotSchemaV12>;
+export declare function projectRelayOperationGetResultV12(value: unknown): z.output<(typeof relayRequestMethodSchemasV12)["operation.get"]["result"]>;
+export declare function projectRuntimeEventEnvelopeForRelayV12(value: unknown): RelayRuntimeEventEnvelopeV12 | undefined;
+/** Downgrade before delivery to a 1.1 browser; never leaks new descriptor fields. */
+export declare function projectRelayMessageV12ToV11(message: RelayMessageV12): RelayMessageV11;
 export declare const RELAY_PROTOCOL_REGISTRY: {
+    readonly "1.2": {
+        readonly messageTypes: readonly ["device.connect", "runtime.request", "runtime.response", "runtime.event", "runtime.ack", "runtime.gap", "runtime.encrypted", "interaction.request", "interaction.resolved", "interaction.cancelled"];
+        readonly messageSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"device.connect">;
+            deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
+            pairingToken: z.ZodString;
+            protocolVersion: z.ZodLiteral<"1.2">;
+        }, 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">;
+            params: z.ZodJSONSchema;
+            method: z.ZodEnum<{
+                "operation.result.get": "operation.result.get";
+                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";
+                "operation.get": "operation.get";
+                "interaction.candidate": "interaction.candidate";
+            }>;
+        }, 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.ZodUnion<readonly [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;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"tool.completed">;
+                    toolCallId: z.ZodString;
+                    agentName: z.ZodString;
+                    toolName: z.ZodString;
+                    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";
+                        }>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"approval.required">;
+                    approval: z.ZodReadonly<z.ZodObject<{
+                        approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                        agentName: z.ZodString;
+                        toolName: z.ZodString;
+                        explanation: 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.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                        status: z.ZodLiteral<"resolved">;
+                        decision: z.ZodEnum<{
+                            approve: "approve";
+                            reject: "reject";
+                        }>;
+                    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                        status: z.ZodLiteral<"cancelled">;
+                    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                        status: z.ZodLiteral<"expired">;
+                    }, 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">;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"turn.failed">;
+                    stage: z.ZodEnum<{
+                        bootstrap: "bootstrap";
+                        plan: "plan";
+                        execute: "execute";
+                    }>;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"capabilities.changed">;
+                }, z.core.$strict>>]>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"tool.completed">;
+                    toolCallId: z.ZodString;
+                    agentName: z.ZodString;
+                    toolName: z.ZodString;
+                    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";
+                        }>;
+                    }, z.core.$strict>>>;
+                    appOutput: z.ZodOptional<z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                        status: z.ZodLiteral<"rejected">;
+                        reason: z.ZodEnum<{
+                            credential_field: "credential_field";
+                            credential_value: "credential_value";
+                        }>;
+                        field: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>, z.ZodObject<{
+                        status: z.ZodLiteral<"available">;
+                        schemaId: z.ZodString;
+                        schemaVersion: z.ZodNumber;
+                    }, z.core.$strict>, z.ZodObject<{
+                        status: z.ZodEnum<{
+                            not_provided: "not_provided";
+                            invalid: "invalid";
+                            too_large: "too_large";
+                            expired: "expired";
+                            denied: "denied";
+                        }>;
+                    }, z.core.$strict>]>>>;
+                    operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
+                }, 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<{
+                interaction: "interaction";
+                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>>, z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            method: z.ZodLiteral<"approval.request">;
+            projection: z.ZodReadonly<z.ZodObject<{
+                approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                explanation: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+            relaySequence: z.ZodNumber;
+            interactionId: z.core.$ZodBranded<z.ZodString, "InteractionId">;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+            expiresAt: z.ZodString;
+            sensitivity: z.ZodLiteral<"normal">;
+            type: z.ZodLiteral<"interaction.request">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            method: z.ZodLiteral<"userInput.request">;
+            projection: z.ZodReadonly<z.ZodObject<{
+                title: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                controls: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                    minLength: z.ZodOptional<z.ZodNumber>;
+                    maxLength: z.ZodOptional<z.ZodNumber>;
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    required: z.ZodBoolean;
+                    type: z.ZodLiteral<"text">;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    minLength: z.ZodOptional<z.ZodNumber>;
+                    maxLength: z.ZodOptional<z.ZodNumber>;
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    required: z.ZodBoolean;
+                    type: z.ZodLiteral<"multiline">;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    min: z.ZodOptional<z.ZodNumber>;
+                    max: z.ZodOptional<z.ZodNumber>;
+                    integer: z.ZodOptional<z.ZodBoolean>;
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    required: z.ZodBoolean;
+                    type: z.ZodLiteral<"number">;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    required: z.ZodBoolean;
+                    type: z.ZodLiteral<"boolean">;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    multiple: z.ZodBoolean;
+                    options: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        id: z.ZodString;
+                        label: z.ZodString;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    minSelections: z.ZodOptional<z.ZodNumber>;
+                    maxSelections: z.ZodOptional<z.ZodNumber>;
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    required: z.ZodBoolean;
+                    type: z.ZodLiteral<"choice">;
+                }, z.core.$strict>>]>>;
+            }, z.core.$strict>>;
+            workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+            relaySequence: z.ZodNumber;
+            interactionId: z.core.$ZodBranded<z.ZodString, "InteractionId">;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+            expiresAt: z.ZodString;
+            sensitivity: z.ZodLiteral<"normal">;
+            type: z.ZodLiteral<"interaction.request">;
+        }, z.core.$strict>>]>, z.ZodReadonly<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+            relaySequence: z.ZodNumber;
+            interactionId: z.core.$ZodBranded<z.ZodString, "InteractionId">;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+            method: z.ZodEnum<{
+                "approval.request": "approval.request";
+                "userInput.request": "userInput.request";
+            }>;
+            type: z.ZodLiteral<"interaction.resolved">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+            relaySequence: z.ZodNumber;
+            interactionId: z.core.$ZodBranded<z.ZodString, "InteractionId">;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+            method: z.ZodEnum<{
+                "approval.request": "approval.request";
+                "userInput.request": "userInput.request";
+            }>;
+            type: z.ZodLiteral<"interaction.cancelled">;
+        }, z.core.$strict>>]>;
+        readonly requestMethods: readonly ["initialize", "thread.list", "thread.create", "thread.open", "thread.snapshot", "thread.rename", "thread.delete", "thread.detach", "thread.capabilities", "turn.start", "turn.cancel", "operation.get", "interaction.candidate", "operation.result.get"];
+        readonly requestMethodSchemas: {
+            readonly "thread.open": {
+                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>>;
+                    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";
+                    }>;
+                    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;
+                            appOutput: z.ZodOptional<z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                                status: z.ZodLiteral<"rejected">;
+                                reason: z.ZodEnum<{
+                                    credential_field: "credential_field";
+                                    credential_value: "credential_value";
+                                }>;
+                                field: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strict>>, z.ZodObject<{
+                                status: z.ZodLiteral<"available">;
+                                schemaId: z.ZodString;
+                                schemaVersion: z.ZodNumber;
+                            }, z.core.$strict>, z.ZodObject<{
+                                status: z.ZodEnum<{
+                                    not_provided: "not_provided";
+                                    invalid: "invalid";
+                                    too_large: "too_large";
+                                    expired: "expired";
+                                    denied: "denied";
+                                }>;
+                            }, z.core.$strict>]>>>;
+                        }, z.core.$strict>>>;
+                        nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                }, z.core.$strict>>;
+            };
+            readonly "thread.snapshot": {
+                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>>;
+                    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";
+                    }>;
+                    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;
+                            appOutput: z.ZodOptional<z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                                status: z.ZodLiteral<"rejected">;
+                                reason: z.ZodEnum<{
+                                    credential_field: "credential_field";
+                                    credential_value: "credential_value";
+                                }>;
+                                field: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strict>>, z.ZodObject<{
+                                status: z.ZodLiteral<"available">;
+                                schemaId: z.ZodString;
+                                schemaVersion: z.ZodNumber;
+                            }, z.core.$strict>, z.ZodObject<{
+                                status: z.ZodEnum<{
+                                    not_provided: "not_provided";
+                                    invalid: "invalid";
+                                    too_large: "too_large";
+                                    expired: "expired";
+                                    denied: "denied";
+                                }>;
+                            }, z.core.$strict>]>>>;
+                        }, z.core.$strict>>>;
+                        nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                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 "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 "operation.get": {
+                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;
+                        appOutput: z.ZodOptional<z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                            status: z.ZodLiteral<"rejected">;
+                            reason: z.ZodEnum<{
+                                credential_field: "credential_field";
+                                credential_value: "credential_value";
+                            }>;
+                            field: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>>, z.ZodObject<{
+                            status: z.ZodLiteral<"available">;
+                            schemaId: z.ZodString;
+                            schemaVersion: z.ZodNumber;
+                        }, z.core.$strict>, z.ZodObject<{
+                            status: z.ZodEnum<{
+                                not_provided: "not_provided";
+                                invalid: "invalid";
+                                too_large: "too_large";
+                                expired: "expired";
+                                denied: "denied";
+                            }>;
+                        }, z.core.$strict>]>>>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>;
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    operationId: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                }, z.core.$strict>>;
+            };
+            readonly "operation.result.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<{
+                    result: z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+                        threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                        operationId: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                        agentName: z.ZodString;
+                        toolName: z.ZodString;
+                        createdAt: z.ZodString;
+                        output: z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                            status: z.ZodLiteral<"rejected">;
+                            reason: z.ZodEnum<{
+                                credential_field: "credential_field";
+                                credential_value: "credential_value";
+                            }>;
+                            field: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>>, z.ZodObject<{
+                            status: z.ZodLiteral<"available">;
+                            schemaId: z.ZodString;
+                            schemaVersion: z.ZodNumber;
+                            remoteReadable: z.ZodBoolean;
+                            data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+                            fallbackText: z.ZodString;
+                        }, z.core.$strict>, z.ZodObject<{
+                            status: z.ZodEnum<{
+                                not_provided: "not_provided";
+                                invalid: "invalid";
+                                too_large: "too_large";
+                                expired: "expired";
+                                denied: "denied";
+                            }>;
+                        }, z.core.$strict>]>>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>;
+            };
+            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<{
+                    limits: z.ZodReadonly<z.ZodObject<{
+                        maxFrameBytes: z.ZodNumber;
+                        maxPageSize: z.ZodNumber;
+                        eventReplay: z.ZodLiteral<false>;
+                        idempotencyCacheEntries: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    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";
+                    }>>;
+                    protocolVersion: z.ZodEnum<{
+                        1.1: "1.1";
+                        "1.0": "1.0";
+                    }>;
+                }, 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.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 "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 "interaction.candidate": {
+                readonly params: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                    method: z.ZodLiteral<"approval.request">;
+                    candidate: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                        decision: z.ZodLiteral<"approve">;
+                    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                        decision: z.ZodLiteral<"reject">;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>]>;
+                    interactionId: z.core.$ZodBranded<z.ZodString, "InteractionId">;
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    method: z.ZodLiteral<"userInput.request">;
+                    candidate: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                        status: z.ZodLiteral<"submitted">;
+                        values: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                            id: z.ZodString;
+                            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+                        }, z.core.$strict>>>;
+                    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                        status: z.ZodLiteral<"cancelled">;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>]>;
+                    interactionId: z.core.$ZodBranded<z.ZodString, "InteractionId">;
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                }, z.core.$strict>>]>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    accepted: z.ZodLiteral<true>;
+                }, z.core.$strict>>;
+            };
+        };
+        readonly requestMethodDispositions: {
+            readonly "operation.result.get": "query";
+            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 "operation.get": "query";
+            readonly "interaction.candidate": "mutation";
+        };
+        readonly mutationMethods: readonly ["thread.create", "thread.rename", "thread.delete", "thread.detach", "turn.start", "turn.cancel", "interaction.candidate"];
+        readonly localOnlyMethods: readonly ["initialize"];
+    };
     readonly "1.1": {
         readonly messageTypes: readonly ["device.connect", "runtime.request", "runtime.response", "runtime.event", "runtime.ack", "runtime.gap", "runtime.encrypted", "interaction.request", "interaction.resolved", "interaction.cancelled"];
         readonly messageSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
@@ -4671,7 +6636,7 @@ type RelaySchemaResult<TDefinition> = TDefinition extends {
     readonly result: infer TSchema extends z.ZodType;
 } ? TSchema : never;
 export type RelayMessageForVersion<TVersion extends RelayProtocolVersion> = z.output<RelayProtocolRegistryMap[TVersion]["messageSchema"]>;
-export type RelayRequestMethodForVersion<TVersion extends RelayProtocolVersion> = Extract<keyof RelayProtocolRegistryMap[TVersion]["requestMethodSchemas"], string>;
+export type RelayRequestMethodForVersion<TVersion extends RelayProtocolVersion> = TVersion extends RelayProtocolVersion ? Extract<keyof RelayProtocolRegistryMap[TVersion]["requestMethodSchemas"], string> : never;
 type RelayRequestMethodDefinitionForVersion<TVersion extends RelayProtocolVersion, TMethod extends RelayRequestMethodForVersion<TVersion>> = TMethod extends keyof RelayProtocolRegistryMap[TVersion]["requestMethodSchemas"] ? RelayProtocolRegistryMap[TVersion]["requestMethodSchemas"][TMethod] : never;
 export type RelayRequestParamsForVersion<TVersion extends RelayProtocolVersion, TMethod extends RelayRequestMethodForVersion<TVersion>> = z.output<RelaySchemaParams<RelayRequestMethodDefinitionForVersion<TVersion, TMethod>>>;
 export type RelayRequestResultForVersion<TVersion extends RelayProtocolVersion, TMethod extends RelayRequestMethodForVersion<TVersion>> = z.output<RelaySchemaResult<RelayRequestMethodDefinitionForVersion<TVersion, TMethod>>>;
@@ -4751,4 +6716,7 @@ export type RelayRuntimeEvent = z.infer<typeof relayRuntimeEventSchema>;
 export type RelayGap = z.infer<typeof relayGapSchema>;
 /** @deprecated Legacy generic Relay types remain pinned to Wire 1.0. */
 export type RelayEncryptedMessage = z.infer<typeof relayEncryptedMessageSchema>;
+export type RelaySupportedMessage = RelayMessageV11 | RelayMessageV12;
+/** Keep legacy capability payloads free of unsupported App-output claims. */
+export declare function projectRelayCapabilitiesV11(value: unknown): JsonValue;
 export {};