npm - @roll-agent/relay-protocol - Versions diffs - 0.1.1 → 0.3.0 - Mend

@roll-agent/relay-protocol 0.1.1 → 0.3.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 (51) hide show

package/dist/index.d.ts CHANGED Viewed

@@ -1,10 +1,36 @@
-import { type JsonValue } from "@roll-agent/protocol";
+import { operationGetResultSchema, type JsonValue, type ThreadSnapshotV11 } from "@roll-agent/protocol";
 import { z } from "zod/v4";
-export declare const SUPPORTED_RELAY_PROTOCOL_VERSIONS: readonly ["1.0"];
+export declare const SUPPORTED_RELAY_PROTOCOL_VERSIONS: readonly ["1.1", "1.0"];
 export type RelayProtocolVersion = (typeof SUPPORTED_RELAY_PROTOCOL_VERSIONS)[number];
+export declare const LATEST_RELAY_PROTOCOL_VERSION: "1.1";
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
 export declare const RELAY_PROTOCOL_VERSION: "1.0";
-/** @deprecated Use `RELAY_PROTOCOL_VERSION`. */
+/** @deprecated The one-argument Companion connection API remains pinned to Wire 1.0. */
 export declare const COMPANION_RELAY_PROTOCOL_VERSION: "1.0";
+export declare const RELAY_MESSAGE_TYPES_V10: {
+    readonly deviceConnect: "device.connect";
+    readonly runtimeRequest: "runtime.request";
+    readonly runtimeResponse: "runtime.response";
+    readonly runtimeEvent: "runtime.event";
+    readonly runtimeAck: "runtime.ack";
+    readonly runtimeGap: "runtime.gap";
+    readonly runtimeEncrypted: "runtime.encrypted";
+};
+export declare const RELAY_MESSAGE_TYPES_V11: {
+    readonly interactionRequest: "interaction.request";
+    readonly interactionResolved: "interaction.resolved";
+    readonly interactionCancelled: "interaction.cancelled";
+    readonly deviceConnect: "device.connect";
+    readonly runtimeRequest: "runtime.request";
+    readonly runtimeResponse: "runtime.response";
+    readonly runtimeEvent: "runtime.event";
+    readonly runtimeAck: "runtime.ack";
+    readonly runtimeGap: "runtime.gap";
+    readonly runtimeEncrypted: "runtime.encrypted";
+};
+export declare const RELAY_MESSAGE_TYPE_VALUES_V10: readonly ["device.connect", "runtime.request", "runtime.response", "runtime.event", "runtime.ack", "runtime.gap", "runtime.encrypted"];
+export declare const RELAY_MESSAGE_TYPE_VALUES_V11: readonly ["device.connect", "runtime.request", "runtime.response", "runtime.event", "runtime.ack", "runtime.gap", "runtime.encrypted", "interaction.request", "interaction.resolved", "interaction.cancelled"];
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
 export declare const RELAY_MESSAGE_TYPES: {
     readonly deviceConnect: "device.connect";
     readonly runtimeRequest: "runtime.request";
@@ -14,11 +40,44 @@ export declare const RELAY_MESSAGE_TYPES: {
     readonly runtimeGap: "runtime.gap";
     readonly runtimeEncrypted: "runtime.encrypted";
 };
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
 export declare const RELAY_MESSAGE_TYPE_VALUES: readonly ["device.connect", "runtime.request", "runtime.response", "runtime.event", "runtime.ack", "runtime.gap", "runtime.encrypted"];
 /**
  * Relay Wire 1.0 is intentionally independent from the latest Runtime registry.
  * New Runtime methods never become remotely callable without a Relay version change.
  */
+export declare const RELAY_REQUEST_METHODS_V10: {
+    readonly initialize: "initialize";
+    readonly threadList: "thread.list";
+    readonly threadCreate: "thread.create";
+    readonly threadOpen: "thread.open";
+    readonly threadSnapshot: "thread.snapshot";
+    readonly threadRename: "thread.rename";
+    readonly threadDelete: "thread.delete";
+    readonly threadDetach: "thread.detach";
+    readonly threadCapabilities: "thread.capabilities";
+    readonly turnStart: "turn.start";
+    readonly turnCancel: "turn.cancel";
+    readonly approvalRespond: "approval.respond";
+    readonly operationGet: "operation.get";
+    readonly approvalCandidate: "approval.candidate";
+};
+export declare const RELAY_REQUEST_METHODS_V11: {
+    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";
+};
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
 export declare const RELAY_REQUEST_METHODS: {
     readonly initialize: "initialize";
     readonly threadList: "thread.list";
@@ -35,8 +94,43 @@ export declare const RELAY_REQUEST_METHODS: {
     readonly operationGet: "operation.get";
     readonly approvalCandidate: "approval.candidate";
 };
-export type RelayRequestMethod = (typeof RELAY_REQUEST_METHODS)[keyof typeof RELAY_REQUEST_METHODS];
+export type RelayRequestMethod = (typeof RELAY_REQUEST_METHODS_V10)[keyof typeof RELAY_REQUEST_METHODS_V10];
+export declare const RELAY_REQUEST_METHOD_VALUES_V10: readonly ["initialize", "thread.list", "thread.create", "thread.open", "thread.snapshot", "thread.rename", "thread.delete", "thread.detach", "thread.capabilities", "turn.start", "turn.cancel", "approval.respond", "operation.get", "approval.candidate"];
+export declare const RELAY_REQUEST_METHOD_VALUES_V11: 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"];
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
 export declare const RELAY_REQUEST_METHOD_VALUES: readonly ["initialize", "thread.list", "thread.create", "thread.open", "thread.snapshot", "thread.rename", "thread.delete", "thread.detach", "thread.capabilities", "turn.start", "turn.cancel", "approval.respond", "operation.get", "approval.candidate"];
+export declare const RELAY_REQUEST_METHOD_DISPOSITIONS_V10: {
+    readonly initialize: "local-only";
+    readonly "thread.list": "query";
+    readonly "thread.create": "mutation";
+    readonly "thread.open": "query";
+    readonly "thread.snapshot": "query";
+    readonly "thread.rename": "mutation";
+    readonly "thread.delete": "mutation";
+    readonly "thread.detach": "mutation";
+    readonly "thread.capabilities": "query";
+    readonly "turn.start": "mutation";
+    readonly "turn.cancel": "mutation";
+    readonly "approval.respond": "mutation";
+    readonly "operation.get": "query";
+    readonly "approval.candidate": "mutation";
+};
+export declare const RELAY_REQUEST_METHOD_DISPOSITIONS_V11: {
+    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";
+};
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
 export declare const RELAY_REQUEST_METHOD_DISPOSITIONS: {
     readonly initialize: "local-only";
     readonly "thread.list": "query";
@@ -54,7 +148,13 @@ export declare const RELAY_REQUEST_METHOD_DISPOSITIONS: {
     readonly "approval.candidate": "mutation";
 };
 export type RelayRequestMethodDisposition = (typeof RELAY_REQUEST_METHOD_DISPOSITIONS)[RelayRequestMethod];
+export declare const RELAY_MUTATION_REQUEST_METHODS_V10: readonly ["thread.create", "thread.rename", "thread.delete", "thread.detach", "turn.start", "turn.cancel", "approval.respond", "approval.candidate"];
+export declare const RELAY_MUTATION_REQUEST_METHODS_V11: readonly ["thread.create", "thread.rename", "thread.delete", "thread.detach", "turn.start", "turn.cancel", "interaction.candidate"];
+export declare const RELAY_LOCAL_ONLY_REQUEST_METHODS_V10: readonly ["initialize"];
+export declare const RELAY_LOCAL_ONLY_REQUEST_METHODS_V11: readonly ["initialize"];
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
 export declare const RELAY_MUTATION_REQUEST_METHODS: readonly ["thread.create", "thread.rename", "thread.delete", "thread.detach", "turn.start", "turn.cancel", "approval.respond", "approval.candidate"];
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
 export declare const RELAY_LOCAL_ONLY_REQUEST_METHODS: readonly ["initialize"];
 export declare const RELAY_ERROR_CODES: {
     readonly protocolVersionUnsupported: "RELAY_PROTOCOL_VERSION_UNSUPPORTED";
@@ -82,13 +182,44 @@ export declare const RELAY_ERROR_RETRYABILITY: {
     readonly COMPANION_ERROR: false;
 };
 export declare function getRelayErrorRetryability(code: RelayErrorCode): boolean;
+/** Wire 1.1 adds Host-level request authorization without mutating frozen Wire 1.0 exports. */
+export declare const RELAY_ERROR_CODES_V11: {
+    readonly remoteRequestDenied: "REMOTE_REQUEST_DENIED";
+    readonly protocolVersionUnsupported: "RELAY_PROTOCOL_VERSION_UNSUPPORTED";
+    readonly invalidFrame: "RELAY_INVALID_FRAME";
+    readonly invalidParams: "INVALID_PARAMS";
+    readonly requestIdConflict: "RELAY_REQUEST_ID_CONFLICT";
+    readonly workspaceNotFound: "WORKSPACE_NOT_FOUND";
+    readonly encryptionRequired: "RELAY_ENCRYPTION_REQUIRED";
+    readonly encryptedPayloadInvalid: "ENCRYPTED_PAYLOAD_INVALID";
+    readonly localApprovalDenied: "LocalApprovalDeniedError";
+    readonly localConfirmationRequired: "LocalConfirmationRequiredError";
+    readonly companionError: "COMPANION_ERROR";
+};
+export type RelayErrorCodeV11 = (typeof RELAY_ERROR_CODES_V11)[keyof typeof RELAY_ERROR_CODES_V11];
+export declare const RELAY_ERROR_RETRYABILITY_V11: {
+    readonly REMOTE_REQUEST_DENIED: false;
+    readonly RELAY_PROTOCOL_VERSION_UNSUPPORTED: false;
+    readonly RELAY_INVALID_FRAME: false;
+    readonly INVALID_PARAMS: false;
+    readonly RELAY_REQUEST_ID_CONFLICT: false;
+    readonly WORKSPACE_NOT_FOUND: false;
+    readonly RELAY_ENCRYPTION_REQUIRED: false;
+    readonly ENCRYPTED_PAYLOAD_INVALID: false;
+    readonly LocalApprovalDeniedError: false;
+    readonly LocalConfirmationRequiredError: false;
+    readonly COMPANION_ERROR: false;
+};
+export declare function getRelayErrorRetryabilityV11(code: RelayErrorCodeV11): boolean;
 export declare const relayProtocolVersionSchema: z.ZodEnum<{
+    1.1: "1.1";
     "1.0": "1.0";
 }>;
 export declare const deviceIdSchema: z.core.$ZodBranded<z.ZodString, "DeviceId">;
 export declare const workspaceIdSchema: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
 export declare const relayRequestIdSchema: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
 export declare const relayEnvelopeIdSchema: z.ZodString;
+export declare const relayInteractionIdSchema: z.core.$ZodBranded<z.ZodString, "InteractionId">;
 export declare const relayApprovalCandidateParamsSchema: z.ZodReadonly<z.ZodObject<{
     threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
     turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
@@ -102,7 +233,126 @@ export declare const relayApprovalCandidateParamsSchema: z.ZodReadonly<z.ZodObje
 export declare const relayApprovalCandidateResultSchema: z.ZodReadonly<z.ZodObject<{
     accepted: z.ZodLiteral<true>;
 }, z.core.$strict>>;
-export declare const relayRequestMethodSchemas: {
+export declare const RELAY_INTERACTION_METHODS_V11: {
+    readonly approvalRequest: "approval.request";
+    readonly userInputRequest: "userInput.request";
+};
+export declare const RELAY_INTERACTION_METHOD_VALUES_V11: readonly ["approval.request", "userInput.request"];
+export declare const relayApprovalInteractionProjectionSchemaV11: 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>>;
+export declare const relayUserInputInteractionProjectionSchemaV11: 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>>;
+export declare const relayApprovalInteractionCandidateParamsSchemaV11: 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>>;
+export declare const relayUserInputInteractionCandidateParamsSchemaV11: 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>>;
+export declare const relayInteractionCandidateParamsSchemaV11: 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>>]>;
+export declare const relayInteractionCandidateResultSchemaV11: z.ZodReadonly<z.ZodObject<{
+    accepted: z.ZodLiteral<true>;
+}, z.core.$strict>>;
+export declare const relayRequestMethodSchemasV10: {
     readonly initialize: {
         readonly params: z.ZodReadonly<z.ZodObject<{
             protocolVersions: z.ZodArray<z.ZodString>;
@@ -112,10 +362,12 @@ export declare const relayRequestMethodSchemas: {
             }, z.core.$strict>>;
         }, z.core.$strict>>;
         readonly result: z.ZodReadonly<z.ZodObject<{
-            protocolVersion: z.ZodEnum<{
-                1.1: "1.1";
-                "1.0": "1.0";
-            }>;
+            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;
@@ -132,12 +384,10 @@ export declare const relayRequestMethodSchemas: {
                 "operation-projection": "operation-projection";
                 "process-local-sequence": "process-local-sequence";
             }>>;
-            limits: z.ZodReadonly<z.ZodObject<{
-                maxFrameBytes: z.ZodNumber;
-                maxPageSize: z.ZodNumber;
-                eventReplay: z.ZodLiteral<false>;
-                idempotencyCacheEntries: z.ZodNumber;
-            }, z.core.$strict>>;
+            protocolVersion: z.ZodEnum<{
+                1.1: "1.1";
+                "1.0": "1.0";
+            }>;
         }, z.core.$strict>>;
     };
     readonly "thread.list": {
@@ -449,126 +699,2216 @@ export declare const relayRequestMethodSchemas: {
         }, z.core.$strict>>;
     };
 };
-export type RelayRequestParams<TMethod extends RelayRequestMethod> = z.infer<(typeof relayRequestMethodSchemas)[TMethod]["params"]>;
-export type RelayRequestResult<TMethod extends RelayRequestMethod> = z.infer<(typeof relayRequestMethodSchemas)[TMethod]["result"]>;
-export declare function isRelayRequestMethod(value: string): value is RelayRequestMethod;
-export declare function getRelayRequestMethodDisposition(value: string): RelayRequestMethodDisposition | undefined;
-export declare function isRelayMutationRequestMethod(method: RelayRequestMethod): method is (typeof RELAY_MUTATION_REQUEST_METHODS)[number];
-export declare function parseRelayRequestParams<TMethod extends RelayRequestMethod>(method: TMethod, value: unknown): RelayRequestParams<TMethod>;
-export declare function parseRelayRequestResult<TMethod extends RelayRequestMethod>(method: TMethod, value: unknown): RelayRequestResult<TMethod>;
-export declare const relayDeviceConnectSchema: z.ZodReadonly<z.ZodObject<{
-    type: z.ZodLiteral<"device.connect">;
-    protocolVersion: z.ZodLiteral<"1.0">;
-    deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
-    pairingToken: z.ZodString;
-}, z.core.$strict>>;
-export declare const relayRuntimeRequestSchema: z.ZodReadonly<z.ZodObject<{
-    type: z.ZodLiteral<"runtime.request">;
-    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
-    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
-    method: z.ZodEnum<{
-        initialize: "initialize";
-        "thread.list": "thread.list";
-        "thread.create": "thread.create";
-        "thread.open": "thread.open";
-        "thread.snapshot": "thread.snapshot";
-        "thread.rename": "thread.rename";
-        "thread.delete": "thread.delete";
-        "thread.detach": "thread.detach";
-        "thread.capabilities": "thread.capabilities";
-        "turn.start": "turn.start";
-        "turn.cancel": "turn.cancel";
-        "approval.respond": "approval.respond";
-        "operation.get": "operation.get";
-        "approval.candidate": "approval.candidate";
-    }>;
-    params: z.ZodJSONSchema;
-}, z.core.$strict>>;
-export declare const relayErrorSchema: z.ZodReadonly<z.ZodObject<{
-    code: z.ZodString;
-    message: z.ZodString;
-    retryable: z.ZodBoolean;
-}, z.core.$strict>>;
-/**
- * This preserves the pre-freeze v1.0 shape: result/error are independently optional.
- * A strict exactly-one response belongs in a later Relay Wire version.
- */
-export declare const relayRuntimeResponseSchema: z.ZodReadonly<z.ZodObject<{
-    type: z.ZodLiteral<"runtime.response">;
-    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
-    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
-    result: z.ZodOptional<z.ZodJSONSchema>;
-    error: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
-        code: z.ZodString;
-        message: z.ZodString;
-        retryable: z.ZodBoolean;
-    }, z.core.$strict>>>;
-}, z.core.$strict>>;
-export declare const relayRuntimeEventSchema: z.ZodReadonly<z.ZodObject<{
-    type: z.ZodLiteral<"runtime.event">;
-    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
-    relaySequence: z.ZodNumber;
-    event: z.ZodReadonly<z.ZodObject<{
-        protocolVersion: z.ZodEnum<{
-            1.1: "1.1";
-            "1.0": "1.0";
-        }>;
-        runtimeInstanceId: z.core.$ZodBranded<z.ZodString, "RuntimeInstanceId">;
-        sequence: z.ZodNumber;
-        timestamp: z.ZodString;
-        threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
-        turnId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TurnId">>;
-        event: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
-            type: z.ZodLiteral<"turn.started">;
-        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-            type: z.ZodLiteral<"message.started">;
-            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
-        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-            type: z.ZodLiteral<"message.delta">;
-            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
-            delta: z.ZodString;
-        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-            type: z.ZodLiteral<"message.completed">;
-            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
-            text: z.ZodString;
-        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-            type: z.ZodLiteral<"reasoning.summary.delta">;
-            reasoningId: z.ZodString;
-            delta: z.ZodString;
-        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-            type: z.ZodLiteral<"tool.started">;
-            toolCallId: z.ZodString;
-            agentName: z.ZodString;
-            toolName: z.ZodString;
-            input: z.ZodJSONSchema;
-        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-            type: z.ZodLiteral<"tool.output">;
-            toolCallId: z.ZodString;
-            agentName: z.ZodString;
-            toolName: z.ZodString;
-            stream: z.ZodEnum<{
-                stdout: "stdout";
-                stderr: "stderr";
-            }>;
-            delta: z.ZodString;
-        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-            type: z.ZodLiteral<"tool.completed">;
-            toolCallId: z.ZodString;
-            agentName: z.ZodString;
-            toolName: z.ZodString;
-            operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
-            outcome: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
-                kind: z.ZodEnum<{
-                    success: "success";
-                    user_rejected: "user_rejected";
-                    policy_denied: "policy_denied";
-                    invalid_input: "invalid_input";
-                    cancelled: "cancelled";
-                    tool_failed: "tool_failed";
-                }>;
-                reason: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>>>;
-            display: z.ZodJSONSchema;
+export declare const relayRequestMethodSchemasV11: {
+    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.open": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            thread: z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                title: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                messageCount: z.ZodNumber;
+            }, z.core.$strict>>;
+            messages: z.ZodReadonly<z.ZodObject<{
+                items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    sequence: z.ZodNumber;
+                    role: z.ZodEnum<{
+                        user: "user";
+                        assistant: "assistant";
+                    }>;
+                    createdAt: z.ZodString;
+                    parts: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        type: z.ZodLiteral<"text">;
+                        text: z.ZodString;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>>;
+                nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            operations: z.ZodReadonly<z.ZodObject<{
+                items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    id: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                    sequence: z.ZodNumber;
+                    toolCallId: z.ZodString;
+                    agentName: z.ZodString;
+                    toolName: z.ZodString;
+                    createdAt: z.ZodString;
+                    outcome: z.ZodReadonly<z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            success: "success";
+                            user_rejected: "user_rejected";
+                            policy_denied: "policy_denied";
+                            invalid_input: "invalid_input";
+                            cancelled: "cancelled";
+                            tool_failed: "tool_failed";
+                        }>;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    display: z.ZodJSONSchema;
+                }, z.core.$strict>>>;
+                nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            activeTurn: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                status: z.ZodEnum<{
+                    running: "running";
+                    cancelling: "cancelling";
+                }>;
+                startedAt: z.ZodString;
+            }, z.core.$strict>>>;
+            pendingApprovals: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                preview: z.ZodJSONSchema;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            transcriptCompleteness: z.ZodEnum<{
+                complete: "complete";
+                legacy_snapshot: "legacy_snapshot";
+            }>;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.snapshot": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            messageBeforeSequence: z.ZodOptional<z.ZodNumber>;
+            operationBeforeSequence: z.ZodOptional<z.ZodNumber>;
+            limit: z.ZodDefault<z.ZodNumber>;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            thread: z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                title: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                messageCount: z.ZodNumber;
+            }, z.core.$strict>>;
+            messages: z.ZodReadonly<z.ZodObject<{
+                items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    sequence: z.ZodNumber;
+                    role: z.ZodEnum<{
+                        user: "user";
+                        assistant: "assistant";
+                    }>;
+                    createdAt: z.ZodString;
+                    parts: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        type: z.ZodLiteral<"text">;
+                        text: z.ZodString;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>>;
+                nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            operations: z.ZodReadonly<z.ZodObject<{
+                items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    id: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                    sequence: z.ZodNumber;
+                    toolCallId: z.ZodString;
+                    agentName: z.ZodString;
+                    toolName: z.ZodString;
+                    createdAt: z.ZodString;
+                    outcome: z.ZodReadonly<z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            success: "success";
+                            user_rejected: "user_rejected";
+                            policy_denied: "policy_denied";
+                            invalid_input: "invalid_input";
+                            cancelled: "cancelled";
+                            tool_failed: "tool_failed";
+                        }>;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    display: z.ZodJSONSchema;
+                }, z.core.$strict>>>;
+                nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            activeTurn: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                status: z.ZodEnum<{
+                    running: "running";
+                    cancelling: "cancelling";
+                }>;
+                startedAt: z.ZodString;
+            }, z.core.$strict>>>;
+            pendingApprovals: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                preview: z.ZodJSONSchema;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            transcriptCompleteness: z.ZodEnum<{
+                complete: "complete";
+                legacy_snapshot: "legacy_snapshot";
+            }>;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.rename": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            title: z.ZodString;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            thread: z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                title: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                messageCount: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.delete": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            deleted: z.ZodLiteral<true>;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.detach": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            detached: z.ZodBoolean;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.capabilities": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            manifest: z.ZodJSONSchema;
+        }, z.core.$strict>>;
+    };
+    readonly "turn.start": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+            input: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+            }, z.core.$strict>>;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            accepted: z.ZodLiteral<true>;
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+        }, z.core.$strict>>;
+    };
+    readonly "turn.cancel": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            cancelling: z.ZodBoolean;
+        }, z.core.$strict>>;
+    };
+    readonly "operation.get": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            operationId: z.core.$ZodBranded<z.ZodString, "OperationId">;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            operation: z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                sequence: z.ZodNumber;
+                toolCallId: z.ZodString;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                createdAt: z.ZodString;
+                outcome: z.ZodReadonly<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        success: "success";
+                        user_rejected: "user_rejected";
+                        policy_denied: "policy_denied";
+                        invalid_input: "invalid_input";
+                        cancelled: "cancelled";
+                        tool_failed: "tool_failed";
+                    }>;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                display: z.ZodJSONSchema;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    };
+    readonly "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>>;
+    };
+};
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
+export declare const relayRequestMethodSchemas: {
+    readonly initialize: {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            protocolVersions: z.ZodArray<z.ZodString>;
+            client: z.ZodReadonly<z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            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.open": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            thread: z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                title: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                messageCount: z.ZodNumber;
+            }, z.core.$strict>>;
+            messages: z.ZodReadonly<z.ZodObject<{
+                items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    sequence: z.ZodNumber;
+                    role: z.ZodEnum<{
+                        user: "user";
+                        assistant: "assistant";
+                    }>;
+                    createdAt: z.ZodString;
+                    parts: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        type: z.ZodLiteral<"text">;
+                        text: z.ZodString;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>>;
+                nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            operations: z.ZodReadonly<z.ZodObject<{
+                items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    id: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                    sequence: z.ZodNumber;
+                    toolCallId: z.ZodString;
+                    agentName: z.ZodString;
+                    toolName: z.ZodString;
+                    createdAt: z.ZodString;
+                    outcome: z.ZodReadonly<z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            success: "success";
+                            user_rejected: "user_rejected";
+                            policy_denied: "policy_denied";
+                            invalid_input: "invalid_input";
+                            cancelled: "cancelled";
+                            tool_failed: "tool_failed";
+                        }>;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    display: z.ZodJSONSchema;
+                }, z.core.$strict>>>;
+                nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            activeTurn: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                status: z.ZodEnum<{
+                    running: "running";
+                    cancelling: "cancelling";
+                }>;
+                startedAt: z.ZodString;
+            }, z.core.$strict>>>;
+            pendingApprovals: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                preview: z.ZodJSONSchema;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            transcriptCompleteness: z.ZodEnum<{
+                complete: "complete";
+                legacy_snapshot: "legacy_snapshot";
+            }>;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.snapshot": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            messageBeforeSequence: z.ZodOptional<z.ZodNumber>;
+            operationBeforeSequence: z.ZodOptional<z.ZodNumber>;
+            limit: z.ZodDefault<z.ZodNumber>;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            thread: z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                title: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                messageCount: z.ZodNumber;
+            }, z.core.$strict>>;
+            messages: z.ZodReadonly<z.ZodObject<{
+                items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    sequence: z.ZodNumber;
+                    role: z.ZodEnum<{
+                        user: "user";
+                        assistant: "assistant";
+                    }>;
+                    createdAt: z.ZodString;
+                    parts: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        type: z.ZodLiteral<"text">;
+                        text: z.ZodString;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>>;
+                nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            operations: z.ZodReadonly<z.ZodObject<{
+                items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                    id: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                    sequence: z.ZodNumber;
+                    toolCallId: z.ZodString;
+                    agentName: z.ZodString;
+                    toolName: z.ZodString;
+                    createdAt: z.ZodString;
+                    outcome: z.ZodReadonly<z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            success: "success";
+                            user_rejected: "user_rejected";
+                            policy_denied: "policy_denied";
+                            invalid_input: "invalid_input";
+                            cancelled: "cancelled";
+                            tool_failed: "tool_failed";
+                        }>;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    display: z.ZodJSONSchema;
+                }, z.core.$strict>>>;
+                nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            activeTurn: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                status: z.ZodEnum<{
+                    running: "running";
+                    cancelling: "cancelling";
+                }>;
+                startedAt: z.ZodString;
+            }, z.core.$strict>>>;
+            pendingApprovals: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                preview: z.ZodJSONSchema;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            transcriptCompleteness: z.ZodEnum<{
+                complete: "complete";
+                legacy_snapshot: "legacy_snapshot";
+            }>;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.rename": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            title: z.ZodString;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            thread: z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                title: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                messageCount: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.delete": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            deleted: z.ZodLiteral<true>;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.detach": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            detached: z.ZodBoolean;
+        }, z.core.$strict>>;
+    };
+    readonly "thread.capabilities": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            manifest: z.ZodJSONSchema;
+        }, z.core.$strict>>;
+    };
+    readonly "turn.start": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+            input: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodString;
+            }, z.core.$strict>>;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            accepted: z.ZodLiteral<true>;
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+        }, z.core.$strict>>;
+    };
+    readonly "turn.cancel": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            cancelling: z.ZodBoolean;
+        }, z.core.$strict>>;
+    };
+    readonly "approval.respond": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+            approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+            decision: z.ZodEnum<{
+                approve: "approve";
+                reject: "reject";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            resolved: z.ZodLiteral<true>;
+        }, z.core.$strict>>;
+    };
+    readonly "operation.get": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            operationId: z.core.$ZodBranded<z.ZodString, "OperationId">;
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            operation: z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                sequence: z.ZodNumber;
+                toolCallId: z.ZodString;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                createdAt: z.ZodString;
+                outcome: z.ZodReadonly<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        success: "success";
+                        user_rejected: "user_rejected";
+                        policy_denied: "policy_denied";
+                        invalid_input: "invalid_input";
+                        cancelled: "cancelled";
+                        tool_failed: "tool_failed";
+                    }>;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                display: z.ZodJSONSchema;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    };
+    readonly "approval.candidate": {
+        readonly params: z.ZodReadonly<z.ZodObject<{
+            threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+            turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+            approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+            decision: z.ZodEnum<{
+                approve: "approve";
+                reject: "reject";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        readonly result: z.ZodReadonly<z.ZodObject<{
+            accepted: z.ZodLiteral<true>;
+        }, z.core.$strict>>;
+    };
+};
+export type RelayRequestParams<TMethod extends RelayRequestMethod> = z.infer<(typeof relayRequestMethodSchemas)[TMethod]["params"]>;
+export type RelayRequestResult<TMethod extends RelayRequestMethod> = z.infer<(typeof relayRequestMethodSchemas)[TMethod]["result"]>;
+export declare function isRelayRequestMethod(value: string): value is RelayRequestMethod;
+export declare function getRelayRequestMethodDisposition(value: string): RelayRequestMethodDisposition | undefined;
+export declare function isRelayMutationRequestMethod(method: RelayRequestMethod): method is (typeof RELAY_MUTATION_REQUEST_METHODS)[number];
+export declare function parseRelayRequestParams<TMethod extends RelayRequestMethod>(method: TMethod, value: unknown): RelayRequestParams<TMethod>;
+export declare function parseRelayRequestResult<TMethod extends RelayRequestMethod>(method: TMethod, value: unknown): RelayRequestResult<TMethod>;
+export declare const relayDeviceConnectSchema: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"device.connect">;
+    protocolVersion: z.ZodLiteral<"1.0">;
+    deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
+    pairingToken: z.ZodString;
+}, z.core.$strict>>;
+export declare const relayRuntimeRequestSchema: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.request">;
+    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    method: z.ZodEnum<{
+        initialize: "initialize";
+        "thread.list": "thread.list";
+        "thread.create": "thread.create";
+        "thread.open": "thread.open";
+        "thread.snapshot": "thread.snapshot";
+        "thread.rename": "thread.rename";
+        "thread.delete": "thread.delete";
+        "thread.detach": "thread.detach";
+        "thread.capabilities": "thread.capabilities";
+        "turn.start": "turn.start";
+        "turn.cancel": "turn.cancel";
+        "approval.respond": "approval.respond";
+        "operation.get": "operation.get";
+        "approval.candidate": "approval.candidate";
+    }>;
+    params: z.ZodJSONSchema;
+}, z.core.$strict>>;
+export declare const relayErrorSchema: z.ZodReadonly<z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    retryable: z.ZodBoolean;
+}, z.core.$strict>>;
+/**
+ * This preserves the pre-freeze v1.0 shape: result/error are independently optional.
+ * A strict exactly-one response belongs in a later Relay Wire version.
+ */
+export declare const relayRuntimeResponseSchema: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.response">;
+    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    result: z.ZodOptional<z.ZodJSONSchema>;
+    error: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>;
+export declare const relayRuntimeEventSchema: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.event">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    relaySequence: z.ZodNumber;
+    event: z.ZodReadonly<z.ZodObject<{
+        event: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.started">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.started">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.delta">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.completed">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            text: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"reasoning.summary.delta">;
+            reasoningId: z.ZodString;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.started">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            input: z.ZodJSONSchema;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.output">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            stream: z.ZodEnum<{
+                stdout: "stdout";
+                stderr: "stderr";
+            }>;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.completed">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
+            outcome: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    success: "success";
+                    user_rejected: "user_rejected";
+                    policy_denied: "policy_denied";
+                    invalid_input: "invalid_input";
+                    cancelled: "cancelled";
+                    tool_failed: "tool_failed";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            display: z.ZodJSONSchema;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"approval.required">;
+            approval: z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                preview: z.ZodJSONSchema;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"approval.resolved">;
+            approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+            resolution: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"resolved">;
+                decision: z.ZodLiteral<"approve">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"resolved">;
+                decision: z.ZodLiteral<"reject">;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"cancelled">;
+                reason: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"expired">;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>]>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.completed">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.cancelled">;
+            reason: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.failed">;
+            stage: z.ZodEnum<{
+                bootstrap: "bootstrap";
+                plan: "plan";
+                execute: "execute";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"capabilities.changed">;
+        }, z.core.$strict>>]>;
+        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">>;
+        protocolVersion: z.ZodEnum<{
+            1.1: "1.1";
+            "1.0": "1.0";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const relayAckSchema: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.ack">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    throughRelaySequence: z.ZodNumber;
+}, z.core.$strict>>;
+export declare const relayGapSchema: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.gap">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    fromRelaySequence: z.ZodNumber;
+    throughRelaySequence: z.ZodNumber;
+    recovery: z.ZodLiteral<"thread.snapshot">;
+}, z.core.$strict>>;
+/**
+ * This preserves the pre-freeze v1.0 metadata shape. Payload-kind-specific required
+ * fields must be introduced under a later Relay Wire version.
+ */
+export declare const relayEncryptedMessageSchema: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.encrypted">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    envelopeId: z.ZodString;
+    payloadKind: z.ZodEnum<{
+        event: "event";
+        request: "request";
+        response: "response";
+    }>;
+    requestId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RelayRequestId">>;
+    relaySequence: z.ZodOptional<z.ZodNumber>;
+    algorithm: z.ZodString;
+    nonce: z.ZodString;
+    ciphertext: z.ZodString;
+}, z.core.$strict>>;
+export declare const relayDeviceConnectSchemaV10: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"device.connect">;
+    protocolVersion: z.ZodLiteral<"1.0">;
+    deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
+    pairingToken: z.ZodString;
+}, z.core.$strict>>;
+export declare const relayRuntimeRequestSchemaV10: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.request">;
+    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    method: z.ZodEnum<{
+        initialize: "initialize";
+        "thread.list": "thread.list";
+        "thread.create": "thread.create";
+        "thread.open": "thread.open";
+        "thread.snapshot": "thread.snapshot";
+        "thread.rename": "thread.rename";
+        "thread.delete": "thread.delete";
+        "thread.detach": "thread.detach";
+        "thread.capabilities": "thread.capabilities";
+        "turn.start": "turn.start";
+        "turn.cancel": "turn.cancel";
+        "approval.respond": "approval.respond";
+        "operation.get": "operation.get";
+        "approval.candidate": "approval.candidate";
+    }>;
+    params: z.ZodJSONSchema;
+}, z.core.$strict>>;
+export declare const relayRuntimeResponseSchemaV10: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.response">;
+    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    result: z.ZodOptional<z.ZodJSONSchema>;
+    error: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>;
+export declare const relayRuntimeEventSchemaV10: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.event">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    relaySequence: z.ZodNumber;
+    event: z.ZodReadonly<z.ZodObject<{
+        event: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.started">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.started">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.delta">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.completed">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            text: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"reasoning.summary.delta">;
+            reasoningId: z.ZodString;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.started">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            input: z.ZodJSONSchema;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.output">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            stream: z.ZodEnum<{
+                stdout: "stdout";
+                stderr: "stderr";
+            }>;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.completed">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
+            outcome: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    success: "success";
+                    user_rejected: "user_rejected";
+                    policy_denied: "policy_denied";
+                    invalid_input: "invalid_input";
+                    cancelled: "cancelled";
+                    tool_failed: "tool_failed";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            display: z.ZodJSONSchema;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"approval.required">;
+            approval: z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                preview: z.ZodJSONSchema;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"approval.resolved">;
+            approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+            resolution: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"resolved">;
+                decision: z.ZodLiteral<"approve">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"resolved">;
+                decision: z.ZodLiteral<"reject">;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"cancelled">;
+                reason: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"expired">;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>]>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.completed">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.cancelled">;
+            reason: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.failed">;
+            stage: z.ZodEnum<{
+                bootstrap: "bootstrap";
+                plan: "plan";
+                execute: "execute";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"capabilities.changed">;
+        }, z.core.$strict>>]>;
+        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">>;
+        protocolVersion: z.ZodEnum<{
+            1.1: "1.1";
+            "1.0": "1.0";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const relayAckSchemaV10: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.ack">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    throughRelaySequence: z.ZodNumber;
+}, z.core.$strict>>;
+export declare const relayGapSchemaV10: 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>>;
+export declare const relayEncryptedMessageSchemaV10: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.encrypted">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    envelopeId: z.ZodString;
+    payloadKind: z.ZodEnum<{
+        event: "event";
+        request: "request";
+        response: "response";
+    }>;
+    requestId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RelayRequestId">>;
+    relaySequence: z.ZodOptional<z.ZodNumber>;
+    algorithm: z.ZodString;
+    nonce: z.ZodString;
+    ciphertext: z.ZodString;
+}, z.core.$strict>>;
+export declare const relaySafeToolOutcomeSchemaV11: 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>>;
+export declare const relaySafeApprovalResolutionSchemaV11: 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>>]>;
+export declare const relayTimelineEventSchemaV11: 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>>]>;
+export declare const relayRuntimeEventEnvelopeSchemaV11: z.ZodReadonly<z.ZodObject<{
+    protocolVersion: z.ZodEnum<{
+        1.1: "1.1";
+        "1.0": "1.0";
+    }>;
+    runtimeInstanceId: z.core.$ZodBranded<z.ZodString, "RuntimeInstanceId">;
+    sequence: z.ZodNumber;
+    timestamp: z.ZodString;
+    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+    turnId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TurnId">>;
+    event: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"turn.started">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"message.started">;
+        streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"message.delta">;
+        streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+        delta: z.ZodString;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"message.completed">;
+        streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+        text: z.ZodString;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"reasoning.summary.delta">;
+        reasoningId: z.ZodString;
+        delta: z.ZodString;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"tool.started">;
+        toolCallId: z.ZodString;
+        agentName: z.ZodString;
+        toolName: z.ZodString;
+    }, 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.core.$strict>>;
+export declare function projectRuntimeEventEnvelopeForRelayV11(value: unknown): z.output<typeof relayRuntimeEventEnvelopeSchemaV11> | undefined;
+/** Projects a Runtime snapshot into the allowlisted Relay Wire 1.1 query shape. */
+export declare function projectRelayThreadSnapshotV11(value: unknown): ThreadSnapshotV11;
+/** Projects an operation query result without local display or outcome details. */
+export declare function projectRelayOperationGetResultV11(value: unknown): z.output<typeof operationGetResultSchema>;
+export declare const relayApprovalInteractionRequestSchemaV11: 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>>;
+export declare const relayUserInputInteractionRequestSchemaV11: 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>>;
+export declare const relayInteractionRequestSchemaV11: 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>>]>;
+export declare const relayInteractionResolvedSchemaV11: 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>>;
+export declare const relayInteractionCancelledSchemaV11: 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 declare const relayDeviceConnectSchemaV11: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"device.connect">;
+    protocolVersion: z.ZodLiteral<"1.1">;
+    deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
+    pairingToken: z.ZodString;
+}, z.core.$strict>>;
+export declare const relayRuntimeRequestSchemaV11: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.request">;
+    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    method: z.ZodEnum<{
+        initialize: "initialize";
+        "thread.list": "thread.list";
+        "thread.create": "thread.create";
+        "thread.open": "thread.open";
+        "thread.snapshot": "thread.snapshot";
+        "thread.rename": "thread.rename";
+        "thread.delete": "thread.delete";
+        "thread.detach": "thread.detach";
+        "thread.capabilities": "thread.capabilities";
+        "turn.start": "turn.start";
+        "turn.cancel": "turn.cancel";
+        "operation.get": "operation.get";
+        "interaction.candidate": "interaction.candidate";
+    }>;
+    params: z.ZodJSONSchema;
+}, z.core.$strict>>;
+export declare const relayRuntimeResponseSchemaV11: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.response">;
+    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    result: z.ZodOptional<z.ZodJSONSchema>;
+    error: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>;
+export declare const relayRuntimeEventSchemaV11: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.event">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    relaySequence: z.ZodNumber;
+    event: z.ZodReadonly<z.ZodObject<{
+        protocolVersion: z.ZodEnum<{
+            1.1: "1.1";
+            "1.0": "1.0";
+        }>;
+        runtimeInstanceId: z.core.$ZodBranded<z.ZodString, "RuntimeInstanceId">;
+        sequence: z.ZodNumber;
+        timestamp: z.ZodString;
+        threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+        turnId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TurnId">>;
+        event: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.started">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.started">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.delta">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.completed">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            text: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"reasoning.summary.delta">;
+            reasoningId: z.ZodString;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.started">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+        }, 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.core.$strict>>;
+}, z.core.$strict>>;
+export declare const relayAckSchemaV11: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.ack">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    throughRelaySequence: z.ZodNumber;
+}, z.core.$strict>>;
+export declare const relayGapSchemaV11: 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>>;
+export declare const relayEncryptedMessageSchemaV11: z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.encrypted">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    envelopeId: z.ZodString;
+    payloadKind: z.ZodEnum<{
+        event: "event";
+        request: "request";
+        response: "response";
+        interaction: "interaction";
+    }>;
+    requestId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RelayRequestId">>;
+    relaySequence: z.ZodOptional<z.ZodNumber>;
+    algorithm: z.ZodString;
+    nonce: z.ZodString;
+    ciphertext: z.ZodString;
+}, z.core.$strict>>;
+export declare const relayMessageSchemasV10: {
+    readonly "device.connect": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"device.connect">;
+        protocolVersion: z.ZodLiteral<"1.0">;
+        deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
+        pairingToken: z.ZodString;
+    }, z.core.$strict>>;
+    readonly "runtime.request": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.request">;
+        requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        method: z.ZodEnum<{
+            initialize: "initialize";
+            "thread.list": "thread.list";
+            "thread.create": "thread.create";
+            "thread.open": "thread.open";
+            "thread.snapshot": "thread.snapshot";
+            "thread.rename": "thread.rename";
+            "thread.delete": "thread.delete";
+            "thread.detach": "thread.detach";
+            "thread.capabilities": "thread.capabilities";
+            "turn.start": "turn.start";
+            "turn.cancel": "turn.cancel";
+            "approval.respond": "approval.respond";
+            "operation.get": "operation.get";
+            "approval.candidate": "approval.candidate";
+        }>;
+        params: z.ZodJSONSchema;
+    }, z.core.$strict>>;
+    readonly "runtime.response": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.response">;
+        requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        result: z.ZodOptional<z.ZodJSONSchema>;
+        error: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    readonly "runtime.event": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.event">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        relaySequence: z.ZodNumber;
+        event: z.ZodReadonly<z.ZodObject<{
+            event: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"turn.started">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"message.started">;
+                streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"message.delta">;
+                streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+                delta: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"message.completed">;
+                streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+                text: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"reasoning.summary.delta">;
+                reasoningId: z.ZodString;
+                delta: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"tool.started">;
+                toolCallId: z.ZodString;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                input: z.ZodJSONSchema;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"tool.output">;
+                toolCallId: z.ZodString;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                stream: z.ZodEnum<{
+                    stdout: "stdout";
+                    stderr: "stderr";
+                }>;
+                delta: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"tool.completed">;
+                toolCallId: z.ZodString;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
+                outcome: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        success: "success";
+                        user_rejected: "user_rejected";
+                        policy_denied: "policy_denied";
+                        invalid_input: "invalid_input";
+                        cancelled: "cancelled";
+                        tool_failed: "tool_failed";
+                    }>;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                display: z.ZodJSONSchema;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"approval.required">;
+                approval: z.ZodReadonly<z.ZodObject<{
+                    id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                    agentName: z.ZodString;
+                    toolName: z.ZodString;
+                    preview: z.ZodJSONSchema;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"approval.resolved">;
+                approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                resolution: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+                    status: z.ZodLiteral<"resolved">;
+                    decision: z.ZodLiteral<"approve">;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    status: z.ZodLiteral<"resolved">;
+                    decision: z.ZodLiteral<"reject">;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    status: z.ZodLiteral<"cancelled">;
+                    reason: z.ZodString;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    status: z.ZodLiteral<"expired">;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>]>;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"turn.completed">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"turn.cancelled">;
+                reason: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"turn.failed">;
+                stage: z.ZodEnum<{
+                    bootstrap: "bootstrap";
+                    plan: "plan";
+                    execute: "execute";
+                }>;
+                message: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"capabilities.changed">;
+            }, z.core.$strict>>]>;
+            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">>;
+            protocolVersion: z.ZodEnum<{
+                1.1: "1.1";
+                "1.0": "1.0";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    readonly "runtime.ack": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.ack">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        throughRelaySequence: z.ZodNumber;
+    }, z.core.$strict>>;
+    readonly "runtime.gap": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.gap">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        fromRelaySequence: z.ZodNumber;
+        throughRelaySequence: z.ZodNumber;
+        recovery: z.ZodLiteral<"thread.snapshot">;
+    }, z.core.$strict>>;
+    readonly "runtime.encrypted": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.encrypted">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        envelopeId: z.ZodString;
+        payloadKind: z.ZodEnum<{
+            event: "event";
+            request: "request";
+            response: "response";
+        }>;
+        requestId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RelayRequestId">>;
+        relaySequence: z.ZodOptional<z.ZodNumber>;
+        algorithm: z.ZodString;
+        nonce: z.ZodString;
+        ciphertext: z.ZodString;
+    }, z.core.$strict>>;
+};
+export declare const relayMessageSchemaV10: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"device.connect">;
+    protocolVersion: z.ZodLiteral<"1.0">;
+    deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
+    pairingToken: z.ZodString;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.request">;
+    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    method: z.ZodEnum<{
+        initialize: "initialize";
+        "thread.list": "thread.list";
+        "thread.create": "thread.create";
+        "thread.open": "thread.open";
+        "thread.snapshot": "thread.snapshot";
+        "thread.rename": "thread.rename";
+        "thread.delete": "thread.delete";
+        "thread.detach": "thread.detach";
+        "thread.capabilities": "thread.capabilities";
+        "turn.start": "turn.start";
+        "turn.cancel": "turn.cancel";
+        "approval.respond": "approval.respond";
+        "operation.get": "operation.get";
+        "approval.candidate": "approval.candidate";
+    }>;
+    params: z.ZodJSONSchema;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.response">;
+    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    result: z.ZodOptional<z.ZodJSONSchema>;
+    error: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.event">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    relaySequence: z.ZodNumber;
+    event: z.ZodReadonly<z.ZodObject<{
+        event: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.started">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.started">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.delta">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.completed">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            text: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"reasoning.summary.delta">;
+            reasoningId: z.ZodString;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.started">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            input: z.ZodJSONSchema;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.output">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            stream: z.ZodEnum<{
+                stdout: "stdout";
+                stderr: "stderr";
+            }>;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.completed">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
+            outcome: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    success: "success";
+                    user_rejected: "user_rejected";
+                    policy_denied: "policy_denied";
+                    invalid_input: "invalid_input";
+                    cancelled: "cancelled";
+                    tool_failed: "tool_failed";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            display: z.ZodJSONSchema;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"approval.required">;
+            approval: z.ZodReadonly<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                preview: z.ZodJSONSchema;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"approval.resolved">;
+            approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+            resolution: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"resolved">;
+                decision: z.ZodLiteral<"approve">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"resolved">;
+                decision: z.ZodLiteral<"reject">;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"cancelled">;
+                reason: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"expired">;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>]>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.completed">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.cancelled">;
+            reason: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.failed">;
+            stage: z.ZodEnum<{
+                bootstrap: "bootstrap";
+                plan: "plan";
+                execute: "execute";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"capabilities.changed">;
+        }, z.core.$strict>>]>;
+        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">>;
+        protocolVersion: z.ZodEnum<{
+            1.1: "1.1";
+            "1.0": "1.0";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.ack">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    throughRelaySequence: z.ZodNumber;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.gap">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    fromRelaySequence: z.ZodNumber;
+    throughRelaySequence: z.ZodNumber;
+    recovery: z.ZodLiteral<"thread.snapshot">;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.encrypted">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    envelopeId: z.ZodString;
+    payloadKind: z.ZodEnum<{
+        event: "event";
+        request: "request";
+        response: "response";
+    }>;
+    requestId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RelayRequestId">>;
+    relaySequence: z.ZodOptional<z.ZodNumber>;
+    algorithm: z.ZodString;
+    nonce: z.ZodString;
+    ciphertext: z.ZodString;
+}, z.core.$strict>>]>;
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
+export declare const relayMessageSchemas: {
+    readonly "device.connect": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"device.connect">;
+        protocolVersion: z.ZodLiteral<"1.0">;
+        deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
+        pairingToken: z.ZodString;
+    }, z.core.$strict>>;
+    readonly "runtime.request": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.request">;
+        requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        method: z.ZodEnum<{
+            initialize: "initialize";
+            "thread.list": "thread.list";
+            "thread.create": "thread.create";
+            "thread.open": "thread.open";
+            "thread.snapshot": "thread.snapshot";
+            "thread.rename": "thread.rename";
+            "thread.delete": "thread.delete";
+            "thread.detach": "thread.detach";
+            "thread.capabilities": "thread.capabilities";
+            "turn.start": "turn.start";
+            "turn.cancel": "turn.cancel";
+            "approval.respond": "approval.respond";
+            "operation.get": "operation.get";
+            "approval.candidate": "approval.candidate";
+        }>;
+        params: z.ZodJSONSchema;
+    }, z.core.$strict>>;
+    readonly "runtime.response": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.response">;
+        requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        result: z.ZodOptional<z.ZodJSONSchema>;
+        error: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    readonly "runtime.event": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.event">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        relaySequence: z.ZodNumber;
+        event: z.ZodReadonly<z.ZodObject<{
+            event: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"turn.started">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"message.started">;
+                streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"message.delta">;
+                streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+                delta: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"message.completed">;
+                streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+                text: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"reasoning.summary.delta">;
+                reasoningId: z.ZodString;
+                delta: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"tool.started">;
+                toolCallId: z.ZodString;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                input: z.ZodJSONSchema;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"tool.output">;
+                toolCallId: z.ZodString;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                stream: z.ZodEnum<{
+                    stdout: "stdout";
+                    stderr: "stderr";
+                }>;
+                delta: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"tool.completed">;
+                toolCallId: z.ZodString;
+                agentName: z.ZodString;
+                toolName: z.ZodString;
+                operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
+                outcome: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        success: "success";
+                        user_rejected: "user_rejected";
+                        policy_denied: "policy_denied";
+                        invalid_input: "invalid_input";
+                        cancelled: "cancelled";
+                        tool_failed: "tool_failed";
+                    }>;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                display: z.ZodJSONSchema;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"approval.required">;
+                approval: z.ZodReadonly<z.ZodObject<{
+                    id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                    agentName: z.ZodString;
+                    toolName: z.ZodString;
+                    preview: z.ZodJSONSchema;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"approval.resolved">;
+                approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                resolution: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+                    status: z.ZodLiteral<"resolved">;
+                    decision: z.ZodLiteral<"approve">;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    status: z.ZodLiteral<"resolved">;
+                    decision: z.ZodLiteral<"reject">;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    status: z.ZodLiteral<"cancelled">;
+                    reason: z.ZodString;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    status: z.ZodLiteral<"expired">;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>]>;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"turn.completed">;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"turn.cancelled">;
+                reason: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"turn.failed">;
+                stage: z.ZodEnum<{
+                    bootstrap: "bootstrap";
+                    plan: "plan";
+                    execute: "execute";
+                }>;
+                message: z.ZodString;
+            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                type: z.ZodLiteral<"capabilities.changed">;
+            }, z.core.$strict>>]>;
+            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">>;
+            protocolVersion: z.ZodEnum<{
+                1.1: "1.1";
+                "1.0": "1.0";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    readonly "runtime.ack": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.ack">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        throughRelaySequence: z.ZodNumber;
+    }, z.core.$strict>>;
+    readonly "runtime.gap": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.gap">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        fromRelaySequence: z.ZodNumber;
+        throughRelaySequence: z.ZodNumber;
+        recovery: z.ZodLiteral<"thread.snapshot">;
+    }, z.core.$strict>>;
+    readonly "runtime.encrypted": z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"runtime.encrypted">;
+        workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+        envelopeId: z.ZodString;
+        payloadKind: z.ZodEnum<{
+            event: "event";
+            request: "request";
+            response: "response";
+        }>;
+        requestId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RelayRequestId">>;
+        relaySequence: z.ZodOptional<z.ZodNumber>;
+        algorithm: z.ZodString;
+        nonce: z.ZodString;
+        ciphertext: z.ZodString;
+    }, z.core.$strict>>;
+};
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
+export declare const relayMessageSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"device.connect">;
+    protocolVersion: z.ZodLiteral<"1.0">;
+    deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
+    pairingToken: z.ZodString;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.request">;
+    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    method: z.ZodEnum<{
+        initialize: "initialize";
+        "thread.list": "thread.list";
+        "thread.create": "thread.create";
+        "thread.open": "thread.open";
+        "thread.snapshot": "thread.snapshot";
+        "thread.rename": "thread.rename";
+        "thread.delete": "thread.delete";
+        "thread.detach": "thread.detach";
+        "thread.capabilities": "thread.capabilities";
+        "turn.start": "turn.start";
+        "turn.cancel": "turn.cancel";
+        "approval.respond": "approval.respond";
+        "operation.get": "operation.get";
+        "approval.candidate": "approval.candidate";
+    }>;
+    params: z.ZodJSONSchema;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.response">;
+    requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    result: z.ZodOptional<z.ZodJSONSchema>;
+    error: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.event">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    relaySequence: z.ZodNumber;
+    event: z.ZodReadonly<z.ZodObject<{
+        event: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"turn.started">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.started">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.delta">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"message.completed">;
+            streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+            text: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"reasoning.summary.delta">;
+            reasoningId: z.ZodString;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.started">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            input: z.ZodJSONSchema;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.output">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            stream: z.ZodEnum<{
+                stdout: "stdout";
+                stderr: "stderr";
+            }>;
+            delta: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"tool.completed">;
+            toolCallId: z.ZodString;
+            agentName: z.ZodString;
+            toolName: z.ZodString;
+            operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
+            outcome: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    success: "success";
+                    user_rejected: "user_rejected";
+                    policy_denied: "policy_denied";
+                    invalid_input: "invalid_input";
+                    cancelled: "cancelled";
+                    tool_failed: "tool_failed";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            display: z.ZodJSONSchema;
         }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
             type: z.ZodLiteral<"approval.required">;
             approval: z.ZodReadonly<z.ZodObject<{
@@ -613,25 +2953,27 @@ export declare const relayRuntimeEventSchema: z.ZodReadonly<z.ZodObject<{
         }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
             type: z.ZodLiteral<"capabilities.changed">;
         }, z.core.$strict>>]>;
+        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">>;
+        protocolVersion: z.ZodEnum<{
+            1.1: "1.1";
+            "1.0": "1.0";
+        }>;
     }, z.core.$strict>>;
-}, z.core.$strict>>;
-export declare const relayAckSchema: z.ZodReadonly<z.ZodObject<{
+}, 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>>;
-export declare const relayGapSchema: z.ZodReadonly<z.ZodObject<{
-    type: z.ZodLiteral<"runtime.gap">;
-    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
-    fromRelaySequence: z.ZodNumber;
-    throughRelaySequence: z.ZodNumber;
-    recovery: z.ZodLiteral<"thread.snapshot">;
-}, z.core.$strict>>;
-/**
- * This preserves the pre-freeze v1.0 metadata shape. Payload-kind-specific required
- * fields must be introduced under a later Relay Wire version.
- */
-export declare const relayEncryptedMessageSchema: z.ZodReadonly<z.ZodObject<{
+}, 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;
@@ -645,11 +2987,11 @@ export declare const relayEncryptedMessageSchema: z.ZodReadonly<z.ZodObject<{
     algorithm: z.ZodString;
     nonce: z.ZodString;
     ciphertext: z.ZodString;
-}, z.core.$strict>>;
-export declare const relayMessageSchemas: {
+}, z.core.$strict>>]>;
+export declare const relayMessageSchemasV11: {
     readonly "device.connect": z.ZodReadonly<z.ZodObject<{
         type: z.ZodLiteral<"device.connect">;
-        protocolVersion: z.ZodLiteral<"1.0">;
+        protocolVersion: z.ZodLiteral<"1.1">;
         deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
         pairingToken: z.ZodString;
     }, z.core.$strict>>;
@@ -669,9 +3011,8 @@ export declare const relayMessageSchemas: {
             "thread.capabilities": "thread.capabilities";
             "turn.start": "turn.start";
             "turn.cancel": "turn.cancel";
-            "approval.respond": "approval.respond";
             "operation.get": "operation.get";
-            "approval.candidate": "approval.candidate";
+            "interaction.candidate": "interaction.candidate";
         }>;
         params: z.ZodJSONSchema;
     }, z.core.$strict>>;
@@ -722,23 +3063,11 @@ export declare const relayMessageSchemas: {
                 toolCallId: z.ZodString;
                 agentName: z.ZodString;
                 toolName: z.ZodString;
-                input: z.ZodJSONSchema;
-            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-                type: z.ZodLiteral<"tool.output">;
-                toolCallId: z.ZodString;
-                agentName: z.ZodString;
-                toolName: z.ZodString;
-                stream: z.ZodEnum<{
-                    stdout: "stdout";
-                    stderr: "stderr";
-                }>;
-                delta: z.ZodString;
             }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
                 type: z.ZodLiteral<"tool.completed">;
                 toolCallId: z.ZodString;
                 agentName: z.ZodString;
                 toolName: z.ZodString;
-                operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
                 outcome: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
                     kind: z.ZodEnum<{
                         success: "success";
@@ -748,42 +3077,33 @@ export declare const relayMessageSchemas: {
                         cancelled: "cancelled";
                         tool_failed: "tool_failed";
                     }>;
-                    reason: z.ZodOptional<z.ZodString>;
                 }, z.core.$strict>>>;
-                display: z.ZodJSONSchema;
             }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
                 type: z.ZodLiteral<"approval.required">;
                 approval: z.ZodReadonly<z.ZodObject<{
-                    id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
-                    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                    approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
                     agentName: z.ZodString;
                     toolName: z.ZodString;
-                    preview: z.ZodJSONSchema;
-                    reason: z.ZodOptional<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.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
-                    status: z.ZodLiteral<"resolved">;
-                    decision: z.ZodLiteral<"approve">;
-                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                resolution: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
                     status: z.ZodLiteral<"resolved">;
-                    decision: z.ZodLiteral<"reject">;
-                    reason: z.ZodOptional<z.ZodString>;
+                    decision: z.ZodEnum<{
+                        approve: "approve";
+                        reject: "reject";
+                    }>;
                 }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
                     status: z.ZodLiteral<"cancelled">;
-                    reason: z.ZodString;
                 }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
                     status: z.ZodLiteral<"expired">;
-                    reason: z.ZodOptional<z.ZodString>;
                 }, z.core.$strict>>]>;
             }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
                 type: z.ZodLiteral<"turn.completed">;
             }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
                 type: z.ZodLiteral<"turn.cancelled">;
-                reason: z.ZodString;
-                message: z.ZodString;
             }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
                 type: z.ZodLiteral<"turn.failed">;
                 stage: z.ZodEnum<{
@@ -791,7 +3111,6 @@ export declare const relayMessageSchemas: {
                     plan: "plan";
                     execute: "execute";
                 }>;
-                message: z.ZodString;
             }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
                 type: z.ZodLiteral<"capabilities.changed">;
             }, z.core.$strict>>]>;
@@ -817,6 +3136,7 @@ export declare const relayMessageSchemas: {
             event: "event";
             request: "request";
             response: "response";
+            interaction: "interaction";
         }>;
         requestId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RelayRequestId">>;
         relaySequence: z.ZodOptional<z.ZodNumber>;
@@ -824,10 +3144,111 @@ export declare const relayMessageSchemas: {
         nonce: z.ZodString;
         ciphertext: z.ZodString;
     }, z.core.$strict>>;
+    readonly "interaction.request": 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>>]>;
+    readonly "interaction.resolved": 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>>;
+    readonly "interaction.cancelled": 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 declare const relayMessageSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+export declare const relayMessageSchemaV11: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
     type: z.ZodLiteral<"device.connect">;
-    protocolVersion: z.ZodLiteral<"1.0">;
+    protocolVersion: z.ZodLiteral<"1.1">;
     deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
     pairingToken: z.ZodString;
 }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
@@ -846,9 +3267,8 @@ export declare const relayMessageSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<
         "thread.capabilities": "thread.capabilities";
         "turn.start": "turn.start";
         "turn.cancel": "turn.cancel";
-        "approval.respond": "approval.respond";
         "operation.get": "operation.get";
-        "approval.candidate": "approval.candidate";
+        "interaction.candidate": "interaction.candidate";
     }>;
     params: z.ZodJSONSchema;
 }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
@@ -897,120 +3317,1372 @@ export declare const relayMessageSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<
             toolCallId: z.ZodString;
             agentName: z.ZodString;
             toolName: z.ZodString;
-            input: z.ZodJSONSchema;
         }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-            type: z.ZodLiteral<"tool.output">;
-            toolCallId: z.ZodString;
-            agentName: z.ZodString;
-            toolName: z.ZodString;
-            stream: z.ZodEnum<{
-                stdout: "stdout";
-                stderr: "stderr";
+            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.core.$strict>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.ack">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    throughRelaySequence: z.ZodNumber;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.gap">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    fromRelaySequence: z.ZodNumber;
+    throughRelaySequence: z.ZodNumber;
+    recovery: z.ZodLiteral<"thread.snapshot">;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"runtime.encrypted">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+    envelopeId: z.ZodString;
+    payloadKind: z.ZodEnum<{
+        event: "event";
+        request: "request";
+        response: "response";
+        interaction: "interaction";
+    }>;
+    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 interface RelayProtocolRegistry {
+    readonly messageTypes: readonly string[];
+    readonly messageSchema: z.ZodType;
+    readonly requestMethods: readonly string[];
+    readonly requestMethodSchemas: Readonly<Record<string, {
+        readonly params: z.ZodType;
+        readonly result: z.ZodType;
+    }>>;
+    readonly requestMethodDispositions: Readonly<Record<string, "query" | "mutation" | "local-only">>;
+    readonly mutationMethods: readonly string[];
+    readonly localOnlyMethods: readonly string[];
+}
+export declare const RELAY_PROTOCOL_REGISTRY: {
+    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<{
+            type: z.ZodLiteral<"device.connect">;
+            protocolVersion: z.ZodLiteral<"1.1">;
+            deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
+            pairingToken: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"runtime.request">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+            workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+            method: z.ZodEnum<{
+                initialize: "initialize";
+                "thread.list": "thread.list";
+                "thread.create": "thread.create";
+                "thread.open": "thread.open";
+                "thread.snapshot": "thread.snapshot";
+                "thread.rename": "thread.rename";
+                "thread.delete": "thread.delete";
+                "thread.detach": "thread.detach";
+                "thread.capabilities": "thread.capabilities";
+                "turn.start": "turn.start";
+                "turn.cancel": "turn.cancel";
+                "operation.get": "operation.get";
+                "interaction.candidate": "interaction.candidate";
+            }>;
+            params: z.ZodJSONSchema;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"runtime.response">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+            workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+            result: z.ZodOptional<z.ZodJSONSchema>;
+            error: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                retryable: z.ZodBoolean;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"runtime.event">;
+            workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+            relaySequence: z.ZodNumber;
+            event: z.ZodReadonly<z.ZodObject<{
+                protocolVersion: z.ZodEnum<{
+                    1.1: "1.1";
+                    "1.0": "1.0";
+                }>;
+                runtimeInstanceId: z.core.$ZodBranded<z.ZodString, "RuntimeInstanceId">;
+                sequence: z.ZodNumber;
+                timestamp: z.ZodString;
+                threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                turnId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TurnId">>;
+                event: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"turn.started">;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"message.started">;
+                    streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"message.delta">;
+                    streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+                    delta: z.ZodString;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"message.completed">;
+                    streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+                    text: z.ZodString;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"reasoning.summary.delta">;
+                    reasoningId: z.ZodString;
+                    delta: z.ZodString;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"tool.started">;
+                    toolCallId: z.ZodString;
+                    agentName: z.ZodString;
+                    toolName: z.ZodString;
+                }, 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.core.$strict>>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"runtime.ack">;
+            workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+            throughRelaySequence: z.ZodNumber;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"runtime.gap">;
+            workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+            fromRelaySequence: z.ZodNumber;
+            throughRelaySequence: z.ZodNumber;
+            recovery: z.ZodLiteral<"thread.snapshot">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"runtime.encrypted">;
+            workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+            envelopeId: z.ZodString;
+            payloadKind: z.ZodEnum<{
+                event: "event";
+                request: "request";
+                response: "response";
+                interaction: "interaction";
+            }>;
+            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"];
+        readonly requestMethodSchemas: {
+            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.open": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    thread: z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                        title: z.ZodOptional<z.ZodString>;
+                        model: z.ZodOptional<z.ZodString>;
+                        createdAt: z.ZodString;
+                        updatedAt: z.ZodString;
+                        messageCount: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    messages: z.ZodReadonly<z.ZodObject<{
+                        items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                            sequence: z.ZodNumber;
+                            role: z.ZodEnum<{
+                                user: "user";
+                                assistant: "assistant";
+                            }>;
+                            createdAt: z.ZodString;
+                            parts: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                                type: z.ZodLiteral<"text">;
+                                text: z.ZodString;
+                            }, z.core.$strict>>>;
+                        }, z.core.$strict>>>;
+                        nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                    operations: z.ZodReadonly<z.ZodObject<{
+                        items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                            id: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                            sequence: z.ZodNumber;
+                            toolCallId: z.ZodString;
+                            agentName: z.ZodString;
+                            toolName: z.ZodString;
+                            createdAt: z.ZodString;
+                            outcome: z.ZodReadonly<z.ZodObject<{
+                                kind: z.ZodEnum<{
+                                    success: "success";
+                                    user_rejected: "user_rejected";
+                                    policy_denied: "policy_denied";
+                                    invalid_input: "invalid_input";
+                                    cancelled: "cancelled";
+                                    tool_failed: "tool_failed";
+                                }>;
+                                reason: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strict>>;
+                            display: z.ZodJSONSchema;
+                        }, z.core.$strict>>>;
+                        nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                    activeTurn: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                        status: z.ZodEnum<{
+                            running: "running";
+                            cancelling: "cancelling";
+                        }>;
+                        startedAt: z.ZodString;
+                    }, z.core.$strict>>>;
+                    pendingApprovals: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                        turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                        agentName: z.ZodString;
+                        toolName: z.ZodString;
+                        preview: z.ZodJSONSchema;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    transcriptCompleteness: z.ZodEnum<{
+                        complete: "complete";
+                        legacy_snapshot: "legacy_snapshot";
+                    }>;
+                }, z.core.$strict>>;
+            };
+            readonly "thread.snapshot": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    messageBeforeSequence: z.ZodOptional<z.ZodNumber>;
+                    operationBeforeSequence: z.ZodOptional<z.ZodNumber>;
+                    limit: z.ZodDefault<z.ZodNumber>;
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    thread: z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                        title: z.ZodOptional<z.ZodString>;
+                        model: z.ZodOptional<z.ZodString>;
+                        createdAt: z.ZodString;
+                        updatedAt: z.ZodString;
+                        messageCount: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    messages: z.ZodReadonly<z.ZodObject<{
+                        items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                            sequence: z.ZodNumber;
+                            role: z.ZodEnum<{
+                                user: "user";
+                                assistant: "assistant";
+                            }>;
+                            createdAt: z.ZodString;
+                            parts: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                                type: z.ZodLiteral<"text">;
+                                text: z.ZodString;
+                            }, z.core.$strict>>>;
+                        }, z.core.$strict>>>;
+                        nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                    operations: z.ZodReadonly<z.ZodObject<{
+                        items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                            id: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                            sequence: z.ZodNumber;
+                            toolCallId: z.ZodString;
+                            agentName: z.ZodString;
+                            toolName: z.ZodString;
+                            createdAt: z.ZodString;
+                            outcome: z.ZodReadonly<z.ZodObject<{
+                                kind: z.ZodEnum<{
+                                    success: "success";
+                                    user_rejected: "user_rejected";
+                                    policy_denied: "policy_denied";
+                                    invalid_input: "invalid_input";
+                                    cancelled: "cancelled";
+                                    tool_failed: "tool_failed";
+                                }>;
+                                reason: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strict>>;
+                            display: z.ZodJSONSchema;
+                        }, z.core.$strict>>>;
+                        nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                    activeTurn: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                        status: z.ZodEnum<{
+                            running: "running";
+                            cancelling: "cancelling";
+                        }>;
+                        startedAt: z.ZodString;
+                    }, z.core.$strict>>>;
+                    pendingApprovals: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                        turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                        agentName: z.ZodString;
+                        toolName: z.ZodString;
+                        preview: z.ZodJSONSchema;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    transcriptCompleteness: z.ZodEnum<{
+                        complete: "complete";
+                        legacy_snapshot: "legacy_snapshot";
+                    }>;
+                }, z.core.$strict>>;
+            };
+            readonly "thread.rename": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    title: z.ZodString;
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                    requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    thread: z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                        title: z.ZodOptional<z.ZodString>;
+                        model: z.ZodOptional<z.ZodString>;
+                        createdAt: z.ZodString;
+                        updatedAt: z.ZodString;
+                        messageCount: z.ZodNumber;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+            };
+            readonly "thread.delete": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                    requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    deleted: z.ZodLiteral<true>;
+                }, z.core.$strict>>;
+            };
+            readonly "thread.detach": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                    requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    detached: z.ZodBoolean;
+                }, z.core.$strict>>;
+            };
+            readonly "thread.capabilities": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    manifest: z.ZodJSONSchema;
+                }, z.core.$strict>>;
+            };
+            readonly "turn.start": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                    input: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                    }, z.core.$strict>>;
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                    requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    accepted: z.ZodLiteral<true>;
+                    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                }, z.core.$strict>>;
+            };
+            readonly "turn.cancel": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                    requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    cancelling: z.ZodBoolean;
+                }, z.core.$strict>>;
+            };
+            readonly "operation.get": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    operationId: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    operation: z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                        sequence: z.ZodNumber;
+                        toolCallId: z.ZodString;
+                        agentName: z.ZodString;
+                        toolName: z.ZodString;
+                        createdAt: z.ZodString;
+                        outcome: z.ZodReadonly<z.ZodObject<{
+                            kind: z.ZodEnum<{
+                                success: "success";
+                                user_rejected: "user_rejected";
+                                policy_denied: "policy_denied";
+                                invalid_input: "invalid_input";
+                                cancelled: "cancelled";
+                                tool_failed: "tool_failed";
+                            }>;
+                            reason: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>>;
+                        display: z.ZodJSONSchema;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>;
+            };
+            readonly "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 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.0": {
+        readonly messageTypes: readonly ["device.connect", "runtime.request", "runtime.response", "runtime.event", "runtime.ack", "runtime.gap", "runtime.encrypted"];
+        readonly messageSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"device.connect">;
+            protocolVersion: z.ZodLiteral<"1.0">;
+            deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId">;
+            pairingToken: z.ZodString;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            type: z.ZodLiteral<"runtime.request">;
+            requestId: z.core.$ZodBranded<z.ZodString, "RelayRequestId">;
+            workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+            method: z.ZodEnum<{
+                initialize: "initialize";
+                "thread.list": "thread.list";
+                "thread.create": "thread.create";
+                "thread.open": "thread.open";
+                "thread.snapshot": "thread.snapshot";
+                "thread.rename": "thread.rename";
+                "thread.delete": "thread.delete";
+                "thread.detach": "thread.detach";
+                "thread.capabilities": "thread.capabilities";
+                "turn.start": "turn.start";
+                "turn.cancel": "turn.cancel";
+                "approval.respond": "approval.respond";
+                "operation.get": "operation.get";
+                "approval.candidate": "approval.candidate";
             }>;
-            delta: z.ZodString;
+            params: z.ZodJSONSchema;
         }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-            type: z.ZodLiteral<"tool.completed">;
-            toolCallId: z.ZodString;
-            agentName: z.ZodString;
-            toolName: z.ZodString;
-            operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
-            outcome: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
-                kind: z.ZodEnum<{
-                    success: "success";
-                    user_rejected: "user_rejected";
-                    policy_denied: "policy_denied";
-                    invalid_input: "invalid_input";
-                    cancelled: "cancelled";
-                    tool_failed: "tool_failed";
-                }>;
-                reason: z.ZodOptional<z.ZodString>;
+            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>>>;
-            display: z.ZodJSONSchema;
         }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-            type: z.ZodLiteral<"approval.required">;
-            approval: z.ZodReadonly<z.ZodObject<{
-                id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
-                turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
-                agentName: z.ZodString;
-                toolName: z.ZodString;
-                preview: z.ZodJSONSchema;
-                reason: z.ZodOptional<z.ZodString>;
+            type: z.ZodLiteral<"runtime.event">;
+            workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+            relaySequence: z.ZodNumber;
+            event: z.ZodReadonly<z.ZodObject<{
+                event: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"turn.started">;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"message.started">;
+                    streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"message.delta">;
+                    streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+                    delta: z.ZodString;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"message.completed">;
+                    streamId: z.core.$ZodBranded<z.ZodString, "StreamId">;
+                    text: z.ZodString;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"reasoning.summary.delta">;
+                    reasoningId: z.ZodString;
+                    delta: z.ZodString;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"tool.started">;
+                    toolCallId: z.ZodString;
+                    agentName: z.ZodString;
+                    toolName: z.ZodString;
+                    input: z.ZodJSONSchema;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"tool.output">;
+                    toolCallId: z.ZodString;
+                    agentName: z.ZodString;
+                    toolName: z.ZodString;
+                    stream: z.ZodEnum<{
+                        stdout: "stdout";
+                        stderr: "stderr";
+                    }>;
+                    delta: z.ZodString;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"tool.completed">;
+                    toolCallId: z.ZodString;
+                    agentName: z.ZodString;
+                    toolName: z.ZodString;
+                    operationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OperationId">>;
+                    outcome: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            success: "success";
+                            user_rejected: "user_rejected";
+                            policy_denied: "policy_denied";
+                            invalid_input: "invalid_input";
+                            cancelled: "cancelled";
+                            tool_failed: "tool_failed";
+                        }>;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    display: z.ZodJSONSchema;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"approval.required">;
+                    approval: z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                        turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                        agentName: z.ZodString;
+                        toolName: z.ZodString;
+                        preview: z.ZodJSONSchema;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"approval.resolved">;
+                    approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                    resolution: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+                        status: z.ZodLiteral<"resolved">;
+                        decision: z.ZodLiteral<"approve">;
+                    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                        status: z.ZodLiteral<"resolved">;
+                        decision: z.ZodLiteral<"reject">;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                        status: z.ZodLiteral<"cancelled">;
+                        reason: z.ZodString;
+                    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                        status: z.ZodLiteral<"expired">;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>]>;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"turn.completed">;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"turn.cancelled">;
+                    reason: z.ZodString;
+                    message: z.ZodString;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"turn.failed">;
+                    stage: z.ZodEnum<{
+                        bootstrap: "bootstrap";
+                        plan: "plan";
+                        execute: "execute";
+                    }>;
+                    message: z.ZodString;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    type: z.ZodLiteral<"capabilities.changed">;
+                }, z.core.$strict>>]>;
+                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">>;
+                protocolVersion: z.ZodEnum<{
+                    1.1: "1.1";
+                    "1.0": "1.0";
+                }>;
             }, z.core.$strict>>;
         }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-            type: z.ZodLiteral<"approval.resolved">;
-            approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
-            resolution: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
-                status: z.ZodLiteral<"resolved">;
-                decision: z.ZodLiteral<"approve">;
-            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-                status: z.ZodLiteral<"resolved">;
-                decision: z.ZodLiteral<"reject">;
-                reason: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-                status: z.ZodLiteral<"cancelled">;
-                reason: z.ZodString;
-            }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-                status: z.ZodLiteral<"expired">;
-                reason: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>>]>;
-        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-            type: z.ZodLiteral<"turn.completed">;
+            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<"turn.cancelled">;
-            reason: z.ZodString;
-            message: z.ZodString;
+            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<"turn.failed">;
-            stage: z.ZodEnum<{
-                bootstrap: "bootstrap";
-                plan: "plan";
-                execute: "execute";
+            type: z.ZodLiteral<"runtime.encrypted">;
+            workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
+            envelopeId: z.ZodString;
+            payloadKind: z.ZodEnum<{
+                event: "event";
+                request: "request";
+                response: "response";
             }>;
-            message: z.ZodString;
-        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-            type: z.ZodLiteral<"capabilities.changed">;
+            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.core.$strict>>;
-}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-    type: z.ZodLiteral<"runtime.ack">;
-    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
-    throughRelaySequence: z.ZodNumber;
-}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-    type: z.ZodLiteral<"runtime.gap">;
-    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
-    fromRelaySequence: z.ZodNumber;
-    throughRelaySequence: z.ZodNumber;
-    recovery: z.ZodLiteral<"thread.snapshot">;
-}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-    type: z.ZodLiteral<"runtime.encrypted">;
-    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId">;
-    envelopeId: z.ZodString;
-    payloadKind: z.ZodEnum<{
-        event: "event";
-        request: "request";
-        response: "response";
-    }>;
-    requestId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RelayRequestId">>;
-    relaySequence: z.ZodOptional<z.ZodNumber>;
-    algorithm: z.ZodString;
-    nonce: z.ZodString;
-    ciphertext: z.ZodString;
-}, z.core.$strict>>]>;
-export interface RelayProtocolRegistry {
-    readonly messageTypes: readonly (typeof RELAY_MESSAGE_TYPE_VALUES)[number][];
-    readonly requestMethods: readonly RelayRequestMethod[];
-    readonly mutationMethods: readonly RelayRequestMethod[];
-    readonly localOnlyMethods: readonly RelayRequestMethod[];
-}
-export declare const RELAY_PROTOCOL_REGISTRY: {
-    readonly "1.0": {
-        readonly messageTypes: readonly ["device.connect", "runtime.request", "runtime.response", "runtime.event", "runtime.ack", "runtime.gap", "runtime.encrypted"];
         readonly requestMethods: readonly ["initialize", "thread.list", "thread.create", "thread.open", "thread.snapshot", "thread.rename", "thread.delete", "thread.detach", "thread.capabilities", "turn.start", "turn.cancel", "approval.respond", "operation.get", "approval.candidate"];
+        readonly requestMethodSchemas: {
+            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.open": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    thread: z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                        title: z.ZodOptional<z.ZodString>;
+                        model: z.ZodOptional<z.ZodString>;
+                        createdAt: z.ZodString;
+                        updatedAt: z.ZodString;
+                        messageCount: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    messages: z.ZodReadonly<z.ZodObject<{
+                        items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                            sequence: z.ZodNumber;
+                            role: z.ZodEnum<{
+                                user: "user";
+                                assistant: "assistant";
+                            }>;
+                            createdAt: z.ZodString;
+                            parts: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                                type: z.ZodLiteral<"text">;
+                                text: z.ZodString;
+                            }, z.core.$strict>>>;
+                        }, z.core.$strict>>>;
+                        nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                    operations: z.ZodReadonly<z.ZodObject<{
+                        items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                            id: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                            sequence: z.ZodNumber;
+                            toolCallId: z.ZodString;
+                            agentName: z.ZodString;
+                            toolName: z.ZodString;
+                            createdAt: z.ZodString;
+                            outcome: z.ZodReadonly<z.ZodObject<{
+                                kind: z.ZodEnum<{
+                                    success: "success";
+                                    user_rejected: "user_rejected";
+                                    policy_denied: "policy_denied";
+                                    invalid_input: "invalid_input";
+                                    cancelled: "cancelled";
+                                    tool_failed: "tool_failed";
+                                }>;
+                                reason: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strict>>;
+                            display: z.ZodJSONSchema;
+                        }, z.core.$strict>>>;
+                        nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                    activeTurn: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                        status: z.ZodEnum<{
+                            running: "running";
+                            cancelling: "cancelling";
+                        }>;
+                        startedAt: z.ZodString;
+                    }, z.core.$strict>>>;
+                    pendingApprovals: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                        turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                        agentName: z.ZodString;
+                        toolName: z.ZodString;
+                        preview: z.ZodJSONSchema;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    transcriptCompleteness: z.ZodEnum<{
+                        complete: "complete";
+                        legacy_snapshot: "legacy_snapshot";
+                    }>;
+                }, z.core.$strict>>;
+            };
+            readonly "thread.snapshot": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    messageBeforeSequence: z.ZodOptional<z.ZodNumber>;
+                    operationBeforeSequence: z.ZodOptional<z.ZodNumber>;
+                    limit: z.ZodDefault<z.ZodNumber>;
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    thread: z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                        title: z.ZodOptional<z.ZodString>;
+                        model: z.ZodOptional<z.ZodString>;
+                        createdAt: z.ZodString;
+                        updatedAt: z.ZodString;
+                        messageCount: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    messages: z.ZodReadonly<z.ZodObject<{
+                        items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                            sequence: z.ZodNumber;
+                            role: z.ZodEnum<{
+                                user: "user";
+                                assistant: "assistant";
+                            }>;
+                            createdAt: z.ZodString;
+                            parts: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                                type: z.ZodLiteral<"text">;
+                                text: z.ZodString;
+                            }, z.core.$strict>>>;
+                        }, z.core.$strict>>>;
+                        nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                    operations: z.ZodReadonly<z.ZodObject<{
+                        items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                            id: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                            sequence: z.ZodNumber;
+                            toolCallId: z.ZodString;
+                            agentName: z.ZodString;
+                            toolName: z.ZodString;
+                            createdAt: z.ZodString;
+                            outcome: z.ZodReadonly<z.ZodObject<{
+                                kind: z.ZodEnum<{
+                                    success: "success";
+                                    user_rejected: "user_rejected";
+                                    policy_denied: "policy_denied";
+                                    invalid_input: "invalid_input";
+                                    cancelled: "cancelled";
+                                    tool_failed: "tool_failed";
+                                }>;
+                                reason: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strict>>;
+                            display: z.ZodJSONSchema;
+                        }, z.core.$strict>>>;
+                        nextBeforeSequence: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                    activeTurn: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                        status: z.ZodEnum<{
+                            running: "running";
+                            cancelling: "cancelling";
+                        }>;
+                        startedAt: z.ZodString;
+                    }, z.core.$strict>>>;
+                    pendingApprovals: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                        turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                        agentName: z.ZodString;
+                        toolName: z.ZodString;
+                        preview: z.ZodJSONSchema;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    transcriptCompleteness: z.ZodEnum<{
+                        complete: "complete";
+                        legacy_snapshot: "legacy_snapshot";
+                    }>;
+                }, z.core.$strict>>;
+            };
+            readonly "thread.rename": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    title: z.ZodString;
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                    requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    thread: z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                        title: z.ZodOptional<z.ZodString>;
+                        model: z.ZodOptional<z.ZodString>;
+                        createdAt: z.ZodString;
+                        updatedAt: z.ZodString;
+                        messageCount: z.ZodNumber;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+            };
+            readonly "thread.delete": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                    requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    deleted: z.ZodLiteral<true>;
+                }, z.core.$strict>>;
+            };
+            readonly "thread.detach": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                    requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    detached: z.ZodBoolean;
+                }, z.core.$strict>>;
+            };
+            readonly "thread.capabilities": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    manifest: z.ZodJSONSchema;
+                }, z.core.$strict>>;
+            };
+            readonly "turn.start": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                    input: z.ZodReadonly<z.ZodObject<{
+                        text: z.ZodString;
+                    }, z.core.$strict>>;
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                    requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    accepted: z.ZodLiteral<true>;
+                    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                }, z.core.$strict>>;
+            };
+            readonly "turn.cancel": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                    requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    cancelling: z.ZodBoolean;
+                }, z.core.$strict>>;
+            };
+            readonly "approval.respond": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                    approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                    decision: z.ZodEnum<{
+                        approve: "approve";
+                        reject: "reject";
+                    }>;
+                    reason: z.ZodOptional<z.ZodString>;
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                    requestId: z.core.$ZodBranded<z.ZodString, "RequestId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    resolved: z.ZodLiteral<true>;
+                }, z.core.$strict>>;
+            };
+            readonly "operation.get": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    operationId: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    operation: z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+                        id: z.core.$ZodBranded<z.ZodString, "OperationId">;
+                        sequence: z.ZodNumber;
+                        toolCallId: z.ZodString;
+                        agentName: z.ZodString;
+                        toolName: z.ZodString;
+                        createdAt: z.ZodString;
+                        outcome: z.ZodReadonly<z.ZodObject<{
+                            kind: z.ZodEnum<{
+                                success: "success";
+                                user_rejected: "user_rejected";
+                                policy_denied: "policy_denied";
+                                invalid_input: "invalid_input";
+                                cancelled: "cancelled";
+                                tool_failed: "tool_failed";
+                            }>;
+                            reason: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>>;
+                        display: z.ZodJSONSchema;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>;
+            };
+            readonly "approval.candidate": {
+                readonly params: z.ZodReadonly<z.ZodObject<{
+                    threadId: z.core.$ZodBranded<z.ZodString, "ThreadId">;
+                    turnId: z.core.$ZodBranded<z.ZodString, "TurnId">;
+                    approvalId: z.core.$ZodBranded<z.ZodString, "ApprovalId">;
+                    decision: z.ZodEnum<{
+                        approve: "approve";
+                        reject: "reject";
+                    }>;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                readonly result: z.ZodReadonly<z.ZodObject<{
+                    accepted: z.ZodLiteral<true>;
+                }, z.core.$strict>>;
+            };
+        };
+        readonly requestMethodDispositions: {
+            readonly initialize: "local-only";
+            readonly "thread.list": "query";
+            readonly "thread.create": "mutation";
+            readonly "thread.open": "query";
+            readonly "thread.snapshot": "query";
+            readonly "thread.rename": "mutation";
+            readonly "thread.delete": "mutation";
+            readonly "thread.detach": "mutation";
+            readonly "thread.capabilities": "query";
+            readonly "turn.start": "mutation";
+            readonly "turn.cancel": "mutation";
+            readonly "approval.respond": "mutation";
+            readonly "operation.get": "query";
+            readonly "approval.candidate": "mutation";
+        };
         readonly mutationMethods: readonly ["thread.create", "thread.rename", "thread.delete", "thread.detach", "turn.start", "turn.cancel", "approval.respond", "approval.candidate"];
         readonly localOnlyMethods: readonly ["initialize"];
     };
 };
-export declare function getRelayProtocolRegistry(version: RelayProtocolVersion): RelayProtocolRegistry;
+type RelayProtocolRegistryMap = typeof RELAY_PROTOCOL_REGISTRY;
+type RelaySchemaParams<TDefinition> = TDefinition extends {
+    readonly params: infer TSchema extends z.ZodType;
+} ? TSchema : never;
+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>;
+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>>>;
+export type RelayRequestMethodDispositionForVersion<TVersion extends RelayProtocolVersion> = RelayProtocolRegistryMap[TVersion]["requestMethodDispositions"][keyof RelayProtocolRegistryMap[TVersion]["requestMethodDispositions"]];
+export declare function getRelayProtocolRegistry<TVersion extends RelayProtocolVersion>(version: TVersion): RelayProtocolRegistryMap[TVersion];
+export declare function parseRelayMessageForVersion<TVersion extends RelayProtocolVersion>(version: TVersion, value: unknown): RelayMessageForVersion<TVersion>;
+export declare function isRelayRequestMethodForVersion<TVersion extends RelayProtocolVersion>(version: TVersion, value: string): value is RelayRequestMethodForVersion<TVersion>;
+export declare function getRelayRequestMethodDispositionForVersion<TVersion extends RelayProtocolVersion>(version: TVersion, value: string): RelayRequestMethodDispositionForVersion<TVersion> | undefined;
+export declare function parseRelayRequestParamsForVersion<TVersion extends RelayProtocolVersion, TMethod extends RelayRequestMethodForVersion<TVersion>>(version: TVersion, method: TMethod, value: unknown): RelayRequestParamsForVersion<TVersion, TMethod>;
+export declare function parseRelayRequestResultForVersion<TVersion extends RelayProtocolVersion, TMethod extends RelayRequestMethodForVersion<TVersion>>(version: TVersion, method: TMethod, value: unknown): RelayRequestResultForVersion<TVersion, TMethod>;
+export declare function parseRelayInteractionCandidateForRequestV11(request: RelayInteractionRequestV11, candidate: unknown): RelayInteractionCandidateParamsV11;
 export declare function negotiateRelayProtocolVersion(peerVersions: readonly string[]): RelayProtocolVersion | undefined;
 export declare function canonicalizeRelayJson(value: JsonValue): string;
 export declare const RELAY_REQUEST_REPLAY_DISPOSITIONS: {
@@ -1025,7 +4697,13 @@ export type RelayRequestReplayClassification = {
     readonly disposition: typeof RELAY_REQUEST_REPLAY_DISPOSITIONS.conflict;
     readonly errorCode: typeof RELAY_ERROR_CODES.requestIdConflict;
 };
-export declare function classifyRelayRequestReplay(existing: RelayRuntimeRequest, candidate: RelayRuntimeRequest): RelayRequestReplayClassification;
+export interface RelayReplayableRuntimeRequest {
+    readonly requestId: RelayRequestId;
+    readonly workspaceId: WorkspaceId;
+    readonly method: string;
+    readonly params: JsonValue;
+}
+export declare function classifyRelayRequestReplay(existing: RelayReplayableRuntimeRequest, candidate: RelayReplayableRuntimeRequest): RelayRequestReplayClassification;
 export interface RelayAckState {
     readonly acknowledgedThrough: number;
     /** Highest sequence the caller has proved was delivered without a preceding send hole. */
@@ -1038,13 +4716,39 @@ export type DeviceId = z.infer<typeof deviceIdSchema>;
 export type WorkspaceId = z.infer<typeof workspaceIdSchema>;
 export type RelayRequestId = z.infer<typeof relayRequestIdSchema>;
 export type RelayEnvelopeId = z.infer<typeof relayEnvelopeIdSchema>;
+export type InteractionId = z.output<typeof relayInteractionIdSchema>;
 export type RelayApprovalCandidateInput = z.input<typeof relayApprovalCandidateParamsSchema>;
 export type RelayApprovalCandidateParams = z.infer<typeof relayApprovalCandidateParamsSchema>;
 export type RelayApprovalCandidateResult = z.infer<typeof relayApprovalCandidateResultSchema>;
 export type RelayError = z.infer<typeof relayErrorSchema>;
+export type RelayInteractionMethodV11 = (typeof RELAY_INTERACTION_METHOD_VALUES_V11)[number];
+export type RelayApprovalInteractionProjectionV11 = z.output<typeof relayApprovalInteractionProjectionSchemaV11>;
+export type RelayUserInputInteractionProjectionV11 = z.output<typeof relayUserInputInteractionProjectionSchemaV11>;
+export type RelayInteractionCandidateParamsV11 = z.output<typeof relayInteractionCandidateParamsSchemaV11>;
+export type RelayInteractionCandidateResultV11 = z.output<typeof relayInteractionCandidateResultSchemaV11>;
+export type RelayInteractionRequestV11 = z.output<typeof relayInteractionRequestSchemaV11>;
+export type RelayInteractionResolvedV11 = z.output<typeof relayInteractionResolvedSchemaV11>;
+export type RelayInteractionCancelledV11 = z.output<typeof relayInteractionCancelledSchemaV11>;
+export type RelayTimelineEventV11 = z.output<typeof relayTimelineEventSchemaV11>;
+export type RelayRuntimeEventEnvelopeV11 = z.output<typeof relayRuntimeEventEnvelopeSchemaV11>;
+export type RelayMessageV10 = z.output<typeof relayMessageSchemaV10>;
+export type RelayMessageV11 = z.output<typeof relayMessageSchemaV11>;
+export type RelayRequestMethodV11 = RelayRequestMethodForVersion<"1.1">;
+export type RelayRuntimeRequestV10 = z.output<typeof relayRuntimeRequestSchemaV10>;
+export type RelayRuntimeRequestV11 = z.output<typeof relayRuntimeRequestSchemaV11>;
+export type RelayRuntimeEventV10 = z.output<typeof relayRuntimeEventSchemaV10>;
+export type RelayRuntimeEventV11 = z.output<typeof relayRuntimeEventSchemaV11>;
+export type RelayEncryptedMessageV10 = z.output<typeof relayEncryptedMessageSchemaV10>;
+export type RelayEncryptedMessageV11 = z.output<typeof relayEncryptedMessageSchemaV11>;
+/** @deprecated Legacy generic Relay types remain pinned to Wire 1.0. */
 export type RelayMessage = z.infer<typeof relayMessageSchema>;
+/** @deprecated Legacy generic Relay types remain pinned to Wire 1.0. */
 export type RelayRuntimeRequest = z.infer<typeof relayRuntimeRequestSchema>;
+/** @deprecated Legacy generic Relay types remain pinned to Wire 1.0. */
 export type RelayRuntimeResponse = z.infer<typeof relayRuntimeResponseSchema>;
+/** @deprecated Legacy generic Relay types remain pinned to Wire 1.0. */
 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 {};