@langwatch/mcp-server 2.0.0 → 2.2.0

package/src/__tests__/scenario-tools.unit.test.ts

@@ -1,188 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-vi.mock("../langwatch-api-scenarios.js", () => ({
-  listScenarios: vi.fn(),
-  getScenario: vi.fn(),
-}));
-
-import {
-  listScenarios,
-  getScenario,
-} from "../langwatch-api-scenarios.js";
-
-import { handleListScenarios } from "../tools/list-scenarios.js";
-import { handleGetScenario } from "../tools/get-scenario.js";
-import { formatScenarioSchema } from "../tools/discover-scenario-schema.js";
-
-const mockListScenarios = vi.mocked(listScenarios);
-const mockGetScenario = vi.mocked(getScenario);
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-describe("handleListScenarios()", () => {
-  const sampleScenarios = [
-    {
-      id: "scen_abc123",
-      name: "Login Flow Happy Path",
-      situation:
-        "User attempts to log in with valid credentials and expects a welcome message back from the system",
-      criteria: [
-        "Responds with a welcome message",
-        "Includes user name in greeting",
-        "Sets session cookie",
-      ],
-      labels: ["auth", "happy-path"],
-    },
-    {
-      id: "scen_def456",
-      name: "Error Handling",
-      situation: "User sends malformed input",
-      criteria: ["Returns 400 status"],
-      labels: ["error"],
-    },
-  ];
-
-  describe("when scenarios exist (digest mode)", () => {
-    let result: string;
-
-    beforeEach(async () => {
-      mockListScenarios.mockResolvedValue(sampleScenarios);
-      result = await handleListScenarios({});
-    });
-
-    it("includes scenario id", () => {
-      expect(result).toContain("scen_abc123");
-    });
-
-    it("includes scenario name", () => {
-      expect(result).toContain("Login Flow Happy Path");
-    });
-
-    it("includes truncated situation preview", () => {
-      expect(result).toContain("User attempts to log in");
-      expect(result).not.toContain(
-        "User attempts to log in with valid credentials and expects a welcome message back from the system"
-      );
-    });
-
-    it("shows criteria count per scenario", () => {
-      expect(result).toContain("3 criteria");
-    });
-
-    it("includes labels", () => {
-      expect(result).toContain("auth");
-    });
-
-    it("includes all scenarios in the list", () => {
-      expect(result).toContain("scen_def456");
-    });
-
-    /** @scenario Agent lists all scenarios in a project */
-    it("includes the total count header", () => {
-      expect(result).toContain("# Scenarios (2 total)");
-    });
-  });
-
-  describe("when no scenarios exist", () => {
-    let result: string;
-
-    beforeEach(async () => {
-      mockListScenarios.mockResolvedValue([]);
-      result = await handleListScenarios({});
-    });
-
-    /** @scenario Agent lists scenarios when none exist */
-    it("returns a no-scenarios message", () => {
-      expect(result).toContain("No scenarios found");
-    });
-
-    it("includes a tip to use platform_create_scenario", () => {
-      expect(result).toContain("platform_create_scenario");
-    });
-  });
-
-  describe("when format is json", () => {
-    it("returns valid parseable JSON matching the scenario structure", async () => {
-      mockListScenarios.mockResolvedValue(sampleScenarios);
-      const result = await handleListScenarios({ format: "json" });
-      expect(JSON.parse(result)).toEqual(sampleScenarios);
-    });
-  });
-});
-
-describe("handleGetScenario()", () => {
-  const sampleScenario = {
-    id: "scen_abc123",
-    name: "Login Flow Happy Path",
-    situation: "User attempts to log in with valid credentials",
-    criteria: [
-      "Responds with a welcome message",
-      "Includes user name in greeting",
-    ],
-    labels: ["auth", "happy-path"],
-  };
-
-  describe("when format is digest", () => {
-    let result: string;
-
-    beforeEach(async () => {
-      mockGetScenario.mockResolvedValue(sampleScenario);
-      result = await handleGetScenario({ scenarioId: "scen_abc123" });
-    });
-
-    /** @scenario Agent gets full details of a scenario */
-    it("includes the scenario name in the heading", () => {
-      expect(result).toContain("# Scenario: Login Flow Happy Path");
-    });
-
-    it("includes the situation", () => {
-      expect(result).toContain("User attempts to log in with valid credentials");
-    });
-
-    it("includes each criteria item", () => {
-      expect(result).toContain("- Responds with a welcome message");
-      expect(result).toContain("- Includes user name in greeting");
-    });
-
-    it("includes labels", () => {
-      expect(result).toContain("auth, happy-path");
-    });
-  });
-
-  describe("when format is json", () => {
-    it("returns valid parseable JSON matching the scenario structure", async () => {
-      mockGetScenario.mockResolvedValue(sampleScenario);
-      const result = await handleGetScenario({
-        scenarioId: "scen_abc123",
-        format: "json",
-      });
-      expect(JSON.parse(result)).toEqual(sampleScenario);
-    });
-  });
-});
-
-describe("formatScenarioSchema()", () => {
-  it("includes field descriptions with required/optional annotations", () => {
-    const result = formatScenarioSchema();
-    expect(result).toContain("**name** (required)");
-    expect(result).toContain("**situation** (required)");
-    expect(result).toContain("**criteria** (array of strings)");
-    expect(result).toContain("**labels** (array of strings)");
-  });
-
-  it("includes all target types with descriptions", () => {
-    const result = formatScenarioSchema();
-    expect(result).toContain("**prompt**: Test a prompt template");
-    expect(result).toContain("**http**: Test an HTTP endpoint");
-    expect(result).toContain("**code**: Test a code function");
-  });
-
-  it("includes authoring guidance for situations and criteria", () => {
-    const result = formatScenarioSchema();
-    expect(result).toContain("## Writing a Good Situation");
-    expect(result).toContain("## Writing Good Criteria");
-    expect(result).toContain("Specific and testable");
-  });
-});

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

@@ -1,85 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { filterFields } from "../schemas/filter-fields.js";
-import { analyticsMetrics } from "../schemas/analytics-metrics.js";
-import { analyticsGroups } from "../schemas/analytics-groups.js";
-
-describe("schemas", () => {
-  describe("filterFields", () => {
-    it("has at least 22 entries", () => {
-      expect(filterFields.length).toBeGreaterThanOrEqual(22);
-    });
-
-    it("has non-empty field and description for every entry", () => {
-      for (const entry of filterFields) {
-        expect(entry.field).toBeTruthy();
-        expect(entry.description).toBeTruthy();
-      }
-    });
-
-    it("contains expected filter fields", () => {
-      const fieldNames = filterFields.map((f) => f.field);
-      expect(fieldNames).toContain("topics.topics");
-      expect(fieldNames).toContain("metadata.user_id");
-      expect(fieldNames).toContain("spans.model");
-      expect(fieldNames).toContain("evaluations.passed");
-      expect(fieldNames).toContain("events.event_type");
-      expect(fieldNames).toContain("annotations.hasAnnotation");
-      expect(fieldNames).toContain("sentiment.input_sentiment");
-    });
-  });
-
-  describe("analyticsMetrics", () => {
-    it("covers expected categories", () => {
-      const categories = new Set(analyticsMetrics.map((m) => m.category));
-      expect(categories).toContain("metadata");
-      expect(categories).toContain("performance");
-      expect(categories).toContain("evaluations");
-      expect(categories).toContain("sentiment");
-      expect(categories).toContain("events");
-    });
-
-    it("has non-empty allowedAggregations for every metric", () => {
-      for (const metric of analyticsMetrics) {
-        expect(metric.allowedAggregations.length).toBeGreaterThan(0);
-      }
-    });
-
-    it("has non-empty name, label, and description for every metric", () => {
-      for (const metric of analyticsMetrics) {
-        expect(metric.name).toBeTruthy();
-        expect(metric.label).toBeTruthy();
-        expect(metric.description).toBeTruthy();
-      }
-    });
-
-    it("contains expected metrics", () => {
-      const names = analyticsMetrics.map((m) => `${m.category}.${m.name}`);
-      expect(names).toContain("metadata.trace_id");
-      expect(names).toContain("performance.completion_time");
-      expect(names).toContain("performance.total_cost");
-      expect(names).toContain("evaluations.evaluation_score");
-    });
-  });
-
-  describe("analyticsGroups", () => {
-    it("has at least 10 entries", () => {
-      expect(analyticsGroups.length).toBeGreaterThanOrEqual(10);
-    });
-
-    it("has non-empty name, label, and description for every group", () => {
-      for (const group of analyticsGroups) {
-        expect(group.name).toBeTruthy();
-        expect(group.label).toBeTruthy();
-        expect(group.description).toBeTruthy();
-      }
-    });
-
-    it("contains expected group-by options", () => {
-      const names = analyticsGroups.map((g) => g.name);
-      expect(names).toContain("topics.topics");
-      expect(names).toContain("metadata.user_id");
-      expect(names).toContain("metadata.model");
-      expect(names).toContain("events.event_type");
-    });
-  });
-});

package/src/__tests__/support/http-server-harness.ts

@@ -1,138 +0,0 @@
-/**
- * Shared fixtures for the standalone MCP HTTP server tests.
- */
-
-import { expect, vi } from "vitest";
-
-import type { ApiKeyVerifier } from "../../http-security.js";
-import { startHttpServer } from "../../http-server.js";
-
-/** Standard headers the MCP Streamable HTTP protocol requires on POST. */
-export const MCP_POST_HEADERS = {
-  "Content-Type": "application/json",
-  Accept: "application/json, text/event-stream",
-};
-
-export const VALID_KEY = "sk-lw-valid-key";
-export const OTHER_VALID_KEY = "sk-lw-other-valid-key";
-
-/**
- * Stands in for the LangWatch API. The standalone server has no database, so
- * it asks the API whether a key is real; here a fixed list is.
- */
-export function countingVerifier(validKeys: string[]) {
-  const verify = vi.fn(async (apiKey: string) => validKeys.includes(apiKey));
-  const verifier: ApiKeyVerifier = {
-    verify,
-    sweep: () => undefined,
-    clear: () => undefined,
-  };
-  return { verifier, verify };
-}
-
-/** A verifier whose accepted keys can change mid-test, to model revocation. */
-export function revocableVerifier(initialKeys: string[]) {
-  const live = new Set(initialKeys);
-  const verifier: ApiKeyVerifier = {
-    verify: async (apiKey: string) => live.has(apiKey),
-    sweep: () => undefined,
-    clear: () => undefined,
-  };
-  return { verifier, revoke: (apiKey: string) => live.delete(apiKey) };
-}
-
-export interface Harness {
-  baseUrl: string;
-  close: () => Promise<void>;
-}
-
-export async function startHarness(
-  options: Parameters<typeof startHttpServer>[0]
-): Promise<Harness> {
-  const { server, port, host } = await startHttpServer(options);
-  return {
-    baseUrl: `http://${host === "0.0.0.0" ? "127.0.0.1" : host}:${port}`,
-    close: () =>
-      new Promise<void>((resolve) => {
-        server.close(() => resolve());
-      }),
-  };
-}
-
-export function initializeBody(): string {
-  return JSON.stringify({
-    jsonrpc: "2.0",
-    method: "initialize",
-    params: {
-      protocolVersion: "2025-03-26",
-      capabilities: {},
-      clientInfo: { name: "test-client", version: "1.0.0" },
-    },
-    id: 1,
-  });
-}
-
-export function toolsListBody(): string {
-  return JSON.stringify({ jsonrpc: "2.0", method: "tools/list", id: 2 });
-}
-
-/** Opens a Streamable HTTP session and returns its id. */
-export async function openSession({
-  baseUrl,
-  apiKey = VALID_KEY,
-}: {
-  baseUrl: string;
-  apiKey?: string;
-}): Promise<string> {
-  const response = await fetch(`${baseUrl}/mcp`, {
-    method: "POST",
-    headers: { ...MCP_POST_HEADERS, Authorization: `Bearer ${apiKey}` },
-    body: initializeBody(),
-  });
-  expect(response.status).toBe(200);
-  await response.text();
-  return response.headers.get("mcp-session-id")!;
-}
-
-/**
- * Reads an SSE stream until the endpoint event carrying the session id has
- * arrived. A single read can return a partial frame, so waiting for the
- * pattern rather than the first chunk keeps this from failing intermittently.
- */
-export async function readSessionId(response: Response): Promise<string> {
-  const reader = response.body!.getReader();
-  const decoder = new TextDecoder();
-  let buffered = "";
-
-  for (let reads = 0; reads < 20; reads++) {
-    const { value, done } = await reader.read();
-    if (done) break;
-    buffered += decoder.decode(value, { stream: true });
-    const match = /sessionId=([\w-]+)/.exec(buffered);
-    if (match?.[1]) return match[1];
-  }
-
-  throw new Error(`No session id in SSE stream. Received: ${buffered}`);
-}
-
-/**
- * Sends `request` repeatedly until it answers 429, and returns that response
- * along with how many attempts it took. Returns `rejected: undefined` when the
- * limit never triggered within `maxAttempts`.
- */
-export async function requestUntilThrottled({
-  request,
-  maxAttempts = 30,
-}: {
-  request: (attempt: number) => Promise<Response>;
-  maxAttempts?: number;
-}): Promise<{ attempts: number; rejected: Response | undefined }> {
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const response = await request(attempt);
-    if (response.status === 429) {
-      return { attempts: attempt + 1, rejected: response };
-    }
-    await response.text();
-  }
-  return { attempts: maxAttempts, rejected: undefined };
-}