@promptlayer/mcp-server 1.11.0 → 1.15.0

package/src/client.ts

@@ -65,30 +65,46 @@ export class PromptLayerClient {
   logRequest(body: Body) { return this.post("/log-request", body); }
   createSpansBulk(body: Body) { return this.post("/spans-bulk", body); }
 
-  // Datasets
-  listDatasets(params?: Body) { return this.get("/api/public/v2/datasets", params); }
-  getDatasetRows(id: number, params?: Body) { return this.get(`/api/public/v2/datasets/${id}/rows`, params); }
-  createDatasetGroup(body: Body) { return this.post("/api/public/v2/dataset-groups", body); }
-  createDatasetVersionFromFile(body: Body) { return this.post("/api/public/v2/dataset-versions/from-file", body); }
-  createDatasetVersionFromFilterParams(body: Body) { return this.post("/api/public/v2/dataset-versions/from-filter-params", body); }
-  createDraftDatasetVersion(body: Body) { return this.post("/api/public/v2/dataset-versions/create-draft", body); }
-  addRequestLogToDatasetVersion(body: Body) { return this.post("/api/public/v2/dataset-versions/add-request-log", body); }
-  saveDraftDatasetVersion(body: Body) { return this.post("/api/public/v2/dataset-versions/save-draft", body); }
-
-  // Evaluations
-  listEvaluations(params?: Body) { return this.get("/api/public/v2/evaluations", params); }
-  getEvaluationRows(id: number, params?: Body) { return this.get(`/api/public/v2/evaluations/${id}/rows`, params); }
-  createReport(body: Body) { return this.post("/reports", body); }
-  runReport(id: number, body: Body) { return this.post(`/reports/${id}/run`, body); }
-  getReport(id: number) { return this.get(`/reports/${id}`); }
-  getReportScore(id: number) { return this.get(`/reports/${id}/score`); }
-  updateReportScoreCard(id: number, body: Body) { return this.patch(`/reports/${id}/score-card`, body); }
-  renameReport(id: number, body: Body) { return this.patch(`/reports/${id}/rename`, body); }
-  deleteReport(id: number) { return this.del(`/reports/${id}`); }
-  deleteReportsByName(name: string) { return this.del(`/reports/name/${this.enc(name)}`); }
-  addReportColumn(body: Body) { return this.post("/report-columns", body); }
-  editReportColumn(id: number, body: Body) { return this.patch(`/report-columns/${id}`, body); }
-  deleteReportColumn(id: number) { return this.del(`/report-columns/${id}`); }
+  // Smart Tables
+  listSmartTables(params?: Body) { return this.get("/api/public/v2/tables", params); }
+  createSmartTable(body: Body) { return this.post("/api/public/v2/tables", body); }
+  getSmartTable(tableId: string) { return this.get(`/api/public/v2/tables/${this.enc(tableId)}`); }
+  updateSmartTable(tableId: string, body: Body) { return this.patch(`/api/public/v2/tables/${this.enc(tableId)}`, body); }
+  listSmartTableSheets(tableId: string, params?: Body) { return this.get(`/api/public/v2/tables/${this.enc(tableId)}/sheets`, params); }
+  createSmartTableSheet(tableId: string, body: Body) { return this.post(`/api/public/v2/tables/${this.enc(tableId)}/sheets`, body); }
+  getSmartTableSheet(tableId: string, sheetId: string) { return this.get(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}`); }
+  updateSmartTableSheet(tableId: string, sheetId: string, body: Body) { return this.patch(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}`, body); }
+  getSmartTableSheetImportOperation(tableId: string, operationId: string) { return this.get(`/api/public/v2/tables/${this.enc(tableId)}/sheets/operations/${this.enc(operationId)}`); }
+  importSmartTableSheetFile(tableId: string, sheetId: string, body: Body) { return this.post(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/imports/file`, body); }
+  importSmartTableSheetRequestLogs(tableId: string, sheetId: string, body: Body) { return this.post(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/imports/request-logs`, body); }
+  listSmartTableColumns(tableId: string, sheetId: string, params?: Body) { return this.get(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/columns`, params); }
+  createSmartTableColumn(tableId: string, sheetId: string, body: Body) { return this.post(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/columns`, body); }
+  updateSmartTableColumn(tableId: string, sheetId: string, columnId: string, body: Body) { return this.patch(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/columns/${this.enc(columnId)}`, body); }
+  listSmartTableRows(tableId: string, sheetId: string, params?: Body) { return this.get(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/rows`, params); }
+  addSmartTableRows(tableId: string, sheetId: string, body: Body) { return this.post(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/rows`, body); }
+  getSmartTableCell(tableId: string, sheetId: string, cellId: string) { return this.get(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/cells/${this.enc(cellId)}`); }
+  updateSmartTableCell(tableId: string, sheetId: string, cellId: string, body: Body) { return this.patch(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/cells/${this.enc(cellId)}`, body); }
+  recalculateSmartTableCell(tableId: string, sheetId: string, cellId: string) { return this.post(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/cells/${this.enc(cellId)}/recalculate`); }
+  recalculateSmartTableCells(tableId: string, sheetId: string, body: Body) { return this.post(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/cells/recalculate`, body); }
+  listSmartTableOperations(tableId: string, sheetId: string) { return this.get(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/operations`); }
+  createSmartTableOperation(tableId: string, sheetId: string, body: Body) { return this.post(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/operations`, body); }
+  getSmartTableOperation(tableId: string, sheetId: string, operationId: string) { return this.get(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/operations/${this.enc(operationId)}`); }
+  cancelSmartTableOperation(tableId: string, sheetId: string, operationId: string) { return this.del(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/operations/${this.enc(operationId)}`); }
+  getSmartTableScore(tableId: string, sheetId: string) { return this.get(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/score`); }
+  configureSmartTableScore(tableId: string, sheetId: string, body: Body) { return this.patch(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/score`, body); }
+  recalculateSmartTableScore(tableId: string, sheetId: string) { return this.post(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/score`); }
+  listSmartTableVersions(tableId: string, sheetId: string, params?: Body) { return this.get(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/versions`, params); }
+  getSmartTableVersion(tableId: string, sheetId: string, versionId: string) { return this.get(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/versions/${this.enc(versionId)}`); }
+  createSmartTableVersion(tableId: string, sheetId: string, body: Body) { return this.post(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/versions`, body); }
+  getSmartTableScoreHistory(tableId: string, sheetId: string, params?: Body) { return this.get(`/api/public/v2/tables/${this.enc(tableId)}/sheets/${this.enc(sheetId)}/versions/score-history`, params); }
+  listLegacySmartTableMigrations(params?: Body) {
+    const query = params ? { ...params } : undefined;
+    if (query && typeof query.source_id === "number") query.source_id = [query.source_id];
+    return this.get("/api/public/v2/tables/legacy-migrations", query);
+  }
+  previewLegacySmartTableMigration(params: Body) { return this.get("/api/public/v2/tables/legacy-migrations/preview", params); }
+  migrateLegacyToSmartTable(body: Body) { return this.post("/api/public/v2/tables/legacy-migrations", body); }
+  getLegacySmartTableMigrationJob(jobId: string) { return this.get(`/api/public/v2/tables/legacy-migrations/jobs/${this.enc(jobId)}`); }
 
   // Agents
   listWorkflows(params?: Body) { return this.get("/workflows", params); }
@@ -104,6 +120,13 @@ export class PromptLayerClient {
   getToolRegistry(identifier: string, params?: Body) { return this.get(`/api/public/v2/tool-registry/${this.enc(identifier)}`, params); }
   createToolRegistry(body: Body) { return this.post("/api/public/v2/tool-registry", body); }
   createToolVersion(identifier: string, body: Body) { return this.post(`/api/public/v2/tool-registry/${this.enc(identifier)}/versions`, body); }
+  testExecuteToolRegistry(identifier: string, body: Body, query?: Body) { return this.post(`/api/public/v2/tool-registry/${this.enc(identifier)}/test-execute${buildQueryParams(query)}`, body); }
+
+  // Env Vars (workspace + tool scopes)
+  listWorkspaceEnvVars() { return this.get("/api/public/v2/env-vars"); }
+  createWorkspaceEnvVar(body: Body) { return this.post("/api/public/v2/env-vars", body); }
+  listToolEnvVars(identifier: string) { return this.get(`/api/public/v2/tool-registry/${this.enc(identifier)}/env-vars`); }
+  createToolEnvVar(identifier: string, body: Body) { return this.post(`/api/public/v2/tool-registry/${this.enc(identifier)}/env-vars`, body); }
 
   // Folders
   createFolder(body: Body) { return this.post("/api/public/v2/folders", body); }

package/src/handlers.ts

@@ -4,6 +4,11 @@ import { createToolHandler } from "./utils.js";
 
 type Args = Record<string, unknown> & { api_key?: string };
 function body(args: Args) { const { api_key: _, ...rest } = args; return rest; }
+function omit(args: Args, ...keys: string[]) {
+  const rest = body(args);
+  for (const key of keys) delete rest[key];
+  return rest;
+}
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function registerAllTools(server: any) {
@@ -69,56 +74,125 @@ export function registerAllTools(server: any) {
   reg(t["create-spans-bulk"], (c, a) => c.createSpansBulk(body(a)),
     (r) => `Created ${(r as { spans?: unknown[] }).spans?.length ?? 0} span(s)`);
 
-  // Datasets
-  reg(t["list-datasets"], (c, a) => c.listDatasets(body(a)),
-    (r) => { const { datasets, total } = r as { datasets?: unknown[]; total?: number }; return `${datasets?.length ?? 0} dataset(s) (total: ${total ?? "?"})`; });
-  reg(t["create-dataset-group"], (c, a) => c.createDatasetGroup(body(a)), () => "Dataset group created");
-  reg(t["create-dataset-version-from-file"], (c, a) => c.createDatasetVersionFromFile(body(a)), () => "Dataset version from file initiated");
-  reg(t["create-dataset-version-from-filter-params"], (c, a) => c.createDatasetVersionFromFilterParams(body(a)), () => "Dataset version from history initiated");
-  reg(t["get-dataset-rows"],
-    (c, a) => { const { api_key: _, dataset_id, ...p } = a as { dataset_id: number; api_key?: string } & Args; return c.getDatasetRows(dataset_id, p); },
-    (r) => { const { rows, total, page, pages } = r as { rows?: unknown[]; total?: number; page?: number; pages?: number }; return `${rows?.length ?? 0} row(s) (page ${page ?? 1}/${pages ?? 1}, total ${total ?? "?"})`; });
-  reg(t["create-draft-dataset-version"], (c, a) => c.createDraftDatasetVersion(body(a)), () => "Draft dataset version created");
-  reg(t["add-request-log-to-dataset"], (c, a) => c.addRequestLogToDatasetVersion(body(a)), () => "Request log added to draft dataset");
-  reg(t["save-draft-dataset-version"], (c, a) => c.saveDraftDatasetVersion(body(a)), () => "Draft dataset save initiated");
-
-  // Evaluations
-  reg(t["list-evaluations"], (c, a) => c.listEvaluations(body(a)),
-    (r) => { const { items, total } = r as { items?: unknown[]; total?: number }; return `${items?.length ?? 0} evaluation(s) (total: ${total ?? "?"})`; });
-  reg(t["get-evaluation-rows"],
-    (c, a) => { const { api_key: _, evaluation_id, ...p } = a as { evaluation_id: number; api_key?: string } & Args; return c.getEvaluationRows(evaluation_id, p); },
-    (r) => { const { rows, total, page, pages } = r as { rows?: unknown[]; total?: number; page?: number; pages?: number }; return `${rows?.length ?? 0} row(s) (page ${page ?? 1}/${pages ?? 1}, total ${total ?? "?"})`; });
-  reg(t["create-report"], (c, a) => c.createReport(body(a)),
-    (r) => { const id = (r as { report_id?: number }).report_id; return id ? `Pipeline created (ID: ${id})` : "Pipeline created"; });
-  reg(t["run-report"],
-    (c, a) => { const { api_key: _, report_id, ...b } = a as { report_id: number; api_key?: string } & Args; return c.runReport(report_id, b); },
-    () => "Evaluation run started");
-  reg(t["get-report"],
-    (c, a) => c.getReport((a as { report_id: number }).report_id),
-    () => "Evaluation retrieved");
-  reg(t["get-report-score"],
-    (c, a) => c.getReportScore((a as { report_id: number }).report_id),
-    (r) => { const s = (r as { score?: number }).score; return s !== undefined ? `Score: ${s}` : "Score retrieved"; });
-  reg(t["update-report-score-card"],
-    (c, a) => { const { api_key: _, report_id, ...b } = a as { report_id: number; api_key?: string } & Args; return c.updateReportScoreCard(report_id, b); },
-    () => "Score card updated");
-  reg(t["delete-reports-by-name"],
-    (c, a) => c.deleteReportsByName((a as { report_name: string }).report_name),
-    () => "Reports archived");
-  reg(t["delete-report"],
-    (c, a) => c.deleteReport((a as { report_id: number }).report_id),
-    () => "Evaluation pipeline archived");
-  reg(t["rename-report"],
-    (c, a) => { const { api_key: _, report_id, ...b } = a as { report_id: number; api_key?: string } & Args; return c.renameReport(report_id, b); },
-    () => "Evaluation pipeline updated");
-  reg(t["add-report-column"], (c, a) => c.addReportColumn(body(a)),
-    (r) => { const id = (r as { report_column?: { id?: number } }).report_column?.id; return id ? `Column added (ID: ${id})` : "Column added"; });
-  reg(t["edit-report-column"],
-    (c, a) => { const { api_key: _, report_column_id, ...b } = a as { report_column_id: number; api_key?: string } & Args; return c.editReportColumn(report_column_id, b); },
-    () => "Column updated");
-  reg(t["delete-report-column"],
-    (c, a) => c.deleteReportColumn((a as { report_column_id: number }).report_column_id),
-    () => "Column deleted");
+  // Smart Tables
+  reg(t["list-smart-tables"], (c, a) => c.listSmartTables(body(a)),
+    (r) => `${(r as { data?: unknown[] }).data?.length ?? 0} table(s)`);
+  reg(t["create-smart-table"], (c, a) => c.createSmartTable(body(a)),
+    (r) => {
+      const table = (r as { table?: { id?: string; title?: string } }).table;
+      return table?.id ? `Table "${table.title ?? ""}" created (${table.id})` : "Table created";
+    });
+  reg(t["get-smart-table"],
+    (c, a) => c.getSmartTable(a.table_id as string),
+    (r) => `Table "${(r as { table?: { title?: string } }).table?.title ?? ""}" retrieved`);
+  reg(t["update-smart-table"],
+    (c, a) => c.updateSmartTable(a.table_id as string, omit(a, "table_id")),
+    () => "Table updated");
+  reg(t["list-smart-table-sheets"],
+    (c, a) => c.listSmartTableSheets(a.table_id as string, omit(a, "table_id")),
+    (r) => `${(r as { data?: unknown[] }).data?.length ?? 0} sheet(s)`);
+  reg(t["create-smart-table-sheet"],
+    (c, a) => c.createSmartTableSheet(a.table_id as string, omit(a, "table_id")),
+    (r) => {
+      const op = (r as { operation_id?: string }).operation_id;
+      return op ? `Sheet import started (${op})` : "Sheet created";
+    });
+  reg(t["get-smart-table-sheet"],
+    (c, a) => c.getSmartTableSheet(a.table_id as string, a.sheet_id as string),
+    () => "Sheet retrieved");
+  reg(t["update-smart-table-sheet"],
+    (c, a) => c.updateSmartTableSheet(a.table_id as string, a.sheet_id as string, omit(a, "table_id", "sheet_id")),
+    () => "Sheet updated");
+  reg(t["get-smart-table-sheet-import-operation"],
+    (c, a) => c.getSmartTableSheetImportOperation(a.table_id as string, a.operation_id as string),
+    (r) => `Import operation ${(r as { operation?: { status?: string } }).operation?.status ?? "retrieved"}`);
+  reg(t["import-smart-table-sheet-file"],
+    (c, a) => c.importSmartTableSheetFile(a.table_id as string, a.sheet_id as string, omit(a, "table_id", "sheet_id")),
+    (r) => `File import started (${(r as { operation_id?: string }).operation_id ?? "operation queued"})`);
+  reg(t["import-smart-table-sheet-request-logs"],
+    (c, a) => c.importSmartTableSheetRequestLogs(a.table_id as string, a.sheet_id as string, omit(a, "table_id", "sheet_id")),
+    (r) => `Request-log import started (${(r as { operation_id?: string }).operation_id ?? "operation queued"})`);
+  reg(t["list-smart-table-columns"],
+    (c, a) => c.listSmartTableColumns(a.table_id as string, a.sheet_id as string, omit(a, "table_id", "sheet_id")),
+    (r) => `${(r as { data?: unknown[] }).data?.length ?? 0} column(s)`);
+  reg(t["create-smart-table-column"],
+    (c, a) => c.createSmartTableColumn(a.table_id as string, a.sheet_id as string, omit(a, "table_id", "sheet_id")),
+    (r) => `Column created${(r as { column?: { id?: string } }).column?.id ? ` (${(r as { column?: { id?: string } }).column?.id})` : ""}`);
+  reg(t["update-smart-table-column"],
+    (c, a) => c.updateSmartTableColumn(a.table_id as string, a.sheet_id as string, a.column_id as string, omit(a, "table_id", "sheet_id", "column_id")),
+    (r) => (r as { requires_recalculation?: boolean }).requires_recalculation ? "Column updated; recalculation required" : "Column updated");
+  reg(t["list-smart-table-rows"],
+    (c, a) => c.listSmartTableRows(a.table_id as string, a.sheet_id as string, omit(a, "table_id", "sheet_id")),
+    (r) => `${(r as { data?: unknown[] }).data?.length ?? 0} row(s)`);
+  reg(t["add-smart-table-rows"],
+    (c, a) => c.addSmartTableRows(a.table_id as string, a.sheet_id as string, omit(a, "table_id", "sheet_id")),
+    (r) => `${(r as { rows?: unknown[]; data?: unknown[] }).rows?.length ?? (r as { data?: unknown[] }).data?.length ?? 0} row(s) added`);
+  reg(t["get-smart-table-cell"],
+    (c, a) => c.getSmartTableCell(a.table_id as string, a.sheet_id as string, a.cell_id as string),
+    () => "Cell retrieved");
+  reg(t["update-smart-table-cell"],
+    (c, a) => c.updateSmartTableCell(a.table_id as string, a.sheet_id as string, a.cell_id as string, omit(a, "table_id", "sheet_id", "cell_id")),
+    () => "Cell updated");
+  reg(t["recalculate-smart-table-cell"],
+    (c, a) => c.recalculateSmartTableCell(a.table_id as string, a.sheet_id as string, a.cell_id as string),
+    (r) => `${(r as { cell_count?: number }).cell_count ?? 0} cell(s) queued`);
+  reg(t["recalculate-smart-table-cells"],
+    (c, a) => c.recalculateSmartTableCells(a.table_id as string, a.sheet_id as string, omit(a, "table_id", "sheet_id")),
+    (r) => `${(r as { cell_count?: number }).cell_count ?? 0} cell(s) queued`);
+  reg(t["list-smart-table-operations"],
+    (c, a) => c.listSmartTableOperations(a.table_id as string, a.sheet_id as string),
+    (r) => `${(r as { active_operations?: unknown[] }).active_operations?.length ?? 0} active operation(s)`);
+  reg(t["create-smart-table-operation"],
+    (c, a) => c.createSmartTableOperation(a.table_id as string, a.sheet_id as string, omit(a, "table_id", "sheet_id")),
+    (r) => {
+      const op = (r as { operation_id?: string; cell_count?: number }).operation_id;
+      return op ? `Operation started (${op})` : `${(r as { cell_count?: number }).cell_count ?? 0} cell(s) affected`;
+    });
+  reg(t["get-smart-table-operation"],
+    (c, a) => c.getSmartTableOperation(a.table_id as string, a.sheet_id as string, a.operation_id as string),
+    (r) => `Operation ${(r as { operation?: { status?: string } }).operation?.status ?? "retrieved"}`);
+  reg(t["cancel-smart-table-operation"],
+    (c, a) => c.cancelSmartTableOperation(a.table_id as string, a.sheet_id as string, a.operation_id as string),
+    (r) => `${(r as { cancelled_cell_count?: number }).cancelled_cell_count ?? 0} cell(s) cancelled`);
+  reg(t["get-smart-table-score"],
+    (c, a) => c.getSmartTableScore(a.table_id as string, a.sheet_id as string),
+    (r) => `Score ${(r as { status?: string | null }).status ?? "retrieved"}`);
+  reg(t["configure-smart-table-score"],
+    (c, a) => c.configureSmartTableScore(a.table_id as string, a.sheet_id as string, omit(a, "table_id", "sheet_id")),
+    () => "Score configured; recalculation required");
+  reg(t["recalculate-smart-table-score"],
+    (c, a) => c.recalculateSmartTableScore(a.table_id as string, a.sheet_id as string),
+    (r) => `Score recalculation ${(r as { status?: string }).status ?? "queued"}`);
+  reg(t["list-smart-table-versions"],
+    (c, a) => c.listSmartTableVersions(a.table_id as string, a.sheet_id as string, omit(a, "table_id", "sheet_id")),
+    (r) => `${(r as { data?: unknown[] }).data?.length ?? 0} version(s)`);
+  reg(t["get-smart-table-version"],
+    (c, a) => c.getSmartTableVersion(a.table_id as string, a.sheet_id as string, a.version_id as string),
+    () => "Version retrieved");
+  reg(t["create-smart-table-version"],
+    (c, a) => c.createSmartTableVersion(a.table_id as string, a.sheet_id as string, omit(a, "table_id", "sheet_id")),
+    (r) => `Version ${(r as { version?: { version_number?: number } }).version?.version_number ?? "created"}`);
+  reg(t["get-smart-table-score-history"],
+    (c, a) => c.getSmartTableScoreHistory(a.table_id as string, a.sheet_id as string, omit(a, "table_id", "sheet_id")),
+    (r) => `${(r as { score_history?: { returned_points?: number } }).score_history?.returned_points ?? 0} score point(s)`);
+  reg(t["list-legacy-smart-table-migrations"],
+    (c, a) => c.listLegacySmartTableMigrations(body(a)),
+    (r) => `${(r as { legacy_migrations?: unknown[] }).legacy_migrations?.length ?? 0} migration mapping(s)`);
+  reg(t["preview-legacy-smart-table-migration"],
+    (c, a) => c.previewLegacySmartTableMigration(body(a)),
+    (r) => {
+      const counts = (r as { estimated_counts?: { sheets?: number; columns?: number; cells?: number } }).estimated_counts;
+      return counts ? `Preview: ${counts.sheets ?? 0} sheet(s), ${counts.columns ?? 0} column(s), ${counts.cells ?? 0} cell(s)` : "Migration preview retrieved";
+    });
+  reg(t["migrate-legacy-to-smart-table"],
+    (c, a) => c.migrateLegacyToSmartTable(body(a)),
+    (r) => {
+      const job = (r as { job_id?: string; dry_run?: boolean }).job_id;
+      return (r as { dry_run?: boolean }).dry_run ? "Migration dry run complete" : `Migration queued${job ? ` (${job})` : ""}`;
+    });
+  reg(t["get-legacy-smart-table-migration-job"],
+    (c, a) => c.getLegacySmartTableMigrationJob(a.job_id as string),
+    (r) => `Migration job ${(r as { status?: string }).status ?? "retrieved"}`);
 
   // Agents
   reg(t["list-workflows"], (c, a) => c.listWorkflows(body(a)), () => "Agents listed");
@@ -150,6 +224,32 @@ export function registerAllTools(server: any) {
   reg(t["create-tool-version"],
     (c, a) => { const { api_key: _, identifier, ...b } = a as { identifier: string; api_key?: string } & Args; return c.createToolVersion(identifier, b); },
     (r) => { const v = (r as { version?: { number?: number } }).version; return v ? `Version ${v.number} created` : "Version created"; });
+  reg(t["test-execute-tool-registry"],
+    (c, a) => {
+      const { api_key: _, identifier, label, version, ...rest } = a as { identifier: string; api_key?: string; label?: string; version?: number } & Args;
+      const query: Record<string, unknown> = {};
+      if (label !== undefined) query.label = label;
+      if (version !== undefined) query.version = version;
+      return c.testExecuteToolRegistry(identifier, rest, query);
+    },
+    (r) => {
+      const res = (r as { result?: { status?: string; duration_ms?: number; error?: { message?: string } } }).result;
+      if (!res) return "Tool executed";
+      if (res.status === "error") return `Tool failed: ${res.error?.message ?? "unknown error"}`;
+      return `Tool executed (${res.duration_ms ?? 0} ms)`;
+    });
+
+  // Env Vars
+  reg(t["list-workspace-env-vars"], (c) => c.listWorkspaceEnvVars(),
+    (r) => { const v = (r as { workspace_env_vars?: unknown[] }).workspace_env_vars; return `${v?.length ?? 0} workspace env var(s)`; });
+  reg(t["create-workspace-env-var"], (c, a) => c.createWorkspaceEnvVar({ ...body(a), value: "" }),
+    (r) => { const v = (r as { workspace_env_var?: { key?: string; id?: number } }).workspace_env_var; return v ? `Workspace env var "${v.key}" scaffolded (ID: ${v.id}) — set the value in Settings` : "Workspace env var scaffolded"; });
+  reg(t["list-tool-env-vars"],
+    (c, a) => c.listToolEnvVars((a as { identifier: string }).identifier),
+    (r) => { const v = (r as { tool_env_vars?: unknown[] }).tool_env_vars; return `${v?.length ?? 0} tool env var(s)`; });
+  reg(t["create-tool-env-var"],
+    (c, a) => { const { api_key: _, identifier, ...b } = a as { identifier: string; api_key?: string } & Args; return c.createToolEnvVar(identifier, { ...b, value: "" }); },
+    (r) => { const v = (r as { tool_env_var?: { key?: string; id?: number } }).tool_env_var; return v ? `Tool env var "${v.key}" scaffolded (ID: ${v.id}) — set the value in Settings` : "Tool env var scaffolded"; });
 
   // Folders
   reg(t["create-folder"], (c, a) => c.createFolder(body(a)), () => "Folder created");

package/src/index.ts

@@ -13,9 +13,10 @@ PromptLayer is a prompt management and observability platform. This MCP server l
 - **Snippet**: A reusable prompt fragment referenced inside prompt templates with @@@snippet_name@@@ markers. Snippets are themselves prompt templates (with type "completion"). When a prompt is fetched, snippets are expanded inline by default.
 - **Release label**: A pointer (e.g. "prod", "staging") attached to a specific prompt version. Move labels between versions for deployment.
 - **Agent** (backend name: workflow): A multi-step pipeline of nodes. Each node has a type, configuration, and dependencies. Agents are versioned like prompts.
-- **Evaluation pipeline** (backend name: report): Runs evaluation columns against a dataset and produces scores. Columns can be LLM assertions, code execution, comparisons, etc.
-- **Dataset**: A versioned collection of test rows. Belongs to a dataset group. Versions can be created from CSV/JSON files or by filtering request log history.
-- **Folder**: Organizes prompts, agents, datasets, evaluations, and other entities into a hierarchy.
+- **Smart Table**: The primary workspace for test data, evaluation columns, request-log imports, execution, scoring, and version history.
+- **Smart Table sheet**: A tab inside a Smart Table. Sheets contain rows, columns, cells, operations, score configuration, and saved versions.
+- **Legacy dataset/evaluation**: Older dataset and report resources. Tools for these remain available for compatibility, but prefer Smart Tables for new work.
+- **Folder**: Organizes prompts, agents, Smart Tables, and other entities into a hierarchy.
 
 ## Working with prompts and snippets
 
@@ -25,9 +26,13 @@ When publishing back, keep @@@snippet_name@@@ markers intact in the prompt_templ
 
 Use get-prompt-template (the POST variant) only when you need a fully rendered prompt ready to send to an LLM, with input_variables filled in and provider-specific formatting applied.
 
-## Working with evaluations
+## Working with Smart Tables
 
-The recommended way to create an evaluation pipeline is with LLM assertion columns — these use a language model to score each dataset row. For details on all available column types (LLM assertion, code execution, comparison, etc.), search the PromptLayer docs or see https://docs.promptlayer.com/features/evaluations/column-types.
+For new dataset or evaluation-style workflows, use Smart Tables instead of legacy datasets and reports. A typical flow is: create-smart-table, add or import sheets, create columns, add rows or import request logs, run recalculation operations, configure sheet scoring, and save versions.
+
+Use uppercase Smart Table column type values such as TEXT, PROMPT_TEMPLATE, LLM_ASSERTION, CODE_EXECUTION, and COMPOSITION. Direct cell edits are for text cells; computed cells should be recalculated with cell or sheet operation tools.
+
+Use the legacy migration tools to preview or convert existing dataset groups, datasets, and reports into Smart Tables.
 
 ## Additional documentation