@langwatch/mcp-server 0.6.1 → 0.7.0

package/src/langwatch-api-agents.ts

@@ -0,0 +1,108 @@
+import { makeRequest } from "./langwatch-api.js";
+
+export interface AgentSummary {
+  id: string;
+  name: string;
+  type: string;
+  config: Record<string, unknown> | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface AgentListResponse {
+  data: AgentSummary[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+  };
+}
+
+export async function listAgents(params?: {
+  page?: number;
+  limit?: number;
+}): Promise<AgentListResponse> {
+  const query = new URLSearchParams();
+  if (params?.page) query.set("page", String(params.page));
+  if (params?.limit) query.set("limit", String(params.limit));
+  const qs = query.toString() ? `?${query}` : "";
+  return makeRequest("GET", `/api/agents${qs}`) as Promise<AgentListResponse>;
+}
+
+export async function getAgent(id: string): Promise<AgentSummary> {
+  return makeRequest(
+    "GET",
+    `/api/agents/${encodeURIComponent(id)}`,
+  ) as Promise<AgentSummary>;
+}
+
+export async function createAgent(data: {
+  name: string;
+  type: string;
+  config: Record<string, unknown>;
+}): Promise<AgentSummary> {
+  return makeRequest("POST", "/api/agents", data) as Promise<AgentSummary>;
+}
+
+export async function updateAgent(params: {
+  id: string;
+  name?: string;
+  type?: string;
+  config?: Record<string, unknown>;
+}): Promise<AgentSummary> {
+  const { id, ...data } = params;
+  return makeRequest(
+    "PATCH",
+    `/api/agents/${encodeURIComponent(id)}`,
+    data,
+  ) as Promise<AgentSummary>;
+}
+
+/**
+ * Run an agent. For HTTP agents, calls the configured URL directly.
+ * For workflow-linked agents, calls the workflow run endpoint.
+ */
+export async function runAgent(
+  id: string,
+  input?: Record<string, unknown>,
+): Promise<{ agentType: string; result: Record<string, unknown> }> {
+  const agent = await getAgent(id);
+  const config = agent.config ?? {};
+
+  if (agent.type === "http") {
+    const url = (config as Record<string, unknown>).url as string | undefined;
+    if (!url) {
+      throw new Error("HTTP agent has no URL configured");
+    }
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input ?? {}),
+    });
+
+    const result = (await response.json()) as Record<string, unknown>;
+    return { agentType: "http", result };
+  }
+
+  // For workflow-linked agents, use the workflow run endpoint
+  const workflowId = (config as Record<string, unknown>).workflowId as string | undefined;
+  if (!workflowId) {
+    throw new Error(
+      `Agent "${agent.name}" (type: ${agent.type}) cannot be executed directly. ` +
+        `Only HTTP agents and workflow-linked agents can be run.`,
+    );
+  }
+
+  const { runWorkflow } = await import("./langwatch-api-workflows.js");
+  const result = await runWorkflow(workflowId, input);
+  return { agentType: agent.type, result };
+}
+
+export async function deleteAgent(id: string): Promise<{ id: string; name: string }> {
+  return makeRequest(
+    "DELETE",
+    `/api/agents/${encodeURIComponent(id)}`,
+  ) as Promise<{ id: string; name: string }>;
+}

package/src/langwatch-api-annotations.ts

@@ -0,0 +1,49 @@
+import { makeRequest } from "./langwatch-api.js";
+
+export interface AnnotationResponse {
+  id?: string;
+  projectId?: string;
+  traceId?: string;
+  comment?: string;
+  isThumbsUp?: boolean;
+  userId?: string;
+  email?: string;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export async function listAnnotations(): Promise<AnnotationResponse[]> {
+  return makeRequest("GET", "/api/annotations") as Promise<AnnotationResponse[]>;
+}
+
+export async function getAnnotation(id: string): Promise<AnnotationResponse> {
+  return makeRequest(
+    "GET",
+    `/api/annotations/${encodeURIComponent(id)}`,
+  ) as Promise<AnnotationResponse>;
+}
+
+export async function getAnnotationsByTrace(traceId: string): Promise<AnnotationResponse[]> {
+  return makeRequest(
+    "GET",
+    `/api/annotations/trace/${encodeURIComponent(traceId)}`,
+  ) as Promise<AnnotationResponse[]>;
+}
+
+export async function createAnnotation(
+  traceId: string,
+  data: { comment?: string; isThumbsUp?: boolean; email?: string },
+): Promise<AnnotationResponse> {
+  return makeRequest(
+    "POST",
+    `/api/annotations/trace/${encodeURIComponent(traceId)}`,
+    data,
+  ) as Promise<AnnotationResponse>;
+}
+
+export async function deleteAnnotation(id: string): Promise<{ status?: string; message?: string }> {
+  return makeRequest(
+    "DELETE",
+    `/api/annotations/${encodeURIComponent(id)}`,
+  ) as Promise<{ status?: string; message?: string }>;
+}

package/src/langwatch-api-dashboards.ts

@@ -0,0 +1,48 @@
+import { makeRequest } from "./langwatch-api.js";
+
+export interface DashboardSummary {
+  id: string;
+  name: string;
+  order: number;
+  graphCount: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface DashboardDetail extends DashboardSummary {
+  graphs: unknown[];
+}
+
+export interface DashboardListResponse {
+  data: DashboardSummary[];
+}
+
+export async function listDashboards(): Promise<DashboardListResponse> {
+  return makeRequest("GET", "/api/dashboards") as Promise<DashboardListResponse>;
+}
+
+export async function getDashboard(id: string): Promise<DashboardDetail> {
+  return makeRequest(
+    "GET",
+    `/api/dashboards/${encodeURIComponent(id)}`,
+  ) as Promise<DashboardDetail>;
+}
+
+export async function createDashboard(data: { name: string }): Promise<DashboardDetail> {
+  return makeRequest("POST", "/api/dashboards", data) as Promise<DashboardDetail>;
+}
+
+export async function renameDashboard(id: string, data: { name: string }): Promise<DashboardDetail> {
+  return makeRequest(
+    "PATCH",
+    `/api/dashboards/${encodeURIComponent(id)}`,
+    data,
+  ) as Promise<DashboardDetail>;
+}
+
+export async function deleteDashboard(id: string): Promise<{ id: string; name: string }> {
+  return makeRequest(
+    "DELETE",
+    `/api/dashboards/${encodeURIComponent(id)}`,
+  ) as Promise<{ id: string; name: string }>;
+}

package/src/langwatch-api-datasets.ts

@@ -0,0 +1,191 @@
+import { makeRequest } from "./langwatch-api.js";
+
+// --- Dataset types ---
+
+export interface DatasetColumnType {
+  name: string;
+  type: string;
+}
+
+export interface DatasetSummary {
+  id: string;
+  name: string;
+  slug: string;
+  columnTypes: DatasetColumnType[];
+  recordCount?: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface DatasetListResponse {
+  data: DatasetSummary[];
+  pagination: {
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+  };
+}
+
+export interface DatasetRecord {
+  id: string;
+  entry: Record<string, unknown>;
+}
+
+export interface DatasetDetailResponse {
+  id: string;
+  name: string;
+  slug: string;
+  columnTypes: DatasetColumnType[];
+  createdAt: string;
+  updatedAt: string;
+  data: DatasetRecord[];
+}
+
+export interface DatasetMutationResponse {
+  id: string;
+  name: string;
+  slug: string;
+  columnTypes: DatasetColumnType[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface DatasetArchiveResponse {
+  id: string;
+  archived: boolean;
+}
+
+export interface BatchCreateRecordsResponse {
+  data: DatasetRecord[];
+}
+
+export interface DeleteRecordsResponse {
+  deletedCount: number;
+}
+
+export interface DatasetRecordListResponse {
+  data: DatasetRecord[];
+  pagination: {
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+  };
+}
+
+// --- Dataset API functions ---
+
+/** Lists all datasets in the project (paginated). */
+export async function listDatasets(params?: {
+  page?: number;
+  limit?: number;
+}): Promise<DatasetListResponse> {
+  const query = new URLSearchParams();
+  if (params?.page != null) query.set("page", String(params.page));
+  if (params?.limit != null) query.set("limit", String(params.limit));
+  const qs = query.toString();
+  const path = qs ? `/api/dataset?${qs}` : "/api/dataset";
+  return makeRequest("GET", path) as Promise<DatasetListResponse>;
+}
+
+/** Retrieves a single dataset by slug or ID, including records. */
+export async function getDataset(
+  slugOrId: string,
+): Promise<DatasetDetailResponse> {
+  return makeRequest(
+    "GET",
+    `/api/dataset/${encodeURIComponent(slugOrId)}`,
+  ) as Promise<DatasetDetailResponse>;
+}
+
+/** Creates a new dataset. */
+export async function createDataset(data: {
+  name: string;
+  columnTypes?: DatasetColumnType[];
+}): Promise<DatasetMutationResponse> {
+  return makeRequest(
+    "POST",
+    "/api/dataset",
+    data,
+  ) as Promise<DatasetMutationResponse>;
+}
+
+/** Updates an existing dataset by slug or ID. */
+export async function updateDataset(params: {
+  slugOrId: string;
+  name?: string;
+  columnTypes?: DatasetColumnType[];
+}): Promise<DatasetMutationResponse> {
+  const { slugOrId, ...data } = params;
+  return makeRequest(
+    "PATCH",
+    `/api/dataset/${encodeURIComponent(slugOrId)}`,
+    data,
+  ) as Promise<DatasetMutationResponse>;
+}
+
+/** Archives (soft-deletes) a dataset by slug or ID. */
+export async function deleteDataset(
+  slugOrId: string,
+): Promise<DatasetArchiveResponse> {
+  return makeRequest(
+    "DELETE",
+    `/api/dataset/${encodeURIComponent(slugOrId)}`,
+  ) as Promise<DatasetArchiveResponse>;
+}
+
+/** Creates records in a dataset in batch. */
+export async function createDatasetRecords(params: {
+  slugOrId: string;
+  entries: Record<string, unknown>[];
+}): Promise<BatchCreateRecordsResponse> {
+  const { slugOrId, entries } = params;
+  return makeRequest(
+    "POST",
+    `/api/dataset/${encodeURIComponent(slugOrId)}/records`,
+    { entries },
+  ) as Promise<BatchCreateRecordsResponse>;
+}
+
+/** Updates or creates a single record in a dataset. */
+export async function updateDatasetRecord(params: {
+  slugOrId: string;
+  recordId: string;
+  entry: Record<string, unknown>;
+}): Promise<DatasetRecord> {
+  const { slugOrId, recordId, entry } = params;
+  return makeRequest(
+    "PATCH",
+    `/api/dataset/${encodeURIComponent(slugOrId)}/records/${encodeURIComponent(recordId)}`,
+    { entry },
+  ) as Promise<DatasetRecord>;
+}
+
+/** Deletes records from a dataset by IDs. */
+export async function deleteDatasetRecords(params: {
+  slugOrId: string;
+  recordIds: string[];
+}): Promise<DeleteRecordsResponse> {
+  const { slugOrId, recordIds } = params;
+  return makeRequest(
+    "DELETE",
+    `/api/dataset/${encodeURIComponent(slugOrId)}/records`,
+    { recordIds },
+  ) as Promise<DeleteRecordsResponse>;
+}
+
+/** Lists records in a dataset (paginated). */
+export async function listDatasetRecords(params: {
+  slugOrId: string;
+  page?: number;
+  limit?: number;
+}): Promise<DatasetRecordListResponse> {
+  const { slugOrId } = params;
+  const query = new URLSearchParams();
+  if (params.page != null) query.set("page", String(params.page));
+  if (params.limit != null) query.set("limit", String(params.limit));
+  const qs = query.toString();
+  const path = `/api/dataset/${encodeURIComponent(slugOrId)}/records${qs ? `?${qs}` : ""}`;
+  return makeRequest("GET", path) as Promise<DatasetRecordListResponse>;
+}

package/src/langwatch-api-evaluators.ts

@@ -68,3 +68,13 @@ export async function updateEvaluator(params: {
     data,
   ) as Promise<EvaluatorSummary>;
 }
+
+/** Archives (soft-deletes) an evaluator. */
+export async function deleteEvaluator(
+  idOrSlug: string,
+): Promise<{ id: string; archived: boolean }> {
+  return makeRequest(
+    "DELETE",
+    `/api/evaluators/${encodeURIComponent(idOrSlug)}`,
+  ) as Promise<{ id: string; archived: boolean }>;
+}

package/src/langwatch-api-monitors.ts

@@ -0,0 +1,82 @@
+import { makeRequest } from "./langwatch-api.js";
+
+export interface MonitorSummary {
+  id: string;
+  name: string;
+  slug: string;
+  checkType: string;
+  enabled: boolean;
+  executionMode: string;
+  sample: number;
+  level: string;
+  evaluatorId: string | null;
+  preconditions: unknown;
+  parameters: unknown;
+  mappings: unknown;
+  threadIdleTimeout: number | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export async function listMonitors(): Promise<MonitorSummary[]> {
+  return makeRequest("GET", "/api/monitors") as Promise<MonitorSummary[]>;
+}
+
+export async function getMonitor(id: string): Promise<MonitorSummary> {
+  return makeRequest(
+    "GET",
+    `/api/monitors/${encodeURIComponent(id)}`
+  ) as Promise<MonitorSummary>;
+}
+
+export async function createMonitor(data: {
+  name: string;
+  checkType: string;
+  executionMode?: string;
+  sample?: number;
+  evaluatorId?: string;
+  level?: string;
+  parameters?: Record<string, unknown>;
+}): Promise<MonitorSummary> {
+  return makeRequest("POST", "/api/monitors", {
+    ...data,
+    preconditions: [],
+    parameters: data.parameters ?? {},
+  }) as Promise<MonitorSummary>;
+}
+
+export async function updateMonitor(params: {
+  id: string;
+  name?: string;
+  enabled?: boolean;
+  executionMode?: string;
+  sample?: number;
+  parameters?: Record<string, unknown>;
+}): Promise<MonitorSummary> {
+  const { id, ...data } = params;
+  return makeRequest(
+    "PATCH",
+    `/api/monitors/${encodeURIComponent(id)}`,
+    data
+  ) as Promise<MonitorSummary>;
+}
+
+export async function toggleMonitor(params: {
+  id: string;
+  enabled: boolean;
+}): Promise<{ id: string; enabled: boolean }> {
+  return makeRequest(
+    "POST",
+    `/api/monitors/${encodeURIComponent(params.id)}/toggle`,
+    { enabled: params.enabled }
+  ) as Promise<{ id: string; enabled: boolean }>;
+}
+
+export async function deleteMonitor(
+  id: string
+): Promise<{ id: string; deleted: boolean }> {
+  return makeRequest(
+    "DELETE",
+    `/api/monitors/${encodeURIComponent(id)}`
+  ) as Promise<{ id: string; deleted: boolean }>;
+}

package/src/langwatch-api-secrets.ts

@@ -0,0 +1,48 @@
+import { makeRequest } from "./langwatch-api.js";
+
+export interface SecretSummary {
+  id: string;
+  projectId: string;
+  name: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export async function listSecrets(): Promise<SecretSummary[]> {
+  return makeRequest("GET", "/api/secrets") as Promise<SecretSummary[]>;
+}
+
+export async function getSecret(id: string): Promise<SecretSummary> {
+  return makeRequest(
+    "GET",
+    `/api/secrets/${encodeURIComponent(id)}`
+  ) as Promise<SecretSummary>;
+}
+
+export async function createSecret(data: {
+  name: string;
+  value: string;
+}): Promise<SecretSummary> {
+  return makeRequest("POST", "/api/secrets", data) as Promise<SecretSummary>;
+}
+
+export async function updateSecret(params: {
+  id: string;
+  value: string;
+}): Promise<SecretSummary> {
+  const { id, value } = params;
+  return makeRequest(
+    "PUT",
+    `/api/secrets/${encodeURIComponent(id)}`,
+    { value }
+  ) as Promise<SecretSummary>;
+}
+
+export async function deleteSecret(
+  id: string
+): Promise<{ id: string; deleted: boolean }> {
+  return makeRequest(
+    "DELETE",
+    `/api/secrets/${encodeURIComponent(id)}`
+  ) as Promise<{ id: string; deleted: boolean }>;
+}

package/src/langwatch-api-simulation-runs.ts

@@ -0,0 +1,51 @@
+import { makeRequest } from "./langwatch-api.js";
+
+export interface SimulationRunSummary {
+  scenarioRunId: string;
+  scenarioId: string;
+  batchRunId: string;
+  name: string | null;
+  status: string;
+  durationInMs: number;
+  totalCost?: number;
+  results?: {
+    verdict?: string | null;
+    reasoning?: string | null;
+    metCriteria?: string[];
+    unmetCriteria?: string[];
+    error?: string | null;
+  } | null;
+  messages?: Array<{ role: string; content: string }>;
+  timestamp: number;
+  updatedAt: number;
+}
+
+export interface SimulationRunListResponse {
+  runs: SimulationRunSummary[];
+  hasMore?: boolean;
+  nextCursor?: string;
+}
+
+/** Lists simulation runs, optionally filtered by scenario set or batch. */
+export async function listSimulationRuns(params?: {
+  scenarioSetId?: string;
+  batchRunId?: string;
+  limit?: number;
+}): Promise<SimulationRunListResponse> {
+  const query = new URLSearchParams();
+  if (params?.scenarioSetId) query.set("scenarioSetId", params.scenarioSetId);
+  if (params?.batchRunId) query.set("batchRunId", params.batchRunId);
+  if (params?.limit) query.set("limit", String(params.limit));
+  const qs = query.toString() ? `?${query}` : "";
+  return makeRequest("GET", `/api/simulation-runs${qs}`) as Promise<SimulationRunListResponse>;
+}
+
+/** Gets a single simulation run by its ID. */
+export async function getSimulationRun(
+  scenarioRunId: string,
+): Promise<SimulationRunSummary> {
+  return makeRequest(
+    "GET",
+    `/api/simulation-runs/${encodeURIComponent(scenarioRunId)}`,
+  ) as Promise<SimulationRunSummary>;
+}