BaseRequestParamsSchema, BaseNotificationParamsSchema, RequestMetaSchema, structuredContent and metadata to have passthrough

Author: ihrpr

scripts/generateStrictTypes.ts

@@ -36,6 +36,16 @@ const patternsToKeepOpen = [
   /_meta: z\.optional\(z\.object\(\{\}\)\.strip\(\)\)/g,
   // Keep JSON Schema properties open as they can have arbitrary fields
   /properties: z\.optional\(z\.object\(\{\}\)\.strip\(\)\)/g,
+  // Keep BaseRequestParamsSchema passthrough for JSON-RPC param compatibility
+  /const BaseRequestParamsSchema = z\s*\n\s*\.object\([\s\S]*?\)\s*\n\s*\.strip\(\)/g,
+  // Keep BaseNotificationParamsSchema passthrough for JSON-RPC param compatibility  
+  /const BaseNotificationParamsSchema = z\s*\n\s*\.object\([\s\S]*?\)\s*\n\s*\.strip\(\)/g,
+  // Keep RequestMetaSchema passthrough for extensibility
+  /const RequestMetaSchema = z\s*\n\s*\.object\([\s\S]*?\)\s*\n\s*\.strip\(\)/g,
+  // Keep structuredContent passthrough for tool-specific output
+  /structuredContent: z\.object\(\{\}\)\.strip\(\)\.optional\(\)/g,
+  // Keep metadata passthrough for provider-specific data in sampling
+  /metadata: z\.optional\(z\.object\(\{\}\)\.strip\(\)\)/g,
 ];
 
 // Revert strip back to passthrough for these special cases
@@ -48,10 +58,15 @@ patternsToKeepOpen.forEach(pattern => {
 // Add a comment explaining the difference
 const explanation = `
 /**
- * Note: The following fields remain open (using .passthrough()):
+ * Note: The following remain open (using .passthrough()):
  * - experimental: Designed for protocol extensions
  * - _meta: Designed for arbitrary metadata
  * - properties: JSON Schema properties that can have arbitrary fields
+ * - BaseRequestParamsSchema: Required for JSON-RPC param compatibility
+ * - BaseNotificationParamsSchema: Required for JSON-RPC param compatibility
+ * - RequestMetaSchema: Required for protocol extensibility
+ * - structuredContent: Tool-specific output that can have arbitrary fields
+ * - metadata: Provider-specific metadata in sampling requests
  * 
  * All other objects use .strip() to remove unknown properties while
  * maintaining compatibility with extended protocols.

src/strictTypes.ts

@@ -29,10 +29,15 @@ import { z, ZodTypeAny } from "zod";
 import { AuthInfo } from "./server/auth/types.js";
 
 /**
- * Note: The following fields remain open (using .passthrough()):
+ * Note: The following remain open (using .passthrough()):
  * - experimental: Designed for protocol extensions
  * - _meta: Designed for arbitrary metadata
  * - properties: JSON Schema properties that can have arbitrary fields
+ * - BaseRequestParamsSchema: Required for JSON-RPC param compatibility
+ * - BaseNotificationParamsSchema: Required for JSON-RPC param compatibility
+ * - RequestMetaSchema: Required for protocol extensibility
+ * - structuredContent: Tool-specific output that can have arbitrary fields
+ * - metadata: Provider-specific metadata in sampling requests
  * 
  * All other objects use .strip() to remove unknown properties while
  * maintaining compatibility with extended protocols.
@@ -67,13 +72,13 @@ const RequestMetaSchema = z
      */
     progressToken: z.optional(ProgressTokenSchema),
   })
-  .strip();
+  .passthrough();
 
 const BaseRequestParamsSchema = z
   .object({
     _meta: z.optional(RequestMetaSchema),
   })
-  .strip();
+  .passthrough();
 
 export const RequestSchema = z.object({
   method: z.string(),
@@ -88,7 +93,7 @@ const BaseNotificationParamsSchema = z
      */
     _meta: z.optional(z.object({}).passthrough()),
   })
-  .strip();
+  .passthrough();
 
 export const NotificationSchema = z.object({
   method: z.string(),
@@ -1005,7 +1010,7 @@ export const CallToolResultSchema = ResultSchema.extend({
    *
    * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema.
    */
-  structuredContent: z.object({}).strip().optional(),
+  structuredContent: z.object({}).passthrough().optional(),
 
   /**
    * Whether the tool call ended in an error.
@@ -1171,7 +1176,7 @@ export const CreateMessageRequestSchema = RequestSchema.extend({
     /**
      * Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific.
      */
-    metadata: z.optional(z.object({}).strip()),
+    metadata: z.optional(z.object({}).passthrough()),
     /**
      * The server's preferences for which model to select.
      */

src/types.test.ts

@@ -5,8 +5,10 @@ import {
     ContentBlockSchema,
     PromptMessageSchema,
     CallToolResultSchema,
-    CompleteRequestSchema
-} from "./types.js";
+    CompleteRequestSchema,
+    JSONRPCRequestSchema,
+    ReadResourceRequestSchema
+} from "./strictTypes.js";
 
 describe("Types", () => {
 
@@ -312,4 +314,39 @@ describe("Types", () => {
             }
         });
     });
+
+    describe("JSONRPCRequest validation", () => {
+        test("should preserve method-specific params for later validation", () => {
+            // This test verifies that JSONRPCRequestSchema preserves method-specific
+            // parameters (like 'uri' for resources/read) so they can be validated
+            // by the specific request schema later in the processing pipeline.
+            
+            const jsonRpcRequest = {
+                jsonrpc: "2.0",
+                id: 1,
+                method: "resources/read",
+                params: {
+                    uri: "file:///test.txt",
+                    _meta: { progressToken: "token" }
+                }
+            };
+
+            // Step 1: Validate as a generic JSON-RPC request
+            const jsonRpcResult = JSONRPCRequestSchema.safeParse(jsonRpcRequest);
+            expect(jsonRpcResult.success).toBe(true);
+            
+            if (jsonRpcResult.success) {
+                // The params should still contain method-specific fields like 'uri'
+                // even though they're not defined in the base schema
+                expect(jsonRpcResult.data.params).toBeDefined();
+                const params = jsonRpcResult.data.params as { uri: string; _meta?: { progressToken?: string } };
+                expect(params.uri).toBe("file:///test.txt");
+                expect(params._meta?.progressToken).toBe("token");
+            }
+
+            // Step 2: The same request should also validate as ReadResourceRequest
+            const readResourceResult = ReadResourceRequestSchema.safeParse(jsonRpcRequest);
+            expect(readResourceResult.success).toBe(true);
+        });
+    });
 });