@langwatch/mcp-server 2.1.0 → 3.0.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-analytics-reports.ts

@@ -0,0 +1,62 @@
+import { makeRequest } from "./langwatch-api.ts";
+
+/** An Analytics Report, at `/api/v1/analytics/reports`. Dashboards live at `/api/v1/dashboards`. */
+export interface AnalyticsReportSummary {
+  id: string;
+  name: string;
+  order: number;
+  graphCount: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface AnalyticsReportDetail extends AnalyticsReportSummary {
+  graphs: unknown[];
+}
+
+export interface AnalyticsReportListResponse {
+  data: AnalyticsReportSummary[];
+}
+
+const reportPath = (reportId: string) =>
+  `/api/v1/analytics/reports/${encodeURIComponent(reportId)}`;
+
+export async function listAnalyticsReports(): Promise<AnalyticsReportListResponse> {
+  return makeRequest("GET", "/api/v1/analytics/reports") as Promise<AnalyticsReportListResponse>;
+}
+
+export async function getAnalyticsReport({
+  reportId,
+}: {
+  reportId: string;
+}): Promise<AnalyticsReportDetail> {
+  return makeRequest("GET", reportPath(reportId)) as Promise<AnalyticsReportDetail>;
+}
+
+export async function createAnalyticsReport({
+  name,
+}: {
+  name: string;
+}): Promise<AnalyticsReportDetail> {
+  return makeRequest("POST", "/api/v1/analytics/reports", {
+    name,
+  }) as Promise<AnalyticsReportDetail>;
+}
+
+export async function renameAnalyticsReport({
+  reportId,
+  name,
+}: {
+  reportId: string;
+  name: string;
+}): Promise<AnalyticsReportDetail> {
+  return makeRequest("PATCH", reportPath(reportId), { name }) as Promise<AnalyticsReportDetail>;
+}
+
+export async function deleteAnalyticsReport({
+  reportId,
+}: {
+  reportId: string;
+}): Promise<{ id: string; name: string }> {
+  return makeRequest("DELETE", reportPath(reportId)) 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-dashboard-widgets.ts

@@ -0,0 +1,47 @@
+import type { WidgetSource } from "./schemas/widget-sources.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;
+  }[];
+  /** The trace origins the query counts; `null` makes it unset, counting application. */
+  sources?: WidgetSource[] | null;
+}
+
+/** 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;
+}

package/src/langwatch-api-dashboards.ts

@@ -1,48 +1,133 @@
+import type {
+  DashboardWidget,
+  DashboardWidgetQueryInput,
+} from "./langwatch-api-dashboard-widgets.js";
 import { makeRequest } from "./langwatch-api.js";
 
-export interface DashboardSummary {
+/**
+ * A dashboard in the Dashboards area, at `/api/v1/dashboards`; the project comes from the API key
+ * (`modules/dashboard/contract/src/board-rest.schemas.ts`). Every route answers 404 while
+ * Dashboards is off for the key's project. Analytics Reports live at `/api/v1/analytics/reports`.
+ */
+export interface Dashboard {
   id: string;
   name: string;
-  order: number;
-  graphCount: number;
+  description: string | null;
+  scope: "PRIVATE" | "PROJECT" | "ORGANIZATION";
+  createdById: string | null;
   createdAt: string;
   updatedAt: string;
+  platformUrl: string;
 }
 
-export interface DashboardDetail extends DashboardSummary {
-  graphs: unknown[];
+export interface DashboardListItem extends Dashboard {
+  widgetCount: number;
 }
 
-export interface DashboardListResponse {
-  data: DashboardSummary[];
+const dashboardPath = (dashboardId: string) =>
+  `/api/v1/dashboards/${encodeURIComponent(dashboardId)}`;
+const widgetPath = (dashboardId: string, widgetId: string) =>
+  `${dashboardPath(dashboardId)}/widgets/${encodeURIComponent(widgetId)}`;
+
+/** The key's project's dashboards, each with how many widgets it holds. */
+export async function listDashboards(): Promise<{ data: DashboardListItem[] }> {
+  return makeRequest("GET", "/api/v1/dashboards") as Promise<{ data: DashboardListItem[] }>;
 }
 
-export async function listDashboards(): Promise<DashboardListResponse> {
-  return makeRequest("GET", "/api/dashboards") as Promise<DashboardListResponse>;
+/** Reads one dashboard; a dashboard in another project, or an Analytics Report, answers 404. */
+export async function getDashboard({ dashboardId }: { dashboardId: string }): Promise<Dashboard> {
+  return makeRequest("GET", dashboardPath(dashboardId)) as Promise<Dashboard>;
 }
 
-export async function getDashboard(id: string): Promise<DashboardDetail> {
-  return makeRequest(
-    "GET",
-    `/api/dashboards/${encodeURIComponent(id)}`,
-  ) as Promise<DashboardDetail>;
+export async function createDashboard({ name }: { name: string }): Promise<Dashboard> {
+  return makeRequest("POST", "/api/v1/dashboards", { name }) as Promise<Dashboard>;
+}
+
+/** A field left out keeps its value; a `null` description clears it. */
+export async function updateDashboard({
+  dashboardId,
+  ...changes
+}: {
+  dashboardId: string;
+  name?: string;
+  description?: string | null;
+}): Promise<Dashboard> {
+  return makeRequest("PATCH", dashboardPath(dashboardId), changes) as Promise<Dashboard>;
 }
 
-export async function createDashboard(data: { name: string }): Promise<DashboardDetail> {
-  return makeRequest("POST", "/api/dashboards", data) as Promise<DashboardDetail>;
+/** Deletes the dashboard with the widgets on it. */
+export async function deleteDashboard({
+  dashboardId,
+}: {
+  dashboardId: string;
+}): Promise<{ id: string; name: string }> {
+  return makeRequest("DELETE", dashboardPath(dashboardId)) as Promise<{ id: string; name: string }>;
 }
 
-export async function renameDashboard(id: string, data: { name: string }): Promise<DashboardDetail> {
+export async function listWidgetsOnDashboard({
+  dashboardId,
+}: {
+  dashboardId: string;
+}): Promise<{ data: DashboardWidget[] }> {
+  return makeRequest("GET", `${dashboardPath(dashboardId)}/widgets`) as Promise<{
+    data: DashboardWidget[];
+  }>;
+}
+
+/** Saves a widget placed on this dashboard at the next free row. */
+export async function createWidgetOnDashboard({
+  dashboardId,
+  ...data
+}: {
+  dashboardId: string;
+  name: string;
+  code: string;
+  queries: DashboardWidgetQueryInput[];
+  description?: string;
+}): Promise<DashboardWidget> {
   return makeRequest(
-    "PATCH",
-    `/api/dashboards/${encodeURIComponent(id)}`,
+    "POST",
+    `${dashboardPath(dashboardId)}/widgets`,
     data,
-  ) as Promise<DashboardDetail>;
+  ) as Promise<DashboardWidget>;
+}
+
+/** A widget on any other dashboard answers 404. */
+export async function getWidgetOnDashboard({
+  dashboardId,
+  widgetId,
+}: {
+  dashboardId: string;
+  widgetId: string;
+}): Promise<DashboardWidget> {
+  return makeRequest("GET", widgetPath(dashboardId, widgetId)) as Promise<DashboardWidget>;
 }
 
-export async function deleteDashboard(id: string): Promise<{ id: string; name: string }> {
+export async function updateWidgetOnDashboard({
+  dashboardId,
+  widgetId,
+  ...changes
+}: {
+  dashboardId: string;
+  widgetId: string;
+  name?: string;
+  code?: string;
+  queries?: DashboardWidgetQueryInput[];
+  description?: string;
+}): Promise<DashboardWidget> {
   return makeRequest(
-    "DELETE",
-    `/api/dashboards/${encodeURIComponent(id)}`,
-  ) as Promise<{ id: string; name: string }>;
+    "PATCH",
+    widgetPath(dashboardId, widgetId),
+    changes,
+  ) as Promise<DashboardWidget>;
+}
+
+export async function deleteWidgetOnDashboard({
+  dashboardId,
+  widgetId,
+}: {
+  dashboardId: string;
+  widgetId: string;
+}): Promise<void> {
+  await makeRequest("DELETE", widgetPath(dashboardId, widgetId));
 }

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>;
 }