@sentry/junior 0.202.0 → 0.204.0

package/dist/agent-runner-DNb1A49M.js

@@ -0,0 +1,678 @@
+import { m as normalizeSlackEmojiName } from "./config-nGCW1OTG.js";
+import { F as isRecord, d as logInfo, f as logWarn } from "./logging-BzAk1S_s.js";
+import { _ as parseSlackMessageTs, g as parseSlackUserId } from "./context-B45_WqVX.js";
+import { B as getSlackClient, Bt as parseDestination, G as withSlackRetries, H as isDmChannel, I as SlackActionError, U as normalizeSlackConversationId, n as applyPluginFormatMarkdown } from "./agent-hooks-Bbcp9e33.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-BReos-D4.js";
+import { w as getStateAdapter } from "./profile-CrT5nXbw.js";
+import { r as isExperimentalFeatureEnabled } from "./experimental-CIXf7Uye.js";
+import { randomBytes } from "node:crypto";
+import { actorSchema, sourceSchema } from "@sentry/junior-plugin-api";
+//#region src/chat/agent/types.ts
+/** Resume the agent turn after a transient or ambiguous delivery failure. */
+var RetryableDeliveryError = class extends Error {
+	constructor(cause) {
+		super("Assistant delivery was transient or ambiguous", { cause });
+		this.name = "RetryableDeliveryError";
+	}
+};
+/** Return whether one optional agent capability is disabled for this run. */
+function isAgentRunFeatureDisabled(disabledFeatures, feature) {
+	return disabledFeatures?.includes(feature) ?? false;
+}
+/** Resolve the explicit actor, dispatch actor, or credential actor for this run. */
+function actorFromRun(run) {
+	if (run.dispatch?.actor) return run.dispatch.actor;
+	if (run.actor) return run.actor;
+	if (run.credentialContext && !("type" in run.credentialContext.actor)) return run.credentialContext.actor;
+}
+/** Reject contradictory provider coordinates before the run touches state. */
+function assertRunConsistency(run) {
+	const { destination, source } = run;
+	switch (source.kind) {
+		case "slack":
+			if (destination.platform !== "slack") throw new TypeError("Run source and destination platforms do not match");
+			if (source.teamId !== destination.teamId) throw new TypeError("Slack source and destination teams do not match");
+			break;
+		case "local":
+			if (destination.platform !== "local") throw new TypeError("Run source and destination platforms do not match");
+			if (source.conversationId !== destination.conversationId) throw new TypeError("Source and destination conversation IDs do not match");
+			if (run.surface !== "internal" && destination.conversationId !== run.conversationId) throw new TypeError("Source, destination, and run conversation IDs do not match");
+			break;
+		case "web":
+			if (run.surface !== "internal" && source.conversationId !== run.conversationId) throw new TypeError("Web source and run conversation IDs do not match");
+			switch (destination.platform) {
+				case "local":
+					if (source.conversationId !== destination.conversationId) throw new TypeError("Source and destination conversation IDs do not match");
+					if (run.surface !== "internal" && destination.conversationId !== run.conversationId) throw new TypeError("Source, destination, and run conversation IDs do not match");
+			}
+			break;
+		case "resource_event":
+		case "scheduled_task":
+		case "event_task":
+		case "plugin_dispatch":
+		case "agent_invocation": return;
+	}
+	const actor = run.dispatch?.actor ?? run.actor;
+	if (!actor || actor.platform === "system") return;
+	if (actor.platform !== source.kind) throw new TypeError(`Actor platform "${actor.platform}" does not match Source kind "${source.kind}"`);
+	if (actor.platform === "slack" && source.kind === "slack" && actor.teamId !== source.teamId) throw new TypeError("Slack Actor team does not match Source team");
+}
+/** Route tool side effects to the tool channel when one overrides the destination. */
+function toolInvocationDestination(run) {
+	if (run.destination.platform !== "slack" || !run.toolChannelId) return run.destination;
+	return {
+		platform: "slack",
+		teamId: run.destination.teamId,
+		channelId: run.toolChannelId
+	};
+}
+/** Infer the run surface when the caller did not state one. */
+function surfaceFromRun(run) {
+	if (run.surface) return run.surface;
+	if (run.source.kind === "slack") return "slack";
+	if (run.source.kind === "web") return "api";
+	return "internal";
+}
+//#endregion
+//#region src/chat/slack/outbound.ts
+const MAX_SLACK_MESSAGE_TEXT_CHARS = 4e4;
+function requireSlackConversationId(channelId, action) {
+	const normalized = normalizeSlackConversationId(channelId);
+	if (!normalized) throw new Error(`${action} requires a valid channel ID`);
+	return normalized;
+}
+function requireSlackThreadTimestamp(threadTs, action) {
+	const normalized = threadTs.trim();
+	if (!normalized) throw new Error(`${action} requires a thread timestamp`);
+	return normalized;
+}
+function requireSlackMessageTimestamp(timestamp, action) {
+	const normalized = parseSlackMessageTs(timestamp);
+	if (!normalized) throw new Error(`${action} requires a target message timestamp`);
+	return normalized;
+}
+function requireSlackMessageText(text, action) {
+	if (text.trim().length === 0) throw new Error(`${action} requires non-empty text`);
+	if (text.length > MAX_SLACK_MESSAGE_TEXT_CHARS) throw new Error(`${action} text exceeds Slack's 40000 character truncation limit`);
+	return text;
+}
+/** Resolve a Slack message permalink without making read-only workflows fail on lookup errors. */
+async function getSlackMessagePermalink(args) {
+	try {
+		return (await withSlackRetries(() => getSlackClient().chat.getPermalink({
+			channel: args.channelId,
+			message_ts: args.messageTs
+		}), 3, {
+			action: "chat.getPermalink",
+			idempotent: true,
+			spanAttributes: {
+				"app.slack.channel_id": args.channelId,
+				"app.slack.message_ts": args.messageTs
+			}
+		})).permalink;
+	} catch {
+		return;
+	}
+}
+/** Post Slack `mrkdwn` text to a conversation or thread via the shared outbound boundary. */
+async function postSlackMessage(input) {
+	const channelId = requireSlackConversationId(input.channelId, "Slack message posting");
+	const text = requireSlackMessageText(input.text, "Slack message posting");
+	const threadTs = input.threadTs ? requireSlackThreadTimestamp(input.threadTs, "Slack thread message posting") : void 0;
+	const response = await withSlackRetries(() => getSlackClient().chat.postMessage({
+		channel: channelId,
+		text,
+		unfurl_links: false,
+		unfurl_media: false,
+		...input.blocks?.length ? { blocks: input.blocks } : void 0,
+		...threadTs ? { thread_ts: threadTs } : void 0
+	}), 3, {
+		action: "chat.postMessage",
+		spanAttributes: {
+			"app.slack.channel_id": channelId,
+			...threadTs ? { "app.slack.thread_ts": threadTs } : void 0
+		}
+	});
+	const messageTs = parseSlackMessageTs(response.ts);
+	if (!messageTs) throw new Error("Slack message posted without ts");
+	return {
+		ts: messageTs,
+		...input.includePermalink ? { permalink: await getSlackMessagePermalink({
+			channelId,
+			messageTs
+		}) } : void 0
+	};
+}
+/**
+* Post an ephemeral Slack message. Delivery is best-effort on Slack's side, but
+* request validation and Web API behavior are centralized here.
+*/
+async function postSlackEphemeralMessage(input) {
+	const channelId = requireSlackConversationId(input.channelId, "Slack ephemeral message posting");
+	const userId = parseSlackUserId(input.userId);
+	if (!userId) throw new Error("Slack ephemeral message posting requires a user ID");
+	const text = requireSlackMessageText(input.text, "Slack ephemeral message posting");
+	const threadTs = input.threadTs ? requireSlackThreadTimestamp(input.threadTs, "Slack ephemeral thread message posting") : void 0;
+	return { messageTs: (await withSlackRetries(() => getSlackClient().chat.postEphemeral({
+		channel: channelId,
+		user: userId,
+		text,
+		...threadTs ? { thread_ts: threadTs } : void 0
+	}), 3, {
+		action: "chat.postEphemeral",
+		spanAttributes: {
+			"app.slack.channel_id": channelId,
+			"app.slack.user_id": userId,
+			...threadTs ? { "app.slack.thread_ts": threadTs } : void 0
+		}
+	})).message_ts };
+}
+/** Upload files into a Slack conversation or thread via the shared outbound file boundary. */
+async function uploadFilesToConversation(input) {
+	const channelId = requireSlackConversationId(input.channelId, "Slack file upload");
+	const threadTs = input.threadTs ? requireSlackThreadTimestamp(input.threadTs, "Slack file upload") : void 0;
+	if (input.files.length === 0) throw new Error("Slack file upload requires at least one file");
+	const fileUploads = input.files.map((file) => {
+		const filename = file.filename.trim();
+		if (!filename) throw new Error("Slack file upload requires every file to have a filename");
+		return {
+			file: file.data,
+			filename
+		};
+	});
+	return { files: ((await withSlackRetries(() => getSlackClient().filesUploadV2({
+		channel_id: channelId,
+		...threadTs ? { thread_ts: threadTs } : void 0,
+		file_uploads: fileUploads
+	}), 3, {
+		action: "filesUploadV2",
+		spanAttributes: {
+			"app.slack.channel_id": channelId,
+			...threadTs ? { "app.slack.thread_ts": threadTs } : void 0
+		}
+	})).files ?? []).flatMap((completion) => (completion.files ?? []).map((file) => file.id ? { id: file.id } : {})) };
+}
+/** Add a reaction to a Slack message, treating `already_reacted` as idempotent success. */
+async function addReactionToMessage(input) {
+	const channelId = requireSlackConversationId(input.channelId, "Slack reaction");
+	const timestamp = requireSlackMessageTimestamp(input.timestamp, "Slack reaction");
+	const emoji = normalizeSlackEmojiName(input.emoji);
+	if (!emoji) throw new Error("Slack reaction requires a valid emoji alias name");
+	try {
+		await withSlackRetries(() => getSlackClient().reactions.add({
+			channel: channelId,
+			timestamp,
+			name: emoji
+		}), 3, {
+			action: "reactions.add",
+			idempotent: true,
+			spanAttributes: {
+				"app.slack.channel_id": channelId,
+				"app.slack.message_ts": timestamp,
+				"app.slack.reaction": emoji
+			}
+		});
+	} catch (error) {
+		if (error instanceof SlackActionError && error.code === "already_reacted") return { ok: true };
+		throw error;
+	}
+	return { ok: true };
+}
+/** Remove a reaction from a Slack message, treating `no_reaction` as idempotent success. */
+async function removeReactionFromMessage(input) {
+	const channelId = requireSlackConversationId(input.channelId, "Slack reaction removal");
+	const timestamp = requireSlackMessageTimestamp(input.timestamp, "Slack reaction removal");
+	const emoji = normalizeSlackEmojiName(input.emoji);
+	if (!emoji) throw new Error("Slack reaction removal requires a valid emoji alias name");
+	try {
+		await withSlackRetries(() => getSlackClient().reactions.remove({
+			channel: channelId,
+			timestamp,
+			name: emoji
+		}), 3, {
+			action: "reactions.remove",
+			idempotent: true,
+			spanAttributes: {
+				"app.slack.channel_id": channelId,
+				"app.slack.message_ts": timestamp,
+				"app.slack.reaction": emoji
+			}
+		});
+	} catch (error) {
+		if (error instanceof SlackActionError && error.code === "no_reaction") return { ok: true };
+		throw error;
+	}
+	return { ok: true };
+}
+//#endregion
+//#region src/chat/slack/status-format.ts
+const SLACK_STATUS_MAX_LENGTH = 50;
+/** Truncate a status string to fit Slack's 50-char assistant status limit. */
+function truncateStatusText(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return "";
+	if (trimmed.length <= SLACK_STATUS_MAX_LENGTH) return trimmed;
+	return `${trimmed.slice(0, 47).trimEnd()}...`;
+}
+//#endregion
+//#region src/chat/slack/mrkdwn.ts
+/** Escape dynamic text for Slack mrkdwn without changing intended formatting. */
+function escapeSlackMrkdwnText(text) {
+	return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+/** Escape a URL for Slack explicit link syntax while preserving query semantics. */
+function escapeSlackLinkUrl(url) {
+	return url.replaceAll("&", "&amp;").replaceAll("<", "%3C").replaceAll(">", "%3E");
+}
+/** Build a Slack explicit link from dynamic URL and label values. */
+function formatSlackLink(url, label) {
+	return `<${escapeSlackLinkUrl(url)}|${escapeSlackMrkdwnText(label)}>`;
+}
+function readInlineCodeSpan(line, start) {
+	if (line[start] !== "`") return;
+	let n = 1;
+	while (line[start + n] === "`") n++;
+	const marker = "`".repeat(n);
+	let search = start + n;
+	while (search < line.length) {
+		const close = line.indexOf(marker, search);
+		if (close === -1) return;
+		const after = close + n;
+		if (line[after] !== "`") return {
+			text: line.slice(start, after),
+			end: after
+		};
+		search = after + 1;
+	}
+}
+function readExistingSlackAngleToken(line, start) {
+	if (line[start] !== "<") return;
+	const close = line.indexOf(">", start + 1);
+	if (close === -1) return;
+	const body = line.slice(start + 1, close);
+	if (/^(?:https?:\/\/|@|#|!)/.test(body)) return {
+		text: line.slice(start, close + 1),
+		end: close + 1
+	};
+}
+function readMarkdownLink(line, start) {
+	if (line[start] !== "[") return;
+	const labelEnd = line.indexOf("](", start + 1);
+	if (labelEnd === -1) return;
+	const destStart = labelEnd + 2;
+	if (!line.startsWith("http://", destStart) && !line.startsWith("https://", destStart)) return;
+	const closeParens = line.indexOf(")", destStart);
+	if (closeParens === -1) return;
+	return {
+		text: line.slice(start, closeParens + 1),
+		end: closeParens + 1
+	};
+}
+function hasUnmatchedClosingParen(text) {
+	let balance = 0;
+	for (const ch of text) if (ch === "(") balance++;
+	else if (ch === ")") balance--;
+	return balance < 0;
+}
+function readBareUrl(line, start) {
+	let end = start;
+	while (end < line.length) {
+		const ch = line[end];
+		if (/\s/.test(ch) || ch === "<" || ch === ">" || ch === "\"" || ch === "`" || ch === "|" || ch === "*") break;
+		end++;
+	}
+	if (end === start) return;
+	let raw = line.slice(start, end);
+	let suffix = "";
+	const peel = () => {
+		suffix = raw.slice(-1) + suffix;
+		raw = raw.slice(0, -1);
+	};
+	const shouldPeel = () => raw.endsWith("_") || /[.,!?;:]$/.test(raw) || raw.endsWith(")") && hasUnmatchedClosingParen(raw);
+	while (raw.length > 0 && shouldPeel()) peel();
+	if (!/^https?:\/\/.+/.test(raw)) return;
+	return {
+		url: raw,
+		suffix,
+		end
+	};
+}
+/** Wrap bare http(s) URLs on a single line as Slack explicit `<url>` links. */
+function wrapBareUrlsOnLine(line) {
+	let result = "";
+	let i = 0;
+	while (i < line.length) {
+		const codeSpan = readInlineCodeSpan(line, i);
+		if (codeSpan) {
+			result += codeSpan.text;
+			i = codeSpan.end;
+			continue;
+		}
+		const angleToken = readExistingSlackAngleToken(line, i);
+		if (angleToken) {
+			result += angleToken.text;
+			i = angleToken.end;
+			continue;
+		}
+		const mdLink = readMarkdownLink(line, i);
+		if (mdLink) {
+			result += mdLink.text;
+			i = mdLink.end;
+			continue;
+		}
+		if (line.startsWith("https://", i) || line.startsWith("http://", i)) {
+			const parsed = readBareUrl(line, i);
+			if (parsed) {
+				result += `<${parsed.url}>${parsed.suffix}`;
+				i = parsed.end;
+				continue;
+			}
+		}
+		result += line[i];
+		i++;
+	}
+	return result;
+}
+/**
+* Pre-wrap bare http(s) URLs outside fenced code blocks as Slack explicit
+* links, preventing Slack's auto-linker from consuming adjacent formatting
+* markers into the URL.
+*
+* Uses the same fence-toggle rule as `ensureBlockSpacing` so both passes
+* agree on which lines are code.
+*/
+function wrapBareUrls(text) {
+	const lines = text.split("\n");
+	const out = [];
+	let inCodeBlock = false;
+	for (const line of lines) {
+		if (line.trimStart().startsWith("```")) {
+			inCodeBlock = !inCodeBlock;
+			out.push(line);
+			continue;
+		}
+		out.push(inCodeBlock ? line : wrapBareUrlsOnLine(line));
+	}
+	return out.join("\n");
+}
+/** Insert blank lines between content blocks so Slack renders them with visual separation. */
+function ensureBlockSpacing(text) {
+	const codeBlockPattern = /^```/;
+	const listItemPattern = /^[-*•]\s|^\d+\.\s/;
+	const lines = text.split("\n");
+	const result = [];
+	let inCodeBlock = false;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (codeBlockPattern.test(line.trimStart())) {
+			if (!inCodeBlock) {
+				const prev = result.length > 0 ? result[result.length - 1] : void 0;
+				if (prev !== void 0 && prev.trim() !== "") result.push("");
+			}
+			inCodeBlock = !inCodeBlock;
+			result.push(line);
+			continue;
+		}
+		if (inCodeBlock) {
+			result.push(line);
+			continue;
+		}
+		const prev = result.length > 0 ? result[result.length - 1] : void 0;
+		if (prev !== void 0 && prev.trim() !== "" && line.trim() !== "" && !(listItemPattern.test(prev.trimStart()) && listItemPattern.test(line.trimStart()))) result.push("");
+		result.push(line);
+	}
+	return result.join("\n");
+}
+/**
+* Normalize model-authored Slack markdown for delivery via `markdown_text`
+* or `{ type: "markdown" }` blocks.
+*
+* Plugins may first rewrite ordinary Markdown. Core then applies Slack-only
+* delivery shaping: bare URL wrapping and block spacing. Slack reply delivery
+* owns chunking and continuation markers separately.
+*/
+function normalizeSlackReplyMarkdown(text) {
+	let normalized = applyPluginFormatMarkdown(text).replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "");
+	normalized = wrapBareUrls(normalized);
+	normalized = ensureBlockSpacing(normalized);
+	return normalized.replace(/\n{3,}/g, "\n\n").trim();
+}
+/** Normalize assistant status text before handing it to Slack. */
+function normalizeSlackStatusText(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return "";
+	return truncateStatusText(trimmed.replace(/(?:\.\s*)+$/, "").trim());
+}
+//#endregion
+//#region src/chat/slack/oauth-authorization-message.ts
+/** Format the private OAuth authorization prompt for Slack delivery. */
+function formatOAuthAuthorizationMessage(args) {
+	return `${formatSlackLink(args.authorizationUrl, args.label)}. ${args.completionText}`;
+}
+//#endregion
+//#region src/chat/oauth-flow.ts
+const OAUTH_STATE_TTL_MS = 6e5;
+function optionalString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+/** Parse OAuth callback state that was persisted before a provider redirect. */
+function parseOAuthStatePayload(value) {
+	if (!isRecord(value)) return;
+	if (typeof value.userId !== "string" || typeof value.provider !== "string") return;
+	const actor = value.actor === void 0 ? void 0 : actorSchema.safeParse(value.actor);
+	if (value.actor !== void 0 && (!actor || !actor.success)) return;
+	const destination = parseDestination(value.destination);
+	if (value.destination !== void 0 && !destination) return;
+	const source = value.source === void 0 ? void 0 : sourceSchema.safeParse(value.source);
+	if (value.source !== void 0 && (!source || !source.success)) return;
+	return {
+		userId: value.userId,
+		provider: value.provider,
+		...actor?.success ? { actor: actor.data } : void 0,
+		...optionalString(value.channelId) ? { channelId: optionalString(value.channelId) } : void 0,
+		...destination ? { destination } : void 0,
+		...source?.success ? { source: source.data } : void 0,
+		...optionalString(value.threadTs) ? { threadTs: optionalString(value.threadTs) } : void 0,
+		...optionalString(value.resumeConversationId) ? { resumeConversationId: optionalString(value.resumeConversationId) } : void 0,
+		...optionalString(value.resumeSessionId) ? { resumeSessionId: optionalString(value.resumeSessionId) } : void 0,
+		...optionalString(value.scope) ? { scope: optionalString(value.scope) } : void 0
+	};
+}
+/** Return the manifest-owned display label for a provider. */
+function formatProviderLabel(provider) {
+	const displayName = pluginCatalogRuntime.getDisplayName(provider);
+	if (!displayName) throw new Error(`Unknown plugin provider display name: "${provider}"`);
+	return displayName;
+}
+/** Resolve the public base URL from environment variables (JUNIOR_BASE_URL or Vercel). */
+function resolveBaseUrl() {
+	const explicit = process.env.JUNIOR_BASE_URL?.trim();
+	if (explicit) return explicit;
+	const vercelProd = process.env.VERCEL_PROJECT_PRODUCTION_URL?.trim();
+	if (vercelProd) return `https://${vercelProd}`;
+	const vercelUrl = process.env.VERCEL_URL?.trim();
+	if (vercelUrl) return `https://${vercelUrl}`;
+}
+/**
+* Authorization links must only be visible to the requesting user.
+* Try in-context private delivery first, then fall back to a DM.
+*/
+async function deliverPrivateMessage(input) {
+	let client;
+	try {
+		client = getSlackClient();
+	} catch {
+		logWarn("oauth.private_delivery.skipped", { "app.reason": "missing_bot_token" });
+		return false;
+	}
+	if (input.channelId) try {
+		if (isDmChannel(input.channelId)) await postSlackMessage({
+			channelId: input.channelId,
+			text: input.text,
+			threadTs: input.threadTs
+		});
+		else await postSlackEphemeralMessage({
+			channelId: input.channelId,
+			userId: input.userId,
+			text: input.text,
+			threadTs: input.threadTs
+		});
+		return "in_context";
+	} catch (error) {
+		logWarn("oauth.private_delivery.failed", {
+			"app.slack.error": error instanceof Error ? error.message : String(error),
+			"app.slack.channel": input.channelId
+		});
+	}
+	try {
+		const dmChannelId = (await withSlackRetries(() => client.conversations.open({ users: input.userId }), 3, {
+			action: "conversations.open",
+			spanAttributes: { "app.slack.user_id": input.userId }
+		})).channel?.id;
+		if (!dmChannelId) {
+			logWarn("oauth.dm.fallback.failed", { "app.reason": "no_dm_channel_id" });
+			return false;
+		}
+		await postSlackMessage({
+			channelId: dmChannelId,
+			text: input.text
+		});
+		return "fallback_dm";
+	} catch (error) {
+		logWarn("oauth.dm.fallback.failed", { "app.slack.error": error instanceof Error ? error.message : String(error) });
+		return false;
+	}
+}
+/** Present one OAuth request through the active surface's private delivery. */
+async function deliverOAuthAuthorization(request, input) {
+	if (input.authorization) {
+		await input.authorization.deliver(request);
+		return "in_context";
+	}
+	return await deliverPrivateMessage({
+		channelId: input.channelId,
+		threadTs: input.threadTs,
+		userId: input.userId,
+		text: formatOAuthAuthorizationMessage(request)
+	});
+}
+/** Initiate an OAuth authorization code flow for a provider and deliver the auth link to the user. */
+async function startOAuthFlow(provider, input) {
+	const providerConfig = pluginCatalogRuntime.getOAuthConfig(provider);
+	if (!providerConfig) return {
+		ok: false,
+		error: `Provider "${provider}" does not support OAuth authorization`
+	};
+	const clientId = process.env[providerConfig.clientIdEnv]?.trim();
+	if (!clientId) return {
+		ok: false,
+		error: `Missing ${providerConfig.clientIdEnv} environment variable`
+	};
+	const baseUrl = resolveBaseUrl();
+	if (!baseUrl) return {
+		ok: false,
+		error: "Cannot determine base URL (set JUNIOR_BASE_URL or deploy to Vercel)"
+	};
+	const state = input.authorization ? await input.authorization.createState() : randomBytes(32).toString("hex");
+	const requestedScope = input.scope ?? providerConfig.scope;
+	await getStateAdapter().set(`oauth-state:${state}`, {
+		userId: input.actorId,
+		provider,
+		...input.actor ? { actor: input.actor } : void 0,
+		...input.channelId ? { channelId: input.channelId } : void 0,
+		...input.destination ? { destination: input.destination } : void 0,
+		...input.source ? { source: input.source } : void 0,
+		...input.threadTs ? { threadTs: input.threadTs } : void 0,
+		...input.resumeConversationId ? { resumeConversationId: input.resumeConversationId } : void 0,
+		...input.resumeSessionId ? { resumeSessionId: input.resumeSessionId } : void 0,
+		...requestedScope ? { scope: requestedScope } : void 0
+	}, OAUTH_STATE_TTL_MS);
+	const authorizeParams = new URLSearchParams({
+		client_id: clientId,
+		state,
+		redirect_uri: `${baseUrl}${providerConfig.callbackPath}`,
+		response_type: "code"
+	});
+	if (requestedScope) authorizeParams.set("scope", requestedScope);
+	for (const [key, value] of Object.entries(providerConfig.authorizeParams ?? {})) authorizeParams.set(key, value);
+	logInfo("jr_rpc.oauth.started", {
+		"app.credential.provider": provider,
+		...input.activeSkillName ? { "app.skill.name": input.activeSkillName } : void 0
+	});
+	return {
+		ok: true,
+		delivery: await deliverOAuthAuthorization({
+			authorizationUrl: `${providerConfig.authorizeEndpoint}?${authorizeParams.toString()}`,
+			label: `Click here to link your ${formatProviderLabel(provider)} account`,
+			completionText: input.resumeSessionId ? "Once you've authorized, Junior will continue automatically." : "Once you've authorized, you'll see a confirmation in Slack."
+		}, {
+			authorization: input.authorization,
+			channelId: input.channelId,
+			threadTs: input.threadTs,
+			userId: input.actorId
+		})
+	};
+}
+//#endregion
+//#region src/chat/runtime/agent-runner.ts
+const AGENT_ABORT_SETTLE_GRACE_MS = 5e3;
+/** Compose the agent executor with stable host dependencies. */
+function createAgentRunner(execute, options) {
+	const attachmentStorage = options?.attachmentStorage;
+	const streamFn = options?.streamFn;
+	const tracePropagation = options?.tracePropagation;
+	const bindSpawnAgent = options?.bindSpawnAgent;
+	const canBindSpawn = Boolean(bindSpawnAgent) && isExperimentalFeatureEnabled("subagents");
+	return { run: async (run) => {
+		const spawnAgent = bindSpawnAgent && canBindSpawn && !isAgentRunFeatureDisabled(run.disabledFeatures, "subagents") ? bindSpawnAgent(run) : void 0;
+		return await execute({
+			...run,
+			environment: {
+				...run.environment,
+				attachmentStorage: run.environment?.attachmentStorage ?? attachmentStorage,
+				sandboxTracePropagation: run.environment?.sandboxTracePropagation ?? tracePropagation
+			},
+			...spawnAgent ? { durability: {
+				...run.durability,
+				spawnAgent
+			} } : void 0
+		}, streamFn);
+	} };
+}
+async function waitForAgentSettlement(runPromise) {
+	let timeoutId;
+	const settleGrace = new Promise((resolve) => {
+		timeoutId = setTimeout(resolve, AGENT_ABORT_SETTLE_GRACE_MS);
+		timeoutId.unref?.();
+	});
+	await Promise.race([runPromise.then(() => void 0, () => void 0), settleGrace]);
+	if (timeoutId) clearTimeout(timeoutId);
+}
+/** Abort a timed-out agent run and wait briefly for its work to settle. */
+async function runAgentWithTimeout(agentRunner, run, timeoutMs) {
+	if (typeof timeoutMs !== "number") return await agentRunner.run(run);
+	const timeoutError = /* @__PURE__ */ new Error(`executeAgentRun timed out after ${timeoutMs}ms`);
+	const abortController = new AbortController();
+	const signal = run.signal ? AbortSignal.any([run.signal, abortController.signal]) : abortController.signal;
+	const runPromise = agentRunner.run({
+		...run,
+		signal
+	});
+	let timeoutId;
+	const timeoutPromise = new Promise((_, reject) => {
+		timeoutId = setTimeout(() => {
+			abortController.abort(timeoutError);
+			reject(timeoutError);
+		}, timeoutMs);
+	});
+	try {
+		return await Promise.race([runPromise, timeoutPromise]);
+	} catch (error) {
+		if (abortController.signal.aborted) await waitForAgentSettlement(runPromise);
+		throw error;
+	} finally {
+		if (timeoutId) clearTimeout(timeoutId);
+	}
+}
+//#endregion
+export { toolInvocationDestination as C, surfaceFromRun as S, uploadFilesToConversation as _, parseOAuthStatePayload as a, assertRunConsistency as b, escapeSlackMrkdwnText as c, normalizeSlackStatusText as d, truncateStatusText as f, removeReactionFromMessage as g, postSlackMessage as h, formatProviderLabel as i, formatSlackLink as l, getSlackMessagePermalink as m, runAgentWithTimeout as n, resolveBaseUrl as o, addReactionToMessage as p, deliverOAuthAuthorization as r, startOAuthFlow as s, createAgentRunner as t, normalizeSlackReplyMarkdown as u, RetryableDeliveryError as v, isAgentRunFeatureDisabled as x, actorFromRun as y };