@llmops/core 0.3.3 → 0.4.0-beta.1

package/dist/{db-BF1a1duC.cjs → db-Sv8HPCfx.cjs}

@@ -12966,6 +12966,101 @@ const providerConfigsSchema = object({
 	config: record(string$1(), unknown()),
 	enabled: boolean$1().default(true)
 });
+const playgroundColumnSchema = object({
+	id: string$1().uuid(),
+	name: string$1(),
+	position: number$1().int().min(0),
+	providerConfigId: union([string$1().uuid(), _null()]),
+	modelName: string$1(),
+	messages: array(object({
+		role: _enum([
+			"system",
+			"user",
+			"assistant"
+		]),
+		content: string$1()
+	})),
+	temperature: number$1().nullable().optional(),
+	maxTokens: number$1().int().nullable().optional(),
+	topP: number$1().nullable().optional(),
+	frequencyPenalty: number$1().nullable().optional(),
+	presencePenalty: number$1().nullable().optional(),
+	configId: string$1().uuid().nullable().optional(),
+	variantId: string$1().uuid().nullable().optional(),
+	variantVersionId: string$1().uuid().nullable().optional()
+});
+const playgroundsSchema = object({
+	...baseSchema,
+	name: string$1(),
+	datasetId: string$1().uuid().nullable().optional(),
+	columns: array(playgroundColumnSchema).nullable()
+});
+const playgroundRunsSchema = object({
+	...baseSchema,
+	playgroundId: string$1().uuid(),
+	datasetId: string$1().uuid().nullable(),
+	datasetVersionId: string$1().uuid().nullable(),
+	status: _enum([
+		"pending",
+		"running",
+		"completed",
+		"failed",
+		"cancelled"
+	]),
+	startedAt: date$1().nullable(),
+	completedAt: date$1().nullable(),
+	totalRecords: number$1().int().default(0),
+	completedRecords: number$1().int().default(0)
+});
+const playgroundResultsSchema = object({
+	...baseSchema,
+	runId: string$1().uuid(),
+	columnId: string$1().uuid(),
+	datasetRecordId: string$1().uuid().nullable(),
+	inputVariables: record(string$1(), unknown()),
+	outputContent: string$1().nullable(),
+	status: _enum([
+		"pending",
+		"running",
+		"completed",
+		"failed"
+	]),
+	error: string$1().nullable(),
+	latencyMs: number$1().int().nullable(),
+	promptTokens: number$1().int().nullable(),
+	completionTokens: number$1().int().nullable(),
+	totalTokens: number$1().int().nullable(),
+	cost: number$1().int().nullable()
+});
+const datasetsSchema = object({
+	...baseSchema,
+	name: string$1(),
+	description: string$1().nullable().optional(),
+	recordCount: number$1().int().default(0),
+	latestVersionNumber: number$1().int().default(1)
+});
+const datasetVersionsSchema = object({
+	...baseSchema,
+	datasetId: string$1().uuid(),
+	versionNumber: number$1().int().min(1),
+	name: string$1().nullable().optional(),
+	description: string$1().nullable().optional(),
+	recordCount: number$1().int().default(0),
+	snapshotHash: string$1()
+});
+const datasetRecordsSchema = object({
+	...baseSchema,
+	datasetId: string$1().uuid(),
+	input: record(string$1(), unknown()),
+	expected: record(string$1(), unknown()).nullable().optional(),
+	metadata: record(string$1(), unknown()).default({})
+});
+const datasetVersionRecordsSchema = object({
+	...baseSchema,
+	datasetVersionId: string$1().uuid(),
+	datasetRecordId: string$1().uuid(),
+	position: number$1().int().default(0)
+});
 const guardrailConfigsSchema = object({
 	...baseSchema,
 	name: string$1(),
@@ -13327,8 +13422,167 @@ const SCHEMA_METADATA = { tables: {
 			}
 		}
 	},
-	guardrail_configs: {
+	playgrounds: {
 		order: 10,
+		schema: playgroundsSchema,
+		fields: {
+			id: {
+				type: "uuid",
+				primaryKey: true
+			},
+			name: { type: "text" },
+			datasetId: {
+				type: "uuid",
+				nullable: true,
+				references: {
+					table: "datasets",
+					column: "id"
+				}
+			},
+			columns: {
+				type: "jsonb",
+				nullable: true
+			},
+			createdAt: {
+				type: "timestamp",
+				default: "now()"
+			},
+			updatedAt: {
+				type: "timestamp",
+				default: "now()",
+				onUpdate: "now()"
+			}
+		}
+	},
+	playground_runs: {
+		order: 18,
+		schema: playgroundRunsSchema,
+		fields: {
+			id: {
+				type: "uuid",
+				primaryKey: true
+			},
+			playgroundId: {
+				type: "uuid",
+				references: {
+					table: "playgrounds",
+					column: "id"
+				}
+			},
+			datasetId: {
+				type: "uuid",
+				nullable: true,
+				references: {
+					table: "datasets",
+					column: "id"
+				}
+			},
+			datasetVersionId: {
+				type: "uuid",
+				nullable: true,
+				references: {
+					table: "dataset_versions",
+					column: "id"
+				}
+			},
+			status: { type: "text" },
+			startedAt: {
+				type: "timestamp",
+				nullable: true
+			},
+			completedAt: {
+				type: "timestamp",
+				nullable: true
+			},
+			totalRecords: {
+				type: "integer",
+				default: 0
+			},
+			completedRecords: {
+				type: "integer",
+				default: 0
+			},
+			createdAt: {
+				type: "timestamp",
+				default: "now()"
+			},
+			updatedAt: {
+				type: "timestamp",
+				default: "now()",
+				onUpdate: "now()"
+			}
+		}
+	},
+	playground_results: {
+		order: 19,
+		schema: playgroundResultsSchema,
+		fields: {
+			id: {
+				type: "uuid",
+				primaryKey: true
+			},
+			runId: {
+				type: "uuid",
+				references: {
+					table: "playground_runs",
+					column: "id"
+				}
+			},
+			columnId: { type: "uuid" },
+			datasetRecordId: {
+				type: "uuid",
+				nullable: true,
+				references: {
+					table: "dataset_records",
+					column: "id"
+				}
+			},
+			inputVariables: {
+				type: "jsonb",
+				default: "{}"
+			},
+			outputContent: {
+				type: "text",
+				nullable: true
+			},
+			status: { type: "text" },
+			error: {
+				type: "text",
+				nullable: true
+			},
+			latencyMs: {
+				type: "integer",
+				nullable: true
+			},
+			promptTokens: {
+				type: "integer",
+				nullable: true
+			},
+			completionTokens: {
+				type: "integer",
+				nullable: true
+			},
+			totalTokens: {
+				type: "integer",
+				nullable: true
+			},
+			cost: {
+				type: "integer",
+				nullable: true
+			},
+			createdAt: {
+				type: "timestamp",
+				default: "now()"
+			},
+			updatedAt: {
+				type: "timestamp",
+				default: "now()",
+				onUpdate: "now()"
+			}
+		}
+	},
+	guardrail_configs: {
+		order: 11,
 		schema: guardrailConfigsSchema,
 		fields: {
 			id: {
@@ -13366,8 +13620,154 @@ const SCHEMA_METADATA = { tables: {
 			}
 		}
 	},
+	datasets: {
+		order: 12,
+		schema: datasetsSchema,
+		fields: {
+			id: {
+				type: "uuid",
+				primaryKey: true
+			},
+			name: { type: "text" },
+			description: {
+				type: "text",
+				nullable: true
+			},
+			recordCount: {
+				type: "integer",
+				default: 0
+			},
+			latestVersionNumber: {
+				type: "integer",
+				default: 1
+			},
+			createdAt: {
+				type: "timestamp",
+				default: "now()"
+			},
+			updatedAt: {
+				type: "timestamp",
+				default: "now()",
+				onUpdate: "now()"
+			}
+		}
+	},
+	dataset_versions: {
+		order: 13,
+		schema: datasetVersionsSchema,
+		fields: {
+			id: {
+				type: "uuid",
+				primaryKey: true
+			},
+			datasetId: {
+				type: "uuid",
+				references: {
+					table: "datasets",
+					column: "id"
+				}
+			},
+			versionNumber: { type: "integer" },
+			name: {
+				type: "text",
+				nullable: true
+			},
+			description: {
+				type: "text",
+				nullable: true
+			},
+			recordCount: {
+				type: "integer",
+				default: 0
+			},
+			snapshotHash: { type: "text" },
+			createdAt: {
+				type: "timestamp",
+				default: "now()"
+			},
+			updatedAt: {
+				type: "timestamp",
+				default: "now()",
+				onUpdate: "now()"
+			}
+		},
+		uniqueConstraints: [{ columns: ["datasetId", "versionNumber"] }]
+	},
+	dataset_records: {
+		order: 14,
+		schema: datasetRecordsSchema,
+		fields: {
+			id: {
+				type: "uuid",
+				primaryKey: true
+			},
+			datasetId: {
+				type: "uuid",
+				references: {
+					table: "datasets",
+					column: "id"
+				}
+			},
+			input: { type: "jsonb" },
+			expected: {
+				type: "jsonb",
+				nullable: true
+			},
+			metadata: {
+				type: "jsonb",
+				default: "{}"
+			},
+			createdAt: {
+				type: "timestamp",
+				default: "now()"
+			},
+			updatedAt: {
+				type: "timestamp",
+				default: "now()",
+				onUpdate: "now()"
+			}
+		}
+	},
+	dataset_version_records: {
+		order: 15,
+		schema: datasetVersionRecordsSchema,
+		fields: {
+			id: {
+				type: "uuid",
+				primaryKey: true
+			},
+			datasetVersionId: {
+				type: "uuid",
+				references: {
+					table: "dataset_versions",
+					column: "id"
+				}
+			},
+			datasetRecordId: {
+				type: "uuid",
+				references: {
+					table: "dataset_records",
+					column: "id"
+				}
+			},
+			position: {
+				type: "integer",
+				default: 0
+			},
+			createdAt: {
+				type: "timestamp",
+				default: "now()"
+			},
+			updatedAt: {
+				type: "timestamp",
+				default: "now()",
+				onUpdate: "now()"
+			}
+		},
+		uniqueConstraints: [{ columns: ["datasetVersionId", "datasetRecordId"] }]
+	},
 	provider_guardrail_overrides: {
-		order: 11,
+		order: 16,
 		schema: providerGuardrailOverridesSchema,
 		fields: {
 			id: {
@@ -13409,7 +13809,7 @@ const SCHEMA_METADATA = { tables: {
 		uniqueConstraints: [{ columns: ["providerConfigId", "guardrailConfigId"] }]
 	},
 	llm_requests: {
-		order: 12,
+		order: 17,
 		schema: llmRequestsSchema,
 		fields: {
 			id: {
@@ -13526,8 +13926,16 @@ const schemas = {
 	targeting_rules: targetingRulesSchema,
 	workspace_settings: workspaceSettingsSchema,
 	provider_configs: providerConfigsSchema,
+	playgrounds: playgroundsSchema,
+	playground_columns: playgroundColumnSchema,
+	playground_runs: playgroundRunsSchema,
+	playground_results: playgroundResultsSchema,
 	guardrail_configs: guardrailConfigsSchema,
 	provider_guardrail_overrides: providerGuardrailOverridesSchema,
+	datasets: datasetsSchema,
+	dataset_versions: datasetVersionsSchema,
+	dataset_records: datasetRecordsSchema,
+	dataset_version_records: datasetVersionRecordsSchema,
 	llm_requests: llmRequestsSchema
 };
 
@@ -13976,12 +14384,12 @@ async function createDatabaseFromConnection(rawConnection, options) {
 		case "sqlite":
 			if ("aggregate" in rawConnection && !("createSession" in rawConnection)) dialect = new kysely.SqliteDialect({ database: rawConnection });
 			else if ("fileControl" in rawConnection) {
-				const { BunSqliteDialect } = await Promise.resolve().then(() => require("./bun-sqlite-dialect-B5odtOFX.cjs"));
+				const { BunSqliteDialect } = await Promise.resolve().then(() => require("./bun-sqlite-dialect-BOVsPUU1.cjs"));
 				dialect = new BunSqliteDialect({ database: rawConnection });
 			} else if ("createSession" in rawConnection && typeof window === "undefined") try {
 				const { DatabaseSync } = await import("node:sqlite");
 				if (rawConnection instanceof DatabaseSync) {
-					const { NodeSqliteDialect } = await Promise.resolve().then(() => require("./node-sqlite-dialect-BGjMUONa.cjs"));
+					const { NodeSqliteDialect } = await Promise.resolve().then(() => require("./node-sqlite-dialect-BeXYiIVe.cjs"));
 					dialect = new NodeSqliteDialect({ database: rawConnection });
 				}
 			} catch {}
@@ -14010,7 +14418,7 @@ async function createDatabaseFromConnection(rawConnection, options) {
 					}
 				});
 			} else {
-				const { createNeonDialect } = await Promise.resolve().then(() => require("./neon-dialect-DSmsjY8m.cjs"));
+				const { createNeonDialect } = await Promise.resolve().then(() => require("./neon-dialect-DIrx-7Rh.cjs"));
 				dialect = createNeonDialect(rawConnection);
 			}
 			break;
@@ -14082,6 +14490,30 @@ Object.defineProperty(exports, 'createDatabaseFromConnection', {
     return createDatabaseFromConnection;
   }
 });
+Object.defineProperty(exports, 'datasetRecordsSchema', {
+  enumerable: true,
+  get: function () {
+    return datasetRecordsSchema;
+  }
+});
+Object.defineProperty(exports, 'datasetVersionRecordsSchema', {
+  enumerable: true,
+  get: function () {
+    return datasetVersionRecordsSchema;
+  }
+});
+Object.defineProperty(exports, 'datasetVersionsSchema', {
+  enumerable: true,
+  get: function () {
+    return datasetVersionsSchema;
+  }
+});
+Object.defineProperty(exports, 'datasetsSchema', {
+  enumerable: true,
+  get: function () {
+    return datasetsSchema;
+  }
+});
 Object.defineProperty(exports, 'detectDatabaseType', {
   enumerable: true,
   get: function () {
@@ -14166,6 +14598,30 @@ Object.defineProperty(exports, 'parseTableData', {
     return parseTableData;
   }
 });
+Object.defineProperty(exports, 'playgroundColumnSchema', {
+  enumerable: true,
+  get: function () {
+    return playgroundColumnSchema;
+  }
+});
+Object.defineProperty(exports, 'playgroundResultsSchema', {
+  enumerable: true,
+  get: function () {
+    return playgroundResultsSchema;
+  }
+});
+Object.defineProperty(exports, 'playgroundRunsSchema', {
+  enumerable: true,
+  get: function () {
+    return playgroundRunsSchema;
+  }
+});
+Object.defineProperty(exports, 'playgroundsSchema', {
+  enumerable: true,
+  get: function () {
+    return playgroundsSchema;
+  }
+});
 Object.defineProperty(exports, 'providerConfigsSchema', {
   enumerable: true,
   get: function () {