@langwatch/mcp-server 0.5.0 → 0.6.0

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

@@ -0,0 +1,190 @@
+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__/scenario-tools.integration.test.ts

@@ -165,7 +165,7 @@ describe("MCP scenario tools integration", () => {
     await new Promise<void>((resolve) => server.close(() => resolve()));
   });
 
-  describe("list_scenarios", () => {
+  describe("platform_list_scenarios", () => {
     describe("when the API returns scenarios", () => {
       it("returns a non-empty result", async () => {
         const { handleListScenarios } = await import(
@@ -187,7 +187,7 @@ describe("MCP scenario tools integration", () => {
     });
   });
 
-  describe("get_scenario", () => {
+  describe("platform_get_scenario", () => {
     describe("when the scenario exists", () => {
       it("returns a non-empty result", async () => {
         const { handleGetScenario } = await import(
@@ -210,7 +210,7 @@ describe("MCP scenario tools integration", () => {
     });
   });
 
-  describe("create_scenario", () => {
+  describe("platform_create_scenario", () => {
     describe("when valid data is provided", () => {
       it("returns confirmation with new scenario ID", async () => {
         const { handleCreateScenario } = await import(
@@ -241,7 +241,7 @@ describe("MCP scenario tools integration", () => {
     });
   });
 
-  describe("update_scenario", () => {
+  describe("platform_update_scenario", () => {
     describe("when the scenario exists", () => {
       it("returns a non-empty result", async () => {
         const { handleUpdateScenario } = await import(
@@ -270,7 +270,7 @@ describe("MCP scenario tools integration", () => {
     });
   });
 
-  describe("archive_scenario", () => {
+  describe("platform_archive_scenario", () => {
     describe("when the scenario exists", () => {
       it("returns confirmation that scenario was archived", async () => {
         const { handleArchiveScenario } = await import(

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

@@ -96,8 +96,8 @@ describe("handleListScenarios()", () => {
       expect(result).toContain("No scenarios found");
     });
 
-    it("includes a tip to use create_scenario", () => {
-      expect(result).toContain("create_scenario");
+    it("includes a tip to use platform_create_scenario", () => {
+      expect(result).toContain("platform_create_scenario");
     });
   });
 

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

@@ -8,7 +8,6 @@ vi.mock("../langwatch-api.js", () => ({
   getPrompt: vi.fn(),
   createPrompt: vi.fn(),
   updatePrompt: vi.fn(),
-  createPromptVersion: vi.fn(),
 }));
 
 import {
@@ -19,7 +18,6 @@ import {
   getPrompt,
   createPrompt,
   updatePrompt,
-  createPromptVersion,
   type PromptSummary,
 } from "../langwatch-api.js";
 
@@ -38,7 +36,6 @@ const mockListPrompts = vi.mocked(listPrompts);
 const mockGetPrompt = vi.mocked(getPrompt);
 const mockCreatePrompt = vi.mocked(createPrompt);
 const mockUpdatePrompt = vi.mocked(updatePrompt);
-const mockCreatePromptVersion = vi.mocked(createPromptVersion);
 
 beforeEach(() => {
   vi.clearAllMocks();
@@ -449,22 +446,20 @@ describe("handleListPrompts()", () => {
           handle: "greeting",
           name: "Greeting Prompt",
           latestVersionNumber: 3,
-          description: "A friendly greeting prompt",
         },
         {
           id: "p2",
           name: "Summary",
           version: 1,
-          description: "",
         },
       ]);
 
       const result = await handleListPrompts();
 
       expect(result).toContain("# Prompts (2 total)");
-      expect(result).toContain("| Handle | Name | Latest Version | Description |");
-      expect(result).toContain("| greeting | Greeting Prompt | v3 | A friendly greeting prompt |");
-      expect(result).toContain("| p2 | Summary | v1 |  |");
+      expect(result).toContain("| Handle | Name | Latest Version |");
+      expect(result).toContain("| greeting | Greeting Prompt | v3 |");
+      expect(result).toContain("| p2 | Summary | v1 |");
     });
   });
 
@@ -488,14 +483,14 @@ describe("handleListPrompts()", () => {
     });
   });
 
-  it("includes usage tip about get_prompt", async () => {
+  it("includes usage tip about platform_get_prompt", async () => {
     mockListPrompts.mockResolvedValue([
       { handle: "test", name: "Test", latestVersionNumber: 1 },
     ]);
 
     const result = await handleListPrompts();
 
-    expect(result).toContain("get_prompt");
+    expect(result).toContain("platform_get_prompt");
   });
 });
 
@@ -506,13 +501,11 @@ describe("handleGetPrompt()", () => {
         id: "p1",
         handle: "greeting",
         name: "Greeting Prompt",
-        description: "A greeting",
         latestVersionNumber: 2,
         versions: [
           {
             version: 2,
-            model: "gpt-4o",
-            modelProvider: "openai",
+            model: "openai/gpt-4o",
             messages: [
               { role: "system", content: "You are a greeter." },
               { role: "user", content: "Hello!" },
@@ -531,10 +524,9 @@ describe("handleGetPrompt()", () => {
       expect(result).toContain("# Prompt: Greeting Prompt");
       expect(result).toContain("**Handle**: greeting");
       expect(result).toContain("**ID**: p1");
-      expect(result).toContain("**Description**: A greeting");
       expect(result).toContain("**Latest Version**: v2");
-      expect(result).toContain("**Model**: gpt-4o");
-      expect(result).toContain("**Provider**: openai");
+      expect(result).toContain("**Model**: openai/gpt-4o");
+      expect(result).not.toContain("**Provider**");
     });
 
     it("formats messages", async () => {
@@ -598,15 +590,14 @@ describe("handleGetPrompt()", () => {
     it("uses prompt-level model config", async () => {
       mockGetPrompt.mockResolvedValue({
         name: "Simple",
-        model: "gpt-3.5-turbo",
-        modelProvider: "openai",
+        model: "openai/gpt-3.5-turbo",
         messages: [{ role: "system", content: "Be brief." }],
       });
 
       const result = await handleGetPrompt({ idOrHandle: "simple" });
 
-      expect(result).toContain("**Model**: gpt-3.5-turbo");
-      expect(result).toContain("**Provider**: openai");
+      expect(result).toContain("**Model**: openai/gpt-3.5-turbo");
+      expect(result).not.toContain("**Provider**");
       expect(result).toContain("### system\nBe brief.");
     });
   });
@@ -626,17 +617,55 @@ describe("handleCreatePrompt()", () => {
         name: "My Prompt",
         handle: "my-prompt",
         messages: [{ role: "system", content: "You are helpful." }],
-        model: "gpt-4o",
-        modelProvider: "openai",
+        model: "openai/gpt-4o",
       });
 
       expect(result).toContain("Prompt created successfully!");
       expect(result).toContain("**ID**: new-id-123");
       expect(result).toContain("**Handle**: my-prompt");
       expect(result).toContain("**Name**: My Prompt");
-      expect(result).toContain("**Model**: gpt-4o (openai)");
+      expect(result).toContain("**Model**: openai/gpt-4o");
       expect(result).toContain("**Version**: v1");
     });
+
+    it("generates handle from name when handle is not provided", async () => {
+      mockCreatePrompt.mockResolvedValue({
+        id: "new-id",
+        handle: "my-prompt",
+      });
+
+      await handleCreatePrompt({
+        name: "My Prompt!",
+        messages: [{ role: "system", content: "test" }],
+        model: "openai/gpt-4o",
+      });
+
+      expect(mockCreatePrompt).toHaveBeenCalledWith({
+        handle: "my-prompt",
+        messages: [{ role: "system", content: "test" }],
+        model: "openai/gpt-4o",
+      });
+    });
+
+    it("uses provided handle instead of generating one", async () => {
+      mockCreatePrompt.mockResolvedValue({
+        id: "new-id",
+        handle: "custom-handle",
+      });
+
+      await handleCreatePrompt({
+        name: "My Prompt",
+        handle: "custom-handle",
+        messages: [{ role: "system", content: "test" }],
+        model: "openai/gpt-4o",
+      });
+
+      expect(mockCreatePrompt).toHaveBeenCalledWith({
+        handle: "custom-handle",
+        messages: [{ role: "system", content: "test" }],
+        model: "openai/gpt-4o",
+      });
+    });
   });
 
   describe("when API returns no name", () => {
@@ -646,8 +675,7 @@ describe("handleCreatePrompt()", () => {
       const result = await handleCreatePrompt({
         name: "Fallback Name",
         messages: [{ role: "system", content: "test" }],
-        model: "gpt-4o",
-        modelProvider: "openai",
+        model: "openai/gpt-4o",
       });
 
       expect(result).toContain("**Name**: Fallback Name");
@@ -656,7 +684,7 @@ describe("handleCreatePrompt()", () => {
 });
 
 describe("handleUpdatePrompt()", () => {
-  describe("when updating in place", () => {
+  describe("when updating a prompt", () => {
     it("formats an update success message", async () => {
       mockUpdatePrompt.mockResolvedValue({
         id: "p1",
@@ -677,53 +705,19 @@ describe("handleUpdatePrompt()", () => {
       expect(result).toContain("**Commit**: Update system prompt");
     });
 
-    it("calls updatePrompt API", async () => {
+    it("calls updatePrompt API with correct params", async () => {
       mockUpdatePrompt.mockResolvedValue({});
 
       await handleUpdatePrompt({
         idOrHandle: "greeting",
-        model: "gpt-4o",
+        model: "openai/gpt-4o",
+        commitMessage: "Switch model",
       });
 
       expect(mockUpdatePrompt).toHaveBeenCalledWith("greeting", {
-        model: "gpt-4o",
-      });
-      expect(mockCreatePromptVersion).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("when creating a new version", () => {
-    it("formats a version creation success message", async () => {
-      mockCreatePromptVersion.mockResolvedValue({
-        id: "p1",
-        latestVersionNumber: 3,
-      });
-
-      const result = await handleUpdatePrompt({
-        idOrHandle: "greeting",
-        messages: [{ role: "system", content: "New version" }],
-        createVersion: true,
-        commitMessage: "v3",
-      });
-
-      expect(result).toContain("New version created successfully!");
-      expect(result).toContain("**Version**: v3");
-      expect(result).toContain("**Commit**: v3");
-    });
-
-    it("calls createPromptVersion API", async () => {
-      mockCreatePromptVersion.mockResolvedValue({});
-
-      await handleUpdatePrompt({
-        idOrHandle: "greeting",
-        messages: [{ role: "system", content: "New" }],
-        createVersion: true,
-      });
-
-      expect(mockCreatePromptVersion).toHaveBeenCalledWith("greeting", {
-        messages: [{ role: "system", content: "New" }],
+        model: "openai/gpt-4o",
+        commitMessage: "Switch model",
       });
-      expect(mockUpdatePrompt).not.toHaveBeenCalled();
     });
   });
 });