@sentry/junior 0.203.0 → 0.204.0

package/dist/usage-D3EbSO7w.js

@@ -0,0 +1,296 @@
+import { n as botConfig } from "./config-nGCW1OTG.js";
+import { f as logWarn } from "./logging-BzAk1S_s.js";
+import { t as usageSchema } from "./usage-schema-CKaDkH_j.js";
+import { z } from "zod";
+import { conversationEventPresentationSchema, defineConversationEvent } from "@sentry/junior-plugin-api";
+//#region src/chat/conversations/structured-events.ts
+/** Reserved namespace for Junior-owned conversation metadata events. */
+const JUNIOR_NATIVE_EVENT_NAMESPACE = "junior";
+const authenticationEventContentSchema = z.object({
+	accountLabel: z.string().trim().min(1).max(120).optional(),
+	actorId: z.string().min(1),
+	authorizationId: z.string().min(1).optional(),
+	provider: z.string().regex(/^[a-z][a-z0-9-]*$/),
+	providerLabel: z.string().trim().min(1).max(80).optional()
+}).strict();
+const agentsInstructionsUpdatedContentSchema = z.object({
+	action: z.enum([
+		"loaded",
+		"replaced",
+		"cleared"
+	]),
+	directory: z.string().trim().min(1).max(500).optional(),
+	fingerprint: z.string().trim().min(1).max(128),
+	sources: z.array(z.object({
+		content: z.string().min(1).max(32768),
+		path: z.string().trim().min(1).max(500)
+	}).strict()).max(32),
+	textBytes: z.number().int().nonnegative().optional()
+}).strict();
+function providerTitle(content) {
+	return content.providerLabel?.trim() || content.provider;
+}
+function agentsInstructionsTitle(action) {
+	if (action === "loaded") return "Loaded AGENTS.md";
+	if (action === "replaced") return "Updated AGENTS.md";
+	return "Cleared AGENTS.md";
+}
+function sourceFilename(sourcePath) {
+	return sourcePath.split("/").at(-1) || sourcePath;
+}
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes} bytes`;
+	const kilobytes = bytes / 1024;
+	return `${Number.isInteger(kilobytes) ? kilobytes : kilobytes.toFixed(1)} KB`;
+}
+function agentsInstructionsPreview(content) {
+	const source = content.sources[0];
+	if (!source) return void 0;
+	const filename = sourceFilename(source.path);
+	const label = content.sources.length === 1 ? filename : `${content.sources.length} AGENTS.md files`;
+	return typeof content.textBytes === "number" ? `${label} · ${formatBytes(content.textBytes)}` : label;
+}
+/** Junior-owned account-link transcript event. */
+const authenticationLinkedEvent = defineConversationEvent({
+	name: "authentication_linked",
+	version: 1,
+	schema: authenticationEventContentSchema,
+	renderEvent(event) {
+		const provider = providerTitle(event);
+		return {
+			icon: "link",
+			title: `${provider} connected`,
+			...event.accountLabel ? { preview: `Connected as \`${event.accountLabel}\`` } : void 0,
+			details: [{
+				title: `${provider} connected`,
+				...event.accountLabel ? { description: `Connected as \`${event.accountLabel}\`` } : void 0,
+				metadata: [event.provider]
+			}]
+		};
+	}
+});
+/** Junior-owned account-unlink transcript event. */
+const authenticationUnlinkedEvent = defineConversationEvent({
+	name: "authentication_unlinked",
+	version: 1,
+	schema: authenticationEventContentSchema,
+	renderEvent(event) {
+		const provider = providerTitle(event);
+		return {
+			icon: "key",
+			title: `${provider} disconnected`,
+			details: [{
+				title: `${provider} disconnected`,
+				metadata: [event.provider]
+			}]
+		};
+	}
+});
+/** Junior-owned AGENTS.md bootstrap transition for the dashboard timeline. */
+const agentsInstructionsUpdatedEvent = defineConversationEvent({
+	name: "agents_instructions_updated",
+	version: 1,
+	schema: agentsInstructionsUpdatedContentSchema,
+	renderEvent(event) {
+		const title = agentsInstructionsTitle(event.action);
+		const preview = agentsInstructionsPreview(event);
+		return {
+			icon: "brain",
+			title,
+			...preview ? { preview } : void 0,
+			...event.sources.length > 0 ? { details: event.sources.map((source) => ({
+				title: sourceFilename(source.path),
+				content: source.content
+			})) } : void 0
+		};
+	}
+});
+const NATIVE_EVENT_DEFINITIONS = [
+	authenticationLinkedEvent,
+	authenticationUnlinkedEvent,
+	agentsInstructionsUpdatedEvent
+];
+/** Resolve a registered Junior-native conversation event definition. */
+function getJuniorNativeEventDefinition(args) {
+	return NATIVE_EVENT_DEFINITIONS.find((definition) => definition.eventName === args.name && definition.version === args.version);
+}
+/** Render one Junior-native event through its active definition. */
+function renderJuniorNativeConversationEvent(args) {
+	if (args.namespace !== "junior") return void 0;
+	const definition = getJuniorNativeEventDefinition(args);
+	if (!definition) return void 0;
+	const presentation = definition.renderEvent(definition.parse(args.content));
+	return presentation === void 0 ? void 0 : conversationEventPresentationSchema.parse(presentation);
+}
+const TITLE_PROMPTS = {
+	conversation: [
+		"Generate a concise 5-8 word conversation title from the first user message below.",
+		"Capture the user's main request.",
+		"Reply with ONLY the title, with no quotes or trailing punctuation."
+	],
+	task: [
+		"Generate a concise 5-8 word task title from the task instruction below.",
+		"Capture the task's main purpose.",
+		"Reply with ONLY the title, with no quotes or trailing punctuation."
+	]
+};
+/** Collapse whitespace and cap a candidate short title. */
+function normalizeShortTitle(value) {
+	return value.replace(/\s+/g, " ").trim().slice(0, 60);
+}
+/**
+* Deterministic display title when no generated title is stored.
+* Uses the first non-empty line of the source text, capped like generated titles.
+*/
+function fallbackShortTitle(sourceText, fallback = "Untitled") {
+	return normalizeShortTitle(sourceText.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0) ?? "") || fallback;
+}
+/** Generate a short title with the fast model, or return undefined on failure. */
+async function generateShortTitle(args) {
+	const sourceText = args.sourceText.trim();
+	if (!sourceText) return void 0;
+	try {
+		return normalizeShortTitle((await args.completeText({
+			modelId: botConfig.fastModelId,
+			temperature: 0,
+			promptName: `junior.${args.kind}_title`,
+			messages: [{
+				role: "user",
+				content: [
+					...TITLE_PROMPTS[args.kind],
+					"",
+					args.kind === "conversation" ? `First user message: ${sourceText.slice(0, 500)}` : `Task instruction: ${sourceText.slice(0, 500)}`
+				].join("\n"),
+				timestamp: Date.now()
+			}],
+			metadata: { modelId: botConfig.fastModelId }
+		})).text) || void 0;
+	} catch (error) {
+		logWarn(`${args.kind}.title.generation.failed`, { "exception.message": error instanceof Error ? error.message : String(error) });
+		return;
+	}
+}
+/**
+* Prefer an explicit task title when provided; otherwise generate one from the
+* instruction with the fast model.
+*/
+async function resolveTaskTitle(args) {
+	const explicit = normalizeShortTitle(args.title ?? "");
+	if (explicit) return explicit;
+	return generateShortTitle({
+		completeText: args.completeText,
+		kind: "task",
+		sourceText: args.instruction
+	});
+}
+//#endregion
+//#region src/chat/tools/execution/tool-input-error.ts
+/** Thrown when a tool fails due to invalid model/user input, not a system error. */
+var ToolInputError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "ToolInputError";
+	}
+};
+//#endregion
+//#region src/chat/usage.ts
+const agentTurnUsageSchema = usageSchema;
+const COMPONENT_USAGE_FIELDS = [
+	"inputTokens",
+	"outputTokens",
+	"cachedInputTokens",
+	"cacheCreationTokens"
+];
+const COST_COMPONENT_FIELDS = [
+	"input",
+	"output",
+	"cacheRead",
+	"cacheWrite"
+];
+/** Return whether any token counter is present on a usage record. */
+function hasAgentTurnUsage(usage) {
+	return Boolean(usage && (Object.entries(usage).some(([field, value]) => field !== "cost" && typeof value === "number" && Number.isFinite(value)) || Object.values(usage.cost ?? {}).some((value) => typeof value === "number" && Number.isFinite(value))));
+}
+function getFiniteCount(value) {
+	return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
+}
+function getFiniteCost(value) {
+	return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : void 0;
+}
+function addCost(left, right) {
+	return Math.round(((left ?? 0) + right) * 0xe8d4a51000) / 0xe8d4a51000;
+}
+function getComponentTotal(usage) {
+	let total;
+	for (const field of COMPONENT_USAGE_FIELDS) {
+		const value = getFiniteCount(usage[field]);
+		if (value === void 0) continue;
+		total = (total ?? 0) + value;
+	}
+	return total;
+}
+/** Estimated total USD cost from one usage record, when any cost field is present. */
+function agentTurnCostUsd(usage) {
+	if (!usage?.cost) return void 0;
+	const total = getFiniteCost(usage.cost.total);
+	if (total !== void 0) return total;
+	let componentTotal = 0;
+	let hasComponent = false;
+	for (const field of COST_COMPONENT_FIELDS) {
+		const value = getFiniteCost(usage.cost[field]);
+		if (value === void 0) continue;
+		hasComponent = true;
+		componentTotal = addCost(componentTotal, value);
+	}
+	return hasComponent ? componentTotal : void 0;
+}
+/** Total token count from one usage record, preferring component counters. */
+function agentTurnTotalTokens(usage) {
+	if (!usage) return void 0;
+	const componentTotal = getComponentTotal(usage);
+	if (componentTotal !== void 0) return componentTotal;
+	return getFiniteCount(usage.totalTokens);
+}
+/** Aggregate token usage across slices without double-counting provider totals. */
+function addAgentTurnUsage(...usages) {
+	const components = {};
+	let componentTotal;
+	let totalOnlyTokens;
+	let reasoningTokens;
+	const cost = {};
+	for (const usage of usages) {
+		if (!usage) continue;
+		const reasoning = getFiniteCount(usage.reasoningTokens);
+		if (reasoning !== void 0) reasoningTokens = (reasoningTokens ?? 0) + reasoning;
+		if (usage.cost) for (const field of [...COST_COMPONENT_FIELDS, "total"]) {
+			const value = getFiniteCost(usage.cost[field]);
+			if (value === void 0) continue;
+			cost[field] = addCost(cost[field], value);
+		}
+		const usageComponentTotal = getComponentTotal(usage);
+		if (usageComponentTotal !== void 0) {
+			componentTotal = (componentTotal ?? 0) + usageComponentTotal;
+			for (const field of COMPONENT_USAGE_FIELDS) {
+				const value = getFiniteCount(usage[field]);
+				if (value === void 0) continue;
+				components[field] = (components[field] ?? 0) + value;
+			}
+			continue;
+		}
+		const totalTokens = getFiniteCount(usage.totalTokens);
+		if (totalTokens !== void 0) totalOnlyTokens = (totalOnlyTokens ?? 0) + totalTokens;
+	}
+	if (totalOnlyTokens !== void 0) return {
+		totalTokens: totalOnlyTokens + (componentTotal ?? 0),
+		...reasoningTokens !== void 0 ? { reasoningTokens } : void 0,
+		...Object.keys(cost).length > 0 ? { cost } : void 0
+	};
+	const result = {
+		...components,
+		...reasoningTokens !== void 0 ? { reasoningTokens } : void 0,
+		...Object.keys(cost).length > 0 ? { cost } : void 0
+	};
+	return hasAgentTurnUsage(result) ? result : void 0;
+}
+//#endregion
+export { hasAgentTurnUsage as a, generateShortTitle as c, agentsInstructionsUpdatedEvent as d, authenticationLinkedEvent as f, agentTurnUsageSchema as i, resolveTaskTitle as l, renderJuniorNativeConversationEvent as m, agentTurnCostUsd as n, ToolInputError as o, authenticationUnlinkedEvent as p, agentTurnTotalTokens as r, fallbackShortTitle as s, addAgentTurnUsage as t, JUNIOR_NATIVE_EVENT_NAMESPACE as u };

package/dist/usage-schema-CKaDkH_j.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+//#region src/usage-schema.ts
+const usageCostSchema = z.object({
+	input: z.number().finite().nonnegative().optional(),
+	output: z.number().finite().nonnegative().optional(),
+	cacheRead: z.number().finite().nonnegative().optional(),
+	cacheWrite: z.number().finite().nonnegative().optional(),
+	total: z.number().finite().nonnegative().optional()
+}).strict();
+const usageSchema = z.object({
+	inputTokens: z.number().int().nonnegative().optional(),
+	outputTokens: z.number().int().nonnegative().optional(),
+	cachedInputTokens: z.number().int().nonnegative().optional(),
+	cacheCreationTokens: z.number().int().nonnegative().optional(),
+	reasoningTokens: z.number().int().nonnegative().optional(),
+	totalTokens: z.number().int().nonnegative().optional(),
+	cost: usageCostSchema.optional()
+}).strict();
+//#endregion
+export { usageSchema as t };

package/dist/validation-C2CR-OX3.js

@@ -0,0 +1,40 @@
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-BReos-D4.js";
+import { isDeepStrictEqual } from "node:util";
+//#region src/chat/plugins/validation.ts
+var validation_exports = /* @__PURE__ */ __exportAll({
+	validatePluginEgressCredentialHooks: () => validatePluginEgressCredentialHooks,
+	validatePluginRegistrations: () => validatePluginRegistrations
+});
+/** Validate hook registrations against the loaded plugin manifest catalog. */
+function validatePluginRegistrations(registrations) {
+	const loadedPlugins = new Map(pluginCatalogRuntime.getProviders().map((plugin) => [plugin.manifest.name, plugin]));
+	for (const registration of registrations) {
+		const loadedPlugin = loadedPlugins.get(registration.manifest.name);
+		if (!loadedPlugin) throw new Error(`Plugin registration "${registration.manifest.name}" does not have a matching plugin manifest. Add an inline manifest, packageName, or app-local plugin.yaml with the same name.`);
+		const effectiveRegistrationManifest = pluginCatalogRuntime.parseConfiguredInlineManifest(registration.manifest, loadedPlugin.dir);
+		if (!isDeepStrictEqual(effectiveRegistrationManifest, loadedPlugin.manifest)) throw new Error(`Plugin registration "${registration.manifest.name}" manifest does not match the loaded plugin manifest. Use one canonical manifest source for runtime hook plugins.`);
+	}
+}
+/** Validate credential hook registrations against the loaded plugin manifests. */
+function validatePluginEgressCredentialHooks(registrations) {
+	const plugins = new Map(registrations.map((registration) => [registration.manifest.name, registration]));
+	for (const provider of pluginCatalogRuntime.getProviders()) {
+		const hooks = plugins.get(provider.manifest.name)?.hooks;
+		const hasGrantHook = Boolean(hooks?.grantForEgress);
+		const hasIssueHook = Boolean(hooks?.issueCredential);
+		const hasGenericCredentials = Boolean(provider.manifest.credentials || provider.manifest.apiHeaders);
+		const hasDomains = Boolean(provider.manifest.domains?.length);
+		const hasHookManagedOAuth = Boolean(provider.manifest.oauth && !provider.manifest.credentials);
+		if (!hasGrantHook && !hasIssueHook) {
+			if (hasDomains && !hasGenericCredentials) throw new Error(`Plugin "${provider.manifest.name}" manifest.domains requires egress credential hooks when no generic credentials or apiHeaders are configured.`);
+			if (hasHookManagedOAuth) throw new Error(`Plugin "${provider.manifest.name}" manifest.oauth without oauth-bearer credentials requires egress credential hooks.`);
+			continue;
+		}
+		if (!hasGrantHook || !hasIssueHook) throw new Error(`Plugin "${provider.manifest.name}" egress credential hooks must include both grantForEgress and issueCredential.`);
+		if (hasGenericCredentials) throw new Error(`Plugin "${provider.manifest.name}" egress credential hooks must use manifest.domains instead of generic credentials or apiHeaders.`);
+		if (!hasDomains) throw new Error(`Plugin "${provider.manifest.name}" egress credential hooks require manifest.domains to list sandbox egress hosts.`);
+	}
+}
+//#endregion
+export { validatePluginRegistrations as n, validation_exports as r, validatePluginEgressCredentialHooks as t };

package/dist/vercel-queue-DIkVcfK4.js

@@ -0,0 +1,167 @@
+import { z } from "zod";
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { QueueClient } from "@vercel/queue";
+/** Validate the v2 conversation work hint sent through Vercel Queue. */
+const conversationQueueMessageSchema = z.object({
+	schemaVersion: z.literal(2),
+	conversationId: z.string().trim().min(1)
+}).strict();
+var ConversationQueueMessageRejectedError = class extends Error {
+	conversationId;
+	reason;
+	constructor(reason, message, options = {}) {
+		super(message);
+		this.name = "ConversationQueueMessageRejectedError";
+		this.reason = reason;
+		this.conversationId = options.conversationId;
+	}
+};
+/** Return whether an error means the queue message was permanently rejected. */
+function isConversationQueueMessageRejectedError(error) {
+	return error instanceof ConversationQueueMessageRejectedError;
+}
+//#endregion
+//#region src/chat/vercel-queue-client.ts
+function defaultQueueClientOptions() {
+	if (process.env.VERCEL_DEPLOYMENT_ID?.trim()) return {};
+	return { deploymentId: null };
+}
+/** Create a Vercel Queue client that also works in local and eval runtimes. */
+function createVercelQueueClient() {
+	return new QueueClient(defaultQueueClientOptions());
+}
+//#endregion
+//#region src/chat/queue/sign.ts
+/** Sign and check queue messages before public callbacks run them. */
+const QUEUE_SIGNATURE_MAX_AGE_MS = 36e5;
+function secret() {
+	return process.env.JUNIOR_SECRET?.trim() || void 0;
+}
+function digest(args) {
+	return createHmac("sha256", args.secret).update([
+		args.context,
+		args.signedAtMs,
+		...args.parts
+	].join(args.separator)).digest("hex");
+}
+function sameHex(expected, actual) {
+	const left = Buffer.from(expected);
+	const right = Buffer.from(actual);
+	return left.length === right.length && timingSafeEqual(left, right);
+}
+function body(value) {
+	const { signature: _signature, signatureVersion: _signatureVersion, signedAtMs: _signedAtMs, ...message } = value;
+	return message;
+}
+/** Sign one queue message. */
+function signQueueMessage(config, message, nowMs = Date.now()) {
+	const key = secret();
+	if (!key) throw new Error("Cannot sign queue message without JUNIOR_SECRET");
+	if (!Number.isFinite(nowMs)) throw new Error("Cannot sign queue message with an invalid clock");
+	const separator = config.separator ?? "\0";
+	return {
+		...message,
+		signedAtMs: nowMs,
+		signatureVersion: config.signatureVersion,
+		signature: digest({
+			context: config.context,
+			parts: config.parts(message),
+			secret: key,
+			separator,
+			signedAtMs: nowMs
+		})
+	};
+}
+/** Check one signed queue message. */
+function verifyQueueMessage(config, value, nowMs = Date.now()) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {
+		status: "rejected",
+		reason: "malformed"
+	};
+	const signed = z.object({
+		signature: z.string().trim().min(1),
+		signatureVersion: z.literal(config.signatureVersion),
+		signedAtMs: z.number().finite()
+	}).safeParse(value);
+	const message = config.schema.safeParse(body(value));
+	if (!signed.success || !message.success) return {
+		status: "rejected",
+		reason: "malformed"
+	};
+	const key = secret();
+	if (!key) return {
+		status: "unavailable",
+		reason: "missing_secret"
+	};
+	if (!Number.isFinite(nowMs)) return {
+		status: "unavailable",
+		reason: "invalid_clock"
+	};
+	const maxAgeMs = config.maxAgeMs ?? 36e5;
+	if (Math.abs(nowMs - signed.data.signedAtMs) > maxAgeMs) return {
+		status: "rejected",
+		reason: "expired"
+	};
+	if (!sameHex(digest({
+		context: config.context,
+		parts: config.parts(message.data),
+		secret: key,
+		separator: config.separator ?? "\0",
+		signedAtMs: signed.data.signedAtMs
+	}), signed.data.signature)) return {
+		status: "rejected",
+		reason: "signature_mismatch"
+	};
+	return {
+		status: "verified",
+		message: message.data
+	};
+}
+//#endregion
+//#region src/chat/task-execution/queue-signing.ts
+const conversationQueueSign = {
+	context: "junior.conversation_work_queue.v2",
+	schema: conversationQueueMessageSchema,
+	separator: ":",
+	signatureVersion: "v2",
+	parts: (message) => [message.conversationId]
+};
+const CONVERSATION_WORK_QUEUE_SIGNATURE_MAX_SKEW_MS = QUEUE_SIGNATURE_MAX_AGE_MS;
+/** Sign a conversation queue payload before it crosses the public callback route. */
+function signConversationQueueMessage(message, nowMs = Date.now()) {
+	return signQueueMessage(conversationQueueSign, message, nowMs);
+}
+/** Explain whether a queue payload is verified, rejected, or unavailable. */
+function verifyConversationQueueMessage(value, nowMs = Date.now()) {
+	return verifyQueueMessage(conversationQueueSign, value, nowMs);
+}
+const CONVERSATION_WORK_QUEUE_RETENTION_SECONDS = CONVERSATION_WORK_QUEUE_SIGNATURE_MAX_SKEW_MS / 1e3;
+let defaultQueue;
+/** Resolve the Vercel Queue topic used for conversation wake-up nudges. */
+function resolveConversationWorkQueueTopic(options = {}) {
+	return options.topic?.trim() || process.env.JUNIOR_CONVERSATION_WORK_QUEUE_TOPIC?.trim() || "junior_conversation_work";
+}
+function toDelaySeconds(options) {
+	if (!options?.delayMs || options.delayMs <= 0) return;
+	return Math.ceil(options.delayMs / 1e3);
+}
+/** Create the Vercel Queue implementation for conversation wake-up nudges. */
+function createVercelConversationWorkQueue(options = {}) {
+	const topic = resolveConversationWorkQueueTopic(options);
+	const client = options.client ?? createVercelQueueClient();
+	return { async send(message, sendOptions) {
+		const result = await client.send(topic, signConversationQueueMessage(message), {
+			idempotencyKey: sendOptions?.idempotencyKey,
+			delaySeconds: toDelaySeconds(sendOptions),
+			retentionSeconds: options.retentionSeconds ?? CONVERSATION_WORK_QUEUE_RETENTION_SECONDS
+		});
+		return result.messageId ? { messageId: result.messageId } : {};
+	} };
+}
+/** Return the default production conversation work queue. */
+function getVercelConversationWorkQueue() {
+	defaultQueue ??= createVercelConversationWorkQueue();
+	return defaultQueue;
+}
+//#endregion
+export { signQueueMessage as a, ConversationQueueMessageRejectedError as c, QUEUE_SIGNATURE_MAX_AGE_MS as i, conversationQueueMessageSchema as l, resolveConversationWorkQueueTopic as n, verifyQueueMessage as o, verifyConversationQueueMessage as r, createVercelQueueClient as s, getVercelConversationWorkQueue as t, isConversationQueueMessageRejectedError as u };

package/dist/vercel.d.ts

@@ -1,12 +1,12 @@
-interface JuniorVercelConfigOptions {
-    /** Override the Vercel build command, or pass null to omit it. */
-    buildCommand?: string | null;
+//#region src/vercel.d.ts
+export interface JuniorVercelConfigOptions {
+  /** Override the Vercel build command, or pass null to omit it. */
+  buildCommand?: string | null;
 }
 /** Return the root Vercel project config for scaffolded Junior apps.
  *
  * New apps run `junior upgrade` before `pnpm build`; older installs without
  * Junior SQL configured can override `buildCommand` to keep their prior build.
  */
-declare function juniorVercelConfig(options?: JuniorVercelConfigOptions): Record<string, unknown>;
-
-export { type JuniorVercelConfigOptions, juniorVercelConfig };
+export declare function juniorVercelConfig(options?: JuniorVercelConfigOptions): Record<string, unknown>;
+//#endregion

package/dist/vercel.js

@@ -1,6 +1,14 @@
-import {
-  juniorVercelConfig
-} from "./chunk-Y7X25LFY.js";
-export {
-  juniorVercelConfig
-};
+//#region src/vercel.ts
+/** Return the root Vercel project config for scaffolded Junior apps.
+*
+* New apps run `junior upgrade` before `pnpm build`; older installs without
+* Junior SQL configured can override `buildCommand` to keep their prior build.
+*/
+function juniorVercelConfig(options = {}) {
+	const buildCommand = options.buildCommand === void 0 ? "pnpm exec junior upgrade && pnpm build" : options.buildCommand;
+	const config = { framework: "nitro" };
+	if (buildCommand !== null) config.buildCommand = buildCommand;
+	return config;
+}
+//#endregion
+export { juniorVercelConfig };

package/dist/version-CnXZ614E.d.ts

@@ -0,0 +1,5 @@
+//#region src/version.d.ts
+/** Installed Junior package version, or `unknown` when package metadata is unavailable. */
+declare const JUNIOR_VERSION: string;
+//#endregion
+export { JUNIOR_VERSION as t };

package/dist/version-DxcWdoKa.js

@@ -0,0 +1,8 @@
+//#region package.json
+var version = "0.204.0";
+//#endregion
+//#region src/version.ts
+/** Installed Junior package version, or `unknown` when package metadata is unavailable. */
+const JUNIOR_VERSION = typeof version === "string" && version.trim() ? version : "unknown";
+//#endregion
+export { JUNIOR_VERSION as t };

package/dist/version.d.ts

@@ -1,4 +1,2 @@
-/** Installed Junior package version, or `unknown` when package metadata is unavailable. */
-declare const JUNIOR_VERSION: string;
-
-export { JUNIOR_VERSION };
+import { t as JUNIOR_VERSION } from "./version-CnXZ614E.js";
+export { JUNIOR_VERSION };

package/dist/version.js

@@ -1,6 +1,2 @@
-import {
-  JUNIOR_VERSION
-} from "./chunk-WDZR3QQM.js";
-export {
-  JUNIOR_VERSION
-};
+import { t as JUNIOR_VERSION } from "./version-DxcWdoKa.js";
+export { JUNIOR_VERSION };

package/dist/web-authorization-RMBxAR_t.js

@@ -0,0 +1,76 @@
+import { a as getClient } from "./sentry-CD3SdJl-.js";
+import { w as getStateAdapter } from "./profile-CrT5nXbw.js";
+import { randomUUID } from "node:crypto";
+//#region src/chat/sentry-links.ts
+function getSentryOrgSlug() {
+	return process.env.SENTRY_ORG_SLUG?.trim() || void 0;
+}
+function isSentrySaasDsnHost(host) {
+	return host === "sentry.io" || host.endsWith(".sentry.io");
+}
+function buildSentryWebBaseUrl(dsn) {
+	if (isSentrySaasDsnHost(dsn.host)) return "https://sentry.io";
+	const port = dsn.port ? `:${dsn.port}` : "";
+	const path = dsn.path ? `/${dsn.path}` : "";
+	return `${dsn.protocol}://${dsn.host}${port}${path}`;
+}
+function buildSentryOrgPath(args) {
+	const dsn = getClient()?.getDsn();
+	if (!dsn?.host || !dsn.projectId) return;
+	const orgSlug = getSentryOrgSlug();
+	if (!orgSlug) return;
+	const params = new URLSearchParams();
+	params.set("project", dsn.projectId);
+	if (args.query) for (const [key, value] of Object.entries(args.query)) params.set(key, value);
+	const path = `${args.path}?${params.toString()}`;
+	if (isSentrySaasDsnHost(dsn.host)) return `https://${orgSlug}.sentry.io/${path}`;
+	return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
+}
+/** Build a Sentry conversation URL only when the runtime has enough Sentry config. */
+function buildSentryConversationUrl(conversationId) {
+	return buildSentryOrgPath({ path: `explore/conversations/${encodeURIComponent(conversationId)}/` });
+}
+/** Build a Sentry event URL only when the runtime has enough Sentry config. */
+function buildSentryEventUrl(eventId) {
+	return buildSentryOrgPath({
+		path: "issues/",
+		query: { query: eventId }
+	});
+}
+//#endregion
+//#region src/chat/conversations/web-authorization.ts
+const WEB_AUTHORIZATION_PREFIX = "junior:web_authorization:v1";
+const WEB_AUTHORIZATION_TTL_MS = 864e5;
+function authorizationKey(conversationId, actorId) {
+	return `${WEB_AUTHORIZATION_PREFIX}:${conversationId}:${actorId}`;
+}
+/** Build authorization delivery for one web turn. */
+function createWebAuthorization(args) {
+	return {
+		createState: async () => randomUUID(),
+		deliver: async (request) => {
+			await getStateAdapter().set(authorizationKey(args.conversationId, args.actorId), JSON.stringify({
+				...request,
+				...args
+			}), WEB_AUTHORIZATION_TTL_MS);
+		}
+	};
+}
+/** Read the pending authorization request for one web actor. */
+async function getWebAuthorization(args) {
+	const value = await getStateAdapter().get(authorizationKey(args.conversationId, args.actorId));
+	if (typeof value !== "string") return void 0;
+	try {
+		const parsed = JSON.parse(value);
+		if (parsed.actorId !== args.actorId || parsed.conversationId !== args.conversationId || typeof parsed.authorizationUrl !== "string" || typeof parsed.label !== "string" || typeof parsed.completionText !== "string") return;
+		return parsed;
+	} catch {
+		return;
+	}
+}
+/** Remove a web authorization request after the parked turn continues. */
+async function deleteWebAuthorization(args) {
+	await getStateAdapter().delete(authorizationKey(args.conversationId, args.actorId));
+}
+//#endregion
+export { buildSentryEventUrl as a, buildSentryConversationUrl as i, deleteWebAuthorization as n, getWebAuthorization as r, createWebAuthorization as t };