@sentry/junior 0.202.0 → 0.204.0

package/dist/thread-state-CRc9jTJS.js

@@ -0,0 +1,431 @@
+import { F as isRecord, I as toOptionalNumber, L as toOptionalString } from "./logging-BzAk1S_s.js";
+import { Et as getDb, ut as JUNIOR_THREAD_STATE_TTL_MS } from "./agent-hooks-Bbcp9e33.js";
+import { n as juniorDestinations } from "./destinations-BeBiJeEM.js";
+import { u as juniorLocationConfigurations } from "./executor-DcMSlI5c.js";
+import { $ as persistConversationMessages } from "./checkpoint-CNrPyRJN.js";
+import { w as getStateAdapter } from "./profile-CrT5nXbw.js";
+import { z } from "zod";
+import { randomUUID } from "node:crypto";
+import { and, eq, sql } from "drizzle-orm";
+//#region src/chat/configuration/types.ts
+/** JSON value accepted by Location configuration. */
+const configValueSchema = z.json();
+//#endregion
+//#region src/chat/configuration/validation.ts
+const CONFIG_KEY_RE = /^[a-z0-9]+(?:\.[a-z0-9-]+)+$/;
+const SECRET_KEY_RE = /(?:^|[_.-])(token|secret|password|passphrase|api[-_]?key|private[-_]?key|credential|auth)(?:$|[_.-])/i;
+const SECRET_VALUE_PATTERNS = [
+	/\bBearer\s+[A-Za-z0-9._-]{16,}\b/i,
+	/-----BEGIN [A-Z ]*PRIVATE KEY-----/,
+	/\b(?:ghp|ghs|github_pat)_[A-Za-z0-9_]{20,}\b/,
+	/\bxox[baprs]-[A-Za-z0-9-]{10,}\b/i,
+	/\bsk-[A-Za-z0-9]{20,}\b/,
+	/\bAIza[0-9A-Za-z\-_]{30,}\b/,
+	/\bAKIA[0-9A-Z]{16}\b/,
+	/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/
+];
+function validateConfigKey(key) {
+	const trimmed = key.trim();
+	if (!trimmed) return "Configuration key must not be empty";
+	if (!CONFIG_KEY_RE.test(trimmed)) return `Invalid configuration key "${key}"; expected dotted lowercase namespace (for example "provider.repo")`;
+	if (SECRET_KEY_RE.test(trimmed)) return `Configuration key "${key}" appears to be secret-related and is not allowed`;
+}
+function collectStringValues(value, output, depth = 0) {
+	if (depth > 5) return;
+	if (typeof value === "string") {
+		output.push(value);
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const item of value) collectStringValues(item, output, depth + 1);
+		return;
+	}
+	if (value && typeof value === "object") for (const [key, nested] of Object.entries(value)) {
+		output.push(key);
+		collectStringValues(nested, output, depth + 1);
+	}
+}
+function validateConfigValue(value) {
+	const stringValues = [];
+	collectStringValues(value, stringValues);
+	for (const text of stringValues) for (const pattern of SECRET_VALUE_PATTERNS) if (pattern.test(text)) return "Configuration value appears to contain secret material and is not allowed";
+}
+//#endregion
+//#region src/chat/configuration/service.ts
+function sanitizeEntry(value) {
+	if (!isRecord(value)) return;
+	const key = toOptionalString(value.key);
+	if (!key || validateConfigKey(key)) return;
+	const updatedAt = toOptionalString(value.updatedAt);
+	if (!updatedAt) return;
+	if (value.scope !== "channel" && value.scope !== "conversation" && value.scope !== "location") return;
+	const parsedValue = configValueSchema.safeParse(value.value);
+	if (!parsedValue.success) return;
+	return {
+		key,
+		value: parsedValue.data,
+		scope: "location",
+		updatedAt,
+		updatedBy: toOptionalString(value.updatedBy),
+		source: toOptionalString(value.source),
+		expiresAt: toOptionalString(value.expiresAt)
+	};
+}
+/** Coerce legacy persisted configuration into current Location entries. */
+function coerceLegacyLocationConfig(raw) {
+	const rawConfig = isRecord(raw) && isRecord(raw.configuration) ? raw.configuration : {};
+	const rawEntries = isRecord(rawConfig.entries) ? rawConfig.entries : {};
+	return Object.values(rawEntries).flatMap((value) => {
+		const entry = sanitizeEntry(value);
+		return entry ? [entry] : [];
+	});
+}
+/** Create a Location configuration service over entry-level storage. */
+function createLocationConfigurationService(storage) {
+	const get = async (key) => await storage.get(key.trim());
+	const set = async (input) => {
+		const normalizedKey = input.key.trim();
+		const keyError = validateConfigKey(normalizedKey);
+		if (keyError) throw new Error(keyError);
+		const value = configValueSchema.parse(input.value);
+		const valueError = validateConfigValue(value);
+		if (valueError) throw new Error(valueError);
+		const entry = {
+			key: normalizedKey,
+			value,
+			scope: "location",
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			updatedBy: toOptionalString(input.updatedBy),
+			source: toOptionalString(input.source),
+			expiresAt: toOptionalString(input.expiresAt)
+		};
+		await storage.set(entry);
+		return entry;
+	};
+	const unset = async (key) => await storage.unset(key.trim());
+	const list = async (options = {}) => {
+		const prefix = options.prefix?.trim();
+		return (await storage.list()).filter((entry) => prefix ? entry.key.startsWith(prefix) : true).sort((a, b) => a.key.localeCompare(b.key));
+	};
+	const resolve = async (key) => (await get(key))?.value;
+	const resolveValues = async (options = {}) => {
+		const keys = options.keys?.map((key) => key.trim()).filter(Boolean);
+		const entries = await list(options.prefix ? { prefix: options.prefix } : {});
+		return Object.fromEntries(entries.filter((entry) => !keys || keys.includes(entry.key)).map((entry) => [entry.key, entry.value]));
+	};
+	return {
+		get,
+		set,
+		unset,
+		list,
+		resolve,
+		resolveValues
+	};
+}
+//#endregion
+//#region src/chat/configuration/sql.ts
+/** Resolve or create the canonical Location for a Slack Destination. */
+async function resolveLocationId(db, destination) {
+	const channelId = destination.channelId;
+	const now = /* @__PURE__ */ new Date();
+	const location = (await db.insert(juniorDestinations).values({
+		id: randomUUID(),
+		provider: "slack",
+		providerTenantId: destination.teamId,
+		providerDestinationId: channelId,
+		kind: channelId.startsWith("D") ? "dm" : channelId.startsWith("G") ? "group" : "channel",
+		parentDestinationId: null,
+		displayName: null,
+		visibility: "unknown",
+		metadata: { platform: "slack" },
+		createdAt: now,
+		updatedAt: now
+	}).onConflictDoUpdate({
+		target: [
+			juniorDestinations.provider,
+			juniorDestinations.providerTenantId,
+			juniorDestinations.providerDestinationId
+		],
+		set: { id: sql`${juniorDestinations.id}` }
+	}).returning({ id: juniorDestinations.id }))[0];
+	if (!location) throw new Error("Location upsert returned no row");
+	return location.id;
+}
+/** Persist configuration rows for the Location addressed by a Slack Destination. */
+function createSqlLocationConfigurationStorage(db, destination) {
+	const locationWhere = and(eq(juniorDestinations.provider, "slack"), eq(juniorDestinations.providerTenantId, destination.teamId), eq(juniorDestinations.providerDestinationId, destination.channelId));
+	const selectEntries = () => db.select({
+		key: juniorLocationConfigurations.key,
+		value: juniorLocationConfigurations.value,
+		updatedAt: juniorLocationConfigurations.updatedAt,
+		updatedBy: juniorLocationConfigurations.updatedBy,
+		source: juniorLocationConfigurations.source,
+		expiresAt: juniorLocationConfigurations.expiresAt
+	}).from(juniorLocationConfigurations).innerJoin(juniorDestinations, eq(juniorDestinations.id, juniorLocationConfigurations.locationId));
+	const entryFromRow = (row) => ({
+		key: row.key,
+		value: configValueSchema.parse(JSON.parse(row.value)),
+		scope: "location",
+		updatedAt: row.updatedAt.toISOString(),
+		updatedBy: row.updatedBy ?? void 0,
+		source: row.source ?? void 0,
+		expiresAt: row.expiresAt ?? void 0
+	});
+	const list = async () => (await selectEntries().where(locationWhere)).map(entryFromRow);
+	const set = async (entry) => {
+		const locationId = await resolveLocationId(db, destination);
+		await db.insert(juniorLocationConfigurations).values({
+			locationId,
+			key: entry.key,
+			value: JSON.stringify(entry.value),
+			updatedAt: new Date(entry.updatedAt),
+			updatedBy: entry.updatedBy,
+			source: entry.source,
+			expiresAt: entry.expiresAt
+		}).onConflictDoUpdate({
+			target: [juniorLocationConfigurations.locationId, juniorLocationConfigurations.key],
+			set: {
+				value: JSON.stringify(entry.value),
+				updatedAt: new Date(entry.updatedAt),
+				updatedBy: entry.updatedBy,
+				source: entry.source,
+				expiresAt: entry.expiresAt
+			}
+		});
+	};
+	return {
+		get: async (key) => {
+			const rows = await selectEntries().where(and(locationWhere, eq(juniorLocationConfigurations.key, key))).limit(1);
+			return rows[0] ? entryFromRow(rows[0]) : void 0;
+		},
+		list,
+		set,
+		unset: async (key) => {
+			const locationId = await resolveLocationId(db, destination);
+			return (await db.delete(juniorLocationConfigurations).where(and(eq(juniorLocationConfigurations.locationId, locationId), eq(juniorLocationConfigurations.key, key))).returning({ key: juniorLocationConfigurations.key })).length > 0;
+		},
+		insertLegacy: async (entries) => {
+			if (entries.length === 0) return;
+			const locationId = await resolveLocationId(db, destination);
+			await db.insert(juniorLocationConfigurations).values(entries.map((entry) => ({
+				locationId,
+				key: entry.key,
+				value: JSON.stringify(entry.value),
+				updatedAt: new Date(entry.updatedAt),
+				updatedBy: entry.updatedBy,
+				source: entry.source,
+				expiresAt: entry.expiresAt
+			}))).onConflictDoNothing();
+		}
+	};
+}
+/** Resolve SQL-owned Location configuration and copy live legacy entries once. */
+function createDurableLocationConfigurationService(args) {
+	const storage = createSqlLocationConfigurationStorage(args.db, args.destination);
+	let cutover;
+	const ensureCutover = () => cutover ??= (async () => {
+		if ((await storage.list()).length > 0) return;
+		const legacy = coerceLegacyLocationConfig(await args.loadLegacy());
+		await storage.insertLegacy(legacy);
+	})();
+	return createLocationConfigurationService({
+		get: async (key) => {
+			await ensureCutover();
+			return await storage.get(key);
+		},
+		list: async () => {
+			await ensureCutover();
+			return await storage.list();
+		},
+		set: async (entry) => {
+			await ensureCutover();
+			await storage.set(entry);
+		},
+		unset: async (key) => {
+			await ensureCutover();
+			return await storage.unset(key);
+		}
+	});
+}
+//#endregion
+//#region src/chat/state/conversation.ts
+function defaultConversationState() {
+	return {
+		schemaVersion: 1,
+		messages: [],
+		compactions: [],
+		processing: {},
+		vision: { byFileId: {} }
+	};
+}
+function coercePendingAuthState(value) {
+	if (!isRecord(value)) return;
+	const kind = value.kind;
+	const provider = toOptionalString(value.provider);
+	const actorId = toOptionalString(value.actorId);
+	const authSessionId = toOptionalString(value.authSessionId);
+	const scope = toOptionalString(value.scope);
+	const sessionId = toOptionalString(value.sessionId);
+	const linkSentAtMs = toOptionalNumber(value.linkSentAtMs);
+	if (kind !== "mcp" && kind !== "plugin" || !provider || !actorId || kind === "mcp" && !authSessionId || !sessionId || typeof linkSentAtMs !== "number") return;
+	const base = {
+		provider,
+		actorId,
+		...scope ? { scope } : void 0,
+		sessionId,
+		linkSentAtMs
+	};
+	return kind === "mcp" ? {
+		...base,
+		authSessionId,
+		kind
+	} : {
+		...base,
+		kind
+	};
+}
+/** Safely coerce an unknown persisted value into a ThreadConversationState. */
+function coerceThreadConversationState(value) {
+	if (!isRecord(value)) return defaultConversationState();
+	const root = value;
+	const rawConversation = isRecord(root.conversation) ? root.conversation : {};
+	const messages = [];
+	const compactions = [];
+	const rawProcessing = isRecord(rawConversation.processing) ? rawConversation.processing : {};
+	const processing = {
+		activeTurnId: toOptionalString(rawProcessing.activeTurnId),
+		lastCompletedAtMs: toOptionalNumber(rawProcessing.lastCompletedAtMs),
+		pendingAuth: coercePendingAuthState(rawProcessing.pendingAuth)
+	};
+	const rawVision = isRecord(rawConversation.vision) ? rawConversation.vision : {};
+	const rawVisionByFileId = isRecord(rawVision.byFileId) ? rawVision.byFileId : {};
+	const byFileId = {};
+	for (const [fileId, value] of Object.entries(rawVisionByFileId)) {
+		if (typeof fileId !== "string" || fileId.trim().length === 0) continue;
+		if (!isRecord(value)) continue;
+		const summary = toOptionalString(value.summary);
+		const analyzedAtMs = toOptionalNumber(value.analyzedAtMs);
+		if (!summary || !analyzedAtMs) continue;
+		byFileId[fileId] = {
+			summary,
+			analyzedAtMs
+		};
+	}
+	return {
+		schemaVersion: 1,
+		messages,
+		compactions,
+		processing,
+		vision: {
+			backfillCompletedAtMs: toOptionalNumber(rawVision.backfillCompletedAtMs),
+			byFileId
+		}
+	};
+}
+/**
+* Wrap active conversation control into the thread scratch envelope.
+*
+* Visible history lives in SQL. Image summaries use a separate disposable
+* cache, so thread scratch does not retain them.
+*/
+function buildConversationStatePatch(conversation) {
+	return { conversation: {
+		schemaVersion: 1,
+		processing: { ...conversation.processing }
+	} };
+}
+//#endregion
+//#region src/chat/runtime/thread-state.ts
+function threadStateKey(threadId) {
+	return `thread-state:${threadId}`;
+}
+function channelStateKey(channelId) {
+	return `channel-state:${channelId}`;
+}
+function buildThreadStatePayload(patch) {
+	const payload = {};
+	if (patch.conversation) Object.assign(payload, buildConversationStatePatch(patch.conversation));
+	if (patch.sandboxRef !== void 0) {
+		payload.app_sandbox_id = patch.sandboxRef?.id ?? "";
+		payload.app_sandbox_dependency_profile_hash = patch.sandboxRef?.profileHash ?? "";
+		payload.app_sandbox_workspace_id = patch.sandboxRef?.workspaceId ?? "";
+	}
+	return payload;
+}
+/**
+* Merge a payload into thread scratch with Junior's TTL.
+*
+* Chat SDK state writes hardcode a 30-day TTL. This boundary owns Junior's
+* shorter retention policy for the same scratch keys.
+*/
+async function mergePersistedState(key, payload) {
+	if (Object.keys(payload).length === 0) return;
+	const stateAdapter = getStateAdapter();
+	await stateAdapter.connect();
+	const existing = await stateAdapter.get(key) ?? {};
+	await stateAdapter.set(key, {
+		...existing,
+		...payload
+	}, JUNIOR_THREAD_STATE_TTL_MS);
+}
+/** Extract persisted sandbox metadata from thread state payload. */
+function getPersistedSandboxState(state) {
+	const id = toOptionalString(state.app_sandbox_id);
+	if (!id) return;
+	const profileHash = toOptionalString(state.app_sandbox_dependency_profile_hash);
+	const workspaceId = toOptionalString(state.app_sandbox_workspace_id);
+	return {
+		id,
+		...profileHash ? { profileHash } : void 0,
+		...workspaceId ? { workspaceId } : void 0
+	};
+}
+/** Persist a thread-state patch for a Chat thread handle. */
+async function persistThreadState(thread, patch) {
+	if (patch.conversation) await persistConversationMessages({
+		conversation: patch.conversation,
+		conversationId: toOptionalString(thread.id) ?? toOptionalString(thread.runId)
+	});
+	await persistThreadRuntimeState(thread, patch);
+}
+/** Persist only the Redis-backed runtime scratch in a thread-state patch. */
+async function persistThreadRuntimeState(thread, patch) {
+	const threadId = toOptionalString(thread.id) ?? toOptionalString(thread.runId);
+	if (!threadId) throw new Error("thread id is required to persist runtime scratch");
+	await mergePersistedState(threadStateKey(threadId), buildThreadStatePayload(patch));
+}
+/** Load the persisted state payload for a thread without requiring a Chat singleton. */
+async function getPersistedThreadState(threadId) {
+	const stateAdapter = getStateAdapter();
+	await stateAdapter.connect();
+	return await stateAdapter.get(threadStateKey(threadId)) ?? {};
+}
+/** Persist a thread-state patch by thread id without constructing a Chat thread. */
+async function persistThreadStateById(threadId, patch) {
+	if (patch.conversation) await persistConversationMessages({
+		conversation: patch.conversation,
+		conversationId: threadId
+	});
+	await mergePersistedState(threadStateKey(threadId), buildThreadStatePayload(patch));
+}
+/** Load legacy Redis-backed channel state during the SQL cutover. */
+async function getLegacyChannelState(channelId) {
+	const stateAdapter = getStateAdapter();
+	await stateAdapter.connect();
+	return await stateAdapter.get(channelStateKey(channelId)) ?? {};
+}
+/**
+* Resolve durable location configuration.
+*
+* Slack still reads the old channel-id Redis bag once during cutover.
+*/
+function getLocationConfigurationService(destination) {
+	if (destination.platform !== "slack") throw new Error("Location configuration requires a Slack Location");
+	return createDurableLocationConfigurationService({
+		destination,
+		db: getDb(),
+		loadLegacy: async () => await getLegacyChannelState(destination.channelId)
+	});
+}
+//#endregion
+export { persistThreadState as a, configValueSchema as c, persistThreadRuntimeState as i, getPersistedSandboxState as n, persistThreadStateById as o, getPersistedThreadState as r, coerceThreadConversationState as s, getLocationConfigurationService as t };

package/dist/turn-execution-BkinIdJF.js

@@ -0,0 +1,47 @@
+import { Ct as getConversationEventStore } from "./agent-hooks-Bbcp9e33.js";
+import { n as runAgentWithTimeout } from "./agent-runner-DNb1A49M.js";
+import { t as ConversationTurnLifecycleService } from "./turn-lifecycle-DQV19VTW.js";
+//#region src/chat/runtime/turn-execution.ts
+/** An error thrown while the agent advances a Run. */
+var AgentRunError = class extends Error {
+	constructor(cause) {
+		super(cause instanceof Error ? cause.message : "Agent Run failed", { cause });
+		this.name = "AgentRunError";
+	}
+};
+/**
+* Run the agent and finish the Turn after the caller saves its result.
+*
+* A paused Run, or a Run waiting for authorization, leaves the Turn open. A
+* save error also leaves the Turn open so the worker can retry or recover it.
+* A timeout aborts the Run before this function reports the failure.
+*/
+async function executeTurn(agentRunner, run, saveResult, timeoutMs) {
+	let outcome;
+	try {
+		outcome = await runAgentWithTimeout(agentRunner, run, timeoutMs);
+	} catch (error) {
+		throw new AgentRunError(error);
+	}
+	if (outcome.status !== "completed") return outcome;
+	const saved = await saveResult(outcome.result);
+	const lifecycle = new ConversationTurnLifecycleService(getConversationEventStore());
+	const common = {
+		conversationId: run.conversationId,
+		createdAtMs: saved.finishedAtMs ?? Date.now(),
+		turnId: run.turnId
+	};
+	if (saved.outcome === "failed") await lifecycle.fail({
+		...common,
+		...saved.eventId ? { eventId: saved.eventId } : void 0,
+		failureCode: saved.failureCode,
+		...saved.failureReason ? { failureReason: saved.failureReason } : void 0
+	});
+	else await lifecycle.complete({
+		...common,
+		outcome: saved.outcome
+	});
+	return { status: "completed" };
+}
+//#endregion
+export { executeTurn as n, AgentRunError as t };

package/dist/turn-lifecycle-DQV19VTW.js

@@ -0,0 +1,54 @@
+import { Ct as getConversationEventStore } from "./agent-hooks-Bbcp9e33.js";
+//#region src/chat/conversations/turn-lifecycle.ts
+/** Persist correlated turn lifecycle facts with retry-safe terminal exclusion. */
+var ConversationTurnLifecycleService = class {
+	events;
+	constructor(events) {
+		this.events = events;
+	}
+	/** Record the turn start once after every input message is durable. */
+	async start(input) {
+		await this.events.append(input.conversationId, [{
+			idempotencyKey: `turn:${input.turnId}:started`,
+			createdAtMs: input.createdAtMs,
+			data: {
+				type: "turn_started",
+				turnId: input.turnId,
+				inputMessageIds: input.inputMessageIds,
+				surface: input.surface
+			}
+		}]);
+	}
+	/** Record successful or intentional-silence completion once. */
+	async complete(input) {
+		await this.events.append(input.conversationId, [{
+			idempotencyKey: `turn:${input.turnId}:terminal`,
+			createdAtMs: input.createdAtMs,
+			data: {
+				type: "turn_completed",
+				turnId: input.turnId,
+				outcome: input.outcome
+			}
+		}]);
+	}
+	/** Record a classified failure once. Do not store raw error text. */
+	async fail(input) {
+		await this.events.append(input.conversationId, [{
+			idempotencyKey: `turn:${input.turnId}:terminal`,
+			createdAtMs: input.createdAtMs,
+			data: {
+				type: "turn_failed",
+				turnId: input.turnId,
+				failureCode: input.failureCode,
+				...input.failureReason ? { failureReason: input.failureReason } : void 0,
+				...input.eventId ? { eventId: input.eventId } : void 0
+			}
+		}]);
+	}
+};
+/** Return the Turn lifecycle that records Conversation events. */
+function getTurnLifecycle() {
+	return new ConversationTurnLifecycleService(getConversationEventStore());
+}
+//#endregion
+export { getTurnLifecycle as n, ConversationTurnLifecycleService as t };