@roll-agent/relay-protocol 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,10 +1,12 @@
-import { approvalIdSchema, jsonValueSchema, runtimeEventEnvelopeSchema, runtimeMethodSchemas, threadIdSchema, turnIdSchema, } from "@roll-agent/protocol";
+import { RUNTIME_SERVER_REQUEST_METHODS, TOOL_OUTCOME_KINDS, approvalIdSchema, approvalExplanationSchema, approvalRequestResultSchema, getApprovalExplanation, interactionIdSchema, jsonValueSchema, normalizeUserInputResult, operationGetResultSchema, operationViewSchema, pendingApprovalSchema, projectThreadSnapshotForVersion, runtimeEventEnvelopeSchema, runtimeEventEnvelopeV11Schema, runtimeMethodSchemasV11, runtimeInstanceIdSchema, streamIdSchema, threadIdSchema, threadSnapshotV11Schema, timestampSchema, turnIdSchema, userInputFormSchema, userInputResultSchema, } from "@roll-agent/protocol";
 import { z } from "zod/v4";
-export const SUPPORTED_RELAY_PROTOCOL_VERSIONS = ["1.0"];
-export const RELAY_PROTOCOL_VERSION = SUPPORTED_RELAY_PROTOCOL_VERSIONS[0];
-/** @deprecated Use `RELAY_PROTOCOL_VERSION`. */
+export const SUPPORTED_RELAY_PROTOCOL_VERSIONS = ["1.1", "1.0"];
+export const LATEST_RELAY_PROTOCOL_VERSION = SUPPORTED_RELAY_PROTOCOL_VERSIONS[0];
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
+export const RELAY_PROTOCOL_VERSION = "1.0";
+/** @deprecated The one-argument Companion connection API remains pinned to Wire 1.0. */
 export const COMPANION_RELAY_PROTOCOL_VERSION = RELAY_PROTOCOL_VERSION;
-export const RELAY_MESSAGE_TYPES = {
+export const RELAY_MESSAGE_TYPES_V10 = {
     deviceConnect: "device.connect",
     runtimeRequest: "runtime.request",
     runtimeResponse: "runtime.response",
@@ -13,20 +15,36 @@ export const RELAY_MESSAGE_TYPES = {
     runtimeGap: "runtime.gap",
     runtimeEncrypted: "runtime.encrypted",
 };
-export const RELAY_MESSAGE_TYPE_VALUES = [
-    RELAY_MESSAGE_TYPES.deviceConnect,
-    RELAY_MESSAGE_TYPES.runtimeRequest,
-    RELAY_MESSAGE_TYPES.runtimeResponse,
-    RELAY_MESSAGE_TYPES.runtimeEvent,
-    RELAY_MESSAGE_TYPES.runtimeAck,
-    RELAY_MESSAGE_TYPES.runtimeGap,
-    RELAY_MESSAGE_TYPES.runtimeEncrypted,
+export const RELAY_MESSAGE_TYPES_V11 = {
+    ...RELAY_MESSAGE_TYPES_V10,
+    interactionRequest: "interaction.request",
+    interactionResolved: "interaction.resolved",
+    interactionCancelled: "interaction.cancelled",
+};
+export const RELAY_MESSAGE_TYPE_VALUES_V10 = [
+    RELAY_MESSAGE_TYPES_V10.deviceConnect,
+    RELAY_MESSAGE_TYPES_V10.runtimeRequest,
+    RELAY_MESSAGE_TYPES_V10.runtimeResponse,
+    RELAY_MESSAGE_TYPES_V10.runtimeEvent,
+    RELAY_MESSAGE_TYPES_V10.runtimeAck,
+    RELAY_MESSAGE_TYPES_V10.runtimeGap,
+    RELAY_MESSAGE_TYPES_V10.runtimeEncrypted,
+];
+export const RELAY_MESSAGE_TYPE_VALUES_V11 = [
+    ...RELAY_MESSAGE_TYPE_VALUES_V10,
+    RELAY_MESSAGE_TYPES_V11.interactionRequest,
+    RELAY_MESSAGE_TYPES_V11.interactionResolved,
+    RELAY_MESSAGE_TYPES_V11.interactionCancelled,
 ];
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
+export const RELAY_MESSAGE_TYPES = RELAY_MESSAGE_TYPES_V10;
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
+export const RELAY_MESSAGE_TYPE_VALUES = RELAY_MESSAGE_TYPE_VALUES_V10;
 /**
  * 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 const RELAY_REQUEST_METHODS = {
+export const RELAY_REQUEST_METHODS_V10 = {
     initialize: "initialize",
     threadList: "thread.list",
     threadCreate: "thread.create",
@@ -42,51 +60,116 @@ export const RELAY_REQUEST_METHODS = {
     operationGet: "operation.get",
     approvalCandidate: "approval.candidate",
 };
-export const RELAY_REQUEST_METHOD_VALUES = [
-    RELAY_REQUEST_METHODS.initialize,
-    RELAY_REQUEST_METHODS.threadList,
-    RELAY_REQUEST_METHODS.threadCreate,
-    RELAY_REQUEST_METHODS.threadOpen,
-    RELAY_REQUEST_METHODS.threadSnapshot,
-    RELAY_REQUEST_METHODS.threadRename,
-    RELAY_REQUEST_METHODS.threadDelete,
-    RELAY_REQUEST_METHODS.threadDetach,
-    RELAY_REQUEST_METHODS.threadCapabilities,
-    RELAY_REQUEST_METHODS.turnStart,
-    RELAY_REQUEST_METHODS.turnCancel,
-    RELAY_REQUEST_METHODS.approvalRespond,
-    RELAY_REQUEST_METHODS.operationGet,
-    RELAY_REQUEST_METHODS.approvalCandidate,
+export const RELAY_REQUEST_METHODS_V11 = {
+    initialize: "initialize",
+    threadList: "thread.list",
+    threadCreate: "thread.create",
+    threadOpen: "thread.open",
+    threadSnapshot: "thread.snapshot",
+    threadRename: "thread.rename",
+    threadDelete: "thread.delete",
+    threadDetach: "thread.detach",
+    threadCapabilities: "thread.capabilities",
+    turnStart: "turn.start",
+    turnCancel: "turn.cancel",
+    operationGet: "operation.get",
+    interactionCandidate: "interaction.candidate",
+};
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
+export const RELAY_REQUEST_METHODS = RELAY_REQUEST_METHODS_V10;
+export const RELAY_REQUEST_METHOD_VALUES_V10 = [
+    RELAY_REQUEST_METHODS_V10.initialize,
+    RELAY_REQUEST_METHODS_V10.threadList,
+    RELAY_REQUEST_METHODS_V10.threadCreate,
+    RELAY_REQUEST_METHODS_V10.threadOpen,
+    RELAY_REQUEST_METHODS_V10.threadSnapshot,
+    RELAY_REQUEST_METHODS_V10.threadRename,
+    RELAY_REQUEST_METHODS_V10.threadDelete,
+    RELAY_REQUEST_METHODS_V10.threadDetach,
+    RELAY_REQUEST_METHODS_V10.threadCapabilities,
+    RELAY_REQUEST_METHODS_V10.turnStart,
+    RELAY_REQUEST_METHODS_V10.turnCancel,
+    RELAY_REQUEST_METHODS_V10.approvalRespond,
+    RELAY_REQUEST_METHODS_V10.operationGet,
+    RELAY_REQUEST_METHODS_V10.approvalCandidate,
 ];
-export const RELAY_REQUEST_METHOD_DISPOSITIONS = {
-    [RELAY_REQUEST_METHODS.initialize]: "local-only",
-    [RELAY_REQUEST_METHODS.threadList]: "query",
-    [RELAY_REQUEST_METHODS.threadCreate]: "mutation",
-    [RELAY_REQUEST_METHODS.threadOpen]: "query",
-    [RELAY_REQUEST_METHODS.threadSnapshot]: "query",
-    [RELAY_REQUEST_METHODS.threadRename]: "mutation",
-    [RELAY_REQUEST_METHODS.threadDelete]: "mutation",
-    [RELAY_REQUEST_METHODS.threadDetach]: "mutation",
-    [RELAY_REQUEST_METHODS.threadCapabilities]: "query",
-    [RELAY_REQUEST_METHODS.turnStart]: "mutation",
-    [RELAY_REQUEST_METHODS.turnCancel]: "mutation",
-    [RELAY_REQUEST_METHODS.approvalRespond]: "mutation",
-    [RELAY_REQUEST_METHODS.operationGet]: "query",
-    [RELAY_REQUEST_METHODS.approvalCandidate]: "mutation",
+export const RELAY_REQUEST_METHOD_VALUES_V11 = [
+    RELAY_REQUEST_METHODS_V11.initialize,
+    RELAY_REQUEST_METHODS_V11.threadList,
+    RELAY_REQUEST_METHODS_V11.threadCreate,
+    RELAY_REQUEST_METHODS_V11.threadOpen,
+    RELAY_REQUEST_METHODS_V11.threadSnapshot,
+    RELAY_REQUEST_METHODS_V11.threadRename,
+    RELAY_REQUEST_METHODS_V11.threadDelete,
+    RELAY_REQUEST_METHODS_V11.threadDetach,
+    RELAY_REQUEST_METHODS_V11.threadCapabilities,
+    RELAY_REQUEST_METHODS_V11.turnStart,
+    RELAY_REQUEST_METHODS_V11.turnCancel,
+    RELAY_REQUEST_METHODS_V11.operationGet,
+    RELAY_REQUEST_METHODS_V11.interactionCandidate,
+];
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
+export const RELAY_REQUEST_METHOD_VALUES = RELAY_REQUEST_METHOD_VALUES_V10;
+export const RELAY_REQUEST_METHOD_DISPOSITIONS_V10 = {
+    [RELAY_REQUEST_METHODS_V10.initialize]: "local-only",
+    [RELAY_REQUEST_METHODS_V10.threadList]: "query",
+    [RELAY_REQUEST_METHODS_V10.threadCreate]: "mutation",
+    [RELAY_REQUEST_METHODS_V10.threadOpen]: "query",
+    [RELAY_REQUEST_METHODS_V10.threadSnapshot]: "query",
+    [RELAY_REQUEST_METHODS_V10.threadRename]: "mutation",
+    [RELAY_REQUEST_METHODS_V10.threadDelete]: "mutation",
+    [RELAY_REQUEST_METHODS_V10.threadDetach]: "mutation",
+    [RELAY_REQUEST_METHODS_V10.threadCapabilities]: "query",
+    [RELAY_REQUEST_METHODS_V10.turnStart]: "mutation",
+    [RELAY_REQUEST_METHODS_V10.turnCancel]: "mutation",
+    [RELAY_REQUEST_METHODS_V10.approvalRespond]: "mutation",
+    [RELAY_REQUEST_METHODS_V10.operationGet]: "query",
+    [RELAY_REQUEST_METHODS_V10.approvalCandidate]: "mutation",
+};
+export const RELAY_REQUEST_METHOD_DISPOSITIONS_V11 = {
+    [RELAY_REQUEST_METHODS_V11.initialize]: "local-only",
+    [RELAY_REQUEST_METHODS_V11.threadList]: "query",
+    [RELAY_REQUEST_METHODS_V11.threadCreate]: "mutation",
+    [RELAY_REQUEST_METHODS_V11.threadOpen]: "query",
+    [RELAY_REQUEST_METHODS_V11.threadSnapshot]: "query",
+    [RELAY_REQUEST_METHODS_V11.threadRename]: "mutation",
+    [RELAY_REQUEST_METHODS_V11.threadDelete]: "mutation",
+    [RELAY_REQUEST_METHODS_V11.threadDetach]: "mutation",
+    [RELAY_REQUEST_METHODS_V11.threadCapabilities]: "query",
+    [RELAY_REQUEST_METHODS_V11.turnStart]: "mutation",
+    [RELAY_REQUEST_METHODS_V11.turnCancel]: "mutation",
+    [RELAY_REQUEST_METHODS_V11.operationGet]: "query",
+    [RELAY_REQUEST_METHODS_V11.interactionCandidate]: "mutation",
 };
-export const RELAY_MUTATION_REQUEST_METHODS = [
-    RELAY_REQUEST_METHODS.threadCreate,
-    RELAY_REQUEST_METHODS.threadRename,
-    RELAY_REQUEST_METHODS.threadDelete,
-    RELAY_REQUEST_METHODS.threadDetach,
-    RELAY_REQUEST_METHODS.turnStart,
-    RELAY_REQUEST_METHODS.turnCancel,
-    RELAY_REQUEST_METHODS.approvalRespond,
-    RELAY_REQUEST_METHODS.approvalCandidate,
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
+export const RELAY_REQUEST_METHOD_DISPOSITIONS = RELAY_REQUEST_METHOD_DISPOSITIONS_V10;
+export const RELAY_MUTATION_REQUEST_METHODS_V10 = [
+    RELAY_REQUEST_METHODS_V10.threadCreate,
+    RELAY_REQUEST_METHODS_V10.threadRename,
+    RELAY_REQUEST_METHODS_V10.threadDelete,
+    RELAY_REQUEST_METHODS_V10.threadDetach,
+    RELAY_REQUEST_METHODS_V10.turnStart,
+    RELAY_REQUEST_METHODS_V10.turnCancel,
+    RELAY_REQUEST_METHODS_V10.approvalRespond,
+    RELAY_REQUEST_METHODS_V10.approvalCandidate,
 ];
-export const RELAY_LOCAL_ONLY_REQUEST_METHODS = [
-    RELAY_REQUEST_METHODS.initialize,
+export const RELAY_MUTATION_REQUEST_METHODS_V11 = [
+    RELAY_REQUEST_METHODS_V11.threadCreate,
+    RELAY_REQUEST_METHODS_V11.threadRename,
+    RELAY_REQUEST_METHODS_V11.threadDelete,
+    RELAY_REQUEST_METHODS_V11.threadDetach,
+    RELAY_REQUEST_METHODS_V11.turnStart,
+    RELAY_REQUEST_METHODS_V11.turnCancel,
+    RELAY_REQUEST_METHODS_V11.interactionCandidate,
 ];
+export const RELAY_LOCAL_ONLY_REQUEST_METHODS_V10 = [
+    RELAY_REQUEST_METHODS_V10.initialize,
+];
+export const RELAY_LOCAL_ONLY_REQUEST_METHODS_V11 = [RELAY_REQUEST_METHODS_V11.initialize];
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
+export const RELAY_MUTATION_REQUEST_METHODS = RELAY_MUTATION_REQUEST_METHODS_V10;
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
+export const RELAY_LOCAL_ONLY_REQUEST_METHODS = RELAY_LOCAL_ONLY_REQUEST_METHODS_V10;
 export const RELAY_ERROR_CODES = {
     protocolVersionUnsupported: "RELAY_PROTOCOL_VERSION_UNSUPPORTED",
     invalidFrame: "RELAY_INVALID_FRAME",
@@ -119,6 +202,7 @@ export const deviceIdSchema = z.string().uuid().brand();
 export const workspaceIdSchema = z.string().uuid().brand();
 export const relayRequestIdSchema = z.string().uuid().brand();
 export const relayEnvelopeIdSchema = z.string().uuid();
+export const relayInteractionIdSchema = interactionIdSchema;
 export const relayApprovalCandidateParamsSchema = z
     .object({
     threadId: threadIdSchema,
@@ -135,25 +219,107 @@ export const relayApprovalCandidateResultSchema = z
 })
     .strict()
     .readonly();
-export const relayRequestMethodSchemas = {
-    [RELAY_REQUEST_METHODS.initialize]: runtimeMethodSchemas["initialize"],
-    [RELAY_REQUEST_METHODS.threadList]: runtimeMethodSchemas["thread.list"],
-    [RELAY_REQUEST_METHODS.threadCreate]: runtimeMethodSchemas["thread.create"],
-    [RELAY_REQUEST_METHODS.threadOpen]: runtimeMethodSchemas["thread.open"],
-    [RELAY_REQUEST_METHODS.threadSnapshot]: runtimeMethodSchemas["thread.snapshot"],
-    [RELAY_REQUEST_METHODS.threadRename]: runtimeMethodSchemas["thread.rename"],
-    [RELAY_REQUEST_METHODS.threadDelete]: runtimeMethodSchemas["thread.delete"],
-    [RELAY_REQUEST_METHODS.threadDetach]: runtimeMethodSchemas["thread.detach"],
-    [RELAY_REQUEST_METHODS.threadCapabilities]: runtimeMethodSchemas["thread.capabilities"],
-    [RELAY_REQUEST_METHODS.turnStart]: runtimeMethodSchemas["turn.start"],
-    [RELAY_REQUEST_METHODS.turnCancel]: runtimeMethodSchemas["turn.cancel"],
-    [RELAY_REQUEST_METHODS.approvalRespond]: runtimeMethodSchemas["approval.respond"],
-    [RELAY_REQUEST_METHODS.operationGet]: runtimeMethodSchemas["operation.get"],
-    [RELAY_REQUEST_METHODS.approvalCandidate]: {
+export const RELAY_INTERACTION_METHODS_V11 = {
+    approvalRequest: RUNTIME_SERVER_REQUEST_METHODS.approvalRequest,
+    userInputRequest: RUNTIME_SERVER_REQUEST_METHODS.userInputRequest,
+};
+export const RELAY_INTERACTION_METHOD_VALUES_V11 = [
+    RELAY_INTERACTION_METHODS_V11.approvalRequest,
+    RELAY_INTERACTION_METHODS_V11.userInputRequest,
+];
+export const relayApprovalInteractionProjectionSchemaV11 = z
+    .object({
+    approvalId: approvalIdSchema,
+    agentName: z.string().min(1),
+    toolName: z.string().min(1),
+    explanation: approvalExplanationSchema.optional(),
+})
+    .strict()
+    .readonly();
+export const relayUserInputInteractionProjectionSchemaV11 = userInputFormSchema;
+const relayInteractionCandidateBaseFieldsV11 = {
+    interactionId: interactionIdSchema,
+    threadId: threadIdSchema,
+    turnId: turnIdSchema,
+};
+export const relayApprovalInteractionCandidateParamsSchemaV11 = z
+    .object({
+    ...relayInteractionCandidateBaseFieldsV11,
+    method: z.literal(RELAY_INTERACTION_METHODS_V11.approvalRequest),
+    candidate: approvalRequestResultSchema,
+})
+    .strict()
+    .readonly();
+export const relayUserInputInteractionCandidateParamsSchemaV11 = z
+    .object({
+    ...relayInteractionCandidateBaseFieldsV11,
+    method: z.literal(RELAY_INTERACTION_METHODS_V11.userInputRequest),
+    candidate: userInputResultSchema,
+})
+    .strict()
+    .readonly();
+export const relayInteractionCandidateParamsSchemaV11 = z.discriminatedUnion("method", [
+    relayApprovalInteractionCandidateParamsSchemaV11,
+    relayUserInputInteractionCandidateParamsSchemaV11,
+]);
+export const relayInteractionCandidateResultSchemaV11 = z
+    .object({ accepted: z.literal(true) })
+    .strict()
+    .readonly();
+const relayCommonRequestMethodSchemas = {
+    initialize: runtimeMethodSchemasV11["initialize"],
+    threadList: runtimeMethodSchemasV11["thread.list"],
+    threadCreate: runtimeMethodSchemasV11["thread.create"],
+    threadOpen: runtimeMethodSchemasV11["thread.open"],
+    threadSnapshot: runtimeMethodSchemasV11["thread.snapshot"],
+    threadRename: runtimeMethodSchemasV11["thread.rename"],
+    threadDelete: runtimeMethodSchemasV11["thread.delete"],
+    threadDetach: runtimeMethodSchemasV11["thread.detach"],
+    threadCapabilities: runtimeMethodSchemasV11["thread.capabilities"],
+    turnStart: runtimeMethodSchemasV11["turn.start"],
+    turnCancel: runtimeMethodSchemasV11["turn.cancel"],
+    approvalRespond: runtimeMethodSchemasV11["approval.respond"],
+    operationGet: runtimeMethodSchemasV11["operation.get"],
+};
+export const relayRequestMethodSchemasV10 = {
+    [RELAY_REQUEST_METHODS_V10.initialize]: relayCommonRequestMethodSchemas.initialize,
+    [RELAY_REQUEST_METHODS_V10.threadList]: relayCommonRequestMethodSchemas.threadList,
+    [RELAY_REQUEST_METHODS_V10.threadCreate]: relayCommonRequestMethodSchemas.threadCreate,
+    [RELAY_REQUEST_METHODS_V10.threadOpen]: relayCommonRequestMethodSchemas.threadOpen,
+    [RELAY_REQUEST_METHODS_V10.threadSnapshot]: relayCommonRequestMethodSchemas.threadSnapshot,
+    [RELAY_REQUEST_METHODS_V10.threadRename]: relayCommonRequestMethodSchemas.threadRename,
+    [RELAY_REQUEST_METHODS_V10.threadDelete]: relayCommonRequestMethodSchemas.threadDelete,
+    [RELAY_REQUEST_METHODS_V10.threadDetach]: relayCommonRequestMethodSchemas.threadDetach,
+    [RELAY_REQUEST_METHODS_V10.threadCapabilities]: relayCommonRequestMethodSchemas.threadCapabilities,
+    [RELAY_REQUEST_METHODS_V10.turnStart]: relayCommonRequestMethodSchemas.turnStart,
+    [RELAY_REQUEST_METHODS_V10.turnCancel]: relayCommonRequestMethodSchemas.turnCancel,
+    [RELAY_REQUEST_METHODS_V10.approvalRespond]: relayCommonRequestMethodSchemas.approvalRespond,
+    [RELAY_REQUEST_METHODS_V10.operationGet]: relayCommonRequestMethodSchemas.operationGet,
+    [RELAY_REQUEST_METHODS_V10.approvalCandidate]: {
         params: relayApprovalCandidateParamsSchema,
         result: relayApprovalCandidateResultSchema,
     },
 };
+export const relayRequestMethodSchemasV11 = {
+    [RELAY_REQUEST_METHODS_V11.initialize]: relayCommonRequestMethodSchemas.initialize,
+    [RELAY_REQUEST_METHODS_V11.threadList]: relayCommonRequestMethodSchemas.threadList,
+    [RELAY_REQUEST_METHODS_V11.threadCreate]: relayCommonRequestMethodSchemas.threadCreate,
+    [RELAY_REQUEST_METHODS_V11.threadOpen]: relayCommonRequestMethodSchemas.threadOpen,
+    [RELAY_REQUEST_METHODS_V11.threadSnapshot]: relayCommonRequestMethodSchemas.threadSnapshot,
+    [RELAY_REQUEST_METHODS_V11.threadRename]: relayCommonRequestMethodSchemas.threadRename,
+    [RELAY_REQUEST_METHODS_V11.threadDelete]: relayCommonRequestMethodSchemas.threadDelete,
+    [RELAY_REQUEST_METHODS_V11.threadDetach]: relayCommonRequestMethodSchemas.threadDetach,
+    [RELAY_REQUEST_METHODS_V11.threadCapabilities]: relayCommonRequestMethodSchemas.threadCapabilities,
+    [RELAY_REQUEST_METHODS_V11.turnStart]: relayCommonRequestMethodSchemas.turnStart,
+    [RELAY_REQUEST_METHODS_V11.turnCancel]: relayCommonRequestMethodSchemas.turnCancel,
+    [RELAY_REQUEST_METHODS_V11.operationGet]: relayCommonRequestMethodSchemas.operationGet,
+    [RELAY_REQUEST_METHODS_V11.interactionCandidate]: {
+        params: relayInteractionCandidateParamsSchemaV11,
+        result: relayInteractionCandidateResultSchemaV11,
+    },
+};
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
+export const relayRequestMethodSchemas = relayRequestMethodSchemasV10;
 export function isRelayRequestMethod(value) {
     return Object.hasOwn(relayRequestMethodSchemas, value);
 }
@@ -215,7 +381,7 @@ export const relayRuntimeEventSchema = z
     type: z.literal(RELAY_MESSAGE_TYPES.runtimeEvent),
     workspaceId: workspaceIdSchema,
     relaySequence: z.number().int().nonnegative(),
-    event: runtimeEventEnvelopeSchema,
+    event: runtimeEventEnvelopeV11Schema,
 })
     .strict()
     .readonly();
@@ -255,7 +421,332 @@ export const relayEncryptedMessageSchema = z
 })
     .strict()
     .readonly();
-export const relayMessageSchemas = {
+export const relayDeviceConnectSchemaV10 = relayDeviceConnectSchema;
+export const relayRuntimeRequestSchemaV10 = relayRuntimeRequestSchema;
+export const relayRuntimeResponseSchemaV10 = relayRuntimeResponseSchema;
+export const relayRuntimeEventSchemaV10 = relayRuntimeEventSchema;
+export const relayAckSchemaV10 = relayAckSchema;
+export const relayGapSchemaV10 = relayGapSchema;
+export const relayEncryptedMessageSchemaV10 = relayEncryptedMessageSchema;
+export const relaySafeToolOutcomeSchemaV11 = z
+    .object({ kind: z.enum(TOOL_OUTCOME_KINDS) })
+    .strict()
+    .readonly();
+export const relaySafeApprovalResolutionSchemaV11 = z.discriminatedUnion("status", [
+    z
+        .object({ status: z.literal("resolved"), decision: z.enum(["approve", "reject"]) })
+        .strict()
+        .readonly(),
+    z
+        .object({ status: z.literal("cancelled") })
+        .strict()
+        .readonly(),
+    z
+        .object({ status: z.literal("expired") })
+        .strict()
+        .readonly(),
+]);
+export const relayTimelineEventSchemaV11 = z.discriminatedUnion("type", [
+    z
+        .object({ type: z.literal("turn.started") })
+        .strict()
+        .readonly(),
+    z
+        .object({ type: z.literal("message.started"), streamId: streamIdSchema })
+        .strict()
+        .readonly(),
+    z
+        .object({ type: z.literal("message.delta"), streamId: streamIdSchema, delta: z.string() })
+        .strict()
+        .readonly(),
+    z
+        .object({ type: z.literal("message.completed"), streamId: streamIdSchema, text: z.string() })
+        .strict()
+        .readonly(),
+    z
+        .object({
+        type: z.literal("reasoning.summary.delta"),
+        reasoningId: z.string().min(1),
+        delta: z.string(),
+    })
+        .strict()
+        .readonly(),
+    z
+        .object({
+        type: z.literal("tool.started"),
+        toolCallId: z.string().min(1),
+        agentName: z.string().min(1),
+        toolName: z.string().min(1),
+    })
+        .strict()
+        .readonly(),
+    z
+        .object({
+        type: z.literal("tool.completed"),
+        toolCallId: z.string().min(1),
+        agentName: z.string().min(1),
+        toolName: z.string().min(1),
+        outcome: relaySafeToolOutcomeSchemaV11.optional(),
+    })
+        .strict()
+        .readonly(),
+    z
+        .object({
+        type: z.literal("approval.required"),
+        approval: relayApprovalInteractionProjectionSchemaV11,
+    })
+        .strict()
+        .readonly(),
+    z
+        .object({
+        type: z.literal("approval.resolved"),
+        approvalId: approvalIdSchema,
+        resolution: relaySafeApprovalResolutionSchemaV11,
+    })
+        .strict()
+        .readonly(),
+    z
+        .object({ type: z.literal("turn.completed") })
+        .strict()
+        .readonly(),
+    z
+        .object({ type: z.literal("turn.cancelled") })
+        .strict()
+        .readonly(),
+    z
+        .object({ type: z.literal("turn.failed"), stage: z.enum(["bootstrap", "plan", "execute"]) })
+        .strict()
+        .readonly(),
+    z
+        .object({ type: z.literal("capabilities.changed") })
+        .strict()
+        .readonly(),
+]);
+export const relayRuntimeEventEnvelopeSchemaV11 = z
+    .object({
+    protocolVersion: z.enum(["1.1", "1.0"]),
+    runtimeInstanceId: runtimeInstanceIdSchema,
+    sequence: z.number().int().nonnegative(),
+    timestamp: timestampSchema,
+    threadId: threadIdSchema,
+    turnId: turnIdSchema.optional(),
+    event: relayTimelineEventSchemaV11,
+})
+    .strict()
+    .readonly();
+function projectRelayTimelineEventV11(event) {
+    if (event.type === "tool.output") {
+        return undefined;
+    }
+    if (event.type === "tool.started") {
+        return relayTimelineEventSchemaV11.parse({
+            type: event.type,
+            toolCallId: event.toolCallId,
+            agentName: event.agentName,
+            toolName: event.toolName,
+        });
+    }
+    if (event.type === "tool.completed") {
+        return relayTimelineEventSchemaV11.parse({
+            type: event.type,
+            toolCallId: event.toolCallId,
+            agentName: event.agentName,
+            toolName: event.toolName,
+            ...(event.outcome === undefined ? {} : { outcome: { kind: event.outcome.kind } }),
+        });
+    }
+    if (event.type === "approval.required") {
+        const explanation = getApprovalExplanation(event.approval);
+        return relayTimelineEventSchemaV11.parse({
+            type: event.type,
+            approval: {
+                approvalId: event.approval.id,
+                agentName: event.approval.agentName,
+                toolName: event.approval.toolName,
+                ...(explanation === undefined ? {} : { explanation }),
+            },
+        });
+    }
+    if (event.type === "approval.resolved") {
+        const resolution = event.resolution.status === "resolved"
+            ? { status: event.resolution.status, decision: event.resolution.decision }
+            : { status: event.resolution.status };
+        return relayTimelineEventSchemaV11.parse({
+            type: event.type,
+            approvalId: event.approvalId,
+            resolution,
+        });
+    }
+    if (event.type === "turn.cancelled") {
+        return relayTimelineEventSchemaV11.parse({ type: event.type });
+    }
+    if (event.type === "turn.failed") {
+        return relayTimelineEventSchemaV11.parse({ type: event.type, stage: event.stage });
+    }
+    return relayTimelineEventSchemaV11.parse(event);
+}
+export function projectRuntimeEventEnvelopeForRelayV11(value) {
+    const envelope = runtimeEventEnvelopeSchema.parse(value);
+    const event = projectRelayTimelineEventV11(envelope.event);
+    if (event === undefined) {
+        return undefined;
+    }
+    return relayRuntimeEventEnvelopeSchemaV11.parse({
+        protocolVersion: envelope.protocolVersion === "1.0" ? "1.0" : "1.1",
+        runtimeInstanceId: envelope.runtimeInstanceId,
+        sequence: envelope.sequence,
+        timestamp: envelope.timestamp,
+        threadId: envelope.threadId,
+        ...(envelope.turnId === undefined ? {} : { turnId: envelope.turnId }),
+        event,
+    });
+}
+function redactRelayOperationViewV11(operation) {
+    return operationViewSchema.parse({
+        id: operation.id,
+        sequence: operation.sequence,
+        toolCallId: operation.toolCallId,
+        agentName: operation.agentName,
+        toolName: operation.toolName,
+        createdAt: operation.createdAt,
+        outcome: { kind: operation.outcome.kind },
+        display: null,
+    });
+}
+function redactRelayPendingApprovalV11(approval) {
+    const explanation = getApprovalExplanation(approval);
+    return pendingApprovalSchema.parse({
+        id: approval.id,
+        turnId: approval.turnId,
+        agentName: approval.agentName,
+        toolName: approval.toolName,
+        preview: explanation === undefined ? null : { explanation },
+    });
+}
+/** Projects a Runtime snapshot into the allowlisted Relay Wire 1.1 query shape. */
+export function projectRelayThreadSnapshotV11(value) {
+    const legacySnapshot = threadSnapshotV11Schema.safeParse(value);
+    const snapshot = legacySnapshot.success
+        ? legacySnapshot.data
+        : projectThreadSnapshotForVersion("1.1", value);
+    return threadSnapshotV11Schema.parse({
+        thread: snapshot.thread,
+        messages: snapshot.messages,
+        operations: {
+            items: snapshot.operations.items.map(redactRelayOperationViewV11),
+            nextBeforeSequence: snapshot.operations.nextBeforeSequence,
+        },
+        ...(snapshot.activeTurn === undefined ? {} : { activeTurn: snapshot.activeTurn }),
+        pendingApprovals: snapshot.pendingApprovals.map(redactRelayPendingApprovalV11),
+        transcriptCompleteness: snapshot.transcriptCompleteness,
+    });
+}
+/** Projects an operation query result without local display or outcome details. */
+export function projectRelayOperationGetResultV11(value) {
+    const result = operationGetResultSchema.parse(value);
+    return operationGetResultSchema.parse({
+        operation: result.operation === null ? null : redactRelayOperationViewV11(result.operation),
+    });
+}
+const relayInteractionRequestBaseFieldsV11 = {
+    workspaceId: workspaceIdSchema,
+    relaySequence: z.number().int().nonnegative(),
+    interactionId: interactionIdSchema,
+    threadId: threadIdSchema,
+    turnId: turnIdSchema,
+    expiresAt: timestampSchema,
+    sensitivity: z.literal("normal"),
+};
+export const relayApprovalInteractionRequestSchemaV11 = z
+    .object({
+    type: z.literal(RELAY_MESSAGE_TYPES_V11.interactionRequest),
+    ...relayInteractionRequestBaseFieldsV11,
+    method: z.literal(RELAY_INTERACTION_METHODS_V11.approvalRequest),
+    projection: relayApprovalInteractionProjectionSchemaV11,
+})
+    .strict()
+    .readonly();
+export const relayUserInputInteractionRequestSchemaV11 = z
+    .object({
+    type: z.literal(RELAY_MESSAGE_TYPES_V11.interactionRequest),
+    ...relayInteractionRequestBaseFieldsV11,
+    method: z.literal(RELAY_INTERACTION_METHODS_V11.userInputRequest),
+    projection: relayUserInputInteractionProjectionSchemaV11,
+})
+    .strict()
+    .readonly();
+export const relayInteractionRequestSchemaV11 = z.discriminatedUnion("method", [
+    relayApprovalInteractionRequestSchemaV11,
+    relayUserInputInteractionRequestSchemaV11,
+]);
+const relayInteractionTerminalBaseFieldsV11 = {
+    workspaceId: workspaceIdSchema,
+    relaySequence: z.number().int().nonnegative(),
+    interactionId: interactionIdSchema,
+    threadId: threadIdSchema,
+    turnId: turnIdSchema,
+    method: z.enum(RELAY_INTERACTION_METHOD_VALUES_V11),
+};
+export const relayInteractionResolvedSchemaV11 = z
+    .object({
+    type: z.literal(RELAY_MESSAGE_TYPES_V11.interactionResolved),
+    ...relayInteractionTerminalBaseFieldsV11,
+})
+    .strict()
+    .readonly();
+export const relayInteractionCancelledSchemaV11 = z
+    .object({
+    type: z.literal(RELAY_MESSAGE_TYPES_V11.interactionCancelled),
+    ...relayInteractionTerminalBaseFieldsV11,
+})
+    .strict()
+    .readonly();
+export const relayDeviceConnectSchemaV11 = z
+    .object({
+    type: z.literal(RELAY_MESSAGE_TYPES_V11.deviceConnect),
+    protocolVersion: z.literal("1.1"),
+    deviceId: deviceIdSchema,
+    pairingToken: z.string().min(16),
+})
+    .strict()
+    .readonly();
+export const relayRuntimeRequestSchemaV11 = z
+    .object({
+    type: z.literal(RELAY_MESSAGE_TYPES_V11.runtimeRequest),
+    requestId: relayRequestIdSchema,
+    workspaceId: workspaceIdSchema,
+    method: z.enum(RELAY_REQUEST_METHOD_VALUES_V11),
+    params: jsonValueSchema,
+})
+    .strict()
+    .readonly();
+export const relayRuntimeResponseSchemaV11 = relayRuntimeResponseSchemaV10;
+export const relayRuntimeEventSchemaV11 = z
+    .object({
+    type: z.literal(RELAY_MESSAGE_TYPES_V11.runtimeEvent),
+    workspaceId: workspaceIdSchema,
+    relaySequence: z.number().int().nonnegative(),
+    event: relayRuntimeEventEnvelopeSchemaV11,
+})
+    .strict()
+    .readonly();
+export const relayAckSchemaV11 = relayAckSchemaV10;
+export const relayGapSchemaV11 = relayGapSchemaV10;
+export const relayEncryptedMessageSchemaV11 = z
+    .object({
+    type: z.literal(RELAY_MESSAGE_TYPES_V11.runtimeEncrypted),
+    workspaceId: workspaceIdSchema,
+    envelopeId: relayEnvelopeIdSchema,
+    payloadKind: z.enum(["request", "response", "event", "interaction"]),
+    requestId: relayRequestIdSchema.optional(),
+    relaySequence: z.number().int().nonnegative().optional(),
+    algorithm: z.string().min(1),
+    nonce: z.string().min(1),
+    ciphertext: z.string().min(1),
+})
+    .strict()
+    .readonly();
+export const relayMessageSchemasV10 = {
     [RELAY_MESSAGE_TYPES.deviceConnect]: relayDeviceConnectSchema,
     [RELAY_MESSAGE_TYPES.runtimeRequest]: relayRuntimeRequestSchema,
     [RELAY_MESSAGE_TYPES.runtimeResponse]: relayRuntimeResponseSchema,
@@ -264,7 +755,7 @@ export const relayMessageSchemas = {
     [RELAY_MESSAGE_TYPES.runtimeGap]: relayGapSchema,
     [RELAY_MESSAGE_TYPES.runtimeEncrypted]: relayEncryptedMessageSchema,
 };
-export const relayMessageSchema = z.discriminatedUnion("type", [
+export const relayMessageSchemaV10 = z.discriminatedUnion("type", [
     relayDeviceConnectSchema,
     relayRuntimeRequestSchema,
     relayRuntimeResponseSchema,
@@ -273,17 +764,113 @@ export const relayMessageSchema = z.discriminatedUnion("type", [
     relayGapSchema,
     relayEncryptedMessageSchema,
 ]);
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
+export const relayMessageSchemas = relayMessageSchemasV10;
+/** @deprecated Legacy generic Relay exports remain pinned to Wire 1.0. */
+export const relayMessageSchema = relayMessageSchemaV10;
+export const relayMessageSchemasV11 = {
+    [RELAY_MESSAGE_TYPES_V11.deviceConnect]: relayDeviceConnectSchemaV11,
+    [RELAY_MESSAGE_TYPES_V11.runtimeRequest]: relayRuntimeRequestSchemaV11,
+    [RELAY_MESSAGE_TYPES_V11.runtimeResponse]: relayRuntimeResponseSchemaV11,
+    [RELAY_MESSAGE_TYPES_V11.runtimeEvent]: relayRuntimeEventSchemaV11,
+    [RELAY_MESSAGE_TYPES_V11.runtimeAck]: relayAckSchemaV11,
+    [RELAY_MESSAGE_TYPES_V11.runtimeGap]: relayGapSchemaV11,
+    [RELAY_MESSAGE_TYPES_V11.runtimeEncrypted]: relayEncryptedMessageSchemaV11,
+    [RELAY_MESSAGE_TYPES_V11.interactionRequest]: relayInteractionRequestSchemaV11,
+    [RELAY_MESSAGE_TYPES_V11.interactionResolved]: relayInteractionResolvedSchemaV11,
+    [RELAY_MESSAGE_TYPES_V11.interactionCancelled]: relayInteractionCancelledSchemaV11,
+};
+export const relayMessageSchemaV11 = z.discriminatedUnion("type", [
+    relayDeviceConnectSchemaV11,
+    relayRuntimeRequestSchemaV11,
+    relayRuntimeResponseSchemaV11,
+    relayRuntimeEventSchemaV11,
+    relayAckSchemaV11,
+    relayGapSchemaV11,
+    relayEncryptedMessageSchemaV11,
+    relayInteractionRequestSchemaV11,
+    relayInteractionResolvedSchemaV11,
+    relayInteractionCancelledSchemaV11,
+]);
 export const RELAY_PROTOCOL_REGISTRY = {
+    "1.1": {
+        messageTypes: RELAY_MESSAGE_TYPE_VALUES_V11,
+        messageSchema: relayMessageSchemaV11,
+        requestMethods: RELAY_REQUEST_METHOD_VALUES_V11,
+        requestMethodSchemas: relayRequestMethodSchemasV11,
+        requestMethodDispositions: RELAY_REQUEST_METHOD_DISPOSITIONS_V11,
+        mutationMethods: RELAY_MUTATION_REQUEST_METHODS_V11,
+        localOnlyMethods: RELAY_LOCAL_ONLY_REQUEST_METHODS_V11,
+    },
     "1.0": {
-        messageTypes: RELAY_MESSAGE_TYPE_VALUES,
-        requestMethods: RELAY_REQUEST_METHOD_VALUES,
-        mutationMethods: RELAY_MUTATION_REQUEST_METHODS,
-        localOnlyMethods: RELAY_LOCAL_ONLY_REQUEST_METHODS,
+        messageTypes: RELAY_MESSAGE_TYPE_VALUES_V10,
+        messageSchema: relayMessageSchemaV10,
+        requestMethods: RELAY_REQUEST_METHOD_VALUES_V10,
+        requestMethodSchemas: relayRequestMethodSchemasV10,
+        requestMethodDispositions: RELAY_REQUEST_METHOD_DISPOSITIONS_V10,
+        mutationMethods: RELAY_MUTATION_REQUEST_METHODS_V10,
+        localOnlyMethods: RELAY_LOCAL_ONLY_REQUEST_METHODS_V10,
     },
 };
 export function getRelayProtocolRegistry(version) {
     return RELAY_PROTOCOL_REGISTRY[version];
 }
+export function parseRelayMessageForVersion(version, value) {
+    return getRelayProtocolRegistry(version).messageSchema.parse(value);
+}
+export function isRelayRequestMethodForVersion(version, value) {
+    return Object.hasOwn(getRelayProtocolRegistry(version).requestMethodSchemas, value);
+}
+export function getRelayRequestMethodDispositionForVersion(version, value) {
+    if (!isRelayRequestMethodForVersion(version, value)) {
+        return undefined;
+    }
+    const dispositions = getRelayProtocolRegistry(version).requestMethodDispositions;
+    return dispositions[value];
+}
+export function parseRelayRequestParamsForVersion(version, method, value) {
+    const definitions = getRelayProtocolRegistry(version).requestMethodSchemas;
+    const definition = definitions[method];
+    if (definition === undefined) {
+        throw new Error(`Relay request method ${method} is unavailable in Wire ${version}`);
+    }
+    return definition.params.parse(value);
+}
+export function parseRelayRequestResultForVersion(version, method, value) {
+    const definitions = getRelayProtocolRegistry(version).requestMethodSchemas;
+    const definition = definitions[method];
+    if (definition === undefined) {
+        throw new Error(`Relay request method ${method} is unavailable in Wire ${version}`);
+    }
+    return definition.result.parse(value);
+}
+export function parseRelayInteractionCandidateForRequestV11(request, candidate) {
+    const base = {
+        interactionId: request.interactionId,
+        threadId: request.threadId,
+        turnId: request.turnId,
+    };
+    if (request.method === RELAY_INTERACTION_METHODS_V11.approvalRequest) {
+        return relayInteractionCandidateParamsSchemaV11.parse({
+            ...base,
+            method: request.method,
+            candidate: approvalRequestResultSchema.parse(candidate),
+        });
+    }
+    const normalized = normalizeUserInputResult({
+        interactionId: request.interactionId,
+        threadId: request.threadId,
+        turnId: request.turnId,
+        expiresAt: request.expiresAt,
+        sensitivity: request.sensitivity,
+        ...request.projection,
+    }, candidate);
+    return relayInteractionCandidateParamsSchemaV11.parse({
+        ...base,
+        method: request.method,
+        candidate: normalized,
+    });
+}
 export function negotiateRelayProtocolVersion(peerVersions) {
     return SUPPORTED_RELAY_PROTOCOL_VERSIONS.find((version) => peerVersions.includes(version));
 }