@roll-agent/protocol 0.3.0 → 0.4.1

package/dist/index.js

@@ -1,28 +1,93 @@
 import { z } from "zod/v4";
-export const SUPPORTED_RUNTIME_PROTOCOL_VERSIONS = ["1.1", "1.0"];
+export const SUPPORTED_RUNTIME_PROTOCOL_VERSIONS_V11 = ["1.1", "1.0"];
+export const SUPPORTED_RUNTIME_PROTOCOL_VERSIONS_V12 = [
+    "1.2",
+    ...SUPPORTED_RUNTIME_PROTOCOL_VERSIONS_V11,
+];
+export const SUPPORTED_RUNTIME_PROTOCOL_VERSIONS = [
+    "1.3",
+    ...SUPPORTED_RUNTIME_PROTOCOL_VERSIONS_V12,
+];
 export const RUNTIME_PROTOCOL_VERSION = SUPPORTED_RUNTIME_PROTOCOL_VERSIONS[0];
 export const RUNTIME_EVENT_NOTIFICATION = "runtime.event";
 export const RUNTIME_SERVER_REQUEST_CANCEL_NOTIFICATION = "runtime.serverRequest.cancel";
+export const RUNTIME_V13_MAX_DURABLE_EVENT_RECORD_BYTES = 16 * 1_024 * 1_024;
+export const RUNTIME_V13_MAX_DURABLE_EVENT_RECORDS = 10_000;
+/**
+ * Advertising Protocol 1.3 is a declaration that the Client accepts at least this many bytes in
+ * one Runtime-to-Client NDJSON frame. The margin above the durable record limit covers the bounded
+ * Runtime envelope and JSON-RPC notification metadata.
+ */
+export const RUNTIME_V13_MIN_CLIENT_FRAME_BYTES = RUNTIME_V13_MAX_DURABLE_EVENT_RECORD_BYTES + 1 * 1_024 * 1_024;
+/** Default bounded window for a complete retained replay batch plus per-envelope metadata. */
+export const RUNTIME_V13_DEFAULT_REPLAY_BUFFER_BYTES = 32 * 1_024 * 1_024;
+/** Recovery Snapshot metadata is clipped because the projection must always fit one Client frame. */
+export const RUNTIME_V13_RECOVERY_SNAPSHOT_METADATA_MAX_CHARS = 1_024;
+export const RUNTIME_V13_RECOVERY_SNAPSHOT_TIMESTAMP_MAX_CHARS = 64;
 export const APPROVAL_EXPLANATION_PREVIEW_KEY = "explanation";
 export const APPROVAL_EXPLANATION_MAX_CHARS = 100;
+export const CLIENT_CAPABILITY_METHOD_MAX_COUNT = 64;
+export const CLIENT_CAPABILITY_METHOD_MAX_CHARS = 100;
+export const USER_INPUT_CONTROL_MAX_COUNT = 16;
+export const USER_INPUT_CONTROL_ID_MAX_CHARS = 64;
+export const USER_INPUT_LABEL_MAX_CHARS = 200;
+export const USER_INPUT_DESCRIPTION_MAX_CHARS = 500;
+export const USER_INPUT_CHOICE_OPTION_MAX_COUNT = 50;
+export const USER_INPUT_TEXT_MAX_CHARS = 10_000;
+export const USER_INPUT_CANCEL_REASON_MAX_CHARS = 500;
+export const INTERACTION_SENSITIVITIES = ["normal"];
 export const RUNTIME_SERVER_REQUEST_METHODS = {
     approvalRequest: "approval.request",
+    userInputRequest: "userInput.request",
+};
+/** Protocol 1.1 Server Request registry. Keep this list frozen. */
+export const RUNTIME_SERVER_REQUEST_METHOD_VALUES_V11 = [
+    RUNTIME_SERVER_REQUEST_METHODS.approvalRequest,
+];
+export const RUNTIME_SERVER_REQUEST_METHOD_VALUES = [
+    ...RUNTIME_SERVER_REQUEST_METHOD_VALUES_V11,
+    RUNTIME_SERVER_REQUEST_METHODS.userInputRequest,
+];
+export const USER_INPUT_CONTROL_TYPES = {
+    text: "text",
+    multiline: "multiline",
+    number: "number",
+    boolean: "boolean",
+    choice: "choice",
 };
 export const RUNTIME_PROTOCOL_CAPABILITIES = {
+    "1.2": {
+        serverRequests: true,
+        serverRequestCapabilityNegotiation: true,
+        approvalResolvedEvents: true,
+        clientApprovalResponses: false,
+        requiredServerRequestMethods: [],
+    },
+    "1.3": {
+        serverRequests: true,
+        serverRequestCapabilityNegotiation: true,
+        approvalResolvedEvents: true,
+        clientApprovalResponses: false,
+        requiredServerRequestMethods: [],
+    },
     "1.1": {
         serverRequests: true,
+        serverRequestCapabilityNegotiation: false,
         approvalResolvedEvents: true,
         clientApprovalResponses: false,
         requiredServerRequestMethods: [RUNTIME_SERVER_REQUEST_METHODS.approvalRequest],
     },
     "1.0": {
         serverRequests: false,
+        serverRequestCapabilityNegotiation: false,
         approvalResolvedEvents: false,
         clientApprovalResponses: true,
         requiredServerRequestMethods: [],
     },
 };
 export const REQUIRED_RUNTIME_SERVER_REQUEST_METHODS_BY_VERSION = {
+    "1.3": RUNTIME_PROTOCOL_CAPABILITIES["1.3"].requiredServerRequestMethods,
+    "1.2": RUNTIME_PROTOCOL_CAPABILITIES["1.2"].requiredServerRequestMethods,
     "1.1": RUNTIME_PROTOCOL_CAPABILITIES["1.1"].requiredServerRequestMethods,
     "1.0": RUNTIME_PROTOCOL_CAPABILITIES["1.0"].requiredServerRequestMethods,
 };
@@ -34,10 +99,12 @@ export function isRuntimeServerRequestMethodRequired(version, method) {
 }
 export const RUNTIME_METHODS = {
     initialize: "initialize",
+    clientCapabilitiesSet: "client.capabilities.set",
     threadList: "thread.list",
     threadCreate: "thread.create",
     threadOpen: "thread.open",
     threadSnapshot: "thread.snapshot",
+    runtimeEventsResume: "runtime.events.resume",
     threadRename: "thread.rename",
     threadDelete: "thread.delete",
     threadDetach: "thread.detach",
@@ -57,7 +124,7 @@ export const RUNTIME_FEATURES = [
     "operation-projection",
     "process-local-sequence",
 ];
-export const RUNTIME_ERROR_CODES = {
+export const RUNTIME_ERROR_CODES_V11 = {
     protocolVersionUnsupported: "PROTOCOL_VERSION_UNSUPPORTED",
     initializeRequired: "INITIALIZE_REQUIRED",
     invalidParams: "INVALID_PARAMS",
@@ -71,6 +138,17 @@ export const RUNTIME_ERROR_CODES = {
     outcomeUnknown: "OUTCOME_UNKNOWN",
     internalError: "INTERNAL_ERROR",
 };
+/** Runtime Protocol 1.2 error registry. Keep this object frozen. */
+export const RUNTIME_ERROR_CODES_V12 = {
+    ...RUNTIME_ERROR_CODES_V11,
+    capabilityRevisionConflict: "CAPABILITY_REVISION_CONFLICT",
+};
+export const RUNTIME_ERROR_CODES = {
+    ...RUNTIME_ERROR_CODES_V12,
+    eventCursorExpired: "EVENT_CURSOR_EXPIRED",
+    eventCursorGap: "EVENT_CURSOR_GAP",
+};
+export const RUNTIME_ERROR_CODES_V13 = RUNTIME_ERROR_CODES;
 export const TOOL_OUTCOME_KINDS = [
     "success",
     "user_rejected",
@@ -82,19 +160,94 @@ export const TOOL_OUTCOME_KINDS = [
 export const threadIdSchema = z.string().uuid().brand();
 export const turnIdSchema = z.string().uuid().brand();
 export const approvalIdSchema = z.string().uuid().brand();
+export const interactionIdSchema = z.string().uuid().brand();
 export const runtimeInstanceIdSchema = z.string().uuid().brand();
 export const requestIdSchema = z.string().uuid().brand();
 export const streamIdSchema = z.string().uuid().brand();
 export const operationIdSchema = z.string().uuid().brand();
+export const runtimeEventIdSchema = z.string().uuid().brand();
+export const runtimeEventCursorSchema = z
+    .string()
+    .max(128)
+    .regex(/^rte1:[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}:(?:0|[1-9]\d*):[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/u)
+    .brand();
 export const timestampSchema = z.string().datetime({ offset: true });
 export const jsonValueSchema = z.json();
 export const jsonRpcIdSchema = z.union([z.string(), z.number()]);
 export const runtimeProtocolVersionSchema = z.enum(SUPPORTED_RUNTIME_PROTOCOL_VERSIONS);
+export const runtimeProtocolVersionV12Schema = z.enum(SUPPORTED_RUNTIME_PROTOCOL_VERSIONS_V12);
+export const runtimeProtocolVersionV11Schema = z.enum(SUPPORTED_RUNTIME_PROTOCOL_VERSIONS_V11);
+export const interactionSensitivitySchema = z.enum(INTERACTION_SENSITIVITIES);
+const runtimeInteractionMetadataObjectSchema = z
+    .object({
+    interactionId: interactionIdSchema,
+    threadId: threadIdSchema,
+    turnId: turnIdSchema,
+    expiresAt: timestampSchema,
+    sensitivity: interactionSensitivitySchema,
+})
+    .strict();
+export const runtimeInteractionMetadataSchema = runtimeInteractionMetadataObjectSchema.readonly();
 export const approvalExplanationSchema = z
     .string()
     .trim()
     .min(1)
     .max(APPROVAL_EXPLANATION_MAX_CHARS);
+function runtimeEventCursorParts(cursor) {
+    const parsed = runtimeEventCursorSchema.parse(cursor);
+    const [, eventLogId, threadSequence, eventId] = parsed.split(":");
+    if (eventLogId === undefined || threadSequence === undefined || eventId === undefined) {
+        throw new Error("Runtime Event cursor has an invalid shape");
+    }
+    return {
+        eventLogId,
+        threadSequence: BigInt(threadSequence),
+        eventId: runtimeEventIdSchema.parse(eventId),
+    };
+}
+function assertComparableRuntimeEventCursors(left, right) {
+    if (left.eventLogId !== right.eventLogId) {
+        throw new Error("Runtime Event cursors belong to different event logs");
+    }
+    if (left.threadSequence === right.threadSequence && left.eventId !== right.eventId) {
+        throw new Error("Runtime Event cursors conflict at the same Thread sequence");
+    }
+}
+/** Compares opaque cursors from one Thread event log without exposing their encoded fields. */
+export function compareRuntimeEventCursors(left, right) {
+    if (left === null) {
+        return right === null ? 0 : -1;
+    }
+    if (right === null) {
+        return 1;
+    }
+    const leftParts = runtimeEventCursorParts(left);
+    const rightParts = runtimeEventCursorParts(right);
+    assertComparableRuntimeEventCursors(leftParts, rightParts);
+    if (leftParts.threadSequence < rightParts.threadSequence) {
+        return -1;
+    }
+    if (leftParts.threadSequence > rightParts.threadSequence) {
+        return 1;
+    }
+    return 0;
+}
+/** Returns the signed step distance, treating `null` as the checkpoint before sequence zero. */
+export function runtimeEventCursorDistance(from, to) {
+    if (from === null) {
+        if (to === null) {
+            return 0n;
+        }
+        return runtimeEventCursorParts(to).threadSequence + 1n;
+    }
+    if (to === null) {
+        return -(runtimeEventCursorParts(from).threadSequence + 1n);
+    }
+    const fromParts = runtimeEventCursorParts(from);
+    const toParts = runtimeEventCursorParts(to);
+    assertComparableRuntimeEventCursors(fromParts, toParts);
+    return toParts.threadSequence - fromParts.threadSequence;
+}
 const runtimeClientInfoFields = {
     name: z.string().trim().min(1).max(100),
     version: z.string().trim().min(1).max(100),
@@ -107,7 +260,8 @@ export const runtimeServerInfoSchema = z
 })
     .strict()
     .readonly();
-export const runtimeLimitsSchema = z
+/** Runtime Protocol 1.2/1.1/1.0 limits. Keep this schema frozen. */
+export const runtimeLimitsV12Schema = z
     .object({
     maxFrameBytes: z.number().int().positive(),
     maxPageSize: z.number().int().positive(),
@@ -116,6 +270,16 @@ export const runtimeLimitsSchema = z
 })
     .strict()
     .readonly();
+export const runtimeLimitsV13Schema = z
+    .object({
+    maxFrameBytes: z.number().int().positive(),
+    maxPageSize: z.number().int().positive(),
+    eventReplay: z.literal(true),
+    idempotencyCacheEntries: z.number().int().positive(),
+})
+    .strict()
+    .readonly();
+export const runtimeLimitsSchema = z.union([runtimeLimitsV13Schema, runtimeLimitsV12Schema]);
 export const initializeParamsSchema = z
     .object({
     protocolVersions: z.array(z.string().min(1)).min(1),
@@ -123,13 +287,87 @@ export const initializeParamsSchema = z
 })
     .strict()
     .readonly();
-export const initializeResultSchema = z
-    .object({
-    protocolVersion: runtimeProtocolVersionSchema,
+const initializeResultCommonFields = {
     runtimeInstanceId: runtimeInstanceIdSchema,
     server: runtimeServerInfoSchema,
     features: z.array(z.enum(RUNTIME_FEATURES)),
-    limits: runtimeLimitsSchema,
+};
+/** Runtime Protocol 1.1/1.0 initialize result. Keep this schema frozen. */
+export const initializeResultV11Schema = z
+    .object({
+    protocolVersion: runtimeProtocolVersionV11Schema,
+    ...initializeResultCommonFields,
+    limits: runtimeLimitsV12Schema,
+})
+    .strict()
+    .readonly();
+/** Runtime Protocol 1.2 initialize result. */
+export const initializeResultV12Schema = z
+    .object({
+    protocolVersion: z.literal("1.2"),
+    ...initializeResultCommonFields,
+    limits: runtimeLimitsV12Schema,
+})
+    .strict()
+    .readonly();
+export const initializeResultV13Schema = z
+    .object({
+    protocolVersion: z.literal("1.3"),
+    ...initializeResultCommonFields,
+    limits: runtimeLimitsV13Schema,
+})
+    .strict()
+    .readonly();
+/** Any currently supported Runtime Protocol initialize result. */
+export const initializeResultSchema = z.union([
+    initializeResultV13Schema,
+    initializeResultV12Schema,
+    initializeResultV11Schema,
+]);
+const clientCapabilityMethodNameSchema = z.string().min(1).max(CLIENT_CAPABILITY_METHOD_MAX_CHARS);
+const clientCapabilityMethodNamesSchema = z
+    .array(clientCapabilityMethodNameSchema)
+    .max(CLIENT_CAPABILITY_METHOD_MAX_COUNT)
+    .superRefine((methods, context) => {
+    const seen = new Set();
+    for (const [index, method] of methods.entries()) {
+        if (seen.has(method)) {
+            context.addIssue({
+                code: "custom",
+                message: "serverRequestMethods must not contain duplicates",
+                path: [index],
+            });
+        }
+        seen.add(method);
+    }
+});
+const acceptedServerRequestMethodsSchema = z
+    .array(z.enum(RUNTIME_SERVER_REQUEST_METHODS))
+    .max(CLIENT_CAPABILITY_METHOD_MAX_COUNT)
+    .superRefine((methods, context) => {
+    const seen = new Set();
+    for (const [index, method] of methods.entries()) {
+        if (seen.has(method)) {
+            context.addIssue({
+                code: "custom",
+                message: "acceptedServerRequestMethods must not contain duplicates",
+                path: [index],
+            });
+        }
+        seen.add(method);
+    }
+});
+export const clientCapabilitiesSetParamsSchema = z
+    .object({
+    revision: z.number().int().min(1),
+    serverRequestMethods: clientCapabilityMethodNamesSchema,
+})
+    .strict()
+    .readonly();
+export const clientCapabilitiesSetResultSchema = z
+    .object({
+    revision: z.number().int().min(1),
+    acceptedServerRequestMethods: acceptedServerRequestMethodsSchema,
 })
     .strict()
     .readonly();
@@ -180,7 +418,7 @@ export const operationViewSchema = z
 })
     .strict()
     .readonly();
-export const activeTurnSchema = z
+export const activeTurnV11Schema = z
     .object({
     id: turnIdSchema,
     status: z.enum(["running", "cancelling"]),
@@ -188,6 +426,16 @@ export const activeTurnSchema = z
 })
     .strict()
     .readonly();
+export const activeTurnV12Schema = z
+    .object({
+    id: turnIdSchema,
+    status: z.enum(["running", "cancelling", "waiting-for-user"]),
+    startedAt: timestampSchema,
+})
+    .strict()
+    .readonly();
+/** Latest Runtime Protocol active Turn shape. */
+export const activeTurnSchema = activeTurnV12Schema;
 export const pendingApprovalSchema = z
     .object({
     id: approvalIdSchema,
@@ -213,17 +461,337 @@ export const operationPageSchema = z
 })
     .strict()
     .readonly();
-export const threadSnapshotSchema = z
-    .object({
+const threadSnapshotV11Fields = {
     thread: threadSummarySchema,
     messages: messagePageSchema,
     operations: operationPageSchema,
-    activeTurn: activeTurnSchema.optional(),
+    activeTurn: activeTurnV11Schema.optional(),
     pendingApprovals: z.array(pendingApprovalSchema),
     transcriptCompleteness: z.enum(["complete", "legacy_snapshot"]),
+};
+/** Protocol 1.1/1.0 wire shape. Keep this schema frozen. */
+export const threadSnapshotV11Schema = z.object(threadSnapshotV11Fields).strict().readonly();
+const userInputIdentifierSchema = z
+    .string()
+    .min(1)
+    .max(USER_INPUT_CONTROL_ID_MAX_CHARS)
+    .refine((value) => value.trim().length > 0, { message: "identifier must not be blank" });
+const userInputLabelSchema = z
+    .string()
+    .min(1)
+    .max(USER_INPUT_LABEL_MAX_CHARS)
+    .refine((value) => value.trim().length > 0, { message: "label must not be blank" });
+const userInputDescriptionSchema = z.string().min(1).max(USER_INPUT_DESCRIPTION_MAX_CHARS);
+const userInputLengthSchema = z.number().int().min(0).max(USER_INPUT_TEXT_MAX_CHARS);
+const userInputSelectionCountSchema = z
+    .number()
+    .int()
+    .min(0)
+    .max(USER_INPUT_CHOICE_OPTION_MAX_COUNT);
+const userInputControlBaseFields = {
+    id: userInputIdentifierSchema,
+    label: userInputLabelSchema,
+    description: userInputDescriptionSchema.optional(),
+    required: z.boolean(),
+};
+const userInputTextControlFields = {
+    ...userInputControlBaseFields,
+    minLength: userInputLengthSchema.optional(),
+    maxLength: userInputLengthSchema.optional(),
+};
+export const userInputTextControlSchema = z
+    .object({
+    type: z.literal(USER_INPUT_CONTROL_TYPES.text),
+    ...userInputTextControlFields,
+})
+    .strict()
+    .superRefine((control, context) => {
+    const minimum = Math.max(control.minLength ?? 0, control.required ? 1 : 0);
+    const maximum = control.maxLength ?? USER_INPUT_TEXT_MAX_CHARS;
+    if (minimum > maximum) {
+        context.addIssue({
+            code: "custom",
+            message: "effective minLength must not exceed maxLength",
+            path: ["maxLength"],
+        });
+    }
+})
+    .readonly();
+export const userInputMultilineControlSchema = z
+    .object({
+    type: z.literal(USER_INPUT_CONTROL_TYPES.multiline),
+    ...userInputTextControlFields,
+})
+    .strict()
+    .superRefine((control, context) => {
+    const minimum = Math.max(control.minLength ?? 0, control.required ? 1 : 0);
+    const maximum = control.maxLength ?? USER_INPUT_TEXT_MAX_CHARS;
+    if (minimum > maximum) {
+        context.addIssue({
+            code: "custom",
+            message: "effective minLength must not exceed maxLength",
+            path: ["maxLength"],
+        });
+    }
+})
+    .readonly();
+export const userInputNumberControlSchema = z
+    .object({
+    type: z.literal(USER_INPUT_CONTROL_TYPES.number),
+    ...userInputControlBaseFields,
+    min: z.number().finite().optional(),
+    max: z.number().finite().optional(),
+    integer: z.boolean().optional(),
+})
+    .strict()
+    .superRefine((control, context) => {
+    if (control.min !== undefined && control.max !== undefined && control.min > control.max) {
+        context.addIssue({
+            code: "custom",
+            message: "min must not exceed max",
+            path: ["min"],
+        });
+    }
+    if (control.integer === true &&
+        Math.ceil(control.min ?? Number.NEGATIVE_INFINITY) >
+            Math.floor(control.max ?? Number.POSITIVE_INFINITY)) {
+        context.addIssue({
+            code: "custom",
+            message: "integer bounds must include at least one integer",
+            path: ["integer"],
+        });
+    }
+})
+    .readonly();
+export const userInputBooleanControlSchema = z
+    .object({
+    type: z.literal(USER_INPUT_CONTROL_TYPES.boolean),
+    ...userInputControlBaseFields,
+})
+    .strict()
+    .readonly();
+export const userInputChoiceOptionSchema = z
+    .object({
+    id: userInputIdentifierSchema,
+    label: userInputLabelSchema,
+    description: userInputDescriptionSchema.optional(),
 })
     .strict()
     .readonly();
+export const userInputChoiceControlSchema = z
+    .object({
+    type: z.literal(USER_INPUT_CONTROL_TYPES.choice),
+    ...userInputControlBaseFields,
+    multiple: z.boolean(),
+    options: z.array(userInputChoiceOptionSchema).min(1).max(USER_INPUT_CHOICE_OPTION_MAX_COUNT),
+    minSelections: userInputSelectionCountSchema.optional(),
+    maxSelections: userInputSelectionCountSchema.min(1).optional(),
+})
+    .strict()
+    .superRefine((control, context) => {
+    const optionIds = new Set();
+    for (const [index, option] of control.options.entries()) {
+        if (optionIds.has(option.id)) {
+            context.addIssue({
+                code: "custom",
+                message: "choice option ids must be unique",
+                path: ["options", index, "id"],
+            });
+        }
+        optionIds.add(option.id);
+    }
+    const maximum = control.maxSelections ?? (control.multiple ? control.options.length : 1);
+    if (control.minSelections !== undefined && control.minSelections > maximum) {
+        context.addIssue({
+            code: "custom",
+            message: "minSelections must not exceed maxSelections",
+            path: ["minSelections"],
+        });
+    }
+    if (maximum > control.options.length) {
+        context.addIssue({
+            code: "custom",
+            message: "maxSelections must not exceed the option count",
+            path: ["maxSelections"],
+        });
+    }
+    if (!control.multiple &&
+        ((control.minSelections !== undefined && control.minSelections > 1) || maximum > 1)) {
+        context.addIssue({
+            code: "custom",
+            message: "single-choice controls allow at most one selection",
+            path: [
+                control.minSelections !== undefined && control.minSelections > 1
+                    ? "minSelections"
+                    : "maxSelections",
+            ],
+        });
+    }
+})
+    .readonly();
+export const userInputControlSchema = z.discriminatedUnion("type", [
+    userInputTextControlSchema,
+    userInputMultilineControlSchema,
+    userInputNumberControlSchema,
+    userInputBooleanControlSchema,
+    userInputChoiceControlSchema,
+]);
+const userInputControlsSchema = z
+    .array(userInputControlSchema)
+    .min(1)
+    .max(USER_INPUT_CONTROL_MAX_COUNT)
+    .superRefine((controls, context) => {
+    const controlIds = new Set();
+    for (const [index, control] of controls.entries()) {
+        if (controlIds.has(control.id)) {
+            context.addIssue({
+                code: "custom",
+                message: "control ids must be unique",
+                path: [index, "id"],
+            });
+        }
+        controlIds.add(control.id);
+    }
+});
+const userInputFormObjectSchema = z
+    .object({
+    title: userInputLabelSchema.optional(),
+    description: userInputDescriptionSchema.optional(),
+    controls: userInputControlsSchema,
+})
+    .strict();
+/** Safe model-authored form definition shared by Runtime, clients and first-party UI. */
+export const userInputFormSchema = userInputFormObjectSchema.readonly();
+const userInputRequestParamsV12ObjectSchema = runtimeInteractionMetadataObjectSchema.extend(userInputFormObjectSchema.shape);
+export const userInputRequestParamsV12Schema = userInputRequestParamsV12ObjectSchema.readonly();
+export const userInputValueSchema = z.union([
+    z.string().max(USER_INPUT_TEXT_MAX_CHARS),
+    z.number().finite(),
+    z.boolean(),
+    z.array(z.string().max(USER_INPUT_CONTROL_ID_MAX_CHARS)).max(USER_INPUT_CHOICE_OPTION_MAX_COUNT),
+]);
+export const userInputSubmittedValueSchema = z
+    .object({
+    id: userInputIdentifierSchema,
+    value: userInputValueSchema,
+})
+    .strict()
+    .readonly();
+export const userInputSubmittedResultSchema = z
+    .object({
+    status: z.literal("submitted"),
+    values: z.array(userInputSubmittedValueSchema).max(USER_INPUT_CONTROL_MAX_COUNT),
+})
+    .strict()
+    .readonly();
+export const userInputCancelledResultSchema = z
+    .object({
+    status: z.literal("cancelled"),
+    reason: z.string().min(1).max(USER_INPUT_CANCEL_REASON_MAX_CHARS).optional(),
+})
+    .strict()
+    .readonly();
+export const userInputResultSchema = z.discriminatedUnion("status", [
+    userInputSubmittedResultSchema,
+    userInputCancelledResultSchema,
+]);
+export const pendingApprovalInteractionProjectionSchema = z
+    .object({
+    method: z.literal(RUNTIME_SERVER_REQUEST_METHODS.approvalRequest),
+    interactionId: interactionIdSchema,
+    threadId: threadIdSchema,
+    turnId: turnIdSchema,
+    expiresAt: timestampSchema,
+    sensitivity: z.literal("normal"),
+    approvalId: approvalIdSchema,
+})
+    .strict()
+    .readonly();
+export const pendingUserInputInteractionProjectionSchema = userInputRequestParamsV12ObjectSchema
+    .extend({
+    method: z.literal(RUNTIME_SERVER_REQUEST_METHODS.userInputRequest),
+})
+    .readonly();
+export const pendingInteractionProjectionSchema = z.discriminatedUnion("method", [
+    pendingApprovalInteractionProjectionSchema,
+    pendingUserInputInteractionProjectionSchema,
+]);
+const threadSnapshotV12Fields = {
+    ...threadSnapshotV11Fields,
+    activeTurn: activeTurnV12Schema.optional(),
+    pendingInteractions: z.array(pendingInteractionProjectionSchema),
+};
+/** Runtime Protocol 1.2 snapshot. Keep this schema frozen. */
+export const threadSnapshotV12Schema = z.object(threadSnapshotV12Fields).strict().readonly();
+export const threadSnapshotV13FullSchema = z
+    .object({
+    ...threadSnapshotV12Fields,
+    eventCursor: runtimeEventCursorSchema.nullable(),
+})
+    .strict()
+    .readonly();
+const recoveryThreadSummarySchema = z
+    .object({
+    id: threadIdSchema,
+    title: z.string().max(RUNTIME_V13_RECOVERY_SNAPSHOT_METADATA_MAX_CHARS).optional(),
+    model: z.string().max(RUNTIME_V13_RECOVERY_SNAPSHOT_METADATA_MAX_CHARS).optional(),
+    createdAt: z
+        .string()
+        .max(RUNTIME_V13_RECOVERY_SNAPSHOT_TIMESTAMP_MAX_CHARS)
+        .datetime({ offset: true }),
+    updatedAt: z
+        .string()
+        .max(RUNTIME_V13_RECOVERY_SNAPSHOT_TIMESTAMP_MAX_CHARS)
+        .datetime({ offset: true }),
+    messageCount: z.number().int().nonnegative(),
+})
+    .strict()
+    .readonly();
+const recoveryMessagePageSchema = z
+    .object({
+    items: z.array(uiMessageSchema).max(0),
+    nextBeforeSequence: z.null(),
+})
+    .strict()
+    .readonly();
+const recoveryOperationPageSchema = z
+    .object({
+    items: z.array(operationViewSchema).max(0),
+    nextBeforeSequence: z.null(),
+})
+    .strict()
+    .readonly();
+const recoveryActiveTurnSchema = z
+    .object({
+    id: turnIdSchema,
+    status: z.enum(["running", "cancelling", "waiting-for-user"]),
+    startedAt: z
+        .string()
+        .max(RUNTIME_V13_RECOVERY_SNAPSHOT_TIMESTAMP_MAX_CHARS)
+        .datetime({ offset: true }),
+})
+    .strict()
+    .readonly();
+export const threadRecoverySnapshotV13Schema = z
+    .object({
+    ...threadSnapshotV12Fields,
+    thread: recoveryThreadSummarySchema,
+    messages: recoveryMessagePageSchema,
+    operations: recoveryOperationPageSchema,
+    pendingApprovals: z.array(pendingApprovalSchema).max(0),
+    pendingInteractions: z.array(pendingInteractionProjectionSchema).max(0),
+    activeTurn: recoveryActiveTurnSchema.optional(),
+    eventCursor: runtimeEventCursorSchema.nullable(),
+    recoveryProjection: z.literal(true),
+})
+    .strict()
+    .readonly();
+export const threadSnapshotV13Schema = z.union([
+    threadSnapshotV13FullSchema,
+    threadRecoverySnapshotV13Schema,
+]);
+/** Latest Runtime Protocol snapshot. Use versioned schemas for compatibility. */
+export const threadSnapshotSchema = threadSnapshotV13Schema;
 const pageSizeSchema = z.number().int().min(1).max(500).default(100);
 const requestFields = { requestId: requestIdSchema };
 const threadRequestFields = { threadId: threadIdSchema };
@@ -255,17 +823,47 @@ export const threadCreateResultSchema = z
     .strict()
     .readonly();
 export const threadOpenParamsSchema = z.object(threadRequestFields).strict().readonly();
+export const threadOpenResultV11Schema = threadSnapshotV11Schema;
 export const threadOpenResultSchema = threadSnapshotSchema;
-export const threadSnapshotParamsSchema = z
-    .object({
+const threadSnapshotParamFields = {
     ...threadRequestFields,
     messageBeforeSequence: z.number().int().nonnegative().optional(),
     operationBeforeSequence: z.number().int().nonnegative().optional(),
     limit: pageSizeSchema,
+};
+/** Runtime Protocol 1.2/1.1/1.0 request shape. Keep this schema frozen. */
+export const threadSnapshotParamsV12Schema = z
+    .object({
+    ...threadSnapshotParamFields,
+})
+    .strict()
+    .readonly();
+export const threadSnapshotParamsV13Schema = z
+    .object({
+    ...threadSnapshotParamFields,
+    recovery: z.literal(true).optional(),
 })
     .strict()
     .readonly();
+/** Latest Runtime Protocol request shape. Use the versioned schemas for compatibility. */
+export const threadSnapshotParamsSchema = threadSnapshotParamsV13Schema;
+export const threadSnapshotResultV11Schema = threadSnapshotV11Schema;
+export const threadSnapshotResultV12Schema = threadSnapshotV12Schema;
 export const threadSnapshotResultSchema = threadSnapshotSchema;
+export const runtimeEventsResumeParamsSchema = z
+    .object({
+    ...threadRequestFields,
+    afterCursor: runtimeEventCursorSchema.nullable(),
+})
+    .strict()
+    .readonly();
+export const runtimeEventsResumeResultSchema = z
+    .object({
+    throughCursor: runtimeEventCursorSchema.nullable(),
+    replayedCount: z.number().int().nonnegative(),
+})
+    .strict()
+    .readonly();
 export const threadRenameParamsSchema = z
     .object({
     ...requestFields,
@@ -354,6 +952,28 @@ export const approvalRequestParamsSchema = z
 })
     .strict()
     .readonly();
+/** Protocol 1.1 wire shape. Keep this alias frozen with approvalRequestParamsSchema. */
+export const approvalRequestParamsV11Schema = approvalRequestParamsSchema;
+export const approvalRequestParamsV12Schema = z
+    .object({
+    interactionId: interactionIdSchema,
+    threadId: threadIdSchema,
+    turnId: turnIdSchema,
+    expiresAt: timestampSchema,
+    sensitivity: z.literal("normal"),
+    approval: pendingApprovalSchema,
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.turnId !== value.approval.turnId) {
+        context.addIssue({
+            code: "custom",
+            message: "approval.turnId must match interaction turnId",
+            path: ["approval", "turnId"],
+        });
+    }
+})
+    .readonly();
 export const approvalRequestResultSchema = z.discriminatedUnion("decision", [
     z
         .object({
@@ -377,6 +997,24 @@ export const runtimeServerRequestCancelParamsSchema = z
 })
     .strict()
     .readonly();
+/** Protocol 1.1 wire shape. Keep this alias frozen with runtimeServerRequestCancelParamsSchema. */
+export const runtimeServerRequestCancelParamsV11Schema = runtimeServerRequestCancelParamsSchema;
+export const runtimeServerRequestCancelParamsV12Schema = z
+    .object({
+    interactionId: interactionIdSchema,
+    reason: z.string().min(1),
+})
+    .strict()
+    .readonly();
+export const runtimeServerRequestCancelProjectionInputSchema = z
+    .object({
+    interactionId: interactionIdSchema,
+    serverRequestId: jsonRpcIdSchema,
+    approvalId: approvalIdSchema.optional(),
+    reason: z.string().min(1),
+})
+    .strict()
+    .readonly();
 export const operationGetParamsSchema = z
     .object({
     ...threadRequestFields,
@@ -421,127 +1059,144 @@ export const approvalResolutionSchema = z.union([
         .strict()
         .readonly(),
 ]);
-export const runtimeEventSchema = 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),
-        input: jsonValueSchema,
-    })
-        .strict()
-        .readonly(),
-    z
-        .object({
-        type: z.literal("tool.output"),
-        toolCallId: z.string().min(1),
-        agentName: z.string().min(1),
-        toolName: z.string().min(1),
-        stream: z.enum(["stdout", "stderr"]),
-        delta: z.string(),
-    })
-        .strict()
-        .readonly(),
-    z
-        .object({
-        type: z.literal("tool.completed"),
-        toolCallId: z.string().min(1),
-        agentName: z.string().min(1),
-        toolName: z.string().min(1),
-        operationId: operationIdSchema.optional(),
-        outcome: toolOutcomeSchema.optional(),
-        display: jsonValueSchema,
-    })
-        .strict()
-        .readonly(),
-    z
-        .object({
-        type: z.literal("approval.required"),
-        approval: pendingApprovalSchema,
-    })
-        .strict()
-        .readonly(),
-    z
-        .object({
-        type: z.literal("approval.resolved"),
-        approvalId: approvalIdSchema,
-        resolution: approvalResolutionSchema,
-    })
-        .strict()
-        .readonly(),
-    z
-        .object({ type: z.literal("turn.completed") })
-        .strict()
-        .readonly(),
-    z
-        .object({
-        type: z.literal("turn.cancelled"),
-        reason: z.string(),
-        message: z.string(),
-    })
-        .strict()
-        .readonly(),
-    z
-        .object({
-        type: z.literal("turn.failed"),
-        stage: z.enum(["bootstrap", "plan", "execute"]),
-        message: z.string(),
-    })
-        .strict()
-        .readonly(),
-    z
-        .object({ type: z.literal("capabilities.changed") })
-        .strict()
-        .readonly(),
-]);
-export const runtimeEventEnvelopeSchema = z
+const turnStartedEventSchema = z
+    .object({ type: z.literal("turn.started") })
+    .strict()
+    .readonly();
+const messageStartedEventSchema = z
+    .object({ type: z.literal("message.started"), streamId: streamIdSchema })
+    .strict()
+    .readonly();
+const messageDeltaEventSchema = z
+    .object({ type: z.literal("message.delta"), streamId: streamIdSchema, delta: z.string() })
+    .strict()
+    .readonly();
+const messageCompletedEventSchema = z
+    .object({ type: z.literal("message.completed"), streamId: streamIdSchema, text: z.string() })
+    .strict()
+    .readonly();
+const reasoningSummaryDeltaEventSchema = z
+    .object({
+    type: z.literal("reasoning.summary.delta"),
+    reasoningId: z.string().min(1),
+    delta: z.string(),
+})
+    .strict()
+    .readonly();
+const toolStartedEventSchema = z
+    .object({
+    type: z.literal("tool.started"),
+    toolCallId: z.string().min(1),
+    agentName: z.string().min(1),
+    toolName: z.string().min(1),
+    input: jsonValueSchema,
+})
+    .strict()
+    .readonly();
+const toolOutputEventSchema = z
+    .object({
+    type: z.literal("tool.output"),
+    toolCallId: z.string().min(1),
+    agentName: z.string().min(1),
+    toolName: z.string().min(1),
+    stream: z.enum(["stdout", "stderr"]),
+    delta: z.string(),
+})
+    .strict()
+    .readonly();
+const toolCompletedEventSchema = z
+    .object({
+    type: z.literal("tool.completed"),
+    toolCallId: z.string().min(1),
+    agentName: z.string().min(1),
+    toolName: z.string().min(1),
+    operationId: operationIdSchema.optional(),
+    outcome: toolOutcomeSchema.optional(),
+    display: jsonValueSchema,
+})
+    .strict()
+    .readonly();
+const approvalRequiredEventSchema = z
+    .object({ type: z.literal("approval.required"), approval: pendingApprovalSchema })
+    .strict()
+    .readonly();
+const approvalResolvedEventSchema = z
     .object({
-    protocolVersion: runtimeProtocolVersionSchema,
+    type: z.literal("approval.resolved"),
+    approvalId: approvalIdSchema,
+    resolution: approvalResolutionSchema,
+})
+    .strict()
+    .readonly();
+const turnCompletedEventSchema = z
+    .object({ type: z.literal("turn.completed") })
+    .strict()
+    .readonly();
+const turnCancelledEventSchema = z
+    .object({ type: z.literal("turn.cancelled"), reason: z.string(), message: z.string() })
+    .strict()
+    .readonly();
+const turnFailedEventSchema = z
+    .object({
+    type: z.literal("turn.failed"),
+    stage: z.enum(["bootstrap", "plan", "execute"]),
+    message: z.string(),
+})
+    .strict()
+    .readonly();
+const capabilitiesChangedEventSchema = z
+    .object({ type: z.literal("capabilities.changed") })
+    .strict()
+    .readonly();
+/** Runtime Protocol 1.1/1.0 event payloads. Keep this registry and ordering frozen. */
+export const runtimeEventV11Schema = z.discriminatedUnion("type", [
+    turnStartedEventSchema,
+    messageStartedEventSchema,
+    messageDeltaEventSchema,
+    messageCompletedEventSchema,
+    reasoningSummaryDeltaEventSchema,
+    toolStartedEventSchema,
+    toolOutputEventSchema,
+    toolCompletedEventSchema,
+    approvalRequiredEventSchema,
+    approvalResolvedEventSchema,
+    turnCompletedEventSchema,
+    turnCancelledEventSchema,
+    turnFailedEventSchema,
+    capabilitiesChangedEventSchema,
+]);
+export const runtimeDurableEventV13Schema = z.discriminatedUnion("type", [
+    turnStartedEventSchema,
+    messageCompletedEventSchema,
+    toolCompletedEventSchema,
+    approvalRequiredEventSchema,
+    approvalResolvedEventSchema,
+    turnCompletedEventSchema,
+    turnCancelledEventSchema,
+    turnFailedEventSchema,
+    capabilitiesChangedEventSchema,
+]);
+export const runtimeEphemeralEventV13Schema = z.discriminatedUnion("type", [
+    messageStartedEventSchema,
+    messageDeltaEventSchema,
+    reasoningSummaryDeltaEventSchema,
+    toolStartedEventSchema,
+    toolOutputEventSchema,
+]);
+/** Runtime Protocol 1.2 event payloads. Currently identical to the 1.1 payload registry. */
+export const runtimeEventV12Schema = runtimeEventV11Schema;
+/** Runtime Protocol 1.3 retains the event payload registry and versions durability in the envelope. */
+export const runtimeEventV13Schema = runtimeEventV12Schema;
+/** Latest Runtime Protocol event payloads. */
+export const runtimeEventSchema = runtimeEventV13Schema;
+const runtimeEventEnvelopeFields = {
     runtimeInstanceId: runtimeInstanceIdSchema,
     sequence: z.number().int().nonnegative(),
     timestamp: timestampSchema,
     threadId: threadIdSchema,
     turnId: turnIdSchema.optional(),
-    event: runtimeEventSchema,
-})
-    .strict()
-    .superRefine((value, context) => {
+};
+function validateRuntimeEventCapabilities(value, context) {
     if (!getRuntimeProtocolCapabilities(value.protocolVersion).approvalResolvedEvents &&
         value.event.type === "approval.resolved") {
         context.addIssue({
@@ -550,20 +1205,89 @@ export const runtimeEventEnvelopeSchema = z
             path: ["event", "type"],
         });
     }
+}
+/** Runtime Protocol 1.1/1.0 event envelope. Keep this schema frozen. */
+export const runtimeEventEnvelopeV11Schema = z
+    .object({
+    protocolVersion: runtimeProtocolVersionV11Schema,
+    ...runtimeEventEnvelopeFields,
+    event: runtimeEventV11Schema,
 })
+    .strict()
+    .superRefine(validateRuntimeEventCapabilities)
     .readonly();
+/** Runtime Protocol 1.2 event envelope. Keep this schema frozen. */
+export const runtimeEventEnvelopeV12Schema = z
+    .object({
+    protocolVersion: z.literal("1.2"),
+    ...runtimeEventEnvelopeFields,
+    event: runtimeEventV12Schema,
+})
+    .strict()
+    .superRefine(validateRuntimeEventCapabilities)
+    .readonly();
+export const runtimeDurableEventEnvelopeV13Schema = z
+    .object({
+    protocolVersion: z.literal("1.3"),
+    ...runtimeEventEnvelopeFields,
+    durability: z.literal("durable"),
+    eventId: runtimeEventIdSchema,
+    cursor: runtimeEventCursorSchema,
+    event: runtimeDurableEventV13Schema,
+})
+    .strict()
+    .superRefine(validateRuntimeEventCapabilities)
+    .readonly();
+export const runtimeEphemeralEventEnvelopeV13Schema = z
+    .object({
+    protocolVersion: z.literal("1.3"),
+    ...runtimeEventEnvelopeFields,
+    durability: z.literal("ephemeral"),
+    event: runtimeEphemeralEventV13Schema,
+})
+    .strict()
+    .superRefine(validateRuntimeEventCapabilities)
+    .readonly();
+export const runtimeEventEnvelopeV13Schema = z.discriminatedUnion("durability", [
+    runtimeDurableEventEnvelopeV13Schema,
+    runtimeEphemeralEventEnvelopeV13Schema,
+]);
+/** Any currently supported Runtime Event envelope. */
+export const runtimeEventEnvelopeSchema = z.union([
+    runtimeEventEnvelopeV13Schema,
+    runtimeEventEnvelopeV12Schema,
+    runtimeEventEnvelopeV11Schema,
+]);
 export const runtimeProtocolErrorDataSchema = z
     .object({
-    rollCode: z.enum(Object.values(RUNTIME_ERROR_CODES)),
+    rollCode: z.enum(Object.values(RUNTIME_ERROR_CODES_V11)),
+    retryable: z.boolean(),
+    details: jsonValueSchema.optional(),
+})
+    .strict()
+    .readonly();
+/** Protocol 1.1 wire shape. Keep this alias frozen with runtimeProtocolErrorDataSchema. */
+export const runtimeProtocolErrorDataV11Schema = runtimeProtocolErrorDataSchema;
+export const runtimeProtocolErrorDataV12Schema = z
+    .object({
+    rollCode: z.enum(Object.values(RUNTIME_ERROR_CODES_V12)),
+    retryable: z.boolean(),
+    details: jsonValueSchema.optional(),
+})
+    .strict()
+    .readonly();
+export const runtimeProtocolErrorDataV13Schema = z
+    .object({
+    rollCode: z.enum(Object.values(RUNTIME_ERROR_CODES_V13)),
     retryable: z.boolean(),
     details: jsonValueSchema.optional(),
 })
     .strict()
     .readonly();
-export const runtimeMethodSchemas = {
+export const runtimeMethodSchemasV11 = {
     [RUNTIME_METHODS.initialize]: {
         params: initializeParamsSchema,
-        result: initializeResultSchema,
+        result: initializeResultV11Schema,
     },
     [RUNTIME_METHODS.threadList]: {
         params: threadListParamsSchema,
@@ -575,11 +1299,11 @@ export const runtimeMethodSchemas = {
     },
     [RUNTIME_METHODS.threadOpen]: {
         params: threadOpenParamsSchema,
-        result: threadOpenResultSchema,
+        result: threadOpenResultV11Schema,
     },
     [RUNTIME_METHODS.threadSnapshot]: {
-        params: threadSnapshotParamsSchema,
-        result: threadSnapshotResultSchema,
+        params: threadSnapshotParamsV12Schema,
+        result: threadSnapshotResultV11Schema,
     },
     [RUNTIME_METHODS.threadRename]: {
         params: threadRenameParamsSchema,
@@ -614,12 +1338,118 @@ export const runtimeMethodSchemas = {
         result: operationGetResultSchema,
     },
 };
-export const runtimeServerRequestSchemas = {
+export const runtimeMethodSchemasV10 = runtimeMethodSchemasV11;
+export const runtimeMethodSchemasV12 = {
+    ...runtimeMethodSchemasV11,
+    [RUNTIME_METHODS.initialize]: {
+        params: initializeParamsSchema,
+        result: initializeResultV12Schema,
+    },
+    [RUNTIME_METHODS.threadOpen]: {
+        params: threadOpenParamsSchema,
+        result: threadSnapshotV12Schema,
+    },
+    [RUNTIME_METHODS.threadSnapshot]: {
+        params: threadSnapshotParamsV12Schema,
+        result: threadSnapshotResultV12Schema,
+    },
+    [RUNTIME_METHODS.clientCapabilitiesSet]: {
+        params: clientCapabilitiesSetParamsSchema,
+        result: clientCapabilitiesSetResultSchema,
+    },
+};
+export const runtimeMethodSchemasV13 = {
+    ...runtimeMethodSchemasV12,
+    [RUNTIME_METHODS.initialize]: {
+        params: initializeParamsSchema,
+        result: initializeResultV13Schema,
+    },
+    [RUNTIME_METHODS.threadOpen]: {
+        params: threadOpenParamsSchema,
+        result: threadOpenResultSchema,
+    },
+    [RUNTIME_METHODS.threadSnapshot]: {
+        params: threadSnapshotParamsV13Schema,
+        result: threadSnapshotResultSchema,
+    },
+    [RUNTIME_METHODS.runtimeEventsResume]: {
+        params: runtimeEventsResumeParamsSchema,
+        result: runtimeEventsResumeResultSchema,
+    },
+};
+/** Latest Runtime method registry. Use the version registry for negotiated availability. */
+export const runtimeMethodSchemas = runtimeMethodSchemasV13;
+export const runtimeServerRequestSchemasV10 = {};
+export const runtimeServerRequestSchemasV11 = {
     [RUNTIME_SERVER_REQUEST_METHODS.approvalRequest]: {
         params: approvalRequestParamsSchema,
         result: approvalRequestResultSchema,
     },
 };
+export const runtimeServerRequestSchemasV12 = {
+    [RUNTIME_SERVER_REQUEST_METHODS.approvalRequest]: {
+        params: approvalRequestParamsV12Schema,
+        result: approvalRequestResultSchema,
+    },
+    [RUNTIME_SERVER_REQUEST_METHODS.userInputRequest]: {
+        params: userInputRequestParamsV12Schema,
+        result: userInputResultSchema,
+    },
+};
+export const runtimeServerRequestSchemasV13 = runtimeServerRequestSchemasV12;
+/** Protocol 1.1 compatibility facade. Prefer the version registry in new code. */
+export const runtimeServerRequestSchemas = runtimeServerRequestSchemasV11;
+export const RUNTIME_PROTOCOL_REGISTRY = {
+    "1.3": {
+        methods: runtimeMethodSchemasV13,
+        serverRequests: runtimeServerRequestSchemasV13,
+        serverRequestMethods: RUNTIME_SERVER_REQUEST_METHOD_VALUES,
+        serverRequestCancelParamsSchema: runtimeServerRequestCancelParamsV12Schema,
+        eventEnvelopeSchema: runtimeEventEnvelopeV13Schema,
+        errorDataSchema: runtimeProtocolErrorDataV13Schema,
+    },
+    "1.2": {
+        methods: runtimeMethodSchemasV12,
+        serverRequests: runtimeServerRequestSchemasV12,
+        serverRequestMethods: RUNTIME_SERVER_REQUEST_METHOD_VALUES,
+        serverRequestCancelParamsSchema: runtimeServerRequestCancelParamsV12Schema,
+        eventEnvelopeSchema: runtimeEventEnvelopeV12Schema,
+        errorDataSchema: runtimeProtocolErrorDataV12Schema,
+    },
+    "1.1": {
+        methods: runtimeMethodSchemasV11,
+        serverRequests: runtimeServerRequestSchemasV11,
+        serverRequestMethods: RUNTIME_SERVER_REQUEST_METHOD_VALUES_V11,
+        serverRequestCancelParamsSchema: runtimeServerRequestCancelParamsV11Schema,
+        eventEnvelopeSchema: runtimeEventEnvelopeV11Schema,
+        errorDataSchema: runtimeProtocolErrorDataV11Schema,
+    },
+    "1.0": {
+        methods: runtimeMethodSchemasV10,
+        serverRequests: runtimeServerRequestSchemasV10,
+        serverRequestMethods: [],
+        serverRequestCancelParamsSchema: null,
+        eventEnvelopeSchema: runtimeEventEnvelopeV11Schema,
+        errorDataSchema: runtimeProtocolErrorDataV11Schema,
+    },
+};
+export function getRuntimeProtocolRegistry(version) {
+    return RUNTIME_PROTOCOL_REGISTRY[version];
+}
+export function isRuntimeMethodAvailable(version, method) {
+    return Object.hasOwn(getRuntimeProtocolRegistry(version).methods, method);
+}
+export function isRuntimeServerRequestMethodAvailable(version, method) {
+    return Object.hasOwn(getRuntimeProtocolRegistry(version).serverRequests, method);
+}
+export function projectClientCapabilitiesSetResult(value) {
+    const params = clientCapabilitiesSetParamsSchema.parse(value);
+    const requested = new Set(params.serverRequestMethods);
+    return clientCapabilitiesSetResultSchema.parse({
+        revision: params.revision,
+        acceptedServerRequestMethods: RUNTIME_PROTOCOL_REGISTRY[RUNTIME_PROTOCOL_VERSION].serverRequestMethods.filter((method) => requested.has(method)),
+    });
+}
 export function getApprovalExplanation(approval) {
     const preview = approval.preview;
     if (typeof preview !== "object" || preview === null || Array.isArray(preview)) {
@@ -628,18 +1458,307 @@ export function getApprovalExplanation(approval) {
     const parsed = approvalExplanationSchema.safeParse(preview[APPROVAL_EXPLANATION_PREVIEW_KEY]);
     return parsed.success ? parsed.data : undefined;
 }
+function validateUserInputTextValue(control, value, path, addIssue) {
+    if (typeof value !== "string") {
+        addIssue(path, `${control.type} control requires a string value`);
+        return;
+    }
+    const minimum = Math.max(control.minLength ?? 0, control.required ? 1 : 0);
+    const maximum = control.maxLength ?? USER_INPUT_TEXT_MAX_CHARS;
+    if (value.length < minimum) {
+        addIssue(path, `string value must contain at least ${String(minimum)} characters`);
+    }
+    if (value.length > maximum) {
+        addIssue(path, `string value must contain at most ${String(maximum)} characters`);
+    }
+}
+const USER_INPUT_VALUE_VALIDATORS = {
+    [USER_INPUT_CONTROL_TYPES.text]: ((control, value, path, addIssue) => {
+        validateUserInputTextValue(userInputTextControlSchema.parse(control), value, path, addIssue);
+    }),
+    [USER_INPUT_CONTROL_TYPES.multiline]: ((control, value, path, addIssue) => {
+        validateUserInputTextValue(userInputMultilineControlSchema.parse(control), value, path, addIssue);
+    }),
+    [USER_INPUT_CONTROL_TYPES.number]: ((control, value, path, addIssue) => {
+        const numberControl = userInputNumberControlSchema.parse(control);
+        if (typeof value !== "number" || !Number.isFinite(value)) {
+            addIssue(path, "number control requires a finite number value");
+            return;
+        }
+        if (numberControl.integer === true && !Number.isInteger(value)) {
+            addIssue(path, "number control requires an integer value");
+        }
+        if (numberControl.min !== undefined && value < numberControl.min) {
+            addIssue(path, `number value must be at least ${String(numberControl.min)}`);
+        }
+        if (numberControl.max !== undefined && value > numberControl.max) {
+            addIssue(path, `number value must be at most ${String(numberControl.max)}`);
+        }
+    }),
+    [USER_INPUT_CONTROL_TYPES.boolean]: ((control, value, path, addIssue) => {
+        userInputBooleanControlSchema.parse(control);
+        if (typeof value !== "boolean") {
+            addIssue(path, "boolean control requires a boolean value");
+        }
+    }),
+    [USER_INPUT_CONTROL_TYPES.choice]: ((control, value, path, addIssue) => {
+        const choiceControl = userInputChoiceControlSchema.parse(control);
+        const optionIds = new Set(choiceControl.options.map((option) => option.id));
+        if (!choiceControl.multiple) {
+            if (typeof value !== "string") {
+                addIssue(path, "single-choice control requires one option id");
+                return;
+            }
+            if (!optionIds.has(value)) {
+                addIssue(path, `unknown choice option id: ${value}`);
+            }
+            return;
+        }
+        if (!Array.isArray(value)) {
+            addIssue(path, "multiple-choice control requires an array of option ids");
+            return;
+        }
+        const selected = new Set();
+        for (const [index, optionId] of value.entries()) {
+            if (selected.has(optionId)) {
+                addIssue([...path, index], `duplicate choice option id: ${optionId}`);
+            }
+            selected.add(optionId);
+            if (!optionIds.has(optionId)) {
+                addIssue([...path, index], `unknown choice option id: ${optionId}`);
+            }
+        }
+        const minimum = Math.max(choiceControl.minSelections ?? 0, choiceControl.required ? 1 : 0);
+        const maximum = choiceControl.maxSelections ?? choiceControl.options.length;
+        if (value.length < minimum) {
+            addIssue(path, `choice value must contain at least ${String(minimum)} selections`);
+        }
+        if (value.length > maximum) {
+            addIssue(path, `choice value must contain at most ${String(maximum)} selections`);
+        }
+    }),
+};
+function userInputControlRequiresValue(control) {
+    if (control.required) {
+        return true;
+    }
+    return control.type === USER_INPUT_CONTROL_TYPES.choice && (control.minSelections ?? 0) > 0;
+}
+/**
+ * Correlates a structurally valid Client result with the original form and returns values in
+ * form definition order. Unknown, duplicate, missing or type-incompatible values are rejected.
+ */
+export function normalizeUserInputResultForForm(form, result) {
+    const parsedForm = userInputFormSchema.parse(form);
+    const parsedResult = userInputResultSchema.parse(result);
+    if (parsedResult.status === "cancelled") {
+        return parsedResult;
+    }
+    const controlsById = new Map(parsedForm.controls.map((control) => [control.id, control]));
+    const correlatedResult = userInputSubmittedResultSchema
+        .superRefine((submitted, context) => {
+        const submittedControlIds = new Set();
+        const addIssue = (path, message) => {
+            context.addIssue({ code: "custom", message, path: [...path] });
+        };
+        for (const [index, submittedValue] of submitted.values.entries()) {
+            const path = ["values", index, "value"];
+            if (submittedControlIds.has(submittedValue.id)) {
+                addIssue(["values", index, "id"], `duplicate control id: ${submittedValue.id}`);
+                continue;
+            }
+            submittedControlIds.add(submittedValue.id);
+            const control = controlsById.get(submittedValue.id);
+            if (control === undefined) {
+                addIssue(["values", index, "id"], `unknown control id: ${submittedValue.id}`);
+                continue;
+            }
+            USER_INPUT_VALUE_VALIDATORS[control.type](control, submittedValue.value, path, addIssue);
+        }
+        for (const control of parsedForm.controls) {
+            if (userInputControlRequiresValue(control) && !submittedControlIds.has(control.id)) {
+                addIssue(["values"], `required control is missing: ${control.id}`);
+            }
+        }
+    })
+        .parse(parsedResult);
+    const submittedById = new Map(correlatedResult.values.map((value) => [value.id, value]));
+    return userInputSubmittedResultSchema.parse({
+        status: "submitted",
+        values: parsedForm.controls.flatMap((control) => {
+            const value = submittedById.get(control.id);
+            return value === undefined ? [] : [value];
+        }),
+    });
+}
+/**
+ * Correlates a structurally valid Client result with the original request and returns values in
+ * form definition order. Unknown, duplicate, missing or type-incompatible values are rejected.
+ */
+export function normalizeUserInputResult(params, result) {
+    const parsedParams = userInputRequestParamsV12Schema.parse(params);
+    return normalizeUserInputResultForForm({
+        ...(parsedParams.title === undefined ? {} : { title: parsedParams.title }),
+        ...(parsedParams.description === undefined ? {} : { description: parsedParams.description }),
+        controls: parsedParams.controls,
+    }, result);
+}
 export function isRuntimeMethod(value) {
-    return Object.hasOwn(runtimeMethodSchemas, value);
+    return Object.hasOwn(runtimeMethodSchemasV11, value);
+}
+function runtimeProtocolSchemaUnavailable(version, kind, name) {
+    const suffix = name === undefined ? "" : ` ${name}`;
+    throw new Error(`Runtime Protocol ${version} does not support ${kind}${suffix}`);
+}
+export function parseRuntimeMethodParamsForVersion(version, method, value) {
+    const methods = getRuntimeProtocolRegistry(version).methods;
+    const definition = methods[method];
+    if (definition === undefined) {
+        return runtimeProtocolSchemaUnavailable(version, "method", method);
+    }
+    return definition.params.parse(value);
+}
+export function parseRuntimeMethodResultForVersion(version, method, value) {
+    const methods = getRuntimeProtocolRegistry(version).methods;
+    const definition = methods[method];
+    if (definition === undefined) {
+        return runtimeProtocolSchemaUnavailable(version, "method", method);
+    }
+    return definition.result.parse(value);
 }
 export function parseRuntimeMethodParams(method, value) {
-    return runtimeMethodSchemas[method].params.parse(value);
+    return runtimeMethodSchemasV11[method].params.parse(value);
 }
 export function parseRuntimeMethodResult(method, value) {
-    return runtimeMethodSchemas[method].result.parse(value);
+    return runtimeMethodSchemasV11[method].result.parse(value);
+}
+export function projectThreadSnapshotForVersion(version, value) {
+    const latest = threadSnapshotV13Schema.safeParse(value);
+    if (version === "1.3") {
+        if (!latest.success) {
+            throw latest.error;
+        }
+        return latest.data;
+    }
+    const v12 = latest.success
+        ? threadSnapshotV12Schema.parse({
+            thread: latest.data.thread,
+            messages: latest.data.messages,
+            operations: latest.data.operations,
+            ...(latest.data.activeTurn === undefined ? {} : { activeTurn: latest.data.activeTurn }),
+            pendingApprovals: latest.data.pendingApprovals,
+            pendingInteractions: latest.data.pendingInteractions,
+            transcriptCompleteness: latest.data.transcriptCompleteness,
+        })
+        : threadSnapshotV12Schema.parse(value);
+    if (version === "1.2") {
+        return v12;
+    }
+    return threadSnapshotV11Schema.parse({
+        thread: v12.thread,
+        messages: v12.messages,
+        operations: v12.operations,
+        ...(v12.activeTurn === undefined
+            ? {}
+            : {
+                activeTurn: {
+                    ...v12.activeTurn,
+                    status: v12.activeTurn.status === "waiting-for-user" ? "running" : v12.activeTurn.status,
+                },
+            }),
+        pendingApprovals: v12.pendingApprovals,
+        transcriptCompleteness: v12.transcriptCompleteness,
+    });
+}
+export function projectRuntimeEventEnvelopeForVersion(version, value) {
+    const source = runtimeEventEnvelopeSchema.parse(value);
+    if (version === "1.3") {
+        return runtimeEventEnvelopeV13Schema.parse(source);
+    }
+    const projectedEnvelopeFields = {
+        runtimeInstanceId: source.runtimeInstanceId,
+        sequence: source.sequence,
+        timestamp: source.timestamp,
+        threadId: source.threadId,
+        ...(source.turnId === undefined ? {} : { turnId: source.turnId }),
+    };
+    if (version === "1.2") {
+        return runtimeEventEnvelopeV12Schema.parse({
+            protocolVersion: version,
+            ...projectedEnvelopeFields,
+            event: runtimeEventV12Schema.parse(source.event),
+        });
+    }
+    return runtimeEventEnvelopeV11Schema.parse({
+        protocolVersion: version,
+        ...projectedEnvelopeFields,
+        event: runtimeEventV11Schema.parse(source.event),
+    });
 }
 export function isRuntimeServerRequestMethod(value) {
     return Object.hasOwn(runtimeServerRequestSchemas, value);
 }
+export function isLatestRuntimeServerRequestMethod(value) {
+    return Object.hasOwn(runtimeServerRequestSchemasV13, value);
+}
+export function parseRuntimeServerRequestParamsForVersion(version, method, value) {
+    const serverRequests = getRuntimeProtocolRegistry(version).serverRequests;
+    const definition = serverRequests[method];
+    if (definition === undefined) {
+        return runtimeProtocolSchemaUnavailable(version, "server request", method);
+    }
+    return definition.params.parse(value);
+}
+export function parseRuntimeServerRequestResultForVersion(version, method, value) {
+    const serverRequests = getRuntimeProtocolRegistry(version).serverRequests;
+    const definition = serverRequests[method];
+    if (definition === undefined) {
+        return runtimeProtocolSchemaUnavailable(version, "server request", method);
+    }
+    return definition.result.parse(value);
+}
+export function parseRuntimeServerRequestCancelParamsForVersion(version, value) {
+    const schema = getRuntimeProtocolRegistry(version).serverRequestCancelParamsSchema;
+    if (schema === null) {
+        return runtimeProtocolSchemaUnavailable(version, "server request cancellation");
+    }
+    return schema.parse(value);
+}
+export function parseRuntimeProtocolErrorDataForVersion(version, value) {
+    return getRuntimeProtocolRegistry(version).errorDataSchema.parse(value);
+}
+export function projectRuntimeServerRequestParams(version, method, value) {
+    const latest = parseRuntimeServerRequestParamsForVersion("1.3", method, value);
+    if (version === "1.3" || version === "1.2") {
+        return latest;
+    }
+    if (version === "1.1" && method === RUNTIME_SERVER_REQUEST_METHODS.approvalRequest) {
+        const approval = approvalRequestParamsV12Schema.parse(latest);
+        return approvalRequestParamsV11Schema.parse({
+            threadId: approval.threadId,
+            approval: approval.approval,
+            expiresAt: approval.expiresAt,
+        });
+    }
+    return runtimeProtocolSchemaUnavailable(version, "server request", method);
+}
+export function projectRuntimeServerRequestCancelParams(version, value) {
+    const input = runtimeServerRequestCancelProjectionInputSchema.parse(value);
+    if (version === "1.3" || version === "1.2") {
+        return runtimeServerRequestCancelParamsV12Schema.parse({
+            interactionId: input.interactionId,
+            reason: input.reason,
+        });
+    }
+    if (version === "1.1") {
+        return runtimeServerRequestCancelParamsV11Schema.parse({
+            serverRequestId: input.serverRequestId,
+            ...(input.approvalId === undefined ? {} : { approvalId: input.approvalId }),
+            reason: input.reason,
+        });
+    }
+    return runtimeProtocolSchemaUnavailable(version, "server request cancellation");
+}
 export function parseRuntimeServerRequestParams(method, value) {
     return runtimeServerRequestSchemas[method].params.parse(value);
 }