@trishchuk/coolors-mcp 1.0.1 → 1.1.0

package/src/bin/server.ts

@@ -24,16 +24,28 @@ const server = new CoolorsMcp({
   instructions:
     "Advanced color operations server with Material Design 3 support, CSS theme matching, image extraction, and accessibility compliance. Uses HCT color space for perceptually accurate operations.",
   name: "coolors-mcp",
-  version: "1.0.0",
+  version: "1.1.0",
 });
 
 // Core color operations: conversion, distance metrics, accessibility
 server.addTool(tools.colorConversionTool);
 server.addTool(tools.colorDistanceTool);
 server.addTool(tools.contrastCheckerTool);
+server.addTool(tools.adjustColorTool);
 server.addTool(tools.paletteGeneratorTool);
 server.addTool(tools.paletteWithLocksTool);
 server.addTool(tools.gradientGeneratorTool);
+server.addTool(tools.exportPaletteTool);
+
+// Color-blindness simulation & accessibility audit
+server.addTool(tools.simulateColorBlindnessTool);
+server.addTool(tools.checkPaletteAccessibilityTool);
+
+// Visual cohesion: tonal scales, state colors, palette consistency, semantics
+server.addTool(tools.generateTonalScaleTool);
+server.addTool(tools.generateStateColorsTool);
+server.addTool(tools.analyzePaletteConsistencyTool);
+server.addTool(tools.generateSemanticPaletteTool);
 
 // Material Design 3: theme generation, harmonization, tonal palettes
 server.addTool(tools.generateMaterialThemeTool);

package/src/color/__tests__/extract-colors.test.ts

@@ -27,9 +27,8 @@ describe("Color Extraction", () => {
     });
 
     it("should extract colors with default options", async () => {
-      const { QuantizerCelebi } = await import(
-        "../quantize/quantizer_celebi.js"
-      );
+      const { QuantizerCelebi } =
+        await import("../quantize/quantizer_celebi.js");
       const { Score } = await import("../score/score.js");
 
       // Mock quantizer to return test colors
@@ -106,9 +105,8 @@ describe("Color Extraction", () => {
     });
 
     it("should extract colors without scoring", async () => {
-      const { QuantizerCelebi } = await import(
-        "../quantize/quantizer_celebi.js"
-      );
+      const { QuantizerCelebi } =
+        await import("../quantize/quantizer_celebi.js");
       const { Score } = await import("../score/score.js");
 
       const mockQuantized = new Map([
@@ -140,9 +138,8 @@ describe("Color Extraction", () => {
     });
 
     it("should handle empty image data", async () => {
-      const { QuantizerCelebi } = await import(
-        "../quantize/quantizer_celebi.js"
-      );
+      const { QuantizerCelebi } =
+        await import("../quantize/quantizer_celebi.js");
       const { Score } = await import("../score/score.js");
 
       vi.mocked(QuantizerCelebi.quantize).mockReturnValue(new Map());
@@ -159,9 +156,8 @@ describe("Color Extraction", () => {
     });
 
     it("should calculate correct percentages", async () => {
-      const { QuantizerCelebi } = await import(
-        "../quantize/quantizer_celebi.js"
-      );
+      const { QuantizerCelebi } =
+        await import("../quantize/quantizer_celebi.js");
       const { Score } = await import("../score/score.js");
 
       const mockQuantized = new Map([
@@ -194,9 +190,8 @@ describe("Color Extraction", () => {
     });
 
     it("should extract theme palette with primary color", async () => {
-      const { QuantizerCelebi } = await import(
-        "../quantize/quantizer_celebi.js"
-      );
+      const { QuantizerCelebi } =
+        await import("../quantize/quantizer_celebi.js");
       const { Score } = await import("../score/score.js");
 
       const mockQuantized = new Map([
@@ -219,9 +214,8 @@ describe("Color Extraction", () => {
     });
 
     it("should extract secondary with different hue", async () => {
-      const { QuantizerCelebi } = await import(
-        "../quantize/quantizer_celebi.js"
-      );
+      const { QuantizerCelebi } =
+        await import("../quantize/quantizer_celebi.js");
       const { Score } = await import("../score/score.js");
 
       const mockQuantized = new Map([
@@ -251,9 +245,8 @@ describe("Color Extraction", () => {
     });
 
     it("should find neutral color with low chroma", async () => {
-      const { QuantizerCelebi } = await import(
-        "../quantize/quantizer_celebi.js"
-      );
+      const { QuantizerCelebi } =
+        await import("../quantize/quantizer_celebi.js");
       const { Score } = await import("../score/score.js");
 
       const mockQuantized = new Map([
@@ -280,9 +273,8 @@ describe("Color Extraction", () => {
     });
 
     it("should find error color in red hue range", async () => {
-      const { QuantizerCelebi } = await import(
-        "../quantize/quantizer_celebi.js"
-      );
+      const { QuantizerCelebi } =
+        await import("../quantize/quantizer_celebi.js");
       const { Score } = await import("../score/score.js");
 
       const primaryArgb = utils.argbFromRgb(103, 80, 164);
@@ -311,9 +303,8 @@ describe("Color Extraction", () => {
     });
 
     it("should throw error for empty image", async () => {
-      const { QuantizerCelebi } = await import(
-        "../quantize/quantizer_celebi.js"
-      );
+      const { QuantizerCelebi } =
+        await import("../quantize/quantizer_celebi.js");
       const { Score } = await import("../score/score.js");
 
       vi.mocked(QuantizerCelebi.quantize).mockReturnValue(new Map());
@@ -331,9 +322,8 @@ describe("Color Extraction", () => {
     });
 
     it("should handle single color image", async () => {
-      const { QuantizerCelebi } = await import(
-        "../quantize/quantizer_celebi.js"
-      );
+      const { QuantizerCelebi } =
+        await import("../quantize/quantizer_celebi.js");
       const { Score } = await import("../score/score.js");
 
       const mockQuantized = new Map([

package/src/color/apca.ts

@@ -0,0 +1,105 @@
+/**
+ * APCA — Accessible Perceptual Contrast Algorithm (WCAG 3 draft)
+ *
+ * Implementation of APCA W3 0.1.9 / SAPC by Andrew Somers (Myndex).
+ * Returns Lc, an absolute contrast value typically in the range [-108, +106].
+ * Sign indicates polarity: positive when text is darker than background
+ * ("dark on light"), negative for light text on dark background. The magnitude
+ * (|Lc|) maps to readability thresholds via APCA's "Bronze Simple Tables":
+ *
+ *   |Lc| >= 75   body text
+ *   |Lc| >= 60   content text
+ *   |Lc| >= 45   large fluent text
+ *   |Lc| >= 30   non-content / spot text
+ *   |Lc| < 15    invisible — fails for any text use
+ *
+ * Reference: https://github.com/Myndex/SAPC-APCA
+ */
+
+import type { RGB } from "./types.js";
+
+// APCA constants (W3-0.1.9 4g)
+const SA98G = {
+  blkClmp: 1.414,
+  blkThrs: 0.022,
+  deltaYmin: 0.0005,
+  loBoTclip: -0.6,
+  loBoTexp: 0.74,
+  loClip: 0.1,
+  // Polarity exponents/factors
+  normBG: 0.56,
+  normTXT: 0.57,
+  revBG: 0.62,
+  revTXT: 0.65,
+  // Soft-clip and scale
+  scaleBoW: 1.14,
+  scaleWoB: 1.14,
+  trailingW: 0.027,
+} as const;
+
+const sRGBtrc = 2.4;
+const Rco = 0.2126729;
+const Gco = 0.7151522;
+const Bco = 0.072175;
+
+/**
+ * Compute APCA Lc for foreground text on background.
+ * `text` is the text/foreground color, `bg` is the background color.
+ */
+export function apcaContrast(text: RGB, bg: RGB): number {
+  let txtY = apcaY(text);
+  let bgY = apcaY(bg);
+
+  // Soft black clamp
+  if (txtY <= SA98G.blkThrs) {
+    txtY += Math.pow(SA98G.blkThrs - txtY, SA98G.blkClmp);
+  }
+  if (bgY <= SA98G.blkThrs) {
+    bgY += Math.pow(SA98G.blkThrs - bgY, SA98G.blkClmp);
+  }
+
+  if (Math.abs(bgY - txtY) < SA98G.deltaYmin) return 0;
+
+  let outputContrast: number;
+
+  if (bgY > txtY) {
+    // Normal polarity (dark text on light background) — positive Lc
+    const SAPC =
+      (Math.pow(bgY, SA98G.normBG) - Math.pow(txtY, SA98G.normTXT)) *
+      SA98G.scaleBoW;
+    outputContrast = SAPC < SA98G.loClip ? 0 : SAPC - SA98G.trailingW;
+  } else {
+    // Reverse polarity (light text on dark background) — negative Lc
+    const SAPC =
+      (Math.pow(bgY, SA98G.revBG) - Math.pow(txtY, SA98G.revTXT)) *
+      SA98G.scaleWoB;
+    outputContrast = SAPC > -SA98G.loClip ? 0 : SAPC + SA98G.trailingW;
+  }
+
+  return outputContrast * 100;
+}
+
+/**
+ * Classify an APCA Lc value against the Bronze Simple level thresholds.
+ */
+export function apcaLevel(lc: number): {
+  body: boolean;
+  content: boolean;
+  large: boolean;
+  spot: boolean;
+} {
+  const abs = Math.abs(lc);
+  return {
+    body: abs >= 75,
+    content: abs >= 60,
+    large: abs >= 45,
+    spot: abs >= 30,
+  };
+}
+
+function apcaY(rgb: RGB): number {
+  const r = Math.pow(rgb.r / 255, sRGBtrc);
+  const g = Math.pow(rgb.g / 255, sRGBtrc);
+  const b = Math.pow(rgb.b / 255, sRGBtrc);
+  return Rco * r + Gco * g + Bco * b;
+}

package/src/color/color-blindness.ts

@@ -0,0 +1,109 @@
+/**
+ * Color Vision Deficiency (CVD) simulation.
+ *
+ * Linear-sRGB transformation matrices from Machado, Oliveira, and Fernandes
+ * (2009), "A Physiologically-based Model for Simulation of Color Vision
+ * Deficiency". Severity 1.0 matrices are used for the dichromatic forms
+ * (protanopia/deuteranopia/tritanopia); severity 0.6 matrices are used for the
+ * milder anomaly forms. Achromatopsia uses ITU-R BT.709 luminance.
+ *
+ * Pipeline: sRGB → linear sRGB → matrix → sRGB.
+ */
+
+import type { RGB } from "./types.js";
+
+export type CvdType =
+  | "achromatopsia"
+  | "deuteranomaly"
+  | "deuteranopia"
+  | "protanomaly"
+  | "protanopia"
+  | "tritanomaly"
+  | "tritanopia";
+
+// Confusion-line matrices applied in linear sRGB space (Machado et al. 2009
+// linear approximation, common in libraries like color-blind / colorjs.io).
+// Each matrix maps linear-sRGB to the visible linear-sRGB for the given CVD.
+const CVD_MATRICES: Record<
+  Exclude<CvdType, "achromatopsia">,
+  [number, number, number, number, number, number, number, number, number]
+> = {
+  deuteranomaly: [
+    0.547494, 0.607765, -0.155259, 0.181692, 0.781742, 0.036566, -0.01041,
+    0.027275, 0.983136,
+  ],
+  deuteranopia: [
+    0.367322, 0.860646, -0.227968, 0.280085, 0.672501, 0.047413, -0.01182,
+    0.04294, 0.968881,
+  ],
+  // Mild forms (-omaly: severity ~0.6, Machado severity 0.6 table)
+  protanomaly: [
+    0.458064, 0.679578, -0.137642, 0.092785, 0.846313, 0.060902, -0.007494,
+    -0.016807, 1.024301,
+  ],
+  // Strong forms (-opia: full dichromacy, severity 1.0)
+  protanopia: [
+    0.152286, 1.052583, -0.204868, 0.114503, 0.786281, 0.099216, -0.003882,
+    -0.048116, 1.051998,
+  ],
+  tritanomaly: [
+    1.193214, -0.109812, -0.083402, 0.058694, 0.901185, 0.040121, -0.005978,
+    0.401901, 0.604077,
+  ],
+  tritanopia: [
+    1.255528, -0.076749, -0.178779, -0.078411, 0.930809, 0.147602, 0.004733,
+    0.691367, 0.3039,
+  ],
+};
+
+/**
+ * Simulate how a color appears to a viewer with the given color vision
+ * deficiency.
+ */
+export function simulateCvd(rgb: RGB, type: CvdType): RGB {
+  if (type === "achromatopsia") {
+    // ITU-R BT.709 luminance (Rec. 709) — perceived brightness.
+    const y = 0.2126 * rgb.r + 0.7152 * rgb.g + 0.0722 * rgb.b;
+    const g = Math.max(0, Math.min(255, Math.round(y)));
+    return { b: g, g, r: g };
+  }
+
+  const m = CVD_MATRICES[type];
+  const r = srgbToLinear(rgb.r);
+  const g = srgbToLinear(rgb.g);
+  const b = srgbToLinear(rgb.b);
+
+  const rOut = m[0] * r + m[1] * g + m[2] * b;
+  const gOut = m[3] * r + m[4] * g + m[5] * b;
+  const bOut = m[6] * r + m[7] * g + m[8] * b;
+
+  return {
+    b: linearToSrgb(bOut),
+    g: linearToSrgb(gOut),
+    r: linearToSrgb(rOut),
+  };
+}
+
+function linearToSrgb(c: number): number {
+  const v = c <= 0.0031308 ? 12.92 * c : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
+  return Math.max(0, Math.min(255, Math.round(v * 255)));
+}
+
+function srgbToLinear(c: number): number {
+  const n = c / 255;
+  return n <= 0.04045 ? n / 12.92 : Math.pow((n + 0.055) / 1.055, 2.4);
+}
+
+/**
+ * Approximate share of the population affected by each CVD type (worldwide,
+ * combining male+female prevalence as reported by Colour Blind Awareness).
+ */
+export const CVD_PREVALENCE: Record<CvdType, number> = {
+  achromatopsia: 0.003,
+  deuteranomaly: 5.0,
+  deuteranopia: 1.0,
+  protanomaly: 1.0,
+  protanopia: 1.0,
+  tritanomaly: 0.01,
+  tritanopia: 0.003,
+};

package/src/coolors-mcp.ts

@@ -1,5 +1,5 @@
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { EventEmitter } from "events";
+import { EventEmitter } from "node:events";
 import { StrictEventEmitter } from "strict-event-emitter-types";
 
 import { CoolorsMCPSession } from "./session.js";

package/src/session.ts

@@ -6,7 +6,7 @@ import {
   ListToolsRequestSchema,
   McpError,
 } from "@modelcontextprotocol/sdk/types.js";
-import { EventEmitter } from "events";
+import { EventEmitter } from "node:events";
 import { StrictEventEmitter } from "strict-event-emitter-types";
 import { toJsonSchema } from "xsschema";
 
@@ -99,9 +99,17 @@ export class CoolorsMCPSession extends (EventEmitter as {
         args = parsed.value;
       }
 
+      const noop = () => {};
+      const context = {
+        client: { version: this.#server.getClientVersion() },
+        log: { debug: noop, error: noop, info: noop, warn: noop },
+        reportProgress: async () => {},
+        session: undefined,
+        streamContent: async () => {},
+      };
       const result = await tool.execute(
         args as Parameters<typeof tool.execute>[0],
-        {} as CoolorsMCPSessionAuth,
+        context as Parameters<typeof tool.execute>[1],
       );
 
       if (typeof result === "string") {

package/src/theme/matcher.ts

@@ -256,7 +256,7 @@ function calculateHctDistance(color1: HCT, color2: HCT): number {
  * Calculate multi-factor match score
  */
 function calculateMatchScore(
-  inputHct: HCT,
+  _inputHct: HCT,
   candidate: ThemeVariable,
   distance: number,
   weights: { accessibility: number; perceptual: number; semantic: number },

package/src/theme/refactor.ts

@@ -165,7 +165,7 @@ export function refactorCss(
 
   const replacements: ColorReplacement[] = [];
   const warnings: RefactoringWarning[] = [];
-  let refactoredCss = css;
+  let refactoredCss: string;
   let totalColors = 0;
   let replacedColors = 0;
   let totalConfidence = 0;

package/src/theme/types.ts

@@ -142,11 +142,14 @@ export interface ThemeVariable {
  * Collection of theme variables organized by role
  */
 export interface ThemeVariables {
+  background?: ThemeVariable[];
   custom?: Record<string, ThemeVariable[]>;
   error?: ThemeVariable[];
   neutral?: ThemeVariable[];
+  outline?: ThemeVariable[];
   primary?: ThemeVariable[];
   secondary?: ThemeVariable[];
+  shadow?: ThemeVariable[];
   surface?: ThemeVariable[];
   tertiary?: ThemeVariable[];
 }

package/src/tools/__tests__/cohesion.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  analyzePaletteConsistencyTool,
+  generateSemanticPaletteTool,
+  generateStateColorsTool,
+  generateTonalScaleTool,
+} from "../cohesion.tools.js";
+
+describe("generateTonalScaleTool", () => {
+  it("generates 11 stops by default", async () => {
+    const result = (await generateTonalScaleTool.execute({
+      seed: "#6750a4",
+    })) as string;
+    expect(result).toContain("| 50 |");
+    expect(result).toContain("| 500 |");
+    expect(result).toContain("| 950 |");
+    expect(result.match(/^\| \d+ \|/gm)?.length ?? 0).toBeGreaterThanOrEqual(
+      11,
+    );
+  });
+
+  it("emits CSS custom properties with the given prefix", async () => {
+    const result = (await generateTonalScaleTool.execute({
+      name: "brand",
+      seed: "#6750a4",
+    })) as string;
+    expect(result).toContain("--brand-50:");
+    expect(result).toContain("--brand-950:");
+  });
+
+  it("rejects invalid colors", async () => {
+    const result = await generateTonalScaleTool.execute({ seed: "nope" });
+    expect(result).toMatch(/Invalid color format/);
+  });
+});
+
+describe("generateStateColorsTool", () => {
+  it("produces all expected interaction states", async () => {
+    const result = (await generateStateColorsTool.execute({
+      base: "#6750a4",
+    })) as string;
+    for (const state of [
+      "base",
+      "hover",
+      "active",
+      "pressed",
+      "focus",
+      "disabled",
+      "selected",
+    ]) {
+      expect(result).toContain(`| ${state} |`);
+    }
+  });
+});
+
+describe("analyzePaletteConsistencyTool", () => {
+  it("returns a cohesion score for a small palette", async () => {
+    const result = (await analyzePaletteConsistencyTool.execute({
+      colors: ["#6750a4", "#7f67be", "#a48dc8"],
+    })) as string;
+    expect(result).toContain("Overall cohesion");
+  });
+
+  it("flags outliers", async () => {
+    const result = (await analyzePaletteConsistencyTool.execute({
+      colors: ["#6750a4", "#7f67be", "#a48dc8", "#ff0000"],
+    })) as string;
+    expect(result).toMatch(/outlier/i);
+  });
+
+  it("requires at least 2 colors", async () => {
+    const result = await analyzePaletteConsistencyTool.execute({
+      colors: ["#6750a4"],
+    });
+    expect(result).toMatch(/at least 2/i);
+  });
+});
+
+describe("generateSemanticPaletteTool", () => {
+  it("returns all 7 semantic roles", async () => {
+    const result = (await generateSemanticPaletteTool.execute({
+      brand: "#6750a4",
+    })) as string;
+    for (const role of [
+      "primary",
+      "secondary",
+      "tertiary",
+      "success",
+      "warning",
+      "error",
+      "info",
+    ]) {
+      expect(result).toContain(`--color-${role}:`);
+    }
+  });
+});

package/src/tools/__tests__/color-blindness.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+
+import { simulateCvd } from "../../color/color-blindness.js";
+import {
+  checkPaletteAccessibilityTool,
+  simulateColorBlindnessTool,
+} from "../color-blindness.tool.js";
+
+describe("simulateCvd", () => {
+  it("achromatopsia collapses to grayscale", () => {
+    const r = simulateCvd({ b: 70, g: 80, r: 230 }, "achromatopsia");
+    expect(r.r).toBe(r.g);
+    expect(r.g).toBe(r.b);
+  });
+
+  it("protanopia shifts pure red toward yellow/olive", () => {
+    const r = simulateCvd({ b: 0, g: 0, r: 255 }, "protanopia");
+    // Protanopes lose long-wavelength sensitivity → red becomes dark/yellow-ish.
+    expect(r.r).toBeLessThan(255);
+    expect(r.g).toBeGreaterThan(0);
+  });
+});
+
+describe("simulateColorBlindnessTool", () => {
+  it("returns a row per color", async () => {
+    const result = (await simulateColorBlindnessTool.execute({
+      colors: ["#e63946", "#2a9d8f"],
+      types: ["protanopia"],
+    })) as string;
+    expect(result).toContain("#e63946");
+    expect(result).toContain("#2a9d8f");
+    expect(result).toContain("protanopia");
+  });
+});
+
+describe("checkPaletteAccessibilityTool", () => {
+  it("audits a 3-color palette across CVD types", async () => {
+    const result = (await checkPaletteAccessibilityTool.execute({
+      colors: ["#000000", "#888888", "#ffffff"],
+    })) as string;
+    expect(result).toContain("Palette Accessibility Audit");
+    expect(result).toContain("protanopia");
+    expect(result).toContain("Summary");
+  });
+});

package/src/tools/__tests__/color-conversion.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+
+import { colorConversionTool } from "../color-conversion.tool.js";
+
+describe("colorConversionTool", () => {
+  // Regression: previously multiplied by 255 again, producing rgb(26265, ...).
+  it("converts hex to rgb without re-scaling", async () => {
+    const result = await colorConversionTool.execute({
+      color: "#6750a4",
+      to: "rgb",
+    });
+    expect(result).toBe("rgb(103, 80, 164)");
+  });
+
+  it("converts hex to hex (round-trip)", async () => {
+    const result = await colorConversionTool.execute({
+      color: "#6750a4",
+      to: "hex",
+    });
+    expect(result).toBe("#6750a4");
+  });
+
+  it("converts hex to hsl", async () => {
+    const result = await colorConversionTool.execute({
+      color: "#6750a4",
+      to: "hsl",
+    });
+    expect(result).toMatch(/^hsl\(\d+, \d+%, \d+%\)$/);
+  });
+
+  it("rejects invalid colors", async () => {
+    const result = await colorConversionTool.execute({
+      color: "not-a-color",
+      to: "rgb",
+    });
+    expect(result).toMatch(/Invalid color format/);
+  });
+});

package/src/tools/__tests__/contrast-checker.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+
+import { apcaContrast } from "../../color/apca.js";
+import { contrastCheckerTool } from "../contrast-checker.tool.js";
+
+describe("apcaContrast", () => {
+  // Reference values from Myndex/SAPC-APCA test vectors
+  it("matches reference: #888 on #fff ≈ 63", () => {
+    const lc = apcaContrast(
+      { b: 0x88, g: 0x88, r: 0x88 },
+      { b: 255, g: 255, r: 255 },
+    );
+    expect(lc).toBeCloseTo(63.06, 1);
+  });
+
+  it("matches reference: #000 on #fff ≈ 106", () => {
+    const lc = apcaContrast({ b: 0, g: 0, r: 0 }, { b: 255, g: 255, r: 255 });
+    expect(lc).toBeCloseTo(106.04, 1);
+  });
+
+  it("matches reference: #fff on #000 ≈ -107", () => {
+    const lc = apcaContrast({ b: 255, g: 255, r: 255 }, { b: 0, g: 0, r: 0 });
+    expect(lc).toBeCloseTo(-107.28, 1);
+  });
+});
+
+describe("contrastCheckerTool", () => {
+  it("returns WCAG block by default", async () => {
+    const result = await contrastCheckerTool.execute({
+      background: "#ffffff",
+      foreground: "#000000",
+    });
+    expect(result).toContain("WCAG 2.x");
+    expect(result).toContain("21.00:1");
+  });
+
+  it("returns APCA when requested", async () => {
+    const result = await contrastCheckerTool.execute({
+      algorithm: "apca",
+      background: "#ffffff",
+      foreground: "#000000",
+    });
+    expect(result).toContain("APCA");
+    expect(result).toContain("Lc:");
+  });
+
+  it("returns both when algorithm=both", async () => {
+    const result = await contrastCheckerTool.execute({
+      algorithm: "both",
+      background: "#ffffff",
+      foreground: "#000000",
+    });
+    expect(result).toContain("WCAG 2.x");
+    expect(result).toContain("APCA");
+  });
+});