@llmops/core 0.5.2-beta.1 → 0.5.3-beta.1

package/dist/index.cjs

@@ -1,5 +1,5 @@
-const require_db = require('./db-B9jJgYNw.cjs');
-const require_neon_dialect = require('./neon-dialect-BBWePgOv.cjs');
+const require_db = require('./db-C6ApWDjW.cjs');
+const require_neon_dialect = require('./neon-dialect-SqAJhPFS.cjs');
 let __llmops_gateway = require("@llmops/gateway");
 __llmops_gateway = require_db.__toESM(__llmops_gateway);
 let kysely = require("kysely");
@@ -12,6 +12,20 @@ let node_crypto = require("node:crypto");
 let json_logic_js = require("json-logic-js");
 json_logic_js = require_db.__toESM(json_logic_js);
 
+//#region src/constants/headers.ts
+/**
+* Custom HTTP headers used for trace context propagation
+* between SDK clients and the LLMOps gateway.
+*/
+const LLMOPS_TRACE_ID_HEADER = "x-llmops-trace-id";
+const LLMOPS_TRACE_NAME_HEADER = "x-llmops-trace-name";
+const LLMOPS_SPAN_NAME_HEADER = "x-llmops-span-name";
+const LLMOPS_SESSION_ID_HEADER = "x-llmops-session-id";
+const LLMOPS_USER_ID_HEADER = "x-llmops-user-id";
+const LLMOPS_SPAN_ID_HEADER = "x-llmops-span-id";
+const LLMOPS_REQUEST_ID_HEADER = "x-llmops-request-id";
+
+//#endregion
 //#region src/providers/supported-providers.ts
 /**
 * Supported providers - derived from @llmops/gateway providers
@@ -1998,7 +2012,11 @@ const insertLLMRequestSchema = require_db.zod_default.object({
 	isStreaming: require_db.zod_default.boolean().default(false),
 	userId: require_db.zod_default.string().nullable().optional(),
 	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.string()).default({}),
-	guardrailResults: guardrailResultsSchema.nullable().optional()
+	guardrailResults: guardrailResultsSchema.nullable().optional(),
+	traceId: require_db.zod_default.string().nullable().optional(),
+	spanId: require_db.zod_default.string().nullable().optional(),
+	parentSpanId: require_db.zod_default.string().nullable().optional(),
+	sessionId: require_db.zod_default.string().nullable().optional()
 });
 /**
 * Schema for listing LLM requests
@@ -2028,6 +2046,18 @@ const dateRangeSchema = require_db.zod_default.object({
 	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.array(require_db.zod_default.string())).optional()
 });
 /**
+* Valid groupBy values for cost summary queries
+*/
+const COST_SUMMARY_GROUP_BY = [
+	"day",
+	"hour",
+	"model",
+	"provider",
+	"config",
+	"endpoint",
+	"tags"
+];
+/**
 * Schema for cost summary with grouping
 */
 const costSummarySchema = require_db.zod_default.object({
@@ -2037,19 +2067,13 @@ const costSummarySchema = require_db.zod_default.object({
 	variantId: require_db.zod_default.string().uuid().optional(),
 	environmentId: require_db.zod_default.string().uuid().optional(),
 	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.array(require_db.zod_default.string())).optional(),
-	groupBy: require_db.zod_default.enum([
-		"day",
-		"hour",
-		"model",
-		"provider",
-		"config"
-	]).optional()
+	groupBy: require_db.zod_default.enum(COST_SUMMARY_GROUP_BY).optional()
 });
 /**
 * Helper to create column reference for SQL
 * Uses sql.ref() to properly quote column names for the database
 */
-const col = (name) => kysely.sql.ref(name);
+const col$1 = (name) => kysely.sql.ref(name);
 const tableCol = (table, name) => kysely.sql.ref(`${table}.${name}`);
 const createLLMRequestsDataLayer = (db) => {
 	return {
@@ -2084,6 +2108,10 @@ const createLLMRequestsDataLayer = (db) => {
 				userId: req.userId ?? null,
 				tags: JSON.stringify(req.tags),
 				guardrailResults: req.guardrailResults ? JSON.stringify(req.guardrailResults) : null,
+				traceId: req.traceId ?? null,
+				spanId: req.spanId ?? null,
+				parentSpanId: req.parentSpanId ?? null,
+				sessionId: req.sessionId ?? null,
 				createdAt: now,
 				updatedAt: now
 			}));
@@ -2118,6 +2146,10 @@ const createLLMRequestsDataLayer = (db) => {
 				userId: req.userId ?? null,
 				tags: JSON.stringify(req.tags),
 				guardrailResults: req.guardrailResults ? JSON.stringify(req.guardrailResults) : null,
+				traceId: req.traceId ?? null,
+				spanId: req.spanId ?? null,
+				parentSpanId: req.parentSpanId ?? null,
+				sessionId: req.sessionId ?? null,
 				createdAt: now,
 				updatedAt: now
 			}).returningAll().executeTakeFirst();
@@ -2133,14 +2165,14 @@ const createLLMRequestsDataLayer = (db) => {
 			if (providerConfigId) baseQuery = baseQuery.where("providerConfigId", "=", providerConfigId);
 			if (provider) baseQuery = baseQuery.where("provider", "=", provider);
 			if (model) baseQuery = baseQuery.where("model", "=", model);
-			if (startDate) baseQuery = baseQuery.where(kysely.sql`${col("createdAt")} >= ${startDate.toISOString()}`);
-			if (endDate) baseQuery = baseQuery.where(kysely.sql`${col("createdAt")} <= ${endDate.toISOString()}`);
+			if (startDate) baseQuery = baseQuery.where(kysely.sql`${col$1("createdAt")} >= ${startDate.toISOString()}`);
+			if (endDate) baseQuery = baseQuery.where(kysely.sql`${col$1("createdAt")} <= ${endDate.toISOString()}`);
 			if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
 				if (values.length === 0) continue;
-				if (values.length === 1) baseQuery = baseQuery.where(kysely.sql`${col("tags")}->>${key} = ${values[0]}`);
+				if (values.length === 1) baseQuery = baseQuery.where(kysely.sql`${col$1("tags")}->>${key} = ${values[0]}`);
 				else {
 					const valueList = kysely.sql.join(values.map((v) => kysely.sql`${v}`));
-					baseQuery = baseQuery.where(kysely.sql`${col("tags")}->>${key} IN (${valueList})`);
+					baseQuery = baseQuery.where(kysely.sql`${col$1("tags")}->>${key} IN (${valueList})`);
 				}
 			}
 			const countResult = await baseQuery.select(kysely.sql`COUNT(*)`.as("total")).executeTakeFirst();
@@ -2160,23 +2192,23 @@ const createLLMRequestsDataLayer = (db) => {
 			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
 			const { startDate, endDate, configId, variantId, environmentId, tags } = result.data;
 			let query = db.selectFrom("llm_requests").select([
-				kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
-				kysely.sql`COALESCE(SUM(${col("inputCost")}), 0)`.as("totalInputCost"),
-				kysely.sql`COALESCE(SUM(${col("outputCost")}), 0)`.as("totalOutputCost"),
-				kysely.sql`COALESCE(SUM(${col("promptTokens")}), 0)`.as("totalPromptTokens"),
-				kysely.sql`COALESCE(SUM(${col("completionTokens")}), 0)`.as("totalCompletionTokens"),
-				kysely.sql`COALESCE(SUM(${col("totalTokens")}), 0)`.as("totalTokens"),
+				kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
+				kysely.sql`COALESCE(SUM(${col$1("inputCost")}), 0)`.as("totalInputCost"),
+				kysely.sql`COALESCE(SUM(${col$1("outputCost")}), 0)`.as("totalOutputCost"),
+				kysely.sql`COALESCE(SUM(${col$1("promptTokens")}), 0)`.as("totalPromptTokens"),
+				kysely.sql`COALESCE(SUM(${col$1("completionTokens")}), 0)`.as("totalCompletionTokens"),
+				kysely.sql`COALESCE(SUM(${col$1("totalTokens")}), 0)`.as("totalTokens"),
 				kysely.sql`COUNT(*)`.as("requestCount")
-			]).where(kysely.sql`${col("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col("createdAt")} <= ${endDate.toISOString()}`);
+			]).where(kysely.sql`${col$1("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col$1("createdAt")} <= ${endDate.toISOString()}`);
 			if (configId) query = query.where("configId", "=", configId);
 			if (variantId) query = query.where("variantId", "=", variantId);
 			if (environmentId) query = query.where("environmentId", "=", environmentId);
 			if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
 				if (values.length === 0) continue;
-				if (values.length === 1) query = query.where(kysely.sql`${col("tags")}->>${key} = ${values[0]}`);
+				if (values.length === 1) query = query.where(kysely.sql`${col$1("tags")}->>${key} = ${values[0]}`);
 				else {
 					const valueList = kysely.sql.join(values.map((v) => kysely.sql`${v}`));
-					query = query.where(kysely.sql`${col("tags")}->>${key} IN (${valueList})`);
+					query = query.where(kysely.sql`${col$1("tags")}->>${key} IN (${valueList})`);
 				}
 			}
 			return await query.executeTakeFirst();
@@ -2188,13 +2220,13 @@ const createLLMRequestsDataLayer = (db) => {
 			return db.selectFrom("llm_requests").select([
 				"provider",
 				"model",
-				kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
-				kysely.sql`COALESCE(SUM(${col("inputCost")}), 0)`.as("totalInputCost"),
-				kysely.sql`COALESCE(SUM(${col("outputCost")}), 0)`.as("totalOutputCost"),
-				kysely.sql`COALESCE(SUM(${col("totalTokens")}), 0)`.as("totalTokens"),
+				kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
+				kysely.sql`COALESCE(SUM(${col$1("inputCost")}), 0)`.as("totalInputCost"),
+				kysely.sql`COALESCE(SUM(${col$1("outputCost")}), 0)`.as("totalOutputCost"),
+				kysely.sql`COALESCE(SUM(${col$1("totalTokens")}), 0)`.as("totalTokens"),
 				kysely.sql`COUNT(*)`.as("requestCount"),
-				kysely.sql`AVG(${col("latencyMs")})`.as("avgLatencyMs")
-			]).where(kysely.sql`${col("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col("createdAt")} <= ${endDate.toISOString()}`).groupBy(["provider", "model"]).orderBy(kysely.sql`SUM(${col("cost")})`, "desc").execute();
+				kysely.sql`AVG(${col$1("latencyMs")})`.as("avgLatencyMs")
+			]).where(kysely.sql`${col$1("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col$1("createdAt")} <= ${endDate.toISOString()}`).groupBy(["provider", "model"]).orderBy(kysely.sql`SUM(${col$1("cost")})`, "desc").execute();
 		},
 		getCostByProvider: async (params) => {
 			const result = await dateRangeSchema.safeParseAsync(params);
@@ -2202,13 +2234,13 @@ const createLLMRequestsDataLayer = (db) => {
 			const { startDate, endDate } = result.data;
 			return db.selectFrom("llm_requests").select([
 				"provider",
-				kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
-				kysely.sql`COALESCE(SUM(${col("inputCost")}), 0)`.as("totalInputCost"),
-				kysely.sql`COALESCE(SUM(${col("outputCost")}), 0)`.as("totalOutputCost"),
-				kysely.sql`COALESCE(SUM(${col("totalTokens")}), 0)`.as("totalTokens"),
+				kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
+				kysely.sql`COALESCE(SUM(${col$1("inputCost")}), 0)`.as("totalInputCost"),
+				kysely.sql`COALESCE(SUM(${col$1("outputCost")}), 0)`.as("totalOutputCost"),
+				kysely.sql`COALESCE(SUM(${col$1("totalTokens")}), 0)`.as("totalTokens"),
 				kysely.sql`COUNT(*)`.as("requestCount"),
-				kysely.sql`AVG(${col("latencyMs")})`.as("avgLatencyMs")
-			]).where(kysely.sql`${col("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col("createdAt")} <= ${endDate.toISOString()}`).groupBy("provider").orderBy(kysely.sql`SUM(${col("cost")})`, "desc").execute();
+				kysely.sql`AVG(${col$1("latencyMs")})`.as("avgLatencyMs")
+			]).where(kysely.sql`${col$1("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col$1("createdAt")} <= ${endDate.toISOString()}`).groupBy("provider").orderBy(kysely.sql`SUM(${col$1("cost")})`, "desc").execute();
 		},
 		getCostByConfig: async (params) => {
 			const result = await dateRangeSchema.safeParseAsync(params);
@@ -2234,61 +2266,90 @@ const createLLMRequestsDataLayer = (db) => {
 			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
 			const { startDate, endDate } = result.data;
 			return db.selectFrom("llm_requests").select([
-				kysely.sql`DATE(${col("createdAt")})`.as("date"),
-				kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
-				kysely.sql`COALESCE(SUM(${col("inputCost")}), 0)`.as("totalInputCost"),
-				kysely.sql`COALESCE(SUM(${col("outputCost")}), 0)`.as("totalOutputCost"),
-				kysely.sql`COALESCE(SUM(${col("totalTokens")}), 0)`.as("totalTokens"),
+				kysely.sql`DATE(${col$1("createdAt")})`.as("date"),
+				kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
+				kysely.sql`COALESCE(SUM(${col$1("inputCost")}), 0)`.as("totalInputCost"),
+				kysely.sql`COALESCE(SUM(${col$1("outputCost")}), 0)`.as("totalOutputCost"),
+				kysely.sql`COALESCE(SUM(${col$1("totalTokens")}), 0)`.as("totalTokens"),
 				kysely.sql`COUNT(*)`.as("requestCount")
-			]).where(kysely.sql`${col("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col("createdAt")} <= ${endDate.toISOString()}`).groupBy(kysely.sql`DATE(${col("createdAt")})`).orderBy(kysely.sql`DATE(${col("createdAt")})`, "asc").execute();
+			]).where(kysely.sql`${col$1("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col$1("createdAt")} <= ${endDate.toISOString()}`).groupBy(kysely.sql`DATE(${col$1("createdAt")})`).orderBy(kysely.sql`DATE(${col$1("createdAt")})`, "asc").execute();
 		},
 		getCostSummary: async (params) => {
 			const result = await costSummarySchema.safeParseAsync(params);
 			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
 			const { startDate, endDate, groupBy, configId, variantId, environmentId, tags } = result.data;
-			let baseQuery = db.selectFrom("llm_requests").where(kysely.sql`${col("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col("createdAt")} <= ${endDate.toISOString()}`);
+			let baseQuery = db.selectFrom("llm_requests").where(kysely.sql`${col$1("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col$1("createdAt")} <= ${endDate.toISOString()}`);
 			if (configId) baseQuery = baseQuery.where("configId", "=", configId);
 			if (variantId) baseQuery = baseQuery.where("variantId", "=", variantId);
 			if (environmentId) baseQuery = baseQuery.where("environmentId", "=", environmentId);
 			if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
 				if (values.length === 0) continue;
-				if (values.length === 1) baseQuery = baseQuery.where(kysely.sql`${col("tags")}->>${key} = ${values[0]}`);
+				if (values.length === 1) baseQuery = baseQuery.where(kysely.sql`${col$1("tags")}->>${key} = ${values[0]}`);
 				else {
 					const valueList = kysely.sql.join(values.map((v) => kysely.sql`${v}`));
-					baseQuery = baseQuery.where(kysely.sql`${col("tags")}->>${key} IN (${valueList})`);
+					baseQuery = baseQuery.where(kysely.sql`${col$1("tags")}->>${key} IN (${valueList})`);
 				}
 			}
 			switch (groupBy) {
 				case "day": return baseQuery.select([
-					kysely.sql`DATE(${col("createdAt")})`.as("groupKey"),
-					kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
+					kysely.sql`DATE(${col$1("createdAt")})`.as("groupKey"),
+					kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
 					kysely.sql`COUNT(*)`.as("requestCount"),
-					kysely.sql`COALESCE(SUM(${col("totalTokens")}), 0)`.as("totalTokens")
-				]).groupBy(kysely.sql`DATE(${col("createdAt")})`).orderBy(kysely.sql`DATE(${col("createdAt")})`, "asc").execute();
+					kysely.sql`COALESCE(SUM(${col$1("totalTokens")}), 0)`.as("totalTokens")
+				]).groupBy(kysely.sql`DATE(${col$1("createdAt")})`).orderBy(kysely.sql`DATE(${col$1("createdAt")})`, "asc").execute();
 				case "hour": return baseQuery.select([
-					kysely.sql`DATE_TRUNC('hour', ${col("createdAt")})`.as("groupKey"),
-					kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
+					kysely.sql`DATE_TRUNC('hour', ${col$1("createdAt")})`.as("groupKey"),
+					kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
 					kysely.sql`COUNT(*)`.as("requestCount"),
-					kysely.sql`COALESCE(SUM(${col("totalTokens")}), 0)`.as("totalTokens")
-				]).groupBy(kysely.sql`DATE_TRUNC('hour', ${col("createdAt")})`).orderBy(kysely.sql`DATE_TRUNC('hour', ${col("createdAt")})`, "asc").execute();
+					kysely.sql`COALESCE(SUM(${col$1("totalTokens")}), 0)`.as("totalTokens")
+				]).groupBy(kysely.sql`DATE_TRUNC('hour', ${col$1("createdAt")})`).orderBy(kysely.sql`DATE_TRUNC('hour', ${col$1("createdAt")})`, "asc").execute();
 				case "model": return baseQuery.select([
-					kysely.sql`${col("provider")} || '/' || ${col("model")}`.as("groupKey"),
-					kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
+					kysely.sql`${col$1("provider")} || '/' || ${col$1("model")}`.as("groupKey"),
+					kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
 					kysely.sql`COUNT(*)`.as("requestCount")
-				]).groupBy(["provider", "model"]).orderBy(kysely.sql`SUM(${col("cost")})`, "desc").execute();
+				]).groupBy(["provider", "model"]).orderBy(kysely.sql`SUM(${col$1("cost")})`, "desc").execute();
 				case "provider": return baseQuery.select([
-					kysely.sql`${col("provider")}`.as("groupKey"),
-					kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
+					kysely.sql`${col$1("provider")}`.as("groupKey"),
+					kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
 					kysely.sql`COUNT(*)`.as("requestCount")
-				]).groupBy("provider").orderBy(kysely.sql`SUM(${col("cost")})`, "desc").execute();
+				]).groupBy("provider").orderBy(kysely.sql`SUM(${col$1("cost")})`, "desc").execute();
 				case "config": return baseQuery.select([
-					kysely.sql`COALESCE(${col("configId")}::text, 'no-config')`.as("groupKey"),
-					kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
+					kysely.sql`COALESCE(${col$1("configId")}::text, 'no-config')`.as("groupKey"),
+					kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
+					kysely.sql`COUNT(*)`.as("requestCount")
+				]).groupBy("configId").orderBy(kysely.sql`SUM(${col$1("cost")})`, "desc").execute();
+				case "endpoint": return baseQuery.select([
+					kysely.sql`COALESCE(${col$1("endpoint")}, 'unknown')`.as("groupKey"),
+					kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
 					kysely.sql`COUNT(*)`.as("requestCount")
-				]).groupBy("configId").orderBy(kysely.sql`SUM(${col("cost")})`, "desc").execute();
+				]).groupBy("endpoint").orderBy(kysely.sql`SUM(${col$1("cost")})`, "desc").execute();
+				case "tags": {
+					const conditions = [kysely.sql`${col$1("createdAt")} >= ${startDate.toISOString()}`, kysely.sql`${col$1("createdAt")} <= ${endDate.toISOString()}`];
+					if (configId) conditions.push(kysely.sql`${col$1("configId")} = ${configId}`);
+					if (variantId) conditions.push(kysely.sql`${col$1("variantId")} = ${variantId}`);
+					if (environmentId) conditions.push(kysely.sql`${col$1("environmentId")} = ${environmentId}`);
+					if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
+						if (values.length === 0) continue;
+						if (values.length === 1) conditions.push(kysely.sql`${col$1("tags")}->>${key} = ${values[0]}`);
+						else {
+							const valueList = kysely.sql.join(values.map((v) => kysely.sql`${v}`));
+							conditions.push(kysely.sql`${col$1("tags")}->>${key} IN (${valueList})`);
+						}
+					}
+					const whereClause = kysely.sql.join(conditions, kysely.sql` AND `);
+					return (await kysely.sql`
+            SELECT t.key || ':' || t.value as "groupKey",
+                   COALESCE(SUM(${col$1("cost")}), 0) as "totalCost",
+                   COUNT(*) as "requestCount"
+            FROM "llm_requests", jsonb_each_text(${col$1("tags")}) t
+            WHERE ${whereClause}
+            GROUP BY t.key, t.value
+            ORDER BY SUM(${col$1("cost")}) DESC
+          `.execute(db)).rows;
+				}
 				default: return baseQuery.select([
 					kysely.sql`'total'`.as("groupKey"),
-					kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
+					kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
 					kysely.sql`COUNT(*)`.as("requestCount")
 				]).execute();
 			}
@@ -2299,22 +2360,22 @@ const createLLMRequestsDataLayer = (db) => {
 			const { startDate, endDate, configId, variantId, environmentId, tags } = result.data;
 			let query = db.selectFrom("llm_requests").select([
 				kysely.sql`COUNT(*)`.as("totalRequests"),
-				kysely.sql`COUNT(CASE WHEN ${col("statusCode")} >= 200 AND ${col("statusCode")} < 300 THEN 1 END)`.as("successfulRequests"),
-				kysely.sql`COUNT(CASE WHEN ${col("statusCode")} >= 400 THEN 1 END)`.as("failedRequests"),
-				kysely.sql`COUNT(CASE WHEN ${col("isStreaming")} = true THEN 1 END)`.as("streamingRequests"),
-				kysely.sql`AVG(${col("latencyMs")})`.as("avgLatencyMs"),
-				kysely.sql`MAX(${col("latencyMs")})`.as("maxLatencyMs"),
-				kysely.sql`MIN(${col("latencyMs")})`.as("minLatencyMs")
-			]).where(kysely.sql`${col("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col("createdAt")} <= ${endDate.toISOString()}`);
+				kysely.sql`COUNT(CASE WHEN ${col$1("statusCode")} >= 200 AND ${col$1("statusCode")} < 300 THEN 1 END)`.as("successfulRequests"),
+				kysely.sql`COUNT(CASE WHEN ${col$1("statusCode")} >= 400 THEN 1 END)`.as("failedRequests"),
+				kysely.sql`COUNT(CASE WHEN ${col$1("isStreaming")} = true THEN 1 END)`.as("streamingRequests"),
+				kysely.sql`AVG(${col$1("latencyMs")})`.as("avgLatencyMs"),
+				kysely.sql`MAX(${col$1("latencyMs")})`.as("maxLatencyMs"),
+				kysely.sql`MIN(${col$1("latencyMs")})`.as("minLatencyMs")
+			]).where(kysely.sql`${col$1("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col$1("createdAt")} <= ${endDate.toISOString()}`);
 			if (configId) query = query.where("configId", "=", configId);
 			if (variantId) query = query.where("variantId", "=", variantId);
 			if (environmentId) query = query.where("environmentId", "=", environmentId);
 			if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
 				if (values.length === 0) continue;
-				if (values.length === 1) query = query.where(kysely.sql`${col("tags")}->>${key} = ${values[0]}`);
+				if (values.length === 1) query = query.where(kysely.sql`${col$1("tags")}->>${key} = ${values[0]}`);
 				else {
 					const valueList = kysely.sql.join(values.map((v) => kysely.sql`${v}`));
-					query = query.where(kysely.sql`${col("tags")}->>${key} IN (${valueList})`);
+					query = query.where(kysely.sql`${col$1("tags")}->>${key} IN (${valueList})`);
 				}
 			}
 			return await query.executeTakeFirst();
@@ -3056,6 +3117,271 @@ const createTargetingRulesDataLayer = (db) => {
 	};
 };
 
+//#endregion
+//#region src/datalayer/traces.ts
+const col = (name) => kysely.sql.ref(name);
+/**
+* Schema for upserting a trace
+*/
+const upsertTraceSchema = require_db.zod_default.object({
+	traceId: require_db.zod_default.string(),
+	name: require_db.zod_default.string().nullable().optional(),
+	sessionId: require_db.zod_default.string().nullable().optional(),
+	userId: require_db.zod_default.string().nullable().optional(),
+	status: require_db.zod_default.enum([
+		"unset",
+		"ok",
+		"error"
+	]).default("unset"),
+	startTime: require_db.zod_default.date(),
+	endTime: require_db.zod_default.date().nullable().optional(),
+	durationMs: require_db.zod_default.number().int().nullable().optional(),
+	spanCount: require_db.zod_default.number().int().default(1),
+	totalInputTokens: require_db.zod_default.number().int().default(0),
+	totalOutputTokens: require_db.zod_default.number().int().default(0),
+	totalTokens: require_db.zod_default.number().int().default(0),
+	totalCost: require_db.zod_default.number().int().default(0),
+	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.string()).default({}),
+	metadata: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).default({})
+});
+/**
+* Schema for inserting spans
+*/
+const insertSpanSchema = require_db.zod_default.object({
+	traceId: require_db.zod_default.string(),
+	spanId: require_db.zod_default.string(),
+	parentSpanId: require_db.zod_default.string().nullable().optional(),
+	name: require_db.zod_default.string(),
+	kind: require_db.zod_default.number().int().default(1),
+	status: require_db.zod_default.number().int().default(0),
+	statusMessage: require_db.zod_default.string().nullable().optional(),
+	startTime: require_db.zod_default.date(),
+	endTime: require_db.zod_default.date().nullable().optional(),
+	durationMs: require_db.zod_default.number().int().nullable().optional(),
+	provider: require_db.zod_default.string().nullable().optional(),
+	model: require_db.zod_default.string().nullable().optional(),
+	promptTokens: require_db.zod_default.number().int().default(0),
+	completionTokens: require_db.zod_default.number().int().default(0),
+	totalTokens: require_db.zod_default.number().int().default(0),
+	cost: require_db.zod_default.number().int().default(0),
+	configId: require_db.zod_default.string().uuid().nullable().optional(),
+	variantId: require_db.zod_default.string().uuid().nullable().optional(),
+	environmentId: require_db.zod_default.string().uuid().nullable().optional(),
+	providerConfigId: require_db.zod_default.string().uuid().nullable().optional(),
+	requestId: require_db.zod_default.string().uuid().nullable().optional(),
+	source: require_db.zod_default.enum(["gateway", "otlp"]).default("gateway"),
+	input: require_db.zod_default.unknown().nullable().optional(),
+	output: require_db.zod_default.unknown().nullable().optional(),
+	attributes: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).default({})
+});
+/**
+* Schema for inserting span events
+*/
+const insertSpanEventSchema = require_db.zod_default.object({
+	traceId: require_db.zod_default.string(),
+	spanId: require_db.zod_default.string(),
+	name: require_db.zod_default.string(),
+	timestamp: require_db.zod_default.date(),
+	attributes: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).default({})
+});
+/**
+* Schema for listing traces
+*/
+const listTracesSchema = require_db.zod_default.object({
+	limit: require_db.zod_default.number().int().positive().max(1e3).default(50),
+	offset: require_db.zod_default.number().int().nonnegative().default(0),
+	sessionId: require_db.zod_default.string().optional(),
+	userId: require_db.zod_default.string().optional(),
+	status: require_db.zod_default.enum([
+		"unset",
+		"ok",
+		"error"
+	]).optional(),
+	name: require_db.zod_default.string().optional(),
+	startDate: require_db.zod_default.date().optional(),
+	endDate: require_db.zod_default.date().optional(),
+	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.array(require_db.zod_default.string())).optional()
+});
+/**
+* Schema for trace stats query
+*/
+const traceStatsSchema = require_db.zod_default.object({
+	startDate: require_db.zod_default.date(),
+	endDate: require_db.zod_default.date(),
+	sessionId: require_db.zod_default.string().optional(),
+	userId: require_db.zod_default.string().optional()
+});
+const createTracesDataLayer = (db) => {
+	return {
+		upsertTrace: async (data) => {
+			const result = await upsertTraceSchema.safeParseAsync(data);
+			if (!result.success) throw new LLMOpsError(`Invalid trace data: ${result.error.message}`);
+			const trace = result.data;
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			await kysely.sql`
+        INSERT INTO "traces" (
+          "id", "traceId", "name", "sessionId", "userId", "status",
+          "startTime", "endTime", "durationMs", "spanCount",
+          "totalInputTokens", "totalOutputTokens", "totalTokens", "totalCost",
+          "tags", "metadata", "createdAt", "updatedAt"
+        ) VALUES (
+          ${(0, node_crypto.randomUUID)()}, ${trace.traceId}, ${trace.name ?? null}, ${trace.sessionId ?? null},
+          ${trace.userId ?? null}, ${trace.status},
+          ${trace.startTime.toISOString()}, ${trace.endTime?.toISOString() ?? null},
+          ${trace.durationMs ?? null}, ${trace.spanCount},
+          ${trace.totalInputTokens}, ${trace.totalOutputTokens},
+          ${trace.totalTokens}, ${trace.totalCost},
+          ${JSON.stringify(trace.tags)}::jsonb, ${JSON.stringify(trace.metadata)}::jsonb,
+          ${now}, ${now}
+        )
+        ON CONFLICT ("traceId") DO UPDATE SET
+          "name" = COALESCE(EXCLUDED."name", "traces"."name"),
+          "sessionId" = COALESCE(EXCLUDED."sessionId", "traces"."sessionId"),
+          "userId" = COALESCE(EXCLUDED."userId", "traces"."userId"),
+          "status" = CASE
+            WHEN EXCLUDED."status" = 'error' THEN 'error'
+            WHEN EXCLUDED."status" = 'ok' AND "traces"."status" != 'error' THEN 'ok'
+            ELSE "traces"."status"
+          END,
+          "startTime" = LEAST("traces"."startTime", EXCLUDED."startTime"),
+          "endTime" = GREATEST(
+            COALESCE("traces"."endTime", EXCLUDED."endTime"),
+            COALESCE(EXCLUDED."endTime", "traces"."endTime")
+          ),
+          "durationMs" = EXTRACT(EPOCH FROM (
+            GREATEST(
+              COALESCE("traces"."endTime", EXCLUDED."endTime"),
+              COALESCE(EXCLUDED."endTime", "traces"."endTime")
+            ) -
+            LEAST("traces"."startTime", EXCLUDED."startTime")
+          ))::integer * 1000,
+          "spanCount" = "traces"."spanCount" + EXCLUDED."spanCount",
+          "totalInputTokens" = "traces"."totalInputTokens" + EXCLUDED."totalInputTokens",
+          "totalOutputTokens" = "traces"."totalOutputTokens" + EXCLUDED."totalOutputTokens",
+          "totalTokens" = "traces"."totalTokens" + EXCLUDED."totalTokens",
+          "totalCost" = "traces"."totalCost" + EXCLUDED."totalCost",
+          "tags" = "traces"."tags" || EXCLUDED."tags",
+          "metadata" = "traces"."metadata" || EXCLUDED."metadata",
+          "updatedAt" = ${now}
+      `.execute(db);
+		},
+		batchInsertSpans: async (spans) => {
+			if (spans.length === 0) return { count: 0 };
+			const validatedSpans = await Promise.all(spans.map(async (span) => {
+				const result = await insertSpanSchema.safeParseAsync(span);
+				if (!result.success) throw new LLMOpsError(`Invalid span data: ${result.error.message}`);
+				return result.data;
+			}));
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const values = validatedSpans.map((span) => ({
+				id: (0, node_crypto.randomUUID)(),
+				traceId: span.traceId,
+				spanId: span.spanId,
+				parentSpanId: span.parentSpanId ?? null,
+				name: span.name,
+				kind: span.kind,
+				status: span.status,
+				statusMessage: span.statusMessage ?? null,
+				startTime: span.startTime.toISOString(),
+				endTime: span.endTime?.toISOString() ?? null,
+				durationMs: span.durationMs ?? null,
+				provider: span.provider ?? null,
+				model: span.model ?? null,
+				promptTokens: span.promptTokens,
+				completionTokens: span.completionTokens,
+				totalTokens: span.totalTokens,
+				cost: span.cost,
+				configId: span.configId ?? null,
+				variantId: span.variantId ?? null,
+				environmentId: span.environmentId ?? null,
+				providerConfigId: span.providerConfigId ?? null,
+				requestId: span.requestId ?? null,
+				source: span.source,
+				input: span.input != null ? JSON.stringify(span.input) : null,
+				output: span.output != null ? JSON.stringify(span.output) : null,
+				attributes: JSON.stringify(span.attributes),
+				createdAt: now,
+				updatedAt: now
+			}));
+			await db.insertInto("spans").values(values).onConflict((oc) => oc.column("spanId").doNothing()).execute();
+			return { count: values.length };
+		},
+		batchInsertSpanEvents: async (events) => {
+			if (events.length === 0) return { count: 0 };
+			const validatedEvents = await Promise.all(events.map(async (event) => {
+				const result = await insertSpanEventSchema.safeParseAsync(event);
+				if (!result.success) throw new LLMOpsError(`Invalid span event data: ${result.error.message}`);
+				return result.data;
+			}));
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const values = validatedEvents.map((event) => ({
+				id: (0, node_crypto.randomUUID)(),
+				traceId: event.traceId,
+				spanId: event.spanId,
+				name: event.name,
+				timestamp: event.timestamp.toISOString(),
+				attributes: JSON.stringify(event.attributes),
+				createdAt: now
+			}));
+			await db.insertInto("span_events").values(values).execute();
+			return { count: values.length };
+		},
+		listTraces: async (params) => {
+			const result = await listTracesSchema.safeParseAsync(params || {});
+			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
+			const { limit, offset, sessionId, userId, status, name, startDate, endDate, tags } = result.data;
+			let baseQuery = db.selectFrom("traces");
+			if (sessionId) baseQuery = baseQuery.where("sessionId", "=", sessionId);
+			if (userId) baseQuery = baseQuery.where("userId", "=", userId);
+			if (status) baseQuery = baseQuery.where("status", "=", status);
+			if (name) baseQuery = baseQuery.where(kysely.sql`${col("name")} ILIKE ${"%" + name + "%"}`);
+			if (startDate) baseQuery = baseQuery.where(kysely.sql`${col("startTime")} >= ${startDate.toISOString()}`);
+			if (endDate) baseQuery = baseQuery.where(kysely.sql`${col("startTime")} <= ${endDate.toISOString()}`);
+			if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
+				if (values.length === 0) continue;
+				if (values.length === 1) baseQuery = baseQuery.where(kysely.sql`${col("tags")}->>${key} = ${values[0]}`);
+				else {
+					const valueList = kysely.sql.join(values.map((v) => kysely.sql`${v}`));
+					baseQuery = baseQuery.where(kysely.sql`${col("tags")}->>${key} IN (${valueList})`);
+				}
+			}
+			const countResult = await baseQuery.select(kysely.sql`COUNT(*)`.as("total")).executeTakeFirst();
+			const total = Number(countResult?.total ?? 0);
+			return {
+				data: await baseQuery.selectAll().orderBy("startTime", "desc").limit(limit).offset(offset).execute(),
+				total,
+				limit,
+				offset
+			};
+		},
+		getTraceWithSpans: async (traceId) => {
+			const trace = await db.selectFrom("traces").selectAll().where("traceId", "=", traceId).executeTakeFirst();
+			if (!trace) return void 0;
+			return {
+				trace,
+				spans: await db.selectFrom("spans").selectAll().where("traceId", "=", traceId).orderBy("startTime", "asc").execute(),
+				events: await db.selectFrom("span_events").selectAll().where("traceId", "=", traceId).orderBy("timestamp", "asc").execute()
+			};
+		},
+		getTraceStats: async (params) => {
+			const result = await traceStatsSchema.safeParseAsync(params);
+			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
+			const { startDate, endDate, sessionId, userId } = result.data;
+			let query = db.selectFrom("traces").select([
+				kysely.sql`COUNT(*)`.as("totalTraces"),
+				kysely.sql`COALESCE(AVG(${col("durationMs")}), 0)`.as("avgDurationMs"),
+				kysely.sql`COUNT(CASE WHEN ${col("status")} = 'error' THEN 1 END)`.as("errorCount"),
+				kysely.sql`COALESCE(SUM(${col("totalCost")}), 0)`.as("totalCost"),
+				kysely.sql`COALESCE(SUM(${col("totalTokens")}), 0)`.as("totalTokens"),
+				kysely.sql`COALESCE(SUM(${col("spanCount")}), 0)`.as("totalSpans")
+			]).where(kysely.sql`${col("startTime")} >= ${startDate.toISOString()}`).where(kysely.sql`${col("startTime")} <= ${endDate.toISOString()}`);
+			if (sessionId) query = query.where("sessionId", "=", sessionId);
+			if (userId) query = query.where("userId", "=", userId);
+			return query.executeTakeFirst();
+		}
+	};
+};
+
 //#endregion
 //#region src/datalayer/variants.ts
 const createVariant = require_db.zod_default.object({ name: require_db.zod_default.string() });
@@ -3349,6 +3675,7 @@ function createDataLayer(db) {
 		...createProviderConfigsDataLayer(db),
 		...createProviderGuardrailOverridesDataLayer(db),
 		...createTargetingRulesDataLayer(db),
+		...createTracesDataLayer(db),
 		...createVariantDataLayer(db),
 		...createVariantVersionsDataLayer(db),
 		...createWorkspaceSettingsDataLayer(db)
@@ -3927,9 +4254,17 @@ var ManifestRouter = class {
 };
 
 //#endregion
+exports.COST_SUMMARY_GROUP_BY = COST_SUMMARY_GROUP_BY;
 exports.CacheService = CacheService;
 exports.DEFAULT_PROVIDER_ENV_VARS = DEFAULT_PROVIDER_ENV_VARS;
 exports.FileCacheBackend = FileCacheBackend;
+exports.LLMOPS_REQUEST_ID_HEADER = LLMOPS_REQUEST_ID_HEADER;
+exports.LLMOPS_SESSION_ID_HEADER = LLMOPS_SESSION_ID_HEADER;
+exports.LLMOPS_SPAN_ID_HEADER = LLMOPS_SPAN_ID_HEADER;
+exports.LLMOPS_SPAN_NAME_HEADER = LLMOPS_SPAN_NAME_HEADER;
+exports.LLMOPS_TRACE_ID_HEADER = LLMOPS_TRACE_ID_HEADER;
+exports.LLMOPS_TRACE_NAME_HEADER = LLMOPS_TRACE_NAME_HEADER;
+exports.LLMOPS_USER_ID_HEADER = LLMOPS_USER_ID_HEADER;
 exports.MS = MS;
 exports.ManifestBuilder = ManifestBuilder;
 exports.ManifestRouter = ManifestRouter;
@@ -3959,6 +4294,7 @@ exports.createPlaygroundRunsDataLayer = createPlaygroundRunsDataLayer;
 exports.createProviderConfigsDataLayer = createProviderConfigsDataLayer;
 exports.createProviderGuardrailOverridesDataLayer = createProviderGuardrailOverridesDataLayer;
 exports.createTargetingRulesDataLayer = createTargetingRulesDataLayer;
+exports.createTracesDataLayer = createTracesDataLayer;
 exports.createVariantDataLayer = createVariantDataLayer;
 exports.createVariantVersionsDataLayer = createVariantVersionsDataLayer;
 exports.createWorkspaceSettingsDataLayer = createWorkspaceSettingsDataLayer;
@@ -4000,7 +4336,10 @@ exports.providerConfigsSchema = require_db.providerConfigsSchema;
 exports.providerGuardrailOverridesSchema = require_db.providerGuardrailOverridesSchema;
 exports.runAutoMigrations = require_db.runAutoMigrations;
 exports.schemas = require_db.schemas;
+exports.spanEventsSchema = require_db.spanEventsSchema;
+exports.spansSchema = require_db.spansSchema;
 exports.targetingRulesSchema = require_db.targetingRulesSchema;
+exports.tracesSchema = require_db.tracesSchema;
 exports.validateLLMOpsConfig = validateLLMOpsConfig;
 exports.validatePartialTableData = require_db.validatePartialTableData;
 exports.validateTableData = require_db.validateTableData;