@sentry/junior 0.204.0 → 0.206.0

package/dist/config-CIE83sR2.js

@@ -0,0 +1,386 @@
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
+import { o as resolveGatewayModel, w as toOptionalTrimmed } from "./client-ceE7NtvC.js";
+import { f as logWarn } from "./logging-D37bayDc.js";
+import { c as TURN_REASONING_LEVELS, l as parseTurnReasoningLevel, o as modelProfileSchema } from "./model-profile-CZmVoGdX.js";
+import { getModel } from "@earendil-works/pi-ai/compat";
+//#region src/chat/slack/emoji.ts
+const SLACK_EMOJI_NAME_RE = /^(?:[a-z0-9_+-]+)(?:::(?:skin-tone-[2-6]))?$/;
+function normalizeSlackEmojiName(value) {
+	const trimmed = value.trim().toLowerCase();
+	if (!trimmed) return null;
+	const normalized = trimmed.startsWith(":") && trimmed.endsWith(":") ? trimmed.slice(1, -1) : trimmed;
+	return SLACK_EMOJI_NAME_RE.test(normalized) ? normalized : null;
+}
+//#endregion
+//#region src/chat/config.ts
+var config_exports = /* @__PURE__ */ __exportAll({
+	CONVERSATION_WORK_SOFT_YIELD_BUFFER_SECONDS: () => 40,
+	DEFAULT_SQL_STATEMENT_TIMEOUT_MS: () => DEFAULT_SQL_STATEMENT_TIMEOUT_MS,
+	FUNCTION_TIMEOUT_BUFFER_SECONDS: () => 20,
+	botConfig: () => botConfig,
+	configureFunctionMaxDurationSeconds: () => configureFunctionMaxDurationSeconds,
+	getChatConfig: () => getChatConfig,
+	getRuntimeMetadata: () => getRuntimeMetadata,
+	getSlackBotToken: () => getSlackBotToken,
+	getSlackClientId: () => getSlackClientId,
+	getSlackClientSecret: () => getSlackClientSecret,
+	getSlackReactionConfig: () => getSlackReactionConfig,
+	getSlackSigningSecret: () => getSlackSigningSecret,
+	readChatConfig: () => readChatConfig,
+	setBotModelConfig: () => setBotModelConfig,
+	setProfiles: () => setProfiles,
+	setSlackReactionConfig: () => setSlackReactionConfig
+});
+const MIN_AGENT_TURN_TIMEOUT_MS = 1e4;
+const DEFAULT_AGENT_TURN_TIMEOUT_MS = 72e4;
+const MAX_SLICES_PER_TURN = 100;
+/**
+* Max tool calls for one turn, including later execution slices of that turn.
+* Chosen from production dispatch traces: healthy runs cluster well under 50;
+* runaway CI-watch loops land in the hundreds. Raised from 150 after that cap
+* fired on legitimate long-form human turns, not just runaway automation.
+*/
+const MAX_TOOL_CALLS_PER_TURN = 250;
+/**
+* Max consecutive automated turns before event wakes stop until a user message.
+* Resource-event CI watches and event-task loops are the common runaway paths.
+* Sentry telemetry has no direct instrumentation for how long real automated
+* chains run (only failure paths on the notice are logged, and those show zero
+* hits in the last 30d), so this is sized qualitatively: it stays well under
+* the runaway CI-watch-loop range noted for maxToolCallsPerTurn (hundreds of
+* tool calls) while giving multi-phase event-task/scheduled-task work enough
+* headroom to avoid pausing on legitimate longer-running automation.
+*/
+const MAX_CONSECUTIVE_AUTOMATED_TURNS = 25;
+const DEFAULT_FUNCTION_MAX_DURATION_SECONDS = 300;
+const DEFAULT_SLACK_SLASH_COMMAND = "/jr";
+const DEFAULT_PROCESSING_REACTION_EMOJI = "eyes";
+const DEFAULT_COMPLETED_REACTION_EMOJI = "white_check_mark";
+const DEFAULT_MODEL_CONTEXT_WINDOW_TOKENS = 4e5;
+const DEFAULT_SQL_STATEMENT_TIMEOUT_MS = 3e4;
+const DEFAULT_ASSISTANT_LOADING_MESSAGES = [
+	"Consulting the orb",
+	"Bribing the gremlins",
+	"Shuffling the papers dramatically",
+	"Summoning the right stack trace",
+	"Negotiating with the mutex",
+	"Poking the internet with a stick",
+	"Asking the docs nicely",
+	"Searching for the least cursed path",
+	"Pretending this was obvious",
+	"Waking up the test suite",
+	"Untangling the spaghetti carefully",
+	"Rattling the command line"
+];
+function parseAgentTurnTimeoutMs(rawValue, maxTimeoutMs) {
+	const value = Number.parseInt(rawValue ?? "", 10);
+	if (Number.isNaN(value)) return Math.max(MIN_AGENT_TURN_TIMEOUT_MS, Math.min(DEFAULT_AGENT_TURN_TIMEOUT_MS, maxTimeoutMs));
+	return Math.max(MIN_AGENT_TURN_TIMEOUT_MS, Math.min(value, maxTimeoutMs));
+}
+function resolveFunctionMaxDurationSeconds(functionMaxDurationSeconds) {
+	return functionMaxDurationSeconds ?? DEFAULT_FUNCTION_MAX_DURATION_SECONDS;
+}
+function resolveConversationWorkSoftYieldAfterMs(functionMaxDurationSeconds) {
+	return Math.max(MIN_AGENT_TURN_TIMEOUT_MS, (functionMaxDurationSeconds - 40) * 1e3);
+}
+function resolveMaxTurnTimeoutMs(functionMaxDurationSeconds) {
+	const budgetSeconds = functionMaxDurationSeconds - 20;
+	return Math.max(MIN_AGENT_TURN_TIMEOUT_MS, budgetSeconds * 1e3);
+}
+function parseLoadingMessages(rawValue) {
+	const trimmed = rawValue?.trim();
+	if (!trimmed) return [...DEFAULT_ASSISTANT_LOADING_MESSAGES];
+	let parsed;
+	try {
+		parsed = JSON.parse(trimmed);
+	} catch {
+		throw new Error("JUNIOR_LOADING_MESSAGES must be a JSON array of strings");
+	}
+	if (!Array.isArray(parsed)) throw new Error("JUNIOR_LOADING_MESSAGES must be a JSON array of strings");
+	return parsed.map((value, index) => {
+		if (typeof value !== "string") throw new Error(`JUNIOR_LOADING_MESSAGES[${index}] must be a string`);
+		return value.trim();
+	});
+}
+function parseOptionalPositiveInteger(envName, rawValue) {
+	const trimmed = toOptionalTrimmed(rawValue);
+	if (trimmed === void 0) return;
+	const value = Number.parseInt(trimmed, 10);
+	if (!Number.isSafeInteger(value) || value <= 0 || String(value) !== trimmed) throw new Error(`${envName} must be a positive integer`);
+	return value;
+}
+function parseSlashCommand(rawValue) {
+	const command = toOptionalTrimmed(rawValue) ?? DEFAULT_SLACK_SLASH_COMMAND;
+	if (!command.startsWith("/") || /\s/.test(command)) throw new Error("JUNIOR_SLASH_COMMAND must start with / and contain no whitespace");
+	return command;
+}
+function parseConversationWorkEnabled(rawValue) {
+	const value = toOptionalTrimmed(rawValue)?.toLowerCase();
+	if (value === void 0 || value === "true") return true;
+	if (value === "false") return false;
+	throw new Error("JUNIOR_CONVERSATION_WORK_ENABLED must be true or false");
+}
+function parseCrossActorMidRunMode(rawValue) {
+	const value = toOptionalTrimmed(rawValue) ?? "follow_up";
+	if (value === "follow_up" || value === "steer") return value;
+	throw new Error("JUNIOR_CROSS_ACTOR_MID_RUN_MODE must be follow_up or steer");
+}
+const DEFAULT_MODEL_ID = getModel("vercel-ai-gateway", "xai/grok-4.5").id;
+const DEFAULT_FAST_MODEL_ID = getModel("vercel-ai-gateway", "anthropic/claude-haiku-4.5").id;
+const DEFAULT_GUARDIAN_MODEL_ID = getModel("vercel-ai-gateway", "openai/gpt-5.6-luna").id;
+const DEFAULT_HANDOFF_MODEL_ID = getModel("vercel-ai-gateway", "openai/gpt-5.6-sol").id;
+const DEFAULT_WEB_SEARCH_MODEL_ID = getModel("vercel-ai-gateway", "openai/gpt-5.4").id;
+const DEFAULT_EMBEDDING_MODEL_ID = "openai/text-embedding-3-small";
+const DEFAULT_IMAGE_GENERATION_MODEL_ID = "google/gemini-3-pro-image";
+function validateGatewayModelId(raw) {
+	const trimmed = toOptionalTrimmed(raw);
+	if (trimmed === void 0) return void 0;
+	resolveGatewayModel(trimmed);
+	return trimmed;
+}
+function validateEmbeddingModelId(raw) {
+	return toOptionalTrimmed(raw);
+}
+function requireModelId(configName, raw, validate) {
+	const modelId = validate(raw);
+	if (!modelId) throw new Error(`${configName} must not be empty`);
+	return modelId;
+}
+const DEFAULT_STANDARD_PROFILE_DESCRIPTION = "Use for default assistant work: lookups, explanations, ordinary tool use, short answers, and light investigation of one source. Avoid for implementation, debugging, multi-file changes, architecture decisions, or research across several systems.";
+const DEFAULT_HANDOFF_PROFILE_DESCRIPTION = "Use for coding and difficult multi-step work: implementation, debugging, root-cause analysis, broad refactors, multi-file changes, architecture decisions, and research across several systems. Avoid for simple lookups, short answers, single-file reads, or ordinary tool use that the default profile can finish.";
+function parseOptionalProfileDescription(rawDescription, configName, profile) {
+	if (rawDescription === void 0) return;
+	if (typeof rawDescription !== "string") throw new Error(`${configName}.${profile}.description must be a string when set`);
+	const description = toOptionalTrimmed(rawDescription);
+	if (!description) throw new Error(`${configName}.${profile}.description must not be empty when set`);
+	return description;
+}
+function parseOptionalProfileReasoningLevel(rawReasoningLevel, configName, profile) {
+	if (rawReasoningLevel === void 0) return;
+	try {
+		return parseTurnReasoningLevel(rawReasoningLevel);
+	} catch {
+		throw new Error(`${configName}.${profile}.reasoningLevel must be one of ${TURN_REASONING_LEVELS.join(", ")}`);
+	}
+}
+function parseProfileConfig(rawProfile, configName, profile) {
+	if (typeof rawProfile === "string") {
+		const modelId = validateGatewayModelId(rawProfile);
+		if (!modelId) throw new Error(`${configName}.${profile} must not be empty`);
+		return { modelId };
+	}
+	if (!rawProfile || typeof rawProfile !== "object" || Array.isArray(rawProfile)) throw new Error(`${configName}.${profile} must be a model id string or an object with modelId`);
+	const rawModelId = rawProfile.modelId;
+	if (typeof rawModelId !== "string") throw new Error(`${configName}.${profile}.modelId must be a model id string`);
+	const modelId = validateGatewayModelId(rawModelId);
+	if (!modelId) throw new Error(`${configName}.${profile}.modelId must not be empty`);
+	const description = parseOptionalProfileDescription(rawProfile.description, configName, profile);
+	const reasoningLevel = parseOptionalProfileReasoningLevel(rawProfile.reasoningLevel, configName, profile);
+	return {
+		modelId,
+		...description ? { description } : void 0,
+		...reasoningLevel ? { reasoningLevel } : void 0
+	};
+}
+function parseProfileMap(rawProfiles, configName) {
+	if (!rawProfiles || typeof rawProfiles !== "object" || Array.isArray(rawProfiles)) throw new Error(`${configName} must be ${configName === "AI_MODEL_PROFILES" ? "a JSON object" : "an object"}`);
+	const profiles = {};
+	for (const [profile, rawProfile] of Object.entries(rawProfiles)) {
+		if (!modelProfileSchema.safeParse(profile).success) throw new Error(`${configName} profile "${profile}" must match ^[a-z][a-z0-9_-]*$`);
+		profiles[profile] = parseProfileConfig(rawProfile, configName, profile);
+	}
+	return profiles;
+}
+function parseProfiles(rawValue, standardModelId, handoffModelId) {
+	const profiles = {
+		standard: {
+			modelId: standardModelId,
+			description: DEFAULT_STANDARD_PROFILE_DESCRIPTION
+		},
+		handoff: {
+			modelId: handoffModelId,
+			description: DEFAULT_HANDOFF_PROFILE_DESCRIPTION,
+			reasoningLevel: "high"
+		}
+	};
+	const trimmed = toOptionalTrimmed(rawValue);
+	if (trimmed === void 0) return profiles;
+	let parsed;
+	try {
+		parsed = JSON.parse(trimmed);
+	} catch {
+		throw new Error("AI_MODEL_PROFILES must be a JSON object");
+	}
+	return {
+		...profiles,
+		...parseProfileMap(parsed, "AI_MODEL_PROFILES")
+	};
+}
+function parseReactionEmoji(envName, rawValue, defaultEmoji) {
+	const trimmed = toOptionalTrimmed(rawValue);
+	if (trimmed === void 0) return defaultEmoji;
+	const normalized = normalizeSlackEmojiName(trimmed);
+	if (!normalized) throw new Error(`${envName} must be a valid Slack emoji name (for example "eyes" or ":white_check_mark:")`);
+	return normalized;
+}
+function warnDeprecatedProfileEnv(env) {
+	for (const envName of [
+		"AI_MODEL",
+		"AI_HANDOFF_MODEL",
+		"AI_MODEL_PROFILES"
+	]) if (toOptionalTrimmed(env[envName]) !== void 0) logWarn("config.profile_env.deprecated", {
+		"app.config.env_name": envName,
+		"app.config.replacement": "createApp({ defaultProfile, profiles })"
+	});
+}
+function readBotConfig(env, functionMaxDurationSeconds) {
+	warnDeprecatedProfileEnv(env);
+	const maxTurnTimeoutMs = resolveMaxTurnTimeoutMs(functionMaxDurationSeconds);
+	const modelId = validateGatewayModelId(env.AI_MODEL) ?? DEFAULT_MODEL_ID;
+	const reasoningLevel = toOptionalTrimmed(env.AI_REASONING_LEVEL);
+	const fastModelId = validateGatewayModelId(env.AI_FAST_MODEL ?? env.AI_MODEL) ?? DEFAULT_FAST_MODEL_ID;
+	const guardianModelId = validateGatewayModelId(env.AI_GUARDIAN_MODEL) ?? DEFAULT_GUARDIAN_MODEL_ID;
+	const handoffModelId = validateGatewayModelId(env.AI_HANDOFF_MODEL) ?? DEFAULT_HANDOFF_MODEL_ID;
+	return {
+		userName: toOptionalTrimmed(env.JUNIOR_BOT_NAME) ?? "junior",
+		defaultProfile: "standard",
+		crossActorMidRunMode: parseCrossActorMidRunMode(env.JUNIOR_CROSS_ACTOR_MID_RUN_MODE),
+		profiles: parseProfiles(env.AI_MODEL_PROFILES, modelId, handoffModelId),
+		contextWindowTokens: parseOptionalPositiveInteger("AI_MODEL_CONTEXT_WINDOW_TOKENS", env.AI_MODEL_CONTEXT_WINDOW_TOKENS) ?? DEFAULT_MODEL_CONTEXT_WINDOW_TOKENS,
+		reasoningLevel: reasoningLevel === void 0 ? void 0 : parseTurnReasoningLevel(reasoningLevel),
+		fastModelId,
+		guardianModelId,
+		imageGenerationModelId: toOptionalTrimmed(env.AI_IMAGE_MODEL) ?? DEFAULT_IMAGE_GENERATION_MODEL_ID,
+		embeddingModelId: validateEmbeddingModelId(env.AI_EMBEDDING_MODEL) ?? DEFAULT_EMBEDDING_MODEL_ID,
+		loadingMessages: parseLoadingMessages(env.JUNIOR_LOADING_MESSAGES),
+		visionModelId: validateGatewayModelId(env.AI_VISION_MODEL),
+		maxSlicesPerTurn: MAX_SLICES_PER_TURN,
+		maxToolCallsPerTurn: MAX_TOOL_CALLS_PER_TURN,
+		maxConsecutiveAutomatedTurns: MAX_CONSECUTIVE_AUTOMATED_TURNS,
+		turnTimeoutMs: parseAgentTurnTimeoutMs(env.AGENT_TURN_TIMEOUT_MS, maxTurnTimeoutMs),
+		webSearchModelId: validateGatewayModelId(env.AI_WEB_SEARCH_MODEL) ?? DEFAULT_WEB_SEARCH_MODEL_ID
+	};
+}
+function readDatabaseUrl(env) {
+	const databaseUrl = toOptionalTrimmed(env.DATABASE_URL);
+	if (!databaseUrl) throw new Error("DATABASE_URL is required");
+	return databaseUrl;
+}
+function isLocalDatabaseUrl(databaseUrl) {
+	try {
+		const { hostname } = new URL(databaseUrl);
+		return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+	} catch {
+		return false;
+	}
+}
+function readSqlDriver(env, databaseUrl) {
+	const value = toOptionalTrimmed(env.JUNIOR_DATABASE_DRIVER);
+	if (value === void 0) {
+		if (isLocalDatabaseUrl(databaseUrl)) return "postgres";
+		return "neon";
+	}
+	if (value === "neon" || value === "postgres") return value;
+	throw new Error("JUNIOR_DATABASE_DRIVER must be postgres or neon");
+}
+function readSqlStatementTimeoutMs(env) {
+	const rawValue = toOptionalTrimmed(env.JUNIOR_SQL_STATEMENT_TIMEOUT_MS);
+	if (rawValue === void 0) return DEFAULT_SQL_STATEMENT_TIMEOUT_MS;
+	const value = Number.parseInt(rawValue, 10);
+	if (!Number.isSafeInteger(value) || value < 0 || String(value) !== rawValue) throw new Error("JUNIOR_SQL_STATEMENT_TIMEOUT_MS must be a non-negative integer");
+	return value === 0 ? false : value;
+}
+/** Parse all chat configuration from environment variables. */
+function readChatConfig(env = process.env, functionMaxDurationSeconds = DEFAULT_FUNCTION_MAX_DURATION_SECONDS) {
+	const databaseUrl = readDatabaseUrl(env);
+	const resolvedFunctionMaxDurationSeconds = resolveFunctionMaxDurationSeconds(functionMaxDurationSeconds);
+	return {
+		bot: readBotConfig(env, resolvedFunctionMaxDurationSeconds),
+		functionMaxDurationSeconds: resolvedFunctionMaxDurationSeconds,
+		conversationWorkEnabled: parseConversationWorkEnabled(env.JUNIOR_CONVERSATION_WORK_ENABLED),
+		conversationWorkSoftYieldAfterMs: resolveConversationWorkSoftYieldAfterMs(resolvedFunctionMaxDurationSeconds),
+		sql: {
+			databaseUrl,
+			driver: readSqlDriver(env, databaseUrl),
+			statementTimeoutMs: readSqlStatementTimeoutMs(env)
+		},
+		slack: {
+			botToken: toOptionalTrimmed(env.SLACK_BOT_TOKEN) ?? toOptionalTrimmed(env.SLACK_BOT_USER_TOKEN),
+			clientId: toOptionalTrimmed(env.SLACK_CLIENT_ID),
+			clientSecret: toOptionalTrimmed(env.SLACK_CLIENT_SECRET),
+			completedReactionEmoji: DEFAULT_COMPLETED_REACTION_EMOJI,
+			processingReactionEmoji: DEFAULT_PROCESSING_REACTION_EMOJI,
+			signingSecret: toOptionalTrimmed(env.SLACK_SIGNING_SECRET),
+			slashCommand: parseSlashCommand(env.JUNIOR_SLASH_COMMAND)
+		},
+		state: {
+			adapter: env.JUNIOR_STATE_ADAPTER?.trim().toLowerCase() === "memory" ? "memory" : "redis",
+			keyPrefix: toOptionalTrimmed(env.JUNIOR_STATE_KEY_PREFIX),
+			redisUrl: toOptionalTrimmed(env.REDIS_URL)
+		}
+	};
+}
+/** Chat configuration parsed once at module load from the process environment. */
+const chatConfig = readChatConfig(process.env);
+/** Apply the host execution budget injected by juniorNitro(). */
+function configureFunctionMaxDurationSeconds(functionMaxDurationSeconds) {
+	const resolved = resolveFunctionMaxDurationSeconds(functionMaxDurationSeconds);
+	chatConfig.functionMaxDurationSeconds = resolved;
+	chatConfig.conversationWorkSoftYieldAfterMs = resolveConversationWorkSoftYieldAfterMs(resolved);
+	chatConfig.bot.turnTimeoutMs = parseAgentTurnTimeoutMs(process.env.AGENT_TURN_TIMEOUT_MS, resolveMaxTurnTimeoutMs(resolved));
+}
+/** Return the chat configuration (parsed once at startup). */
+function getChatConfig() {
+	return chatConfig;
+}
+/** Bot configuration derived from environment at module load. */
+const botConfig = chatConfig.bot;
+function getSlackBotToken() {
+	return chatConfig.slack.botToken;
+}
+function getSlackSigningSecret() {
+	return chatConfig.slack.signingSecret;
+}
+function getSlackClientId() {
+	return chatConfig.slack.clientId;
+}
+function getSlackClientSecret() {
+	return chatConfig.slack.clientSecret;
+}
+/** Return runtime metadata (version from deploy environment). */
+function getRuntimeMetadata() {
+	return { version: toOptionalTrimmed(process.env.VERCEL_GIT_COMMIT_SHA) };
+}
+/** Apply model overrides from createApp(). */
+function setBotModelConfig(config) {
+	if (config.embeddingModelId !== void 0) botConfig.embeddingModelId = requireModelId("embeddingModelId", config.embeddingModelId, validateEmbeddingModelId);
+	if (config.fastModelId !== void 0) botConfig.fastModelId = requireModelId("fastModelId", config.fastModelId, validateGatewayModelId);
+	if (config.guardianModelId !== void 0) botConfig.guardianModelId = requireModelId("guardianModelId", config.guardianModelId, validateGatewayModelId);
+	if (config.imageGenerationModelId !== void 0) botConfig.imageGenerationModelId = requireModelId("imageGenerationModelId", config.imageGenerationModelId, validateEmbeddingModelId);
+	if (config.visionModelId !== void 0) botConfig.visionModelId = requireModelId("visionModelId", config.visionModelId, validateGatewayModelId);
+	if (config.webSearchModelId !== void 0) botConfig.webSearchModelId = requireModelId("webSearchModelId", config.webSearchModelId, validateGatewayModelId);
+}
+/** Apply profiles from createApp(). */
+function setProfiles(profiles, defaultProfile) {
+	if (!profiles || !defaultProfile) throw new Error("profiles and defaultProfile must be configured together");
+	const configuredProfiles = parseProfileMap(profiles, "profiles");
+	const selectedDefault = defaultProfile;
+	if (!modelProfileSchema.safeParse(selectedDefault).success) throw new Error(`defaultProfile "${selectedDefault}" must match ^[a-z][a-z0-9_-]*$`);
+	if (!Object.hasOwn(configuredProfiles, selectedDefault)) throw new Error(`defaultProfile "${selectedDefault}" is not configured`);
+	botConfig.profiles = configuredProfiles;
+	botConfig.defaultProfile = selectedDefault;
+}
+/** Return the current Slack reaction emoji config. */
+function getSlackReactionConfig() {
+	return {
+		completedReactionEmoji: chatConfig.slack.completedReactionEmoji,
+		processingReactionEmoji: chatConfig.slack.processingReactionEmoji
+	};
+}
+/** Apply Slack reaction emoji overrides from createApp() options, validating names. */
+function setSlackReactionConfig(overrides) {
+	if (overrides.processingReactionEmoji !== void 0) chatConfig.slack.processingReactionEmoji = parseReactionEmoji("processingReactionEmoji", overrides.processingReactionEmoji, chatConfig.slack.processingReactionEmoji);
+	if (overrides.completedReactionEmoji !== void 0) chatConfig.slack.completedReactionEmoji = parseReactionEmoji("completedReactionEmoji", overrides.completedReactionEmoji, chatConfig.slack.completedReactionEmoji);
+}
+//#endregion
+export { getChatConfig as a, getSlackClientId as c, getSlackSigningSecret as d, setBotModelConfig as f, normalizeSlackEmojiName as h, configureFunctionMaxDurationSeconds as i, getSlackClientSecret as l, setSlackReactionConfig as m, botConfig as n, getRuntimeMetadata as o, setProfiles as p, config_exports as r, getSlackBotToken as s, DEFAULT_SQL_STATEMENT_TIMEOUT_MS as t, getSlackReactionConfig as u };