@markusylisiurunen/tau 0.3.17 → 0.3.19

package/dist/protocol/index.js

@@ -1,2 +1,2 @@
-export { applySessionProtocolDelta, createSessionProtocolDeltaMessage, createSessionProtocolEphemeralMessage, createSessionProtocolError, createSessionProtocolErrorResponse, createSessionProtocolReadyMessage, createSessionProtocolRequest, createSessionProtocolSuccessResponse, isSessionProtocolMethod, parseSessionProtocolOutgoingLine, parseSessionProtocolRequestLine, SESSION_PROTOCOL_ERROR_CODES, SESSION_PROTOCOL_METHODS, SESSION_PROTOCOL_VERSION, serializeSessionProtocolMessage, validateSessionProtocolParams, validateSessionProtocolResult, } from "./session_protocol.js";
+export { applySessionProtocolDelta, createSessionProtocolDeltaMessage, createSessionProtocolEphemeralMessage, createSessionProtocolError, createSessionProtocolErrorResponse, createSessionProtocolPendingUserMessagesMessage, createSessionProtocolReadyMessage, createSessionProtocolRequest, createSessionProtocolSuccessResponse, isSessionProtocolMethod, parseSessionProtocolOutgoingLine, parseSessionProtocolRequestLine, SESSION_PROTOCOL_ERROR_CODES, SESSION_PROTOCOL_METHODS, SESSION_PROTOCOL_VERSION, serializeSessionProtocolMessage, validateSessionProtocolParams, validateSessionProtocolResult, } from "./session_protocol.js";
 //# sourceMappingURL=index.js.map

package/dist/protocol/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/protocol/index.ts"],"names":[],"mappings":"AAoHA,OAAO,EACL,yBAAyB,EACzB,iCAAiC,EACjC,qCAAqC,EACrC,0BAA0B,EAC1B,kCAAkC,EAClC,iCAAiC,EACjC,4BAA4B,EAC5B,oCAAoC,EACpC,uBAAuB,EACvB,gCAAgC,EAChC,+BAA+B,EAC/B,4BAA4B,EAC5B,wBAAwB,EACxB,wBAAwB,EACxB,+BAA+B,EAC/B,6BAA6B,EAC7B,6BAA6B,GAC9B,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/protocol/index.ts"],"names":[],"mappings":"AA2HA,OAAO,EACL,yBAAyB,EACzB,iCAAiC,EACjC,qCAAqC,EACrC,0BAA0B,EAC1B,kCAAkC,EAClC,+CAA+C,EAC/C,iCAAiC,EACjC,4BAA4B,EAC5B,oCAAoC,EACpC,uBAAuB,EACvB,gCAAgC,EAChC,+BAA+B,EAC/B,4BAA4B,EAC5B,wBAAwB,EACxB,wBAAwB,EACxB,+BAA+B,EAC/B,6BAA6B,EAC7B,6BAA6B,GAC9B,MAAM,uBAAuB,CAAC"}

package/dist/protocol/session_protocol.d.ts

@@ -1,6 +1,6 @@
 import type { Message, TextContent, ThinkingContent, ToolCall } from "@earendil-works/pi-ai";
 export declare const SESSION_PROTOCOL_VERSION: 1;
-export declare const SESSION_PROTOCOL_METHODS: readonly ["initialize", "session.create", "session.list", "session.observe", "session.unobserve", "session.record", "session.submit", "session.queue", "session.steer", "session.retry", "session.exec", "session.interrupt", "session.snapshot", "session.setRisk", "session.setReasoning", "session.setPersona", "session.resolvePrompt", "session.autocompletePaths", "session.reload", "session.compact", "session.prune", "session.rewind", "session.terminateSubagent", "session.ephemeral.create", "session.ephemeral.submit", "session.ephemeral.close", "session.clientTool.ack", "session.clientTool.result"];
+export declare const SESSION_PROTOCOL_METHODS: readonly ["initialize", "session.create", "session.list", "session.observe", "session.unobserve", "session.record", "session.submit", "session.queue", "session.steer", "session.cancelPendingMessages", "session.retry", "session.exec", "session.interrupt", "session.snapshot", "session.setRisk", "session.setReasoning", "session.setPersona", "session.resolvePrompt", "session.autocompletePaths", "session.reload", "session.compact", "session.prune", "session.rewind", "session.terminateSubagent", "session.ephemeral.create", "session.ephemeral.submit", "session.ephemeral.close", "session.clientTool.ack", "session.clientTool.result"];
 export type SessionProtocolMethod = (typeof SESSION_PROTOCOL_METHODS)[number];
 export declare const SESSION_PROTOCOL_ERROR_CODES: {
     readonly parseError: "parse_error";
@@ -9,6 +9,7 @@ export declare const SESSION_PROTOCOL_ERROR_CODES: {
     readonly invalidParams: "invalid_params";
     readonly notFound: "not_found";
     readonly busy: "busy";
+    readonly cancelled: "cancelled";
     readonly internalError: "internal_error";
 };
 export type SessionProtocolErrorCode = (typeof SESSION_PROTOCOL_ERROR_CODES)[keyof typeof SESSION_PROTOCOL_ERROR_CODES];
@@ -62,6 +63,7 @@ export type SessionProtocolUserMessageParams = {
 export type SessionProtocolSubmitParams = SessionProtocolUserMessageParams;
 export type SessionProtocolQueueParams = SessionProtocolUserMessageParams;
 export type SessionProtocolSteerParams = SessionProtocolUserMessageParams;
+export type SessionProtocolCancelPendingMessagesParams = SessionProtocolSessionIdParams;
 export type SessionProtocolRecordParams = SessionProtocolSessionIdParams & {
     text: string;
     historyEntryId?: string;
@@ -145,6 +147,7 @@ export type SessionProtocolParamsByMethod = {
     "session.submit": SessionProtocolSubmitParams;
     "session.queue": SessionProtocolQueueParams;
     "session.steer": SessionProtocolSteerParams;
+    "session.cancelPendingMessages": SessionProtocolCancelPendingMessagesParams;
     "session.retry": SessionProtocolRetryParams;
     "session.exec": SessionProtocolExecParams;
     "session.interrupt": SessionProtocolSessionIdParams;
@@ -185,6 +188,25 @@ export type SessionProtocolUserMessageTurnResult = SessionProtocolTurnResult & {
 export type SessionProtocolSubmitResult = SessionProtocolUserMessageTurnResult;
 export type SessionProtocolQueueResult = SessionProtocolUserMessageTurnResult;
 export type SessionProtocolSteerResult = SessionProtocolUserMessageTurnResult;
+export type SessionProtocolPendingUserMessage = {
+    id: string;
+    mode: "queue" | "steer";
+    text: string;
+};
+export type SessionProtocolPendingUserMessagesState = {
+    revision: number;
+    messages: SessionProtocolPendingUserMessage[];
+};
+export type SessionProtocolCreateResult = {
+    sessionId: string;
+};
+export type SessionProtocolObserveResult = {
+    snapshot: SessionProtocolSnapshot;
+    pendingUserMessages: SessionProtocolPendingUserMessagesState;
+};
+export type SessionProtocolCancelPendingMessagesResult = {
+    cancelled: SessionProtocolPendingUserMessage[];
+};
 export type SessionProtocolRecordResult = {
     snapshot: SessionProtocolSnapshot;
     userHistoryEntryId: string;
@@ -254,8 +276,8 @@ export type SessionProtocolPromptCompositionSnapshot = {
     environmentTag: string;
     subagentPrompts: Record<string, string>;
 };
-export type SessionProtocolReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
-export type SessionProtocolThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+export type SessionProtocolReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export type SessionProtocolThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 export type SessionProtocolServiceTier = "priority" | "flex";
 export type SessionProtocolModelSnapshot = {
     id: string;
@@ -271,6 +293,13 @@ export type SessionProtocolModelSnapshot = {
         output: number;
         cacheRead: number;
         cacheWrite: number;
+        tiers?: Array<{
+            inputTokensAbove: number;
+            input: number;
+            output: number;
+            cacheRead: number;
+            cacheWrite: number;
+        }>;
     };
     contextWindow: number;
     maxTokens: number;
@@ -346,6 +375,7 @@ export type SessionProtocolSnapshot = {
     sessionId: string;
     revision: number;
     lifecycle: SessionProtocolSessionLifecycle;
+    costTotal: number;
     settings: SessionProtocolSettingsSnapshot;
     bootstrap: SessionProtocolBootstrapSnapshot;
     catalog: SessionProtocolContentCatalogSnapshot;
@@ -483,14 +513,15 @@ export type SessionProtocolClientToolResultResult = {
 };
 export type SessionProtocolResultByMethod = {
     initialize: SessionProtocolInitializeResult;
-    "session.create": SessionProtocolSnapshot;
+    "session.create": SessionProtocolCreateResult;
     "session.list": SessionProtocolListResult;
-    "session.observe": SessionProtocolSnapshot;
+    "session.observe": SessionProtocolObserveResult;
     "session.unobserve": SessionProtocolUnobserveResult;
     "session.record": SessionProtocolRecordResult;
     "session.submit": SessionProtocolSubmitResult;
     "session.queue": SessionProtocolQueueResult;
     "session.steer": SessionProtocolSteerResult;
+    "session.cancelPendingMessages": SessionProtocolCancelPendingMessagesResult;
     "session.retry": SessionProtocolRetryResult;
     "session.exec": SessionProtocolExecResult;
     "session.interrupt": SessionProtocolInterruptResult;
@@ -548,6 +579,9 @@ export type SessionProtocolDeltaReason = "user-message" | "assistant-stream" | "
 export type SessionProtocolChange = {
     type: "lifecycle.set";
     lifecycle: SessionProtocolSessionLifecycle;
+} | {
+    type: "cost.set";
+    costTotal: number;
 } | {
     type: "settings.set";
     settings: SessionProtocolSettingsSnapshot;
@@ -655,8 +689,14 @@ export type SessionProtocolEphemeralMessage = {
     sessionId: string;
     event: SessionProtocolEphemeralEvent;
 };
-export type SessionProtocolOutgoingMessage = SessionProtocolResponseMessage | SessionProtocolDeltaMessage | SessionProtocolEphemeralMessage | SessionProtocolClientToolMessage | SessionProtocolReadyMessage;
-export type SessionProtocolParsedOutgoingMessage = SessionProtocolParsedResponseMessage | SessionProtocolDeltaMessage | SessionProtocolEphemeralMessage | SessionProtocolClientToolMessage | SessionProtocolReadyMessage;
+export type SessionProtocolPendingUserMessagesMessage = {
+    version: typeof SESSION_PROTOCOL_VERSION;
+    type: "session.pendingUserMessages";
+    sessionId: string;
+    state: SessionProtocolPendingUserMessagesState;
+};
+export type SessionProtocolOutgoingMessage = SessionProtocolResponseMessage | SessionProtocolDeltaMessage | SessionProtocolEphemeralMessage | SessionProtocolPendingUserMessagesMessage | SessionProtocolClientToolMessage | SessionProtocolReadyMessage;
+export type SessionProtocolParsedOutgoingMessage = SessionProtocolParsedResponseMessage | SessionProtocolDeltaMessage | SessionProtocolEphemeralMessage | SessionProtocolPendingUserMessagesMessage | SessionProtocolClientToolMessage | SessionProtocolReadyMessage;
 export type SessionProtocolOutgoingParseFailureReason = "invalid_payload" | "empty_line" | "parse_error" | "unsupported_version" | "unsupported_message_type" | "response_invalid_id";
 export type SessionProtocolOutgoingParseFailure = {
     ok: false;
@@ -709,6 +749,10 @@ export declare function createSessionProtocolEphemeralMessage(options: {
     sessionId: string;
     event: SessionProtocolEphemeralEvent;
 }): SessionProtocolEphemeralMessage;
+export declare function createSessionProtocolPendingUserMessagesMessage(options: {
+    sessionId: string;
+    state: SessionProtocolPendingUserMessagesState;
+}): SessionProtocolPendingUserMessagesMessage;
 export declare function applySessionProtocolDelta(snapshot: SessionProtocolSnapshot, message: SessionProtocolDeltaMessage): SessionProtocolSnapshot;
 export declare function createSessionProtocolReadyMessage(): SessionProtocolReadyMessage;
 export declare function serializeSessionProtocolMessage(message: SessionProtocolOutgoingMessage): string;
@@ -724,6 +768,7 @@ export declare function validateSessionProtocolParams(method: "session.record",
 export declare function validateSessionProtocolParams(method: "session.submit", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSubmitParams>;
 export declare function validateSessionProtocolParams(method: "session.queue", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolQueueParams>;
 export declare function validateSessionProtocolParams(method: "session.steer", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSteerParams>;
+export declare function validateSessionProtocolParams(method: "session.cancelPendingMessages", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolCancelPendingMessagesParams>;
 export declare function validateSessionProtocolParams(method: "session.retry", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolRetryParams>;
 export declare function validateSessionProtocolParams(method: "session.exec", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolExecParams>;
 export declare function validateSessionProtocolParams(method: "session.interrupt", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSessionIdParams>;

package/dist/protocol/session_protocol.js

@@ -10,6 +10,7 @@ export const SESSION_PROTOCOL_METHODS = [
     "session.submit",
     "session.queue",
     "session.steer",
+    "session.cancelPendingMessages",
     "session.retry",
     "session.exec",
     "session.interrupt",
@@ -46,6 +47,7 @@ export const SESSION_PROTOCOL_ERROR_CODES = {
     invalidParams: "invalid_params",
     notFound: "not_found",
     busy: "busy",
+    cancelled: "cancelled",
     internalError: "internal_error",
 };
 const SESSION_PROTOCOL_ERROR_CODE_VALUES = [
@@ -55,6 +57,7 @@ const SESSION_PROTOCOL_ERROR_CODE_VALUES = [
     SESSION_PROTOCOL_ERROR_CODES.invalidParams,
     SESSION_PROTOCOL_ERROR_CODES.notFound,
     SESSION_PROTOCOL_ERROR_CODES.busy,
+    SESSION_PROTOCOL_ERROR_CODES.cancelled,
     SESSION_PROTOCOL_ERROR_CODES.internalError,
 ];
 const sessionProtocolMethodSchema = z.enum(SESSION_PROTOCOL_METHODS);
@@ -129,6 +132,7 @@ const sessionProtocolOutgoingRoutingSchema = z
         "ready",
         "session.delta",
         "session.ephemeral",
+        "session.pendingUserMessages",
         "session.clientTool.call",
         "session.clientTool.cancel",
         "response",
@@ -216,6 +220,7 @@ const sessionProtocolReasoningEffortSchema = z.enum([
     "medium",
     "high",
     "xhigh",
+    "max",
 ]);
 const sessionProtocolSetReasoningParamsSchema = z
     .object({
@@ -377,7 +382,7 @@ const sessionProtocolModelSnapshotSchema = z
     baseUrl: z.string(),
     reasoning: z.boolean(),
     thinkingLevelMap: z
-        .partialRecord(z.enum(["off", "minimal", "low", "medium", "high", "xhigh"]), z.string().nullable())
+        .partialRecord(z.enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]), z.string().nullable())
         .optional(),
     input: z.array(z.enum(["text", "image"])),
     cost: z
@@ -386,6 +391,17 @@ const sessionProtocolModelSnapshotSchema = z
         output: z.number().nonnegative(),
         cacheRead: z.number().nonnegative(),
         cacheWrite: z.number().nonnegative(),
+        tiers: z
+            .array(z
+            .object({
+            inputTokensAbove: z.number().int().nonnegative(),
+            input: z.number().nonnegative(),
+            output: z.number().nonnegative(),
+            cacheRead: z.number().nonnegative(),
+            cacheWrite: z.number().nonnegative(),
+        })
+            .strict())
+            .optional(),
     })
         .strict(),
     contextWindow: z.number().int().positive(),
@@ -629,6 +645,7 @@ const sessionProtocolSnapshotSchema = z
     sessionId: nonEmptyStringSchema,
     revision: z.number().int().positive(),
     lifecycle: sessionProtocolSessionLifecycleSchema,
+    costTotal: z.number().nonnegative(),
     settings: sessionProtocolSettingsSnapshotSchema,
     bootstrap: sessionProtocolBootstrapSnapshotSchema,
     catalog: sessionProtocolContentCatalogSnapshotSchema,
@@ -690,6 +707,12 @@ const sessionProtocolChangeSchema = z.discriminatedUnion("type", [
         lifecycle: sessionProtocolSessionLifecycleSchema,
     })
         .strict(),
+    z
+        .object({
+        type: z.literal("cost.set"),
+        costTotal: z.number().nonnegative(),
+    })
+        .strict(),
     z
         .object({
         type: z.literal("settings.set"),
@@ -860,6 +883,40 @@ const sessionProtocolEphemeralMessageSchema = z
     event: sessionProtocolEphemeralEventSchema,
 })
     .strict();
+const sessionProtocolPendingUserMessageSchema = z
+    .object({
+    id: nonEmptyStringSchema,
+    mode: z.enum(["queue", "steer"]),
+    text: nonEmptyStringSchema,
+})
+    .strict();
+const sessionProtocolPendingUserMessagesStateSchema = z
+    .object({
+    revision: z.number().int().positive(),
+    messages: z.array(sessionProtocolPendingUserMessageSchema),
+})
+    .strict()
+    .superRefine((state, ctx) => {
+    const ids = new Set();
+    for (const message of state.messages) {
+        if (ids.has(message.id)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["messages"],
+                message: `duplicate pending user message id '${message.id}'`,
+            });
+        }
+        ids.add(message.id);
+    }
+});
+const sessionProtocolPendingUserMessagesMessageSchema = z
+    .object({
+    version: z.literal(SESSION_PROTOCOL_VERSION),
+    type: z.literal("session.pendingUserMessages"),
+    sessionId: nonEmptyStringSchema,
+    state: sessionProtocolPendingUserMessagesStateSchema,
+})
+    .strict();
 const sessionProtocolInitializeResultSchema = z
     .object({
     protocolVersion: z.literal(SESSION_PROTOCOL_VERSION),
@@ -867,6 +924,17 @@ const sessionProtocolInitializeResultSchema = z
     alreadyInitialized: z.boolean(),
 })
     .strict();
+const sessionProtocolCreateResultSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+})
+    .strict();
+const sessionProtocolObserveResultSchema = z
+    .object({
+    snapshot: sessionProtocolSnapshotSchema,
+    pendingUserMessages: sessionProtocolPendingUserMessagesStateSchema,
+})
+    .strict();
 const sessionProtocolListResultSchema = z
     .object({
     sessions: z.array(sessionProtocolSessionSummarySchema),
@@ -895,6 +963,11 @@ const sessionProtocolSubmitWithUserResultSchema = sessionProtocolTurnResultSchem
     userHistoryEntryId: nonEmptyStringSchema,
 })
     .strict();
+const sessionProtocolCancelPendingMessagesResultSchema = z
+    .object({
+    cancelled: z.array(sessionProtocolPendingUserMessageSchema),
+})
+    .strict();
 const sessionProtocolRecordResultSchema = z
     .object({
     snapshot: sessionProtocolSnapshotSchema,
@@ -1075,6 +1148,19 @@ export function createSessionProtocolEphemeralMessage(options) {
     }
     return parsedMessage.data;
 }
+export function createSessionProtocolPendingUserMessagesMessage(options) {
+    const message = {
+        version: SESSION_PROTOCOL_VERSION,
+        type: "session.pendingUserMessages",
+        sessionId: options.sessionId,
+        state: options.state,
+    };
+    const parsedMessage = sessionProtocolPendingUserMessagesMessageSchema.safeParse(message);
+    if (!parsedMessage.success) {
+        throw new Error(`session protocol pending user messages message is invalid: ${formatZodError(parsedMessage.error)}`);
+    }
+    return parsedMessage.data;
+}
 export function applySessionProtocolDelta(snapshot, message) {
     if (message.sessionId !== snapshot.sessionId) {
         throw new Error(`session delta targets '${message.sessionId}' but current snapshot is '${snapshot.sessionId}'`);
@@ -1100,6 +1186,9 @@ export function applySessionProtocolDelta(snapshot, message) {
             case "lifecycle.set":
                 next.lifecycle = change.lifecycle;
                 break;
+            case "cost.set":
+                next.costTotal = change.costTotal;
+                break;
             case "settings.set":
                 next.settings = structuredClone(change.settings);
                 break;
@@ -1478,6 +1567,9 @@ export function parseSessionProtocolOutgoingLine(line) {
     if (routing.data.type === "session.ephemeral") {
         return parseSessionProtocolEphemeralMessage(parsed);
     }
+    if (routing.data.type === "session.pendingUserMessages") {
+        return parseSessionProtocolPendingUserMessagesMessage(parsed);
+    }
     if (routing.data.type === "session.clientTool.call" ||
         routing.data.type === "session.clientTool.cancel") {
         return parseSessionProtocolClientToolMessage(parsed);
@@ -1504,6 +1596,7 @@ export function validateSessionProtocolParams(method, params) {
             return validateExecParams(params);
         case "session.list":
             return validateNoParams(method, params);
+        case "session.cancelPendingMessages":
         case "session.retry":
         case "session.interrupt":
         case "session.snapshot":
@@ -1544,7 +1637,9 @@ export function validateSessionProtocolResult(method, result) {
         case "initialize":
             return validateResult(method, result, sessionProtocolInitializeResultSchema);
         case "session.create":
+            return validateResult(method, result, sessionProtocolCreateResultSchema);
         case "session.observe":
+            return validateResult(method, result, sessionProtocolObserveResultSchema);
         case "session.snapshot":
         case "session.setRisk":
         case "session.setPersona":
@@ -1583,6 +1678,8 @@ export function validateSessionProtocolResult(method, result) {
         case "session.queue":
         case "session.steer":
             return validateResult(method, result, sessionProtocolSubmitWithUserResultSchema);
+        case "session.cancelPendingMessages":
+            return validateResult(method, result, sessionProtocolCancelPendingMessagesResultSchema);
         case "session.record":
             return validateResult(method, result, sessionProtocolRecordResultSchema);
         case "session.retry":
@@ -1751,7 +1848,7 @@ function validateSetReasoningParams(params) {
                 : hasIssue(parsed.error, ["sessionId"])
                     ? "session.setReasoning params.sessionId must be a non-empty string"
                     : hasIssue(parsed.error, ["reasoning"])
-                        ? "session.setReasoning params.reasoning must be one of none, minimal, low, medium, high, or xhigh"
+                        ? "session.setReasoning params.reasoning must be one of none, minimal, low, medium, high, xhigh, or max"
                         : `session.setReasoning params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
@@ -2048,7 +2145,7 @@ function validateCreateParams(params) {
                                 : hasIssue(parsed.error, ["riskLevel"])
                                     ? "session.create params.riskLevel must be 'read-only' or 'read-write'"
                                     : hasIssue(parsed.error, ["reasoning"])
-                                        ? "session.create params.reasoning must be one of none, minimal, low, medium, high, or xhigh"
+                                        ? "session.create params.reasoning must be one of none, minimal, low, medium, high, xhigh, or max"
                                         : `session.create params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
@@ -2166,6 +2263,26 @@ function parseSessionProtocolEphemeralMessage(payload) {
         message: ephemeralMessage.data,
     };
 }
+function parseSessionProtocolPendingUserMessagesMessage(payload) {
+    const fail = (message) => outgoingParseFailure("session.pendingUserMessages", null, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, message);
+    const message = sessionProtocolPendingUserMessagesMessageSchema.safeParse(payload);
+    if (!message.success) {
+        if (hasIssue(message.error, [], "unrecognized_keys")) {
+            return fail("session.pendingUserMessages message contains unsupported fields");
+        }
+        if (hasIssue(message.error, ["sessionId"])) {
+            return fail("session.pendingUserMessages.sessionId must be a non-empty string");
+        }
+        if (hasIssue(message.error, ["state"])) {
+            return fail("session.pendingUserMessages.state is invalid");
+        }
+        return fail(`invalid session.pendingUserMessages message: ${formatZodError(message.error)}`);
+    }
+    return {
+        ok: true,
+        message: message.data,
+    };
+}
 function parseSessionProtocolResponseMessage(payload) {
     const parsedIdField = sessionProtocolIdFieldSchema.safeParse(payload);
     const responseId = parseNullableRequestId(parsedIdField.success ? parsedIdField.data.id : undefined);