@sentry/junior 0.202.0 → 0.204.0

package/dist/worker-CsOLq-mR.js

@@ -0,0 +1,625 @@
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
+import { P as isProviderRetryError, i as getChatConfig } from "./config-nGCW1OTG.js";
+import { S as withLogContext, d as logInfo, f as logWarn, u as logException } from "./logging-BzAk1S_s.js";
+import { At as releaseConversationWork, Bt as isInvalidConversationRecordError, Ct as ensureConversationWake, Mt as requestAnotherSlice, Ot as recordAttemptFailure, Pt as startConversationWork, St as drainConversationMailbox, Tt as getConversationWorkState, bt as countPendingConversationMessages, gt as clearConsumedConversationWake, ht as checkInConversationWork, kt as recordConversationRetry, pt as beginConversationResume, ut as ackMessages, vt as completeConversationStop, xt as deadLetterAttempt, yt as completeConversationWork, zt as isFinalAttempt } from "./stats-DTUbAb88.js";
+import { c as ConversationQueueMessageRejectedError } from "./vercel-queue-DIkVcfK4.js";
+import { a as getTurnRequestDeadline } from "./job-queue-Drn_LXlM.js";
+//#region src/chat/task-execution/worker.ts
+var worker_exports = /* @__PURE__ */ __exportAll({
+	CONVERSATION_WORK_DEFER_DELAY_MS: () => CONVERSATION_WORK_DEFER_DELAY_MS,
+	processConversationWork: () => processConversationWork
+});
+const CONVERSATION_WORK_DEFER_DELAY_MS = 15e3;
+const CONVERSATION_STOP_CHECK_INTERVAL_MS = 500;
+function now(options) {
+	return options.nowMs?.() ?? Date.now();
+}
+function selectContiguousTurnBatch(messages) {
+	const first = messages[0];
+	if (!first) return [];
+	const nextTurnIndex = messages.findIndex((message) => message.input.authorId !== first.input.authorId || message.source !== first.source);
+	return messages.slice(0, nextTurnIndex === -1 ? messages.length : nextTurnIndex);
+}
+/** Prioritize interrupts while keeping each attempt to one Actor and Source. */
+function selectAttemptMessages(work) {
+	const messages = work.messages;
+	const interrupts = messages.filter((message) => message.delivery === "interrupt");
+	if (interrupts.length > 0) return selectContiguousTurnBatch(interrupts);
+	return work.execution.status === "paused" ? [] : selectContiguousTurnBatch(messages);
+}
+function nudgeIdempotencyKey(reason, conversationId, nowMs) {
+	return `${reason}:${conversationId}:${nowMs}`;
+}
+async function requestLostLeaseRecovery(args) {
+	const before = await getConversationWorkState({
+		conversationId: args.conversationId,
+		state: args.options.state
+	});
+	const retry = await recordConversationRetry({
+		conversationId: args.conversationId,
+		leaseToken: args.leaseToken,
+		conversationStore: args.options.conversationStore,
+		nowMs: args.nowMs,
+		state: args.options.state
+	});
+	if (retry === "lost_lease") return;
+	if (retry === "stopped") {
+		logException(/* @__PURE__ */ new Error("Conversation work stopped after repeated failed attempts"), "conversation.work.retry.exhausted", {
+			"app.run.id": before?.execution.runId ?? "unknown",
+			"app.worker.last_progress_at_ms": before?.execution.lastProgressAtMs ?? before?.createdAtMs ?? 0,
+			"app.worker.retry_count": (before?.execution.retryCount ?? 0) + 1
+		});
+		return;
+	}
+	if (!await requestAnotherSlice({
+		conversationId: args.conversationId,
+		destination: args.destination,
+		leaseToken: args.leaseToken,
+		conversationStore: args.options.conversationStore,
+		nowMs: args.nowMs,
+		state: args.options.state
+	})) return;
+	if (!await releaseConversationWork({
+		conversationId: args.conversationId,
+		leaseToken: args.leaseToken,
+		conversationStore: args.options.conversationStore,
+		nowMs: args.nowMs,
+		state: args.options.state
+	})) return;
+	await ensureConversationWake({
+		conversationId: args.conversationId,
+		conversationStore: args.options.conversationStore,
+		idempotencyKey: nudgeIdempotencyKey("lost_lease", args.conversationId, args.nowMs),
+		nowMs: args.nowMs,
+		queue: args.options.queue,
+		replaceExistingWake: true,
+		state: args.options.state
+	});
+}
+/**
+* Record one failed delivery attempt and surface dead-lettered messages.
+*
+* Consumption is logged here so every dead-lettered message leaves a
+* `conversation.work.dead_lettered` trail with its terminal attempt count.
+*/
+async function recordFailedDeliveryAttempt(args) {
+	const failure = await recordAttemptFailure({
+		conversationId: args.conversationId,
+		inboundMessageIds: args.messageIds,
+		leaseToken: args.leaseToken,
+		conversationStore: args.options.conversationStore,
+		nowMs: args.nowMs,
+		state: args.options.state
+	});
+	for (const message of failure.deadLetteredMessages) logWarn("conversation.work.dead_lettered", {
+		"app.conversation.source": message.source,
+		"app.inbound.attempt_count": message.attemptCount ?? 0,
+		"app.inbound.message_id": message.inboundMessageId,
+		"app.inbound.pending_count": failure.pendingCount
+	});
+	return failure;
+}
+/** True only when this attempt dead-lettered messages and left no further pending work. */
+function isTerminalFailure(failure) {
+	return failure.status === "recorded" && failure.deadLetteredMessages.length > 0 && failure.pendingCount === 0;
+}
+function logRetryExhausted(args) {
+	logException(args.error, "conversation.work.retry.exhausted", {
+		"app.run.id": args.work.execution.runId ?? "unknown",
+		"app.worker.last_progress_at_ms": args.work.execution.lastProgressAtMs ?? args.work.createdAtMs,
+		"app.worker.retry_count": args.retryCount
+	});
+}
+function startLeaseCheckIn(args) {
+	const timer = setInterval(() => {
+		const nowMs = now(args.options);
+		checkInConversationWork({
+			conversationId: args.conversationId,
+			leaseToken: args.leaseToken,
+			conversationStore: args.options.conversationStore,
+			nowMs,
+			state: args.options.state
+		}).then((checkedIn) => {
+			if (!checkedIn) {
+				args.onLostLease();
+				logWarn("conversation.work.check_in.failed");
+			}
+		}, (error) => {
+			logException(error, "conversation.work.check_in.failed");
+		});
+	}, args.options.checkInIntervalMs ?? 15e3);
+	timer.unref?.();
+	return timer;
+}
+/** Poll shared state only when a worker adapter asks to observe remote stops. */
+function createConversationStopSignal(args) {
+	const controller = new AbortController();
+	let checking = false;
+	let failureCaptured = false;
+	let listening = false;
+	let timer;
+	const requestStop = () => {
+		if (!controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("Conversation work stopped"));
+	};
+	if (args.initialStopRunId === args.runId) requestStop();
+	const check = async () => {
+		if (checking || controller.signal.aborted) return;
+		checking = true;
+		try {
+			if ((await getConversationWorkState({
+				conversationId: args.conversationId,
+				state: args.options.state
+			}))?.execution.stop?.runId === args.runId) requestStop();
+		} catch (error) {
+			if (!failureCaptured) {
+				failureCaptured = true;
+				logException(error, "conversation.work.stop_check.failed");
+			}
+		} finally {
+			checking = false;
+		}
+	};
+	return {
+		close() {
+			if (timer) clearInterval(timer);
+		},
+		isEnabled() {
+			return listening;
+		},
+		wasObserved() {
+			return listening && controller.signal.aborted;
+		},
+		signal() {
+			listening = true;
+			if (!timer && !controller.signal.aborted) {
+				timer = setInterval(() => void check(), CONVERSATION_STOP_CHECK_INTERVAL_MS);
+				timer.unref?.();
+			}
+			return controller.signal;
+		}
+	};
+}
+/** Process one queue wake-up for a conversation. */
+async function processConversationWork(message, options) {
+	return withLogContext({ conversationId: message.conversationId }, () => processConversationWorkInContext(message, options));
+}
+async function processConversationWorkInContext(message, options) {
+	const conversationId = message.conversationId;
+	let initial;
+	try {
+		initial = await getConversationWorkState({
+			conversationId,
+			state: options.state
+		});
+	} catch (error) {
+		if (isInvalidConversationRecordError(error)) throw new ConversationQueueMessageRejectedError("invalid_record", `Conversation record failed validation for ${conversationId}`, { conversationId });
+		throw error;
+	}
+	if (!initial || countPendingConversationMessages(initial) === 0 && initial.execution.status === "idle" && !initial.execution.lease) {
+		if (initial) await clearConsumedConversationWake({
+			conversationId,
+			conversationStore: options.conversationStore,
+			nowMs: now(options),
+			state: options.state
+		});
+		return { status: "no_work" };
+	}
+	let destination = initial.destination;
+	if (!destination && options.conversationStore) {
+		const stored = await options.conversationStore.get({ conversationId });
+		if (stored && !stored.parentConversationId) destination = stored.destination;
+	}
+	const lease = await startConversationWork({
+		conversationId,
+		conversationStore: options.conversationStore,
+		nowMs: now(options),
+		state: options.state
+	});
+	if (lease.status === "no_work") {
+		await clearConsumedConversationWake({
+			conversationId,
+			conversationStore: options.conversationStore,
+			nowMs: now(options),
+			state: options.state
+		});
+		return { status: "no_work" };
+	}
+	if (lease.status === "active") {
+		const nudgeNowMs = now(options);
+		await ensureConversationWake({
+			conversationId,
+			conversationStore: options.conversationStore,
+			delayMs: CONVERSATION_WORK_DEFER_DELAY_MS,
+			idempotencyKey: nudgeIdempotencyKey("active", conversationId, nudgeNowMs),
+			nowMs: nudgeNowMs,
+			queue: options.queue,
+			replaceExistingWake: true,
+			state: options.state
+		});
+		logInfo("conversation.work.nudge.deferred", { "app.lease.expires_at_ms": lease.leaseExpiresAtMs });
+		return { status: "active" };
+	}
+	const startedAtMs = now(options);
+	const softYieldDeadlineMs = startedAtMs + (options.softYieldAfterMs ?? getChatConfig().conversationWorkSoftYieldAfterMs);
+	let attemptMessageIds = [];
+	let attemptSelectedMessageIds = /* @__PURE__ */ new Set();
+	let attemptStartMessageIds = /* @__PURE__ */ new Set();
+	let failedWithoutProgress = false;
+	let leaseLost = false;
+	const markLeaseLost = () => {
+		leaseLost = true;
+	};
+	const timer = startLeaseCheckIn({
+		conversationId,
+		leaseToken: lease.leaseToken,
+		onLostLease: markLeaseLost,
+		options
+	});
+	logInfo("conversation.work.lease.acquired", {
+		"app.lease.expires_at_ms": lease.leaseExpiresAtMs,
+		"app.worker.soft_yield_deadline_ms": softYieldDeadlineMs
+	});
+	const drain = (handle) => drainConversationMailbox({
+		conversationId,
+		leaseToken: lease.leaseToken,
+		conversationStore: options.conversationStore,
+		handle: async (messages) => {
+			const candidates = messages.filter((message) => message.delivery === "interrupt" && (attemptSelectedMessageIds.has(message.inboundMessageId) || !attemptStartMessageIds.has(message.inboundMessageId)));
+			if (candidates.length === 0) return [];
+			return await handle(candidates) ?? candidates.map((message) => message.inboundMessageId);
+		},
+		nowMs: now(options),
+		state: options.state
+	});
+	const requestDeadlineAtMs = getTurnRequestDeadline()?.deadlineAtMs;
+	const shouldYield = () => leaseLost || now(options) >= softYieldDeadlineMs || requestDeadlineAtMs !== void 0 && Date.now() >= requestDeadlineAtMs;
+	const checkIn = async () => {
+		const checkedIn = await checkInConversationWork({
+			conversationId,
+			leaseToken: lease.leaseToken,
+			conversationStore: options.conversationStore,
+			nowMs: now(options),
+			state: options.state
+		});
+		if (!checkedIn) markLeaseLost();
+		return checkedIn;
+	};
+	const yieldWork = async () => {
+		const yieldNowMs = now(options);
+		await ensureConversationWake({
+			conversationId,
+			conversationStore: options.conversationStore,
+			idempotencyKey: nudgeIdempotencyKey("yield", conversationId, yieldNowMs),
+			nowMs: yieldNowMs,
+			queue: options.queue,
+			replaceExistingWake: true,
+			state: options.state
+		});
+		if (!await releaseConversationWork({
+			conversationId,
+			leaseToken: lease.leaseToken,
+			conversationStore: options.conversationStore,
+			nowMs: yieldNowMs,
+			state: options.state
+		})) return { status: "lost_lease" };
+		logInfo("conversation.work.yielded", {
+			"app.worker.elapsed_ms": now(options) - startedAtMs,
+			"app.worker.soft_yield_deadline_ms": softYieldDeadlineMs
+		});
+		return { status: "yielded" };
+	};
+	try {
+		let hasRun = false;
+		let resumeIfStopped = false;
+		while (true) {
+			attemptMessageIds = [];
+			const leasedWork = await getConversationWorkState({
+				conversationId,
+				state: options.state
+			});
+			if (!leasedWork || leasedWork.lease?.leaseToken !== lease.leaseToken || leaseLost) {
+				markLeaseLost();
+				await requestLostLeaseRecovery({
+					conversationId,
+					destination,
+					leaseToken: lease.leaseToken,
+					nowMs: now(options),
+					options
+				});
+				return { status: "lost_lease" };
+			}
+			const resumePending = leasedWork.execution.status === "paused";
+			const attemptMessages = selectAttemptMessages(leasedWork);
+			const runId = leasedWork.execution.runId;
+			if (!runId) throw new Error(`Conversation run is missing for ${conversationId}`);
+			attemptStartMessageIds = new Set(leasedWork.messages.map((message) => message.inboundMessageId));
+			if (hasRun && shouldYield()) {
+				if (resumePending) return await yieldWork();
+				break;
+			}
+			if (resumePending && attemptMessages.length === 0) {
+				if (!await beginConversationResume({
+					conversationId,
+					leaseToken: lease.leaseToken,
+					conversationStore: options.conversationStore,
+					nowMs: now(options),
+					state: options.state
+				})) {
+					markLeaseLost();
+					await requestLostLeaseRecovery({
+						conversationId,
+						destination,
+						leaseToken: lease.leaseToken,
+						nowMs: now(options),
+						options
+					});
+					return { status: "lost_lease" };
+				}
+			}
+			attemptMessageIds = attemptMessages.map((message) => message.inboundMessageId);
+			attemptSelectedMessageIds = new Set(attemptMessageIds);
+			const ack = async () => {
+				if (!await ackMessages({
+					conversationId,
+					inboundMessageIds: attemptMessageIds,
+					leaseToken: lease.leaseToken,
+					conversationStore: options.conversationStore,
+					nowMs: now(options),
+					state: options.state
+				})) {
+					markLeaseLost();
+					throw new Error(`Conversation work lease lost before inbox ack for ${conversationId}`);
+				}
+			};
+			const stop = createConversationStopSignal({
+				conversationId,
+				initialStopRunId: leasedWork.execution.stop?.runId,
+				options,
+				runId
+			});
+			const workerContext = {
+				attempt: {
+					ack,
+					conversationId,
+					destination,
+					drain,
+					isFinalAttempt: attemptMessages.some((message) => isFinalAttempt(message)),
+					messages: attemptMessages
+				},
+				conversationId,
+				destination,
+				shouldYield,
+				stopSignal: stop.signal,
+				checkIn
+			};
+			let result;
+			try {
+				result = await options.run(workerContext);
+			} finally {
+				stop.close();
+			}
+			resumeIfStopped ||= stop.isEnabled();
+			hasRun = true;
+			if (result.status === "lost_lease") {
+				await requestLostLeaseRecovery({
+					conversationId,
+					destination,
+					leaseToken: lease.leaseToken,
+					nowMs: now(options),
+					options
+				});
+				return { status: "lost_lease" };
+			}
+			if (leaseLost) {
+				await requestLostLeaseRecovery({
+					conversationId,
+					destination,
+					leaseToken: lease.leaseToken,
+					nowMs: now(options),
+					options
+				});
+				return { status: "lost_lease" };
+			}
+			if (result.status === "completed" && stop.wasObserved()) {
+				if ((await completeConversationStop({
+					conversationId,
+					conversationStore: options.conversationStore,
+					leaseToken: lease.leaseToken,
+					nowMs: now(options),
+					runId,
+					state: options.state
+				})).status === "lost_lease") {
+					markLeaseLost();
+					await requestLostLeaseRecovery({
+						conversationId,
+						destination,
+						leaseToken: lease.leaseToken,
+						nowMs: now(options),
+						options
+					});
+					return { status: "lost_lease" };
+				}
+			}
+			if (result.status === "yielded") {
+				if (!await requestAnotherSlice({
+					conversationId,
+					destination,
+					leaseToken: lease.leaseToken,
+					conversationStore: options.conversationStore,
+					nowMs: now(options),
+					state: options.state
+				})) return { status: "lost_lease" };
+				return await yieldWork();
+			}
+			if (result.status === "deferred") {
+				const deferredNowMs = now(options);
+				if (!await releaseConversationWork({
+					conversationId,
+					leaseToken: lease.leaseToken,
+					conversationStore: options.conversationStore,
+					nowMs: deferredNowMs,
+					state: options.state
+				})) return { status: "lost_lease" };
+				return (await ensureConversationWake({
+					conversationId,
+					conversationStore: options.conversationStore,
+					idempotencyKey: nudgeIdempotencyKey("deferred", conversationId, deferredNowMs),
+					nowMs: deferredNowMs,
+					queue: options.queue,
+					state: options.state
+				})).status === "enqueued" ? { status: "pending_requeued" } : { status: "completed" };
+			}
+			if (attemptMessageIds.length > 0) {
+				const failure = await recordFailedDeliveryAttempt({
+					conversationId,
+					leaseToken: lease.leaseToken,
+					nowMs: now(options),
+					messageIds: attemptMessageIds,
+					options
+				});
+				if (isTerminalFailure(failure)) {
+					if (failure.retryCount >= 5) logRetryExhausted({
+						error: /* @__PURE__ */ new Error("Conversation work stopped after repeated failed attempts"),
+						retryCount: failure.retryCount,
+						work: leasedWork
+					});
+					await deadLetterAttempt({
+						conversationId,
+						leaseToken: lease.leaseToken,
+						conversationStore: options.conversationStore,
+						nowMs: now(options),
+						state: options.state
+					});
+					return { status: "failed" };
+				}
+				if (failure.status === "lost_lease") return { status: "lost_lease" };
+				if (failure.status === "recorded") {
+					failedWithoutProgress = true;
+					break;
+				}
+			}
+			if (result.status === "paused") break;
+			const next = await getConversationWorkState({
+				conversationId,
+				state: options.state
+			});
+			if (!next || next.lease?.leaseToken !== lease.leaseToken) return { status: "lost_lease" };
+			if (next.execution.status !== "paused" && countPendingConversationMessages(next) === 0) break;
+		}
+		const completion = await completeConversationWork({
+			conversationId,
+			leaseToken: lease.leaseToken,
+			madeProgress: !failedWithoutProgress,
+			resumeIfStopped,
+			conversationStore: options.conversationStore,
+			nowMs: now(options),
+			state: options.state
+		});
+		if (completion === "lost_lease") return { status: "lost_lease" };
+		if (completion === "pending") {
+			const nudgeNowMs = now(options);
+			return (await ensureConversationWake({
+				conversationId,
+				conversationStore: options.conversationStore,
+				idempotencyKey: nudgeIdempotencyKey("pending", conversationId, nudgeNowMs),
+				nowMs: nudgeNowMs,
+				queue: options.queue,
+				state: options.state
+			})).status === "enqueued" ? { status: "pending_requeued" } : { status: "completed" };
+		}
+		logInfo("conversation.work.completed", { "app.worker.elapsed_ms": now(options) - startedAtMs });
+		return { status: "completed" };
+	} catch (error) {
+		const errorNowMs = now(options);
+		let recoveryRecorded = false;
+		try {
+			const failure = attemptMessageIds.length > 0 ? await recordFailedDeliveryAttempt({
+				conversationId,
+				leaseToken: lease.leaseToken,
+				nowMs: errorNowMs,
+				messageIds: attemptMessageIds,
+				options
+			}) : void 0;
+			if (failure && isTerminalFailure(failure)) {
+				if (failure.retryCount >= 5) logRetryExhausted({
+					error,
+					retryCount: failure.retryCount,
+					work: initial
+				});
+				await deadLetterAttempt({
+					conversationId,
+					leaseToken: lease.leaseToken,
+					conversationStore: options.conversationStore,
+					nowMs: errorNowMs,
+					state: options.state
+				});
+			} else if (failure?.status === "recorded") {
+				await releaseConversationWork({
+					conversationId,
+					leaseToken: lease.leaseToken,
+					conversationStore: options.conversationStore,
+					nowMs: errorNowMs,
+					state: options.state
+				});
+				await ensureConversationWake({
+					conversationId,
+					conversationStore: options.conversationStore,
+					idempotencyKey: nudgeIdempotencyKey("error", conversationId, errorNowMs),
+					nowMs: errorNowMs,
+					queue: options.queue,
+					replaceExistingWake: true,
+					state: options.state
+				});
+			} else {
+				if ((failure ? failure.status : await recordConversationRetry({
+					conversationId,
+					leaseToken: lease.leaseToken,
+					conversationStore: options.conversationStore,
+					nowMs: errorNowMs,
+					state: options.state
+				})) === "stopped") {
+					logException(error, "conversation.work.retry.exhausted", {
+						"app.run.id": initial.execution.runId ?? "unknown",
+						"app.worker.last_progress_at_ms": initial.execution.lastProgressAtMs ?? initial.createdAtMs,
+						"app.worker.retry_count": failure?.retryCount ?? (initial.execution.retryCount ?? 0) + 1
+					});
+					recoveryRecorded = true;
+					return { status: "failed" };
+				}
+				if (await requestAnotherSlice({
+					conversationId,
+					destination,
+					leaseToken: lease.leaseToken,
+					conversationStore: options.conversationStore,
+					nowMs: errorNowMs,
+					state: options.state
+				})) await ensureConversationWake({
+					conversationId,
+					conversationStore: options.conversationStore,
+					idempotencyKey: nudgeIdempotencyKey("error", conversationId, errorNowMs),
+					nowMs: errorNowMs,
+					queue: options.queue,
+					replaceExistingWake: true,
+					state: options.state
+				});
+				await releaseConversationWork({
+					conversationId,
+					leaseToken: lease.leaseToken,
+					conversationStore: options.conversationStore,
+					nowMs: errorNowMs,
+					state: options.state
+				});
+			}
+			recoveryRecorded = true;
+		} catch (recoveryError) {
+			logException(recoveryError, "conversation.work.requeue.failed");
+		}
+		if (!isProviderRetryError(error)) logException(error, "conversation.work.failed", { "app.worker.elapsed_ms": now(options) - startedAtMs });
+		if (!recoveryRecorded) throw error;
+		return { status: "failed" };
+	} finally {
+		clearInterval(timer);
+	}
+}
+//#endregion
+export { worker_exports as n, processConversationWork as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.202.0",
+  "version": "0.204.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -85,7 +85,7 @@
     "pg": "^8.16.3",
     "yaml": "^2.9.0",
     "zod": "^4.5.4",
-    "@sentry/junior-plugin-api": "0.202.0"
+    "@sentry/junior-plugin-api": "0.204.0"
   },
   "devDependencies": {
     "@emnapi/core": "^1.10.0",
@@ -100,20 +100,20 @@
     "msw": "^2.14.6",
     "nitro": "3.0.260522-beta",
     "oxlint": "^1.79.0",
-    "tsup": "^8.5.1",
+    "tsdown": "0.23.0",
     "typescript": "^6.0.3",
     "vercel": "^54.4.0",
     "vitest": "^4.1.7",
-    "@sentry/junior-testing": "0.0.0",
-    "@sentry/junior-github": "0.202.0",
-    "@sentry/junior-memory": "0.202.0"
+    "@sentry/junior-github": "0.204.0",
+    "@sentry/junior-memory": "0.204.0",
+    "@sentry/junior-testing": "0.0.0"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsdown",
     "acp:smoke": "pnpm exec tsx scripts/acp-smoke.ts",
     "db:generate": "pnpm exec drizzle-kit generate --config drizzle.config.ts",
-    "lint": "oxlint --config .oxlintrc.json --deny-warnings src tests scripts bin tsup.config.ts && depcruise --config .dependency-cruiser.mjs src/chat",
-    "lint:fix": "oxlint --config .oxlintrc.json --deny-warnings --fix src tests scripts bin tsup.config.ts",
+    "lint": "oxlint --config .oxlintrc.json --deny-warnings src tests scripts bin tsdown.config.ts && depcruise --config .dependency-cruiser.mjs src/chat",
+    "lint:fix": "oxlint --config .oxlintrc.json --deny-warnings --fix src tests scripts bin tsdown.config.ts",
     "test": "vitest run --maxWorkers=4",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",