@langwatch/mcp-server 0.6.1 → 0.7.0

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

@@ -8,6 +8,11 @@ vi.mock("../langwatch-api.js", () => ({
   getPrompt: vi.fn(),
   createPrompt: vi.fn(),
   updatePrompt: vi.fn(),
+  assignPromptTag: vi.fn(),
+  listPromptTags: vi.fn(),
+  createPromptTag: vi.fn(),
+  renamePromptTag: vi.fn(),
+  deletePromptTag: vi.fn(),
 }));
 
 import {
@@ -18,6 +23,11 @@ import {
   getPrompt,
   createPrompt,
   updatePrompt,
+  assignPromptTag,
+  listPromptTags,
+  createPromptTag,
+  renamePromptTag,
+  deletePromptTag,
   type PromptSummary,
 } from "../langwatch-api.js";
 
@@ -28,6 +38,11 @@ import { handleListPrompts } from "../tools/list-prompts.js";
 import { handleGetPrompt } from "../tools/get-prompt.js";
 import { handleCreatePrompt } from "../tools/create-prompt.js";
 import { handleUpdatePrompt } from "../tools/update-prompt.js";
+import { handleAssignPromptTag } from "../tools/assign-prompt-tag.js";
+import { handleListPromptTags } from "../tools/list-prompt-tags.js";
+import { handleCreatePromptTag } from "../tools/create-prompt-tag.js";
+import { handleRenamePromptTag } from "../tools/rename-prompt-tag.js";
+import { handleDeletePromptTag } from "../tools/delete-prompt-tag.js";
 
 const mockSearchTraces = vi.mocked(searchTraces);
 const mockGetTraceById = vi.mocked(getTraceById);
@@ -36,6 +51,11 @@ const mockListPrompts = vi.mocked(listPrompts);
 const mockGetPrompt = vi.mocked(getPrompt);
 const mockCreatePrompt = vi.mocked(createPrompt);
 const mockUpdatePrompt = vi.mocked(updatePrompt);
+const mockAssignPromptTag = vi.mocked(assignPromptTag);
+const mockListPromptTags = vi.mocked(listPromptTags);
+const mockCreatePromptTag = vi.mocked(createPromptTag);
+const mockRenamePromptTag = vi.mocked(renamePromptTag);
+const mockDeletePromptTag = vi.mocked(deletePromptTag);
 
 beforeEach(() => {
   vi.clearAllMocks();
@@ -390,6 +410,31 @@ describe("handleGetAnalytics()", () => {
       expect(result).toContain("Grouped by: metadata.model");
     });
 
+    it("formats grouped data with group column", async () => {
+      mockGetAnalytics.mockResolvedValue({
+        currentPeriod: [
+          {
+            date: "2024-01-01",
+            "sentiment.thumbs_up_down": {
+              "Thumbs Up": { "0/metadata.trace_id/cardinality": 10 },
+              "Thumbs Down": { "0/metadata.trace_id/cardinality": 5 },
+            },
+          },
+        ],
+        previousPeriod: [],
+      });
+
+      const result = await handleGetAnalytics({
+        metric: "metadata.trace_id",
+        aggregation: "cardinality",
+        groupBy: "sentiment.thumbs_up_down",
+      });
+
+      expect(result).toContain("| Date | Group | Value |");
+      expect(result).toContain("| 2024-01-01 | Thumbs Up | 10 |");
+      expect(result).toContain("| 2024-01-01 | Thumbs Down | 5 |");
+    });
+
     it("uses the specified aggregation", async () => {
       mockGetAnalytics.mockResolvedValue({ currentPeriod: [], previousPeriod: [] });
 
@@ -721,3 +766,135 @@ describe("handleUpdatePrompt()", () => {
     });
   });
 });
+
+describe("handleGetPrompt() with tag options", () => {
+  describe("when called with a tag", () => {
+    it("passes tag option to the API", async () => {
+      mockGetPrompt.mockResolvedValue({ name: "Test" });
+
+      await handleGetPrompt({ idOrHandle: "pizza-prompt", tag: "production" });
+
+      expect(mockGetPrompt).toHaveBeenCalledWith("pizza-prompt", { version: undefined, tag: "production" });
+    });
+  });
+});
+
+describe("handleCreatePrompt() with tags", () => {
+  describe("when called with tags", () => {
+    it("includes tags in the output", async () => {
+      mockCreatePrompt.mockResolvedValue({ id: "p1", handle: "test" });
+
+      const result = await handleCreatePrompt({
+        name: "Test",
+        messages: [{ role: "system", content: "hi" }],
+        model: "openai/gpt-5-mini",
+        tags: ["production"],
+      });
+
+      expect(result).toContain("**Tags**: production");
+    });
+  });
+});
+
+describe("handleUpdatePrompt() with tags", () => {
+  describe("when called with tags", () => {
+    it("includes tags in the output", async () => {
+      mockUpdatePrompt.mockResolvedValue({ id: "p1", handle: "test", latestVersionNumber: 2 });
+
+      const result = await handleUpdatePrompt({
+        idOrHandle: "test",
+        commitMessage: "add tags",
+        tags: ["staging"],
+      });
+
+      expect(result).toContain("**Tags**: staging");
+    });
+  });
+});
+
+describe("handleAssignPromptTag()", () => {
+  describe("when tag is assigned successfully", () => {
+    it("returns a confirmation with prompt, tag, and version", async () => {
+      mockAssignPromptTag.mockResolvedValue({ success: true });
+
+      const result = await handleAssignPromptTag({
+        idOrHandle: "pizza-prompt",
+        tag: "production",
+        versionId: "v123",
+      });
+
+      expect(result).toContain("Tag assigned successfully!");
+      expect(result).toContain("**Prompt**: pizza-prompt");
+      expect(result).toContain("**Tag**: production");
+      expect(result).toContain("**Version ID**: v123");
+    });
+  });
+});
+
+describe("handleListPromptTags()", () => {
+  describe("when tags exist", () => {
+    it("formats tags as a markdown list", async () => {
+      mockListPromptTags.mockResolvedValue([
+        { id: "1", name: "production", createdAt: "2024-01-01" },
+        { id: "2", name: "staging" },
+      ]);
+
+      const result = await handleListPromptTags();
+
+      expect(result).toContain("# Prompt Tags");
+      expect(result).toContain("**production**");
+      expect(result).toContain("**staging**");
+    });
+  });
+
+  describe("when no tags exist", () => {
+    it("returns an empty-state message mentioning latest", async () => {
+      mockListPromptTags.mockResolvedValue([]);
+
+      const result = await handleListPromptTags();
+
+      expect(result).toContain("No prompt tags found");
+      expect(result).toContain("`latest`");
+    });
+  });
+});
+
+describe("handleCreatePromptTag()", () => {
+  describe("when tag is created successfully", () => {
+    it("returns a confirmation with the tag name", async () => {
+      mockCreatePromptTag.mockResolvedValue({ id: "t1", name: "canary" });
+
+      const result = await handleCreatePromptTag({ name: "canary" });
+
+      expect(result).toContain("Tag created successfully!");
+      expect(result).toContain("**Name**: canary");
+    });
+  });
+});
+
+describe("handleRenamePromptTag()", () => {
+  describe("when tag is renamed successfully", () => {
+    it("returns a confirmation with old and new names", async () => {
+      mockRenamePromptTag.mockResolvedValue({ id: "t1", name: "preview" });
+
+      const result = await handleRenamePromptTag({ tag: "canary", name: "preview" });
+
+      expect(result).toContain("Tag renamed successfully!");
+      expect(result).toContain("**Old name**: canary");
+      expect(result).toContain("**New name**: preview");
+    });
+  });
+});
+
+describe("handleDeletePromptTag()", () => {
+  describe("when tag is deleted successfully", () => {
+    it("returns a confirmation with the tag name", async () => {
+      mockDeletePromptTag.mockResolvedValue(null);
+
+      const result = await handleDeletePromptTag({ tag: "canary" });
+
+      expect(result).toContain("Tag deleted successfully!");
+      expect(result).toContain("**Tag**: canary");
+    });
+  });
+});

package/src/config.d.ts

@@ -0,0 +1,15 @@
+export interface McpConfig {
+  apiKey: string | undefined;
+  endpoint: string;
+}
+
+export declare function initConfig(args: {
+  apiKey?: string;
+  endpoint?: string;
+}): void;
+
+export declare function getConfig(): McpConfig;
+
+export declare function requireApiKey(): string;
+
+export declare function runWithConfig<T>(config: McpConfig, fn: () => T): T;

package/src/config.ts

@@ -1,12 +1,56 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
 export interface McpConfig {
   apiKey: string | undefined;
   endpoint: string;
 }
 
-let config: McpConfig | undefined;
+// ---------------------------------------------------------------------------
+// Singleton storage on globalThis
+//
+// When the langwatch app (CJS, no "type": "module") imports this module,
+// tsx creates a CJS-cached copy. When mcp-server's own ESM dist chunks
+// do `await import("./search-traces-*.js")`, Node creates a separate
+// ESM-cached copy. Module-level variables are NOT shared between them.
+//
+// By storing config on globalThis, both CJS and ESM instances read/write
+// the same object, fixing the "Config not initialized" error that occurs
+// when initConfig() runs on the CJS side but tool handlers execute on
+// the ESM side.
+// ---------------------------------------------------------------------------
+
+const GLOBAL_KEY = "__langwatch_mcp_config" as const;
+const STORAGE_KEY = "__langwatch_mcp_config_storage" as const;
+
+interface McpGlobalState {
+  globalConfig: McpConfig | undefined;
+  configStorage: AsyncLocalStorage<McpConfig>;
+}
+
+function getGlobalState(): McpGlobalState {
+  const g = globalThis as unknown as Record<string, unknown>;
+  if (!g[GLOBAL_KEY]) {
+    g[GLOBAL_KEY] = undefined;
+  }
+  if (!g[STORAGE_KEY]) {
+    g[STORAGE_KEY] = new AsyncLocalStorage<McpConfig>();
+  }
+  return {
+    get globalConfig() {
+      return g[GLOBAL_KEY] as McpConfig | undefined;
+    },
+    set globalConfig(val: McpConfig | undefined) {
+      g[GLOBAL_KEY] = val;
+    },
+    get configStorage() {
+      return g[STORAGE_KEY] as AsyncLocalStorage<McpConfig>;
+    },
+  };
+}
 
 export function initConfig(args: { apiKey?: string; endpoint?: string }): void {
-  config = {
+  const state = getGlobalState();
+  state.globalConfig = {
     apiKey: args.apiKey || process.env.LANGWATCH_API_KEY,
     endpoint:
       args.endpoint ||
@@ -15,17 +59,49 @@ export function initConfig(args: { apiKey?: string; endpoint?: string }): void {
   };
 }
 
+/**
+ * Returns the current config: the per-request scoped config if inside
+ * a `runWithConfig()` callback, otherwise the global config.
+ */
 export function getConfig(): McpConfig {
-  if (!config) throw new Error("Config not initialized");
-  return config;
+  const state = getGlobalState();
+  const scoped = state.configStorage.getStore();
+  if (scoped) return scoped;
+  if (!state.globalConfig) {
+    console.error(
+      "[MCP config] getConfig() failed: globalConfig is null, no scoped config active. " +
+        "Was initConfig() called? Stack:",
+      new Error().stack,
+    );
+    throw new Error("Config not initialized");
+  }
+  return state.globalConfig;
 }
 
 export function requireApiKey(): string {
-  const { apiKey } = getConfig();
-  if (!apiKey) {
+  const config = getConfig();
+  if (!config.apiKey) {
+    const state = getGlobalState();
+    const hasScoped = !!state.configStorage.getStore();
+    console.error(
+      "[MCP config] requireApiKey() failed: apiKey is undefined. " +
+        `scopedConfig=${hasScoped}, endpoint=${config.endpoint}. ` +
+        "In HTTP mode, the API key should be set per-session via runWithConfig(). Stack:",
+      new Error().stack,
+    );
     throw new Error(
       "LANGWATCH_API_KEY is required. Set it via --apiKey flag or LANGWATCH_API_KEY environment variable."
     );
   }
-  return apiKey;
+  return config.apiKey;
+}
+
+/**
+ * Runs `fn` with a per-request scoped config. All calls to `getConfig()`
+ * and `requireApiKey()` within `fn` (including async continuations) will
+ * see the provided config instead of the global one.
+ */
+export function runWithConfig<T>(config: McpConfig, fn: () => T): T {
+  const state = getGlobalState();
+  return state.configStorage.run(config, fn);
 }

package/src/create-mcp-server.d.ts

@@ -0,0 +1,6 @@
+// Minimal type declaration — avoids pulling mcp-server's full dependency tree
+// into the langwatch app's typecheck scope. The actual return type is McpServer,
+// but we only expose the connect() method that handler.ts uses.
+export declare function createMcpServer(): {
+  connect(transport: unknown): Promise<void>;
+};