langfuse-mcp-extended 0.1.0

package/build/index.js

@@ -0,0 +1,1179 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import { z } from "zod";
+var ConfigSchema = z.object({
+  langfuse: z.object({
+    publicKey: z.string().min(1, "LANGFUSE_PUBLIC_KEY is required"),
+    secretKey: z.string().min(1, "LANGFUSE_SECRET_KEY is required"),
+    baseUrl: z.string().url().default("https://cloud.langfuse.com")
+  }),
+  server: z.object({
+    enablePrompts: z.boolean().default(false),
+    logLevel: z.enum(["debug", "info", "warn", "error"]).default("info")
+  })
+});
+function loadConfig() {
+  const result = ConfigSchema.safeParse({
+    langfuse: {
+      publicKey: process.env.LANGFUSE_PUBLIC_KEY,
+      secretKey: process.env.LANGFUSE_SECRET_KEY,
+      baseUrl: process.env.LANGFUSE_BASE_URL || "https://cloud.langfuse.com"
+    },
+    server: {
+      enablePrompts: process.env.MCP_ENABLE_PROMPTS === "true",
+      logLevel: process.env.LOG_LEVEL || "info"
+    }
+  });
+  if (!result.success) {
+    const errors = result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`);
+    throw new Error(`Configuration error:
+${errors.join("\n")}`);
+  }
+  return result.data;
+}
+function createLogger(config) {
+  const levels = { debug: 0, info: 1, warn: 2, error: 3 };
+  const currentLevel = levels[config.server.logLevel];
+  return {
+    debug: (msg, ...args) => {
+      if (currentLevel <= 0) console.error(`[DEBUG] ${msg}`, ...args);
+    },
+    info: (msg, ...args) => {
+      if (currentLevel <= 1) console.error(`[INFO] ${msg}`, ...args);
+    },
+    warn: (msg, ...args) => {
+      if (currentLevel <= 2) console.error(`[WARN] ${msg}`, ...args);
+    },
+    error: (msg, ...args) => {
+      if (currentLevel <= 3) console.error(`[ERROR] ${msg}`, ...args);
+    }
+  };
+}
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/client.ts
+import Langfuse from "langfuse";
+var LangfuseClient = class {
+  langfuse;
+  logger;
+  baseUrl;
+  authHeader;
+  constructor(config, logger) {
+    this.logger = logger;
+    this.baseUrl = config.langfuse.baseUrl;
+    const credentials = `${config.langfuse.publicKey}:${config.langfuse.secretKey}`;
+    this.authHeader = `Basic ${Buffer.from(credentials).toString("base64")}`;
+    this.langfuse = new Langfuse({
+      publicKey: config.langfuse.publicKey,
+      secretKey: config.langfuse.secretKey,
+      baseUrl: config.langfuse.baseUrl
+    });
+    this.logger.debug(`LangfuseClient initialized with baseUrl: ${this.baseUrl}`);
+  }
+  /**
+   * Access the Langfuse SDK instance
+   */
+  get sdk() {
+    return this.langfuse;
+  }
+  /**
+   * Make a direct API request to Langfuse
+   */
+  async apiRequest(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    this.logger.debug(`API Request: ${method} ${path}`);
+    const response = await fetch(url, {
+      method,
+      headers: {
+        Authorization: this.authHeader,
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      this.logger.error(`API Error: ${response.status} - ${errorText}`);
+      throw new LangfuseApiError(response.status, errorText, path);
+    }
+    const text = await response.text();
+    if (!text) {
+      return {};
+    }
+    return JSON.parse(text);
+  }
+  /**
+   * Shutdown the client and flush any pending data
+   */
+  async shutdown() {
+    await this.langfuse.shutdownAsync();
+    this.logger.debug("LangfuseClient shutdown complete");
+  }
+};
+var LangfuseApiError = class extends Error {
+  constructor(statusCode, body, path) {
+    super(`Langfuse API Error (${statusCode}) at ${path}: ${body}`);
+    this.statusCode = statusCode;
+    this.body = body;
+    this.path = path;
+    this.name = "LangfuseApiError";
+  }
+  get isNotFound() {
+    return this.statusCode === 404;
+  }
+  get isUnauthorized() {
+    return this.statusCode === 401;
+  }
+  get isRateLimited() {
+    return this.statusCode === 429;
+  }
+};
+
+// src/tools/traces/listTraces.ts
+import { z as z2 } from "zod";
+
+// src/utils/errors.ts
+function formatSuccess(data, summary) {
+  const content = [];
+  if (summary) {
+    content.push({ type: "text", text: summary });
+  }
+  content.push({
+    type: "text",
+    text: JSON.stringify(data, null, 2)
+  });
+  return { content };
+}
+function formatError(message) {
+  return {
+    content: [{ type: "text", text: `Error: ${message}` }],
+    isError: true
+  };
+}
+function handleToolError(error) {
+  if (error instanceof LangfuseApiError) {
+    if (error.isNotFound) {
+      return formatError(`Resource not found: ${error.path}`);
+    }
+    if (error.isUnauthorized) {
+      return formatError("Authentication failed. Check your API keys.");
+    }
+    if (error.isRateLimited) {
+      return formatError("Rate limited. Please try again later.");
+    }
+    return formatError(`API Error (${error.statusCode}): ${error.body}`);
+  }
+  if (error instanceof Error && error.name === "ZodError") {
+    return formatError(`Validation error: ${error.message}`);
+  }
+  if (error instanceof Error) {
+    return formatError(error.message);
+  }
+  console.error("Unexpected error:", error);
+  return formatError("An unexpected error occurred");
+}
+
+// src/tools/registry.ts
+function defineTool(definition) {
+  return definition;
+}
+var ToolRegistry = class {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  tools = /* @__PURE__ */ new Map();
+  client;
+  config;
+  logger;
+  constructor(client, config, logger) {
+    this.client = client;
+    this.config = config;
+    this.logger = logger;
+  }
+  /**
+   * Register a tool in the registry
+   */
+  register(tool) {
+    if (tool.enabled && !tool.enabled(this.config)) {
+      this.logger.debug(`Tool ${tool.name} is disabled by configuration`);
+      return;
+    }
+    this.tools.set(tool.name, tool);
+    this.logger.debug(`Registered tool: ${tool.name}`);
+  }
+  /**
+   * Register multiple tools
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  registerAll(tools) {
+    for (const tool of tools) {
+      this.register(tool);
+    }
+  }
+  /**
+   * Get all registered tools in MCP format
+   */
+  getTools() {
+    return Array.from(this.tools.values()).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: this.zodToJsonSchema(tool.inputSchema)
+    }));
+  }
+  /**
+   * Execute a tool by name
+   */
+  async execute(name, args) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return {
+        content: [{ type: "text", text: `Unknown tool: ${name}` }],
+        isError: true
+      };
+    }
+    try {
+      const parseResult = tool.inputSchema.safeParse(args);
+      if (!parseResult.success) {
+        const errors = parseResult.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+        return {
+          content: [{ type: "text", text: `Invalid input: ${errors}` }],
+          isError: true
+        };
+      }
+      this.logger.debug(`Executing tool: ${name}`);
+      return await tool.handler(parseResult.data, this.client, this.logger);
+    } catch (error) {
+      this.logger.error(`Error executing tool ${name}:`, error);
+      return handleToolError(error);
+    }
+  }
+  /**
+   * Convert Zod schema to JSON Schema for MCP
+   */
+  zodToJsonSchema(schema) {
+    const jsonSchema = {
+      type: "object",
+      properties: {},
+      required: []
+    };
+    if ("shape" in schema && typeof schema.shape === "object") {
+      const shape = schema.shape;
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = this.zodTypeToJsonSchema(value);
+        if (!value.isOptional()) {
+          required.push(key);
+        }
+      }
+      jsonSchema.properties = properties;
+      if (required.length > 0) {
+        jsonSchema.required = required;
+      }
+    }
+    return jsonSchema;
+  }
+  /**
+   * Convert individual Zod type to JSON Schema
+   */
+  zodTypeToJsonSchema(zodType) {
+    const schema = {};
+    if (zodType.description) {
+      schema.description = zodType.description;
+    }
+    let innerType = zodType;
+    if ("unwrap" in zodType && typeof zodType.unwrap === "function") {
+      innerType = zodType.unwrap();
+    }
+    const typeName = innerType._def?.typeName;
+    switch (typeName) {
+      case "ZodString":
+        schema.type = "string";
+        break;
+      case "ZodNumber":
+        schema.type = "number";
+        break;
+      case "ZodBoolean":
+        schema.type = "boolean";
+        break;
+      case "ZodArray":
+        schema.type = "array";
+        if (innerType._def?.type) {
+          schema.items = this.zodTypeToJsonSchema(innerType._def.type);
+        }
+        break;
+      case "ZodObject":
+        schema.type = "object";
+        break;
+      case "ZodEnum":
+        schema.type = "string";
+        if (innerType._def?.values) {
+          schema.enum = innerType._def.values;
+        }
+        break;
+      default:
+        schema.type = "string";
+    }
+    return schema;
+  }
+};
+
+// src/utils/pagination.ts
+function buildQueryString(params) {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        query.append(key, item);
+      }
+    } else if (typeof value === "boolean") {
+      query.set(key, value ? "true" : "false");
+    } else {
+      query.set(key, String(value));
+    }
+  }
+  const queryString = query.toString();
+  return queryString ? `?${queryString}` : "";
+}
+function formatPaginationSummary(count, total, page, hasMore) {
+  const parts = [];
+  if (total !== void 0) {
+    parts.push(`Showing ${count} of ${total} items`);
+  } else {
+    parts.push(`Found ${count} items`);
+  }
+  if (page !== void 0) {
+    parts.push(`(page ${page})`);
+  }
+  if (hasMore) {
+    parts.push("- more available");
+  }
+  return parts.join(" ");
+}
+
+// src/tools/traces/listTraces.ts
+var inputSchema = z2.object({
+  page: z2.number().int().min(1).optional().describe("Page number (1-indexed)"),
+  limit: z2.number().int().min(1).max(100).optional().default(50).describe("Items per page"),
+  name: z2.string().optional().describe("Filter by trace name"),
+  userId: z2.string().optional().describe("Filter by user ID"),
+  sessionId: z2.string().optional().describe("Filter by session ID"),
+  tags: z2.array(z2.string()).optional().describe("Filter by tags (AND logic)"),
+  fromTimestamp: z2.string().optional().describe("Start of time range (ISO 8601)"),
+  toTimestamp: z2.string().optional().describe("End of time range (ISO 8601)"),
+  environment: z2.string().optional().describe("Filter by environment"),
+  orderBy: z2.enum(["timestamp", "latency", "totalCost"]).optional().describe("Sort field")
+});
+var listTraces = defineTool({
+  name: "listTraces",
+  description: "List traces with filtering and pagination. Returns trace metadata including latency, cost, and observation/score counts.",
+  inputSchema,
+  handler: async (input, client, logger) => {
+    logger.debug("listTraces called with:", input);
+    const queryParams = {
+      page: input.page,
+      limit: input.limit,
+      name: input.name,
+      userId: input.userId,
+      sessionId: input.sessionId,
+      tags: input.tags,
+      fromTimestamp: input.fromTimestamp,
+      toTimestamp: input.toTimestamp,
+      environment: input.environment,
+      orderBy: input.orderBy
+    };
+    const query = buildQueryString(queryParams);
+    const response = await client.apiRequest("GET", `/api/public/traces${query}`);
+    const summary = formatPaginationSummary(
+      response.data.length,
+      response.meta.totalItems,
+      response.meta.page,
+      response.meta.page < response.meta.totalPages
+    );
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/traces/getTrace.ts
+import { z as z3 } from "zod";
+var inputSchema2 = z3.object({
+  traceId: z3.string().min(1).describe("The unique trace identifier")
+});
+var getTrace = defineTool({
+  name: "getTrace",
+  description: "Get a specific trace with full details including all observations and scores.",
+  inputSchema: inputSchema2,
+  handler: async (input, client, logger) => {
+    logger.debug("getTrace called with:", input);
+    const response = await client.apiRequest(
+      "GET",
+      `/api/public/traces/${encodeURIComponent(input.traceId)}`
+    );
+    const observationCount = response.observations?.length ?? 0;
+    const scoreCount = response.scores?.length ?? 0;
+    const summary = `Trace "${response.name || response.id}" with ${observationCount} observations and ${scoreCount} scores`;
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/traces/deleteTrace.ts
+import { z as z4 } from "zod";
+var inputSchema3 = z4.object({
+  traceId: z4.string().min(1).describe("The unique trace identifier to delete")
+});
+var deleteTrace = defineTool({
+  name: "deleteTrace",
+  description: "Delete a specific trace. This action is irreversible.",
+  inputSchema: inputSchema3,
+  handler: async (input, client, logger) => {
+    logger.debug("deleteTrace called with:", input);
+    await client.apiRequest("DELETE", `/api/public/traces/${encodeURIComponent(input.traceId)}`);
+    return formatSuccess(
+      { deleted: true, traceId: input.traceId },
+      `Successfully deleted trace: ${input.traceId}`
+    );
+  }
+});
+
+// src/tools/observations/listObservations.ts
+import { z as z5 } from "zod";
+var inputSchema4 = z5.object({
+  cursor: z5.string().optional().describe("Pagination cursor from previous response"),
+  limit: z5.number().int().min(1).max(100).optional().default(50).describe("Items per page"),
+  traceId: z5.string().optional().describe("Filter by trace ID"),
+  name: z5.string().optional().describe("Filter by observation name"),
+  type: z5.enum(["GENERATION", "SPAN", "EVENT"]).optional().describe("Filter by observation type"),
+  parentObservationId: z5.string().optional().describe("Filter by parent observation"),
+  fromStartTime: z5.string().optional().describe("Start of time range (ISO 8601)"),
+  toStartTime: z5.string().optional().describe("End of time range (ISO 8601)"),
+  userId: z5.string().optional().describe("Filter by user ID"),
+  version: z5.string().optional().describe("Filter by version")
+});
+var listObservations = defineTool({
+  name: "listObservations",
+  description: "List observations (generations, spans, events) with cursor-based pagination. Includes usage metrics, costs, and latency.",
+  inputSchema: inputSchema4,
+  handler: async (input, client, logger) => {
+    logger.debug("listObservations called with:", input);
+    const queryParams = {
+      page: input.cursor ? parseInt(input.cursor, 10) : 1,
+      limit: input.limit,
+      traceId: input.traceId,
+      name: input.name,
+      type: input.type,
+      parentObservationId: input.parentObservationId,
+      fromStartTime: input.fromStartTime,
+      toStartTime: input.toStartTime,
+      userId: input.userId,
+      version: input.version
+    };
+    const query = buildQueryString(queryParams);
+    const response = await client.apiRequest(
+      "GET",
+      `/api/public/observations${query}`
+    );
+    const summary = formatPaginationSummary(
+      response.data.length,
+      response.meta.totalItems,
+      response.meta.page,
+      response.meta.page < response.meta.totalPages
+    );
+    const result = {
+      ...response,
+      nextCursor: response.meta.page < response.meta.totalPages ? String(response.meta.page + 1) : void 0
+    };
+    return formatSuccess(result, summary);
+  }
+});
+
+// src/tools/observations/getObservation.ts
+import { z as z6 } from "zod";
+var inputSchema5 = z6.object({
+  observationId: z6.string().min(1).describe("The unique observation identifier")
+});
+var getObservation = defineTool({
+  name: "getObservation",
+  description: "Get a specific observation with all details including input/output, usage, costs, and timing.",
+  inputSchema: inputSchema5,
+  handler: async (input, client, logger) => {
+    logger.debug("getObservation called with:", input);
+    const response = await client.apiRequest(
+      "GET",
+      `/api/public/observations/${encodeURIComponent(input.observationId)}`
+    );
+    const typeLabel = response.type.toLowerCase();
+    const modelInfo = response.model ? ` using ${response.model}` : "";
+    const summary = `${typeLabel} "${response.name || response.id}"${modelInfo}`;
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/scores/createScore.ts
+import { z as z7 } from "zod";
+var inputSchema6 = z7.object({
+  traceId: z7.string().min(1).describe("ID of the trace to score"),
+  observationId: z7.string().optional().describe("Optional: ID of specific observation to score"),
+  name: z7.string().min(1).describe("Name of the score (e.g., 'accuracy', 'relevance')"),
+  value: z7.union([z7.number(), z7.string()]).describe("Score value - numeric for NUMERIC type, string for CATEGORICAL/BOOLEAN"),
+  dataType: z7.enum(["NUMERIC", "CATEGORICAL", "BOOLEAN"]).optional().describe("Type of score value"),
+  comment: z7.string().optional().describe("Optional comment explaining the score"),
+  configId: z7.string().optional().describe("Optional score config ID for validation"),
+  id: z7.string().optional().describe("Optional custom ID for idempotency")
+});
+var createScore = defineTool({
+  name: "createScore",
+  description: "Create a score for a trace or observation. Supports numeric, boolean, and categorical score types.",
+  inputSchema: inputSchema6,
+  handler: async (input, client, logger) => {
+    logger.debug("createScore called with:", input);
+    const response = await client.apiRequest("POST", "/api/public/scores", {
+      traceId: input.traceId,
+      observationId: input.observationId,
+      name: input.name,
+      value: input.value,
+      dataType: input.dataType,
+      comment: input.comment,
+      configId: input.configId,
+      id: input.id
+    });
+    const targetDesc = input.observationId ? `observation ${input.observationId}` : `trace ${input.traceId}`;
+    const summary = `Created score "${input.name}" = ${input.value} for ${targetDesc}`;
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/scores/listScores.ts
+import { z as z8 } from "zod";
+var inputSchema7 = z8.object({
+  page: z8.number().int().min(1).optional().describe("Page number (1-indexed)"),
+  limit: z8.number().int().min(1).max(100).optional().default(50).describe("Items per page"),
+  traceId: z8.string().optional().describe("Filter by trace ID"),
+  observationId: z8.string().optional().describe("Filter by observation ID"),
+  name: z8.string().optional().describe("Filter by score name"),
+  source: z8.enum(["API", "ANNOTATION", "EVAL"]).optional().describe("Filter by score source"),
+  dataType: z8.enum(["NUMERIC", "CATEGORICAL", "BOOLEAN"]).optional().describe("Filter by data type"),
+  configId: z8.string().optional().describe("Filter by score config ID"),
+  fromTimestamp: z8.string().optional().describe("Start of time range (ISO 8601)"),
+  toTimestamp: z8.string().optional().describe("End of time range (ISO 8601)"),
+  userId: z8.string().optional().describe("Filter by user ID who created the trace"),
+  operator: z8.enum(["<", ">", "<=", ">=", "!=", "="]).optional().describe("Comparison operator for value filter"),
+  value: z8.number().optional().describe("Value to compare against (requires operator)")
+});
+var listScores = defineTool({
+  name: "listScores",
+  description: "List scores with filtering. Supports both trace and observation scores.",
+  inputSchema: inputSchema7,
+  handler: async (input, client, logger) => {
+    logger.debug("listScores called with:", input);
+    const queryParams = {
+      page: input.page,
+      limit: input.limit,
+      traceId: input.traceId,
+      observationId: input.observationId,
+      name: input.name,
+      source: input.source,
+      dataType: input.dataType,
+      configId: input.configId,
+      fromTimestamp: input.fromTimestamp,
+      toTimestamp: input.toTimestamp,
+      userId: input.userId,
+      operator: input.operator,
+      value: input.value
+    };
+    const query = buildQueryString(queryParams);
+    const response = await client.apiRequest(
+      "GET",
+      `/api/public/v2/scores${query}`
+    );
+    const summary = formatPaginationSummary(
+      response.data.length,
+      response.meta.totalItems,
+      response.meta.page,
+      response.meta.page < response.meta.totalPages
+    );
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/scores/getScore.ts
+import { z as z9 } from "zod";
+var inputSchema8 = z9.object({
+  scoreId: z9.string().min(1).describe("The unique score identifier")
+});
+var getScore = defineTool({
+  name: "getScore",
+  description: "Get a specific score by ID.",
+  inputSchema: inputSchema8,
+  handler: async (input, client, logger) => {
+    logger.debug("getScore called with:", input);
+    const response = await client.apiRequest(
+      "GET",
+      `/api/public/v2/scores/${encodeURIComponent(input.scoreId)}`
+    );
+    const summary = `Score "${response.name}" = ${response.value} (${response.dataType})`;
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/scores/deleteScore.ts
+import { z as z10 } from "zod";
+var inputSchema9 = z10.object({
+  scoreId: z10.string().min(1).describe("The unique score identifier to delete")
+});
+var deleteScore = defineTool({
+  name: "deleteScore",
+  description: "Delete a specific score. This action is irreversible.",
+  inputSchema: inputSchema9,
+  handler: async (input, client, logger) => {
+    logger.debug("deleteScore called with:", input);
+    await client.apiRequest("DELETE", `/api/public/scores/${encodeURIComponent(input.scoreId)}`);
+    return formatSuccess(
+      { deleted: true, scoreId: input.scoreId },
+      `Successfully deleted score: ${input.scoreId}`
+    );
+  }
+});
+
+// src/tools/score-configs/createScoreConfig.ts
+import { z as z11 } from "zod";
+var categorySchema = z11.object({
+  value: z11.number().describe("Numeric value for this category"),
+  label: z11.string().describe("Display label for this category")
+});
+var inputSchema10 = z11.object({
+  name: z11.string().min(1).describe("Unique name for the score configuration"),
+  dataType: z11.enum(["NUMERIC", "CATEGORICAL", "BOOLEAN"]).describe("Type of score values this config accepts"),
+  minValue: z11.number().optional().describe("Minimum allowed value (NUMERIC only)"),
+  maxValue: z11.number().optional().describe("Maximum allowed value (NUMERIC only)"),
+  categories: z11.array(categorySchema).optional().describe("Category definitions (CATEGORICAL only)"),
+  description: z11.string().optional().describe("Description of what this score measures")
+});
+var createScoreConfig = defineTool({
+  name: "createScoreConfig",
+  description: "Create a score configuration that defines validation rules for scores. Supports numeric ranges, categorical values, and boolean types.",
+  inputSchema: inputSchema10,
+  handler: async (input, client, logger) => {
+    logger.debug("createScoreConfig called with:", input);
+    const response = await client.apiRequest(
+      "POST",
+      "/api/public/score-configs",
+      {
+        name: input.name,
+        dataType: input.dataType,
+        minValue: input.minValue,
+        maxValue: input.maxValue,
+        categories: input.categories,
+        description: input.description
+      }
+    );
+    let summary = `Created score config "${input.name}" (${input.dataType})`;
+    if (input.dataType === "NUMERIC" && (input.minValue !== void 0 || input.maxValue !== void 0)) {
+      summary += ` with range [${input.minValue ?? "-\u221E"}, ${input.maxValue ?? "\u221E"}]`;
+    } else if (input.dataType === "CATEGORICAL" && input.categories) {
+      summary += ` with ${input.categories.length} categories`;
+    }
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/score-configs/listScoreConfigs.ts
+import { z as z12 } from "zod";
+var inputSchema11 = z12.object({
+  page: z12.number().int().min(1).optional().describe("Page number (1-indexed)"),
+  limit: z12.number().int().min(1).max(100).optional().default(50).describe("Items per page")
+});
+var listScoreConfigs = defineTool({
+  name: "listScoreConfigs",
+  description: "List all score configurations in the project.",
+  inputSchema: inputSchema11,
+  handler: async (input, client, logger) => {
+    logger.debug("listScoreConfigs called with:", input);
+    const queryParams = {
+      page: input.page,
+      limit: input.limit
+    };
+    const query = buildQueryString(queryParams);
+    const response = await client.apiRequest(
+      "GET",
+      `/api/public/score-configs${query}`
+    );
+    const summary = formatPaginationSummary(
+      response.data.length,
+      response.meta.totalItems,
+      response.meta.page,
+      response.meta.page < response.meta.totalPages
+    );
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/score-configs/getScoreConfig.ts
+import { z as z13 } from "zod";
+var inputSchema12 = z13.object({
+  configId: z13.string().min(1).describe("The unique score config identifier")
+});
+var getScoreConfig = defineTool({
+  name: "getScoreConfig",
+  description: "Get a specific score configuration by ID.",
+  inputSchema: inputSchema12,
+  handler: async (input, client, logger) => {
+    logger.debug("getScoreConfig called with:", input);
+    const response = await client.apiRequest(
+      "GET",
+      `/api/public/score-configs/${encodeURIComponent(input.configId)}`
+    );
+    let summary = `Score config "${response.name}" (${response.dataType})`;
+    if (response.dataType === "NUMERIC") {
+      const min = response.minValue ?? "-\u221E";
+      const max = response.maxValue ?? "\u221E";
+      summary += ` [${min}, ${max}]`;
+    } else if (response.dataType === "CATEGORICAL" && response.categories) {
+      summary += ` with ${response.categories.length} categories`;
+    }
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/datasets/createDataset.ts
+import { z as z14 } from "zod";
+var inputSchema13 = z14.object({
+  name: z14.string().min(1).describe("Unique name for the dataset"),
+  description: z14.string().optional().describe("Description of the dataset"),
+  metadata: z14.record(z14.unknown()).optional().describe("Additional metadata as key-value pairs")
+});
+var createDataset = defineTool({
+  name: "createDataset",
+  description: "Create a new dataset for evaluation. Datasets contain items with expected inputs/outputs for testing LLM applications.",
+  inputSchema: inputSchema13,
+  handler: async (input, client, logger) => {
+    logger.debug("createDataset called with:", input);
+    const response = await client.apiRequest(
+      "POST",
+      "/api/public/v2/datasets",
+      {
+        name: input.name,
+        description: input.description,
+        metadata: input.metadata
+      }
+    );
+    const summary = `Created dataset "${input.name}"${input.description ? `: ${input.description}` : ""}`;
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/datasets/listDatasets.ts
+import { z as z15 } from "zod";
+var inputSchema14 = z15.object({
+  page: z15.number().int().min(1).optional().describe("Page number (1-indexed)"),
+  limit: z15.number().int().min(1).max(100).optional().default(50).describe("Items per page")
+});
+var listDatasets = defineTool({
+  name: "listDatasets",
+  description: "List all datasets in the project.",
+  inputSchema: inputSchema14,
+  handler: async (input, client, logger) => {
+    logger.debug("listDatasets called with:", input);
+    const queryParams = {
+      page: input.page,
+      limit: input.limit
+    };
+    const query = buildQueryString(queryParams);
+    const response = await client.apiRequest(
+      "GET",
+      `/api/public/v2/datasets${query}`
+    );
+    const summary = formatPaginationSummary(
+      response.data.length,
+      response.meta.totalItems,
+      response.meta.page,
+      response.meta.page < response.meta.totalPages
+    );
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/datasets/getDataset.ts
+import { z as z16 } from "zod";
+var inputSchema15 = z16.object({
+  datasetName: z16.string().min(1).describe("The name of the dataset to retrieve")
+});
+var getDataset = defineTool({
+  name: "getDataset",
+  description: "Get a dataset by name including its items and run names.",
+  inputSchema: inputSchema15,
+  handler: async (input, client, logger) => {
+    logger.debug("getDataset called with:", input);
+    const response = await client.apiRequest(
+      "GET",
+      `/api/public/v2/datasets/${encodeURIComponent(input.datasetName)}`
+    );
+    const itemCount = response.items?.length ?? 0;
+    const runCount = response.runs?.length ?? 0;
+    const summary = `Dataset "${response.name}" with ${itemCount} items and ${runCount} runs`;
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/datasets/createDatasetItem.ts
+import { z as z17 } from "zod";
+var inputSchema16 = z17.object({
+  datasetName: z17.string().min(1).describe("Name of the dataset to add the item to"),
+  input: z17.unknown().describe("The input for this dataset item (any JSON value)"),
+  expectedOutput: z17.unknown().optional().describe("The expected output for evaluation"),
+  metadata: z17.record(z17.unknown()).optional().describe("Additional metadata"),
+  sourceTraceId: z17.string().optional().describe("Link to source trace that generated this item"),
+  sourceObservationId: z17.string().optional().describe("Link to source observation (requires sourceTraceId)"),
+  id: z17.string().optional().describe("Custom ID for idempotent upsert"),
+  status: z17.enum(["ACTIVE", "ARCHIVED"]).optional().describe("Item status (defaults to ACTIVE)")
+});
+var createDatasetItem = defineTool({
+  name: "createDatasetItem",
+  description: "Create or upsert a dataset item. Use id parameter for idempotent updates.",
+  inputSchema: inputSchema16,
+  handler: async (input, client, logger) => {
+    logger.debug("createDatasetItem called with:", input);
+    const response = await client.apiRequest(
+      "POST",
+      "/api/public/dataset-items",
+      {
+        datasetName: input.datasetName,
+        input: input.input,
+        expectedOutput: input.expectedOutput,
+        metadata: input.metadata,
+        sourceTraceId: input.sourceTraceId,
+        sourceObservationId: input.sourceObservationId,
+        id: input.id,
+        status: input.status
+      }
+    );
+    const summary = `Created dataset item ${response.id} in "${input.datasetName}"`;
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/datasets/listDatasetItems.ts
+import { z as z18 } from "zod";
+var inputSchema17 = z18.object({
+  datasetName: z18.string().min(1).describe("Name of the dataset to list items from"),
+  page: z18.number().int().min(1).optional().describe("Page number (1-indexed)"),
+  limit: z18.number().int().min(1).max(100).optional().default(50).describe("Items per page"),
+  sourceTraceId: z18.string().optional().describe("Filter by source trace ID"),
+  sourceObservationId: z18.string().optional().describe("Filter by source observation ID")
+});
+var listDatasetItems = defineTool({
+  name: "listDatasetItems",
+  description: "List items in a dataset with optional filtering.",
+  inputSchema: inputSchema17,
+  handler: async (input, client, logger) => {
+    logger.debug("listDatasetItems called with:", input);
+    const queryParams = {
+      datasetName: input.datasetName,
+      page: input.page,
+      limit: input.limit,
+      sourceTraceId: input.sourceTraceId,
+      sourceObservationId: input.sourceObservationId
+    };
+    const query = buildQueryString(queryParams);
+    const response = await client.apiRequest(
+      "GET",
+      `/api/public/dataset-items${query}`
+    );
+    const summary = formatPaginationSummary(
+      response.data.length,
+      response.meta.totalItems,
+      response.meta.page,
+      response.meta.page < response.meta.totalPages
+    );
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/datasets/getDatasetItem.ts
+import { z as z19 } from "zod";
+var inputSchema18 = z19.object({
+  datasetItemId: z19.string().min(1).describe("The unique dataset item identifier")
+});
+var getDatasetItem = defineTool({
+  name: "getDatasetItem",
+  description: "Get a specific dataset item by ID.",
+  inputSchema: inputSchema18,
+  handler: async (input, client, logger) => {
+    logger.debug("getDatasetItem called with:", input);
+    const response = await client.apiRequest(
+      "GET",
+      `/api/public/dataset-items/${encodeURIComponent(input.datasetItemId)}`
+    );
+    const summary = `Dataset item ${response.id} from "${response.datasetName}" (${response.status})`;
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/datasets/deleteDatasetItem.ts
+import { z as z20 } from "zod";
+var inputSchema19 = z20.object({
+  datasetItemId: z20.string().min(1).describe("The unique dataset item identifier to delete")
+});
+var deleteDatasetItem = defineTool({
+  name: "deleteDatasetItem",
+  description: "Delete a specific dataset item. This action is irreversible.",
+  inputSchema: inputSchema19,
+  handler: async (input, client, logger) => {
+    logger.debug("deleteDatasetItem called with:", input);
+    await client.apiRequest(
+      "DELETE",
+      `/api/public/dataset-items/${encodeURIComponent(input.datasetItemId)}`
+    );
+    return formatSuccess(
+      { deleted: true, datasetItemId: input.datasetItemId },
+      `Successfully deleted dataset item: ${input.datasetItemId}`
+    );
+  }
+});
+
+// src/tools/datasets/createDatasetRunItem.ts
+import { z as z21 } from "zod";
+var inputSchema20 = z21.object({
+  runName: z21.string().min(1).describe("Name of the dataset run"),
+  runDescription: z21.string().optional().describe("Description of the run"),
+  datasetItemId: z21.string().min(1).describe("ID of the dataset item being evaluated"),
+  traceId: z21.string().min(1).describe("ID of the trace that processed this item"),
+  observationId: z21.string().optional().describe("ID of specific observation (if applicable)"),
+  metadata: z21.record(z21.unknown()).optional().describe("Additional run item metadata")
+});
+var createDatasetRunItem = defineTool({
+  name: "createDatasetRunItem",
+  description: "Create a dataset run item linking a trace/observation to a dataset item for evaluation.",
+  inputSchema: inputSchema20,
+  handler: async (input, client, logger) => {
+    logger.debug("createDatasetRunItem called with:", input);
+    const response = await client.apiRequest(
+      "POST",
+      "/api/public/dataset-run-items",
+      {
+        runName: input.runName,
+        runDescription: input.runDescription,
+        datasetItemId: input.datasetItemId,
+        traceId: input.traceId,
+        observationId: input.observationId,
+        metadata: input.metadata
+      }
+    );
+    const summary = `Created run item in "${input.runName}" linking trace ${input.traceId} to item ${input.datasetItemId}`;
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/datasets/listDatasetRuns.ts
+import { z as z22 } from "zod";
+var inputSchema21 = z22.object({
+  datasetName: z22.string().min(1).describe("Name of the dataset to list runs from"),
+  page: z22.number().int().min(1).optional().describe("Page number (1-indexed)"),
+  limit: z22.number().int().min(1).max(100).optional().default(50).describe("Items per page")
+});
+var listDatasetRuns = defineTool({
+  name: "listDatasetRuns",
+  description: "List all runs for a specific dataset.",
+  inputSchema: inputSchema21,
+  handler: async (input, client, logger) => {
+    logger.debug("listDatasetRuns called with:", input);
+    const queryParams = {
+      page: input.page,
+      limit: input.limit
+    };
+    const query = buildQueryString(queryParams);
+    const response = await client.apiRequest(
+      "GET",
+      `/api/public/datasets/${encodeURIComponent(input.datasetName)}/runs${query}`
+    );
+    const summary = formatPaginationSummary(
+      response.data.length,
+      response.meta.totalItems,
+      response.meta.page,
+      response.meta.page < response.meta.totalPages
+    );
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/datasets/getDatasetRun.ts
+import { z as z23 } from "zod";
+var inputSchema22 = z23.object({
+  datasetName: z23.string().min(1).describe("Name of the dataset"),
+  runName: z23.string().min(1).describe("Name of the run to retrieve")
+});
+var getDatasetRun = defineTool({
+  name: "getDatasetRun",
+  description: "Get a specific dataset run by name including its run items.",
+  inputSchema: inputSchema22,
+  handler: async (input, client, logger) => {
+    logger.debug("getDatasetRun called with:", input);
+    const response = await client.apiRequest(
+      "GET",
+      `/api/public/datasets/${encodeURIComponent(input.datasetName)}/runs/${encodeURIComponent(input.runName)}`
+    );
+    const itemCount = response.datasetRunItems?.length ?? 0;
+    const summary = `Run "${response.name}" with ${itemCount} items`;
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/sessions/listSessions.ts
+import { z as z24 } from "zod";
+var inputSchema23 = z24.object({
+  page: z24.number().int().min(1).optional().describe("Page number (1-indexed)"),
+  limit: z24.number().int().min(1).max(100).optional().default(50).describe("Items per page"),
+  fromTimestamp: z24.string().optional().describe("Start of time range (ISO 8601)"),
+  toTimestamp: z24.string().optional().describe("End of time range (ISO 8601)")
+});
+var listSessions = defineTool({
+  name: "listSessions",
+  description: "List all sessions. Sessions group multiple traces from the same user interaction.",
+  inputSchema: inputSchema23,
+  handler: async (input, client, logger) => {
+    logger.debug("listSessions called with:", input);
+    const queryParams = {
+      page: input.page,
+      limit: input.limit,
+      fromTimestamp: input.fromTimestamp,
+      toTimestamp: input.toTimestamp
+    };
+    const query = buildQueryString(queryParams);
+    const response = await client.apiRequest(
+      "GET",
+      `/api/public/sessions${query}`
+    );
+    const summary = formatPaginationSummary(
+      response.data.length,
+      response.meta.totalItems,
+      response.meta.page,
+      response.meta.page < response.meta.totalPages
+    );
+    const result = {
+      ...response,
+      nextCursor: response.meta.page < response.meta.totalPages ? String(response.meta.page + 1) : void 0
+    };
+    return formatSuccess(result, summary);
+  }
+});
+
+// src/tools/sessions/getSession.ts
+import { z as z25 } from "zod";
+var inputSchema24 = z25.object({
+  sessionId: z25.string().min(1).describe("The unique session identifier")
+});
+var getSession = defineTool({
+  name: "getSession",
+  description: "Get a specific session by ID including its traces.",
+  inputSchema: inputSchema24,
+  handler: async (input, client, logger) => {
+    logger.debug("getSession called with:", input);
+    const response = await client.apiRequest(
+      "GET",
+      `/api/public/sessions/${encodeURIComponent(input.sessionId)}`
+    );
+    const traceCount = response.traces?.length ?? 0;
+    const summary = `Session ${response.id} with ${traceCount} traces`;
+    return formatSuccess(response, summary);
+  }
+});
+
+// src/tools/index.ts
+var allTools = {
+  traces: [listTraces, getTrace, deleteTrace],
+  observations: [listObservations, getObservation],
+  scores: [createScore, listScores, getScore, deleteScore],
+  scoreConfigs: [createScoreConfig, listScoreConfigs, getScoreConfig],
+  datasets: [
+    createDataset,
+    listDatasets,
+    getDataset,
+    createDatasetItem,
+    listDatasetItems,
+    getDatasetItem,
+    deleteDatasetItem,
+    createDatasetRunItem,
+    listDatasetRuns,
+    getDatasetRun
+  ],
+  sessions: [listSessions, getSession]
+  // prompts: [],       // TODO: Phase 5 (optional)
+};
+function getAllTools() {
+  return Object.values(allTools).flat();
+}
+
+// src/server.ts
+var SERVER_NAME = "langfuse-mcp-server";
+var SERVER_VERSION = "0.1.0";
+function createServer(config, logger) {
+  const langfuseClient = new LangfuseClient(config, logger);
+  const toolRegistry = new ToolRegistry(langfuseClient, config, logger);
+  toolRegistry.registerAll(getAllTools());
+  const server = new Server(
+    {
+      name: SERVER_NAME,
+      version: SERVER_VERSION
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    logger.debug("Received list tools request");
+    return {
+      tools: toolRegistry.getTools()
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    logger.info(`Tool called: ${name}`);
+    const result = await toolRegistry.execute(name, args ?? {});
+    return result;
+  });
+  server.onerror = (error) => {
+    logger.error("Server error:", error);
+  };
+  return {
+    server,
+    langfuseClient,
+    toolRegistry
+  };
+}
+async function runServer(config, logger) {
+  logger.info(`Starting ${SERVER_NAME} v${SERVER_VERSION}`);
+  logger.info(`Langfuse URL: ${config.langfuse.baseUrl}`);
+  const { server, langfuseClient } = createServer(config, logger);
+  const transport = new StdioServerTransport();
+  const shutdown = async () => {
+    logger.info("Shutting down server...");
+    await langfuseClient.shutdown();
+    await server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await server.connect(transport);
+  logger.info("Server connected and ready");
+}
+
+// src/index.ts
+async function main() {
+  try {
+    const config = loadConfig();
+    const logger = createLogger(config);
+    await runServer(config, logger);
+  } catch (error) {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+  }
+}
+main().catch(console.error);
+//# sourceMappingURL=index.js.map