@sealab/mcp-server 1.0.2 → 1.0.4

package/dist/tools/projects.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectTools = void 0;
+exports.listProjects = listProjects;
+exports.getProject = getProject;
+exports.createProject = createProject;
+exports.updateProject = updateProject;
+exports.deleteProject = deleteProject;
+exports.attachOrderToProject = attachOrderToProject;
+exports.detachOrderFromProject = detachOrderFromProject;
+exports.updateProjectOrderQuantity = updateProjectOrderQuantity;
+exports.updateProjectOrderOptions = updateProjectOrderOptions;
+exports.updateProjectArticleMaterial = updateProjectArticleMaterial;
+exports.updateProjectArticleMaterials = updateProjectArticleMaterials;
+exports.shareProjectAccess = shareProjectAccess;
+exports.updateProjectAccess = updateProjectAccess;
+exports.revokeProjectAccess = revokeProjectAccess;
+exports.listProjectAccess = listProjectAccess;
+const zod_1 = require("zod");
+const api_client_1 = require("../client/api-client");
+const ProjectStatusSchema = zod_1.z.enum(['Active', 'On Hold', 'Complete']);
+const PermissionTypeSchema = zod_1.z.enum(['VIEW', 'EDIT', 'ADMIN']);
+const MaterialFieldSchema = zod_1.z.enum(['caseMaterial', 'frontMaterial', 'backPanelMaterial', 'innerCaseMaterial']);
+const FinishingTypeSchema = zod_1.z.enum(['Matte', 'Satin', 'Primed']);
+const ListProjectsSchema = zod_1.z.object({});
+const GetProjectSchema = zod_1.z.object({
+    projectId: zod_1.z.number().int().positive().describe('Project ID. Use list_projects first if unknown.'),
+});
+const ProjectInputSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1).describe('Project name.'),
+    address1: zod_1.z.string().optional().describe('Project address line 1.'),
+    address2: zod_1.z.string().optional().describe('Project address line 2.'),
+    city: zod_1.z.string().optional().describe('Project city.'),
+    state: zod_1.z.string().optional().describe('Project state.'),
+    zipcode: zod_1.z.string().optional().describe('Project ZIP/postal code.'),
+    status: ProjectStatusSchema.default('Active').describe('Project status.'),
+    phase: zod_1.z.string().optional().describe('Project phase, e.g. Design, Shop Drawings, Install.'),
+    clientName: zod_1.z.string().optional().describe('Client or end-customer name.'),
+    budget: zod_1.z.number().optional().describe('Optional project budget.'),
+    dueDate: zod_1.z.string().optional().describe('Optional due date in YYYY-MM-DD format.'),
+    taxExempt: zod_1.z.boolean().optional().describe('Whether project summary pricing should display without sales tax.'),
+    notes: zod_1.z.string().optional().describe('Project notes.'),
+});
+const CreateProjectSchema = ProjectInputSchema;
+const UpdateProjectSchema = ProjectInputSchema.partial().extend({
+    projectId: zod_1.z.number().int().positive().describe('Project ID to update.'),
+});
+const DeleteProjectSchema = zod_1.z.object({
+    projectId: zod_1.z.number().int().positive().describe('Project ID to delete.'),
+});
+const ProjectOrderSchema = zod_1.z.object({
+    projectId: zod_1.z.number().int().positive().describe('Project ID.'),
+    orderId: zod_1.z.string().describe('Order ID to attach or detach.'),
+});
+const UpdateProjectOrderQuantitySchema = ProjectOrderSchema.extend({
+    quantity: zod_1.z.number().int().min(1).describe('Project quantity multiplier for this order. Does not change the order itself.'),
+});
+const UpdateProjectOrderOptionsSchema = ProjectOrderSchema.extend({
+    includeDrawerboxes: zod_1.z.boolean().optional().describe('Include drawer boxes for this order. Omit to leave unchanged.'),
+    includeAssembly: zod_1.z.boolean().optional().describe('Include assembly for this order. Omit to leave unchanged.'),
+    includeHardware: zod_1.z.boolean().optional().describe('Include hardware for this order. Omit to leave unchanged.'),
+    includeFinishing: zod_1.z.boolean().optional().describe('Include finishing for this order. Omit to leave unchanged.'),
+    finishingType: FinishingTypeSchema.optional().describe('Finishing type. Required when setting includeFinishing to true.'),
+    finishingColor: zod_1.z.string().optional().describe('Finishing color. Required when setting includeFinishing to true.'),
+});
+const UpdateProjectArticleMaterialSchema = ProjectOrderSchema.extend({
+    positionName: zod_1.z.string().describe('Article position name within the order, e.g. "Base_01".'),
+    field: MaterialFieldSchema.describe('Material field to update.'),
+    materialDescription: zod_1.z.string().min(1).describe('Exact material description from the Sealab material list.'),
+});
+const UpdateProjectArticleMaterialsSchema = ProjectOrderSchema.extend({
+    positionNames: zod_1.z.array(zod_1.z.string()).min(1).describe('Article position names to update.'),
+    field: MaterialFieldSchema.describe('Material field to update.'),
+    materialDescription: zod_1.z.string().min(1).describe('Exact material description from the Sealab material list.'),
+});
+const ProjectAccessSchema = zod_1.z.object({
+    projectId: zod_1.z.number().int().positive().describe('Project ID.'),
+    grantedToEmail: zod_1.z.string().email().describe('Email address to grant or update access for.'),
+    permissionType: PermissionTypeSchema.default('VIEW').describe('VIEW = read-only, EDIT = can update project/order options, ADMIN = admin-level project permission.'),
+    hidePrice: zod_1.z.boolean().default(false).describe('Whether to hide project pricing from this user.'),
+});
+const RevokeProjectAccessSchema = zod_1.z.object({
+    projectId: zod_1.z.number().int().positive().describe('Project ID.'),
+    email: zod_1.z.string().email().describe('Email address whose project access should be revoked.'),
+});
+const ListProjectAccessSchema = zod_1.z.object({
+    projectId: zod_1.z.number().int().positive().describe('Project ID.'),
+});
+function compactProject(project) {
+    return {
+        projectId: project.projectId,
+        name: project.name,
+        status: project.status,
+        phase: project.phase,
+        clientName: project.clientName,
+        address: [project.address1, project.address2, project.city, project.state, project.zipcode].filter(Boolean).join(', '),
+        shared: project.shared,
+        permissionType: project.permissionType,
+        hidePrice: project.hidePrice,
+        updatedAt: project.updatedAt,
+        orderCount: project.orders?.length ?? project.summary?.orderSummaries?.length,
+        projectTotalValue: project.hidePrice ? undefined : project.summary?.projectTotalValue,
+    };
+}
+function formatProjectList(projects) {
+    if (!projects || projects.length === 0)
+        return 'No projects found.';
+    return JSON.stringify(projects.map(compactProject), null, 2);
+}
+function formatProject(project) {
+    return JSON.stringify(project, null, 2);
+}
+async function apiError(error, fallback) {
+    try {
+        (0, api_client_1.handleAxiosError)(error);
+    }
+    catch (e) {
+        return e.message;
+    }
+    return fallback;
+}
+async function listProjects(_) {
+    try {
+        const { data } = await api_client_1.client.get('/projects');
+        return formatProjectList(data);
+    }
+    catch (error) {
+        return apiError(error, 'Unexpected error listing projects.');
+    }
+}
+async function getProject(input) {
+    try {
+        const { data } = await api_client_1.client.get(`/projects/${input.projectId}`);
+        return formatProject(data);
+    }
+    catch (error) {
+        return apiError(error, 'Unexpected error fetching project.');
+    }
+}
+async function createProject(input) {
+    try {
+        const { data } = await api_client_1.client.post('/projects', input);
+        return `Project created successfully. Project ID: ${data.projectId}. Name: ${data.name}.`;
+    }
+    catch (error) {
+        return apiError(error, 'Unexpected error creating project.');
+    }
+}
+async function updateProject(input) {
+    const { projectId, ...payload } = input;
+    try {
+        const { data: current } = await api_client_1.client.get(`/projects/${projectId}`);
+        const { data } = await api_client_1.client.put(`/projects/${projectId}`, { ...current, ...payload });
+        return `Project updated successfully.\n${formatProject(data)}`;
+    }
+    catch (error) {
+        return apiError(error, 'Unexpected error updating project.');
+    }
+}
+async function deleteProject(input) {
+    try {
+        await api_client_1.client.delete(`/projects/${input.projectId}`);
+        return `Project ${input.projectId} deleted successfully. Pending attached orders were detached, not deleted.`;
+    }
+    catch (error) {
+        return apiError(error, 'Unexpected error deleting project.');
+    }
+}
+async function attachOrderToProject(input) {
+    try {
+        await api_client_1.client.post(`/projects/${input.projectId}/orders/${input.orderId}`);
+        return `Order ${input.orderId} attached to project ${input.projectId}.`;
+    }
+    catch (error) {
+        return apiError(error, 'Unexpected error attaching order to project.');
+    }
+}
+async function detachOrderFromProject(input) {
+    try {
+        await api_client_1.client.delete(`/projects/${input.projectId}/orders/${input.orderId}`);
+        return `Order ${input.orderId} detached from project ${input.projectId}.`;
+    }
+    catch (error) {
+        return apiError(error, 'Unexpected error detaching order from project.');
+    }
+}
+async function updateProjectOrderQuantity(input) {
+    try {
+        const { data } = await api_client_1.client.put(`/projects/${input.projectId}/orders/${input.orderId}/quantity`, {
+            quantity: input.quantity,
+        });
+        return `Project order quantity updated.\n${formatProject(data)}`;
+    }
+    catch (error) {
+        return apiError(error, 'Unexpected error updating project order quantity.');
+    }
+}
+async function updateProjectOrderOptions(input) {
+    const { projectId, orderId, ...payload } = input;
+    try {
+        const { data } = await api_client_1.client.patch(`/projects/${projectId}/orders/${orderId}/options`, payload);
+        return `Project order options updated.\n${JSON.stringify(data, null, 2)}`;
+    }
+    catch (error) {
+        return apiError(error, 'Unexpected error updating project order options.');
+    }
+}
+async function updateProjectArticleMaterial(input) {
+    try {
+        const { data } = await api_client_1.client.patch(`/projects/${input.projectId}/orders/${input.orderId}/articles/${encodeURIComponent(input.positionName)}/materials`, { field: input.field, materialDescription: input.materialDescription });
+        return `Project article material updated.\n${JSON.stringify(data, null, 2)}`;
+    }
+    catch (error) {
+        return apiError(error, 'Unexpected error updating project article material.');
+    }
+}
+async function updateProjectArticleMaterials(input) {
+    try {
+        const { data } = await api_client_1.client.patch(`/projects/${input.projectId}/orders/${input.orderId}/articles/materials`, { positionNames: input.positionNames, field: input.field, materialDescription: input.materialDescription });
+        return `Project article materials updated.\n${JSON.stringify(data, null, 2)}`;
+    }
+    catch (error) {
+        return apiError(error, 'Unexpected error updating project article materials.');
+    }
+}
+async function shareProjectAccess(input) {
+    try {
+        await api_client_1.client.post(`/projects/${input.projectId}/permissions/grant`, {
+            grantedToEmail: input.grantedToEmail,
+            permissionType: input.permissionType,
+            hidePrice: input.hidePrice,
+        });
+        const priceNote = input.hidePrice ? ' Pricing will be hidden from them.' : '';
+        return `Access granted. ${input.grantedToEmail} now has ${input.permissionType} access to project ${input.projectId}.${priceNote}`;
+    }
+    catch (error) {
+        return apiError(error, 'Unexpected error granting project access.');
+    }
+}
+async function updateProjectAccess(input) {
+    try {
+        await api_client_1.client.put(`/projects/${input.projectId}/permissions/update`, {
+            grantedToEmail: input.grantedToEmail,
+            permissionType: input.permissionType,
+            hidePrice: input.hidePrice,
+        });
+        const priceNote = input.hidePrice ? ' Pricing is hidden from them.' : ' Pricing is visible to them.';
+        return `Permission updated. ${input.grantedToEmail} now has ${input.permissionType} access to project ${input.projectId}.${priceNote}`;
+    }
+    catch (error) {
+        return apiError(error, 'Unexpected error updating project access.');
+    }
+}
+async function revokeProjectAccess(input) {
+    try {
+        await api_client_1.client.delete(`/projects/${input.projectId}/permissions/revoke`, {
+            params: { email: input.email },
+        });
+        return `Access revoked. ${input.email} can no longer access project ${input.projectId}.`;
+    }
+    catch (error) {
+        return apiError(error, 'Unexpected error revoking project access.');
+    }
+}
+async function listProjectAccess(input) {
+    try {
+        const { data } = await api_client_1.client.get(`/projects/${input.projectId}/permissions`);
+        if (!data || data.length === 0) {
+            return `No shared access on project ${input.projectId}. Only the project owner can view it.`;
+        }
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        return apiError(error, 'Unexpected error listing project access.');
+    }
+}
+exports.projectTools = [
+    {
+        name: 'list_projects',
+        description: 'List projects available to the authenticated customer, including owned and shared projects. Use this before choosing a projectId.',
+        inputSchema: ListProjectsSchema,
+        handler: listProjects,
+    },
+    {
+        name: 'get_project',
+        description: 'Get full project details including attached orders, material/service/component summaries, custom line items, and permission metadata.',
+        inputSchema: GetProjectSchema,
+        handler: getProject,
+    },
+    {
+        name: 'create_project',
+        description: 'Create a new customer project. Use this when the customer wants a new job/project container before attaching or placing orders.',
+        inputSchema: CreateProjectSchema,
+        handler: createProject,
+    },
+    {
+        name: 'update_project',
+        description: 'Update project metadata such as name, address, status, phase, client, budget, due date, tax exemption, or notes. Omitted fields are left unchanged.',
+        inputSchema: UpdateProjectSchema,
+        handler: updateProject,
+    },
+    {
+        name: 'delete_project',
+        description: 'Delete a project owned by the customer. Production or paid attached orders block deletion; pending orders are detached and remain in order history.',
+        inputSchema: DeleteProjectSchema,
+        handler: deleteProject,
+    },
+    {
+        name: 'attach_order_to_project',
+        description: 'Attach one of the customer-owned orders to a project the customer can edit. This copies the project snapshot to the order.',
+        inputSchema: ProjectOrderSchema,
+        handler: attachOrderToProject,
+    },
+    {
+        name: 'detach_order_from_project',
+        description: 'Remove an order from a project without deleting the order.',
+        inputSchema: ProjectOrderSchema,
+        handler: detachOrderFromProject,
+    },
+    {
+        name: 'update_project_order_quantity',
+        description: 'Set the project quantity multiplier for an attached order. This affects project summaries only; it does not alter the actual order.',
+        inputSchema: UpdateProjectOrderQuantitySchema,
+        handler: updateProjectOrderQuantity,
+    },
+    {
+        name: 'update_project_order_options',
+        description: 'Update service options for an order within a project: drawerboxes, assembly, hardware, finishing type/color. Omit unchanged fields.',
+        inputSchema: UpdateProjectOrderOptionsSchema,
+        handler: updateProjectOrderOptions,
+    },
+    {
+        name: 'update_project_article_material',
+        description: 'Update a material field for one cabinet/article in an attached project order. Use exact material descriptions.',
+        inputSchema: UpdateProjectArticleMaterialSchema,
+        handler: updateProjectArticleMaterial,
+    },
+    {
+        name: 'update_project_article_materials',
+        description: 'Bulk update a material field for multiple cabinet/article positions in an attached project order. Use exact material descriptions.',
+        inputSchema: UpdateProjectArticleMaterialsSchema,
+        handler: updateProjectArticleMaterials,
+    },
+    {
+        name: 'share_project_access',
+        description: 'Grant another user access to a project. Project owners only. Permission levels are VIEW, EDIT, and ADMIN; hidePrice hides project pricing.',
+        inputSchema: ProjectAccessSchema,
+        handler: shareProjectAccess,
+    },
+    {
+        name: 'update_project_access',
+        description: 'Update an existing project permission level or price visibility. Project owners only.',
+        inputSchema: ProjectAccessSchema,
+        handler: updateProjectAccess,
+    },
+    {
+        name: 'revoke_project_access',
+        description: 'Revoke a user from a project. Project owners only.',
+        inputSchema: RevokeProjectAccessSchema,
+        handler: revokeProjectAccess,
+    },
+    {
+        name: 'list_project_access',
+        description: 'List users who currently have shared access to a project. Project owners only.',
+        inputSchema: ListProjectAccessSchema,
+        handler: listProjectAccess,
+    },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sealab/mcp-server",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "MCP server for the Sealab cabinetry catalog",
   "main": "dist/index.js",
   "bin": {
@@ -17,14 +17,16 @@
     "@modelcontextprotocol/sdk": "^1.0.0",
     "axios": "^1.6.0",
     "form-data": "^4.0.0",
+    "pngjs": "^7.0.0",
     "zod": "^3.22.0",
     "zod-to-json-schema": "^3.22.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
+    "@types/pngjs": "^6.0.5",
+    "ts-node": "^10.9.0",
     "typescript": "^5.3.0",
-    "vitest": "^1.0.0",
-    "ts-node": "^10.9.0"
+    "vitest": "^1.0.0"
   },
   "engines": {
     "node": ">=18"

package/src/client/api-client.ts

@@ -7,13 +7,21 @@ if (!API_KEY) {
   throw new Error('SEALAB_API_KEY environment variable is required');
 }
 
-export const client: AxiosInstance = axios.create({
-  baseURL: `${API_URL}/api/mcp/v1`,
-  headers: {
-    'X-API-Key': API_KEY,
-  },
-  timeout: 10000,
-});
+export const client: AxiosInstance = axios.create({
+  baseURL: `${API_URL}/api/mcp/v1`,
+  headers: {
+    'X-API-Key': API_KEY,
+  },
+  timeout: 10000,
+});
+
+export const aiDrawingClient: AxiosInstance = axios.create({
+  baseURL: `${API_URL}/api/ai-drawing/v1`,
+  headers: {
+    'X-API-Key': API_KEY,
+  },
+  timeout: 10000,
+});
 
 export class McpApiError extends Error {
   constructor(public readonly status: number, message: string) {

package/src/index.ts

@@ -11,8 +11,12 @@ import { configurationInfoTools } from './tools/configuration-info';
 import { savedSettingsTools } from './tools/saved-settings';
 import { canvasTools } from './tools/canvas';
 import { permissionTools } from './tools/permissions';
+import { projectTools } from './tools/projects';
+import { aiDrawingTools } from './tools/ai-drawing';
+import { aiDrawingOverlayTools } from './tools/ai-drawing-overlay';
+import { normalizeMcpJsonSchema } from './schema-normalizer';
 
-const allTools = [...catalogTools, ...orderTools, ...configurationTools, ...configurationInfoTools, ...savedSettingsTools, ...canvasTools, ...permissionTools];
+const allTools = [...catalogTools, ...orderTools, ...configurationTools, ...configurationInfoTools, ...savedSettingsTools, ...canvasTools, ...permissionTools, ...projectTools, ...aiDrawingTools, ...aiDrawingOverlayTools];
 
 const server = new Server(
   { name: 'sealab', version: '1.0.0' },
@@ -23,7 +27,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
   tools: allTools.map((t) => ({
     name: t.name,
     description: t.description,
-    inputSchema: zodToJsonSchema(t.inputSchema as any, { target: 'openApi3' }),
+    inputSchema: normalizeMcpJsonSchema(zodToJsonSchema(t.inputSchema as any, { target: 'openApi3' })),
   })),
 }));
 

package/src/schema-normalizer.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeMcpJsonSchema } from './schema-normalizer';
+
+describe('normalizeMcpJsonSchema', () => {
+  it('converts OpenAPI boolean exclusiveMinimum into JSON Schema numeric exclusiveMinimum', () => {
+    expect(normalizeMcpJsonSchema({
+      type: 'number',
+      minimum: 0,
+      exclusiveMinimum: true,
+    })).toEqual({
+      type: 'number',
+      exclusiveMinimum: 0,
+    });
+  });
+
+  it('converts OpenAPI boolean exclusiveMaximum into JSON Schema numeric exclusiveMaximum', () => {
+    expect(normalizeMcpJsonSchema({
+      type: 'number',
+      maximum: 1000,
+      exclusiveMaximum: true,
+    })).toEqual({
+      type: 'number',
+      exclusiveMaximum: 1000,
+    });
+  });
+
+  it('removes false exclusive bounds without changing inclusive bounds', () => {
+    expect(normalizeMcpJsonSchema({
+      type: 'number',
+      minimum: 0,
+      maximum: 1000,
+      exclusiveMinimum: false,
+      exclusiveMaximum: false,
+    })).toEqual({
+      type: 'number',
+      minimum: 0,
+      maximum: 1000,
+    });
+  });
+
+  it('normalizes nested placement item schemas', () => {
+    const normalized = normalizeMcpJsonSchema({
+      type: 'object',
+      properties: {
+        placements: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              height: {
+                type: 'number',
+                minimum: 0,
+                exclusiveMinimum: true,
+              },
+            },
+          },
+        },
+      },
+    }) as any;
+
+    expect(normalized.properties.placements.items.properties.height).toEqual({
+      type: 'number',
+      exclusiveMinimum: 0,
+    });
+  });
+
+  it('collapses homogeneous tuple items into a Gemini-compatible item schema', () => {
+    const normalized = normalizeMcpJsonSchema({
+      type: 'array',
+      minItems: 4,
+      maxItems: 4,
+      items: [
+        { type: 'number', minimum: 0, maximum: 1000 },
+        { $ref: '#/properties/proposals/items/properties/bbox/items/0' },
+        { $ref: '#/properties/proposals/items/properties/bbox/items/0' },
+        { $ref: '#/properties/proposals/items/properties/bbox/items/0' },
+      ],
+    }) as any;
+
+    expect(Array.isArray(normalized.items)).toBe(false);
+    expect(normalized).toEqual({
+      type: 'array',
+      minItems: 4,
+      maxItems: 4,
+      items: { type: 'number', minimum: 0, maximum: 1000 },
+    });
+  });
+
+  it('keeps heterogeneous tuple schemas valid by using anyOf item schemas', () => {
+    const normalized = normalizeMcpJsonSchema({
+      type: 'array',
+      minItems: 2,
+      maxItems: 2,
+      items: [
+        { type: 'number' },
+        { type: 'string' },
+      ],
+    }) as any;
+
+    expect(normalized.items).toEqual({
+      anyOf: [
+        { type: 'number' },
+        { type: 'string' },
+      ],
+    });
+  });
+});

package/src/schema-normalizer.ts

@@ -0,0 +1,86 @@
+type JsonObject = { [key: string]: unknown };
+
+function isJsonObject(value: unknown): value is JsonObject {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function normalizeExclusiveBounds(schema: JsonObject): JsonObject {
+  const normalized = { ...schema };
+
+  if (normalized.exclusiveMinimum === true) {
+    if (typeof normalized.minimum === 'number') {
+      normalized.exclusiveMinimum = normalized.minimum;
+      delete normalized.minimum;
+    } else {
+      delete normalized.exclusiveMinimum;
+    }
+  } else if (normalized.exclusiveMinimum === false) {
+    delete normalized.exclusiveMinimum;
+  }
+
+  if (normalized.exclusiveMaximum === true) {
+    if (typeof normalized.maximum === 'number') {
+      normalized.exclusiveMaximum = normalized.maximum;
+      delete normalized.maximum;
+    } else {
+      delete normalized.exclusiveMaximum;
+    }
+  } else if (normalized.exclusiveMaximum === false) {
+    delete normalized.exclusiveMaximum;
+  }
+
+  return normalized;
+}
+
+function schemaSignature(schema: unknown): string {
+  if (Array.isArray(schema)) {
+    return `[${schema.map((item) => schemaSignature(item)).join(',')}]`;
+  }
+
+  if (!isJsonObject(schema)) {
+    return JSON.stringify(schema);
+  }
+
+  return `{${Object.keys(schema)
+    .sort()
+    .map((key) => `${JSON.stringify(key)}:${schemaSignature(schema[key])}`)
+    .join(',')}}`;
+}
+
+function isRefToFirstTupleItem(item: unknown): boolean {
+  return isJsonObject(item) && typeof item.$ref === 'string' && item.$ref.endsWith('/items/0');
+}
+
+function normalizeTupleItems(schema: JsonObject): JsonObject {
+  if (!Array.isArray(schema.items)) {
+    return schema;
+  }
+
+  const normalizedItems = schema.items.map((item) => normalizeMcpJsonSchema(item));
+  const firstItem = normalizedItems[0];
+  const allItemsMatchFirst = normalizedItems.every((item) => (
+    schemaSignature(item) === schemaSignature(firstItem) || isRefToFirstTupleItem(item)
+  ));
+
+  return {
+    ...schema,
+    items: allItemsMatchFirst ? firstItem : { anyOf: normalizedItems },
+  };
+}
+
+export function normalizeMcpJsonSchema(schema: unknown): unknown {
+  if (Array.isArray(schema)) {
+    return schema.map((item) => normalizeMcpJsonSchema(item));
+  }
+
+  if (!isJsonObject(schema)) {
+    return schema;
+  }
+
+  const normalized = normalizeTupleItems(normalizeExclusiveBounds(schema));
+  for (const [key, value] of Object.entries(normalized)) {
+    normalized[key] = normalizeMcpJsonSchema(value);
+  }
+
+  return normalized;
+}

package/src/tools/ai-drawing-overlay.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from 'vitest';
+
+import { aiDrawingOverlayTools } from './ai-drawing-overlay';
+
+describe('aiDrawingOverlayTools', () => {
+  it('does not register overlay extraction or placement-candidate tools in the MCP surface', () => {
+    expect(aiDrawingOverlayTools).toEqual([]);
+  });
+});

package/src/tools/ai-drawing-overlay.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+export const aiDrawingOverlayTools: Array<{
+  name: string;
+  description: string;
+  inputSchema: z.ZodTypeAny;
+  handler: (input: unknown) => Promise<string>;
+}> = [];