docs(core): clarify schema-bundle overload validates only (no outbound transforms)

Reverts 0e053fe. The params schema in the {params, result} bundle is a
type guard, not a transformer: the value the caller passes is sent as-is,
matching v1 and request() behavior. parsed.data is intentionally unused
on the outbound path — validation catches shape errors before the
round-trip, but transforms/defaults are an inbound concern (parsing
untrusted wire data), not an outbound one (sending trusted local data).

Adds JSDoc note and a test asserting params are sent verbatim.

Author: felixweinberger

packages/core/src/shared/protocol.ts

@@ -46,7 +46,7 @@ import {
     ProtocolErrorCode,
     SUPPORTED_PROTOCOL_VERSIONS
 } from '../types/index.js';
-import type { AnySchema, SchemaInput, SchemaOutput } from '../util/schema.js';
+import type { AnySchema, 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';
@@ -1143,10 +1143,14 @@ export abstract class Protocol<ContextT extends BaseContext> {
      *
      * Pass a `{ params, result }` schema bundle as the third argument to get typed `params` and
      * pre-send validation; pass a bare result schema for loose, unvalidated params.
+     *
+     * The `params` schema is used only for validation — the value you pass is sent as-is.
+     * Transforms (e.g. `.trim()`) and defaults (e.g. `.default(n)`) on the schema are not
+     * applied to outbound data, matching the behavior of {@linkcode Protocol.request | request}.
      */
     sendCustomRequest<P extends AnySchema, R extends AnySchema>(
         method: string,
-        params: SchemaInput<P>,
+        params: SchemaOutput<P>,
         schemas: { params: P; result: R },
         options?: RequestOptions
     ): Promise<SchemaOutput<R>>;
@@ -1168,7 +1172,6 @@ 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;
@@ -1186,11 +1189,12 @@ export abstract class Protocol<ContextT extends BaseContext> {
      * standard MCP notifications.
      *
      * Pass a `{ params }` schema bundle as the third argument to get typed `params` and pre-send
-     * validation.
+     * validation. The schema validates only — transforms and defaults are not applied to
+     * outbound data; the value you pass is sent as-is.
      */
     sendCustomNotification<P extends AnySchema>(
         method: string,
-        params: SchemaInput<P>,
+        params: SchemaOutput<P>,
         schemas: { params: P },
         options?: NotificationOptions
     ): Promise<void>;
@@ -1207,7 +1211,6 @@ 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,11 +20,6 @@ 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

@@ -192,16 +192,16 @@ 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 () => {
+    test('schema bundle overload: params sent as-is (validate-only, no outbound transforms)', async () => {
         const [client, server] = await linkedPair();
-        const ParamsWithTransforms = z.object({ query: z.string().trim(), page: z.number().default(1) });
+        const P = z.object({ query: z.string().transform(s => s.trim()), page: z.number() });
         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 });
+        await client.sendCustomRequest('acme/q', { query: '  hi  ', page: 1 }, { params: P, result: z.object({}) });
+        expect(received).toEqual({ query: '  hi  ', page: 1 });
     });
 });