@langwatch/mcp-server 0.6.1 → 0.8.0

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

@@ -0,0 +1,244 @@
+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__/docker.integration.test.ts

@@ -0,0 +1,234 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { execSync } from "child_process";
+
+const IMAGE_NAME = "langwatch-mcp-server-test";
+const CONTAINER_NAME = "langwatch-mcp-server-test-container";
+const HOST_PORT = 13099; // unlikely to conflict
+const BEARER_TOKEN = "test-docker-api-key";
+
+/** Standard headers required by the MCP Streamable HTTP protocol */
+const MCP_POST_HEADERS = {
+  "Content-Type": "application/json",
+  Accept: "application/json, text/event-stream",
+};
+
+describe("Docker container", () => {
+  let containerRunning = false;
+
+  beforeAll(async () => {
+    try {
+      // Build from repo root (mcp-server needs langevals/ for build)
+      const repoRoot = process.cwd().replace(/\/mcp-server.*$/, "");
+      execSync(
+        `docker build -t ${IMAGE_NAME} -f mcp-server/Dockerfile .`,
+        {
+          cwd: repoRoot,
+          stdio: "pipe",
+          timeout: 180_000,
+        }
+      );
+
+      // Stop any previous container
+      execSync(`docker rm -f ${CONTAINER_NAME} 2>/dev/null || true`, {
+        stdio: "pipe",
+      });
+
+      // Start the container WITHOUT LANGWATCH_API_KEY -- clients bring their own
+      execSync(
+        `docker run -d --name ${CONTAINER_NAME} -p ${HOST_PORT}:3000 ${IMAGE_NAME}`,
+        { stdio: "pipe" }
+      );
+
+      // Wait for the server to be ready
+      let retries = 0;
+      while (retries < 20) {
+        try {
+          const res = await fetch(`http://localhost:${HOST_PORT}/health`);
+          if (res.ok) {
+            containerRunning = true;
+            break;
+          }
+        } catch {
+          // not ready yet
+        }
+        await new Promise((r) => setTimeout(r, 500));
+        retries++;
+      }
+
+      if (!containerRunning) {
+        const logs = execSync(`docker logs ${CONTAINER_NAME}`, {
+          encoding: "utf8",
+        });
+        throw new Error(`Container failed to start. Logs:\n${logs}`);
+      }
+    } catch (error) {
+      console.error("Docker setup failed:", error);
+      // Clean up on failure
+      execSync(`docker rm -f ${CONTAINER_NAME} 2>/dev/null || true`, {
+        stdio: "pipe",
+      });
+    }
+  }, 180_000); // 3 min for build + start
+
+  afterAll(() => {
+    execSync(`docker rm -f ${CONTAINER_NAME} 2>/dev/null || true`, {
+      stdio: "pipe",
+    });
+  });
+
+  it("health endpoint responds without authentication", async () => {
+    if (!containerRunning) return;
+
+    const res = await fetch(`http://localhost:${HOST_PORT}/health`);
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.status).toBe("ok");
+  });
+
+  it("CORS headers are present", async () => {
+    if (!containerRunning) return;
+
+    const res = await fetch(`http://localhost:${HOST_PORT}/health`);
+    expect(res.headers.get("access-control-allow-origin")).toBe("*");
+  });
+
+  it("returns 401 on initialize without Bearer token", async () => {
+    if (!containerRunning) return;
+
+    const res = await fetch(`http://localhost:${HOST_PORT}/mcp`, {
+      method: "POST",
+      headers: MCP_POST_HEADERS,
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+          protocolVersion: "2025-03-26",
+          capabilities: {},
+          clientInfo: { name: "docker-test", version: "1.0.0" },
+        },
+      }),
+    });
+
+    expect(res.status).toBe(401);
+    const body = await res.json();
+    expect(body.error).toContain("Authorization");
+  });
+
+  it("MCP initialize works with Bearer token", async () => {
+    if (!containerRunning) return;
+
+    const res = await fetch(`http://localhost:${HOST_PORT}/mcp`, {
+      method: "POST",
+      headers: {
+        ...MCP_POST_HEADERS,
+        Authorization: `Bearer ${BEARER_TOKEN}`,
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+          protocolVersion: "2025-03-26",
+          capabilities: {},
+          clientInfo: { name: "docker-test", version: "1.0.0" },
+        },
+      }),
+    });
+
+    expect(res.status).toBe(200);
+    const sessionId = res.headers.get("mcp-session-id");
+    expect(sessionId).toBeTruthy();
+
+    // Parse SSE response for the initialize result
+    const text = await res.text();
+    expect(text).toContain("serverInfo");
+  });
+
+  it("lists tools after initialization with Bearer token", async () => {
+    if (!containerRunning) return;
+
+    // Initialize a session
+    const initRes = await fetch(`http://localhost:${HOST_PORT}/mcp`, {
+      method: "POST",
+      headers: {
+        ...MCP_POST_HEADERS,
+        Authorization: `Bearer ${BEARER_TOKEN}`,
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+          protocolVersion: "2025-03-26",
+          capabilities: {},
+          clientInfo: { name: "docker-test", version: "1.0.0" },
+        },
+      }),
+    });
+
+    const sessionId = initRes.headers.get("mcp-session-id");
+
+    // Send initialized notification
+    await fetch(`http://localhost:${HOST_PORT}/mcp`, {
+      method: "POST",
+      headers: {
+        ...MCP_POST_HEADERS,
+        "mcp-session-id": sessionId!,
+        Authorization: `Bearer ${BEARER_TOKEN}`,
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "notifications/initialized",
+      }),
+    });
+
+    // List tools
+    const toolsRes = await fetch(`http://localhost:${HOST_PORT}/mcp`, {
+      method: "POST",
+      headers: {
+        ...MCP_POST_HEADERS,
+        "mcp-session-id": sessionId!,
+        Authorization: `Bearer ${BEARER_TOKEN}`,
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 2,
+        method: "tools/list",
+      }),
+    });
+
+    expect(toolsRes.status).toBe(200);
+    const toolsText = await toolsRes.text();
+    expect(toolsText).toContain("fetch_langwatch_docs");
+    expect(toolsText).toContain("search_traces");
+  });
+
+  it("legacy SSE endpoint responds with Bearer token", async () => {
+    if (!containerRunning) return;
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+
+    try {
+      const res = await fetch(`http://localhost:${HOST_PORT}/sse`, {
+        signal: controller.signal,
+        headers: { Authorization: `Bearer ${BEARER_TOKEN}` },
+      });
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toContain("text/event-stream");
+    } catch (error: any) {
+      if (error.name !== "AbortError") throw error;
+      // AbortError is expected -- SSE stays open
+    } finally {
+      clearTimeout(timeout);
+    }
+  });
+
+  it("legacy SSE endpoint returns 401 without token", async () => {
+    if (!containerRunning) return;
+
+    const res = await fetch(`http://localhost:${HOST_PORT}/sse`);
+    expect(res.status).toBe(401);
+  });
+});