feat: add eslint rule to validate tool schema patterns

Add `@local/no-zod-nullable-object` ESLint rule that disallows
`.nullable()` and `.object()` in tool schemas (src/tools/**).
Fix existing violation in fill_form by using "uid=value" string
format instead of zod.object(). Remove the TODO from CONTRIBUTING.md.

Closes ChromeDevTools#1076

Author: mvanhorn

CONTRIBUTING.md

@@ -145,7 +145,5 @@ export const scenario: TestScenario = {
 
 ## Restrictions on JSON schema
 
-- no .nullable(), no .object() types.
+- no .nullable(), no .object() types. Enforced by the `@local/no-zod-nullable-object` ESLint rule.
 - represent complex object as a short formatted string.
-
-TODO: implement eslint for schema https://github.com/ChromeDevTools/chrome-devtools-mcp/issues/1076

eslint.config.mjs

@@ -134,6 +134,13 @@ export default defineConfig([
       ],
     },
   },
+  {
+    name: 'Tool schema restrictions',
+    files: ['src/tools/**/*.ts'],
+    rules: {
+      '@local/no-zod-nullable-object': 'error',
+    },
+  },
   {
     name: 'Tests',
     files: ['**/*.test.ts'],

scripts/eslint_rules/local-plugin.js

@@ -5,5 +5,11 @@
  */
 
 import checkLicenseRule from './check-license-rule.js';
+import noZodNullableObjectRule from './no-zod-nullable-object-rule.js';
 
-export default {rules: {'check-license': checkLicenseRule}};
+export default {
+  rules: {
+    'check-license': checkLicenseRule,
+    'no-zod-nullable-object': noZodNullableObjectRule,
+  },
+};

scripts/eslint_rules/no-zod-nullable-object-rule.js

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export default {
+  name: 'no-zod-nullable-object',
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow .nullable() and .object() in tool schemas. Use optional strings to represent complex objects.',
+    },
+    schema: [],
+    messages: {
+      noNullable:
+        'Do not use .nullable() in tool schemas. Use .optional() instead.',
+      noObject:
+        'Do not use .object() in tool schemas. Represent complex objects as a short formatted string.',
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (
+          node.callee.type !== 'MemberExpression' ||
+          node.callee.property.type !== 'Identifier'
+        ) {
+          return;
+        }
+
+        const methodName = node.callee.property.name;
+
+        if (methodName === 'nullable') {
+          context.report({
+            node: node.callee.property,
+            messageId: 'noNullable',
+          });
+        }
+
+        if (methodName === 'object') {
+          // Only flag zod.object() calls, not arbitrary .object() calls.
+          const obj = node.callee.object;
+          if (
+            obj.type === 'Identifier' &&
+            (obj.name === 'zod' || obj.name === 'z')
+          ) {
+            context.report({
+              node: node.callee.property,
+              messageId: 'noObject',
+            });
+          }
+        }
+      },
+    };
+  },
+};

src/tools/input.ts

@@ -319,25 +319,25 @@ export const fillForm = definePageTool({
   },
   schema: {
     elements: zod
-      .array(
-        zod.object({
-          uid: zod.string().describe('The uid of the element to fill out'),
-          value: zod.string().describe('Value for the element'),
-        }),
-      )
-      .describe('Elements from snapshot to fill out.'),
+      .array(zod.string())
+      .describe(
+        'Elements from snapshot to fill out. Each entry is formatted as "uid=value".',
+      ),
     includeSnapshot: includeSnapshotSchema,
   },
   handler: async (request, response, context) => {
     const page = request.page;
-    for (const element of request.params.elements) {
-      await context.waitForEventsAfterAction(async () => {
-        await fillFormElement(
-          element.uid,
-          element.value,
-          context as McpContext,
-          page,
+    for (const entry of request.params.elements) {
+      const separatorIndex = entry.indexOf('=');
+      if (separatorIndex === -1) {
+        throw new Error(
+          `Invalid element format: "${entry}". Expected "uid=value".`,
         );
+      }
+      const uid = entry.slice(0, separatorIndex);
+      const value = entry.slice(separatorIndex + 1);
+      await context.waitForEventsAfterAction(async () => {
+        await fillFormElement(uid, value, context as McpContext, page);
       });
     }
     response.appendResponseLine(`Successfully filled out the form`);

tests/tools/input.test.ts

@@ -670,16 +670,7 @@ describe('input', () => {
         await fillForm.handler(
           {
             params: {
-              elements: [
-                {
-                  uid: '1_2',
-                  value: 'test',
-                },
-                {
-                  uid: '1_4',
-                  value: 'test2',
-                },
-              ],
+              elements: ['1_2=test', '1_4=test2'],
             },
             page: context.getSelectedMcpPage(),
           },