@sentry/junior 0.205.0 → 0.206.0

package/dist/prompt-3gqNY1Ka.js

@@ -0,0 +1,552 @@
+import { M as conversationBriefSchema, N as parseBriefInput, j as briefOutcomeStatusSchema } from "./conversation-AA4R1VUn.js";
+import { z } from "zod";
+//#region src/chat/briefs/generate.ts
+const MAX_INPUT_CHARS = 6e4;
+const MAX_MESSAGE_TEXT_CHARS = 4e3;
+const MAX_TOOL_TEXT_CHARS = 1500;
+const MAX_LINKS = 40;
+const SIZE_CAPS = {
+	small: {
+		decisions: 3,
+		openDecisions: 2,
+		facts: 5,
+		keywords: 5
+	},
+	medium: {
+		decisions: 8,
+		openDecisions: 5,
+		facts: 10,
+		keywords: 8
+	},
+	large: {
+		decisions: 20,
+		openDecisions: 10,
+		facts: 15,
+		keywords: 12
+	}
+};
+const modelBriefSchema = z.object({
+	summary: z.string().trim().min(1),
+	intent: z.string().trim().min(1),
+	outcome: z.object({
+		status: briefOutcomeStatusSchema,
+		text: z.string().trim().min(1)
+	}).strict(),
+	decisions: z.array(z.object({
+		text: z.string().trim().min(1),
+		by: z.string().trim().min(1).optional(),
+		kind: z.enum([
+			"stated",
+			"confirmed",
+			"assumed"
+		])
+	}).strict()),
+	openDecisions: z.array(z.object({
+		text: z.string().trim().min(1),
+		owner: z.string().trim().min(1).optional()
+	}).strict()),
+	facts: z.array(z.string().trim().min(1)),
+	keywords: z.array(z.string().trim().min(1)),
+	urls: z.array(z.object({
+		label: z.string().trim().min(1),
+		url: z.string().url().max(2048)
+	}).strict())
+}).strict();
+function truncate(value, limit) {
+	const trimmed = value.trim();
+	return trimmed.length <= limit ? trimmed : trimmed.slice(0, limit);
+}
+function truncateSentence(value, limit) {
+	const trimmed = value.trim();
+	if (trimmed.length <= limit) return trimmed;
+	const bounded = trimmed.slice(0, limit);
+	const boundary = Math.max(bounded.lastIndexOf("."), bounded.lastIndexOf("!"), bounded.lastIndexOf("?"));
+	if (boundary + 1 >= limit * .6) return bounded.slice(0, boundary + 1).trim();
+	return `${trimmed.slice(0, limit - 1).trimEnd()}…`;
+}
+function uniqueStrings(values, limit) {
+	const unique = /* @__PURE__ */ new Set();
+	for (const value of values) {
+		const normalized = truncate(value, 400);
+		if (normalized) unique.add(normalized);
+		if (unique.size === limit) break;
+	}
+	return [...unique];
+}
+const RUNTIME_MARKER_PATTERN = /\[\[NO_REPLY\]\]|<\/?(?:active-asks|analysis-error|available-skills|brief-input|compaction|current-instruction|image-attachment|omitted-image-attachments|pi-history|plugin-contribution|resolved-or-replaced-asks|runtime-turn-context|thread-compactions|thread-context|turn-context)\b/i;
+function hasRuntimeMarker(value) {
+	return RUNTIME_MARKER_PATTERN.test(value);
+}
+function normalizeModelBrief(args) {
+	let coercedDecisionKinds = 0;
+	let droppedAttributionCount = 0;
+	let droppedRuntimeMarkerCount = 0;
+	const participantNames = new Map(args.record.participants.map((participant) => [participant.name.toLowerCase(), participant.name]));
+	participantNames.set("junior", "Junior");
+	const attribution = (value) => {
+		if (!value?.trim()) return void 0;
+		const matched = participantNames.get(value.trim().toLowerCase());
+		if (!matched) droppedAttributionCount += 1;
+		return matched;
+	};
+	const decisions = args.model.decisions.flatMap((decision) => {
+		if (hasRuntimeMarker(decision.text)) {
+			droppedRuntimeMarkerCount += 1;
+			return [];
+		}
+		let by = attribution(decision.by);
+		let kind = decision.kind;
+		if (by === "Junior" && kind !== "assumed") {
+			kind = "assumed";
+			coercedDecisionKinds += 1;
+		} else if (by && by !== "Junior" && kind === "assumed") {
+			by = void 0;
+			coercedDecisionKinds += 1;
+		}
+		return [{
+			text: truncate(decision.text, 400),
+			...by ? { by } : void 0,
+			kind
+		}];
+	});
+	const openDecisions = args.model.openDecisions.flatMap((decision) => {
+		if (hasRuntimeMarker(decision.text)) {
+			droppedRuntimeMarkerCount += 1;
+			return [];
+		}
+		const owner = attribution(decision.owner);
+		return [{
+			text: truncate(decision.text, 400),
+			...owner ? { owner } : void 0
+		}];
+	});
+	const facts = args.model.facts.filter((fact) => {
+		const keep = !hasRuntimeMarker(fact);
+		if (!keep) droppedRuntimeMarkerCount += 1;
+		return keep;
+	});
+	return {
+		brief: conversationBriefSchema.parse({
+			schemaVersion: 1,
+			record: args.record,
+			summary: truncateSentence(args.model.summary, 600),
+			intent: truncateSentence(args.model.intent, 400),
+			outcome: {
+				status: args.model.outcome.status,
+				text: truncateSentence(args.model.outcome.text, 600)
+			},
+			decisions: decisions.slice(0, args.caps.decisions),
+			openDecisions: openDecisions.slice(0, args.caps.openDecisions),
+			facts: uniqueStrings(facts, args.caps.facts),
+			links: args.links,
+			keywords: uniqueStrings(args.model.keywords.map((keyword) => keyword.toLowerCase()), args.caps.keywords)
+		}),
+		coercedDecisionKinds,
+		droppedAttributionCount,
+		droppedRuntimeMarkerCount
+	};
+}
+function inputEntries(input, throughIndex) {
+	return input.entries.filter((entry) => entry.index <= throughIndex).map((entry) => {
+		const limit = entry.role === "tool" ? MAX_TOOL_TEXT_CHARS : MAX_MESSAGE_TEXT_CHARS;
+		return {
+			...entry,
+			text: entry.text.length > limit ? `${entry.text.slice(0, limit - 1)}…` : entry.text
+		};
+	});
+}
+function buildBriefRecord(input, entries) {
+	if (entries.length === 0) throw new Error("A Brief requires at least one entry through its index");
+	const participantByName = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (entry.role !== "user" || !entry.author?.trim()) continue;
+		const key = entry.author.trim().toLowerCase();
+		const participant = participantByName.get(key);
+		if (participant) participant.messages += 1;
+		else participantByName.set(key, {
+			name: entry.author.trim(),
+			messages: 1
+		});
+	}
+	const activityTimes = entries.map((entry) => entry.createdAtMs);
+	const startedAtMs = Math.min(...activityTimes);
+	const lastActivityAtMs = Math.max(...activityTimes);
+	const turns = new Set(entries.flatMap((entry) => entry.turnId ? [entry.turnId] : [])).size;
+	return {
+		startedAt: new Date(startedAtMs).toISOString(),
+		lastActivityAt: new Date(lastActivityAtMs).toISOString(),
+		durationMs: lastActivityAtMs - startedAtMs,
+		participants: [...participantByName.values()],
+		userMessages: entries.filter((entry) => entry.role === "user").length,
+		assistantMessages: entries.filter((entry) => entry.role === "assistant").length,
+		toolResults: entries.filter((entry) => entry.role === "tool").length,
+		events: entries.filter((entry) => entry.role === "event").length,
+		...turns > 0 ? { turns } : void 0,
+		...input.location ? { location: input.location } : void 0,
+		codeChanges: input.codeChanges
+	};
+}
+function briefSizeClass(record) {
+	if (record.userMessages <= 3) return "small";
+	if (record.userMessages <= 12) return "medium";
+	return "large";
+}
+function promptInput(args) {
+	const messages = args.entries.filter((entry) => entry.role !== "tool");
+	const tools = args.entries.filter((entry) => entry.role === "tool");
+	const keptMessages = [...messages];
+	const keptTools = [];
+	const base = {
+		conversation: {
+			id: args.input.conversationId,
+			title: args.input.title,
+			visibility: args.input.visibility,
+			location: args.input.location
+		},
+		record: args.record,
+		sizeClass: args.sizeClass,
+		caps: args.caps,
+		previousBrief: args.previous,
+		resources: args.input.resources
+	};
+	const serialize = () => {
+		const kept = /* @__PURE__ */ new Set([...keptMessages, ...keptTools]);
+		return JSON.stringify({
+			...base,
+			omitted: {
+				messages: messages.length - keptMessages.length,
+				toolResults: tools.length - keptTools.length
+			},
+			entries: args.entries.filter((entry) => kept.has(entry))
+		});
+	};
+	let text = serialize();
+	while (text.length > MAX_INPUT_CHARS && keptMessages.length > 0) {
+		keptMessages.shift();
+		text = serialize();
+	}
+	if (text.length > MAX_INPUT_CHARS) throw new Error("Brief metadata exceeds the 60,000 character input limit");
+	for (let index = tools.length - 1; index >= 0; index -= 1) {
+		keptTools.push(tools[index]);
+		const candidate = serialize();
+		if (candidate.length <= MAX_INPUT_CHARS) text = candidate;
+		else keptTools.pop();
+	}
+	return [
+		"<brief-input>",
+		text,
+		"</brief-input>",
+		"Return the next Brief as structured data."
+	].join("\n");
+}
+function deterministicLinks(input) {
+	return [...input.codeChanges.map((change) => ({
+		kind: "code_change",
+		label: truncate(`${change.repository}#${change.number}${change.title ? ` · ${change.title}` : ""}`, 400),
+		url: change.url,
+		status: change.state
+	})), ...input.resources.map((resource) => ({
+		kind: "resource",
+		label: truncate(resource.label, 400),
+		url: resource.url,
+		...resource.status ? { status: resource.status } : void 0
+	}))];
+}
+function decodeHtmlEntities(value) {
+	const entities = {
+		"&#39;": "'",
+		"&amp;": "&",
+		"&gt;": ">",
+		"&lt;": "<",
+		"&quot;": "\""
+	};
+	return value.replace(/&(?:amp|lt|gt|quot|#39);/g, (entity) => entities[entity]);
+}
+function endsWithUnopenedBracket(url, open, close) {
+	return url.endsWith(close) && url.split(open).length < url.split(close).length;
+}
+/**
+* Strip punctuation that prose attaches to a URL. A closing bracket stays when
+* the URL opened it, so `wiki/Foo_(bar)` survives and `(see https://x/y)` does not.
+*/
+function normalizeCitationUrl(raw) {
+	let url = decodeHtmlEntities(raw).trim();
+	for (;;) {
+		let next = url.replace(/[;,.]+$/, "").replace(/\/+$/, "");
+		if (endsWithUnopenedBracket(next, "(", ")") || endsWithUnopenedBracket(next, "[", "]")) next = next.slice(0, -1);
+		if (next === url) return url;
+		url = next;
+	}
+}
+/** Models sometimes append a stray `/https` to a cited URL; try without it. */
+function citationCandidates(raw) {
+	const normalized = normalizeCitationUrl(raw);
+	const stripped = normalizeCitationUrl(normalized.replace(/\/https?$/i, ""));
+	return stripped === normalized ? [normalized] : [normalized, stripped];
+}
+/** URL tokens in prose or Slack `<url|label>` links, normalized for matching. */
+function normalizedUrlTokens(value) {
+	const tokens = decodeHtmlEntities(value).match(/https?:\/\/[^\s<>"'|]+/gi);
+	return new Set((tokens ?? []).map(normalizeCitationUrl).filter((url) => url.length > 0));
+}
+function buildEvidenceLinks(args) {
+	const deterministic = deterministicLinks(args.input);
+	const transcriptUrls = normalizedUrlTokens(args.entries.map((entry) => entry.text).join("\n"));
+	const priorUrls = new Set((args.previous?.links ?? []).map((link) => normalizeCitationUrl(link.url)));
+	const linkedUrls = new Set(deterministic.map((link) => normalizeCitationUrl(link.url)));
+	const supportedUrls = /* @__PURE__ */ new Set();
+	const droppedUrls = /* @__PURE__ */ new Map();
+	const cited = [];
+	for (const citation of args.model.urls) {
+		const candidates = citationCandidates(citation.url);
+		const normalized = candidates.find((candidate) => linkedUrls.has(candidate) || transcriptUrls.has(candidate) || priorUrls.has(candidate));
+		if (normalized === void 0) {
+			droppedUrls.set(`${citation.url}\0${candidates[0]}`, {
+				normalized: candidates[0],
+				raw: citation.url
+			});
+			continue;
+		}
+		supportedUrls.add(normalized);
+		if (linkedUrls.has(normalized)) continue;
+		linkedUrls.add(normalized);
+		cited.push({
+			raw: citation.url,
+			link: {
+				kind: "url",
+				label: truncate(citation.label, 400),
+				url: normalized
+			}
+		});
+	}
+	const citedLimit = Math.max(0, MAX_LINKS - deterministic.length);
+	for (const citation of cited.slice(citedLimit)) droppedUrls.set(`${citation.raw}\0${citation.link.url}`, {
+		normalized: citation.link.url,
+		raw: citation.raw
+	});
+	const links = [...deterministic, ...cited.slice(0, citedLimit).map((citation) => citation.link)].slice(0, MAX_LINKS);
+	const keptUrls = new Set(links.map((link) => normalizeCitationUrl(link.url)));
+	return {
+		droppedUrls: [...droppedUrls.values()],
+		keptUrlCount: [...supportedUrls].filter((url) => keptUrls.has(url)).length,
+		links
+	};
+}
+function hasMergedEvidence(input) {
+	return input.codeChanges.some((change) => change.state === "merged") || input.resources.some((resource) => resource.status?.trim().toLowerCase() === "merged");
+}
+/** Build the text indexed for a Brief without adding transcript content. */
+function buildBriefSearchText(brief, title) {
+	return [
+		title,
+		brief.summary,
+		brief.intent,
+		brief.outcome.text,
+		...brief.decisions.map((decision) => decision.text),
+		...brief.openDecisions.map((decision) => decision.text),
+		...brief.facts,
+		...brief.keywords,
+		...brief.links.map((link) => link.label),
+		...brief.record.participants.map((participant) => participant.name),
+		...brief.record.codeChanges.map((change) => `${change.repository}#${change.number} ${change.state}`)
+	].filter((value) => Boolean(value?.trim())).join("\n");
+}
+/** Generate one bounded Brief and attach only deterministic evidence links. */
+async function generateBrief(args) {
+	const input = parseBriefInput(args.input);
+	if (!Number.isSafeInteger(args.throughIndex) || args.throughIndex < 0) throw new Error("throughIndex must be a non-negative integer");
+	const entries = inputEntries(input, args.throughIndex);
+	const record = buildBriefRecord(input, entries);
+	const sizeClass = briefSizeClass(record);
+	const caps = SIZE_CAPS[sizeClass];
+	const result = await args.completeObject({
+		maxTokens: 2500,
+		prompt: promptInput({
+			caps,
+			entries,
+			input,
+			previous: args.previous,
+			record,
+			sizeClass
+		}),
+		schema: modelBriefSchema,
+		system: args.prompt,
+		temperature: 0
+	});
+	const model = modelBriefSchema.parse(result.object);
+	const { droppedUrls, keptUrlCount, links } = buildEvidenceLinks({
+		entries,
+		input,
+		model,
+		previous: args.previous
+	});
+	const normalized = normalizeModelBrief({
+		caps,
+		links,
+		model,
+		record
+	});
+	const mergedClaim = /\bmerged\b/i.test(`${normalized.brief.summary}\n${normalized.brief.outcome.text}`);
+	const hasLinkedEvidence = input.codeChanges.length > 0 || input.resources.length > 0;
+	return {
+		brief: normalized.brief,
+		...result.costUsd !== void 0 ? { costUsd: result.costUsd } : void 0,
+		evidence: {
+			citedUrlCount: model.urls.length,
+			codeChangeCount: input.codeChanges.length,
+			coercedDecisionKinds: normalized.coercedDecisionKinds,
+			droppedAttributionCount: normalized.droppedAttributionCount,
+			droppedRuntimeMarkerCount: normalized.droppedRuntimeMarkerCount,
+			droppedUrls,
+			keptUrlCount,
+			mergedClaimWithoutEvidence: mergedClaim && hasLinkedEvidence && !hasMergedEvidence(input),
+			resourceCount: input.resources.length
+		},
+		searchText: buildBriefSearchText(normalized.brief, input.title),
+		throughIndex: args.throughIndex
+	};
+}
+//#endregion
+//#region src/chat/resource-events/actor.ts
+/**
+* System author ID stamped on resource-event mailbox messages.
+*
+* Keep this stable so conversation history can recognize the same system input
+* for resource-event Turns.
+*
+* TODO(dcramer): Delete this ID after resumes read resource-event Source.kind
+* from the Turn checkpoint instead of Message author data.
+*/
+const RESOURCE_EVENT_AUTHOR_ID = "UJRNEVENT";
+/** System Message author for resource-event input. */
+const RESOURCE_EVENT_MESSAGE_AUTHOR = {
+	fullName: "Junior event",
+	isBot: true,
+	userId: RESOURCE_EVENT_AUTHOR_ID,
+	userName: "junior-event"
+};
+/** System execution actor for every resource-event turn. */
+const RESOURCE_EVENT_SYSTEM_ACTOR = {
+	platform: "system",
+	name: "resource-event"
+};
+/**
+* Whether a saved Message started a resource-event Turn.
+*
+* TODO(dcramer): Delete this marker check after deployed Turn cursors all store
+* Source and Actor. `eventType` only supports saved synthetic Slack input.
+*/
+function isResourceEventConversationMessage(message) {
+	return Boolean(message.meta?.eventType) || message.author?.userId === "UJRNEVENT";
+}
+//#endregion
+//#region src/chat/briefs/event-entries.ts
+const TOOL_TEXT_LIMIT = 1500;
+function actorIdentityKey(actor) {
+	const slackUserId = actor?.slackUserId?.trim();
+	if (slackUserId) return `slack:${slackUserId}`;
+	const email = actor?.email?.trim();
+	return email ? `email:${email.toLowerCase()}` : void 0;
+}
+function bestActorName(actor) {
+	return actor?.fullName?.trim() || actor?.slackUserName?.trim() || actor?.email?.trim() || void 0;
+}
+function actorNames(events) {
+	const actors = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		if (event.data.type !== "message") continue;
+		const actor = event.data.actorIdentity;
+		const key = actorIdentityKey(actor);
+		if (!key) continue;
+		const known = actors.get(key) ?? {};
+		actors.set(key, {
+			fullName: known.fullName ?? (actor?.fullName?.trim() || void 0),
+			slackUserName: known.slackUserName ?? (actor?.slackUserName?.trim() || void 0),
+			email: known.email ?? (actor?.email?.trim() || void 0)
+		});
+	}
+	const names = /* @__PURE__ */ new Map();
+	for (const [key, actor] of actors) {
+		const name = bestActorName(actor);
+		if (name) names.set(key, name);
+	}
+	return names;
+}
+function actorName(actor, resolvedNames) {
+	if (!actor) return void 0;
+	const key = actorIdentityKey(actor);
+	return (key ? resolvedNames.get(key) : void 0) ?? bestActorName(actor);
+}
+function toolText(output) {
+	if (output === void 0) return void 0;
+	const text = typeof output === "string" ? output : JSON.stringify(output, void 0, 2);
+	if (!text?.trim()) return void 0;
+	return text.length <= TOOL_TEXT_LIMIT ? text : `${text.slice(0, 1499)}…`;
+}
+/** Map reporting events to the entries used by every Brief input adapter. */
+function briefEntriesFromReportEvents(events) {
+	const resolvedActorNames = actorNames(events);
+	const turnByMessageId = /* @__PURE__ */ new Map();
+	for (const event of events) if (event.data.type === "turn_lifecycle" && event.data.state === "started") for (const messageId of event.data.inputMessageIds ?? []) turnByMessageId.set(messageId, event.data.turnId);
+	const entries = [];
+	let activeTurnId;
+	for (const event of events) {
+		const data = event.data;
+		if (data.type === "turn_lifecycle") {
+			if (data.state === "started") activeTurnId = data.turnId;
+			else if (data.turnId === activeTurnId) activeTurnId = void 0;
+			continue;
+		}
+		if (data.type === "message" && data.text && data.role !== "system") {
+			const turnId = data.role === "user" ? turnByMessageId.get(data.messageId) : activeTurnId;
+			const author = actorName(data.actorIdentity, resolvedActorNames);
+			const role = data.role === "user" && (Boolean(data.eventType) || data.actorIdentity?.slackUserId === "UJRNEVENT") ? "event" : data.role;
+			entries.push({
+				index: event.seq,
+				role,
+				...author ? { author } : void 0,
+				text: data.text,
+				createdAtMs: Date.parse(event.createdAt),
+				...turnId ? { turnId } : void 0
+			});
+			continue;
+		}
+		if (data.type !== "tool_calls") continue;
+		for (const call of data.calls) {
+			const text = toolText(call.output);
+			if (!text) continue;
+			entries.push({
+				index: event.seq,
+				role: "tool",
+				author: call.name,
+				text,
+				createdAtMs: Date.parse(event.createdAt),
+				...activeTurnId ? { turnId: activeTurnId } : void 0
+			});
+		}
+	}
+	return entries;
+}
+//#endregion
+//#region src/chat/briefs/prompt.ts
+const BRIEF_PROMPT = `You write one durable Brief for a Junior Conversation.
+
+Use only facts supported by the supplied entries, evidence, or previous Brief. Do not invent names, ids, numbers, outcomes, choices, owners, or links.
+
+Rules:
+- Summarize the intent and current outcome in plain prose.
+- Keep earlier decisions unless later entries reverse them. State a reversal as a new decision.
+- A decision is a choice made by a listed participant in this Conversation. It is not a research finding, tool result, action, observation, or suggestion. Put findings in facts or the summary.
+- Set each decision kind to stated when a human participant stated the choice themselves, confirmed when Junior proposed it and a human participant explicitly accepted it, or assumed when Junior chose while working and no participant confirmed or objected.
+- An open decision is a choice the participants explicitly left open, asked about, or were asked to make. Phrase it as the choice and include its options when known. A next step such as merging or reviewing is not an open decision. Do not use worries, monitoring questions, or finished work.
+- Facts are durable one-line facts that help after the transcript expires. Prefer ids, versions, owners, constraints, and numbers. Do not list fields, recap the transcript, or include transient progress.
+- Ignore Junior runtime mechanics, context tags, and markers such as [[NO_REPLY]].
+- Never say that a code change was merged, closed, deployed, or released unless a supplied code change or resource has that status. Say opened for an open code change.
+- Attribute by or owner only to a participant in the supplied record. Junior is also valid.
+- Choose the outcome status that best describes where the Conversation ended.
+- Follow the supplied size class caps. Keep the first items that matter most.
+- Cite a URL only when its exact full string occurs in an entry, evidence, or the previous Brief. Return cited URLs in urls. Core adds code changes and resources separately.
+- Keep the summary under 600 characters, intent under 400 characters, outcome text under 600 characters, and each other string under 400 characters.
+`;
+//#endregion
+export { RESOURCE_EVENT_SYSTEM_ACTOR as a, RESOURCE_EVENT_MESSAGE_AUTHOR as i, briefEntriesFromReportEvents as n, isResourceEventConversationMessage as o, RESOURCE_EVENT_AUTHOR_ID as r, generateBrief as s, BRIEF_PROMPT as t };

package/dist/{registry-BA0__8ai.js → registry-DiR0-xRg.js}

@@ -1,4 +1,4 @@
-import { _ as setSpanAttributes, d as logInfo, f as logWarn } from "./logging-BMJzdDlP.js";
+import { _ as setSpanAttributes, d as logInfo, f as logWarn } from "./logging-D37bayDc.js";
 import { i as credentialUserSubjectId } from "./context-B45_WqVX.js";
 import { n as normalizePluginPackageNames, o as pluginRoots, t as discoverInstalledPluginPackageContent } from "./package-discovery-7a9YqLhE.js";
 import path from "node:path";

package/dist/{resolve-bvD1ORdv.js → resolve-Bn5q__9b.js}

@@ -1,5 +1,5 @@
-import { C as withSpan, _ as setSpanAttributes } from "./logging-BMJzdDlP.js";
-import { A as sleep, P as SANDBOX_WORKSPACE_ROOT, r as isStale, t as create, u as isSandboxUnavailableError, v as getVercelSandboxCredentials, w as getStateAdapter, x as runNonInteractiveCommand } from "./profile-T0tXE4zu.js";
+import { C as withSpan, _ as setSpanAttributes } from "./logging-D37bayDc.js";
+import { A as sleep, P as SANDBOX_WORKSPACE_ROOT, r as isStale, t as create, u as isSandboxUnavailableError, v as getVercelSandboxCredentials, w as getStateAdapter, x as runNonInteractiveCommand } from "./profile-CSixooTi.js";
 import { z } from "zod";
 import { FileSystem, Sandbox } from "@vercel/sandbox";
 //#region src/chat/sandbox/resources.ts

package/dist/{runner-BXYxfIUL.js → runner-DFx3dIJH.js}

@@ -1,13 +1,13 @@
-import { p as authorizationId } from "./agent-D4nu8MQV.js";
-import { S as withLogContext, u as logException, y as setTags } from "./logging-BMJzdDlP.js";
+import { p as authorizationId } from "./agent-C9yuiZUF.js";
+import { S as withLogContext, u as logException, y as setTags } from "./logging-D37bayDc.js";
 import { t as credentialContextForActor } from "./context-B45_WqVX.js";
-import { Ct as getConversationEventStore, Tt as getConversationStore } from "./agent-hooks-DXHpTJ4m.js";
-import { $ as persistConversationMessages, P as commitAcceptedReply, Q as hydrateConversationMessages, R as loadProjection, W as recordAuthorizationCompleted, d as persistWithRetry, dt as recordDeliveredAssistantMessage, it as buildConversationContext, jt as stripRuntimeTurnContext, lt as markConversationMessage, pt as upsertConversationMessage, r as saveTurnCheckpoint, ut as normalizeConversationText } from "./checkpoint-CrViJ8Ps.js";
-import { S as startActiveTurn, s as getAssistantReplyText, x as markTurnFailed } from "./pending-auth-CUbXq06G.js";
-import { n as scheduleSessionCompletedPluginTasks, t as processPluginTask } from "./task-runner-B2_mJZj0.js";
-import { t as ConversationTurnLifecycleService } from "./turn-lifecycle-CcnwrOcp.js";
-import { n as getPersistedSandboxState, o as persistThreadStateById, r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-CqZ1m-es.js";
-import { d as buildDeliveredTurnStatePatch, r as finalizeFailedTurnReplyWithEvent, t as completeAuthPauseTurn } from "./auth-pause-state-C2P3guS1.js";
+import { Ft as getConversationStore, Nt as getConversationEventStore } from "./agent-hooks-DNjlz2A-.js";
+import { $ as persistConversationMessages, P as commitAcceptedReply, Q as hydrateConversationMessages, R as loadProjection, W as recordAuthorizationCompleted, d as persistWithRetry, dt as recordDeliveredAssistantMessage, it as buildConversationContext, jt as stripRuntimeTurnContext, lt as markConversationMessage, pt as upsertConversationMessage, r as saveTurnCheckpoint, ut as normalizeConversationText } from "./checkpoint-BY47jJCB.js";
+import { S as startActiveTurn, s as getAssistantReplyText, x as markTurnFailed } from "./pending-auth-BPUzcs7n.js";
+import { n as scheduleSessionCompletedPluginTasks, t as processPluginTask } from "./task-runner-alpjVSxQ.js";
+import { t as ConversationTurnLifecycleService } from "./turn-lifecycle-VbwZLfBv.js";
+import { n as getPersistedSandboxState, o as persistThreadStateById, r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-CRK7aA41.js";
+import { d as buildDeliveredTurnStatePatch, r as finalizeFailedTurnReplyWithEvent, t as completeAuthPauseTurn } from "./auth-pause-state-MVZ6xvEK.js";
 import { randomUUID } from "node:crypto";
 import { createLocalSource, localDestinationSchema } from "@sentry/junior-plugin-api";
 //#region src/chat/local/runner.ts

package/dist/{sandbox-egress-signals-ngEPjSEW.js → sandbox-egress-signals-bwvjihxA.js}

@@ -1,4 +1,4 @@
-import { Z as sandboxEgressSignalsResponseSchema } from "./agent-D4nu8MQV.js";
+import { J as sandboxEgressSignalsResponseSchema } from "./agent-C9yuiZUF.js";
 //#region src/chat/local/sandbox-egress-signals.ts
 const SANDBOX_EGRESS_SIGNALS_PATH = "/api/internal/sandbox-egress/signals";
 const LOCAL_DEV_SERVER_TIMEOUT_MS = 1e3;