@markusylisiurunen/tau 0.3.18 → 0.3.20

package/dist/protocol/session_protocol.js

@@ -15,7 +15,6 @@ export const SESSION_PROTOCOL_METHODS = [
     "session.exec",
     "session.interrupt",
     "session.snapshot",
-    "session.setRisk",
     "session.setReasoning",
     "session.setPersona",
     "session.resolvePrompt",
@@ -90,7 +89,7 @@ const sessionProtocolReadyMessageSchema = z
     type: z.literal("ready"),
     methods: sessionProtocolMethodListSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolClientToolCallMessageSchema = z
     .object({
     version: z.literal(SESSION_PROTOCOL_VERSION),
@@ -102,7 +101,7 @@ const sessionProtocolClientToolCallMessageSchema = z
     ackDeadlineMs: z.number().int().positive(),
     executionDeadlineMs: z.number().int().positive(),
 })
-    .strict();
+    .strip();
 const sessionProtocolClientToolCancelMessageSchema = z
     .object({
     version: z.literal(SESSION_PROTOCOL_VERSION),
@@ -111,7 +110,7 @@ const sessionProtocolClientToolCancelMessageSchema = z
     callId: nonEmptyStringSchema,
     reason: z.enum(["aborted", "timeout", "client-detached"]),
 })
-    .strict();
+    .strip();
 const sessionProtocolClientToolMessageSchema = z.discriminatedUnion("type", [
     sessionProtocolClientToolCallMessageSchema,
     sessionProtocolClientToolCancelMessageSchema,
@@ -124,7 +123,7 @@ const sessionProtocolRequestEnvelopeSchema = z
     method: z.string(),
     params: z.unknown(),
 })
-    .strict();
+    .strip();
 const sessionProtocolOutgoingRoutingSchema = z
     .object({
     version: z.literal(SESSION_PROTOCOL_VERSION),
@@ -138,11 +137,11 @@ const sessionProtocolOutgoingRoutingSchema = z
         "response",
     ]),
 })
-    .passthrough();
-const sessionProtocolIdFieldSchema = z.object({ id: z.unknown() }).passthrough();
-const sessionProtocolOkFieldSchema = z.object({ ok: z.unknown() }).passthrough();
-const sessionProtocolVersionFieldSchema = z.object({ version: z.unknown() }).passthrough();
-const sessionProtocolTypeFieldSchema = z.object({ type: z.unknown() }).passthrough();
+    .strip();
+const sessionProtocolIdFieldSchema = z.object({ id: z.unknown() }).strip();
+const sessionProtocolOkFieldSchema = z.object({ ok: z.unknown() }).strip();
+const sessionProtocolVersionFieldSchema = z.object({ version: z.unknown() }).strip();
+const sessionProtocolTypeFieldSchema = z.object({ type: z.unknown() }).strip();
 const sessionProtocolResponseSuccessSchema = z
     .object({
     version: z.literal(SESSION_PROTOCOL_VERSION),
@@ -151,7 +150,7 @@ const sessionProtocolResponseSuccessSchema = z
     ok: z.literal(true),
     result: z.unknown(),
 })
-    .strict();
+    .strip();
 const sessionProtocolResponseErrorSchema = z
     .object({
     version: z.literal(SESSION_PROTOCOL_VERSION),
@@ -164,9 +163,9 @@ const sessionProtocolResponseErrorSchema = z
         message: z.string(),
         data: z.unknown().optional(),
     })
-        .strict(),
+        .strip(),
 })
-    .strict();
+    .strip();
 const sessionProtocolClientToolDefinitionSchema = z
     .object({
     name: nonEmptyStringSchema,
@@ -174,7 +173,7 @@ const sessionProtocolClientToolDefinitionSchema = z
     parameters: z.unknown(),
     executionTimeoutMs: z.number().int().positive().optional(),
 })
-    .strict();
+    .strip();
 const sessionProtocolInitializeParamsSchema = z
     .object({
     client: z
@@ -183,16 +182,16 @@ const sessionProtocolInitializeParamsSchema = z
         version: nonEmptyStringSchema,
         tools: z.array(sessionProtocolClientToolDefinitionSchema).optional(),
     })
-        .strict(),
+        .strip(),
 })
-    .strict();
+    .strip();
 const sessionProtocolUserMessageParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
     text: z.string(),
     historyEntryId: nonEmptyStringSchema.optional(),
 })
-    .strict();
+    .strip();
 const sessionProtocolRecordParamsSchema = sessionProtocolUserMessageParamsSchema;
 const sessionProtocolExecParamsSchema = z
     .object({
@@ -201,18 +200,12 @@ const sessionProtocolExecParamsSchema = z
     cwd: nonEmptyStringSchema.optional(),
     timeoutMs: z.number().int().positive().optional(),
 })
-    .strict();
+    .strip();
 const sessionProtocolSessionIdParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
 })
-    .strict();
-const sessionProtocolSetRiskParamsSchema = z
-    .object({
-    sessionId: nonEmptyStringSchema,
-    riskLevel: z.enum(["read-only", "read-write"]),
-})
-    .strict();
+    .strip();
 const sessionProtocolReasoningEffortSchema = z.enum([
     "none",
     "minimal",
@@ -227,33 +220,33 @@ const sessionProtocolSetReasoningParamsSchema = z
     sessionId: nonEmptyStringSchema,
     reasoning: sessionProtocolReasoningEffortSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolSetPersonaParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
     personaId: nonEmptyStringSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolResolvePromptParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
     promptId: nonEmptyStringSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolAutocompletePathsParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
     query: z.string(),
     limit: z.number().int().positive().max(100),
 })
-    .strict();
+    .strip();
 const sessionProtocolCompactParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
     mode: z.enum(["summary-only", "summary-and-last"]),
     guidance: z.string().optional(),
 })
-    .strict();
+    .strip();
 const sessionProtocolPruneParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
@@ -261,19 +254,19 @@ const sessionProtocolPruneParamsSchema = z
     fraction: z.number().min(0).max(1),
     guidance: z.string().optional(),
 })
-    .strict();
+    .strip();
 const sessionProtocolRewindParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
     historyEntryId: nonEmptyStringSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolTerminateSubagentParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
     subagentId: nonEmptyStringSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolEphemeralAgentToolSchema = z.enum([
     "bash",
     "write",
@@ -287,9 +280,8 @@ const sessionProtocolEphemeralCreateParamsSchema = z
     sessionId: nonEmptyStringSchema,
     instructions: nonEmptyStringSchema,
     tools: z.array(sessionProtocolEphemeralAgentToolSchema),
-    riskLevel: z.enum(["read-only", "read-write"]),
 })
-    .strict();
+    .strip();
 const sessionProtocolEphemeralSubmitParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
@@ -298,19 +290,19 @@ const sessionProtocolEphemeralSubmitParamsSchema = z
     forkFromThreadId: nonEmptyStringSchema.optional(),
     message: nonEmptyStringSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolEphemeralCloseParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
     contextId: nonEmptyStringSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolClientToolAckParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
     callId: nonEmptyStringSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolClientToolResultParamsSchema = z.discriminatedUnion("ok", [
     z
         .object({
@@ -319,7 +311,7 @@ const sessionProtocolClientToolResultParamsSchema = z.discriminatedUnion("ok", [
         ok: z.literal(true),
         content: z.string(),
     })
-        .strict(),
+        .strip(),
     z
         .object({
         sessionId: nonEmptyStringSchema,
@@ -327,7 +319,7 @@ const sessionProtocolClientToolResultParamsSchema = z.discriminatedUnion("ok", [
         ok: z.literal(false),
         error: z.string(),
     })
-        .strict(),
+        .strip(),
 ]);
 const absolutePathSchema = nonEmptyStringSchema.refine((value) => value.startsWith("/"));
 const sessionProtocolLocalExecutionEnvironmentInputSchema = z
@@ -335,7 +327,7 @@ const sessionProtocolLocalExecutionEnvironmentInputSchema = z
     kind: z.literal("local"),
     cwd: absolutePathSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolCloudflareSandboxExecutionEnvironmentInputSchema = z
     .object({
     kind: z.literal("cloudflare-sandbox"),
@@ -343,7 +335,7 @@ const sessionProtocolCloudflareSandboxExecutionEnvironmentInputSchema = z
     sandboxId: nonEmptyStringSchema,
     cwd: absolutePathSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolFlySpriteExecutionEnvironmentInputSchema = z
     .object({
     kind: z.literal("fly-sprite"),
@@ -351,7 +343,7 @@ const sessionProtocolFlySpriteExecutionEnvironmentInputSchema = z
     spriteName: nonEmptyStringSchema,
     cwd: absolutePathSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolExecutionEnvironmentInputSchema = z.discriminatedUnion("kind", [
     sessionProtocolLocalExecutionEnvironmentInputSchema,
     sessionProtocolCloudflareSandboxExecutionEnvironmentInputSchema,
@@ -361,17 +353,16 @@ const sessionProtocolCreateParamsSchema = z
     .object({
     executionEnvironment: sessionProtocolExecutionEnvironmentInputSchema,
     personaId: nonEmptyStringSchema.optional(),
-    riskLevel: z.enum(["read-only", "read-write"]).optional(),
     reasoning: sessionProtocolReasoningEffortSchema.optional(),
 })
-    .strict();
-const sessionProtocolEmptyParamsSchema = z.object({}).strict();
+    .strip();
+const sessionProtocolEmptyParamsSchema = z.object({}).strip();
 const sessionProtocolSessionSummarySchema = z
     .object({
     sessionId: nonEmptyStringSchema,
     lifecycle: sessionProtocolSessionLifecycleSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolServiceTierSchema = z.enum(["priority", "flex"]);
 const sessionProtocolModelSnapshotSchema = z
     .object({
@@ -400,30 +391,29 @@ const sessionProtocolModelSnapshotSchema = z
             cacheRead: z.number().nonnegative(),
             cacheWrite: z.number().nonnegative(),
         })
-            .strict())
+            .strip())
             .optional(),
     })
-        .strict(),
+        .strip(),
     contextWindow: z.number().int().positive(),
     maxTokens: z.number().int().positive(),
     compat: z.unknown().optional(),
 })
-    .strict();
+    .strip();
 const sessionProtocolPersonaSettingsSnapshotSchema = z
     .object({
     reasoning: sessionProtocolReasoningEffortSchema.optional(),
     interleavedThinking: z.boolean().optional(),
     serviceTier: sessionProtocolServiceTierSchema.optional(),
 })
-    .strict();
+    .strip();
 const sessionProtocolSubagentSnapshotSchema = z
     .object({
     description: z.string().optional(),
     tools: z.array(nonEmptyStringSchema).optional(),
-    riskLevel: z.enum(["read-only", "read-write"]).optional(),
     launchModels: z.array(nonEmptyStringSchema).optional(),
 })
-    .strict();
+    .strip();
 const sessionProtocolPersonaSnapshotSchema = z
     .object({
     id: nonEmptyStringSchema,
@@ -435,36 +425,35 @@ const sessionProtocolPersonaSnapshotSchema = z
     skills: z.union([z.literal("*"), z.array(nonEmptyStringSchema)]),
     source: z.enum(["builtin", "user", "project"]),
 })
-    .strict();
+    .strip();
 const sessionProtocolPromptTemplateSnapshotSchema = z
     .object({
     id: nonEmptyStringSchema,
     label: z.string().optional(),
     description: z.string().optional(),
 })
-    .strict();
+    .strip();
 const sessionProtocolSkillSnapshotSchema = z
     .object({
     name: nonEmptyStringSchema,
     description: nonEmptyStringSchema,
     path: nonEmptyStringSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolContentCatalogSnapshotSchema = z
     .object({
     personas: z.array(sessionProtocolPersonaSnapshotSchema),
     prompts: z.array(sessionProtocolPromptTemplateSnapshotSchema),
     skills: z.array(sessionProtocolSkillSnapshotSchema),
 })
-    .strict();
+    .strip();
 const sessionProtocolSettingsSnapshotSchema = z
     .object({
     personaId: nonEmptyStringSchema,
-    riskLevel: z.enum(["read-only", "read-write"]),
     reasoning: sessionProtocolReasoningEffortSchema.optional(),
     serviceTier: sessionProtocolServiceTierSchema.optional(),
 })
-    .strict();
+    .strip();
 const sessionProtocolBootstrapSnapshotSchema = z
     .object({
     model: sessionProtocolModelSnapshotSchema,
@@ -473,16 +462,16 @@ const sessionProtocolBootstrapSnapshotSchema = z
         environmentTag: nonEmptyStringSchema,
         subagentPrompts: z.record(z.string(), z.string()),
     })
-        .strict(),
+        .strip(),
 })
-    .strict();
+    .strip();
 const sessionProtocolLocalExecutionEnvironmentSnapshotSchema = z
     .object({
     kind: z.literal("local"),
     cwd: nonEmptyStringSchema,
     home: nonEmptyStringSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolCloudflareSandboxExecutionEnvironmentSnapshotSchema = z
     .object({
     kind: z.literal("cloudflare-sandbox"),
@@ -491,7 +480,7 @@ const sessionProtocolCloudflareSandboxExecutionEnvironmentSnapshotSchema = z
     cwd: nonEmptyStringSchema,
     home: nonEmptyStringSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolFlySpriteExecutionEnvironmentSnapshotSchema = z
     .object({
     kind: z.literal("fly-sprite"),
@@ -500,7 +489,7 @@ const sessionProtocolFlySpriteExecutionEnvironmentSnapshotSchema = z
     cwd: nonEmptyStringSchema,
     home: nonEmptyStringSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolExecutionEnvironmentSnapshotSchema = z.discriminatedUnion("kind", [
     sessionProtocolLocalExecutionEnvironmentSnapshotSchema,
     sessionProtocolCloudflareSandboxExecutionEnvironmentSnapshotSchema,
@@ -512,14 +501,14 @@ const sessionProtocolSystemMessageSchema = z
     content: z.string(),
     timestamp: z.number().finite(),
 })
-    .strict();
+    .strip();
 const sessionProtocolDraftAssistantMessageSchema = z
     .object({
     role: z.literal("assistant"),
     content: z.array(z.unknown()),
     timestamp: z.number().finite(),
 })
-    .strict();
+    .strip();
 const sessionProtocolMessagePayloadSchema = z.union([
     sessionProtocolSystemMessageSchema,
     messageSchema,
@@ -532,14 +521,14 @@ const sessionProtocolMessageSchema = z
     modelVisible: z.boolean(),
     message: sessionProtocolMessagePayloadSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolNoticeSchema = z
     .object({
     severity: z.enum(["info", "warn", "error"]),
     text: z.string(),
     timestamp: z.number().finite(),
 })
-    .strict();
+    .strip();
 const sessionProtocolOperationSchema = z
     .object({
     kind: z.enum(["auto-compaction", "manual-compaction", "prune", "reload", "rewind"]),
@@ -550,7 +539,7 @@ const sessionProtocolOperationSchema = z
     error: z.string().optional(),
     data: z.record(z.string(), z.unknown()).optional(),
 })
-    .strict();
+    .strip();
 const sessionProtocolTimelineItemSchema = z.discriminatedUnion("type", [
     z
         .object({
@@ -558,21 +547,21 @@ const sessionProtocolTimelineItemSchema = z.discriminatedUnion("type", [
         id: nonEmptyStringSchema,
         messageId: nonEmptyStringSchema,
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("notice"),
         id: nonEmptyStringSchema,
         notice: sessionProtocolNoticeSchema,
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("operation"),
         id: nonEmptyStringSchema,
         operation: sessionProtocolOperationSchema,
     })
-        .strict(),
+        .strip(),
 ]);
 const sessionProtocolToolRunSchema = z
     .object({
@@ -584,7 +573,7 @@ const sessionProtocolToolRunSchema = z
         messageId: nonEmptyStringSchema,
         contentIndex: z.number().int().nonnegative(),
     })
-        .strict(),
+        .strip(),
     status: z.enum(["queued", "running", "succeeded", "failed", "blocked", "cancelled"]),
     startedAt: z.number().finite().optional(),
     finishedAt: z.number().finite().optional(),
@@ -593,7 +582,7 @@ const sessionProtocolToolRunSchema = z
     error: z.string().optional(),
     facetIds: z.array(nonEmptyStringSchema),
 })
-    .strict();
+    .strip();
 const sessionProtocolAgentUsageSchema = z
     .object({
     input: z.number().finite(),
@@ -603,7 +592,7 @@ const sessionProtocolAgentUsageSchema = z
     contextWindowUsageTokens: z.number().finite(),
     contextWindow: z.number().finite(),
 })
-    .strict();
+    .strip();
 const sessionProtocolAgentRunSchema = z
     .object({
     id: nonEmptyStringSchema,
@@ -623,13 +612,13 @@ const sessionProtocolAgentRunSchema = z
     finalText: z.string().optional(),
     error: z.string().optional(),
 })
-    .strict();
+    .strip();
 const sessionProtocolFacetSubjectSchema = z.discriminatedUnion("type", [
-    z.object({ type: z.literal("session") }).strict(),
-    z.object({ type: z.literal("message"), id: nonEmptyStringSchema }).strict(),
-    z.object({ type: z.literal("tool"), id: nonEmptyStringSchema }).strict(),
-    z.object({ type: z.literal("agent"), id: nonEmptyStringSchema }).strict(),
-    z.object({ type: z.literal("operation"), id: nonEmptyStringSchema }).strict(),
+    z.object({ type: z.literal("session") }).strip(),
+    z.object({ type: z.literal("message"), id: nonEmptyStringSchema }).strip(),
+    z.object({ type: z.literal("tool"), id: nonEmptyStringSchema }).strip(),
+    z.object({ type: z.literal("agent"), id: nonEmptyStringSchema }).strip(),
+    z.object({ type: z.literal("operation"), id: nonEmptyStringSchema }).strip(),
 ]);
 const sessionProtocolFacetSchema = z
     .object({
@@ -639,7 +628,7 @@ const sessionProtocolFacetSchema = z
     version: z.number().int().positive(),
     data: z.record(z.string(), z.unknown()),
 })
-    .strict();
+    .strip();
 const sessionProtocolSnapshotSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
@@ -656,7 +645,7 @@ const sessionProtocolSnapshotSchema = z
     agents: z.record(nonEmptyStringSchema, sessionProtocolAgentRunSchema),
     facets: z.record(nonEmptyStringSchema, sessionProtocolFacetSchema),
 })
-    .strict()
+    .strip()
     .superRefine((snapshot, ctx) => {
     const messageIds = new Set();
     for (const message of snapshot.messages) {
@@ -706,32 +695,32 @@ const sessionProtocolChangeSchema = z.discriminatedUnion("type", [
         type: z.literal("lifecycle.set"),
         lifecycle: sessionProtocolSessionLifecycleSchema,
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("cost.set"),
         costTotal: z.number().nonnegative(),
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("settings.set"),
         settings: sessionProtocolSettingsSnapshotSchema,
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("message.append"),
         message: sessionProtocolMessageSchema,
         timelineItem: sessionProtocolTimelineItemSchema.optional(),
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("message.replace"),
         message: sessionProtocolMessageSchema,
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("message.content.append"),
@@ -740,61 +729,61 @@ const sessionProtocolChangeSchema = z.discriminatedUnion("type", [
         thinking: z.string().optional(),
         timestamp: z.number().finite(),
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("timeline.append"),
         item: sessionProtocolTimelineItemSchema,
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("timeline.replace"),
         item: sessionProtocolTimelineItemSchema,
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("timeline.remove"),
         id: nonEmptyStringSchema,
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("tool.set"),
         tool: sessionProtocolToolRunSchema,
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("tool.remove"),
         id: nonEmptyStringSchema,
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("agent.set"),
         agent: sessionProtocolAgentRunSchema,
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("agent.remove"),
         id: nonEmptyStringSchema,
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("facet.set"),
         facet: sessionProtocolFacetSchema,
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("facet.remove"),
         id: nonEmptyStringSchema,
     })
-        .strict(),
+        .strip(),
 ]);
 const sessionProtocolDeltaSchema = z.discriminatedUnion("type", [
     z
@@ -802,13 +791,13 @@ const sessionProtocolDeltaSchema = z.discriminatedUnion("type", [
         type: z.literal("snapshot.patch"),
         changes: z.array(sessionProtocolChangeSchema),
     })
-        .strict(),
+        .strip(),
     z
         .object({
         type: z.literal("snapshot.reset"),
         snapshot: sessionProtocolSnapshotSchema,
     })
-        .strict(),
+        .strip(),
 ]);
 const sessionProtocolDeltaMessageSchema = z
     .object({
@@ -820,7 +809,7 @@ const sessionProtocolDeltaMessageSchema = z
     reason: sessionProtocolDeltaReasonSchema,
     delta: sessionProtocolDeltaSchema,
 })
-    .strict()
+    .strip()
     .superRefine((message, ctx) => {
     if (message.delta.type === "snapshot.patch" && message.fromRevision === null) {
         ctx.addIssue({
@@ -871,9 +860,9 @@ const sessionProtocolEphemeralAgentThreadUpdateEventSchema = z
         usage: sessionProtocolAgentUsageSchema,
         lastActivityText: z.string().optional(),
     })
-        .strict(),
+        .strip(),
 })
-    .strict();
+    .strip();
 const sessionProtocolEphemeralEventSchema = sessionProtocolEphemeralAgentThreadUpdateEventSchema;
 const sessionProtocolEphemeralMessageSchema = z
     .object({
@@ -882,20 +871,20 @@ const sessionProtocolEphemeralMessageSchema = z
     sessionId: nonEmptyStringSchema,
     event: sessionProtocolEphemeralEventSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolPendingUserMessageSchema = z
     .object({
     id: nonEmptyStringSchema,
     mode: z.enum(["queue", "steer"]),
     text: nonEmptyStringSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolPendingUserMessagesStateSchema = z
     .object({
     revision: z.number().int().positive(),
     messages: z.array(sessionProtocolPendingUserMessageSchema),
 })
-    .strict()
+    .strip()
     .superRefine((state, ctx) => {
     const ids = new Set();
     for (const message of state.messages) {
@@ -916,30 +905,30 @@ const sessionProtocolPendingUserMessagesMessageSchema = z
     sessionId: nonEmptyStringSchema,
     state: sessionProtocolPendingUserMessagesStateSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolInitializeResultSchema = z
     .object({
     protocolVersion: z.literal(SESSION_PROTOCOL_VERSION),
     methods: sessionProtocolMethodListSchema,
     alreadyInitialized: z.boolean(),
 })
-    .strict();
+    .strip();
 const sessionProtocolCreateResultSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolObserveResultSchema = z
     .object({
     snapshot: sessionProtocolSnapshotSchema,
     pendingUserMessages: sessionProtocolPendingUserMessagesStateSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolListResultSchema = z
     .object({
     sessions: z.array(sessionProtocolSessionSummarySchema),
 })
-    .strict();
+    .strip();
 const sessionProtocolSubmitResultSchema = z
     .object({
     turn: z
@@ -950,30 +939,30 @@ const sessionProtocolSubmitResultSchema = z
             reason: z.literal("auto-compaction-failed"),
             message: z.string(),
         })
-            .strict()
+            .strip()
             .optional(),
     })
-        .strict(),
+        .strip(),
 })
-    .strict();
+    .strip();
 const sessionProtocolTurnResultSchema = sessionProtocolSubmitResultSchema;
 const sessionProtocolRetryResultSchema = sessionProtocolTurnResultSchema;
 const sessionProtocolSubmitWithUserResultSchema = sessionProtocolTurnResultSchema
     .extend({
     userHistoryEntryId: nonEmptyStringSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolCancelPendingMessagesResultSchema = z
     .object({
     cancelled: z.array(sessionProtocolPendingUserMessageSchema),
 })
-    .strict();
+    .strip();
 const sessionProtocolRecordResultSchema = z
     .object({
     snapshot: sessionProtocolSnapshotSchema,
     userHistoryEntryId: nonEmptyStringSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolExecResultSchema = z
     .object({
     output: z.string(),
@@ -982,26 +971,26 @@ const sessionProtocolExecResultSchema = z
     exitCode: z.number().int().nullable(),
     truncated: z.boolean(),
 })
-    .strict();
+    .strip();
 const sessionProtocolInterruptResultSchema = z
     .object({
     interrupted: z.boolean(),
     isTurnRunning: z.boolean(),
 })
-    .strict();
+    .strip();
 const sessionProtocolSettingsUpdateResultSchema = z
     .object({
     revision: z.number().int().positive(),
     settings: sessionProtocolSettingsSnapshotSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolCompactResultSchema = z
     .object({
     snapshot: sessionProtocolSnapshotSchema,
     compactionMessage: nonEmptyStringSchema,
     includedLastAssistant: z.boolean(),
 })
-    .strict();
+    .strip();
 const sessionProtocolPruneResultSchema = z
     .object({
     snapshot: sessionProtocolSnapshotSchema,
@@ -1012,7 +1001,7 @@ const sessionProtocolPruneResultSchema = z
     editResultsPruned: z.number().int().nonnegative(),
     bytesPruned: z.number().int().nonnegative(),
 })
-    .strict();
+    .strip();
 const sessionProtocolRewindResultSchema = z
     .object({
     snapshot: sessionProtocolSnapshotSchema,
@@ -1020,7 +1009,7 @@ const sessionProtocolRewindResultSchema = z
     text: z.string(),
     removedEntryIds: z.array(nonEmptyStringSchema),
 })
-    .strict();
+    .strip();
 const sessionProtocolReloadResultSchema = z
     .object({
     snapshot: sessionProtocolSnapshotSchema,
@@ -1031,56 +1020,56 @@ const sessionProtocolReloadResultSchema = z
         prompts: z.number().int().nonnegative(),
         skills: z.number().int().nonnegative(),
     })
-        .strict(),
+        .strip(),
 })
-    .strict();
+    .strip();
 const sessionProtocolResolvePromptResultSchema = z
     .object({
     promptId: nonEmptyStringSchema,
     text: z.string(),
 })
-    .strict();
+    .strip();
 const sessionProtocolAutocompletePathsResultSchema = z
     .object({
     paths: z.array(z.string()),
 })
-    .strict();
+    .strip();
 const sessionProtocolUnobserveResultSchema = z
     .object({
     unobserved: z.literal(true),
 })
-    .strict();
+    .strip();
 const sessionProtocolTerminateSubagentResultSchema = z
     .object({
     found: z.boolean(),
 })
-    .strict();
+    .strip();
 const sessionProtocolEphemeralCreateResultSchema = z
     .object({
     contextId: nonEmptyStringSchema,
 })
-    .strict();
+    .strip();
 const sessionProtocolEphemeralSubmitResultSchema = z
     .object({
     threadId: nonEmptyStringSchema,
     response: z.string(),
 })
-    .strict();
+    .strip();
 const sessionProtocolEphemeralCloseResultSchema = z
     .object({
     closed: z.boolean(),
 })
-    .strict();
+    .strip();
 const sessionProtocolClientToolAckResultSchema = z
     .object({
     accepted: z.boolean(),
 })
-    .strict();
+    .strip();
 const sessionProtocolClientToolResultResultSchema = z
     .object({
     accepted: z.boolean(),
 })
-    .strict();
+    .strip();
 export function isSessionProtocolMethod(value) {
     return typeof value === "string" && SESSION_PROTOCOL_METHOD_SET.has(value);
 }
@@ -1430,13 +1419,6 @@ export function parseSessionProtocolRequestLine(line) {
                 error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.invalidRequest, "request id must be a non-empty string"),
             };
         }
-        if (hasIssue(requestEnvelope.error, [], "unrecognized_keys")) {
-            return {
-                ok: false,
-                id: requestId,
-                error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.invalidRequest, "request contains unsupported top-level fields"),
-            };
-        }
         if (hasIssue(requestEnvelope.error, ["version"])) {
             const parsedVersionField = sessionProtocolVersionFieldSchema.safeParse(parsed);
             const version = parsedVersionField.success ? parsedVersionField.data.version : undefined;
@@ -1602,8 +1584,6 @@ export function validateSessionProtocolParams(method, params) {
         case "session.snapshot":
         case "session.reload":
             return validateSessionIdParams(method, params);
-        case "session.setRisk":
-            return validateSetRiskParams(params);
         case "session.setReasoning":
             return validateSetReasoningParams(params);
         case "session.setPersona":
@@ -1641,7 +1621,6 @@ export function validateSessionProtocolResult(method, result) {
         case "session.observe":
             return validateResult(method, result, sessionProtocolObserveResultSchema);
         case "session.snapshot":
-        case "session.setRisk":
         case "session.setPersona":
             return validateResult(method, result, sessionProtocolSnapshotSchema);
         case "session.setReasoning":
@@ -1695,11 +1674,9 @@ function validateSessionIdParams(method, params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? `${method} params must be an object`
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? `${method} params only support sessionId`
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? `${method} params.sessionId must be a non-empty string`
-                    : `${method} params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["sessionId"])
+                ? `${method} params.sessionId must be a non-empty string`
+                : `${method} params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return {
@@ -1714,7 +1691,7 @@ function validateInitializeParams(params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "initialize params must be an object with client metadata"
-            : hasIssue(parsed.error, ["client"]) || hasIssue(parsed.error, [], "unrecognized_keys")
+            : hasIssue(parsed.error, ["client"])
                 ? "initialize.client must be an object with name/version strings and optional tools"
                 : hasIssue(parsed.error, ["client", "name"])
                     ? "initialize.client.name must be a non-empty string"
@@ -1739,15 +1716,13 @@ function validateUserMessageParams(method, params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? `${method} params must be an object`
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? `${method} params only support sessionId, text, and optional historyEntryId`
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? `${method} params.sessionId must be a non-empty string`
-                    : hasIssue(parsed.error, ["text"])
-                        ? `${method} params.text must be a string`
-                        : hasIssue(parsed.error, ["historyEntryId"])
-                            ? `${method} params.historyEntryId must be a non-empty string when provided`
-                            : `${method} params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["sessionId"])
+                ? `${method} params.sessionId must be a non-empty string`
+                : hasIssue(parsed.error, ["text"])
+                    ? `${method} params.text must be a string`
+                    : hasIssue(parsed.error, ["historyEntryId"])
+                        ? `${method} params.historyEntryId must be a non-empty string when provided`
+                        : `${method} params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return {
@@ -1766,15 +1741,13 @@ function validateRecordParams(params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "session.record params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.record params only support sessionId, text, and optional historyEntryId"
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? "session.record params.sessionId must be a non-empty string"
-                    : hasIssue(parsed.error, ["text"])
-                        ? "session.record params.text must be a string"
-                        : hasIssue(parsed.error, ["historyEntryId"])
-                            ? "session.record params.historyEntryId must be a non-empty string when provided"
-                            : `session.record params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.record params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["text"])
+                    ? "session.record params.text must be a string"
+                    : hasIssue(parsed.error, ["historyEntryId"])
+                        ? "session.record params.historyEntryId must be a non-empty string when provided"
+                        : `session.record params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return {
@@ -1793,17 +1766,15 @@ function validateExecParams(params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "session.exec params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.exec params only support sessionId, command, optional cwd, and optional timeoutMs"
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? "session.exec params.sessionId must be a non-empty string"
-                    : hasIssue(parsed.error, ["command"])
-                        ? "session.exec params.command must be a non-empty string"
-                        : hasIssue(parsed.error, ["cwd"])
-                            ? "session.exec params.cwd must be a non-empty string when provided"
-                            : hasIssue(parsed.error, ["timeoutMs"])
-                                ? "session.exec params.timeoutMs must be a positive integer when provided"
-                                : `session.exec params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.exec params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["command"])
+                    ? "session.exec params.command must be a non-empty string"
+                    : hasIssue(parsed.error, ["cwd"])
+                        ? "session.exec params.cwd must be a non-empty string when provided"
+                        : hasIssue(parsed.error, ["timeoutMs"])
+                            ? "session.exec params.timeoutMs must be a positive integer when provided"
+                            : `session.exec params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return {
@@ -1816,40 +1787,16 @@ function validateExecParams(params) {
         },
     };
 }
-function validateSetRiskParams(params) {
-    const parsed = sessionProtocolSetRiskParamsSchema.safeParse(params);
-    if (!parsed.success) {
-        const message = hasIssue(parsed.error, [], "invalid_type")
-            ? "session.setRisk params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.setRisk params only support sessionId and riskLevel"
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? "session.setRisk params.sessionId must be a non-empty string"
-                    : hasIssue(parsed.error, ["riskLevel"])
-                        ? "session.setRisk params.riskLevel must be 'read-only' or 'read-write'"
-                        : `session.setRisk params are invalid: ${formatZodError(parsed.error)}`;
-        return invalidParams(message);
-    }
-    return {
-        ok: true,
-        value: {
-            sessionId: parsed.data.sessionId,
-            riskLevel: parsed.data.riskLevel,
-        },
-    };
-}
 function validateSetReasoningParams(params) {
     const parsed = sessionProtocolSetReasoningParamsSchema.safeParse(params);
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "session.setReasoning params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.setReasoning params only support sessionId and reasoning"
-                : 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, xhigh, or max"
-                        : `session.setReasoning params are invalid: ${formatZodError(parsed.error)}`;
+            : 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, xhigh, or max"
+                    : `session.setReasoning params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return {
@@ -1865,13 +1812,11 @@ function validateSetPersonaParams(params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "session.setPersona params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.setPersona params only support sessionId and personaId"
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? "session.setPersona params.sessionId must be a non-empty string"
-                    : hasIssue(parsed.error, ["personaId"])
-                        ? "session.setPersona params.personaId must be a non-empty string"
-                        : `session.setPersona params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.setPersona params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["personaId"])
+                    ? "session.setPersona params.personaId must be a non-empty string"
+                    : `session.setPersona params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return {
@@ -1887,13 +1832,11 @@ function validateResolvePromptParams(params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "session.resolvePrompt params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.resolvePrompt params only support sessionId and promptId"
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? "session.resolvePrompt params.sessionId must be a non-empty string"
-                    : hasIssue(parsed.error, ["promptId"])
-                        ? "session.resolvePrompt params.promptId must be a non-empty string"
-                        : `session.resolvePrompt params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.resolvePrompt params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["promptId"])
+                    ? "session.resolvePrompt params.promptId must be a non-empty string"
+                    : `session.resolvePrompt params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return {
@@ -1909,15 +1852,13 @@ function validateAutocompletePathsParams(params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "session.autocompletePaths params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.autocompletePaths params only support sessionId, query, and limit"
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? "session.autocompletePaths params.sessionId must be a non-empty string"
-                    : hasIssue(parsed.error, ["query"])
-                        ? "session.autocompletePaths params.query must be a string"
-                        : hasIssue(parsed.error, ["limit"])
-                            ? "session.autocompletePaths params.limit must be a positive integer up to 100"
-                            : `session.autocompletePaths params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.autocompletePaths params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["query"])
+                    ? "session.autocompletePaths params.query must be a string"
+                    : hasIssue(parsed.error, ["limit"])
+                        ? "session.autocompletePaths params.limit must be a positive integer up to 100"
+                        : `session.autocompletePaths params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return {
@@ -1934,15 +1875,13 @@ function validateCompactParams(params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "session.compact params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.compact params only support sessionId, mode, and optional guidance"
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? "session.compact params.sessionId must be a non-empty string"
-                    : hasIssue(parsed.error, ["mode"])
-                        ? "session.compact params.mode must be 'summary-only' or 'summary-and-last'"
-                        : hasIssue(parsed.error, ["guidance"])
-                            ? "session.compact params.guidance must be a string when provided"
-                            : `session.compact params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.compact params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["mode"])
+                    ? "session.compact params.mode must be 'summary-only' or 'summary-and-last'"
+                    : hasIssue(parsed.error, ["guidance"])
+                        ? "session.compact params.guidance must be a string when provided"
+                        : `session.compact params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return {
@@ -1959,17 +1898,15 @@ function validatePruneParams(params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "session.prune params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.prune params only support sessionId, strategy, fraction, and optional guidance"
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? "session.prune params.sessionId must be a non-empty string"
-                    : hasIssue(parsed.error, ["strategy"])
-                        ? "session.prune params.strategy must be 'earliest', 'largest', or 'smart'"
-                        : hasIssue(parsed.error, ["fraction"])
-                            ? "session.prune params.fraction must be a number between 0 and 1"
-                            : hasIssue(parsed.error, ["guidance"])
-                                ? "session.prune params.guidance must be a string when provided"
-                                : `session.prune params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.prune params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["strategy"])
+                    ? "session.prune params.strategy must be 'earliest', 'largest', or 'smart'"
+                    : hasIssue(parsed.error, ["fraction"])
+                        ? "session.prune params.fraction must be a number between 0 and 1"
+                        : hasIssue(parsed.error, ["guidance"])
+                            ? "session.prune params.guidance must be a string when provided"
+                            : `session.prune params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return {
@@ -1987,13 +1924,11 @@ function validateRewindParams(params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "session.rewind params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.rewind params only support sessionId and historyEntryId"
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? "session.rewind params.sessionId must be a non-empty string"
-                    : hasIssue(parsed.error, ["historyEntryId"])
-                        ? "session.rewind params.historyEntryId must be a non-empty string"
-                        : `session.rewind params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.rewind params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["historyEntryId"])
+                    ? "session.rewind params.historyEntryId must be a non-empty string"
+                    : `session.rewind params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return {
@@ -2009,13 +1944,11 @@ function validateTerminateSubagentParams(params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "session.terminateSubagent params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.terminateSubagent params only support sessionId and subagentId"
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? "session.terminateSubagent params.sessionId must be a non-empty string"
-                    : hasIssue(parsed.error, ["subagentId"])
-                        ? "session.terminateSubagent params.subagentId must be a non-empty string"
-                        : `session.terminateSubagent params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.terminateSubagent params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["subagentId"])
+                    ? "session.terminateSubagent params.subagentId must be a non-empty string"
+                    : `session.terminateSubagent params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return {
@@ -2031,17 +1964,13 @@ function validateEphemeralCreateParams(params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "session.ephemeral.create params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.ephemeral.create params only support sessionId, instructions, tools, and riskLevel"
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? "session.ephemeral.create params.sessionId must be a non-empty string"
-                    : hasIssue(parsed.error, ["instructions"])
-                        ? "session.ephemeral.create params.instructions must be a non-empty string"
-                        : hasIssue(parsed.error, ["tools"])
-                            ? "session.ephemeral.create params.tools are invalid"
-                            : hasIssue(parsed.error, ["riskLevel"])
-                                ? "session.ephemeral.create params.riskLevel must be read-only or read-write"
-                                : `session.ephemeral.create params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.ephemeral.create params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["instructions"])
+                    ? "session.ephemeral.create params.instructions must be a non-empty string"
+                    : hasIssue(parsed.error, ["tools"])
+                        ? "session.ephemeral.create params.tools are invalid"
+                        : `session.ephemeral.create params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return { ok: true, value: parsed.data };
@@ -2051,19 +1980,17 @@ function validateEphemeralSubmitParams(params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "session.ephemeral.submit params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.ephemeral.submit params only support sessionId, contextId, threadId, optional forkFromThreadId, and message"
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? "session.ephemeral.submit params.sessionId must be a non-empty string"
-                    : hasIssue(parsed.error, ["contextId"])
-                        ? "session.ephemeral.submit params.contextId must be a non-empty string"
-                        : hasIssue(parsed.error, ["threadId"])
-                            ? "session.ephemeral.submit params.threadId must be a non-empty string"
-                            : hasIssue(parsed.error, ["forkFromThreadId"])
-                                ? "session.ephemeral.submit params.forkFromThreadId must be a non-empty string when provided"
-                                : hasIssue(parsed.error, ["message"])
-                                    ? "session.ephemeral.submit params.message must be a non-empty string"
-                                    : `session.ephemeral.submit params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.ephemeral.submit params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["contextId"])
+                    ? "session.ephemeral.submit params.contextId must be a non-empty string"
+                    : hasIssue(parsed.error, ["threadId"])
+                        ? "session.ephemeral.submit params.threadId must be a non-empty string"
+                        : hasIssue(parsed.error, ["forkFromThreadId"])
+                            ? "session.ephemeral.submit params.forkFromThreadId must be a non-empty string when provided"
+                            : hasIssue(parsed.error, ["message"])
+                                ? "session.ephemeral.submit params.message must be a non-empty string"
+                                : `session.ephemeral.submit params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return {
@@ -2084,13 +2011,11 @@ function validateEphemeralCloseParams(params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "session.ephemeral.close params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.ephemeral.close params only support sessionId and contextId"
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? "session.ephemeral.close params.sessionId must be a non-empty string"
-                    : hasIssue(parsed.error, ["contextId"])
-                        ? "session.ephemeral.close params.contextId must be a non-empty string"
-                        : `session.ephemeral.close params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.ephemeral.close params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["contextId"])
+                    ? "session.ephemeral.close params.contextId must be a non-empty string"
+                    : `session.ephemeral.close params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return { ok: true, value: parsed.data };
@@ -2100,13 +2025,11 @@ function validateClientToolAckParams(params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "session.clientTool.ack params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.clientTool.ack params only support sessionId and callId"
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? "session.clientTool.ack params.sessionId must be a non-empty string"
-                    : hasIssue(parsed.error, ["callId"])
-                        ? "session.clientTool.ack params.callId must be a non-empty string"
-                        : `session.clientTool.ack params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.clientTool.ack params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["callId"])
+                    ? "session.clientTool.ack params.callId must be a non-empty string"
+                    : `session.clientTool.ack params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return { ok: true, value: parsed.data };
@@ -2116,13 +2039,11 @@ function validateClientToolResultParams(params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "session.clientTool.result params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.clientTool.result params only support sessionId, callId, ok, content, and error"
-                : hasIssue(parsed.error, ["sessionId"])
-                    ? "session.clientTool.result params.sessionId must be a non-empty string"
-                    : hasIssue(parsed.error, ["callId"])
-                        ? "session.clientTool.result params.callId must be a non-empty string"
-                        : `session.clientTool.result params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["sessionId"])
+                ? "session.clientTool.result params.sessionId must be a non-empty string"
+                : hasIssue(parsed.error, ["callId"])
+                    ? "session.clientTool.result params.callId must be a non-empty string"
+                    : `session.clientTool.result params are invalid: ${formatZodError(parsed.error)}`;
         return invalidParams(message);
     }
     return { ok: true, value: parsed.data };
@@ -2132,21 +2053,17 @@ function validateCreateParams(params) {
     if (!parsed.success) {
         const message = hasIssue(parsed.error, [], "invalid_type")
             ? "session.create params must be an object"
-            : hasIssue(parsed.error, [], "unrecognized_keys")
-                ? "session.create params only support executionEnvironment, personaId, riskLevel, and reasoning"
-                : hasIssue(parsed.error, ["executionEnvironment"])
-                    ? "session.create params.executionEnvironment must be an object"
-                    : hasIssue(parsed.error, ["executionEnvironment", "kind"])
-                        ? "session.create params.executionEnvironment.kind must be 'local', 'cloudflare-sandbox', or 'fly-sprite'"
-                        : hasIssue(parsed.error, ["executionEnvironment", "cwd"])
-                            ? "session.create params.executionEnvironment.cwd must be an absolute path"
-                            : hasIssue(parsed.error, ["personaId"])
-                                ? "session.create params.personaId must be a non-empty string"
-                                : 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, xhigh, or max"
-                                        : `session.create params are invalid: ${formatZodError(parsed.error)}`;
+            : hasIssue(parsed.error, ["executionEnvironment"])
+                ? "session.create params.executionEnvironment must be an object"
+                : hasIssue(parsed.error, ["executionEnvironment", "kind"])
+                    ? "session.create params.executionEnvironment.kind must be 'local', 'cloudflare-sandbox', or 'fly-sprite'"
+                    : hasIssue(parsed.error, ["executionEnvironment", "cwd"])
+                        ? "session.create params.executionEnvironment.cwd must be an absolute path"
+                        : hasIssue(parsed.error, ["personaId"])
+                            ? "session.create params.personaId must be a non-empty string"
+                            : hasIssue(parsed.error, ["reasoning"])
+                                ? "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);
     }
     return {
@@ -2192,9 +2109,6 @@ function parseSessionProtocolDeltaMessage(payload) {
     const fail = (message) => outgoingParseFailure("session.delta", null, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, message);
     const deltaMessage = sessionProtocolDeltaMessageSchema.safeParse(payload);
     if (!deltaMessage.success) {
-        if (hasIssue(deltaMessage.error, [], "unrecognized_keys")) {
-            return fail("session.delta message contains unsupported fields");
-        }
         if (hasIssue(deltaMessage.error, ["sessionId"])) {
             return fail("session.delta.sessionId must be a non-empty string");
         }
@@ -2233,9 +2147,6 @@ function parseSessionProtocolClientToolMessage(payload) {
     const fail = (message) => outgoingParseFailure(messageType, null, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, message);
     const message = sessionProtocolClientToolMessageSchema.safeParse(payload);
     if (!message.success) {
-        if (hasIssue(message.error, [], "unrecognized_keys")) {
-            return fail(`${String(messageType)} message contains unsupported fields`);
-        }
         return fail(`invalid ${String(messageType)} message: ${formatZodError(message.error)}`);
     }
     return {
@@ -2247,9 +2158,6 @@ function parseSessionProtocolEphemeralMessage(payload) {
     const fail = (message) => outgoingParseFailure("session.ephemeral", null, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, message);
     const ephemeralMessage = sessionProtocolEphemeralMessageSchema.safeParse(payload);
     if (!ephemeralMessage.success) {
-        if (hasIssue(ephemeralMessage.error, [], "unrecognized_keys")) {
-            return fail("session.ephemeral message contains unsupported fields");
-        }
         if (hasIssue(ephemeralMessage.error, ["sessionId"])) {
             return fail("session.ephemeral.sessionId must be a non-empty string");
         }
@@ -2267,9 +2175,6 @@ 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");
         }
@@ -2296,9 +2201,6 @@ function parseSessionProtocolResponseMessage(payload) {
     if (ok === true) {
         const successResponse = sessionProtocolResponseSuccessSchema.safeParse(payload);
         if (!successResponse.success) {
-            if (hasIssue(successResponse.error, [], "unrecognized_keys")) {
-                return fail("successful response must only include result payload");
-            }
             if (hasIssue(successResponse.error, ["result"], "invalid_type")) {
                 return fail("successful response must include result");
             }
@@ -2323,9 +2225,6 @@ function parseSessionProtocolResponseMessage(payload) {
     }
     const errorResponse = sessionProtocolResponseErrorSchema.safeParse(payload);
     if (!errorResponse.success) {
-        if (hasIssue(errorResponse.error, [], "unrecognized_keys")) {
-            return fail("error response must only include error payload");
-        }
         if (hasIssue(errorResponse.error, ["error"])) {
             return fail("error response.error must be an object");
         }