@llmops/core 0.3.3 → 0.4.0-beta.1

package/dist/index.cjs

@@ -1,5 +1,5 @@
-const require_db = require('./db-BF1a1duC.cjs');
-const require_neon_dialect = require('./neon-dialect-BQsMY2pg.cjs');
+const require_db = require('./db-Sv8HPCfx.cjs');
+const require_neon_dialect = require('./neon-dialect-CN5kb3Gw.cjs');
 let __llmops_gateway = require("@llmops/gateway");
 __llmops_gateway = require_db.__toESM(__llmops_gateway);
 let kysely = require("kysely");
@@ -1055,7 +1055,8 @@ const createConfigDataLayer = (db) => {
 				...row,
 				provider: null,
 				modelName: null,
-				jsonData: null
+				jsonData: null,
+				variantVersionId: null
 			}));
 			const latestVersions = await Promise.all(variantIds.map((variantId) => db.selectFrom("variant_versions").selectAll().where("variantId", "=", variantId).orderBy("version", "desc").limit(1).executeTakeFirst()));
 			const versionMap = new Map(latestVersions.filter((v) => v !== void 0).map((v) => [v.variantId, v]));
@@ -1065,7 +1066,8 @@ const createConfigDataLayer = (db) => {
 					...row,
 					provider: version?.provider ?? null,
 					modelName: version?.modelName ?? null,
-					jsonData: version?.jsonData ?? null
+					jsonData: version?.jsonData ?? null,
+					variantVersionId: version?.id ?? null
 				};
 			});
 		}
@@ -1303,6 +1305,215 @@ const createConfigVariantDataLayer = (db) => {
 	};
 };
 
+//#endregion
+//#region src/datalayer/datasets.ts
+const createDataset = require_db.zod_default.object({
+	name: require_db.zod_default.string(),
+	description: require_db.zod_default.string().nullable().optional()
+});
+const updateDataset = require_db.zod_default.object({
+	datasetId: require_db.zod_default.string().uuid(),
+	name: require_db.zod_default.string().optional(),
+	description: require_db.zod_default.string().nullable().optional()
+});
+const getDatasetById = require_db.zod_default.object({ datasetId: require_db.zod_default.string().uuid() });
+const deleteDataset = require_db.zod_default.object({ datasetId: require_db.zod_default.string().uuid() });
+const listDatasets = require_db.zod_default.object({
+	limit: require_db.zod_default.number().int().positive().optional(),
+	offset: require_db.zod_default.number().int().nonnegative().optional()
+});
+const createRecord = require_db.zod_default.object({
+	datasetId: require_db.zod_default.string().uuid(),
+	input: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()),
+	expected: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).nullable().optional(),
+	metadata: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).optional()
+});
+const updateRecord = require_db.zod_default.object({
+	recordId: require_db.zod_default.string().uuid(),
+	input: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).optional(),
+	expected: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).nullable().optional(),
+	metadata: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).optional()
+});
+const deleteRecord = require_db.zod_default.object({ recordId: require_db.zod_default.string().uuid() });
+const listRecords = require_db.zod_default.object({
+	datasetId: require_db.zod_default.string().uuid(),
+	limit: require_db.zod_default.number().int().positive().optional(),
+	offset: require_db.zod_default.number().int().nonnegative().optional()
+});
+const createVersion = require_db.zod_default.object({
+	datasetId: require_db.zod_default.string().uuid(),
+	name: require_db.zod_default.string().nullable().optional(),
+	description: require_db.zod_default.string().nullable().optional()
+});
+const getVersionById = require_db.zod_default.object({ versionId: require_db.zod_default.string().uuid() });
+const listVersions = require_db.zod_default.object({
+	datasetId: require_db.zod_default.string().uuid(),
+	limit: require_db.zod_default.number().int().positive().optional(),
+	offset: require_db.zod_default.number().int().nonnegative().optional()
+});
+const getVersionRecords = require_db.zod_default.object({
+	versionId: require_db.zod_default.string().uuid(),
+	limit: require_db.zod_default.number().int().positive().optional(),
+	offset: require_db.zod_default.number().int().nonnegative().optional()
+});
+const createDatasetsDataLayer = (db) => {
+	return {
+		createDataset: async (params) => {
+			const value = await createDataset.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { name, description } = value.data;
+			return db.insertInto("datasets").values({
+				id: (0, node_crypto.randomUUID)(),
+				name,
+				description: description ?? null,
+				recordCount: 0,
+				latestVersionNumber: 1,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}).returningAll().executeTakeFirst();
+		},
+		updateDataset: async (params) => {
+			const value = await updateDataset.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { datasetId, name, description } = value.data;
+			const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+			if (name !== void 0) updateData.name = name;
+			if (description !== void 0) updateData.description = description;
+			return db.updateTable("datasets").set(updateData).where("id", "=", datasetId).returningAll().executeTakeFirst();
+		},
+		getDatasetById: async (params) => {
+			const value = await getDatasetById.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { datasetId } = value.data;
+			return db.selectFrom("datasets").selectAll().where("id", "=", datasetId).executeTakeFirst();
+		},
+		deleteDataset: async (params) => {
+			const value = await deleteDataset.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { datasetId } = value.data;
+			await db.deleteFrom("dataset_version_records").where("datasetVersionId", "in", db.selectFrom("dataset_versions").select("id").where("datasetId", "=", datasetId)).execute();
+			await db.deleteFrom("dataset_versions").where("datasetId", "=", datasetId).execute();
+			await db.deleteFrom("dataset_records").where("datasetId", "=", datasetId).execute();
+			return db.deleteFrom("datasets").where("id", "=", datasetId).returningAll().executeTakeFirst();
+		},
+		listDatasets: async (params) => {
+			const value = await listDatasets.safeParseAsync(params || {});
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { limit = 100, offset = 0 } = value.data;
+			return db.selectFrom("datasets").selectAll().orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
+		},
+		countDatasets: async () => {
+			const result = await db.selectFrom("datasets").select(db.fn.countAll().as("count")).executeTakeFirst();
+			return Number(result?.count ?? 0);
+		},
+		createRecord: async (params) => {
+			const value = await createRecord.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { datasetId, input, expected, metadata } = value.data;
+			const record$1 = await db.insertInto("dataset_records").values({
+				id: (0, node_crypto.randomUUID)(),
+				datasetId,
+				input: JSON.stringify(input),
+				expected: expected ? JSON.stringify(expected) : null,
+				metadata: JSON.stringify(metadata || {}),
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}).returningAll().executeTakeFirst();
+			await db.updateTable("datasets").set((eb) => ({
+				recordCount: eb("recordCount", "+", 1),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			})).where("id", "=", datasetId).execute();
+			return record$1;
+		},
+		updateRecord: async (params) => {
+			const value = await updateRecord.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { recordId, input, expected, metadata } = value.data;
+			const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+			if (input !== void 0) updateData.input = JSON.stringify(input);
+			if (expected !== void 0) updateData.expected = expected ? JSON.stringify(expected) : null;
+			if (metadata !== void 0) updateData.metadata = JSON.stringify(metadata);
+			return db.updateTable("dataset_records").set(updateData).where("id", "=", recordId).returningAll().executeTakeFirst();
+		},
+		deleteRecord: async (params) => {
+			const value = await deleteRecord.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { recordId } = value.data;
+			const record$1 = await db.selectFrom("dataset_records").select(["datasetId"]).where("id", "=", recordId).executeTakeFirst();
+			if (!record$1) throw new LLMOpsError("Record not found");
+			await db.deleteFrom("dataset_version_records").where("datasetRecordId", "=", recordId).execute();
+			const deleted = await db.deleteFrom("dataset_records").where("id", "=", recordId).returningAll().executeTakeFirst();
+			await db.updateTable("datasets").set((eb) => ({
+				recordCount: eb("recordCount", "-", 1),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			})).where("id", "=", record$1.datasetId).execute();
+			return deleted;
+		},
+		listRecords: async (params) => {
+			const value = await listRecords.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { datasetId, limit = 100, offset = 0 } = value.data;
+			return db.selectFrom("dataset_records").selectAll().where("datasetId", "=", datasetId).orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
+		},
+		getRecordById: async (recordId) => {
+			return db.selectFrom("dataset_records").selectAll().where("id", "=", recordId).executeTakeFirst();
+		},
+		createVersion: async (params) => {
+			const value = await createVersion.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { datasetId, name, description } = value.data;
+			const dataset = await db.selectFrom("datasets").select(["latestVersionNumber", "recordCount"]).where("id", "=", datasetId).executeTakeFirst();
+			if (!dataset) throw new LLMOpsError("Dataset not found");
+			const newVersionNumber = dataset.latestVersionNumber + 1;
+			const recordIds = (await db.selectFrom("dataset_records").select(["id"]).where("datasetId", "=", datasetId).orderBy("createdAt", "asc").execute()).map((r) => r.id);
+			const snapshotHash = (0, node_crypto.createHash)("sha256").update(recordIds.join(",")).digest("hex");
+			const versionId = (0, node_crypto.randomUUID)();
+			const version = await db.insertInto("dataset_versions").values({
+				id: versionId,
+				datasetId,
+				versionNumber: newVersionNumber,
+				name: name ?? null,
+				description: description ?? null,
+				recordCount: dataset.recordCount,
+				snapshotHash,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}).returningAll().executeTakeFirst();
+			if (recordIds.length > 0) await db.insertInto("dataset_version_records").values(recordIds.map((recordId, index) => ({
+				id: (0, node_crypto.randomUUID)(),
+				datasetVersionId: versionId,
+				datasetRecordId: recordId,
+				position: index,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}))).execute();
+			await db.updateTable("datasets").set({
+				latestVersionNumber: newVersionNumber,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}).where("id", "=", datasetId).execute();
+			return version;
+		},
+		getVersionById: async (params) => {
+			const value = await getVersionById.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { versionId } = value.data;
+			return db.selectFrom("dataset_versions").selectAll().where("id", "=", versionId).executeTakeFirst();
+		},
+		listVersions: async (params) => {
+			const value = await listVersions.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { datasetId, limit = 100, offset = 0 } = value.data;
+			return db.selectFrom("dataset_versions").selectAll().where("datasetId", "=", datasetId).orderBy("versionNumber", "desc").limit(limit).offset(offset).execute();
+		},
+		getVersionRecords: async (params) => {
+			const value = await getVersionRecords.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { versionId, limit = 100, offset = 0 } = value.data;
+			return db.selectFrom("dataset_version_records").innerJoin("dataset_records", "dataset_records.id", "dataset_version_records.datasetRecordId").selectAll("dataset_records").select("dataset_version_records.position").where("dataset_version_records.datasetVersionId", "=", versionId).orderBy("dataset_version_records.position", "asc").limit(limit).offset(offset).execute();
+		}
+	};
+};
+
 //#endregion
 //#region src/datalayer/environments.ts
 const createNewEnvironment = require_db.zod_default.object({
@@ -1931,6 +2142,300 @@ const createLLMRequestsDataLayer = (db) => {
 	};
 };
 
+//#endregion
+//#region src/datalayer/playgrounds.ts
+const createNewPlayground = require_db.zod_default.object({
+	name: require_db.zod_default.string(),
+	datasetId: require_db.zod_default.string().uuid().nullable().optional(),
+	columns: require_db.zod_default.array(require_db.playgroundColumnSchema).nullable().optional()
+});
+const updatePlayground = require_db.zod_default.object({
+	playgroundId: require_db.zod_default.uuidv4(),
+	name: require_db.zod_default.string().optional(),
+	datasetId: require_db.zod_default.string().uuid().nullable().optional(),
+	columns: require_db.zod_default.array(require_db.playgroundColumnSchema).nullable().optional()
+});
+const getPlaygroundById = require_db.zod_default.object({ playgroundId: require_db.zod_default.uuidv4() });
+const deletePlayground = require_db.zod_default.object({ playgroundId: require_db.zod_default.uuidv4() });
+const listPlaygrounds = require_db.zod_default.object({
+	limit: require_db.zod_default.number().int().positive().optional(),
+	offset: require_db.zod_default.number().int().nonnegative().optional()
+});
+const createPlaygroundDataLayer = (db) => {
+	return {
+		createNewPlayground: async (params) => {
+			const value = await createNewPlayground.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { name, datasetId, columns } = value.data;
+			return db.insertInto("playgrounds").values({
+				id: (0, node_crypto.randomUUID)(),
+				name,
+				datasetId: datasetId ?? null,
+				columns: columns ? JSON.stringify(columns) : null,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}).returningAll().executeTakeFirst();
+		},
+		updatePlayground: async (params) => {
+			const value = await updatePlayground.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { playgroundId, name, datasetId, columns } = value.data;
+			const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+			if (name !== void 0) updateData.name = name;
+			if (datasetId !== void 0) updateData.datasetId = datasetId;
+			if (columns !== void 0) updateData.columns = columns ? JSON.stringify(columns) : null;
+			return db.updateTable("playgrounds").set(updateData).where("id", "=", playgroundId).returningAll().executeTakeFirst();
+		},
+		getPlaygroundById: async (params) => {
+			const value = await getPlaygroundById.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { playgroundId } = value.data;
+			return db.selectFrom("playgrounds").selectAll().where("id", "=", playgroundId).executeTakeFirst();
+		},
+		deletePlayground: async (params) => {
+			const value = await deletePlayground.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { playgroundId } = value.data;
+			return db.deleteFrom("playgrounds").where("id", "=", playgroundId).returningAll().executeTakeFirst();
+		},
+		listPlaygrounds: async (params) => {
+			const value = await listPlaygrounds.safeParseAsync(params || {});
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { limit = 100, offset = 0 } = value.data;
+			return db.selectFrom("playgrounds").selectAll().orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
+		},
+		countPlaygrounds: async () => {
+			const result = await db.selectFrom("playgrounds").select(db.fn.countAll().as("count")).executeTakeFirst();
+			return Number(result?.count ?? 0);
+		}
+	};
+};
+
+//#endregion
+//#region src/datalayer/playgroundResults.ts
+const createPlaygroundResult = require_db.zod_default.object({
+	runId: require_db.zod_default.string().uuid(),
+	columnId: require_db.zod_default.string().uuid(),
+	datasetRecordId: require_db.zod_default.string().uuid().nullable().optional(),
+	inputVariables: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).default({}),
+	status: require_db.zod_default.enum([
+		"pending",
+		"running",
+		"completed",
+		"failed"
+	]).default("pending")
+});
+const createPlaygroundResultsBatch = require_db.zod_default.object({ results: require_db.zod_default.array(createPlaygroundResult) });
+const updatePlaygroundResult = require_db.zod_default.object({
+	resultId: require_db.zod_default.string().uuid(),
+	outputContent: require_db.zod_default.string().nullable().optional(),
+	status: require_db.zod_default.enum([
+		"pending",
+		"running",
+		"completed",
+		"failed"
+	]).optional(),
+	error: require_db.zod_default.string().nullable().optional(),
+	latencyMs: require_db.zod_default.number().int().nullable().optional(),
+	promptTokens: require_db.zod_default.number().int().nullable().optional(),
+	completionTokens: require_db.zod_default.number().int().nullable().optional(),
+	totalTokens: require_db.zod_default.number().int().nullable().optional(),
+	cost: require_db.zod_default.number().int().nullable().optional()
+});
+const getPlaygroundResultById = require_db.zod_default.object({ resultId: require_db.zod_default.string().uuid() });
+const listPlaygroundResults = require_db.zod_default.object({
+	runId: require_db.zod_default.string().uuid(),
+	columnId: require_db.zod_default.string().uuid().optional(),
+	limit: require_db.zod_default.number().int().positive().optional(),
+	offset: require_db.zod_default.number().int().nonnegative().optional()
+});
+const deletePlaygroundResultsByRunId = require_db.zod_default.object({ runId: require_db.zod_default.string().uuid() });
+const createPlaygroundResultsDataLayer = (db) => {
+	return {
+		createPlaygroundResult: async (params) => {
+			const value = await createPlaygroundResult.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { runId, columnId, datasetRecordId, inputVariables, status } = value.data;
+			return db.insertInto("playground_results").values({
+				id: (0, node_crypto.randomUUID)(),
+				runId,
+				columnId,
+				datasetRecordId: datasetRecordId ?? null,
+				inputVariables: JSON.stringify(inputVariables),
+				outputContent: null,
+				status,
+				error: null,
+				latencyMs: null,
+				promptTokens: null,
+				completionTokens: null,
+				totalTokens: null,
+				cost: null,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}).returningAll().executeTakeFirst();
+		},
+		createPlaygroundResultsBatch: async (params) => {
+			const value = await createPlaygroundResultsBatch.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { results } = value.data;
+			if (results.length === 0) return [];
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const values = results.map((result) => ({
+				id: (0, node_crypto.randomUUID)(),
+				runId: result.runId,
+				columnId: result.columnId,
+				datasetRecordId: result.datasetRecordId ?? null,
+				inputVariables: JSON.stringify(result.inputVariables),
+				outputContent: null,
+				status: result.status,
+				error: null,
+				latencyMs: null,
+				promptTokens: null,
+				completionTokens: null,
+				totalTokens: null,
+				cost: null,
+				createdAt: now,
+				updatedAt: now
+			}));
+			return db.insertInto("playground_results").values(values).returningAll().execute();
+		},
+		updatePlaygroundResult: async (params) => {
+			const value = await updatePlaygroundResult.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { resultId, outputContent, status, error, latencyMs, promptTokens, completionTokens, totalTokens, cost } = value.data;
+			const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+			if (outputContent !== void 0) updateData.outputContent = outputContent;
+			if (status !== void 0) updateData.status = status;
+			if (error !== void 0) updateData.error = error;
+			if (latencyMs !== void 0) updateData.latencyMs = latencyMs;
+			if (promptTokens !== void 0) updateData.promptTokens = promptTokens;
+			if (completionTokens !== void 0) updateData.completionTokens = completionTokens;
+			if (totalTokens !== void 0) updateData.totalTokens = totalTokens;
+			if (cost !== void 0) updateData.cost = cost;
+			return db.updateTable("playground_results").set(updateData).where("id", "=", resultId).returningAll().executeTakeFirst();
+		},
+		getPlaygroundResultById: async (params) => {
+			const value = await getPlaygroundResultById.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { resultId } = value.data;
+			return db.selectFrom("playground_results").selectAll().where("id", "=", resultId).executeTakeFirst();
+		},
+		listPlaygroundResults: async (params) => {
+			const value = await listPlaygroundResults.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { runId, columnId, limit = 500, offset = 0 } = value.data;
+			let query = db.selectFrom("playground_results").selectAll().where("runId", "=", runId);
+			if (columnId) query = query.where("columnId", "=", columnId);
+			return query.orderBy("createdAt", "asc").limit(limit).offset(offset).execute();
+		},
+		deletePlaygroundResultsByRunId: async (params) => {
+			const value = await deletePlaygroundResultsByRunId.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { runId } = value.data;
+			return db.deleteFrom("playground_results").where("runId", "=", runId).returningAll().execute();
+		},
+		countPlaygroundResults: async (runId) => {
+			const result = await db.selectFrom("playground_results").select(db.fn.countAll().as("count")).where("runId", "=", runId).executeTakeFirst();
+			return Number(result?.count ?? 0);
+		},
+		countCompletedPlaygroundResults: async (runId) => {
+			const result = await db.selectFrom("playground_results").select(db.fn.countAll().as("count")).where("runId", "=", runId).where("status", "=", "completed").executeTakeFirst();
+			return Number(result?.count ?? 0);
+		}
+	};
+};
+
+//#endregion
+//#region src/datalayer/playgroundRuns.ts
+const createPlaygroundRun = require_db.zod_default.object({
+	playgroundId: require_db.zod_default.string().uuid(),
+	datasetId: require_db.zod_default.string().uuid().nullable().optional(),
+	datasetVersionId: require_db.zod_default.string().uuid().nullable().optional(),
+	status: require_db.zod_default.enum([
+		"pending",
+		"running",
+		"completed",
+		"failed",
+		"cancelled"
+	]).default("pending"),
+	totalRecords: require_db.zod_default.number().int().default(0)
+});
+const updatePlaygroundRun = require_db.zod_default.object({
+	runId: require_db.zod_default.string().uuid(),
+	status: require_db.zod_default.enum([
+		"pending",
+		"running",
+		"completed",
+		"failed",
+		"cancelled"
+	]).optional(),
+	startedAt: require_db.zod_default.date().nullable().optional(),
+	completedAt: require_db.zod_default.date().nullable().optional(),
+	completedRecords: require_db.zod_default.number().int().optional()
+});
+const getPlaygroundRunById = require_db.zod_default.object({ runId: require_db.zod_default.string().uuid() });
+const listPlaygroundRuns = require_db.zod_default.object({
+	playgroundId: require_db.zod_default.string().uuid(),
+	limit: require_db.zod_default.number().int().positive().optional(),
+	offset: require_db.zod_default.number().int().nonnegative().optional()
+});
+const deletePlaygroundRun = require_db.zod_default.object({ runId: require_db.zod_default.string().uuid() });
+const createPlaygroundRunsDataLayer = (db) => {
+	return {
+		createPlaygroundRun: async (params) => {
+			const value = await createPlaygroundRun.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { playgroundId, datasetId, datasetVersionId, status, totalRecords } = value.data;
+			return db.insertInto("playground_runs").values({
+				id: (0, node_crypto.randomUUID)(),
+				playgroundId,
+				datasetId: datasetId ?? null,
+				datasetVersionId: datasetVersionId ?? null,
+				status,
+				startedAt: null,
+				completedAt: null,
+				totalRecords,
+				completedRecords: 0,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}).returningAll().executeTakeFirst();
+		},
+		updatePlaygroundRun: async (params) => {
+			const value = await updatePlaygroundRun.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { runId, status, startedAt, completedAt, completedRecords } = value.data;
+			const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+			if (status !== void 0) updateData.status = status;
+			if (startedAt !== void 0) updateData.startedAt = startedAt?.toISOString() ?? null;
+			if (completedAt !== void 0) updateData.completedAt = completedAt?.toISOString() ?? null;
+			if (completedRecords !== void 0) updateData.completedRecords = completedRecords;
+			return db.updateTable("playground_runs").set(updateData).where("id", "=", runId).returningAll().executeTakeFirst();
+		},
+		getPlaygroundRunById: async (params) => {
+			const value = await getPlaygroundRunById.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { runId } = value.data;
+			return db.selectFrom("playground_runs").selectAll().where("id", "=", runId).executeTakeFirst();
+		},
+		listPlaygroundRuns: async (params) => {
+			const value = await listPlaygroundRuns.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { playgroundId, limit = 50, offset = 0 } = value.data;
+			return db.selectFrom("playground_runs").selectAll().where("playgroundId", "=", playgroundId).orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
+		},
+		deletePlaygroundRun: async (params) => {
+			const value = await deletePlaygroundRun.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { runId } = value.data;
+			return db.deleteFrom("playground_runs").where("id", "=", runId).returningAll().executeTakeFirst();
+		},
+		countPlaygroundRuns: async (playgroundId) => {
+			const result = await db.selectFrom("playground_runs").select(db.fn.countAll().as("count")).where("playgroundId", "=", playgroundId).executeTakeFirst();
+			return Number(result?.count ?? 0);
+		}
+	};
+};
+
 //#endregion
 //#region src/datalayer/providerConfigs.ts
 /**
@@ -2641,10 +3146,14 @@ const createDataLayer = async (db) => {
 	return {
 		...createConfigDataLayer(db),
 		...createConfigVariantDataLayer(db),
+		...createDatasetsDataLayer(db),
 		...createEnvironmentDataLayer(db),
 		...createEnvironmentSecretDataLayer(db),
 		...createGuardrailConfigsDataLayer(db),
 		...createLLMRequestsDataLayer(db),
+		...createPlaygroundDataLayer(db),
+		...createPlaygroundResultsDataLayer(db),
+		...createPlaygroundRunsDataLayer(db),
 		...createProviderConfigsDataLayer(db),
 		...createProviderGuardrailOverridesDataLayer(db),
 		...createTargetingRulesDataLayer(db),
@@ -3243,12 +3752,19 @@ exports.configsSchema = require_db.configsSchema;
 exports.createDataLayer = createDataLayer;
 exports.createDatabase = require_db.createDatabase;
 exports.createDatabaseFromConnection = require_db.createDatabaseFromConnection;
+exports.createDatasetsDataLayer = createDatasetsDataLayer;
 exports.createGuardrailConfigsDataLayer = createGuardrailConfigsDataLayer;
 exports.createLLMRequestsDataLayer = createLLMRequestsDataLayer;
 exports.createNeonDialect = require_neon_dialect.createNeonDialect;
+exports.createPlaygroundResultsDataLayer = createPlaygroundResultsDataLayer;
+exports.createPlaygroundRunsDataLayer = createPlaygroundRunsDataLayer;
 exports.createProviderConfigsDataLayer = createProviderConfigsDataLayer;
 exports.createProviderGuardrailOverridesDataLayer = createProviderGuardrailOverridesDataLayer;
 exports.createWorkspaceSettingsDataLayer = createWorkspaceSettingsDataLayer;
+exports.datasetRecordsSchema = require_db.datasetRecordsSchema;
+exports.datasetVersionRecordsSchema = require_db.datasetVersionRecordsSchema;
+exports.datasetVersionsSchema = require_db.datasetVersionsSchema;
+exports.datasetsSchema = require_db.datasetsSchema;
 exports.detectDatabaseType = require_db.detectDatabaseType;
 exports.dollarsToMicroDollars = dollarsToMicroDollars;
 exports.environmentSecretsSchema = require_db.environmentSecretsSchema;
@@ -3273,6 +3789,10 @@ exports.matchType = require_db.matchType;
 exports.microDollarsToDollars = microDollarsToDollars;
 exports.parsePartialTableData = require_db.parsePartialTableData;
 exports.parseTableData = require_db.parseTableData;
+exports.playgroundColumnSchema = require_db.playgroundColumnSchema;
+exports.playgroundResultsSchema = require_db.playgroundResultsSchema;
+exports.playgroundRunsSchema = require_db.playgroundRunsSchema;
+exports.playgroundsSchema = require_db.playgroundsSchema;
 exports.providerConfigsSchema = require_db.providerConfigsSchema;
 exports.providerGuardrailOverridesSchema = require_db.providerGuardrailOverridesSchema;
 exports.runAutoMigrations = require_db.runAutoMigrations;