@langwatch/mcp-server 2.1.0 → 2.2.0

package/src/langwatch-api-agents.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 
-import { makeRequest } from "./langwatch-api.js";
-import { requestPublicJson } from "./public-http-request.js";
+import { makeRequest } from "./langwatch-api.ts";
+import { requestPublicJson } from "./public-http-request.ts";
 
 /**
  * The run parameters a call carries: a flat record of scalars. The platform
@@ -106,10 +106,7 @@ export async function listAgents(params?: {
 }
 
 export async function getAgent(id: string): Promise<AgentSummary> {
-  return makeRequest(
-    "GET",
-    `/api/v1/agents/${encodeURIComponent(id)}`,
-  ) as Promise<AgentSummary>;
+  return makeRequest("GET", `/api/v1/agents/${encodeURIComponent(id)}`) as Promise<AgentSummary>;
 }
 
 export async function createAgent(data: {
@@ -160,10 +157,9 @@ export interface AgentTestRunResponse {
 }
 
 /**
- * Runs one scripted scenario against an agent: the user sends "ping", the
- * agent answers, and the run succeeds when the answer arrives. The project
- * gains no scenario, run plan or test suite, and the answer carries the run
- * ids to follow.
+ * Runs one scripted "ping" scenario against an agent and succeeds when
+ * the answer arrives. Creates no scenario, run plan or test suite; the
+ * response carries the run ids to follow.
  */
 export async function testAgent(id: string): Promise<AgentTestRunResponse> {
   return makeRequest(
@@ -177,14 +173,15 @@ const isMessageList = (value: unknown): value is AgentCallMessage[] =>
   Array.isArray(value) &&
   value.every(
     (item) =>
-      typeof item === "object" && item !== null && typeof (item as AgentCallMessage).role === "string",
+      typeof item === "object" &&
+      item !== null &&
+      typeof (item as AgentCallMessage).role === "string",
   );
 
 /**
- * The relay body for a connected agent: `message` is one user turn, `input`
- * is the body itself (it must carry `messages`), `parameters` are the run
- * parameters and `threadId` continues a conversation. A string is the
- * refusal, so the tool can answer it.
+ * The relay body for a connected agent: `message` is one user turn,
+ * `input` is the raw body (must carry `messages`), `parameters` are run
+ * parameters, `threadId` continues a conversation. A string is a refusal.
  */
 export function buildRelayBody({
   input,
@@ -218,7 +215,7 @@ export function buildRelayBody({
     }
     inputParams = parsed.data;
   }
-  if (inputParams || parameters) body.params = { ...(inputParams ?? {}), ...(parameters ?? {}) };
+  if (inputParams || parameters) body.params = { ...inputParams, ...parameters };
   return body;
 }
 
@@ -279,14 +276,14 @@ export async function runAgent({
     );
   }
 
-  const { runWorkflow } = await import("./langwatch-api-workflows.js");
+  const { runWorkflow } = await import("./langwatch-api-workflows.ts");
   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/v1/agents/${encodeURIComponent(id)}`,
-  ) as Promise<{ id: string; name: string }>;
+  return makeRequest("DELETE", `/api/v1/agents/${encodeURIComponent(id)}`) as Promise<{
+    id: string;
+    name: string;
+  }>;
 }

package/src/langwatch-api-annotations.ts

@@ -1,4 +1,4 @@
-import { makeRequest } from "./langwatch-api.js";
+import { makeRequest } from "./langwatch-api.ts";
 
 export interface AnnotationResponse {
   id?: string;
@@ -13,21 +13,20 @@ export interface AnnotationResponse {
 }
 
 export async function listAnnotations(): Promise<AnnotationResponse[]> {
-  return makeRequest("GET", "/api/annotations") as Promise<AnnotationResponse[]>;
+  return makeRequest("GET", "/api/v1/annotations") as Promise<AnnotationResponse[]>;
 }
 
 export async function getAnnotation(id: string): Promise<AnnotationResponse> {
   return makeRequest(
     "GET",
-    `/api/annotations/${encodeURIComponent(id)}`,
+    `/api/v1/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[]>;
+  return makeRequest("GET", `/api/v1/annotations/trace/${encodeURIComponent(traceId)}`) as Promise<
+    AnnotationResponse[]
+  >;
 }
 
 export async function createAnnotation(
@@ -36,14 +35,14 @@ export async function createAnnotation(
 ): Promise<AnnotationResponse> {
   return makeRequest(
     "POST",
-    `/api/annotations/trace/${encodeURIComponent(traceId)}`,
+    `/api/v1/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 }>;
+  return makeRequest("DELETE", `/api/v1/annotations/${encodeURIComponent(id)}`) as Promise<{
+    status?: string;
+    message?: string;
+  }>;
 }

package/src/langwatch-api-api-keys.ts

@@ -1,4 +1,4 @@
-import { makeRequest } from "./langwatch-api.js";
+import { makeRequest } from "./langwatch-api.ts";
 
 export interface RoleBinding {
   id: string;
@@ -28,7 +28,7 @@ export interface ApiKeyCreateResponse {
 }
 
 export async function listApiKeys(): Promise<{ data: ApiKeySummary[] }> {
-  return makeRequest("GET", "/api/api-keys") as Promise<{ data: ApiKeySummary[] }>;
+  return makeRequest("GET", "/api/v1/api-keys") as Promise<{ data: ApiKeySummary[] }>;
 }
 
 export async function createApiKey(data: {
@@ -36,19 +36,18 @@ export async function createApiKey(data: {
   name: string;
   description?: string;
   expiresAt?: string;
-  bindings?: Array<{
+  bindings?: {
     role: "ADMIN" | "MEMBER" | "VIEWER";
     scopeType: "ORGANIZATION" | "TEAM" | "PROJECT";
     scopeId: string;
-  }>;
+  }[];
   projectIds?: string[];
 }): Promise<ApiKeyCreateResponse> {
-  return makeRequest("POST", "/api/api-keys", data) as Promise<ApiKeyCreateResponse>;
+  return makeRequest("POST", "/api/v1/api-keys", data) as Promise<ApiKeyCreateResponse>;
 }
 
 export async function revokeApiKey(id: string): Promise<{ success: boolean }> {
-  return makeRequest(
-    "DELETE",
-    `/api/api-keys/${encodeURIComponent(id)}`,
-  ) as Promise<{ success: boolean }>;
+  return makeRequest("DELETE", `/api/v1/api-keys/${encodeURIComponent(id)}`) as Promise<{
+    success: boolean;
+  }>;
 }

package/src/langwatch-api-boards.ts

@@ -0,0 +1,46 @@
+import { makeRequest } from "./langwatch-api.js";
+
+/**
+ * A board in the Dashboards area, the place a widget is added to
+ * (`modules/dashboard/contract/src/board-rest.schemas.ts`). Analytics Reports boards are
+ * `/api/v1/dashboards`, and hold no widget.
+ */
+export interface Board {
+  id: string;
+  name: string;
+  description: string | null;
+  scope: "PRIVATE" | "PROJECT" | "ORGANIZATION";
+  createdAt: string;
+  updatedAt: string;
+  platformUrl: string;
+}
+
+export interface BoardListItem extends Board {
+  widgetCount: number;
+}
+
+/** The project's Dashboards boards, each with how many widgets it holds. */
+export async function listBoards({
+  projectId,
+}: {
+  projectId: string;
+}): Promise<{ data: BoardListItem[] }> {
+  return makeRequest(
+    "GET",
+    `/api/v1/projects/${encodeURIComponent(projectId)}/analytics/boards`,
+  ) as Promise<{ data: BoardListItem[] }>;
+}
+
+/** Reads one Dashboards board; a board in another project, or only in Reports, answers 404. */
+export async function getBoard({
+  projectId,
+  boardId,
+}: {
+  projectId: string;
+  boardId: string;
+}): Promise<Board> {
+  return makeRequest(
+    "GET",
+    `/api/v1/projects/${encodeURIComponent(projectId)}/analytics/boards/${encodeURIComponent(boardId)}`,
+  ) as Promise<Board>;
+}

package/src/langwatch-api-dashboard-widgets.ts

@@ -0,0 +1,112 @@
+import { makeRequest } from "./langwatch-api.js";
+
+/**
+ * One named LangWatchQL statement a widget may run, as the REST endpoint validates it
+ * (`modules/dashboard/contract/src/dashboard-widget-rest.schemas.ts`).
+ */
+export interface DashboardWidgetQueryInput {
+  name: string;
+  sql: string;
+  parameters?: {
+    name: string;
+    type: "string" | "number" | "boolean";
+    default?: string | number | boolean;
+  }[];
+}
+
+/** Where a widget came from, as the platform records it. */
+export type DashboardWidgetSource =
+  | { kind: "catalogue"; catalogueId: string }
+  | { kind: "langy" }
+  | { kind: "code" }
+  | { kind: "api" };
+
+export interface DashboardWidgetDefinition {
+  version: number;
+  code: string;
+  queries: DashboardWidgetQueryInput[];
+  description?: string;
+  prompt?: string;
+  source?: DashboardWidgetSource;
+}
+
+export interface DashboardWidget {
+  id: string;
+  name: string;
+  definition: DashboardWidgetDefinition;
+  createdAt: string;
+  updatedAt: string;
+  platformUrl: string;
+  dashboardId: string | null;
+  gridColumn: number;
+  gridRow: number;
+  colSpan: number;
+  rowSpan: number;
+}
+
+/** Saves a new widget, unplaced (not yet on any dashboard). */
+export async function createDashboardWidget(params: {
+  projectId: string;
+  name: string;
+  code: string;
+  queries: DashboardWidgetQueryInput[];
+}): Promise<DashboardWidget> {
+  const { projectId, ...data } = params;
+  return makeRequest(
+    "POST",
+    `/api/v1/projects/${encodeURIComponent(projectId)}/analytics/dashboard-widgets`,
+    data,
+  ) as Promise<DashboardWidget>;
+}
+
+/** Reads one widget; a widget in another project answers 404. */
+export async function getDashboardWidget(params: {
+  projectId: string;
+  widgetId: string;
+}): Promise<DashboardWidget> {
+  return makeRequest(
+    "GET",
+    `/api/v1/projects/${encodeURIComponent(params.projectId)}/analytics/dashboard-widgets/${encodeURIComponent(params.widgetId)}`,
+  ) as Promise<DashboardWidget>;
+}
+
+/** Changes the fields given; every field left out keeps its stored value. */
+export async function updateDashboardWidget(params: {
+  projectId: string;
+  widgetId: string;
+  name?: string;
+  code?: string;
+  queries?: DashboardWidgetQueryInput[];
+  description?: string;
+}): Promise<DashboardWidget> {
+  const { projectId, widgetId, ...data } = params;
+  return makeRequest(
+    "PATCH",
+    `/api/v1/projects/${encodeURIComponent(projectId)}/analytics/dashboard-widgets/${encodeURIComponent(widgetId)}`,
+    data,
+  ) as Promise<DashboardWidget>;
+}
+
+/** Places an existing widget on a dashboard, at the next free row. */
+export async function assignDashboardWidgetToDashboard(params: {
+  projectId: string;
+  widgetId: string;
+  dashboardId: string;
+}): Promise<DashboardWidget> {
+  return makeRequest(
+    "POST",
+    `/api/v1/projects/${encodeURIComponent(params.projectId)}/analytics/dashboard-widgets/${encodeURIComponent(params.widgetId)}/dashboard`,
+    { dashboardId: params.dashboardId },
+  ) as Promise<DashboardWidget>;
+}
+
+/** Deletes a widget. Used to undo a create when placing it fails. */
+export async function deleteDashboardWidget(params: {
+  projectId: string;
+  widgetId: string;
+}): Promise<void> {
+  await makeRequest(
+    "DELETE",
+    `/api/v1/projects/${encodeURIComponent(params.projectId)}/analytics/dashboard-widgets/${encodeURIComponent(params.widgetId)}`,
+  );
+}

package/src/langwatch-api-dashboards.ts

@@ -1,4 +1,4 @@
-import { makeRequest } from "./langwatch-api.js";
+import { makeRequest } from "./langwatch-api.ts";
 
 export interface DashboardSummary {
   id: string;
@@ -18,31 +18,34 @@ export interface DashboardListResponse {
 }
 
 export async function listDashboards(): Promise<DashboardListResponse> {
-  return makeRequest("GET", "/api/dashboards") as Promise<DashboardListResponse>;
+  return makeRequest("GET", "/api/v1/dashboards") as Promise<DashboardListResponse>;
 }
 
 export async function getDashboard(id: string): Promise<DashboardDetail> {
   return makeRequest(
     "GET",
-    `/api/dashboards/${encodeURIComponent(id)}`,
+    `/api/v1/dashboards/${encodeURIComponent(id)}`,
   ) as Promise<DashboardDetail>;
 }
 
 export async function createDashboard(data: { name: string }): Promise<DashboardDetail> {
-  return makeRequest("POST", "/api/dashboards", data) as Promise<DashboardDetail>;
+  return makeRequest("POST", "/api/v1/dashboards", data) as Promise<DashboardDetail>;
 }
 
-export async function renameDashboard(id: string, data: { name: string }): Promise<DashboardDetail> {
+export async function renameDashboard(
+  id: string,
+  data: { name: string },
+): Promise<DashboardDetail> {
   return makeRequest(
     "PATCH",
-    `/api/dashboards/${encodeURIComponent(id)}`,
+    `/api/v1/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 }>;
+  return makeRequest("DELETE", `/api/v1/dashboards/${encodeURIComponent(id)}`) as Promise<{
+    id: string;
+    name: string;
+  }>;
 }

package/src/langwatch-api-datasets.ts

@@ -1,4 +1,4 @@
-import { makeRequest } from "./langwatch-api.js";
+import { LangWatchApiError, makeRequest } from "./langwatch-api.ts";
 
 // --- Dataset types ---
 
@@ -40,6 +40,10 @@ export interface DatasetDetailResponse {
   createdAt: string;
   updatedAt: string;
   data: DatasetRecord[];
+  /** Records in the dataset, when `data` is a preview of them. */
+  totalRecords?: number;
+  /** Records of the dataset left out of `data`. */
+  omittedRecords?: number;
 }
 
 export interface DatasetMutationResponse {
@@ -72,8 +76,16 @@ export interface DatasetRecordListResponse {
     limit: number;
     totalPages: number;
   };
+  /** The dataset the page belongs to. Absent on servers that do not send it. */
+  dataset?: DatasetMutationResponse;
 }
 
+/** The most records a dataset preview holds. */
+export const DATASET_PREVIEW_MAX_RECORDS = 100;
+
+/** The most bytes of records a dataset preview holds. */
+export const DATASET_PREVIEW_MAX_BYTES = 1024 * 1024;
+
 // --- Dataset API functions ---
 
 /** Lists all datasets in the project (paginated). */
@@ -85,18 +97,82 @@ export async function listDatasets(params?: {
   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";
+  const path = qs ? `/api/v1/dataset?${qs}` : "/api/v1/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>;
+/**
+ * Retrieves a dataset by slug or ID with a preview of its records: the first page, cut at
+ * `DATASET_PREVIEW_MAX_RECORDS` records and `DATASET_PREVIEW_MAX_BYTES` bytes. A dataset of
+ * any size can be read this way. `omittedRecords` counts what the preview leaves out.
+ */
+export async function getDataset(slugOrId: string): Promise<DatasetDetailResponse> {
+  const page = await readPreviewPage(slugOrId);
+  // A server without the records endpoint, or one that sends no dataset with a page, is
+  // asked for the whole dataset in one response.
+  if (!page?.dataset) {
+    return makeRequest(
+      "GET",
+      `/api/v1/dataset/${encodeURIComponent(slugOrId)}`,
+    ) as Promise<DatasetDetailResponse>;
+  }
+
+  const data: DatasetRecord[] = [];
+  let bytes = 0;
+  for (const record of page.data) {
+    bytes += JSON.stringify(record).length;
+    if (bytes > DATASET_PREVIEW_MAX_BYTES) break;
+    data.push(record);
+  }
+
+  const { id, name, slug, columnTypes, createdAt, updatedAt } = page.dataset;
+  const totalRecords = page.pagination.total;
+  return {
+    id,
+    name,
+    slug,
+    columnTypes,
+    createdAt,
+    updatedAt,
+    data,
+    totalRecords,
+    omittedRecords: Math.max(0, totalRecords - data.length),
+  };
+}
+
+/**
+ * The first page of a dataset's records, or `null` when the records endpoint answers 404. A
+ * page refused as too large is asked for again with the size the refusal suggests, or half.
+ */
+async function readPreviewPage(slugOrId: string): Promise<DatasetRecordListResponse | null> {
+  let limit = DATASET_PREVIEW_MAX_RECORDS;
+  for (;;) {
+    try {
+      return await listDatasetRecords({ slugOrId, page: 1, limit });
+    } catch (error) {
+      if (!(error instanceof LangWatchApiError)) throw error;
+      if (error.status === 404) return null;
+      if (error.status !== 413 || limit <= 1) throw error;
+      limit = smallerLimit(limit, error.responseBody);
+    }
+  }
+}
+
+/** The page size a `dataset_page_too_large` refusal suggests, or half the refused one. */
+function smallerLimit(limit: number, responseBody: string): number {
+  const half = Math.max(1, Math.floor(limit / 2));
+  try {
+    const suggested: unknown = (JSON.parse(responseBody) as { meta?: { suggestedLimit?: unknown } })
+      .meta?.suggestedLimit;
+    const usable =
+      typeof suggested === "number" &&
+      Number.isInteger(suggested) &&
+      suggested >= 1 &&
+      suggested < limit;
+    return usable ? suggested : half;
+  } catch {
+    return half;
+  }
 }
 
 /** Creates a new dataset. */
@@ -104,11 +180,7 @@ export async function createDataset(data: {
   name: string;
   columnTypes?: DatasetColumnType[];
 }): Promise<DatasetMutationResponse> {
-  return makeRequest(
-    "POST",
-    "/api/dataset",
-    data,
-  ) as Promise<DatasetMutationResponse>;
+  return makeRequest("POST", "/api/v1/dataset", data) as Promise<DatasetMutationResponse>;
 }
 
 /** Updates an existing dataset by slug or ID. */
@@ -120,18 +192,16 @@ export async function updateDataset(params: {
   const { slugOrId, ...data } = params;
   return makeRequest(
     "PATCH",
-    `/api/dataset/${encodeURIComponent(slugOrId)}`,
+    `/api/v1/dataset/${encodeURIComponent(slugOrId)}`,
     data,
   ) as Promise<DatasetMutationResponse>;
 }
 
 /** Archives (soft-deletes) a dataset by slug or ID. */
-export async function deleteDataset(
-  slugOrId: string,
-): Promise<DatasetArchiveResponse> {
+export async function deleteDataset(slugOrId: string): Promise<DatasetArchiveResponse> {
   return makeRequest(
     "DELETE",
-    `/api/dataset/${encodeURIComponent(slugOrId)}`,
+    `/api/v1/dataset/${encodeURIComponent(slugOrId)}`,
   ) as Promise<DatasetArchiveResponse>;
 }
 
@@ -141,11 +211,9 @@ export async function createDatasetRecords(params: {
   entries: Record<string, unknown>[];
 }): Promise<BatchCreateRecordsResponse> {
   const { slugOrId, entries } = params;
-  return makeRequest(
-    "POST",
-    `/api/dataset/${encodeURIComponent(slugOrId)}/records`,
-    { entries },
-  ) as Promise<BatchCreateRecordsResponse>;
+  return makeRequest("POST", `/api/v1/dataset/${encodeURIComponent(slugOrId)}/records`, {
+    entries,
+  }) as Promise<BatchCreateRecordsResponse>;
 }
 
 /** Updates or creates a single record in a dataset. */
@@ -157,7 +225,7 @@ export async function updateDatasetRecord(params: {
   const { slugOrId, recordId, entry } = params;
   return makeRequest(
     "PATCH",
-    `/api/dataset/${encodeURIComponent(slugOrId)}/records/${encodeURIComponent(recordId)}`,
+    `/api/v1/dataset/${encodeURIComponent(slugOrId)}/records/${encodeURIComponent(recordId)}`,
     { entry },
   ) as Promise<DatasetRecord>;
 }
@@ -168,11 +236,9 @@ export async function deleteDatasetRecords(params: {
   recordIds: string[];
 }): Promise<DeleteRecordsResponse> {
   const { slugOrId, recordIds } = params;
-  return makeRequest(
-    "DELETE",
-    `/api/dataset/${encodeURIComponent(slugOrId)}/records`,
-    { recordIds },
-  ) as Promise<DeleteRecordsResponse>;
+  return makeRequest("DELETE", `/api/v1/dataset/${encodeURIComponent(slugOrId)}/records`, {
+    recordIds,
+  }) as Promise<DeleteRecordsResponse>;
 }
 
 /** Lists records in a dataset (paginated). */
@@ -186,6 +252,6 @@ export async function listDatasetRecords(params: {
   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}` : ""}`;
+  const path = `/api/v1/dataset/${encodeURIComponent(slugOrId)}/records${qs ? `?${qs}` : ""}`;
   return makeRequest("GET", path) as Promise<DatasetRecordListResponse>;
 }

package/src/langwatch-api-evaluators.ts

@@ -1,4 +1,4 @@
-import { makeRequest } from "./langwatch-api.js";
+import { makeRequest } from "./langwatch-api.ts";
 
 // --- Evaluator types ---
 
@@ -13,8 +13,8 @@ export interface EvaluatorSummary {
   copiedFromEvaluatorId: string | null;
   createdAt: string;
   updatedAt: string;
-  fields: Array<{ identifier: string; type: string; optional?: boolean }>;
-  outputFields: Array<{ identifier: string; type: string; optional?: boolean }>;
+  fields: { identifier: string; type: string; optional?: boolean }[];
+  outputFields: { identifier: string; type: string; optional?: boolean }[];
   workflowName?: string;
   workflowIcon?: string;
 }
@@ -25,25 +25,22 @@ export interface EvaluatorSummary {
  * Extracts the evaluatorType from an evaluator's config.
  * Centralises the cast so callers don't repeat it.
  */
-export function getEvaluatorType(
-  evaluator: Pick<EvaluatorSummary, "config">,
-): string | undefined {
-  return (evaluator.config as Record<string, unknown> | null)
-    ?.evaluatorType as string | undefined;
+export function getEvaluatorType(evaluator: Pick<EvaluatorSummary, "config">): string | undefined {
+  return (evaluator.config as Record<string, unknown> | null)?.evaluatorType as string | undefined;
 }
 
 // --- Evaluator API functions ---
 
 /** Lists all evaluators in the project. */
 export async function listEvaluators(): Promise<EvaluatorSummary[]> {
-  return makeRequest("GET", "/api/evaluators") as Promise<EvaluatorSummary[]>;
+  return makeRequest("GET", "/api/v1/evaluators") as Promise<EvaluatorSummary[]>;
 }
 
 /** Retrieves a single evaluator by ID or slug. */
 export async function getEvaluator(idOrSlug: string): Promise<EvaluatorSummary> {
   return makeRequest(
     "GET",
-    `/api/evaluators/${encodeURIComponent(idOrSlug)}`,
+    `/api/v1/evaluators/${encodeURIComponent(idOrSlug)}`,
   ) as Promise<EvaluatorSummary>;
 }
 
@@ -52,7 +49,7 @@ export async function createEvaluator(data: {
   name: string;
   config: Record<string, unknown>;
 }): Promise<EvaluatorSummary> {
-  return makeRequest("POST", "/api/evaluators", data) as Promise<EvaluatorSummary>;
+  return makeRequest("POST", "/api/v1/evaluators", data) as Promise<EvaluatorSummary>;
 }
 
 /** Updates an existing evaluator. */
@@ -64,17 +61,14 @@ export async function updateEvaluator(params: {
   const { id, ...data } = params;
   return makeRequest(
     "PUT",
-    `/api/evaluators/${encodeURIComponent(id)}`,
+    `/api/v1/evaluators/${encodeURIComponent(id)}`,
     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 }>;
+export async function deleteEvaluator(idOrSlug: string): Promise<{ success: boolean }> {
+  return makeRequest("DELETE", `/api/v1/evaluators/${encodeURIComponent(idOrSlug)}`) as Promise<{
+    success: boolean;
+  }>;
 }