fix: handle inputSchema for MCP tools in schema sanitizer

MCP tools from @ai-sdk/mcp use inputSchema with a jsonSchema getter,
not parameters like regular AI SDK tools. The sanitizer now handles
both cases to properly strip unsupported properties for OpenAI.

Author: ibetitsmike

src/common/utils/tools/schemaSanitizer.test.ts

@@ -9,6 +9,15 @@ function getParams(tool: Tool): any {
   return (tool as any).parameters;
 }
 
+// Test helper to access tool inputSchema (MCP tools)
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getInputSchema(tool: Tool): any {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const inputSchema = (tool as any).inputSchema;
+  // inputSchema has a jsonSchema getter
+  return inputSchema?.jsonSchema;
+}
+
 describe("schemaSanitizer", () => {
   describe("sanitizeToolSchemaForOpenAI", () => {
     it("should strip minLength from string properties", () => {
@@ -163,6 +172,65 @@ describe("schemaSanitizer", () => {
       // Original should still have minLength
       expect(params.properties.content.minLength).toBe(1);
     });
+
+    it("should sanitize MCP tools with inputSchema", () => {
+      // MCP tools use inputSchema with a jsonSchema getter instead of parameters
+      const jsonSchema = {
+        type: "object",
+        properties: {
+          content: { type: "string", minLength: 1, maxLength: 100 },
+          count: { type: "number", minimum: 0, maximum: 10 },
+        },
+        required: ["content"],
+      };
+
+      const mcpTool = {
+        type: "dynamic",
+        description: "MCP test tool",
+        inputSchema: {
+          // Simulate the jsonSchema getter that @ai-sdk/mcp creates
+          get jsonSchema() {
+            return jsonSchema;
+          },
+        },
+        execute: () => Promise.resolve({}),
+      } as unknown as Tool;
+
+      const sanitized = sanitizeToolSchemaForOpenAI(mcpTool);
+      const schema = getInputSchema(sanitized);
+
+      // Unsupported properties should be stripped
+      expect(schema.properties.content).toEqual({ type: "string" });
+      expect(schema.properties.count).toEqual({ type: "number" });
+      // Supported properties should be preserved
+      expect(schema.type).toBe("object");
+      expect(schema.required).toEqual(["content"]);
+    });
+
+    it("should not mutate the original MCP tool inputSchema", () => {
+      const jsonSchema = {
+        type: "object",
+        properties: {
+          content: { type: "string", minLength: 1 },
+        },
+      };
+
+      const mcpTool = {
+        type: "dynamic",
+        description: "MCP test tool",
+        inputSchema: {
+          get jsonSchema() {
+            return jsonSchema;
+          },
+        },
+        execute: () => Promise.resolve({}),
+      } as unknown as Tool;
+
+      sanitizeToolSchemaForOpenAI(mcpTool);
+
+      // Original should still have minLength
+      expect(jsonSchema.properties.content.minLength).toBe(1);
+    });
   });
 
   describe("sanitizeMCPToolsForOpenAI", () => {

src/common/utils/tools/schemaSanitizer.ts

@@ -104,15 +104,50 @@ function stripUnsupportedProperties(schema: unknown): void {
  * This function creates a new tool with sanitized parameters that strips
  * unsupported schema properties like minLength, maximum, default, etc.
  *
+ * Tools can have schemas in two places:
+ * - `parameters`: Used by tools created with ai SDK's `tool()` function
+ * - `inputSchema`: Used by MCP tools created with `dynamicTool()` from @ai-sdk/mcp
+ *
  * @param tool - The original tool to sanitize
  * @returns A new tool with sanitized parameter schema
  */
 export function sanitizeToolSchemaForOpenAI(tool: Tool): Tool {
-  // Access tool internals - the AI SDK tool structure has parameters
+  // Access tool internals - the AI SDK tool structure varies:
+  // - Regular tools have `parameters` (Zod schema)
+  // - MCP/dynamic tools have `inputSchema` (JSON Schema wrapper with getter)
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const toolRecord = tool as any as Record<string, unknown>;
 
-  // If no parameters, return as-is
+  // Check for inputSchema first (MCP tools use this)
+  // The inputSchema is a wrapper object with a jsonSchema getter
+  if (toolRecord.inputSchema && typeof toolRecord.inputSchema === "object") {
+    const inputSchemaWrapper = toolRecord.inputSchema as Record<string, unknown>;
+
+    // Get the actual JSON Schema - it's exposed via a getter
+    const rawJsonSchema = inputSchemaWrapper.jsonSchema;
+    if (rawJsonSchema && typeof rawJsonSchema === "object") {
+      // Deep clone and sanitize
+      const clonedSchema = JSON.parse(JSON.stringify(rawJsonSchema)) as Record<string, unknown>;
+      stripUnsupportedProperties(clonedSchema);
+
+      // Create a new inputSchema wrapper that returns our sanitized schema
+      const sanitizedInputSchema = {
+        ...inputSchemaWrapper,
+        // Override the jsonSchema getter with our sanitized version
+        get jsonSchema() {
+          return clonedSchema;
+        },
+      };
+
+      return {
+        ...tool,
+        inputSchema: sanitizedInputSchema,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any as Tool;
+    }
+  }
+
+  // Fall back to parameters (regular AI SDK tools)
   if (!toolRecord.parameters) {
     return tool;
   }