From 6cc81584b9c0fac87aae344124032bf5f2e29d1f Mon Sep 17 00:00:00 2001
From: Aliaksei Venski <avenski@ecovadis.com>
Date: Fri, 14 Aug 2026 16:52:42 +0200
Subject: [PATCH 1/3] fix(ui): render the correct widget for nullable MCP tool
 schema properties

JSON Schema allows "type" to be an array (e.g. ["string", "null"]) for a
nullable/optional field, the shape Pydantic's model_json_schema() emits for
Optional[str] / str | None. A real Azure DevOps MCP tool schema
(testplan_test_suite_write) declares its optional parameters exactly this
way. Both ToolTestPanel (the MCP Tool Testing Playground) and
MCPToolArgumentsForm (the chat playground's tool-call argument form) compare
a property's type with strict equality against a single string, with no
fallback for the array case.

In ToolTestPanel this leaves the field with no input at all, since none of
the type checks match and there is no default branch: the field's label
renders with nothing to type into, and the same strict comparison in the
submit-time value conversion would also skip type coercion for it.
MCPToolArgumentsForm has a final else branch, so the same schema shape
instead renders the wrong widget (a plain text input for what should be a
number or boolean field).

Add resolveSchemaType to both files, resolving to the first non-"null" type
when given an array, and use it everywhere a property's type decides a
widget or a value conversion. Widen InputSchemaProperty.type in the shared
types module to string | string[] to match.
---
 .../_components/ToolTestPanel.test.tsx        | 48 ++++++++++++++
 .../mcp_tools/MCPToolArgumentsForm.test.tsx   | 36 ++++++++++
 .../mcp_tools/MCPToolArgumentsForm.tsx        | 66 ++++++++++++-------
 .../src/components/mcp_tools/types.tsx        |  6 +-
 4 files changed, 130 insertions(+), 26 deletions(-)

diff --git a/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/ToolTestPanel.test.tsx b/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/ToolTestPanel.test.tsx
index 26e66c8338c..9ac67563011 100644
--- a/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/ToolTestPanel.test.tsx
+++ b/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/ToolTestPanel.test.tsx
@@ -158,6 +158,54 @@ describe("ToolTestPanel defaults", () => {
     expect(callButton.closest("form")).not.toBeNull();
     expect(callButton).toHaveAttribute("type", "button");
   });
+
+  it("renders inputs for nullable (type-array) schema properties instead of leaving them blank", () => {
+    // JSON Schema represents an optional/nullable field as an array type, e.g. ["string", "null"] -
+    // the shape Pydantic's model_json_schema() emits for Optional[str]. A real Azure DevOps MCP tool
+    // schema (testplan_test_suite_write) declares its optional fields exactly this way.
+    const schema: InputSchema = {
+      type: "object",
+      properties: {
+        name: { type: ["string", "null"], description: "Optional name" },
+        parentSuiteId: { type: ["integer", "null"], description: "Optional parent suite id" },
+        active: { type: ["boolean", "null"], description: "Optional flag" },
+      },
+    };
+
+    renderPanel(schema);
+
+    expect(screen.getByLabelText("name")).toHaveValue("");
+    expect(screen.getByLabelText("parentSuiteId")).toHaveValue(0);
+    expect(screen.getByLabelText("active")).toBeInTheDocument();
+  });
+
+  it("coerces a nullable integer field to a number on submit, not a string", async () => {
+    const schema: InputSchema = {
+      type: "object",
+      properties: {
+        parentSuiteId: { type: ["integer", "null"], description: "Optional parent suite id" },
+      },
+    };
+    const onSubmit = vi.fn();
+
+    render(
+      <ToolTestPanel
+        tool={buildTool(schema)}
+        onSubmit={onSubmit}
+        isLoading={false}
+        result={null}
+        error={null}
+        onClose={vi.fn()}
+      />,
+    );
+
+    const input = screen.getByLabelText("parentSuiteId");
+    await userEvent.clear(input);
+    await userEvent.type(input, "42");
+    await userEvent.click(screen.getByRole("button", { name: "Call Tool" }));
+
+    expect(onSubmit).toHaveBeenCalledWith(expect.objectContaining({ parentSuiteId: 42 }));
+  });
 });
 
 describe("ToolTestPanel argument payload", () => {
diff --git a/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.test.tsx b/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.test.tsx
index d6e614da5eb..60a808c4496 100644
--- a/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.test.tsx
+++ b/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.test.tsx
@@ -178,3 +178,39 @@ describe("MCPToolArgumentsForm", () => {
     await expect(submit(ref)).resolves.toEqual({});
   });
 });
+
+describe("MCPToolArgumentsForm nullable schema types", () => {
+  it("renders inputs for nullable (type-array) schema properties instead of a plain text fallback", () => {
+    // JSON Schema represents an optional/nullable field as an array type, e.g. ["integer", "null"] -
+    // the shape Pydantic's model_json_schema() emits for Optional[int]. Unlike ToolTestPanel, this
+    // component has a final "else" branch that falls back to a plain text Input, so the bug here
+    // is a wrong widget (text instead of number), not a missing one.
+    renderForm({
+      type: "object",
+      properties: {
+        parentSuiteId: { type: ["integer", "null"], description: "Optional parent suite id" },
+      },
+      required: [],
+    });
+
+    const input = screen.getByLabelText("parentSuiteId");
+    expect(input).toHaveValue(0);
+  });
+
+  it("coerces a nullable integer field to a number in getSubmitValues, not a string", async () => {
+    const user = userEvent.setup();
+    const ref = renderForm({
+      type: "object",
+      properties: {
+        parentSuiteId: { type: ["integer", "null"], description: "Optional parent suite id" },
+      },
+      required: [],
+    });
+
+    const input = screen.getByLabelText("parentSuiteId");
+    await user.clear(input);
+    await user.type(input, "42");
+
+    await expect(submit(ref)).resolves.toEqual(expect.objectContaining({ parentSuiteId: 42 }));
+  });
+});
diff --git a/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.tsx b/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.tsx
index ca8c5697e6e..7f06cfbdd4e 100644
--- a/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.tsx
+++ b/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.tsx
@@ -20,14 +20,14 @@ const BOOLEAN_ITEMS = [
 
 const isBlank = (value: unknown): boolean => value === undefined || value === null || value === "";
 
-const jsonErrorFor = (prop: InputSchemaProperty, value: unknown): string | null => {
+const jsonErrorFor = (effectiveType: string | undefined, value: unknown): string | null => {
   try {
     const parsed = typeof value === "string" ? JSON.parse(value) : value;
     const isValidObject =
-      prop.type === "object" && parsed !== null && typeof parsed === "object" && !Array.isArray(parsed);
-    const isValidArray = prop.type === "array" && Array.isArray(parsed);
+      effectiveType === "object" && parsed !== null && typeof parsed === "object" && !Array.isArray(parsed);
+    const isValidArray = effectiveType === "array" && Array.isArray(parsed);
     if (isValidObject || isValidArray) return null;
-    return prop.type === "object" ? "Please enter a JSON object" : "Please enter a JSON array";
+    return effectiveType === "object" ? "Please enter a JSON object" : "Please enter a JSON array";
   } catch {
     return "Invalid JSON";
   }
@@ -46,9 +46,10 @@ const collectErrors = (
     if (actualSchema.required?.includes(key) && blank) {
       return [[key, { type: "required", message: requiredMessages[key] ?? `Please enter ${key}` }]];
     }
-    if (prop.type !== "object" && prop.type !== "array") return [];
+    const effectiveType = resolveSchemaType(prop.type);
+    if (effectiveType !== "object" && effectiveType !== "array") return [];
     if (blank) return [];
-    const message = jsonErrorFor(prop, value);
+    const message = jsonErrorFor(effectiveType, value);
     return message === null ? [] : [[key, { type: "validate", message }]];
   });
   return Object.fromEntries(entries);
@@ -76,6 +77,17 @@ const labelFor = (key: string, prop: InputSchemaProperty, required: boolean): Re
 const isPlainObject = (value: unknown): value is Record<string, any> =>
   typeof value === "object" && value !== null && !Array.isArray(value);
 
+// JSON Schema allows "type" to be an array (e.g. ["string", "null"]) for a nullable field, the
+// shape Pydantic's model_json_schema() emits for Optional[str] / str | None. Every branch below
+// that decides a widget or a value conversion from a property's type needs the single effective
+// (non-null) type, not the raw field verbatim.
+function resolveSchemaType(type: InputSchemaProperty["type"] | undefined): string | undefined {
+  if (Array.isArray(type)) {
+    return type.find((t) => t !== "null") ?? type[0];
+  }
+  return type;
+}
+
 function buildArrayItems(items?: InputSchemaProperty | InputSchemaProperty[]): any[] {
   if (!items) return [];
   if (Array.isArray(items)) {
@@ -88,8 +100,9 @@ function buildArrayItems(items?: InputSchemaProperty | InputSchemaProperty[]): a
 function buildDefaultValue(prop?: InputSchemaProperty, overrideDefault?: any): any {
   if (!prop) return undefined;
   const effectiveDefault = overrideDefault !== undefined ? overrideDefault : prop.default;
+  const effectiveType = resolveSchemaType(prop.type);
 
-  if (prop.type === "object") {
+  if (effectiveType === "object") {
     const base = isPlainObject(effectiveDefault) ? { ...effectiveDefault } : {};
     if (prop.properties) {
       Object.entries(prop.properties).forEach(([childKey, childProp]) => {
@@ -99,7 +112,7 @@ function buildDefaultValue(prop?: InputSchemaProperty, overrideDefault?: any): a
     return base;
   }
 
-  if (prop.type === "array") {
+  if (effectiveType === "array") {
     if (Array.isArray(effectiveDefault)) {
       const itemSchema = prop.items;
       if (!itemSchema) return effectiveDefault;
@@ -120,7 +133,7 @@ function buildDefaultValue(prop?: InputSchemaProperty, overrideDefault?: any): a
   }
 
   if (effectiveDefault !== undefined) return effectiveDefault;
-  switch (prop.type) {
+  switch (effectiveType) {
     case "integer":
     case "number":
       return 0;
@@ -134,8 +147,9 @@ function buildDefaultValue(prop?: InputSchemaProperty, overrideDefault?: any): a
 
 const getInitialValueForField = (prop: InputSchemaProperty): any => {
   const defaultValue = buildDefaultValue(prop);
-  if (prop.type === "object" || prop.type === "array") {
-    const fallback = prop.type === "array" ? [] : {};
+  const effectiveType = resolveSchemaType(prop.type);
+  if (effectiveType === "object" || effectiveType === "array") {
+    const fallback = effectiveType === "array" ? [] : {};
     return JSON.stringify(defaultValue ?? fallback, null, 2);
   }
   return defaultValue;
@@ -152,7 +166,8 @@ function convertFormValues(
   Object.entries(values).forEach(([key, value]) => {
     const prop = schemaToUse.properties?.[key];
     if (prop && value !== null && value !== undefined && value !== "") {
-      switch (prop.type) {
+      const effectiveType = resolveSchemaType(prop.type);
+      switch (effectiveType) {
         case "boolean":
           convertedValues[key] = value === "true" || value === true;
           break;
@@ -161,7 +176,7 @@ function convertFormValues(
           const numericValue = Number(value);
           convertedValues[key] = Number.isNaN(numericValue)
             ? value
-            : prop.type === "integer"
+            : effectiveType === "integer"
               ? Math.trunc(numericValue)
               : numericValue;
           break;
@@ -171,9 +186,9 @@ function convertFormValues(
           try {
             const parsed = typeof value === "string" ? JSON.parse(value) : value;
             const isValidObject =
-              prop.type === "object" && parsed !== null && typeof parsed === "object" && !Array.isArray(parsed);
-            const isValidArray = prop.type === "array" && Array.isArray(parsed);
-            if ((prop.type === "object" && isValidObject) || (prop.type === "array" && isValidArray)) {
+              effectiveType === "object" && parsed !== null && typeof parsed === "object" && !Array.isArray(parsed);
+            const isValidArray = effectiveType === "array" && Array.isArray(parsed);
+            if ((effectiveType === "object" && isValidObject) || (effectiveType === "array" && isValidArray)) {
               convertedValues[key] = parsed;
             } else {
               convertedValues[key] = value;
@@ -194,7 +209,7 @@ function convertFormValues(
     }
   });
 
-  const isNestedParams = schema.properties?.params?.type === "object" && schema.properties.params.properties;
+  const isNestedParams = resolveSchemaType(schema.properties?.params?.type) === "object" && schema.properties?.params?.properties;
 
   return isNestedParams ? { params: convertedValues } : convertedValues;
 }
@@ -227,7 +242,7 @@ const MCPToolArgumentsForm = forwardRef<MCPToolArgumentsFormRef, MCPToolArgument
     }, [tool.inputSchema]);
 
     const actualSchema: InputSchema = useMemo(() => {
-      if (schema.properties?.params?.type === "object" && schema.properties.params.properties) {
+      if (resolveSchemaType(schema.properties?.params?.type) === "object" && schema.properties?.params?.properties) {
         return {
           type: "object",
           properties: schema.properties.params.properties,
@@ -320,6 +335,7 @@ const MCPToolArgumentsForm = forwardRef<MCPToolArgumentsFormRef, MCPToolArgument
           <FieldGroup>
             {Object.entries(actualSchema.properties).map(([key, prop]) => {
               const required = actualSchema.required?.includes(key) ?? false;
+              const effectiveType = resolveSchemaType(prop.type);
               return (
                 <FormField
                   key={`${tool.name}-${key}`}
@@ -328,7 +344,7 @@ const MCPToolArgumentsForm = forwardRef<MCPToolArgumentsFormRef, MCPToolArgument
                   label={labelFor(key, prop, required)}
                 >
                   {(field) => {
-                    if (prop.type === "string" && prop.enum) {
+                    if (effectiveType === "string" && prop.enum) {
                       return (
                         <Select value={field.value ?? ""} onValueChange={field.onChange}>
                           <SelectTrigger
@@ -350,7 +366,7 @@ const MCPToolArgumentsForm = forwardRef<MCPToolArgumentsFormRef, MCPToolArgument
                         </Select>
                       );
                     }
-                    if (prop.type === "boolean") {
+                    if (effectiveType === "boolean") {
                       return (
                         <Select items={BOOLEAN_ITEMS} value={field.value ?? ""} onValueChange={field.onChange}>
                           <SelectTrigger
@@ -369,28 +385,28 @@ const MCPToolArgumentsForm = forwardRef<MCPToolArgumentsFormRef, MCPToolArgument
                         </Select>
                       );
                     }
-                    if (prop.type === "number" || prop.type === "integer") {
+                    if (effectiveType === "number" || effectiveType === "integer") {
                       return (
                         <Input
                           {...field}
                           type="number"
-                          step={prop.type === "integer" ? 1 : undefined}
+                          step={effectiveType === "integer" ? 1 : undefined}
                           value={field.value as number | string}
                           placeholder={prop.description || `Enter ${key}`}
                         />
                       );
                     }
-                    if (prop.type === "object" || prop.type === "array") {
+                    if (effectiveType === "object" || effectiveType === "array") {
                       return (
                         <Textarea
                           {...field}
-                          rows={prop.type === "object" ? 4 : 3}
+                          rows={effectiveType === "object" ? 4 : 3}
                           value={field.value as string}
                           spellCheck={false}
                           className="font-mono"
                           placeholder={
                             prop.description ||
-                            (prop.type === "object" ? `Enter JSON object for ${key}` : `Enter JSON array for ${key}`)
+                            (effectiveType === "object" ? `Enter JSON object for ${key}` : `Enter JSON array for ${key}`)
                           }
                         />
                       );
diff --git a/ui/litellm-dashboard/src/components/mcp_tools/types.tsx b/ui/litellm-dashboard/src/components/mcp_tools/types.tsx
index 67e51ab23aa..24fa70c7f5f 100644
--- a/ui/litellm-dashboard/src/components/mcp_tools/types.tsx
+++ b/ui/litellm-dashboard/src/components/mcp_tools/types.tsx
@@ -294,7 +294,11 @@ export const handleAuth = (authType?: string | null): string => {
 
 // Define the structure for tool input schema properties
 export interface InputSchemaProperty {
-  type?: string;
+  // JSON Schema allows an array here (e.g. ["string", "null"]) for a nullable/optional field —
+  // the shape Pydantic's model_json_schema() emits for Optional[str] / str | None. Callers must
+  // resolve to a single type with resolveSchemaType before branching on it. Optional because a
+  // property may instead be described purely via anyOf/oneOf, with no top-level type at all.
+  type?: string | string[];
   description?: string;
   properties?: Record<string, InputSchemaProperty>; // For nested object properties
   required?: string[]; // For required fields in nested objects

From 5b46865e7b239004b96b4861ad9a1329aa552a55 Mon Sep 17 00:00:00 2001
From: Aliaksei Venski <avenski@ecovadis.com>
Date: Tue, 25 Aug 2026 11:31:16 +0200
Subject: [PATCH 2/3] fix(ui): resolve review feedback on the
 nullable-schema-type fix

Three issues from review and CI on this branch:

Greptile (P1): a nullable numeric/boolean field with no explicit default was
getting a synthetic 0/false from buildDefaultValue. Unlike a string's natural
"" default, that value looks user-provided, passes the non-empty submission
filter, and gets sent to the tool even when the field was never touched.
Nullable numeric/boolean fields with no default now resolve to undefined
instead, so an untouched field is correctly omitted from the payload.

Greptile (P2): the JSON-Schema-nullable-type explanation comment was
duplicated across both components, the shared types module, and both test
files. Extract the shared logic those comments were explaining (resolveSchemaType,
buildDefaultValue, getInitialValueForField) into one module,
mcpToolSchemaDefaults.ts, with the explanation living in exactly one place;
ToolTestPanel and MCPToolArgumentsForm both import from it instead of each
carrying their own copy.

CI (ESLint max-lines): ToolTestPanel.tsx had grown past the 800-line limit.
Extracting the ~100 lines of duplicated parsing logic into the shared module
brings it back to 781.

Added mcpToolSchemaDefaults.test.ts with direct unit tests for the extracted
logic (matching this repo's own stated pattern of unit-testing extracted
logic rather than only driving it through a render), including the
nullable-default fix. Updated the existing render-based tests: the
"renders inputs for nullable properties" test now asserts the numeric field
starts empty instead of 0, and a new test in each component's test file
asserts an untouched nullable field is omitted from the submitted values
entirely rather than sent as a synthetic 0.

Rebase note: this repo has since migrated ToolTestPanel/ToolArgumentsForm
off antd onto react-hook-form + shadcn, and off the local resolveSchemaType
duplicated in ToolTestPanel.tsx onto a shared resolveSchemaProperty in
toolCallArguments.ts (which additionally resolves anyOf/oneOf, not just
type arrays). ToolTestPanel.tsx therefore does not import
mcpToolSchemaDefaults.ts - the nullable-default-omission fix is ported
into toolCallArguments.ts's own buildDefaultValue instead, preserving this
commit's actual intent (consistent omit-if-untouched behavior across both
forms) against the current file layout. MCPToolArgumentsForm.tsx, which
was not touched by that refactor, imports mcpToolSchemaDefaults.ts as
originally written here.
---
 .../_components/ToolTestPanel.test.tsx        | 32 ++++++-
 .../mcp_tools/MCPToolArgumentsForm.test.tsx   | 24 +++--
 .../mcp_tools/MCPToolArgumentsForm.tsx        | 84 +-----------------
 .../mcp_tools/mcpToolSchemaDefaults.test.ts   | 60 +++++++++++++
 .../mcp_tools/mcpToolSchemaDefaults.ts        | 88 +++++++++++++++++++
 .../src/components/mcp_tools/types.tsx        |  5 +-
 6 files changed, 199 insertions(+), 94 deletions(-)
 create mode 100644 ui/litellm-dashboard/src/components/mcp_tools/mcpToolSchemaDefaults.test.ts
 create mode 100644 ui/litellm-dashboard/src/components/mcp_tools/mcpToolSchemaDefaults.ts

diff --git a/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/ToolTestPanel.test.tsx b/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/ToolTestPanel.test.tsx
index 9ac67563011..f1414a4b104 100644
--- a/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/ToolTestPanel.test.tsx
+++ b/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/ToolTestPanel.test.tsx
@@ -160,9 +160,8 @@ describe("ToolTestPanel defaults", () => {
   });
 
   it("renders inputs for nullable (type-array) schema properties instead of leaving them blank", () => {
-    // JSON Schema represents an optional/nullable field as an array type, e.g. ["string", "null"] -
-    // the shape Pydantic's model_json_schema() emits for Optional[str]. A real Azure DevOps MCP tool
-    // schema (testplan_test_suite_write) declares its optional fields exactly this way.
+    // A real Azure DevOps MCP tool schema (testplan_test_suite_write) declares its optional
+    // fields exactly this way.
     const schema: InputSchema = {
       type: "object",
       properties: {
@@ -175,10 +174,35 @@ describe("ToolTestPanel defaults", () => {
     renderPanel(schema);
 
     expect(screen.getByLabelText("name")).toHaveValue("");
-    expect(screen.getByLabelText("parentSuiteId")).toHaveValue(0);
+    expect(screen.getByLabelText("parentSuiteId")).toHaveValue(null);
     expect(screen.getByLabelText("active")).toBeInTheDocument();
   });
 
+  it("omits an untouched nullable numeric field from the submitted payload instead of sending a synthetic 0", async () => {
+    const schema: InputSchema = {
+      type: "object",
+      properties: {
+        parentSuiteId: { type: ["integer", "null"], description: "Optional parent suite id" },
+      },
+    };
+    const onSubmit = vi.fn();
+
+    render(
+      <ToolTestPanel
+        tool={buildTool(schema)}
+        onSubmit={onSubmit}
+        isLoading={false}
+        result={null}
+        error={null}
+        onClose={vi.fn()}
+      />,
+    );
+
+    await userEvent.click(screen.getByRole("button", { name: "Call Tool" }));
+
+    expect(onSubmit).toHaveBeenCalledWith({});
+  });
+
   it("coerces a nullable integer field to a number on submit, not a string", async () => {
     const schema: InputSchema = {
       type: "object",
diff --git a/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.test.tsx b/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.test.tsx
index 60a808c4496..b5972c1fb12 100644
--- a/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.test.tsx
+++ b/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.test.tsx
@@ -180,11 +180,10 @@ describe("MCPToolArgumentsForm", () => {
 });
 
 describe("MCPToolArgumentsForm nullable schema types", () => {
-  it("renders inputs for nullable (type-array) schema properties instead of a plain text fallback", () => {
-    // JSON Schema represents an optional/nullable field as an array type, e.g. ["integer", "null"] -
-    // the shape Pydantic's model_json_schema() emits for Optional[int]. Unlike ToolTestPanel, this
-    // component has a final "else" branch that falls back to a plain text Input, so the bug here
-    // is a wrong widget (text instead of number), not a missing one.
+  it("renders a number widget for nullable (type-array) schema properties instead of a plain text fallback", () => {
+    // Unlike ToolTestPanel, this component has a final "else" branch that falls back to a plain
+    // text Input, so the pre-fix bug here was a wrong widget (text instead of number), not a
+    // missing one; the field must also start empty, not a synthetic 0.
     renderForm({
       type: "object",
       properties: {
@@ -193,8 +192,21 @@ describe("MCPToolArgumentsForm nullable schema types", () => {
       required: [],
     });
 
+    // Native type="number" input: jest-dom reports an empty one as null, not "".
     const input = screen.getByLabelText("parentSuiteId");
-    expect(input).toHaveValue(0);
+    expect(input).toHaveValue(null);
+  });
+
+  it("omits an untouched nullable numeric field from getSubmitValues instead of sending a synthetic 0", async () => {
+    const ref = renderForm({
+      type: "object",
+      properties: {
+        parentSuiteId: { type: ["integer", "null"], description: "Optional parent suite id" },
+      },
+      required: [],
+    });
+
+    await expect(submit(ref)).resolves.toEqual({});
   });
 
   it("coerces a nullable integer field to a number in getSubmitValues, not a string", async () => {
diff --git a/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.tsx b/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.tsx
index 7f06cfbdd4e..0738c05ffc9 100644
--- a/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.tsx
+++ b/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.tsx
@@ -8,6 +8,7 @@ import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@
 import { Textarea } from "@/components/ui/textarea";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip";
 import { MCPTool, InputSchema, InputSchemaProperty } from "./types";
+import { resolveSchemaType, getInitialValueForField } from "./mcpToolSchemaDefaults";
 
 type ToolFormValues = Record<string, unknown>;
 
@@ -74,87 +75,6 @@ const labelFor = (key: string, prop: InputSchemaProperty, required: boolean): Re
   </span>
 );
 
-const isPlainObject = (value: unknown): value is Record<string, any> =>
-  typeof value === "object" && value !== null && !Array.isArray(value);
-
-// JSON Schema allows "type" to be an array (e.g. ["string", "null"]) for a nullable field, the
-// shape Pydantic's model_json_schema() emits for Optional[str] / str | None. Every branch below
-// that decides a widget or a value conversion from a property's type needs the single effective
-// (non-null) type, not the raw field verbatim.
-function resolveSchemaType(type: InputSchemaProperty["type"] | undefined): string | undefined {
-  if (Array.isArray(type)) {
-    return type.find((t) => t !== "null") ?? type[0];
-  }
-  return type;
-}
-
-function buildArrayItems(items?: InputSchemaProperty | InputSchemaProperty[]): any[] {
-  if (!items) return [];
-  if (Array.isArray(items)) {
-    return items.map((item) => buildDefaultValue(item)).filter((value) => value !== undefined);
-  }
-  const itemDefault = buildDefaultValue(items);
-  return itemDefault !== undefined ? [itemDefault] : [];
-}
-
-function buildDefaultValue(prop?: InputSchemaProperty, overrideDefault?: any): any {
-  if (!prop) return undefined;
-  const effectiveDefault = overrideDefault !== undefined ? overrideDefault : prop.default;
-  const effectiveType = resolveSchemaType(prop.type);
-
-  if (effectiveType === "object") {
-    const base = isPlainObject(effectiveDefault) ? { ...effectiveDefault } : {};
-    if (prop.properties) {
-      Object.entries(prop.properties).forEach(([childKey, childProp]) => {
-        base[childKey] = buildDefaultValue(childProp, base[childKey]);
-      });
-    }
-    return base;
-  }
-
-  if (effectiveType === "array") {
-    if (Array.isArray(effectiveDefault)) {
-      const itemSchema = prop.items;
-      if (!itemSchema) return effectiveDefault;
-      if (effectiveDefault.length === 0) {
-        const sample = buildArrayItems(itemSchema);
-        return sample.length ? sample : effectiveDefault;
-      }
-      if (Array.isArray(itemSchema)) {
-        return effectiveDefault.map((value, index) => {
-          const schema = itemSchema[index] ?? itemSchema[itemSchema.length - 1];
-          return buildDefaultValue(schema, value);
-        });
-      }
-      return effectiveDefault.map((value) => buildDefaultValue(itemSchema, value));
-    }
-    if (effectiveDefault !== undefined) return effectiveDefault;
-    return buildArrayItems(prop.items);
-  }
-
-  if (effectiveDefault !== undefined) return effectiveDefault;
-  switch (effectiveType) {
-    case "integer":
-    case "number":
-      return 0;
-    case "boolean":
-      return false;
-    case "string":
-    default:
-      return "";
-  }
-}
-
-const getInitialValueForField = (prop: InputSchemaProperty): any => {
-  const defaultValue = buildDefaultValue(prop);
-  const effectiveType = resolveSchemaType(prop.type);
-  if (effectiveType === "object" || effectiveType === "array") {
-    const fallback = effectiveType === "array" ? [] : {};
-    return JSON.stringify(defaultValue ?? fallback, null, 2);
-  }
-  return defaultValue;
-};
-
 function convertFormValues(
   values: Record<string, any>,
   actualSchema: InputSchema,
@@ -391,7 +311,7 @@ const MCPToolArgumentsForm = forwardRef<MCPToolArgumentsFormRef, MCPToolArgument
                           {...field}
                           type="number"
                           step={effectiveType === "integer" ? 1 : undefined}
-                          value={field.value as number | string}
+                          value={(field.value as number | string) ?? ""}
                           placeholder={prop.description || `Enter ${key}`}
                         />
                       );
diff --git a/ui/litellm-dashboard/src/components/mcp_tools/mcpToolSchemaDefaults.test.ts b/ui/litellm-dashboard/src/components/mcp_tools/mcpToolSchemaDefaults.test.ts
new file mode 100644
index 00000000000..9c864dffe3b
--- /dev/null
+++ b/ui/litellm-dashboard/src/components/mcp_tools/mcpToolSchemaDefaults.test.ts
@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+
+import { buildDefaultValue, getInitialValueForField, resolveSchemaType } from "./mcpToolSchemaDefaults";
+
+describe("resolveSchemaType", () => {
+  it("returns a scalar type unchanged", () => {
+    expect(resolveSchemaType("string")).toBe("string");
+  });
+
+  it("returns the first non-null entry of a nullable type array", () => {
+    expect(resolveSchemaType(["integer", "null"])).toBe("integer");
+    expect(resolveSchemaType(["null", "boolean"])).toBe("boolean");
+  });
+
+  it("falls back to the first entry when every entry is null", () => {
+    expect(resolveSchemaType(["null"])).toBe("null");
+  });
+});
+
+describe("buildDefaultValue", () => {
+  it("defaults a required (non-nullable) integer with no explicit default to 0", () => {
+    expect(buildDefaultValue({ type: "integer" })).toBe(0);
+  });
+
+  it("defaults a required (non-nullable) boolean with no explicit default to false", () => {
+    expect(buildDefaultValue({ type: "boolean" })).toBe(false);
+  });
+
+  it("defaults a required (non-nullable) string with no explicit default to an empty string", () => {
+    expect(buildDefaultValue({ type: "string" })).toBe("");
+  });
+
+  it("leaves a nullable integer with no explicit default undefined, not a synthetic 0", () => {
+    expect(buildDefaultValue({ type: ["integer", "null"] })).toBeUndefined();
+  });
+
+  it("leaves a nullable boolean with no explicit default undefined, not a synthetic false", () => {
+    expect(buildDefaultValue({ type: ["boolean", "null"] })).toBeUndefined();
+  });
+
+  it("defaults a nullable string with no explicit default to an empty string, unaffected by nullability", () => {
+    expect(buildDefaultValue({ type: ["string", "null"] })).toBe("");
+  });
+
+  it("still honors an explicit default on a nullable numeric field", () => {
+    expect(buildDefaultValue({ type: ["integer", "null"], default: 7 })).toBe(7);
+  });
+});
+
+describe("getInitialValueForField", () => {
+  it("passes through undefined for a nullable numeric field with no default", () => {
+    expect(getInitialValueForField({ type: ["integer", "null"] })).toBeUndefined();
+  });
+
+  it("JSON-stringifies an object field's computed default", () => {
+    expect(getInitialValueForField({ type: "object", properties: { a: { type: "string" } } })).toBe(
+      JSON.stringify({ a: "" }, null, 2),
+    );
+  });
+});
diff --git a/ui/litellm-dashboard/src/components/mcp_tools/mcpToolSchemaDefaults.ts b/ui/litellm-dashboard/src/components/mcp_tools/mcpToolSchemaDefaults.ts
new file mode 100644
index 00000000000..9080b0ef03e
--- /dev/null
+++ b/ui/litellm-dashboard/src/components/mcp_tools/mcpToolSchemaDefaults.ts
@@ -0,0 +1,88 @@
+import { InputSchemaProperty } from "./types";
+
+// JSON Schema allows "type" to be an array (e.g. ["string", "null"]) for a nullable field, the
+// shape Pydantic's model_json_schema() emits for Optional[str] / str | None. Every branch that
+// decides a widget or a value conversion from a property's type needs the single effective
+// (non-null) type, not the raw field verbatim.
+export function resolveSchemaType(type: InputSchemaProperty["type"] | undefined): string | undefined {
+  if (Array.isArray(type)) {
+    return type.find((t) => t !== "null") ?? type[0];
+  }
+  return type;
+}
+
+const isPlainObject = (value: unknown): value is Record<string, any> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+function buildArrayItems(items?: InputSchemaProperty | InputSchemaProperty[]): any[] {
+  if (!items) return [];
+  if (Array.isArray(items)) {
+    return items.map((item) => buildDefaultValue(item)).filter((value) => value !== undefined);
+  }
+  const itemDefault = buildDefaultValue(items);
+  return itemDefault !== undefined ? [itemDefault] : [];
+}
+
+export function buildDefaultValue(prop?: InputSchemaProperty, overrideDefault?: any): any {
+  if (!prop) return undefined;
+  const effectiveDefault = overrideDefault !== undefined ? overrideDefault : prop.default;
+  const effectiveType = resolveSchemaType(prop.type);
+
+  if (effectiveType === "object") {
+    const base = isPlainObject(effectiveDefault) ? { ...effectiveDefault } : {};
+    if (prop.properties) {
+      Object.entries(prop.properties).forEach(([childKey, childProp]) => {
+        base[childKey] = buildDefaultValue(childProp, base[childKey]);
+      });
+    }
+    return base;
+  }
+
+  if (effectiveType === "array") {
+    if (Array.isArray(effectiveDefault)) {
+      const itemSchema = prop.items;
+      if (!itemSchema) return effectiveDefault;
+      if (effectiveDefault.length === 0) {
+        const sample = buildArrayItems(itemSchema);
+        return sample.length ? sample : effectiveDefault;
+      }
+      if (Array.isArray(itemSchema)) {
+        return effectiveDefault.map((value, index) => {
+          const schema = itemSchema[index] ?? itemSchema[itemSchema.length - 1];
+          return buildDefaultValue(schema, value);
+        });
+      }
+      return effectiveDefault.map((value) => buildDefaultValue(itemSchema, value));
+    }
+    if (effectiveDefault !== undefined) return effectiveDefault;
+    return buildArrayItems(prop.items);
+  }
+
+  if (effectiveDefault !== undefined) return effectiveDefault;
+
+  // A nullable numeric/boolean field (an array "type") with no explicit default starts empty
+  // rather than a synthetic 0/false: unlike a string's natural "" default, that value looks
+  // user-provided, passes the non-empty submission filter, and gets sent to the tool even when
+  // the field was never touched.
+  const isNullable = Array.isArray(prop.type);
+  switch (effectiveType) {
+    case "integer":
+    case "number":
+      return isNullable ? undefined : 0;
+    case "boolean":
+      return isNullable ? undefined : false;
+    case "string":
+    default:
+      return "";
+  }
+}
+
+export const getInitialValueForField = (prop: InputSchemaProperty): any => {
+  const defaultValue = buildDefaultValue(prop);
+  const effectiveType = resolveSchemaType(prop.type);
+  if (effectiveType === "object" || effectiveType === "array") {
+    const fallback = effectiveType === "array" ? [] : {};
+    return JSON.stringify(defaultValue ?? fallback, null, 2);
+  }
+  return defaultValue;
+};
diff --git a/ui/litellm-dashboard/src/components/mcp_tools/types.tsx b/ui/litellm-dashboard/src/components/mcp_tools/types.tsx
index 24fa70c7f5f..dc1938a08e1 100644
--- a/ui/litellm-dashboard/src/components/mcp_tools/types.tsx
+++ b/ui/litellm-dashboard/src/components/mcp_tools/types.tsx
@@ -296,8 +296,9 @@ export const handleAuth = (authType?: string | null): string => {
 export interface InputSchemaProperty {
   // JSON Schema allows an array here (e.g. ["string", "null"]) for a nullable/optional field —
   // the shape Pydantic's model_json_schema() emits for Optional[str] / str | None. Callers must
-  // resolve to a single type with resolveSchemaType before branching on it. Optional because a
-  // property may instead be described purely via anyOf/oneOf, with no top-level type at all.
+  // resolve to a single type with resolveSchemaType (mcpToolSchemaDefaults.ts / toolCallArguments.ts)
+  // before branching on it. Optional because a property may instead be described purely via
+  // anyOf/oneOf, with no top-level type at all.
   type?: string | string[];
   description?: string;
   properties?: Record<string, InputSchemaProperty>; // For nested object properties

From 1a2e40111c6bf6f66a38ac2d04a2cd01216aa3ee Mon Sep 17 00:00:00 2001
From: Aliaksei Venski <avenski@ecovadis.com>
Date: Tue, 25 Aug 2026 12:10:49 +0200
Subject: [PATCH 3/3] fix(ui): handle nullable JSON-Schema type arrays in tool
 call arguments

resolveSchemaProperty now collapses a type array (e.g. ["integer", "null"],
the shape Pydantic's model_json_schema() emits for Optional[int]) to its
non-null member before any caller branches on it - it previously only
handled the anyOf/oneOf nullable encoding.

buildDefaultValue no longer synthesizes 0/false for an untouched nullable
numeric/boolean field, since that value looks user-provided and gets sent
to the tool even when the field was never touched. initialArgumentValues
now passes the raw (unresolved) prop into buildDefaultValue so it can still
see the original array type and know the field is nullable.

Found and fixed while rebasing this branch onto the current
litellm_internal_staging, verified via the existing and newly-added tests
in toolCallArguments/ToolTestPanel and MCPToolArgumentsForm.
---
 .../_components/toolCallArguments.ts          | 21 ++++++++++++++++---
 .../mcp_tools/MCPToolArgumentsForm.tsx        |  7 +++++--
 2 files changed, 23 insertions(+), 5 deletions(-)

diff --git a/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/toolCallArguments.ts b/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/toolCallArguments.ts
index bdf0a52d02d..4e2833b7103 100644
--- a/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/toolCallArguments.ts
+++ b/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/toolCallArguments.ts
@@ -16,6 +16,12 @@ const isPlainObject = (value: unknown): value is Record<string, unknown> =>
   typeof value === "object" && value !== null && !Array.isArray(value);
 
 export const resolveSchemaProperty = (prop: InputSchemaProperty): InputSchemaProperty => {
+  // JSON Schema represents a nullable/optional field as a type array (e.g. ["integer", "null"]) -
+  // the shape Pydantic's model_json_schema() emits for Optional[int]. Collapse to the single
+  // non-null type before any caller branches on it.
+  if (Array.isArray(prop.type)) {
+    return { ...prop, type: prop.type.find((t) => t !== "null") ?? prop.type[0] };
+  }
   if (prop.type !== undefined) return prop;
   const members = (prop.anyOf ?? prop.oneOf ?? []).filter((member) => member.type !== "null");
   if (members.length !== 1 || members[0].type === undefined) return prop;
@@ -185,12 +191,17 @@ function buildDefaultValue(declared: InputSchemaProperty | undefined, overrideDe
   if (prop.type === "array") return buildArrayDefault(prop, effectiveDefault);
   if (effectiveDefault !== undefined) return effectiveDefault;
 
+  // A nullable numeric/boolean field (an array "type" on the ORIGINAL declaration) with no
+  // explicit default starts empty rather than a synthetic 0/false: unlike a string's natural ""
+  // default, that value looks user-provided, passes the non-empty submission filter in
+  // buildToolCallArguments, and gets sent to the tool even when the field was never touched.
+  const isNullable = Array.isArray(declared.type);
   switch (prop.type) {
     case "integer":
     case "number":
-      return 0;
+      return isNullable ? undefined : 0;
     case "boolean":
-      return false;
+      return isNullable ? undefined : false;
     default:
       return "";
   }
@@ -199,7 +210,11 @@ function buildDefaultValue(declared: InputSchemaProperty | undefined, overrideDe
 export const initialArgumentValues = (fields: readonly ToolArgumentField[]): unknown[] =>
   fields.map(({ prop }) => {
     const resolved = resolveSchemaProperty(prop);
-    const defaultValue = buildDefaultValue(resolved);
+    // Pass the RAW prop, not `resolved` - buildDefaultValue resolves it again internally, and
+    // needs the original `type` (possibly still an array) to know the field is nullable at all.
+    // Passing the pre-resolved (already-scalar) type here would make Array.isArray(declared.type)
+    // always false, silently defeating the nullable-omits-default behavior above.
+    const defaultValue = buildDefaultValue(prop);
     if (isJsonField(resolved)) {
       return isBlank(defaultValue) ? "" : JSON.stringify(defaultValue, null, 2);
     }
diff --git a/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.tsx b/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.tsx
index 0738c05ffc9..48fbcca0b88 100644
--- a/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.tsx
+++ b/ui/litellm-dashboard/src/components/mcp_tools/MCPToolArgumentsForm.tsx
@@ -129,7 +129,8 @@ function convertFormValues(
     }
   });
 
-  const isNestedParams = resolveSchemaType(schema.properties?.params?.type) === "object" && schema.properties?.params?.properties;
+  const isNestedParams =
+    resolveSchemaType(schema.properties?.params?.type) === "object" && schema.properties?.params?.properties;
 
   return isNestedParams ? { params: convertedValues } : convertedValues;
 }
@@ -326,7 +327,9 @@ const MCPToolArgumentsForm = forwardRef<MCPToolArgumentsFormRef, MCPToolArgument
                           className="font-mono"
                           placeholder={
                             prop.description ||
-                            (effectiveType === "object" ? `Enter JSON object for ${key}` : `Enter JSON array for ${key}`)
+                            (effectiveType === "object"
+                              ? `Enter JSON object for ${key}`
+                              : `Enter JSON array for ${key}`)
                           }
                         />
                       );