@sentry/junior 0.203.0 → 0.205.0

package/dist/config-BOtJQ7Pc.js

@@ -0,0 +1,941 @@
+import { C as withSpan, f as logWarn, h as serializeGenAiAttribute, i as extractGenAiUsageAttributes, p as normalizeGenAiFinishReason, u as logException } from "./logging-BMJzdDlP.js";
+import { a as toCanonicalInputMessage, n as getCurrentConversationPrivacy, o as toCanonicalOutputMessage, s as toGenAiMessagesTraceAttributes } from "./conversation-privacy-BZRA6Pes.js";
+import { c as TURN_REASONING_LEVELS, l as parseTurnReasoningLevel, o as modelProfileSchema } from "./model-profile-CZmVoGdX.js";
+import { calculateCost, completeSimple, getEnvApiKey, getModel, getModels, registerApiProvider } from "@earendil-works/pi-ai/compat";
+import { stream as streamAnthropic, streamSimple as streamSimpleAnthropic } from "@earendil-works/pi-ai/api/anthropic-messages";
+import { createGatewayProvider } from "@ai-sdk/gateway";
+import { getVercelOidcToken } from "@vercel/oidc";
+import { NoObjectGeneratedError, embedMany, generateObject } from "ai";
+//#region src/chat/optional-string.ts
+/**
+* Normalize optional env-style strings so blank values do not masquerade as
+* configured inputs.
+*/
+function toOptionalTrimmed(value) {
+	if (!value) return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+//#endregion
+//#region src/chat/pi/gateway-auth.ts
+/**
+* AI Gateway credential resolution for every Junior model path.
+*
+* Prefer Vercel project OIDC so gateway usage attributes to the deploying
+* project. Fall back to AI_GATEWAY_API_KEY for local/CI and non-Vercel hosts.
+* Never cache resolved tokens: runtime OIDC rotates on each invocation.
+*/
+const MISSING_GATEWAY_CREDENTIALS_ERROR = "Missing AI gateway credentials (enable Vercel OIDC or set AI_GATEWAY_API_KEY)";
+/**
+* Resolve the preferred AI Gateway bearer credential.
+*
+* Order:
+* 1. Vercel OIDC via `@vercel/oidc` (request header `x-vercel-oidc-token`,
+*    then `VERCEL_OIDC_TOKEN`, with local refresh when needed)
+* 2. Explicit `AI_GATEWAY_API_KEY` / pi-ai env mapping for vercel-ai-gateway
+*/
+async function resolveGatewayCredential() {
+	try {
+		const oidcToken = toOptionalTrimmed(await getVercelOidcToken());
+		if (oidcToken) return {
+			mode: "oidc",
+			token: oidcToken
+		};
+	} catch {}
+	const apiKey = toOptionalTrimmed(getEnvApiKey("vercel-ai-gateway"));
+	if (apiKey) return {
+		mode: "api_key",
+		token: apiKey
+	};
+}
+/** Resolve the bearer token string for Authorization headers and Pi getApiKey. */
+async function getGatewayApiKey() {
+	return (await resolveGatewayCredential())?.token;
+}
+//#endregion
+//#region src/chat/services/provider-error.ts
+/** Structured failure produced at an AI provider boundary. */
+var ProviderError = class extends Error {
+	code = "provider_error";
+	kind;
+	modelId;
+	retryable;
+	retryAfterMs;
+	status;
+	constructor(details) {
+		super(`AI provider error: ${details.kind}`, details.cause !== void 0 ? { cause: details.cause } : {});
+		this.name = "ProviderError";
+		this.kind = details.kind;
+		this.modelId = details.modelId;
+		this.retryable = details.retryable;
+		this.retryAfterMs = details.retryAfterMs;
+		this.status = details.status;
+	}
+};
+const NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+	"ECONNREFUSED",
+	"ECONNRESET",
+	"ENOTFOUND",
+	"EAI_AGAIN"
+]);
+const TIMEOUT_ERROR_CODES = /* @__PURE__ */ new Set([
+	"ETIMEDOUT",
+	"ECONNABORTED",
+	"ESOCKETTIMEDOUT"
+]);
+const CONTENT_POLICY_PATTERN = /\b(?:content|safety)[ _-]?policy\b|\b(?:content|safety) (?:filter|violation)\b|\bmoderation (?:blocked|rejected|refused)\b/i;
+const QUOTA_PATTERN = /insufficient.?quota|quota exceeded|usage limit|available balance|out of budget|billing (?:limit|quota|error)|payment required/i;
+const AUTH_PATTERN = /unauthenticated|invalid.?api.?key|no api key|authentication (?:failed|error|required)|(?:invalid|missing|expired|revoked).{0,24}\bcredentials?\b|\bcredentials?\b.{0,24}(?:invalid|missing|expired|revoked)|\bno\b.{0,16}\bcredentials?\b/i;
+const PERMISSION_PATTERN = /permission denied|forbidden|not authorized|authorization (?:failed|required|denied)/i;
+const INVALID_REQUEST_PATTERN = /context.?length|context.?window|validation (?:error|failed)|bad request|unsupported model|invalid model|unknown (?:ai gateway )?model|mismatched api/i;
+const CAPACITY_PATTERN = /overloaded|at capacity|capacity exceeded/i;
+const TIMEOUT_PATTERN = /timed? out|timeout|gateway timeout/i;
+const NETWORK_PATTERN = /network.?error|connection (?:error|refused|lost|closed)|fetch failed|socket (?:hang up|closed)|stream ended before/i;
+const SERVER_PATTERN = /service(?: temporarily)?[ _-]?unavailable|server.?error|internal.?error|bad gateway|upstream (?:request )?failed/i;
+const TERMINAL_KINDS = /* @__PURE__ */ new Set([
+	"auth",
+	"permission",
+	"invalid_request",
+	"invalid_response",
+	"quota",
+	"content_policy"
+]);
+const RETRYABLE_KINDS = /* @__PURE__ */ new Set([
+	"rate_limit",
+	"capacity",
+	"timeout",
+	"network",
+	"server"
+]);
+function providerMessage(error) {
+	return (error instanceof Error ? error.message : String(error)).trim();
+}
+const PROVIDER_ERROR_SUMMARY_MAX_CHARS = 240;
+/** Short provider-boundary text for telemetry. Drop trailing JSON bodies. */
+function summarizeProviderErrorMessage(message) {
+	const normalized = message.trim().replace(/\s+/g, " ");
+	if (!normalized) return void 0;
+	const jsonStart = normalized.indexOf("{");
+	const summary = (jsonStart >= 0 ? normalized.slice(0, jsonStart) : normalized).trim();
+	if (!summary) return void 0;
+	return summary.length > PROVIDER_ERROR_SUMMARY_MAX_CHARS ? `${summary.slice(0, PROVIDER_ERROR_SUMMARY_MAX_CHARS)}...` : summary;
+}
+function extractTransportKind(error, depth = 0) {
+	if (!(error instanceof Error) || depth > 4) return void 0;
+	const providerError = error;
+	const code = typeof providerError.code === "string" ? providerError.code.toUpperCase() : void 0;
+	if (code && TIMEOUT_ERROR_CODES.has(code)) return "timeout";
+	if (code && NETWORK_ERROR_CODES.has(code)) return "network";
+	return extractTransportKind(providerError.cause, depth + 1);
+}
+function extractStatus(error, message) {
+	if (error instanceof Error) {
+		const providerError = error;
+		if (typeof providerError.status === "number") return providerError.status;
+		if (typeof providerError.statusCode === "number") return providerError.statusCode;
+	}
+	const match = message.match(/^(?:Error:\s*)?([45]\d\d)\b|\bstatus(?:Code)?["'=:\s]+([45]\d\d)\b/i);
+	const status = match?.[1] ?? match?.[2];
+	return status ? Number(status) : void 0;
+}
+function extractRetryAfterMs(error, message) {
+	const headers = error instanceof Error ? error.responseHeaders ?? error.response?.headers : void 0;
+	const retryAfter = headers instanceof Headers ? headers.get("retry-after") : headers && typeof headers === "object" ? Object.entries(headers).find(([name]) => name.toLowerCase() === "retry-after")?.[1] : void 0;
+	const raw = typeof retryAfter === "string" || typeof retryAfter === "number" ? String(retryAfter) : message.match(/"retry-after"\s*:\s*"?([^",}]+)"?/i)?.[1];
+	if (!raw) return void 0;
+	const seconds = Number(raw);
+	if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+	const date = Date.parse(raw);
+	return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+}
+/** Classify stable provider signals without copying Pi's retry vocabulary. */
+function classifyProviderError(status, message, transportKind) {
+	if (CONTENT_POLICY_PATTERN.test(message)) return "content_policy";
+	if (QUOTA_PATTERN.test(message)) return "quota";
+	if (status === 401 || AUTH_PATTERN.test(message)) return "auth";
+	if (status === 403 || PERMISSION_PATTERN.test(message)) return "permission";
+	if (INVALID_REQUEST_PATTERN.test(message)) return "invalid_request";
+	if (status === 429 || /rate.?limit|too many requests/i.test(message)) return "rate_limit";
+	if (status === 408) return "timeout";
+	if (CAPACITY_PATTERN.test(message)) return "capacity";
+	if (transportKind === "timeout" || TIMEOUT_PATTERN.test(message)) return "timeout";
+	if (transportKind === "network" || NETWORK_PATTERN.test(message)) return "network";
+	if (status !== void 0 && status >= 500 || SERVER_PATTERN.test(message)) return "server";
+	if (status !== void 0 && status >= 400) return "invalid_request";
+	return "unknown";
+}
+/** Normalize SDK, Gateway, and Pi failures into one provider error contract. */
+function createProviderError(error, options = {}) {
+	if (error instanceof ProviderError) return error;
+	const message = providerMessage(error);
+	const status = extractStatus(error, message);
+	const kind = options.kind ?? classifyProviderError(status, message, extractTransportKind(error));
+	const retryable = !TERMINAL_KINDS.has(kind) && (options.retryable ?? RETRYABLE_KINDS.has(kind));
+	return new ProviderError({
+		cause: error,
+		kind,
+		modelId: options.modelId,
+		retryable,
+		retryAfterMs: extractRetryAfterMs(error, message),
+		status
+	});
+}
+/** Return whether a provider-boundary error should be retried. */
+function isProviderRetryError(error) {
+	return error instanceof ProviderError && error.retryable;
+}
+/** Find the provider failure preserved inside a domain error cause chain. */
+function findProviderError(error) {
+	const visited = /* @__PURE__ */ new Set();
+	let current = error;
+	while (current instanceof Error && !visited.has(current)) {
+		if (current instanceof ProviderError) return current;
+		visited.add(current);
+		current = current.cause;
+	}
+}
+/** Return stable, sanitized copy suitable for a terminal user response. */
+function getProviderErrorUserMessage(error) {
+	switch (error.kind) {
+		case "capacity": return "The selected model is temporarily unavailable because it is at capacity. Please try again shortly.";
+		case "rate_limit": {
+			const seconds = error.retryAfterMs ? Math.max(1, Math.ceil(error.retryAfterMs / 1e3)) : void 0;
+			return seconds ? `The model is rate-limited. Please try again in about ${seconds} seconds.` : "The model is rate-limited. Please try again shortly.";
+		}
+		case "timeout":
+		case "network":
+		case "server": return "The model provider had a temporary connection problem. Please try again.";
+		case "auth": return "The model provider rejected Junior's credentials. This needs an administrator or configuration fix.";
+		case "permission": return "The model provider denied access to this model or request. Ask an administrator to check model access, organization policy, and region availability.";
+		case "quota": return "The model provider's usage quota has been exhausted. This needs an administrator or billing configuration fix.";
+		case "content_policy": return "The model provider blocked this request under its content policy. Please revise the request and try again.";
+		case "invalid_request": return "The model provider rejected this request as invalid. Please revise the request or ask an administrator to check the model configuration.";
+		case "invalid_response": return "The model provider returned an invalid response. Please try again.";
+		default: return "";
+	}
+}
+/** Return safe structured fields for terminal failure telemetry. */
+function getProviderErrorAttributes(error) {
+	const cause = error.cause;
+	const causeMessage = cause instanceof Error ? cause.message : typeof cause === "string" ? cause : void 0;
+	const summary = causeMessage ? summarizeProviderErrorMessage(causeMessage) : void 0;
+	return {
+		"app.ai.provider_error.kind": error.kind,
+		"app.ai.provider_error.retryable": error.retryable,
+		...error.status !== void 0 ? { "app.ai.provider_error.status": error.status } : void 0,
+		...error.retryAfterMs !== void 0 ? { "app.ai.provider_error.retry_after_ms": error.retryAfterMs } : void 0,
+		...summary ? { "app.ai.provider_error.summary": summary } : void 0,
+		...error.modelId ? { "gen_ai.request.model": error.modelId } : void 0
+	};
+}
+//#endregion
+//#region src/chat/xml.ts
+function escapeXml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+}
+/** Recover text escaped for an internal XML prompt boundary. */
+function unescapeXml(value) {
+	return value.replaceAll("&quot;", "\"").replaceAll("&apos;", "'").replaceAll("&gt;", ">").replaceAll("&lt;", "<").replaceAll("&amp;", "&");
+}
+//#endregion
+//#region src/chat/current-instruction.ts
+const CURRENT_INSTRUCTION_TAG = "current-instruction";
+const CURRENT_INSTRUCTION_OPEN_PREFIX = `<${CURRENT_INSTRUCTION_TAG}`;
+const CURRENT_INSTRUCTION_OPEN_BARE = `<${CURRENT_INSTRUCTION_TAG}>`;
+const CURRENT_INSTRUCTION_OPEN_ATTR_PREFIX = `<${CURRENT_INSTRUCTION_TAG} `;
+const CURRENT_INSTRUCTION_CLOSE = `\n</${CURRENT_INSTRUCTION_TAG}>`;
+function isCurrentInstructionOpeningTag(value) {
+	return value === CURRENT_INSTRUCTION_OPEN_BARE || value.startsWith(CURRENT_INSTRUCTION_OPEN_ATTR_PREFIX) && value.endsWith(">");
+}
+function readCurrentInstructionBody(text) {
+	const start = text.indexOf(CURRENT_INSTRUCTION_OPEN_PREFIX);
+	if (start < 0) return;
+	const openingEnd = text.indexOf(">\n", start);
+	if (openingEnd < 0) return;
+	if (!isCurrentInstructionOpeningTag(text.slice(start, openingEnd + 1))) return;
+	const bodyStart = openingEnd + 2;
+	const bodyEnd = text.indexOf(CURRENT_INSTRUCTION_CLOSE, bodyStart);
+	if (bodyEnd < bodyStart) return;
+	return text.slice(bodyStart, bodyEnd);
+}
+/** Render the active user task in a stable prompt boundary. */
+function renderCurrentInstruction(instruction, attrs) {
+	const renderedAttrs = [
+		attrs?.authorId ? `author_id="${escapeXml(attrs.authorId)}"` : void 0,
+		attrs?.authorName ? `author_name="${escapeXml(attrs.authorName)}"` : void 0,
+		attrs?.slackTs ? `slack_ts="${escapeXml(attrs.slackTs)}"` : void 0
+	].filter((attr) => Boolean(attr)).join(" ");
+	return [
+		renderedAttrs ? `<${CURRENT_INSTRUCTION_TAG} ${renderedAttrs}>` : `<${CURRENT_INSTRUCTION_TAG}>`,
+		escapeXml(instruction),
+		`</${CURRENT_INSTRUCTION_TAG}>`
+	].join("\n");
+}
+/** Recover display text from the internal current-task prompt boundary. */
+function unwrapCurrentInstruction(text) {
+	const body = readCurrentInstructionBody(text);
+	return body === void 0 ? void 0 : unescapeXml(body);
+}
+//#endregion
+//#region src/chat/services/context-compaction-marker.ts
+const COMPACTION_SUMMARY_PREFIX = "Context compaction summary for future Junior turns:";
+const ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX = "Active-turn context checkpoint. If no newer user instruction follows this checkpoint, continue the same unfinished task now using the authoritative instructions above and this summary as internal continuation state. If a newer user instruction follows, treat this checkpoint as prior context and follow that newer instruction. Do not reply with a plan or summary solely because this checkpoint appeared:";
+const MODEL_HANDOFF_SUMMARY_PREFIX = "Model handoff checkpoint. Continue the outstanding request now using this summary as the complete prior context:";
+/** Return whether text is one of Junior's durable compacted-context markers. */
+function isCompactionSummaryText(text) {
+	const normalized = (unwrapCurrentInstruction(text) ?? text).trimStart();
+	return normalized.startsWith("Context compaction summary for future Junior turns:") || normalized.startsWith("Active-turn context checkpoint. If no newer user instruction follows this checkpoint, continue the same unfinished task now using the authoritative instructions above and this summary as internal continuation state. If a newer user instruction follows, treat this checkpoint as prior context and follow that newer instruction. Do not reply with a plan or summary solely because this checkpoint appeared:") || normalized.startsWith("Model handoff checkpoint. Continue the outstanding request now using this summary as the complete prior context:");
+}
+/** Return whether model-visible history contains a durable compacted context marker. */
+function hasCompactedConversationContext(messages) {
+	return messages.some((message) => {
+		const content = message.content;
+		if (typeof content === "string") return isCompactionSummaryText(content);
+		if (!Array.isArray(content)) return false;
+		return content.some((part) => part && typeof part === "object" && part.type === "text" && typeof part.text === "string" && isCompactionSummaryText(part.text));
+	});
+}
+//#endregion
+//#region src/chat/pi/client.ts
+registerApiProvider({
+	api: "anthropic-messages",
+	stream: streamAnthropic,
+	streamSimple: streamSimpleAnthropic
+});
+const GATEWAY_PROVIDER = "vercel-ai-gateway";
+const GEN_AI_PROVIDER_NAME = GATEWAY_PROVIDER;
+const GEN_AI_SERVER_ADDRESS = "ai-gateway.vercel.sh";
+const GEN_AI_OPERATION_CHAT = "chat";
+const GEN_AI_OPERATION_EMBEDDINGS = "embeddings";
+const EMBEDDING_INPUT_COST_USD_PER_MILLION_TOKENS = {
+	"cohere/embed-v4.0": .12,
+	"google/gemini-embedding-001": .15,
+	"google/text-embedding-005": .025,
+	"mistral/mistral-embed": .1,
+	"openai/text-embedding-3-large": .13,
+	"openai/text-embedding-3-small": .02,
+	"openai/text-embedding-ada-002": .1,
+	"voyage/voyage-3.5": .06,
+	"voyage/voyage-3.5-lite": .02
+};
+function embeddingCostUsd(modelId, inputTokens) {
+	const costPerMillionTokens = EMBEDDING_INPUT_COST_USD_PER_MILLION_TOKENS[modelId];
+	return costPerMillionTokens === void 0 ? void 0 : inputTokens * costPerMillionTokens / 1e6;
+}
+function extractText(message) {
+	return (message.content ?? []).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text ?? "").join("").trim();
+}
+/**
+* Look up a gateway model by id. Throws `Unknown AI Gateway model id: …` if
+* the id is not in pi-ai's registry — callers at the config boundary can use
+* this to fail fast at startup instead of mid-turn.
+*/
+function resolveGatewayModel(modelId) {
+	const matched = getModels(GATEWAY_PROVIDER).find((model) => model.id === modelId);
+	if (!matched) throw new Error(`Unknown AI Gateway model id: ${modelId}`);
+	return matched;
+}
+/** Execute a direct chat completion inside a dedicated `gen_ai.chat` span. */
+async function completeText(params) {
+	const model = resolveGatewayModel(params.modelId);
+	const credential = await resolveGatewayCredential();
+	const apiKey = credential?.token;
+	const authMode = credential?.mode ?? "api_key";
+	const effectivePrivacy = getCurrentConversationPrivacy() ?? "private";
+	const messageAttributeMode = params.messageAttributeMode ?? (effectivePrivacy === "public" ? "content" : "metadata");
+	const requestMessagesAttribute = messageAttributeMode === "content" ? serializeGenAiAttribute(params.messages.map(toCanonicalInputMessage)) : void 0;
+	const systemInstructionsAttribute = params.system && messageAttributeMode === "content" ? serializeGenAiAttribute([{
+		type: "text",
+		content: params.system
+	}]) : void 0;
+	const baseAttributes = {
+		"gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+		"gen_ai.operation.name": GEN_AI_OPERATION_CHAT,
+		"gen_ai.request.model": params.modelId,
+		"gen_ai.output.type": "text",
+		...params.promptName ? { "gen_ai.prompt.name": params.promptName } : void 0,
+		"server.address": GEN_AI_SERVER_ADDRESS,
+		"server.port": 443,
+		...hasCompactedConversationContext(params.messages) ? { "gen_ai.conversation.compacted": true } : void 0,
+		"app.conversation.privacy": effectivePrivacy,
+		...params.thinkingLevel ? { "gen_ai.request.reasoning.level": params.thinkingLevel } : void 0,
+		...params.temperature !== void 0 ? { "gen_ai.request.temperature": params.temperature } : void 0,
+		...params.maxTokens !== void 0 ? { "gen_ai.request.max_tokens": params.maxTokens } : void 0
+	};
+	const startAttributes = {
+		...baseAttributes,
+		...toGenAiMessagesTraceAttributes("gen_ai.input", params.messages),
+		...params.system ? { "gen_ai.system_instructions.content_chars": params.system.length } : void 0,
+		...systemInstructionsAttribute ? { "gen_ai.system_instructions": systemInstructionsAttribute } : void 0,
+		...requestMessagesAttribute ? { "gen_ai.input.messages": requestMessagesAttribute } : void 0,
+		"gen_ai.provider.auth_mode": authMode
+	};
+	return withSpan(`${GEN_AI_OPERATION_CHAT} ${params.modelId}`, "gen_ai.chat", logContextFromMetadata(params.modelId, params.metadata), async (setSpanAttributes) => {
+		let message;
+		try {
+			message = await completeSimple(model, {
+				systemPrompt: params.system,
+				messages: params.messages
+			}, {
+				...apiKey ? { apiKey } : void 0,
+				temperature: params.temperature,
+				maxTokens: params.maxTokens,
+				reasoning: params.thinkingLevel,
+				signal: params.signal,
+				metadata: params.metadata
+			});
+		} catch (error) {
+			throw createProviderError(error, { modelId: params.modelId });
+		}
+		const outputText = extractText(message);
+		const outputMessagesAttribute = serializeGenAiAttribute(messageAttributeMode === "content" ? [toCanonicalOutputMessage(message)] : void 0);
+		const usageAttributes = extractGenAiUsageAttributes(message);
+		setSpanAttributes({
+			...baseAttributes,
+			...toGenAiMessagesTraceAttributes("gen_ai.output", [{
+				role: "assistant",
+				content: outputText ? [{
+					type: "text",
+					text: outputText
+				}] : []
+			}]),
+			...outputMessagesAttribute ? { "gen_ai.output.messages": outputMessagesAttribute } : void 0,
+			...usageAttributes,
+			...message.stopReason ? { "gen_ai.response.finish_reasons": [normalizeGenAiFinishReason(message.stopReason)] } : void 0,
+			...message.model ? { "gen_ai.response.model": message.model } : void 0
+		});
+		if (message.stopReason === "error") {
+			const providerMessage = message.errorMessage?.trim() || "Unknown provider error";
+			logWarn("ai.completion.provider_error", {
+				...baseAttributes,
+				"exception.message": providerMessage
+			});
+			throw createProviderError(providerMessage, { modelId: params.modelId });
+		}
+		return {
+			message,
+			text: outputText
+		};
+	}, startAttributes);
+}
+function logContextFromMetadata(modelId, metadata) {
+	const conversationId = typeof metadata?.conversationId === "string" ? metadata.conversationId : typeof metadata?.threadId === "string" ? metadata.threadId : void 0;
+	const messageConversationId = typeof metadata?.threadId === "string" ? metadata.threadId : void 0;
+	const destinationName = typeof metadata?.channelId === "string" ? metadata.channelId : void 0;
+	const runId = typeof metadata?.runId === "string" ? metadata.runId : void 0;
+	return {
+		modelId,
+		...conversationId ? { conversationId } : void 0,
+		...messageConversationId ? { messageConversationId } : void 0,
+		...destinationName ? { destinationName } : void 0,
+		...runId ? { runId } : void 0
+	};
+}
+function objectCompletionCost(modelId, usage) {
+	const cacheRead = usage.inputTokenDetails.cacheReadTokens;
+	const cacheWrite = usage.inputTokenDetails.cacheWriteTokens;
+	const input = usage.inputTokenDetails.noCacheTokens ?? (usage.inputTokens === void 0 ? void 0 : Math.max(0, usage.inputTokens - (cacheRead ?? 0) - (cacheWrite ?? 0)));
+	if (input === void 0 && usage.outputTokens === void 0 && cacheRead === void 0 && cacheWrite === void 0) return;
+	return calculateCost(resolveGatewayModel(modelId), {
+		input: input ?? 0,
+		output: usage.outputTokens ?? 0,
+		cacheRead: cacheRead ?? 0,
+		cacheWrite: cacheWrite ?? 0,
+		...usage.outputTokenDetails.reasoningTokens !== void 0 ? { reasoning: usage.outputTokenDetails.reasoningTokens } : void 0,
+		totalTokens: usage.totalTokens ?? (input ?? 0) + (usage.outputTokens ?? 0) + (cacheRead ?? 0) + (cacheWrite ?? 0),
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	}).total;
+}
+/** Estimate cost without changing the outcome of a successful completion. */
+function bestEffortObjectCompletionCost(modelId, usage) {
+	try {
+		return objectCompletionCost(modelId, usage);
+	} catch (error) {
+		logWarn("ai.completion.cost_estimate.failed", {
+			"exception.message": error instanceof Error ? error.message : String(error),
+			"gen_ai.request.model": modelId
+		});
+		return;
+	}
+}
+/** Execute a schema-constrained completion using the AI SDK structured output path. */
+async function completeObject(params) {
+	const credential = await resolveGatewayCredential();
+	const provider = createGatewayProvider(credential ? { apiKey: credential.token } : {});
+	let result;
+	try {
+		result = await withSpan(`${GEN_AI_OPERATION_CHAT} ${params.modelId}`, "gen_ai.chat", logContextFromMetadata(params.modelId, params.metadata), async (setSpanAttributes) => {
+			const result = await generateObject({
+				model: provider.chat(params.modelId),
+				schema: params.schema,
+				prompt: params.prompt,
+				...params.system !== void 0 ? { system: params.system } : void 0,
+				...params.temperature !== void 0 ? { temperature: params.temperature } : void 0,
+				...params.maxTokens !== void 0 ? { maxOutputTokens: params.maxTokens } : void 0,
+				...params.recordTelemetryPayloads === false ? { experimental_telemetry: {
+					isEnabled: true,
+					recordInputs: false,
+					recordOutputs: false
+				} } : void 0,
+				...params.signal !== void 0 ? { abortSignal: params.signal } : void 0
+			});
+			setSpanAttributes({
+				"gen_ai.response.finish_reasons": [result.finishReason],
+				...extractGenAiUsageAttributes(result.usage)
+			});
+			return result;
+		}, {
+			"gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+			"gen_ai.operation.name": GEN_AI_OPERATION_CHAT,
+			"gen_ai.request.model": params.modelId,
+			"gen_ai.output.type": "json",
+			...params.promptName ? { "gen_ai.prompt.name": params.promptName } : void 0,
+			"server.address": GEN_AI_SERVER_ADDRESS,
+			"server.port": 443,
+			"gen_ai.provider.auth_mode": credential?.mode ?? "api_key",
+			...params.thinkingLevel ? { "gen_ai.request.reasoning.level": params.thinkingLevel } : void 0,
+			...params.temperature !== void 0 ? { "gen_ai.request.temperature": params.temperature } : void 0,
+			...params.maxTokens !== void 0 ? { "gen_ai.request.max_tokens": params.maxTokens } : void 0
+		});
+	} catch (error) {
+		throw createProviderError(error, {
+			...NoObjectGeneratedError.isInstance(error) ? { kind: "invalid_response" } : void 0,
+			modelId: params.modelId
+		});
+	}
+	const costUsd = bestEffortObjectCompletionCost(params.modelId, result.usage);
+	return {
+		object: result.object,
+		...costUsd !== void 0 ? { costUsd } : void 0
+	};
+}
+/** Generate text embeddings through the host-owned AI Gateway provider. */
+async function embedTexts(params) {
+	const texts = params.texts.map((text) => text.trim());
+	if (texts.length === 0 || texts.some((text) => text.length === 0)) throw new Error("Embedding text is required.");
+	const credential = await resolveGatewayCredential();
+	const provider = createGatewayProvider(credential ? { apiKey: credential.token } : {});
+	try {
+		const result = await withSpan(`${GEN_AI_OPERATION_EMBEDDINGS} ${params.modelId}`, "gen_ai.embeddings", logContextFromMetadata(params.modelId, params.metadata), async (setSpanAttributes) => {
+			const result = await embedMany({
+				model: provider.embeddingModel(params.modelId),
+				values: texts,
+				...params.signal !== void 0 ? { abortSignal: params.signal } : void 0
+			});
+			const dimensions = result.embeddings[0]?.length;
+			if (result.embeddings.length !== texts.length || !dimensions || !result.embeddings.every((embedding) => embedding.length === dimensions)) throw createProviderError("Embedding provider returned invalid vectors.", {
+				kind: "invalid_response",
+				modelId: params.modelId
+			});
+			const costUsd = embeddingCostUsd(params.modelId, result.usage.tokens);
+			setSpanAttributes({
+				"gen_ai.embeddings.dimension.count": dimensions,
+				...extractGenAiUsageAttributes({
+					inputTokens: result.usage.tokens,
+					...costUsd !== void 0 ? { cost: {
+						input: costUsd,
+						total: costUsd
+					} } : void 0
+				})
+			});
+			return {
+				costUsd,
+				dimensions,
+				result
+			};
+		}, {
+			"gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+			"gen_ai.operation.name": GEN_AI_OPERATION_EMBEDDINGS,
+			"gen_ai.request.model": params.modelId,
+			"server.address": GEN_AI_SERVER_ADDRESS,
+			"server.port": 443,
+			"gen_ai.provider.auth_mode": credential?.mode ?? "api_key"
+		});
+		return {
+			...result.costUsd !== void 0 ? { costUsd: result.costUsd } : void 0,
+			dimensions: result.dimensions,
+			model: params.modelId,
+			provider: GEN_AI_PROVIDER_NAME,
+			vectors: result.result.embeddings
+		};
+	} catch (error) {
+		const providerError = createProviderError(error, { modelId: params.modelId });
+		if (isProviderRetryError(providerError)) throw providerError;
+		logException(providerError, "ai.embeddings.failed", {
+			"gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+			"gen_ai.operation.name": GEN_AI_OPERATION_EMBEDDINGS,
+			"gen_ai.request.model": params.modelId
+		});
+		throw providerError;
+	}
+}
+//#endregion
+//#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
+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 { createProviderError as A, MODEL_HANDOFF_SUMMARY_PREFIX as C, unwrapCurrentInstruction as D, renderCurrentInstruction as E, MISSING_GATEWAY_CREDENTIALS_ERROR as F, getGatewayApiKey as I, resolveGatewayCredential as L, getProviderErrorAttributes as M, getProviderErrorUserMessage as N, escapeXml as O, isProviderRetryError as P, toOptionalTrimmed as R, COMPACTION_SUMMARY_PREFIX as S, isCompactionSummaryText as T, completeObject as _, getRuntimeMetadata as a, resolveGatewayModel as b, getSlackClientSecret as c, setBotModelConfig as d, setProfiles as f, GEN_AI_SERVER_ADDRESS as g, GEN_AI_PROVIDER_NAME as h, getChatConfig as i, findProviderError as j, ProviderError as k, getSlackReactionConfig as l, normalizeSlackEmojiName as m, botConfig as n, getSlackBotToken as o, setSlackReactionConfig as p, configureFunctionMaxDurationSeconds as r, getSlackClientId as s, DEFAULT_SQL_STATEMENT_TIMEOUT_MS as t, getSlackSigningSecret as u, completeText as v, hasCompactedConversationContext as w, ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX as x, embedTexts as y };