fix(core): send transformed parsed.data in sendCustom* schema-bundle overloads

The schema-bundle overload validated params via parseSchema but discarded
parsed.data and sent the raw input over the wire. Zod transforms (.trim(),
.toLowerCase()) and defaults (.default(n)) were silently dropped.

Now sends parsed.data after successful validation. The overload's params
type changed from SchemaOutput<P> to SchemaInput<P> since callers pass
pre-transform input. Adds SchemaInput<T> = z.input<T> to schema utils.

Author: felixweinberger

packages/core/src/shared/protocol.ts

@@ -46,7 +46,7 @@ import {
     ProtocolErrorCode,
     SUPPORTED_PROTOCOL_VERSIONS
 } from '../types/index.js';
-import type { AnySchema, SchemaOutput } from '../util/schema.js';
+import type { AnySchema, SchemaInput, SchemaOutput } from '../util/schema.js';
 import { parseSchema } from '../util/schema.js';
 import type { TaskContext, TaskManagerHost, TaskManagerOptions, TaskRequestOptions } from './taskManager.js';
 import { NullTaskManager, TaskManager } from './taskManager.js';
@@ -1146,7 +1146,7 @@ export abstract class Protocol<ContextT extends BaseContext> {
      */
     sendCustomRequest<P extends AnySchema, R extends AnySchema>(
         method: string,
-        params: SchemaOutput<P>,
+        params: SchemaInput<P>,
         schemas: { params: P; result: R },
         options?: RequestOptions
     ): Promise<SchemaOutput<R>>;
@@ -1168,6 +1168,7 @@ export abstract class Protocol<ContextT extends BaseContext> {
             if (!parsed.success) {
                 throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid params for ${method}: ${parsed.error.message}`);
             }
+            params = parsed.data as Record<string, unknown> | undefined;
             resultSchema = schemaOrBundle.result;
         } else {
             resultSchema = schemaOrBundle;
@@ -1189,7 +1190,7 @@ export abstract class Protocol<ContextT extends BaseContext> {
      */
     sendCustomNotification<P extends AnySchema>(
         method: string,
-        params: SchemaOutput<P>,
+        params: SchemaInput<P>,
         schemas: { params: P },
         options?: NotificationOptions
     ): Promise<void>;
@@ -1206,6 +1207,7 @@ export abstract class Protocol<ContextT extends BaseContext> {
             if (!parsed.success) {
                 throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid params for ${method}: ${parsed.error.message}`);
             }
+            params = parsed.data as Record<string, unknown> | undefined;
             options = maybeOptions;
         } else {
             options = schemasOrOptions;

packages/core/src/util/schema.ts

@@ -20,6 +20,11 @@ export type AnyObjectSchema = z.core.$ZodObject;
  */
 export type SchemaOutput<T extends AnySchema> = z.output<T>;
 
+/**
+ * Extracts the input type from a Zod schema (pre-transform / pre-default).
+ */
+export type SchemaInput<T extends AnySchema> = z.input<T>;
+
 /**
  * Parses data against a Zod schema (synchronous).
  * Returns a discriminated union with success/error.

packages/core/test/shared/customMethods.test.ts

@@ -191,6 +191,18 @@ describe('sendCustomRequest', () => {
             })
         ).rejects.toSatisfy((e: unknown) => e instanceof ProtocolError && e.code === ProtocolErrorCode.InvalidParams);
     });
+
+    test('schema bundle overload: transforms and defaults applied to outbound params', async () => {
+        const [client, server] = await linkedPair();
+        const ParamsWithTransforms = z.object({ query: z.string().trim(), page: z.number().default(1) });
+        let received: unknown;
+        server.setCustomRequestHandler('acme/q', z.unknown(), p => {
+            received = p;
+            return {};
+        });
+        await client.sendCustomRequest('acme/q', { query: '  hi  ' }, { params: ParamsWithTransforms, result: z.object({}) });
+        expect(received).toEqual({ query: 'hi', page: 1 });
+    });
 });
 
 describe('sendCustomNotification', () => {