@keystrokehq/keystroke 0.0.160 → 0.0.161

package/dist/{dist-BAzfOMfz.mjs → dist-DXzvN8aq.mjs}

@@ -1,5 +1,5 @@
 import { Bn as __require, Ln as __commonJSMin, Vn as __toESM } from "./dist-Dv44b9V1.mjs";
-import { C as normalizeCredentialList, _ as CREDENTIAL_SCOPE_LEVEL_TO_SCOPE_TYPE } from "./dist-DM1Na5CA.mjs";
+import { C as normalizeCredentialList, _ as CREDENTIAL_SCOPE_LEVEL_TO_SCOPE_TYPE } from "./dist-BIbZjRd7.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 import "node:fs";
 import { ZodFirstPartyTypeKind } from "zod/v3";
@@ -13251,7 +13251,7 @@ async function connectMcpServer(name, options) {
 }
 async function createTransport(url, transport, requestInit, fetchImpl) {
 	if (transport === "sse") {
-		const { SSEClientTransport } = await import("./sse-Ba5sWI6l.mjs");
+		const { SSEClientTransport } = await import("./sse-BBd2aLiw.mjs");
 		return new SSEClientTransport(url, {
 			requestInit,
 			fetch: fetchImpl
@@ -16464,9 +16464,58 @@ const agentSessionsSqlite = sqliteTable("agent_sessions", {
 	updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull(),
 	deletedAt: integer("deleted_at", { mode: "timestamp_ms" })
 }, (table) => [index("agent_sessions_agent_updated_idx").on(table.agentId, table.updatedAt)]);
+const agentRuns = pgTable("agent_runs", {
+	id: text$1("id").primaryKey(),
+	sessionId: text$1("session_id").notNull().references(() => agentSessions.id),
+	projectId: text$1("project_id").notNull(),
+	agentId: text$1("agent_id").notNull().references(() => agents.id),
+	runIndex: integer$1("run_index").notNull(),
+	sourceKind: text$1("source_kind").$type().notNull().default("api"),
+	sourceId: text$1("source_id"),
+	ranByUserId: text$1("ran_by_user_id"),
+	status: text$1("status").$type().notNull(),
+	error: jsonb("error"),
+	startedAt: timestamp("started_at", { withTimezone: true }).notNull(),
+	finishedAt: timestamp("finished_at", { withTimezone: true }),
+	totalCostUsd: doublePrecision("total_cost_usd"),
+	totalTokens: integer$1("total_tokens"),
+	modelsUsed: jsonb("models_used").$type(),
+	createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+	updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+	deletedAt: timestamp("deleted_at", { withTimezone: true })
+}, (table) => [
+	index$1("agent_runs_session_run_index_idx").on(table.sessionId, table.runIndex),
+	index$1("agent_runs_agent_started_idx").on(table.agentId, table.startedAt),
+	index$1("agent_runs_project_started_idx").on(table.projectId, table.startedAt)
+]);
+const agentRunsSqlite = sqliteTable("agent_runs", {
+	id: text("id").primaryKey(),
+	sessionId: text("session_id").notNull().references(() => agentSessionsSqlite.id),
+	projectId: text("project_id").notNull(),
+	agentId: text("agent_id").notNull().references(() => agentsSqlite.id),
+	runIndex: integer("run_index").notNull(),
+	sourceKind: text("source_kind").$type().notNull().default("api"),
+	sourceId: text("source_id"),
+	ranByUserId: text("ran_by_user_id"),
+	status: text("status").$type().notNull(),
+	error: text("error", { mode: "json" }),
+	startedAt: integer("started_at", { mode: "timestamp_ms" }).notNull(),
+	finishedAt: integer("finished_at", { mode: "timestamp_ms" }),
+	totalCostUsd: real("total_cost_usd"),
+	totalTokens: integer("total_tokens"),
+	modelsUsed: text("models_used", { mode: "json" }).$type(),
+	createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull(),
+	deletedAt: integer("deleted_at", { mode: "timestamp_ms" })
+}, (table) => [
+	index("agent_runs_session_run_index_idx").on(table.sessionId, table.runIndex),
+	index("agent_runs_agent_started_idx").on(table.agentId, table.startedAt),
+	index("agent_runs_project_started_idx").on(table.projectId, table.startedAt)
+]);
 const agentEvents = pgTable("agent_events", {
 	id: text$1("id").primaryKey(),
 	sessionId: text$1("session_id").notNull().references(() => agentSessions.id),
+	runId: text$1("run_id").references(() => agentRuns.id),
 	seq: integer$1("seq").notNull(),
 	eventType: text$1("event_type").notNull(),
 	payload: jsonb("payload").notNull(),
@@ -16476,12 +16525,37 @@ const agentEvents = pgTable("agent_events", {
 const agentEventsSqlite = sqliteTable("agent_events", {
 	id: text("id").primaryKey(),
 	sessionId: text("session_id").notNull().references(() => agentSessionsSqlite.id),
+	runId: text("run_id").references(() => agentRunsSqlite.id),
 	seq: integer("seq").notNull(),
 	eventType: text("event_type").notNull(),
 	payload: text("payload", { mode: "json" }).notNull(),
 	createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
 	deletedAt: integer("deleted_at", { mode: "timestamp_ms" })
 });
+const usageRecords = pgTable("usage_records", {
+	id: text$1("id").primaryKey(),
+	runId: text$1("run_id").notNull(),
+	runKind: text$1("run_kind").$type().notNull(),
+	kind: text$1("kind").notNull(),
+	label: text$1("label").notNull(),
+	quantity: integer$1("quantity"),
+	unit: text$1("unit"),
+	amount: doublePrecision("amount").notNull(),
+	metadata: jsonb("metadata"),
+	createdAt: timestamp("created_at", { withTimezone: true }).notNull()
+}, (table) => [index$1("usage_records_run_run_kind_idx").on(table.runId, table.runKind), index$1("usage_records_kind_idx").on(table.kind)]);
+const usageRecordsSqlite = sqliteTable("usage_records", {
+	id: text("id").primaryKey(),
+	runId: text("run_id").notNull(),
+	runKind: text("run_kind").$type().notNull(),
+	kind: text("kind").notNull(),
+	label: text("label").notNull(),
+	quantity: integer("quantity"),
+	unit: text("unit"),
+	amount: real("amount").notNull(),
+	metadata: text("metadata", { mode: "json" }),
+	createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull()
+}, (table) => [index("usage_records_run_run_kind_idx").on(table.runId, table.runKind), index("usage_records_kind_idx").on(table.kind)]);
 const triggerAttachments = pgTable("trigger_attachments", {
 	id: text$1("id").primaryKey(),
 	projectId: text$1("project_id").notNull(),
@@ -16972,6 +17046,14 @@ const tableRegistry = {
 		pg: agentEvents,
 		sqlite: agentEventsSqlite
 	},
+	agentRuns: {
+		pg: agentRuns,
+		sqlite: agentRunsSqlite
+	},
+	usageRecords: {
+		pg: usageRecords,
+		sqlite: usageRecordsSqlite
+	},
 	triggerAttachments: {
 		pg: triggerAttachments,
 		sqlite: triggerAttachmentsSqlite
@@ -17086,6 +17168,9 @@ async function insertAgentSession(values) {
 async function selectActiveAgentSession(sessionId) {
 	return (await getDb$1().select().from(agentSessions).where(scopedAnd$1(agentSessions, eq(agentSessions.id, sessionId), isNull(agentSessions.deletedAt))).limit(1))[0];
 }
+async function selectAgentSessionById(sessionId) {
+	return selectActiveAgentSession(sessionId);
+}
 async function touchAgentSession(sessionId, updatedAt) {
 	await getDb$1().update(agentSessions).set({ updatedAt }).where(scopedAnd$1(agentSessions, eq(agentSessions.id, sessionId), isNull(agentSessions.deletedAt)));
 }
@@ -17093,11 +17178,68 @@ async function maxSeqForSession(sessionId) {
 	return (await getDb$1().select({ value: max(agentEvents.seq) }).from(agentEvents).innerJoin(agentSessions, eq(agentSessions.id, agentEvents.sessionId)).where(scopedAnd$1(agentSessions, eq(agentEvents.sessionId, sessionId), isNull(agentEvents.deletedAt))))[0]?.value ?? 0;
 }
 async function insertAgentEvent(values) {
-	await getDb$1().insert(agentEvents).values(values);
+	await getDb$1().insert(agentEvents).values({
+		...values,
+		runId: values.runId ?? null
+	});
 }
 async function listMessagePayloads(sessionId, messageEventType) {
 	return (await getDb$1().select({ payload: agentEvents.payload }).from(agentEvents).innerJoin(agentSessions, eq(agentSessions.id, agentEvents.sessionId)).where(scopedAnd$1(agentSessions, eq(agentEvents.sessionId, sessionId), eq(agentEvents.eventType, messageEventType), isNull(agentEvents.deletedAt))).orderBy(asc(agentEvents.seq))).map((row) => row.payload);
 }
+async function nextRunIndex(sessionId) {
+	return ((await getDb$1().select({ value: max(agentRuns.runIndex) }).from(agentRuns).where(scopedAnd$1(agentRuns, eq(agentRuns.sessionId, sessionId), isNull(agentRuns.deletedAt))))[0]?.value ?? -1) + 1;
+}
+async function insertAgentRun(values) {
+	await getDb$1().insert(agentRuns).values({
+		...values,
+		projectId: projectScopeId(),
+		sourceKind: values.sourceKind ?? "api",
+		sourceId: values.sourceId ?? null,
+		ranByUserId: values.ranByUserId ?? null,
+		error: null,
+		finishedAt: null,
+		totalCostUsd: null,
+		totalTokens: null,
+		modelsUsed: null
+	});
+}
+async function finalizeAgentRun(runId, values) {
+	await getDb$1().update(agentRuns).set({
+		status: values.status,
+		finishedAt: values.finishedAt,
+		error: values.error ?? null,
+		totalCostUsd: values.totalCostUsd,
+		totalTokens: values.totalTokens,
+		modelsUsed: values.modelsUsed,
+		updatedAt: values.updatedAt
+	}).where(scopedAnd$1(agentRuns, eq(agentRuns.id, runId), isNull(agentRuns.deletedAt)));
+}
+async function insertUsageRecord(values) {
+	await getDb$1().insert(usageRecords).values({
+		...values,
+		quantity: values.quantity ?? null,
+		unit: values.unit ?? null,
+		metadata: values.metadata ?? null
+	});
+}
+async function sumUsageForRun(runId, runKind) {
+	const records = await getDb$1().select().from(usageRecords).where(and(eq(usageRecords.runId, runId), eq(usageRecords.runKind, runKind)));
+	let totalCostUsd = 0;
+	let totalTokens = 0;
+	const modelsUsed = /* @__PURE__ */ new Set();
+	for (const record of records) {
+		totalCostUsd += record.amount;
+		if (record.kind === "llm") {
+			if (record.unit === "tokens" && record.quantity != null) totalTokens += record.quantity;
+			modelsUsed.add(record.label);
+		}
+	}
+	return {
+		totalCostUsd,
+		totalTokens,
+		modelsUsed: [...modelsUsed]
+	};
+}
 const MESSAGE_EVENT_TYPE = "message";
 /** Org/user credentials live once in the shared org database; project scope stays per-project. */
 function credentialScopeAnd(scopeType, ...conditions) {
@@ -17200,11 +17342,12 @@ async function touchSession(sessionId) {
 async function nextSeq(sessionId) {
 	return await maxSeqForSession(sessionId) + 1;
 }
-async function appendEvent(sessionId, eventType, payload) {
+async function appendEvent(sessionId, eventType, payload, options) {
 	const seq = await nextSeq(sessionId);
 	await insertAgentEvent({
 		id: crypto.randomUUID(),
 		sessionId,
+		runId: options?.runId ?? null,
 		seq,
 		eventType,
 		payload,
@@ -17216,6 +17359,67 @@ async function appendEvent(sessionId, eventType, payload) {
 async function listMessageEvents(sessionId) {
 	return listMessagePayloads(sessionId, MESSAGE_EVENT_TYPE);
 }
+async function createAgentRun(options) {
+	const now = /* @__PURE__ */ new Date();
+	const runId = crypto.randomUUID();
+	const runIndex = await nextRunIndex(options.sessionId);
+	await insertAgentRun({
+		id: runId,
+		sessionId: options.sessionId,
+		agentId: options.agentId,
+		runIndex,
+		sourceKind: options.sourceKind,
+		sourceId: options.sourceId,
+		ranByUserId: options.ranByUserId,
+		status: "running",
+		startedAt: now,
+		createdAt: now,
+		updatedAt: now,
+		deletedAt: null
+	});
+	return runId;
+}
+async function recordLlmUsageFromAssistantMessage(options) {
+	const { usage } = options;
+	await insertUsageRecord({
+		id: crypto.randomUUID(),
+		runId: options.runId,
+		runKind: "agent",
+		kind: "llm",
+		label: usage.label,
+		quantity: usage.quantity,
+		unit: "tokens",
+		amount: usage.amount,
+		metadata: usage.metadata,
+		createdAt: /* @__PURE__ */ new Date()
+	});
+}
+async function finalizeAgentRunFromPrompt(options) {
+	const finishedAt = options.finishedAt ?? /* @__PURE__ */ new Date();
+	const rollups = await sumUsageForRun(options.runId, "agent");
+	await finalizeAgentRun(options.runId, {
+		status: options.status,
+		finishedAt,
+		error: options.error ?? null,
+		totalCostUsd: rollups.totalCostUsd,
+		totalTokens: rollups.totalTokens,
+		modelsUsed: rollups.modelsUsed,
+		updatedAt: finishedAt
+	});
+}
+async function resolveAgentRunSourceFromSession(sessionId) {
+	const session = await selectAgentSessionById(sessionId);
+	if (!session) return {
+		sourceKind: "api",
+		sourceId: null,
+		ranByUserId: null
+	};
+	return {
+		sourceKind: session.sourceKind,
+		sourceId: session.sourceId,
+		ranByUserId: session.ranByUserId
+	};
+}
 const ALGORITHM$1 = "aes-256-gcm";
 const IV_LENGTH$1 = 12;
 function resolveEncryptionKey$1() {
@@ -18206,6 +18410,6 @@ async function resolveActionCredentials(requirements, options) {
 	return parseResolvedCredentials(requirements, await resolveCredentials(requirements, options.consumer, options.contextOverride));
 }
 //#endregion
-export { zodToJsonSchema as A, isMcp as C, extractWWWAuthenticateParams as D, auth as E, createFetchWithInit as O, defineMcp as S, UnauthorizedError as T, logSystem as _, resolveActionCredentials as a, connectMcpServer as b, appendEvent as c, getSession as d, listMessageEvents as f, getTraceContext as g, captureConsole as h, isCredentialError as i, JSONRPCMessageSchema as j, normalizeHeaders as k, createSession as l, touchSession as m, captureCredentialToolErrors as n, resolveMcpTools as o, resolveRunSourceFromTraceContext as p, createCredentialResolver as r, MESSAGE_EVENT_TYPE as s, buildCredentialRunContext as t, getAgentByRoute as u, withSpan as v, createParser as w, connectMcpStdio as x, connectMcpDefinition as y };
+export { auth as A, connectMcpDefinition as C, isMcp as D, defineMcp as E, JSONRPCMessageSchema as F, createFetchWithInit as M, normalizeHeaders as N, createParser as O, zodToJsonSchema as P, withSpan as S, connectMcpStdio as T, resolveRunSourceFromTraceContext as _, resolveActionCredentials as a, getTraceContext as b, appendEvent as c, finalizeAgentRunFromPrompt as d, getAgentByRoute as f, resolveAgentRunSourceFromSession as g, recordLlmUsageFromAssistantMessage as h, isCredentialError as i, extractWWWAuthenticateParams as j, UnauthorizedError as k, createAgentRun as l, listMessageEvents as m, captureCredentialToolErrors as n, resolveMcpTools as o, getSession as p, createCredentialResolver as r, MESSAGE_EVENT_TYPE as s, buildCredentialRunContext as t, createSession as u, touchSession as v, connectMcpServer as w, logSystem as x, captureConsole as y };
 
-//# sourceMappingURL=dist-BAzfOMfz.mjs.map
+//# sourceMappingURL=dist-DXzvN8aq.mjs.map