@sentry/junior 0.266.0 → 0.268.0

package/dist/db-BU4LQD8s.d.ts

@@ -0,0 +1,6 @@
+import "./store-xMuuXRE0.js";
+import "./schema-ZngqcOWM.js";
+import { z } from "zod";
+import "drizzle-orm/pg-core";
+import "drizzle-orm/migrator";
+import "drizzle-orm/pg-core/session";

package/dist/{executor-TnWbvL09.js → executor-4vhvsMZJ.js}

@@ -1,6 +1,6 @@
-import "./config-C0UwYqDK.js";
-import { f as logException } from "./logging-Ce0mXZ8J.js";
-import { a as juniorAgentInvocations, c as juniorIdentities, d as juniorDestinations, f as timestamptz, i as juniorAgentBindings, l as juniorUsers, s as juniorConversations } from "./agent-invocations-CxKldAeB.js";
+import "./config-DrTeF80T.js";
+import { p as logException } from "./logging-DLSpkSSr.js";
+import { a as juniorAgentInvocations, c as juniorIdentities, d as juniorDestinations, f as timestamptz, i as juniorAgentBindings, l as juniorUsers, s as juniorConversations } from "./agent-invocations-C1RNOCs8.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { sql } from "drizzle-orm";
 import { bigint, boolean, check, date, doublePrecision, foreignKey, index, integer, jsonb, pgTable, primaryKey, text, uniqueIndex, uuid } from "drizzle-orm/pg-core";
@@ -292,7 +292,10 @@ const juniorStats = pgTable("junior_stats", {
 * One row per Automation of either kind. `record` holds the fields that have
 * no column. Each write also copies the nested fields that queries filter or
 * search on into columns: `team_id`, `channel_id`, `creator_slack_user_id`,
-* `instruction`, and the event trigger `namespace` and `identifier`.
+* `instruction`, and the event trigger `namespace` and `identifier`. An event
+* trigger with no identifier runs for every resource of its namespace, so its
+* `identifier` is null. The match index finds those rows with
+* `identifier is null`.
 */
 const juniorAutomations = pgTable("junior_automations", {
 	id: text("id").primaryKey(),
@@ -317,7 +320,7 @@ const juniorAutomations = pgTable("junior_automations", {
 	check("junior_automations_kind_check", sql`${table.kind} in ('scheduled', 'event')`),
 	check("junior_automations_status_check", sql`${table.status} in ('active', 'blocked', 'paused', 'completed', 'deleted')`),
 	check("junior_automations_record_check", sql`jsonb_typeof(${table.record}) = 'object'`),
-	check("junior_automations_trigger_check", sql`(${table.kind} = 'scheduled' and ${table.namespace} is null and ${table.identifier} is null) or (${table.kind} = 'event' and ${table.namespace} is not null and ${table.identifier} is not null and ${table.nextRunAtMs} is null and ${table.runNowAtMs} is null and ${table.status} <> 'completed')`),
+	check("junior_automations_trigger_check", sql`(${table.kind} = 'scheduled' and ${table.namespace} is null and ${table.identifier} is null) or (${table.kind} = 'event' and ${table.namespace} is not null and ${table.nextRunAtMs} is null and ${table.runNowAtMs} is null and ${table.status} <> 'completed')`),
 	index("junior_automations_team_idx").on(table.teamId, table.createdAtMs, table.id).where(sql`${table.status} <> 'deleted'`),
 	index("junior_automations_creator_identity_idx").on(table.creatorIdentityId, table.createdAtMs, table.id),
 	index("junior_automations_run_now_due_idx").on(table.runNowAtMs, table.createdAtMs, table.id).where(sql`${table.status} = 'active' AND ${table.runNowAtMs} IS NOT NULL`),
@@ -379,6 +382,76 @@ const juniorAutomationRuns = pgTable("junior_automation_runs", {
 	index("junior_automation_runs_completed_idx").on(table.completedAtMs),
 	index("junior_automation_runs_incomplete_idx").on(table.automationId, table.scheduledForMs).where(sql`${table.status} in ('pending', 'running')`)
 ]);
+// src/db/schema/review-items.ts
+/**
+* One Review item: something that needs a person. See
+* `chat/review-items/README.md`. An action item stores its `request`, and
+* its `answer` after an assignee submits it. `closed_at` is set for `done`
+* and `dismissed`. `closed_by_user_id` is null when an agent closed it.
+*/
+const juniorReviewItems = pgTable("junior_review_items", {
+	id: text("id").primaryKey(),
+	kind: text("kind").$type().notNull(),
+	status: text("status").$type().notNull(),
+	/**
+	* `private` when the Conversation that added it is not public. A private
+	* item stays private and links only to that Conversation.
+	*/
+	visibility: text("visibility").$type().notNull(),
+	title: text("title").notNull(),
+	body: text("body").notNull(),
+	request: jsonb("request").$type(),
+	answer: jsonb("answer").$type(),
+	assignedToEveryone: boolean("assigned_to_everyone").notNull().default(false),
+	dedupeKey: text("dedupe_key").notNull(),
+	subjectId: text("subject_id"),
+	subjectTitle: text("subject_title"),
+	subjectUrl: text("subject_url"),
+	/** Conversation of the agent that added the item. */
+	addedByConversationId: text("added_by_conversation_id").notNull(),
+	/**
+	* Provider tenant, such as a Slack workspace, of the Conversation that
+	* added the item. A public item is visible only inside it.
+	*/
+	provider: text("provider"),
+	providerTenantId: text("provider_tenant_id"),
+	automationId: text("automation_id").references(() => juniorAutomations.id, { onDelete: "set null" }),
+	closedAt: timestamptz("closed_at"),
+	closedByUserId: text("closed_by_user_id").references(() => juniorUsers.id),
+	closeReason: text("close_reason"),
+	createdAt: timestamptz("created_at").notNull(),
+	updatedAt: timestamptz("updated_at").notNull()
+}, (table) => [
+	check("junior_review_items_kind_check", sql`(${table.kind} = 'notice' and ${table.request} is null and ${table.answer} is null) or (${table.kind} = 'action' and ${table.request} is not null)`),
+	check("junior_review_items_status_check", sql`(${table.status} = 'open' and ${table.closedAt} is null) or (${table.status} in ('done', 'dismissed') and ${table.closedAt} is not null)`),
+	check("junior_review_items_tenant_check", sql`(${table.provider} is null) = (${table.providerTenantId} is null)`),
+	check("junior_review_items_visibility_check", sql`${table.visibility} = 'public' or not ${table.assignedToEveryone}`),
+	uniqueIndex("junior_review_items_open_dedupe_uidx").on(sql`coalesce(${table.provider}, '')`, sql`coalesce(${table.providerTenantId}, '')`, table.dedupeKey).where(sql`${table.status} = 'open'`),
+	index("junior_review_items_status_idx").on(table.status, table.updatedAt, table.id),
+	index("junior_review_items_subject_idx").on(table.subjectId, table.status),
+	index("junior_review_items_automation_idx").on(table.automationId, table.status)
+]);
+/** The assigned Users of a Review item. Everyone is a flag on the item. */
+const juniorReviewItemAssignees = pgTable("junior_review_item_assignees", {
+	itemId: text("item_id").notNull().references(() => juniorReviewItems.id, { onDelete: "cascade" }),
+	userId: text("user_id").notNull().references(() => juniorUsers.id, { onDelete: "cascade" })
+}, (table) => [primaryKey({ columns: [table.itemId, table.userId] }), index("junior_review_item_assignees_user_idx").on(table.userId)]);
+/** The Conversations linked to a Review item. */
+const juniorReviewItemConversations = pgTable("junior_review_item_conversations", {
+	itemId: text("item_id").notNull().references(() => juniorReviewItems.id, { onDelete: "cascade" }),
+	conversationId: text("conversation_id").notNull().references(() => juniorConversations.conversationId, { onDelete: "cascade" })
+}, (table) => [primaryKey({ columns: [table.itemId, table.conversationId] }), index("junior_review_item_conversations_conversation_idx").on(table.conversationId)]);
+/**
+* The Slack message that shows a Review item in one linked Slack thread.
+* Junior updates it in place after each change.
+*/
+const juniorReviewItemSlackCards = pgTable("junior_review_item_slack_cards", {
+	itemId: text("item_id").notNull().references(() => juniorReviewItems.id, { onDelete: "cascade" }),
+	conversationId: text("conversation_id").notNull(),
+	teamId: text("team_id").notNull(),
+	channelId: text("channel_id").notNull(),
+	messageTs: text("message_ts").notNull()
+}, (table) => [primaryKey({ columns: [table.itemId, table.conversationId] })]);
 // src/db/schema/workspaces.ts
 /** Named recipe used to prepare a reusable Sandbox. */
 const juniorWorkspaces = pgTable("junior_workspaces", {
@@ -452,6 +525,10 @@ const juniorSqlSchema = {
 	juniorLocationConfigurations,
 	juniorDestinations,
 	juniorIdentities,
+	juniorReviewItemAssignees,
+	juniorReviewItemConversations,
+	juniorReviewItemSlackCards,
+	juniorReviewItems,
 	juniorSnapshots,
 	juniorStats,
 	juniorAutomationRuns,
@@ -706,4 +783,4 @@ function createJuniorSqlExecutor(args) {
 		statementTimeoutMs
 	});
 }
-export { juniorConversationAnnotations as _, juniorAutomationRuns as a, juniorAttachments as b, juniorStats as c, juniorConversationBindings as d, juniorConversationBriefs as f, juniorApiTokens as g, juniorConversationEvents as h, juniorWorkspaces as i, juniorLocationConfigurations as l, juniorConversationMetrics as m, juniorSnapshots as n, juniorAutomationVersions as o, CONVERSATION_METRICS as p, juniorWorkspaceRepos as r, juniorAutomations as s, createJuniorSqlExecutor as t, juniorConversationParticipants as u, juniorCodeChanges as v, juniorArtifacts as x, juniorCodeRepositories as y };
+export { juniorCodeRepositories as C, juniorCodeChanges as S, juniorArtifacts as T, CONVERSATION_METRICS as _, juniorReviewItemAssignees as a, juniorApiTokens as b, juniorReviewItems as c, juniorAutomations as d, juniorStats as f, juniorConversationBriefs as g, juniorConversationBindings as h, juniorWorkspaces as i, juniorAutomationRuns as l, juniorConversationParticipants as m, juniorSnapshots as n, juniorReviewItemConversations as o, juniorLocationConfigurations as p, juniorWorkspaceRepos as r, juniorReviewItemSlackCards as s, createJuniorSqlExecutor as t, juniorAutomationVersions as u, juniorConversationMetrics as v, juniorAttachments as w, juniorConversationAnnotations as x, juniorConversationEvents as y };

package/dist/instrumentation.js

@@ -1,6 +1,6 @@
-import { F as getDeploymentTelemetryAttributes, P as getDeploymentServiceVersion } from "./logging-Ce0mXZ8J.js";
+import { F as getDeploymentServiceVersion, I as getDeploymentTelemetryAttributes } from "./logging-DLSpkSSr.js";
 import { a as getClient, c as init, o as getGlobalScope } from "./sentry-MDkYAVPV.js";
-import { n as getCurrentConversationPrivacy } from "./conversation-privacy-CY7JVjxn.js";
+import { n as getCurrentConversationPrivacy } from "./conversation-privacy-CxlOCiUo.js";
 import { t as consumePrivateTraceResultMarker } from "./private-trace-result-CE7_lEdq.js";
 // src/chat/sentry-payload-filter.ts
 const PAYLOAD_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
@@ -164,6 +164,10 @@ function initSentry() {
 		environment: process.env.SENTRY_ENVIRONMENT ?? process.env.VERCEL_ENV ?? process.env.NODE_ENV,
 		release: serviceVersion,
 		tracesSampleRate: getSampleRate(process.env.SENTRY_TRACES_SAMPLE_RATE, 1),
+		ignoreSpans: [{
+			op: "http.server",
+			attributes: { "url.path": "/_vercel/ping" }
+		}],
 		dataCollection: {
 			httpBodies: ["incomingRequest"],
 			databaseQueryData: false

package/dist/{assistant-reply-UyzAfZQo.js → interruption-marker-CkncDT8d.js}

@@ -1,4 +1,4 @@
-import { Wt as extractAssistantText } from "./tasks-DDT-J3Rf.js";
+import { Ln as extractAssistantText } from "./tasks-SB9z-VTU.js";
 // src/chat/no-reply.ts
 const NO_REPLY_MARKER = "[[NO_REPLY]]";
 /**
@@ -40,4 +40,10 @@ function getAssistantReplyText(message) {
 	const decision = decideReply(message);
 	return decision.kind === "deliver" ? decision.text : void 0;
 }
-export { isNoReplyMarker as a, NO_REPLY_MARKER as i, getAssistantReplyText as n, sanitizeAssistantText as r, decideReply as t };
+// src/chat/interruption-marker.ts
+const INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
+/** Return the marker added when a visible reply ended mid-execution. */
+function getInterruptionMarker() {
+	return INTERRUPTED_MARKER;
+}
+export { NO_REPLY_MARKER as a, sanitizeAssistantText as i, decideReply as n, isNoReplyMarker as o, getAssistantReplyText as r, getInterruptionMarker as t };

package/dist/{job-queue-DBpHmKnd.js → job-queue-In9QKz-I.js}

@@ -1,5 +1,5 @@
-import { i as getChatConfig } from "./config-C0UwYqDK.js";
-import { T as withSpan } from "./logging-Ce0mXZ8J.js";
+import { i as getChatConfig } from "./config-DrTeF80T.js";
+import { E as withSpan, m as logInfo, p as logException } from "./logging-DLSpkSSr.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { z } from "zod";
 import { createHash, createHmac, timingSafeEqual } from "node:crypto";
@@ -40,6 +40,131 @@ function runWithTurnRequestDeadline(callback, startedAtMs = Date.now()) {
 	if (requestDeadlineStorage.getStore()) return callback();
 	return requestDeadlineStorage.run(createTurnRequestDeadline(startedAtMs), callback);
 }
+// src/chat/queue/bullmq.ts
+const MAX_ATTEMPTS = 50;
+const MAX_BACKOFF_MS = 3e4;
+const COMPLETED_JOB_AGE_SECONDS = 3600;
+const FAILED_JOB_AGE_SECONDS = 86400;
+/**
+* Import a module by a name held in a variable.
+*
+* Bundlers follow a literal `import("bullmq")` and put BullMQ into the
+* production server, even though production never selects this provider.
+* Node resolves this import when the app runs instead.
+*/
+function importAtRuntime(specifier) {
+	return import(
+		/* @vite-ignore */
+		specifier
+);
+}
+function bullmqConfig() {
+	const config = getChatConfig().queue;
+	if (config.provider !== "bullmq") throw new Error("The BullMQ queue provider is not configured");
+	return config;
+}
+/** Load BullMQ and open a Redis client that the caller must close. */
+async function connect() {
+	const [bullmq, redis] = await Promise.all([importAtRuntime("bullmq"), importAtRuntime("redis")]).catch((error) => {
+		throw new Error("JUNIOR_QUEUE_PROVIDER=bullmq needs the bullmq and redis packages installed", { cause: error });
+	});
+	const client = redis.createClient({ url: bullmqConfig().redisUrl });
+	try {
+		await client.connect();
+		return {
+			bullmq,
+			connection: bullmq.createNodeRedisClient(client)
+		};
+	} catch (error) {
+		client.destroy();
+		throw error;
+	}
+}
+/** BullMQ job ids must not contain ":", and Junior's keys do. */
+function toJobId(idempotencyKey) {
+	return `k-${createHash("sha256").update(idempotencyKey).digest("base64url")}`;
+}
+function metadataFor(job, consumer) {
+	return {
+		consumerGroup: consumer.consumerGroup,
+		createdAt: new Date(job.timestamp),
+		deliveryCount: job.attemptsMade + 1,
+		messageId: job.id ?? "",
+		topicName: consumer.topic
+	};
+}
+async function processJob(job, consumer) {
+	const { payload, retentionSeconds } = job.data;
+	if (retentionSeconds !== void 0 && Date.now() - job.timestamp > retentionSeconds * 1e3) return;
+	const metadata = metadataFor(job, consumer);
+	try {
+		await consumer.handler(payload, metadata);
+	} catch (error) {
+		if (consumer.retry(error, metadata)?.acknowledge) return;
+		throw error;
+	}
+}
+/** Start one BullMQ worker for each consumer, on a Redis client it owns. */
+async function startWorker(consumers) {
+	const { bullmq, connection } = await connect();
+	const concurrency = bullmqConfig().workerConcurrency;
+	const workers = consumers.map((consumer) => {
+		const worker = new bullmq.Worker(consumer.topic, (job) => processJob(job, consumer), {
+			concurrency,
+			connection,
+			...consumer.visibilityTimeoutSeconds !== void 0 && { lockDuration: consumer.visibilityTimeoutSeconds * 1e3 },
+			settings: { backoffStrategy: (attemptsMade) => Math.min(1e3 * 2 ** (attemptsMade - 1), MAX_BACKOFF_MS) }
+		});
+		worker.on("error", (error) => {
+			logException(error, "queue.bullmq.worker.exception", { "messaging.destination.name": consumer.topic });
+		});
+		return worker;
+	});
+	logInfo("queue.bullmq.worker.started", {
+		"app.queue.worker_concurrency": concurrency,
+		"messaging.destination.names": consumers.map((consumer) => consumer.topic)
+	});
+	return { close: async () => {
+		try {
+			const failures = (await Promise.allSettled(workers.map((worker) => worker.close()))).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+			if (failures.length > 0) throw new AggregateError(failures, "BullMQ workers did not close");
+		} finally {
+			await connection.quit();
+		}
+	} };
+}
+/** Add one job on a Redis client that is open only for this send. */
+async function send$1(topic, payload, options = {}) {
+	const { bullmq, connection } = await connect();
+	const queue = new bullmq.Queue(topic, { connection });
+	try {
+		const job = await queue.add(topic, {
+			payload,
+			retentionSeconds: options.retentionSeconds
+		}, {
+			attempts: MAX_ATTEMPTS,
+			backoff: { type: "custom" },
+			delay: options.delaySeconds ? options.delaySeconds * 1e3 : void 0,
+			jobId: options.idempotencyKey ? toJobId(options.idempotencyKey) : void 0,
+			removeOnComplete: { age: COMPLETED_JOB_AGE_SECONDS },
+			removeOnFail: { age: FAILED_JOB_AGE_SECONDS }
+		});
+		return job.id ? { messageId: job.id } : {};
+	} finally {
+		try {
+			await queue.close();
+		} finally {
+			await connection.quit();
+		}
+	}
+}
+/** Queue provider backed by BullMQ, for local development only. */
+const bullmqQueueProvider = {
+	messagingSystem: "bullmq",
+	send: send$1,
+	createCallback: () => async () => new Response("This queue provider does not push messages", { status: 404 }),
+	startWorker
+};
 // src/chat/queue/vercel.ts
 function defaultQueueClientOptions() {
 	if (process.env.VERCEL_DEPLOYMENT_ID?.trim()) return {};
@@ -76,7 +201,7 @@ const vercelQueueProvider = {
 // src/chat/queue/provider.ts
 /** Return the queue provider for this deployment. */
 function getQueueProvider() {
-	return vercelQueueProvider;
+	return getChatConfig().queue.provider === "bullmq" ? bullmqQueueProvider : vercelQueueProvider;
 }
 // src/chat/queue/sign.ts
 /** Sign and check queue messages before public callbacks run them. */