@langwatch/mcp-server 2.1.0 → 2.2.0

package/src/__tests__/datasets.unit.test.ts

@@ -1,244 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-vi.mock("../langwatch-api-datasets.js", () => ({
-  listDatasets: vi.fn(),
-  getDataset: vi.fn(),
-}));
-
-import { listDatasets, getDataset } from "../langwatch-api-datasets.js";
-
-import { handleListDatasets } from "../tools/list-datasets.js";
-import { handleGetDataset } from "../tools/get-dataset.js";
-import { formatDatasetResponse } from "../tools/get-dataset.js";
-import { createDatasetSchema } from "../schemas/create-dataset.js";
-
-const mockListDatasets = vi.mocked(listDatasets);
-const mockGetDataset = vi.mocked(getDataset);
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-// ── formatDatasetResponse ────────────────────────────────────────
-
-describe("formatDatasetResponse()", () => {
-  const sampleDataset = {
-    id: "ds_abc123",
-    name: "My Dataset",
-    slug: "my-dataset",
-    columnTypes: [
-      { name: "input", type: "string" },
-      { name: "output", type: "string" },
-    ],
-    createdAt: "2025-01-01T00:00:00.000Z",
-    updatedAt: "2025-01-02T00:00:00.000Z",
-    data: [
-      { id: "rec-1", entry: { input: "hello", output: "world" } },
-      { id: "rec-2", entry: { input: "foo", output: "bar" } },
-    ],
-  };
-
-  describe("when given a dataset with columns and records", () => {
-    let result: string;
-
-    beforeEach(() => {
-      result = formatDatasetResponse(sampleDataset);
-    });
-
-    it("includes the dataset name in the heading", () => {
-      expect(result).toContain("# Dataset: My Dataset");
-    });
-
-    it("includes the slug", () => {
-      expect(result).toContain("my-dataset");
-    });
-
-    /** @scenario "formatDatasetResponse renders column table and record entries as markdown" */
-    it("includes a column table", () => {
-      expect(result).toContain("input");
-      expect(result).toContain("output");
-      expect(result).toContain("string");
-    });
-
-    it("includes record entries", () => {
-      expect(result).toContain("hello");
-      expect(result).toContain("world");
-      expect(result).toContain("foo");
-      expect(result).toContain("bar");
-    });
-
-    it("includes record IDs", () => {
-      expect(result).toContain("rec-1");
-      expect(result).toContain("rec-2");
-    });
-  });
-
-  describe("when given a dataset with no records", () => {
-    it("indicates no records", () => {
-      const result = formatDatasetResponse({
-        ...sampleDataset,
-        data: [],
-      });
-      expect(result).toContain("No records");
-    });
-  });
-});
-
-// ── handleListDatasets ──────────────────────────────────────────
-
-describe("handleListDatasets()", () => {
-  const sampleListResponse = {
-    data: [
-      {
-        id: "ds_abc123",
-        name: "User Feedback",
-        slug: "user-feedback",
-        columnTypes: [
-          { name: "input", type: "string" },
-          { name: "output", type: "string" },
-        ],
-        recordCount: 25,
-        createdAt: "2025-01-01T00:00:00.000Z",
-        updatedAt: "2025-01-02T00:00:00.000Z",
-      },
-    ],
-    pagination: { total: 1, page: 1, limit: 50, totalPages: 1 },
-  };
-
-  describe("when format is digest (default)", () => {
-    it("returns markdown containing dataset names", async () => {
-      mockListDatasets.mockResolvedValue(sampleListResponse);
-      const result = await handleListDatasets();
-      expect(result).toContain("User Feedback");
-      expect(result).toContain("user-feedback");
-    });
-  });
-
-  describe("when format is json", () => {
-    it("returns valid parseable JSON containing all datasets and total", async () => {
-      mockListDatasets.mockResolvedValue(sampleListResponse);
-      const result = await handleListDatasets({ format: "json" });
-      const parsed = JSON.parse(result);
-      expect(parsed.data).toEqual(sampleListResponse.data);
-      expect(parsed.total).toBe(sampleListResponse.pagination.total);
-    });
-  });
-
-  describe("when no datasets exist", () => {
-    it("returns a no-datasets message in digest mode", async () => {
-      mockListDatasets.mockResolvedValue({ data: [], pagination: { total: 0, page: 1, limit: 50, totalPages: 0 } });
-      const result = await handleListDatasets();
-      expect(result).toContain("No datasets found");
-    });
-  });
-});
-
-// ── handleGetDataset ────────────────────────────────────────────
-
-describe("handleGetDataset()", () => {
-  const sampleDataset = {
-    id: "ds_abc123",
-    name: "My Dataset",
-    slug: "my-dataset",
-    columnTypes: [
-      { name: "input", type: "string" },
-      { name: "output", type: "string" },
-    ],
-    createdAt: "2025-01-01T00:00:00.000Z",
-    updatedAt: "2025-01-02T00:00:00.000Z",
-    data: [
-      { id: "rec-1", entry: { input: "hello", output: "world" } },
-    ],
-  };
-
-  describe("when format is digest (default)", () => {
-    it("returns markdown containing dataset name", async () => {
-      mockGetDataset.mockResolvedValue(sampleDataset);
-      const result = await handleGetDataset({ slugOrId: "my-dataset" });
-      expect(result).toContain("# Dataset: My Dataset");
-    });
-  });
-
-  describe("when format is json", () => {
-    it("returns valid parseable JSON matching the dataset structure", async () => {
-      mockGetDataset.mockResolvedValue(sampleDataset);
-      const result = await handleGetDataset({ slugOrId: "my-dataset", format: "json" });
-      expect(JSON.parse(result)).toEqual(sampleDataset);
-    });
-  });
-});
-
-// ── platform_create_dataset schema validation ────────────────────
-
-describe("platform_create_dataset schema", () => {
-  describe("when input has no name", () => {
-    /** @scenario "platform_create_dataset schema rejects input without a name" */
-    it("rejects the input with a validation error", () => {
-      const result = createDatasetSchema.safeParse({});
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe("when input has an empty name", () => {
-    it("rejects the input with a validation error", () => {
-      const result = createDatasetSchema.safeParse({ name: "" });
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe("when input has a valid name", () => {
-    it("accepts the input", () => {
-      const result = createDatasetSchema.safeParse({ name: "Test" });
-      expect(result.success).toBe(true);
-    });
-  });
-});
-
-// ── Tool Registration ────────────────────────────────────────────
-
-describe("MCP server dataset tool registration", () => {
-  describe("when the MCP server is created", () => {
-    /** @scenario "All dataset tools are registered in the MCP server" */
-    it("registers all 8 dataset tools", async () => {
-      const { createMcpServer } = await import("../create-mcp-server.js");
-      const server = createMcpServer();
-      // Access registered tools via the internal _registeredTools object
-      const registeredTools = (server as unknown as { _registeredTools: Record<string, unknown> })._registeredTools;
-      const toolNames = Object.keys(registeredTools);
-
-      expect(toolNames).toContain("platform_list_datasets");
-      expect(toolNames).toContain("platform_get_dataset");
-      expect(toolNames).toContain("platform_create_dataset");
-      expect(toolNames).toContain("platform_update_dataset");
-      expect(toolNames).toContain("platform_delete_dataset");
-      expect(toolNames).toContain("platform_create_dataset_records");
-      expect(toolNames).toContain("platform_update_dataset_record");
-      expect(toolNames).toContain("platform_delete_dataset_records");
-    });
-  });
-});
-
-// ── API Key Requirement ──────────────────────────────────────────
-
-describe("dataset tools API key requirement", () => {
-  describe("when no API key is configured", () => {
-    /** @scenario "Dataset tools require an API key" */
-    it("requireApiKey throws when apiKey is empty", async () => {
-      const savedKey = process.env.LANGWATCH_API_KEY;
-      delete process.env.LANGWATCH_API_KEY;
-
-      try {
-        const { initConfig, requireApiKey } = await import("../config.js");
-        initConfig({ apiKey: "", endpoint: "http://localhost:0" });
-
-        expect(() => requireApiKey()).toThrow(
-          "LANGWATCH_API_KEY is required",
-        );
-      } finally {
-        if (savedKey !== undefined) {
-          process.env.LANGWATCH_API_KEY = savedKey;
-        }
-      }
-    });
-  });
-});

package/src/__tests__/date-parsing.unit.test.ts

@@ -1,78 +0,0 @@
-import { describe, it, expect, vi, afterEach } from "vitest";
-import { parseRelativeDate } from "../utils/date-parsing.js";
-
-describe("parseRelativeDate()", () => {
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe("when given a relative duration", () => {
-    it("parses hours", () => {
-      const now = Date.now();
-      vi.spyOn(Date, "now").mockReturnValue(now);
-
-      const result = parseRelativeDate("24h");
-
-      expect(result).toBe(now - 24 * 3600000);
-    });
-
-    it("parses days", () => {
-      const now = Date.now();
-      vi.spyOn(Date, "now").mockReturnValue(now);
-
-      const result = parseRelativeDate("7d");
-
-      expect(result).toBe(now - 7 * 86400000);
-    });
-
-    it("parses weeks", () => {
-      const now = Date.now();
-      vi.spyOn(Date, "now").mockReturnValue(now);
-
-      const result = parseRelativeDate("2w");
-
-      expect(result).toBe(now - 2 * 604800000);
-    });
-
-    it("parses months", () => {
-      const now = Date.now();
-      vi.spyOn(Date, "now").mockReturnValue(now);
-
-      const result = parseRelativeDate("3m");
-
-      expect(result).toBe(now - 3 * 2592000000);
-    });
-  });
-
-  describe("when given an ISO date string", () => {
-    it("parses a valid ISO date", () => {
-      const result = parseRelativeDate("2024-06-15T12:00:00Z");
-
-      expect(result).toBe(Date.parse("2024-06-15T12:00:00Z"));
-    });
-
-    it("parses a date-only string", () => {
-      const result = parseRelativeDate("2024-06-15");
-
-      expect(result).toBe(Date.parse("2024-06-15"));
-    });
-  });
-
-  describe("when given an invalid string", () => {
-    it("throws an error for garbage input", () => {
-      expect(() => parseRelativeDate("banana")).toThrow(
-        'Invalid date: "banana"'
-      );
-    });
-
-    it("throws an error for empty string", () => {
-      expect(() => parseRelativeDate("")).toThrow('Invalid date: ""');
-    });
-
-    it("includes usage hint in error message", () => {
-      expect(() => parseRelativeDate("xyz")).toThrow(
-        "relative duration"
-      );
-    });
-  });
-});

package/src/__tests__/discover-evaluator-schema.unit.test.ts

@@ -1,89 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { formatEvaluatorSchema } from "../tools/discover-evaluator-schema.js";
-
-describe("formatEvaluatorSchema()", () => {
-  describe("when called without evaluatorType (overview)", () => {
-    it("includes the overview header", () => {
-      const result = formatEvaluatorSchema();
-      expect(result).toContain("# Available Evaluator Types");
-    });
-
-    it("includes category sections", () => {
-      const result = formatEvaluatorSchema();
-      expect(result).toContain("## safety");
-    });
-
-    it("includes evaluator type identifiers", () => {
-      const result = formatEvaluatorSchema();
-      expect(result).toContain("openai/moderation");
-      expect(result).toContain("langevals/exact_match");
-    });
-
-    it("includes evaluator display names", () => {
-      const result = formatEvaluatorSchema();
-      expect(result).toContain("OpenAI Moderation");
-    });
-
-    it("instructs the agent to use evaluatorType parameter for full details", () => {
-      const result = formatEvaluatorSchema();
-      expect(result).toContain(
-        "discover_schema({ category: 'evaluators', evaluatorType: '<type>' })",
-      );
-    });
-  });
-
-  describe("when called with a valid evaluatorType (detail)", () => {
-    it("includes the evaluator name in the heading", () => {
-      const result = formatEvaluatorSchema("openai/moderation");
-      expect(result).toContain("# OpenAI Moderation");
-    });
-
-    it("includes the evaluator type in backticks", () => {
-      const result = formatEvaluatorSchema("openai/moderation");
-      expect(result).toContain("`openai/moderation`");
-    });
-
-    it("includes the category", () => {
-      const result = formatEvaluatorSchema("openai/moderation");
-      expect(result).toContain("**Category**: safety");
-    });
-
-    it("includes settings with descriptions and defaults", () => {
-      const result = formatEvaluatorSchema("openai/moderation");
-      expect(result).toContain("## Settings");
-      expect(result).toContain("**model**");
-      expect(result).toContain("Default:");
-    });
-
-    it("includes required/optional fields section", () => {
-      const result = formatEvaluatorSchema("openai/moderation");
-      expect(result).toContain("## Fields");
-    });
-
-    it("includes result fields", () => {
-      const result = formatEvaluatorSchema("openai/moderation");
-      expect(result).toContain("## Result Fields");
-    });
-
-    it("includes a usage example with evaluatorType", () => {
-      const result = formatEvaluatorSchema("openai/moderation");
-      expect(result).toContain("## Usage Example");
-      expect(result).toContain('"evaluatorType"');
-    });
-
-    it("includes env vars when the evaluator requires them", () => {
-      const result = formatEvaluatorSchema("azure/content_safety");
-      expect(result).toContain("## Required Environment Variables");
-      expect(result).toContain("AZURE_CONTENT_SAFETY_ENDPOINT");
-    });
-  });
-
-  describe("when called with an unknown evaluatorType", () => {
-    it("returns an error message with guidance", () => {
-      const result = formatEvaluatorSchema("nonexistent/type");
-      expect(result).toContain("Unknown evaluator type");
-      expect(result).toContain("nonexistent/type");
-      expect(result).toContain("discover_schema");
-    });
-  });
-});

package/src/__tests__/discover-schema.unit.test.ts

@@ -1,118 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { formatSchema } from "../tools/discover-schema.js";
-
-describe("formatSchema()", () => {
-  describe("when category is 'filters'", () => {
-    it("includes metadata.user_id", () => {
-      const result = formatSchema("filters");
-      expect(result).toContain("metadata.user_id");
-    });
-
-    it("includes spans.model", () => {
-      const result = formatSchema("filters");
-      expect(result).toContain("spans.model");
-    });
-
-    it("includes the section header", () => {
-      const result = formatSchema("filters");
-      expect(result).toContain("## Available Filter Fields");
-    });
-
-    it("includes usage instructions", () => {
-      const result = formatSchema("filters");
-      expect(result).toContain("filters");
-      expect(result).toContain("search_traces");
-    });
-  });
-
-  describe("when category is 'metrics'", () => {
-    it("includes performance.completion_time", () => {
-      const result = formatSchema("metrics");
-      expect(result).toContain("performance.completion_time");
-    });
-
-    it("includes allowed aggregations for metrics", () => {
-      const result = formatSchema("metrics");
-      expect(result).toContain("Aggregations:");
-      expect(result).toContain("avg");
-    });
-
-    it("includes the section header", () => {
-      const result = formatSchema("metrics");
-      expect(result).toContain("## Available Metrics");
-    });
-
-    it("groups metrics by category", () => {
-      const result = formatSchema("metrics");
-      expect(result).toContain("### metadata");
-      expect(result).toContain("### performance");
-      expect(result).toContain("### evaluations");
-    });
-  });
-
-  describe("when category is 'groups'", () => {
-    it("includes model group", () => {
-      const result = formatSchema("groups");
-      expect(result).toContain("metadata.model");
-    });
-
-    it("includes topics group", () => {
-      const result = formatSchema("groups");
-      expect(result).toContain("topics.topics");
-    });
-
-    it("includes the section header", () => {
-      const result = formatSchema("groups");
-      expect(result).toContain("## Available Group-By Options");
-    });
-  });
-
-  describe("when category is 'aggregations'", () => {
-    const allAggregations = [
-      "cardinality",
-      "terms",
-      "avg",
-      "sum",
-      "min",
-      "max",
-      "median",
-      "p90",
-      "p95",
-      "p99",
-    ];
-
-    it("includes all 10 aggregation types", () => {
-      const result = formatSchema("aggregations");
-      for (const agg of allAggregations) {
-        expect(result).toContain(`**${agg}**`);
-      }
-    });
-
-    it("includes the section header", () => {
-      const result = formatSchema("aggregations");
-      expect(result).toContain("## Available Aggregation Types");
-    });
-  });
-
-  describe("when category is 'all'", () => {
-    it("includes the filters section", () => {
-      const result = formatSchema("all");
-      expect(result).toContain("## Available Filter Fields");
-    });
-
-    it("includes the metrics section", () => {
-      const result = formatSchema("all");
-      expect(result).toContain("## Available Metrics");
-    });
-
-    it("includes the aggregations section", () => {
-      const result = formatSchema("all");
-      expect(result).toContain("## Available Aggregation Types");
-    });
-
-    it("includes the groups section", () => {
-      const result = formatSchema("all");
-      expect(result).toContain("## Available Group-By Options");
-    });
-  });
-});