@langwatch/mcp-server 2.1.0 → 2.2.0

package/src/__tests__/model-provider-tools.unit.test.ts

@@ -1,190 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-vi.mock("../langwatch-api-model-providers.js", () => ({
-  listModelProviders: vi.fn(),
-  setModelProvider: vi.fn(),
-}));
-
-import {
-  listModelProviders,
-  setModelProvider,
-} from "../langwatch-api-model-providers.js";
-
-import { handleListModelProviders } from "../tools/list-model-providers.js";
-import { handleSetModelProvider } from "../tools/set-model-provider.js";
-
-const mockListModelProviders = vi.mocked(listModelProviders);
-const mockSetModelProvider = vi.mocked(setModelProvider);
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-describe("handleListModelProviders()", () => {
-  const sampleProviders = {
-    openai: {
-      provider: "openai",
-      enabled: true,
-      customKeys: { OPENAI_API_KEY: "HAS_KEY" },
-      models: ["gpt-4o", "gpt-4o-mini"],
-      embeddingsModels: ["text-embedding-3-small"],
-      deploymentMapping: null,
-      extraHeaders: [],
-    },
-    anthropic: {
-      provider: "anthropic",
-      enabled: false,
-      customKeys: null,
-      models: ["claude-sonnet-4-5-20250929"],
-      embeddingsModels: null,
-      deploymentMapping: null,
-      extraHeaders: [],
-    },
-  };
-
-  describe("when providers exist", () => {
-    let result: string;
-
-    beforeEach(async () => {
-      mockListModelProviders.mockResolvedValue(sampleProviders);
-      result = await handleListModelProviders();
-    });
-
-    it("includes the total count header", () => {
-      expect(result).toContain("# Model Providers (2 total)");
-    });
-
-    it("includes provider name", () => {
-      expect(result).toContain("## openai");
-    });
-
-    it("shows enabled status", () => {
-      expect(result).toContain("**Status**: enabled");
-    });
-
-    it("shows disabled status", () => {
-      expect(result).toContain("**Status**: disabled");
-    });
-
-    it("shows key fields that are set", () => {
-      expect(result).toContain("OPENAI_API_KEY: set");
-    });
-
-    it("shows model count", () => {
-      expect(result).toContain("2 available");
-    });
-  });
-
-  describe("when no providers exist", () => {
-    let result: string;
-
-    beforeEach(async () => {
-      mockListModelProviders.mockResolvedValue({});
-      result = await handleListModelProviders();
-    });
-
-    it("returns a no-providers message", () => {
-      expect(result).toContain("No model providers configured");
-    });
-
-    it("includes a tip to use platform_set_model_provider", () => {
-      expect(result).toContain("platform_set_model_provider");
-    });
-  });
-});
-
-describe("handleSetModelProvider()", () => {
-  describe("when update succeeds", () => {
-    let result: string;
-
-    beforeEach(async () => {
-      mockSetModelProvider.mockResolvedValue({
-        openai: {
-          provider: "openai",
-          enabled: true,
-          customKeys: { OPENAI_API_KEY: "HAS_KEY" },
-          models: ["gpt-4o"],
-          embeddingsModels: null,
-          deploymentMapping: null,
-          extraHeaders: [],
-        },
-      });
-      result = await handleSetModelProvider({
-        provider: "openai",
-        enabled: true,
-        customKeys: { OPENAI_API_KEY: "sk-test123" },
-      });
-    });
-
-    it("confirms update", () => {
-      expect(result).toContain("Model provider updated successfully!");
-    });
-
-    it("includes provider name", () => {
-      expect(result).toContain("**Provider**: openai");
-    });
-
-    it("shows enabled status", () => {
-      expect(result).toContain("**Status**: enabled");
-    });
-
-    it("shows key fields", () => {
-      expect(result).toContain("OPENAI_API_KEY: set");
-    });
-  });
-
-  describe("when setting default model without provider prefix", () => {
-    let result: string;
-
-    beforeEach(async () => {
-      mockSetModelProvider.mockResolvedValue({
-        openai: {
-          provider: "openai",
-          enabled: true,
-          customKeys: null,
-          models: ["gpt-4o"],
-          embeddingsModels: null,
-          deploymentMapping: null,
-          extraHeaders: [],
-        },
-      });
-      result = await handleSetModelProvider({
-        provider: "openai",
-        enabled: true,
-        defaultModel: "gpt-4o",
-      });
-    });
-
-    it("prepends provider prefix in response", () => {
-      expect(result).toContain("**Default Model**: openai/gpt-4o");
-    });
-  });
-
-  describe("when setting default model with provider prefix already", () => {
-    let result: string;
-
-    beforeEach(async () => {
-      mockSetModelProvider.mockResolvedValue({
-        openai: {
-          provider: "openai",
-          enabled: true,
-          customKeys: null,
-          models: ["gpt-4o"],
-          embeddingsModels: null,
-          deploymentMapping: null,
-          extraHeaders: [],
-        },
-      });
-      result = await handleSetModelProvider({
-        provider: "openai",
-        enabled: true,
-        defaultModel: "openai/gpt-4o",
-      });
-    });
-
-    it("keeps the prefix as-is", () => {
-      expect(result).toContain("**Default Model**: openai/gpt-4o");
-      expect(result).not.toContain("openai/openai/");
-    });
-  });
-});

package/src/__tests__/project-api-key-tools.unit.test.ts

@@ -1,451 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-vi.mock("../langwatch-api-projects.js", () => ({
-  listProjects: vi.fn(),
-  getProject: vi.fn(),
-  createProject: vi.fn(),
-  updateProject: vi.fn(),
-  archiveProject: vi.fn(),
-}));
-
-vi.mock("../langwatch-api-api-keys.js", () => ({
-  listApiKeys: vi.fn(),
-  createApiKey: vi.fn(),
-  revokeApiKey: vi.fn(),
-}));
-
-import {
-  listProjects,
-  getProject,
-  createProject,
-  updateProject,
-  archiveProject,
-} from "../langwatch-api-projects.js";
-
-import {
-  listApiKeys,
-  createApiKey,
-  revokeApiKey,
-} from "../langwatch-api-api-keys.js";
-
-import { handleListProjects } from "../tools/list-projects.js";
-import { handleGetProject } from "../tools/get-project.js";
-import { handleCreateProject } from "../tools/create-project.js";
-import { handleUpdateProject } from "../tools/update-project.js";
-import { handleArchiveProject } from "../tools/archive-project.js";
-import { handleListApiKeys } from "../tools/list-api-keys.js";
-import { handleCreateApiKey } from "../tools/create-api-key.js";
-import { handleRevokeApiKey } from "../tools/revoke-api-key.js";
-
-const mockListProjects = vi.mocked(listProjects);
-const mockGetProject = vi.mocked(getProject);
-const mockCreateProject = vi.mocked(createProject);
-const mockUpdateProject = vi.mocked(updateProject);
-const mockArchiveProject = vi.mocked(archiveProject);
-const mockListApiKeys = vi.mocked(listApiKeys);
-const mockCreateApiKey = vi.mocked(createApiKey);
-const mockRevokeApiKey = vi.mocked(revokeApiKey);
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-// --- Project Tools ---
-
-describe("handleListProjects()", () => {
-  const sampleProjects = [
-    {
-      id: "proj_abc123",
-      name: "My Project",
-      slug: "my-project",
-      language: "python",
-      framework: "openai",
-      teamId: "team_1",
-      piiRedactionLevel: "ESSENTIAL",
-      createdAt: "2024-01-01T00:00:00Z",
-      updatedAt: "2024-06-01T00:00:00Z",
-    },
-    {
-      id: "proj_def456",
-      name: "Another Project",
-      slug: "another-project",
-      language: "typescript",
-      framework: "langchain",
-      teamId: "team_1",
-      piiRedactionLevel: "DISABLED",
-      createdAt: "2024-02-01T00:00:00Z",
-      updatedAt: "2024-07-01T00:00:00Z",
-    },
-  ];
-
-  describe("when projects exist", () => {
-    let result: string;
-
-    beforeEach(async () => {
-      mockListProjects.mockResolvedValue({
-        data: sampleProjects,
-        pagination: { page: 1, limit: 100, total: 2, totalPages: 1 },
-      });
-      result = await handleListProjects();
-    });
-
-    it("includes project count", () => {
-      expect(result).toContain("2 total");
-    });
-
-    it("includes project names", () => {
-      expect(result).toContain("My Project");
-      expect(result).toContain("Another Project");
-    });
-
-    it("includes project IDs", () => {
-      expect(result).toContain("proj_abc123");
-      expect(result).toContain("proj_def456");
-    });
-
-    it("includes language and framework", () => {
-      expect(result).toContain("python");
-      expect(result).toContain("openai");
-    });
-  });
-
-  describe("when no projects exist", () => {
-    it("returns empty state with tip", async () => {
-      mockListProjects.mockResolvedValue({
-        data: [],
-        pagination: { page: 1, limit: 100, total: 0, totalPages: 0 },
-      });
-      const result = await handleListProjects();
-      expect(result).toContain("No projects found");
-      expect(result).toContain("platform_create_project");
-    });
-  });
-
-  describe("when paginated", () => {
-    it("shows pagination hint", async () => {
-      mockListProjects.mockResolvedValue({
-        data: [sampleProjects[0]!],
-        pagination: { page: 1, limit: 1, total: 5, totalPages: 5 },
-      });
-      const result = await handleListProjects({ limit: 1 });
-      expect(result).toContain("page 1 of 5");
-    });
-  });
-});
-
-describe("handleGetProject()", () => {
-  it("returns formatted project details", async () => {
-    mockGetProject.mockResolvedValue({
-      id: "proj_abc123",
-      name: "My Project",
-      slug: "my-project",
-      language: "python",
-      framework: "openai",
-      teamId: "team_1",
-      piiRedactionLevel: "ESSENTIAL",
-      createdAt: "2024-01-01T00:00:00Z",
-      updatedAt: "2024-06-01T00:00:00Z",
-    });
-
-    const result = await handleGetProject({ id: "proj_abc123" });
-
-    expect(result).toContain("My Project");
-    expect(result).toContain("proj_abc123");
-    expect(result).toContain("python");
-    expect(result).toContain("ESSENTIAL");
-  });
-});
-
-describe("handleCreateProject()", () => {
-  it("returns project details with service API key", async () => {
-    mockCreateProject.mockResolvedValue({
-      id: "proj_new",
-      name: "New Project",
-      slug: "new-project",
-      language: "typescript",
-      framework: "custom",
-      teamId: "team_1",
-      piiRedactionLevel: "DISABLED",
-      createdAt: "2024-01-01T00:00:00Z",
-      updatedAt: "2024-01-01T00:00:00Z",
-      serviceApiKey: "lw_sk_abc123secret",
-      serviceApiKeyId: "key_svc_1",
-    });
-
-    const result = await handleCreateProject({
-      name: "New Project",
-      language: "typescript",
-      framework: "custom",
-      newTeamName: "My Team",
-    });
-
-    expect(result).toContain("created successfully");
-    expect(result).toContain("New Project");
-    expect(result).toContain("proj_new");
-    expect(result).toContain("lw_sk_abc123secret");
-    expect(result).toContain("Save the service API key now");
-  });
-});
-
-describe("handleUpdateProject()", () => {
-  it("returns updated project details", async () => {
-    mockUpdateProject.mockResolvedValue({
-      id: "proj_abc123",
-      name: "Renamed Project",
-      slug: "my-project",
-      language: "python",
-      framework: "openai",
-      teamId: "team_1",
-      piiRedactionLevel: "STRICT",
-      createdAt: "2024-01-01T00:00:00Z",
-      updatedAt: "2024-08-01T00:00:00Z",
-    });
-
-    const result = await handleUpdateProject({
-      id: "proj_abc123",
-      name: "Renamed Project",
-      piiRedactionLevel: "STRICT",
-    });
-
-    expect(result).toContain("updated successfully");
-    expect(result).toContain("Renamed Project");
-    expect(result).toContain("STRICT");
-  });
-});
-
-describe("handleArchiveProject()", () => {
-  it("returns archive confirmation", async () => {
-    mockArchiveProject.mockResolvedValue({
-      id: "proj_abc123",
-      name: "My Project",
-      archivedAt: "2024-09-01T00:00:00Z",
-    });
-
-    const result = await handleArchiveProject({ id: "proj_abc123" });
-
-    expect(result).toContain("archived successfully");
-    expect(result).toContain("proj_abc123");
-    expect(result).toContain("My Project");
-  });
-});
-
-// --- API Key Tools ---
-
-describe("handleListApiKeys()", () => {
-  describe("when keys exist", () => {
-    it("shows key metadata and status", async () => {
-      mockListApiKeys.mockResolvedValue({
-        data: [
-          {
-            id: "key_1",
-            name: "Production Key",
-            description: "Main production API key",
-            createdAt: "2024-01-01T00:00:00Z",
-            expiresAt: null,
-            lastUsedAt: "2024-06-01T00:00:00Z",
-            revokedAt: null,
-            roleBindings: [
-              { id: "rb_1", role: "ADMIN", scopeType: "PROJECT", scopeId: "proj_abc" },
-            ],
-          },
-          {
-            id: "key_2",
-            name: "Revoked Key",
-            description: null,
-            createdAt: "2024-01-01T00:00:00Z",
-            expiresAt: null,
-            lastUsedAt: null,
-            revokedAt: "2024-05-01T00:00:00Z",
-            roleBindings: [],
-          },
-        ],
-      });
-
-      const result = await handleListApiKeys();
-
-      expect(result).toContain("2 total");
-      expect(result).toContain("Production Key");
-      expect(result).toContain("ACTIVE");
-      expect(result).toContain("Revoked Key");
-      expect(result).toContain("REVOKED");
-      expect(result).toContain("ADMIN on PROJECT:proj_abc");
-    });
-  });
-
-  describe("when no keys exist", () => {
-    it("returns empty state with tip", async () => {
-      mockListApiKeys.mockResolvedValue({ data: [] });
-
-      const result = await handleListApiKeys();
-
-      expect(result).toContain("No API keys found");
-      expect(result).toContain("platform_create_api_key");
-    });
-  });
-});
-
-describe("handleCreateApiKey()", () => {
-  it("returns token with save warning", async () => {
-    mockCreateApiKey.mockResolvedValue({
-      token: "lw_pat_secret_token_123",
-      apiKey: {
-        id: "key_new",
-        name: "My New Key",
-        createdAt: "2024-01-01T00:00:00Z",
-      },
-    });
-
-    const result = await handleCreateApiKey({
-      keyType: "personal",
-      name: "My New Key",
-      bindings: [
-        { role: "ADMIN", scopeType: "ORGANIZATION", scopeId: "org_1" },
-      ],
-    });
-
-    expect(result).toContain("created successfully");
-    expect(result).toContain("My New Key");
-    expect(result).toContain("lw_pat_secret_token_123");
-    expect(result).toContain("Save this token now");
-  });
-});
-
-describe("handleRevokeApiKey()", () => {
-  it("confirms revocation", async () => {
-    mockRevokeApiKey.mockResolvedValue({ success: true });
-
-    const result = await handleRevokeApiKey({ id: "key_123" });
-
-    expect(result).toContain("key_123");
-    expect(result).toContain("revoked successfully");
-  });
-});
-
-// --- Error-path tests ---
-
-describe("handleCreateProject() validation", () => {
-  describe("when neither teamId nor newTeamName is provided", () => {
-    it("returns a validation error without calling the API", async () => {
-      const result = await handleCreateProject({
-        name: "Test Project",
-        language: "python",
-        framework: "openai",
-      });
-
-      expect(result).toContain("Error");
-      expect(result).toContain("teamId");
-      expect(result).toContain("newTeamName");
-      expect(mockCreateProject).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("when API does not return a serviceApiKey", () => {
-    it("throws an error to prevent silent data loss", async () => {
-      mockCreateProject.mockResolvedValue({
-        id: "proj_new",
-        name: "New Project",
-        slug: "new-project",
-        language: "typescript",
-        framework: "custom",
-        teamId: "team_1",
-        piiRedactionLevel: "DISABLED",
-        createdAt: "2024-01-01T00:00:00Z",
-        updatedAt: "2024-01-01T00:00:00Z",
-        serviceApiKey: "",
-        serviceApiKeyId: "key_svc_1",
-      } as never);
-
-      await expect(
-        handleCreateProject({
-          name: "New Project",
-          language: "typescript",
-          framework: "custom",
-          newTeamName: "My Team",
-        }),
-      ).rejects.toThrow("service API key");
-    });
-  });
-});
-
-describe("handleListProjects() edge cases", () => {
-  describe("when API returns non-array data", () => {
-    it("returns empty state message", async () => {
-      mockListProjects.mockResolvedValue({
-        data: null as never,
-        pagination: { page: 1, limit: 100, total: 0, totalPages: 0 },
-      });
-
-      const result = await handleListProjects();
-
-      expect(result).toContain("No projects found");
-    });
-  });
-
-  describe("when API call throws", () => {
-    it("propagates the error", async () => {
-      mockListProjects.mockRejectedValue(
-        new Error('LangWatch API error 403: {"error":"Forbidden","message":"Insufficient permissions"}'),
-      );
-
-      await expect(handleListProjects()).rejects.toThrow("403");
-    });
-  });
-});
-
-describe("handleListApiKeys() edge cases", () => {
-  describe("when a key has a past expiration date", () => {
-    it("shows EXPIRED status", async () => {
-      mockListApiKeys.mockResolvedValue({
-        data: [
-          {
-            id: "key_exp",
-            name: "Expired Key",
-            description: null,
-            createdAt: "2024-01-01T00:00:00Z",
-            expiresAt: "2024-06-01T00:00:00Z",
-            lastUsedAt: null,
-            revokedAt: null,
-            roleBindings: [],
-          },
-        ],
-      });
-
-      const result = await handleListApiKeys();
-
-      expect(result).toContain("EXPIRED");
-    });
-  });
-
-  describe("when a key has a future expiration date", () => {
-    it("shows ACTIVE status", async () => {
-      mockListApiKeys.mockResolvedValue({
-        data: [
-          {
-            id: "key_future",
-            name: "Future Key",
-            description: null,
-            createdAt: "2024-01-01T00:00:00Z",
-            expiresAt: "2099-12-31T23:59:59Z",
-            lastUsedAt: null,
-            revokedAt: null,
-            roleBindings: [],
-          },
-        ],
-      });
-
-      const result = await handleListApiKeys();
-
-      expect(result).toContain("ACTIVE");
-    });
-  });
-
-  describe("when API returns non-array data", () => {
-    it("returns empty state message", async () => {
-      mockListApiKeys.mockResolvedValue({ data: null as never });
-
-      const result = await handleListApiKeys();
-
-      expect(result).toContain("No API keys found");
-    });
-  });
-});

package/src/__tests__/prompt-response-types.unit.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type {
-  PromptDetailResponse,
-  PromptMutationResponse,
-} from "../langwatch-api.js";
-
-describe("Prompt response type interfaces", () => {
-  describe("given fully-populated PromptDetailResponse and PromptMutationResponse fixtures", () => {
-    /** @scenario Declaring every rendered field on the typed response interfaces */
-    it("declares every field the prompt tools render, with no `as` cast needed", () => {
-      // Mirrors apiResponsePromptWithVersionDataSchema (the real GET
-      // /api/prompts/:id contract): version data flattened to the top level,
-      // parameters as an object map, tags as { name, versionId } objects,
-      // and no nested versions array.
-      const detail: PromptDetailResponse = {
-        id: "p1",
-        handle: "greeting-bot",
-        name: "Greeting Bot",
-        version: 3,
-        versionId: "ver_abc123",
-        commitMessage: "Updated tone",
-        model: "openai/gpt-4o",
-        messages: [{ role: "system", content: "You are a friendly bot." }],
-        prompt: "You are a friendly bot.",
-        temperature: 0.7,
-        maxTokens: 512,
-        responseFormat: { type: "json_object" },
-        parameters: { reasoning_effort: "low" },
-        inputs: [{ identifier: "question", type: "str" }],
-        outputs: [{ identifier: "answer", type: "str" }],
-        tags: [
-          { name: "production", versionId: "ver_abc123" },
-          { name: "latest", versionId: "ver_abc123" },
-        ],
-      };
-
-      const mutation: PromptMutationResponse = {
-        id: "p1",
-        handle: "greeting-bot",
-        name: "Greeting Bot",
-        latestVersionNumber: 4,
-        versionId: "ver_def456",
-        tags: ["production"],
-      };
-
-      expect(detail.versionId).toBe("ver_abc123");
-      expect(detail.tags?.[0]?.versionId).toBe("ver_abc123");
-      expect(mutation.versionId).toBe("ver_def456");
-    });
-  });
-});