fix(core): preserve default values for tool parameters (#268)

* fix(core): preserve default values for tool parameters

Preserve JSON Schema default across protocol and MCP transport

Apply defaults in Zod param schema

Update E2E Optional Params assertions to handle ZodDefault wrapper

* fix(test): unroll ZodDefault wrapper in e2e

* fix(test): resolve lint errors in E2E tests and MCP protocol files

- Apply gts formatting to test.e2e.ts and MCP protocol files
- Replace 'any' types with proper AxiosError handling in test.e2e.ts
- Remove unused variables and imports
- Fix Node.js globals in mock-mcp-server.js using global comments

* fix(test): add missing license header to mock-mcp-server.js

* fix(test): revert local testing changes (port 5001→5000, .js imports)

* fix(test): scope PR to #211 and keep ZodDefault-safe e2e assertions

* test(core): add coverage for parameter defaults in protocol schema

* refactor(core): remove never cast for parameter defaults

---------

Co-authored-by: Twisha Bansal <58483338+twishabansal@users.noreply.github.com>

Author: Deeven-Seru

packages/toolbox-core/src/toolbox_core/mcp/transportBase.ts

@@ -29,6 +29,7 @@ interface JsonSchema {
   additionalProperties?: boolean | JsonSchema;
   description?: string;
   required?: string[];
+  default?: unknown;
 }
 
 interface ToolDefinition {
@@ -127,6 +128,7 @@ export abstract class McpHttpTransportBase implements ITransport {
         description: schema.description || '',
         required: required.has(name),
         authSources,
+        default: schema.default,
         ...typeSchema,
       } as ParameterSchema);
     }

packages/toolbox-core/src/toolbox_core/protocol.ts

@@ -71,6 +71,7 @@ interface BaseParameter {
   description: string;
   authSources?: string[];
   required?: boolean;
+  default?: unknown;
 }
 
 export type ParameterSchema = BaseParameter & TypeSchema;
@@ -106,6 +107,7 @@ const ZodBaseParameter = z.object({
   description: z.string(),
   authSources: z.array(z.string()).optional(),
   required: z.boolean().optional(),
+  default: z.any().optional(),
 });
 
 export const ZodParameterSchema: z.ZodType<ParameterSchema> =
@@ -160,11 +162,14 @@ function buildZodShapeFromTypeSchema(typeSchema: TypeSchema): ZodTypeAny {
 }
 
 function buildZodShapeFromParam(param: ParameterSchema): ZodTypeAny {
-  const schema = buildZodShapeFromTypeSchema(param);
+  let schema = buildZodShapeFromTypeSchema(param);
   if (param.required === false) {
-    return schema.nullish();
+    schema = schema.nullish();
   }
-  return schema;
+  if (param.default !== undefined) {
+    schema = schema.default(param.default);
+  }
+  return schema as ZodTypeAny;
 }
 
 export function createZodSchemaFromParams(

packages/toolbox-core/test/e2e/test.e2e.ts

@@ -19,7 +19,7 @@ import {getSupportedMcpVersions} from '../../src/toolbox_core/protocol.js';
 import {AxiosError} from 'axios';
 import {CustomGlobal} from './types.js';
 import {authTokenGetter} from './utils.js';
-import {ZodOptional, ZodNullable, ZodTypeAny} from 'zod';
+import {ZodTypeAny} from 'zod';
 
 describe.each(getSupportedMcpVersions())(
   'ToolboxClient E2E MCP Tests (%s)',
@@ -359,18 +359,32 @@ describe.each(getSupportedMcpVersions())(
         // Optional param 'data'
         expect(shape.data.isOptional()).toBe(true);
         expect(shape.data.isNullable()).toBe(true);
-        expect(
-          (shape.data as ZodOptional<ZodNullable<ZodTypeAny>>).unwrap().unwrap()
-            ._def.typeName,
-        ).toBe('ZodString');
+        {
+          let inner: ZodTypeAny = shape.data as unknown as ZodTypeAny;
+          while (
+            inner?._def?.typeName === 'ZodOptional' ||
+            inner?._def?.typeName === 'ZodNullable' ||
+            inner?._def?.typeName === 'ZodDefault'
+          ) {
+            inner = inner._def.innerType;
+          }
+          expect(inner._def.typeName).toBe('ZodString');
+        }
 
         // Optional param 'id'
         expect(shape.id.isOptional()).toBe(true);
         expect(shape.id.isNullable()).toBe(true);
-        expect(
-          (shape.id as ZodOptional<ZodNullable<ZodTypeAny>>).unwrap().unwrap()
-            ._def.typeName,
-        ).toBe('ZodNumber');
+        {
+          let inner: ZodTypeAny = shape.id as unknown as ZodTypeAny;
+          while (
+            inner?._def?.typeName === 'ZodOptional' ||
+            inner?._def?.typeName === 'ZodNullable' ||
+            inner?._def?.typeName === 'ZodDefault'
+          ) {
+            inner = inner._def.innerType;
+          }
+          expect(inner._def.typeName).toBe('ZodNumber');
+        }
       });
 
       it('should run tool with optional params omitted', async () => {

packages/toolbox-core/test/test.protocol.ts

@@ -531,6 +531,34 @@ describe('createZodObjectSchemaFromParameters', () => {
     );
   });
 
+  describe('default parameters', () => {
+    it('should preserve a default value in parameter schema validation', () => {
+      expectParseSuccess(ZodParameterSchema, {
+        name: 'limit',
+        description: 'query limit',
+        type: 'integer',
+        required: false,
+        default: 10,
+      });
+    });
+
+    it('should apply default value when parameter is omitted', () => {
+      const params: ParameterSchema[] = [
+        {
+          name: 'limit',
+          description: 'query limit',
+          type: 'integer',
+          required: false,
+          default: 10,
+        },
+      ];
+      const schema = createZodSchemaFromParams(params);
+
+      const result = schema.parse({});
+      expect(result).toEqual({limit: 10});
+    });
+  });
+
   describe('optional parameters', () => {
     const params: ParameterSchema[] = [
       {name: 'requiredParam', description: 'required', type: 'string' as const},