@sealab/mcp-server 1.0.0

package/src/tools/catalog.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { client, handleAxiosError } from '../client/api-client';
+
+// --- Schemas ---
+
+const SearchSchema = z.object({
+  q: z.string().optional().describe('Keyword search query'),
+  tags: z.array(z.string()).optional().describe('Filter by tag (e.g. BASE, WALL, PANTRY)'),
+  minH: z.number().optional().describe('Minimum height in inches'),
+  maxH: z.number().optional().describe('Maximum height in inches'),
+  minW: z.number().optional().describe('Minimum width in inches'),
+  maxW: z.number().optional().describe('Maximum width in inches'),
+  minD: z.number().optional().describe('Minimum depth in inches'),
+  maxD: z.number().optional().describe('Maximum depth in inches'),
+});
+
+const GetArticleSchema = z.object({
+  serialNumber: z.string().describe('Article serial number, e.g. B30'),
+});
+
+const ListFilterTagsSchema = z.object({});
+
+// --- Handlers ---
+
+export async function searchCatalog(input: z.infer<typeof SearchSchema>): Promise<string> {
+  try {
+    const { data } = await client.get('/catalog/search', {
+      params: { ...input },
+      paramsSerializer: { indexes: null }, // produces tags=BASE&tags=WALL (not tags[]=)
+    });
+    if (!data || data.length === 0) return 'No articles found matching your search.';
+    return JSON.stringify(data, null, 2);
+  } catch (error) {
+    try { handleAxiosError(error); } catch (e: any) { return e.message; }
+    return 'Unexpected error searching catalog.';
+  }
+}
+
+export async function getArticle(input: z.infer<typeof GetArticleSchema>): Promise<string> {
+  try {
+    const { data } = await client.get(`/catalog/${input.serialNumber}`);
+    return JSON.stringify(data, null, 2);
+  } catch (error) {
+    try { handleAxiosError(error); } catch (e: any) { return e.message; }
+    return 'Unexpected error fetching article.';
+  }
+}
+
+export async function listFilterTags(_input: z.infer<typeof ListFilterTagsSchema>): Promise<string> {
+  try {
+    const { data } = await client.get('/catalog/filter-tags');
+    return (data as string[]).join('\n');
+  } catch (error) {
+    try { handleAxiosError(error); } catch (e: any) { return e.message; }
+    return 'Unexpected error fetching filter tags.';
+  }
+}
+
+// --- Tool definitions (consumed by index.ts) ---
+
+export const catalogTools = [
+  {
+    name: 'search_catalog',
+    description: 'Search the Sealab cabinetry catalog by keyword, filter tags, or dimension ranges. Returns matching articles with serial numbers, dimensions, and feature flags.',
+    inputSchema: SearchSchema,
+    handler: searchCatalog,
+  },
+  {
+    name: 'get_article',
+    description: 'Get full details for a single cabinet article by its serial number.',
+    inputSchema: GetArticleSchema,
+    handler: getArticle,
+  },
+  {
+    name: 'list_filter_tags',
+    description: 'List all available filter tag categories in the catalog (e.g. BASE, WALL, PANTRY, TALL).',
+    inputSchema: ListFilterTagsSchema,
+    handler: listFilterTags,
+  },
+];

package/src/tools/configuration-info.ts

@@ -0,0 +1,274 @@
+import { z } from 'zod';
+import * as fs from 'fs';
+import * as path from 'path';
+import { client, handleAxiosError } from '../client/api-client';
+
+// All fields with a corresponding .txt file in resources/tooltips/
+const VALID_FIELDS = [
+  'backPanel',
+  'backPanelMaterial',
+  'caseEdge',
+  'caseMaterial',
+  'depth',
+  'drawerType',
+  'edgeBandingType',
+  'excludeFronts',
+  'frontEdge',
+  'frontMaterial',
+  'gapBottom',
+  'gapCenter',
+  'gapLeft',
+  'gapRight',
+  'gapTop',
+  'height',
+  'hingePlate',
+  'includeLegLevelers',
+  'jointMethod',
+  'leftCornerWidth',
+  'numOfShelves',
+  'positionName',
+  'rightCornerDepth',
+  'topDrwrHeight',
+  'width',
+] as const;
+
+type ValidField = typeof VALID_FIELDS[number];
+
+const SerialNumberSchema = z.object({
+  serialNumber: z.string().describe('Article serial number'),
+});
+
+const GetArticleContextSchema = SerialNumberSchema;
+const GetArticleOptionsSchema = SerialNumberSchema;
+
+const GetConfigInfoSchema = z.object({
+  field: z.enum(VALID_FIELDS).describe('The configuration field name to get full detail for'),
+});
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Strip HTML tags and collapse whitespace for clean plain-text output */
+function stripHtml(html: string): string {
+  return html
+    .replace(/<[^>]*>/g, ' ')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+/** Read a tooltip file, returns null if missing */
+function readTooltip(field: string): string | null {
+  const filePath = path.join(__dirname, '..', '..', 'resources', 'tooltips', `${field}.txt`);
+  try {
+    return stripHtml(fs.readFileSync(filePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/** Derive the list of applicable config fields from the configuration response */
+function getApplicableFields(config: Record<string, any>): ValidField[] {
+  const fields: ValidField[] = ['positionName', 'height', 'width', 'depth'];
+
+  if (config.hasCase === true)                        fields.push('caseMaterial');
+  if (config.hasMatCaseThin === true)                 fields.push('caseMaterial'); // inner — same file
+  if (config.hasFront === true)                       fields.push('frontMaterial');
+  if (config.hasCase === true && config.hasFront === true) fields.push('excludeFronts');
+  if (config.matBack === true)                        fields.push('backPanelMaterial', 'backPanel');
+  if (config.caseEdge === true)                       fields.push('caseEdge');
+  if (config.frontEdge === true)                      fields.push('frontEdge');
+  if (config.doors === true)                          fields.push('hingePlate');
+  if (config.drawers === true)                        fields.push('drawerType');
+  if (config.topDrwrHeight === true)                  fields.push('topDrwrHeight');
+  if (config.adjShelves === true)                     fields.push('numOfShelves');
+  if (config.gapControl === true)                     fields.push('gapTop', 'gapBottom', 'gapLeft', 'gapRight', 'gapCenter');
+  if (config.jointControl === true)                   fields.push('jointMethod');
+  if (config.cornerVariables === true)                fields.push('leftCornerWidth', 'rightCornerDepth');
+
+  // LP_SP / LP_GP series use edgeBandingType instead of standard edge fields
+  const sn: string = config.serialNumber ?? '';
+  if (sn.startsWith('LP_SP') || sn.startsWith('LP_GP')) fields.push('edgeBandingType');
+
+  // Leg levelers: filterTags-based (dimension check happens at order time)
+  const tags: string = config.filterTags ?? '';
+  if (tags.includes('Leg_Levelers'))                  fields.push('includeLegLevelers');
+
+  // Deduplicate while preserving order
+  return [...new Set(fields)] as ValidField[];
+}
+
+// ---------------------------------------------------------------------------
+// Tool: get_article_context
+// ---------------------------------------------------------------------------
+
+export async function getArticleContext(
+  input: z.infer<typeof GetArticleContextSchema>
+): Promise<string> {
+  try {
+    const { data: config } = await client.get(`/catalog/${input.serialNumber}/configuration`);
+
+    const applicable = getApplicableFields(config);
+
+    const lines: string[] = [];
+    lines.push(`=== CONFIGURATION CONTEXT: ${input.serialNumber} ===`);
+    lines.push('');
+    lines.push('DIMENSION RANGES:');
+    lines.push(`  height: ${config.heightRange ?? 'fixed'}`);
+    lines.push(`  width:  ${config.widthRange ?? 'fixed'}`);
+    lines.push(`  depth:  ${config.depthRange ?? 'fixed'}`);
+    lines.push('');
+    lines.push(`APPLICABLE CONFIG OPTIONS (${applicable.length - 3} fields beyond dimensions):`);
+    lines.push('');
+
+    for (const field of applicable) {
+      const content = readTooltip(field);
+      if (content) {
+        lines.push(`[${field}]`);
+        lines.push(content);
+        lines.push('');
+      }
+    }
+
+    lines.push('---');
+    lines.push('INSTRUCTIONS:');
+    lines.push('1. Present a brief summary of each applicable option to the user.');
+    lines.push('2. For every option that applies to this article, ASK the user what they want — do NOT auto-select, guess, or assume any value.');
+    lines.push('3. Only move to create_order once the user has explicitly confirmed a value for every applicable field.');
+    lines.push('4. If the user provides a drawing or spec that does not specify a value (e.g. no material called out), treat it as missing and ask.');
+    lines.push('5. Only call get_configuration_info if the user asks for more detail on a specific field.');
+
+    return lines.join('\n');
+  } catch (error) {
+    try { handleAxiosError(error); } catch (e: any) { return e.message; }
+    return 'Unexpected error loading article context.';
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tool: get_article_options
+// ---------------------------------------------------------------------------
+
+export async function getArticleOptions(
+  input: z.infer<typeof GetArticleOptionsSchema>
+): Promise<string> {
+  try {
+    const { data } = await client.get(`/catalog/${input.serialNumber}/options`);
+
+    if (!data || Object.keys(data).length === 0) {
+      return 'No selectable options found for this article.';
+    }
+
+    const lines: string[] = [];
+    lines.push(`=== SELECTABLE OPTIONS: ${input.serialNumber} ===`);
+    lines.push('');
+    lines.push('Use these exact strings when setting field values in create_order.');
+    lines.push('');
+
+    if (data.materials) {
+      lines.push('MATERIALS (caseMaterial / frontMaterial / backPanelMaterial / innerCaseMaterial):');
+      (data.materials as string[]).forEach((m: string) => lines.push(`  - ${m}`));
+      lines.push('');
+    }
+
+    if (data.edgebanding) {
+      lines.push('EDGEBANDING (caseEdge / frontEdge):');
+      (data.edgebanding as string[]).forEach((e: string) => lines.push(`  - ${e}`));
+      lines.push('');
+    }
+
+    if (data.jointMethod) {
+      lines.push('JOINT METHOD (jointMethod):');
+      (data.jointMethod as string[]).forEach((v: string) => lines.push(`  - ${v}`));
+      lines.push('');
+    }
+
+    if (data.drawerType) {
+      lines.push('DRAWER TYPE (drawerType):');
+      (data.drawerType as string[]).forEach((v: string) => lines.push(`  - ${v}`));
+      lines.push('');
+    }
+
+    if (data.hingePlate) {
+      lines.push('HINGE PLATE (hingePlate):');
+      (data.hingePlate as string[]).forEach((v: string) => lines.push(`  - ${v}`));
+      lines.push('');
+    }
+
+    if (data.backPanel) {
+      lines.push('BACK PANEL METHOD (backPanel):');
+      (data.backPanel as string[]).forEach((v: string) => lines.push(`  - ${v}`));
+      lines.push('');
+    }
+
+    if (data.numOfShelves) {
+      lines.push('NUMBER OF ADJUSTABLE SHELVES (numOfShelves):');
+      lines.push(`  - ${(data.numOfShelves as string[]).join(', ')}`);
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  } catch (error) {
+    try { handleAxiosError(error); } catch (e: any) { return e.message; }
+    return 'Unexpected error loading article options.';
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tool: get_configuration_info (single-field deep dive)
+// ---------------------------------------------------------------------------
+
+export async function getConfigurationInfo(
+  input: z.infer<typeof GetConfigInfoSchema>
+): Promise<string> {
+  const content = readTooltip(input.field);
+  return content ?? `No information available for field: ${input.field}`;
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+export const configurationInfoTools = [
+  {
+    name: 'get_article_options',
+    description: `Fetch the valid selectable values for all applicable configuration fields for a cabinet article. Returns the exact strings to use when setting caseMaterial, frontMaterial, backPanelMaterial, innerCaseMaterial, caseEdge, frontEdge, jointMethod, drawerType, hingePlate, backPanel, and numOfShelves in create_order.
+
+Call this immediately after get_article_context when a user selects an article. Only fields applicable to the article are returned (e.g. if the article has no doors, hingePlate options are not included).
+
+The values returned are the exact strings the order system expects — do not use variations or paraphrased values.
+
+CRITICAL RULE: Present these options to the user and ask them to choose. Do NOT pick a value on the user's behalf. If the user's source document (drawing, spec sheet, etc.) does not explicitly call out a value for a field, it is missing — ask the user before proceeding.`,
+    inputSchema: GetArticleOptionsSchema,
+    handler: getArticleOptions,
+  },
+  {
+    name: 'get_article_context',
+    description: `Load all configuration context for a cabinet article in a single call. Call this immediately when a user selects or expresses interest in an article — before asking them any configuration questions.
+
+It returns:
+- Dimension ranges (valid height/width/depth for this article)
+- All applicable configuration options with full guidance (only fields that apply to this specific article based on its feature flags)
+
+After calling this, immediately call get_article_options to load the valid selectable values for all applicable fields. Then present the user with a brief summary of all applicable options and their choices.
+
+CRITICAL RULE: After presenting the options, you MUST ask the user to specify each value explicitly. Do NOT auto-select, guess, or default any configuration field — not material, not edgebanding, not joint method, not drawer type, nothing. If the user provides a drawing or document that does not call out a value, that value is missing and must be asked for. Only proceed to create_order once the user has confirmed every applicable field.
+
+Do NOT call get_configuration_info in a loop — this tool already loads the guidance text at once.`,
+    inputSchema: GetArticleContextSchema,
+    handler: getArticleContext,
+  },
+  {
+    name: 'get_configuration_info',
+    description: `Get full detail for a single configuration field. Use this only when the user explicitly asks for more information about a specific option — not as part of the initial article selection flow (use get_article_context for that instead).
+
+Available fields: ${VALID_FIELDS.join(', ')}`,
+    inputSchema: GetConfigInfoSchema,
+    handler: getConfigurationInfo,
+  },
+];

package/src/tools/configuration.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as apiClientModule from '../client/api-client';
+
+vi.mock('../client/api-client', () => ({
+  client: { get: vi.fn() },
+  handleAxiosError: vi.fn((e) => { throw e; }),
+  McpApiError: class McpApiError extends Error {
+    constructor(public status: number, message: string) { super(message); }
+  },
+}));
+
+import { getArticleConfiguration } from './configuration';
+
+describe('getArticleConfiguration', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('returns configuration fields', async () => {
+    vi.mocked(apiClientModule.client.get).mockResolvedValue({
+      data: {
+        serialNumber: 'B30',
+        heightRange: '700-900',
+        widthRange: '300-900',
+        depthRange: '560-560',
+        doors: true,
+        drawers: false,
+      },
+    });
+
+    const result = await getArticleConfiguration({ serialNumber: 'B30' });
+    expect(vi.mocked(apiClientModule.client.get)).toHaveBeenCalledWith('/catalog/B30/configuration');
+    expect(result).toContain('700-900');
+    expect(result).toContain('doors');
+  });
+
+  it('returns error message when article not found', async () => {
+    const err = new (apiClientModule.McpApiError as any)(404, 'Article UNKNOWN not found');
+    vi.mocked(apiClientModule.client.get).mockRejectedValue(err);
+    vi.mocked(apiClientModule.handleAxiosError).mockImplementation(() => { throw err; });
+
+    const result = await getArticleConfiguration({ serialNumber: 'UNKNOWN' });
+    expect(result).toContain('not found');
+  });
+});

package/src/tools/configuration.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { client, handleAxiosError } from '../client/api-client';
+
+const GetConfigSchema = z.object({
+  serialNumber: z.string().describe('Article serial number'),
+});
+
+export async function getArticleConfiguration(input: z.infer<typeof GetConfigSchema>): Promise<string> {
+  try {
+    const { data } = await client.get(`/catalog/${input.serialNumber}/configuration`);
+    return JSON.stringify(data, null, 2);
+  } catch (error) {
+    try { handleAxiosError(error); } catch (e: any) { return e.message; }
+    return 'Unexpected error fetching configuration.';
+  }
+}
+
+export const configurationTools = [
+  {
+    name: 'get_article_configuration',
+    description: 'Get the raw feature flags and dimension ranges for a cabinet article. For guided user-facing configuration, use get_article_context instead — it loads all applicable options and guidance in one call. Use this tool only when you need the raw boolean flags without the guidance text.',
+    inputSchema: GetConfigSchema,
+    handler: getArticleConfiguration,
+  },
+];

package/src/tools/orders.test.ts

@@ -0,0 +1,260 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as apiClientModule from '../client/api-client';
+
+vi.mock('../client/api-client', () => ({
+  client: { get: vi.fn(), post: vi.fn(), patch: vi.fn(), delete: vi.fn() },
+  handleAxiosError: vi.fn((e) => { throw e; }),
+  McpApiError: class McpApiError extends Error {
+    constructor(public status: number, message: string) { super(message); }
+  },
+}));
+
+import { listOrders, getOrder, createOrder, createSavedCart, getSavedCart, updateSavedCartArticles, deleteSavedCartArticles } from './orders';
+
+describe('listOrders', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls /orders with limit and offset', async () => {
+    vi.mocked(apiClientModule.client.get).mockResolvedValue({
+      data: [{ orderId: 'ORD-001', status: 'PROCESSING' }],
+    });
+
+    const result = await listOrders({ limit: 10, offset: 0 });
+    expect(vi.mocked(apiClientModule.client.get)).toHaveBeenCalledWith('/orders', {
+      params: { limit: 10, offset: 0 },
+    });
+    expect(result).toContain('ORD-001');
+  });
+
+  it('returns "No orders found." when result is empty', async () => {
+    vi.mocked(apiClientModule.client.get).mockResolvedValue({ data: [] });
+    const result = await listOrders({ limit: 20, offset: 0 });
+    expect(result).toBe('No orders found.');
+  });
+});
+
+describe('getOrder', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('returns order details', async () => {
+    vi.mocked(apiClientModule.client.get).mockResolvedValue({
+      data: { orderId: 'ORD-001', status: 'SHIPPED' },
+    });
+
+    const result = await getOrder({ orderId: 'ORD-001' });
+    expect(result).toContain('SHIPPED');
+  });
+});
+
+describe('createOrder', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('posts order and returns new orderId', async () => {
+    vi.mocked(apiClientModule.client.post).mockResolvedValue({
+      data: { orderId: 'ORD-NEW-001' },
+    });
+
+    const result = await createOrder({
+      articles: [{ serialNumber: 'B30', quantity: 1, height: 720, width: 600, depth: 560 }],
+      shippingAddress: { address1: '123 Main St', city: 'Brooklyn', state: 'NY', zipcode: '11201' },
+    });
+
+    expect(result).toContain('ORD-NEW-001');
+  });
+});
+
+describe('createSavedCart', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  const validInput = {
+    articles: [{
+      serialNumber: 'B30',
+      positionName: 'Base',
+      quantity: 1,
+      height: 720,
+      width: 600,
+      depth: 560,
+    }],
+    projectName: 'My Kitchen',
+    purchaseOrder: 'PO-001',
+  };
+
+  it('posts to /saved-carts and returns success message with tempOrderId', async () => {
+    vi.mocked(apiClientModule.client.post).mockResolvedValue({
+      data: { tempOrderId: 'SavedCart_1234567890' },
+    });
+
+    const result = await createSavedCart(validInput);
+
+    expect(vi.mocked(apiClientModule.client.post)).toHaveBeenCalledWith(
+      '/saved-carts',
+      expect.any(Object)
+    );
+    expect(result).toContain('SavedCart_1234567890');
+    expect(result).toContain('thesealab.com');
+    expect(result).toContain('Saved Carts');
+  });
+
+  it('returns error string for duplicate positionNames without calling API', async () => {
+    const input = {
+      ...validInput,
+      articles: [
+        { ...validInput.articles[0] },
+        { ...validInput.articles[0] }, // duplicate positionName 'Base'
+      ],
+    };
+
+    const result = await createSavedCart(input);
+
+    expect(result).toContain('duplicate positionName');
+    expect(vi.mocked(apiClientModule.client.post)).not.toHaveBeenCalled();
+  });
+
+  it('returns "Invalid API key" on 401', async () => {
+    const err = new (apiClientModule.McpApiError as any)(401, 'Invalid API key');
+    vi.mocked(apiClientModule.client.post).mockRejectedValue(err);
+    vi.mocked(apiClientModule.handleAxiosError).mockImplementation(() => { throw err; });
+
+    const result = await createSavedCart(validInput);
+    expect(result).toContain('Invalid API key');
+  });
+});
+
+describe('getSavedCart', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  const savedCartResponse = {
+    tempOrderId: 'SavedCart_123',
+    projectName: 'My Kitchen',
+    purchaseOrder: 'PO-001',
+    articles: [
+      {
+        positionName: 'Base',
+        serialNumber: 'B30',
+        displayName: 'Base Cabinet 30"',
+        height: 34.5,
+        width: 30,
+        depth: 24,
+        caseMaterial: 'Maple',
+        frontMaterial: null,
+        excludeFronts: false,
+        edgeBandingType: 'LP_SP',
+        includeLegLevelers: true,
+      },
+    ],
+  };
+
+  it('returns formatted string with cart and article details', async () => {
+    vi.mocked(apiClientModule.client.get).mockResolvedValue({ data: savedCartResponse });
+
+    const result = await getSavedCart({ tempOrderId: 'SavedCart_123' });
+
+    expect(result).toContain('Saved cart: SavedCart_123');
+    expect(result).toContain('My Kitchen');
+    expect(result).toContain('Base');
+    expect(result).toContain('B30');
+    expect(result).toContain('LP_SP');
+    expect(result).toContain('Leg Levelers: true');
+    expect(result).toContain('1 total');
+  });
+
+  it('omits null fields and false booleans from the output', async () => {
+    vi.mocked(apiClientModule.client.get).mockResolvedValue({ data: savedCartResponse });
+
+    const result = await getSavedCart({ tempOrderId: 'SavedCart_123' });
+
+    // frontMaterial is null — should not appear
+    expect(result).not.toContain('Front:');
+    // excludeFronts is false — should not appear (only shown when true)
+    expect(result).not.toContain('Exclude Fronts');
+  });
+
+  it('propagates 401 error from handleAxiosError', async () => {
+    const err = new (apiClientModule.McpApiError as any)(401, 'Invalid API key');
+    vi.mocked(apiClientModule.client.get).mockRejectedValue(err);
+    vi.mocked(apiClientModule.handleAxiosError).mockImplementation(() => { throw err; });
+
+    const result = await getSavedCart({ tempOrderId: 'SavedCart_123' });
+    expect(result).toContain('Invalid API key');
+  });
+});
+
+describe('updateSavedCartArticles', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('patches articles and returns updated count string', async () => {
+    vi.mocked(apiClientModule.client.patch).mockResolvedValue({ data: { updated: 2 } });
+
+    const result = await updateSavedCartArticles({
+      tempOrderId: 'SavedCart_123',
+      articles: [
+        { positionName: 'Base', caseMaterial: 'Oak' },
+        { positionName: 'Upper', caseMaterial: 'Oak' },
+      ],
+    });
+
+    expect(vi.mocked(apiClientModule.client.patch)).toHaveBeenCalledWith(
+      '/saved-carts/SavedCart_123/articles',
+      { articles: expect.any(Array) }
+    );
+    expect(result).toBe('Updated 2 article(s) in saved cart SavedCart_123.');
+  });
+
+  it('returns error string for duplicate positionNames without calling API', async () => {
+    const result = await updateSavedCartArticles({
+      tempOrderId: 'SavedCart_123',
+      articles: [
+        { positionName: 'Base', caseMaterial: 'Oak' },
+        { positionName: 'Base', caseMaterial: 'Maple' },
+      ],
+    });
+
+    expect(result).toContain('duplicate positionName');
+    expect(vi.mocked(apiClientModule.client.patch)).not.toHaveBeenCalled();
+  });
+
+  it('propagates 422 error from handleAxiosError', async () => {
+    const err = new (apiClientModule.McpApiError as any)(422, 'Article(s) not found: Base');
+    vi.mocked(apiClientModule.client.patch).mockRejectedValue(err);
+    vi.mocked(apiClientModule.handleAxiosError).mockImplementation(() => { throw err; });
+
+    const result = await updateSavedCartArticles({
+      tempOrderId: 'SavedCart_123',
+      articles: [{ positionName: 'Base', caseMaterial: 'Oak' }],
+    });
+
+    expect(result).toContain('Article(s) not found: Base');
+  });
+});
+
+describe('deleteSavedCartArticles', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('deletes articles and returns deleted count and names string', async () => {
+    vi.mocked(apiClientModule.client.delete).mockResolvedValue({ data: { deleted: 2 } });
+
+    const result = await deleteSavedCartArticles({
+      tempOrderId: 'SavedCart_123',
+      positionNames: ['Base', 'Upper'],
+    });
+
+    expect(vi.mocked(apiClientModule.client.delete)).toHaveBeenCalledWith(
+      '/saved-carts/SavedCart_123/articles',
+      { data: { positionNames: ['Base', 'Upper'] } }
+    );
+    expect(result).toBe('Deleted 2 article(s) from saved cart SavedCart_123: [Base, Upper].');
+  });
+
+  it('propagates 422 error from handleAxiosError', async () => {
+    const err = new (apiClientModule.McpApiError as any)(422, 'Article(s) not found: Base');
+    vi.mocked(apiClientModule.client.delete).mockRejectedValue(err);
+    vi.mocked(apiClientModule.handleAxiosError).mockImplementation(() => { throw err; });
+
+    const result = await deleteSavedCartArticles({
+      tempOrderId: 'SavedCart_123',
+      positionNames: ['Base'],
+    });
+
+    expect(result).toContain('Article(s) not found: Base');
+  });
+});