@sealab/mcp-server 1.0.2 → 1.0.3

package/dist/tools/orders.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.orderTools = void 0;
+exports.orderTools = exports.ArticleItemSchema = void 0;
 exports.getOrderBreakdown = getOrderBreakdown;
 exports.getPositionBreakdown = getPositionBreakdown;
 exports.createEditCart = createEditCart;
@@ -211,7 +211,7 @@ async function applySavedSettingToArticle(article) {
 async function applySavedSettingsToArticles(articles) {
     return Promise.all(articles.map(applySavedSettingToArticle));
 }
-const ArticleItemSchema = zod_1.z.object({
+exports.ArticleItemSchema = zod_1.z.object({
     serialNumber: zod_1.z.string(),
     positionName: zod_1.z.string().max(25).describe('Unique label for this cabinet within the order. Must be unique across ALL articles in the order. ' +
         'Derive from the cabinet display name: "Upper 1125" → "Upper", "Base Cabinet" → "Base". ' +
@@ -364,7 +364,7 @@ const SubmitCartAsVersionSchema = zod_1.z.object({
 });
 const AddArticlesToCartSchema = zod_1.z.object({
     tempOrderId: zod_1.z.string().describe('Saved cart reference ID — a plain numeric string returned by create_saved_cart or list_saved_carts (e.g. "901787"). Do NOT add any prefix such as "SavedCart_".'),
-    articles: flexArray(ArticleItemSchema).describe('Articles to add to the cart.'),
+    articles: flexArray(exports.ArticleItemSchema).describe('Articles to add to the cart.'),
 });
 const GetSavedCartSchema = zod_1.z.object({
     tempOrderId: zod_1.z.string().describe('Saved cart reference ID — a plain numeric string returned by create_saved_cart or list_saved_carts (e.g. "901787"). Do NOT add any prefix such as "SavedCart_".'),
@@ -411,7 +411,7 @@ const DeleteSavedCartArticlesSchema = zod_1.z.object({
     positionNames: flexArray(zod_1.z.string()).describe('Position names of the articles to delete.'),
 });
 const CreateOrderSchema = zod_1.z.object({
-    articles: flexArray(ArticleItemSchema).describe('Line items to order.'),
+    articles: flexArray(exports.ArticleItemSchema).describe('Line items to order.'),
     projectName: zod_1.z.string().describe('Project name for this order'),
     purchaseOrder: zod_1.z.string().describe('Purchase order number'),
     projectAddress: ProjectAddressSchema.optional().describe('Project address (where cabinets will be installed)'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sealab/mcp-server",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "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,11 @@ import { configurationInfoTools } from './tools/configuration-info';
 import { savedSettingsTools } from './tools/saved-settings';
 import { canvasTools } from './tools/canvas';
 import { permissionTools } from './tools/permissions';
+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, ...aiDrawingTools, ...aiDrawingOverlayTools];
 
 const server = new Server(
   { name: 'sealab', version: '1.0.0' },
@@ -23,7 +26,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>;
+}> = [];