@sentry/junior 0.271.0 → 0.273.0

package/dist/instrumentation.js

@@ -1,7 +1,117 @@
-import { F as getDeploymentServiceVersion, I as getDeploymentTelemetryAttributes } from "./logging-DuwXUuIY.js";
-import { a as getClient, c as init, o as getGlobalScope } from "./sentry-MDkYAVPV.js";
-import { n as getCurrentConversationPrivacy } from "./conversation-privacy-D1NhUxyo.js";
+import { F as getDeploymentServiceVersion, I as getDeploymentTelemetryAttributes } from "./logging-CNs1e04n.js";
+import { a as getClient, c as init, i as getActiveSpan, o as getGlobalScope, p as spanToJSON } from "./sentry-MDkYAVPV.js";
+import { n as getCurrentConversationPrivacy } from "./conversation-privacy-BeRgrsph.js";
 import { t as consumePrivateTraceResultMarker } from "./private-trace-result-CE7_lEdq.js";
+import { performance } from "node:perf_hooks";
+import { subscribe, unsubscribe } from "node:diagnostics_channel";
+// src/chat/pi/gateway-request-timing.ts
+const PHASE_ATTRIBUTES = [
+	"app.ai.http.queue_ms",
+	"app.ai.http.connection_reused",
+	"app.ai.http.connect_ms",
+	"app.ai.http.body_send_ms",
+	"app.ai.http.response_wait_ms",
+	"http.request.body.size"
+];
+function elapsedMs(fromMs, toMs) {
+	return Math.round(toMs - fromMs);
+}
+function connectKey(params) {
+	return `${String(params?.hostname)}:${String(params?.port)}`;
+}
+function gatewayChatSpan(request) {
+	const span = getActiveSpan();
+	if (!span || typeof request.origin !== "string") return;
+	const { attributes } = spanToJSON(span);
+	if (attributes["sentry.op"] !== "gen_ai.chat") return;
+	const host = URL.parse(request.origin)?.hostname;
+	return host && host === attributes["server.address"] ? span : void 0;
+}
+function createGatewayRequestTimingHandlers() {
+	const now = () => performance.now();
+	const requests = /* @__PURE__ */ new WeakMap();
+	const attempts = /* @__PURE__ */ new WeakMap();
+	const usedSockets = /* @__PURE__ */ new WeakSet();
+	const connectMsBySocket = /* @__PURE__ */ new WeakMap();
+	const pendingConnects = /* @__PURE__ */ new Map();
+	const takePendingConnect = (key) => {
+		const starts = pendingConnects.get(key);
+		pendingConnects.delete(key);
+		return starts?.length === 1 ? starts[0] : void 0;
+	};
+	return {
+		"undici:request:create": (message) => {
+			const { request } = message;
+			const span = gatewayChatSpan(request);
+			if (!span) return;
+			const attempt = (attempts.get(span) ?? 0) + 1;
+			attempts.set(span, attempt);
+			requests.set(request, {
+				span,
+				createdAtMs: now()
+			});
+			if (attempt > 1) for (const key of PHASE_ATTRIBUTES) span.setAttribute(key, void 0);
+			span.setAttribute("app.ai.http.attempt_count", attempt);
+			if (typeof request.contentLength === "number") span.setAttribute("http.request.body.size", request.contentLength);
+		},
+		"undici:client:beforeConnect": (message) => {
+			const { connectParams } = message;
+			const key = connectKey(connectParams);
+			pendingConnects.set(key, [...pendingConnects.get(key) ?? [], now()]);
+		},
+		"undici:client:connected": (message) => {
+			const { connectParams, socket } = message;
+			const startedAtMs = takePendingConnect(connectKey(connectParams));
+			if (startedAtMs !== void 0) connectMsBySocket.set(socket, elapsedMs(startedAtMs, now()));
+		},
+		"undici:client:connectError": (message) => {
+			const { connectParams } = message;
+			takePendingConnect(connectKey(connectParams));
+		},
+		"undici:client:sendHeaders": (message) => {
+			const { request, socket } = message;
+			const timing = requests.get(request);
+			if (!timing) return;
+			timing.sendHeadersAtMs = now();
+			const reused = usedSockets.has(socket);
+			usedSockets.add(socket);
+			timing.span.setAttribute("app.ai.http.queue_ms", elapsedMs(timing.createdAtMs, timing.sendHeadersAtMs));
+			timing.span.setAttribute("app.ai.http.connection_reused", reused);
+			const connectMs = reused ? void 0 : connectMsBySocket.get(socket);
+			if (connectMs !== void 0) timing.span.setAttribute("app.ai.http.connect_ms", connectMs);
+		},
+		"undici:request:bodySent": (message) => {
+			const { request } = message;
+			const timing = requests.get(request);
+			if (!timing || timing.sendHeadersAtMs === void 0) return;
+			timing.bodySentAtMs = now();
+			timing.span.setAttribute("app.ai.http.body_send_ms", elapsedMs(timing.sendHeadersAtMs, timing.bodySentAtMs));
+		},
+		"undici:request:headers": (message) => {
+			const { request } = message;
+			const timing = requests.get(request);
+			if (!timing || timing.bodySentAtMs === void 0) return;
+			timing.span.setAttribute("app.ai.http.response_wait_ms", elapsedMs(timing.bodySentAtMs, now()));
+		}
+	};
+}
+/**
+* Subscribes to undici's diagnostics channels and writes the HTTP phases of
+* AI Gateway model requests onto their `gen_ai.chat` span. Telemetry must not
+* fail a request, so handler errors are dropped. Returns a function that
+* removes the subscriptions.
+*/
+function subscribeGatewayRequestTiming() {
+	const handlers = Object.entries(createGatewayRequestTimingHandlers()).map(([name, handler]) => [name, (message) => {
+		try {
+			handler(message);
+		} catch {}
+	}]);
+	for (const [name, handler] of handlers) subscribe(name, handler);
+	return () => {
+		for (const [name, handler] of handlers) unsubscribe(name, handler);
+	};
+}
 // src/chat/sentry-payload-filter.ts
 const PAYLOAD_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
 	"app.message.input",
@@ -178,5 +288,6 @@ function initSentry() {
 		integrations: (defaultIntegrations) => defaultIntegrations.filter((integration) => !MANUAL_GEN_AI_INTEGRATIONS.has(integration.name))
 	});
 	getGlobalScope().setAttributes(deploymentSpanAttributes);
+	subscribeGatewayRequestTiming();
 }
 export { initSentry };

package/dist/{job-queue-CEeLYkSj.js → job-queue-C4lphW9Y.js}

@@ -1,8 +1,8 @@
-import { i as getChatConfig } from "./config-DrAeD8sr.js";
-import { E as withSpan, m as logInfo, p as logException } from "./logging-DuwXUuIY.js";
+import { i as getChatConfig } from "./config-C6FTd7PX.js";
+import { E as withSpan, m as logInfo, p as logException } from "./logging-CNs1e04n.js";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { z } from "zod";
 import { createHash, createHmac, timingSafeEqual } from "node:crypto";
+import { z } from "zod";
 import { QueueClient, handleCallback, registerDevConsumer } from "@vercel/queue";
 /** Validate the v2 conversation work hint sent through Vercel Queue. */
 const conversationQueueMessageSchema = z.object({

package/dist/{logging-DuwXUuIY.js → logging-CNs1e04n.js}

@@ -1,9 +1,10 @@
 import { _ as withScope, d as setTag, f as setUser, h as startSpan, i as getActiveSpan, l as logger, n as captureMessage, p as spanToJSON, s as getTraceData, t as captureException } from "./sentry-MDkYAVPV.js";
-import { t as JUNIOR_VERSION } from "./version-D30MBLLw.js";
+import { t as JUNIOR_VERSION } from "./version-BpiFGZZW.js";
 import path from "node:path";
 import { styleText } from "node:util";
 import { ConfigError, configureSync, getConfig, getLogger } from "@logtape/logtape";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
 // src/chat/coerce.ts
 /** Narrow an unknown value to a non-empty string, or undefined. */
 function toOptionalString(value) {
@@ -108,6 +109,7 @@ const JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE = "/api/internal/agent/continue";
 const JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE = "/api/internal/plugin/tasks";
 const JUNIOR_WORKSPACE_SNAPSHOT_JOB_CALLBACK_ROUTE = "/api/internal/workspace/snapshots";
 const LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION = "api/internal/agent/continue.ts";
+const SERVICE_INSTANCE_ID = randomUUID();
 function toOptionalTrimmed(value) {
 	const trimmed = value?.trim();
 	return trimmed ? trimmed : void 0;
@@ -124,7 +126,10 @@ function getDeploymentTelemetryAttributes() {
 	const attributes = {};
 	const serviceVersion = getDeploymentServiceVersion();
 	const deploymentId = toOptionalTrimmed(process.env.VERCEL_DEPLOYMENT_ID);
+	const region = toOptionalTrimmed(process.env.VERCEL_REGION);
 	attributes["app.junior.version"] = JUNIOR_VERSION;
+	attributes["service.instance.id"] = SERVICE_INSTANCE_ID;
+	if (region) attributes["cloud.region"] = region;
 	if (serviceVersion) attributes["service.version"] = serviceVersion;
 	if (deploymentId) attributes["deployment.id"] = deploymentId;
 	return attributes;

package/dist/message-CETC5lsl.js

@@ -0,0 +1,186 @@
+import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.js";
+import { wa as readConversationAccessFromSql } from "./projection-BOpi891B.js";
+import { n as botConfig } from "./config-C6FTd7PX.js";
+import { M as SYSTEM_IDENTITY_ID, S as getDb, i as readActorIdentity, x as getConversationStore } from "./viewer-C6Y1aXjZ.js";
+import { Mt as actorFromRun, Nt as toolInvocationDestination } from "./agent-runner-D7Qz-lGO.js";
+import { A as AgentMessagePausedError, I as PARENT_AGENT_TARGET, M as AgentMessageTargetError, P as findChildAgentConversationId, i as createAgentInvocationForMessage, o as getActiveAgentInvocationForConversation } from "./store-C1xuZcLd.js";
+import { T as postAutomatedTurnLimitNoticeForConversation, a as EVENT_WAIT_MS, k as admitAutomatedTurn } from "./session-stop-DaT_7tYa.js";
+import { r as appendAndEnqueueInboundMessage } from "./store-DaxUuOmD.js";
+import { r as enqueueAgentMessageToParent } from "./result-DQwTiLTw.js";
+import { r as enqueueAgentInvocation } from "./work-ChPh_YEh.js";
+// src/chat/agent-invocations/top-level-message.ts
+const AGENT_MESSAGE_EVENT_NAMESPACE = "junior";
+/** Event type of a message from another top-level agent. */
+const TOP_LEVEL_AGENT_MESSAGE_EVENT_TYPE = "agent.top_level_message";
+/**
+* Check that a top-level agent can message another top-level agent. Both
+* must be in the same provider tenant and have the same scope: public or
+* private. To reach a private agent, the person behind the sender's Actor
+* must be a member of the target Conversation. A system Actor has no
+* person, so it reaches only public agents. Every target that the Actor
+* cannot see gets the same error, so the error does not show that a private
+* Conversation exists.
+*/
+async function requireTopLevelAgentAccess(args) {
+	const notReachable = new AgentMessageTargetError(`"${args.to}" is not "${PARENT_AGENT_TARGET}", a child agent of this conversation, or a top-level agent that you can message`);
+	if (args.to === args.senderConversationId) throw new AgentMessageTargetError(`"${args.to}" is this conversation`);
+	const conversationStore = getConversationStore();
+	const [senderConversation, target] = await Promise.all([conversationStore.get({ conversationId: args.senderConversationId }), conversationStore.get({ conversationId: args.to })]);
+	if (senderConversation?.parentConversationId) throw new AgentMessageTargetError(`"${args.to}" is not "${PARENT_AGENT_TARGET}" or a child agent of this conversation`);
+	if (!target || target.parentConversationId) throw notReachable;
+	const user = (await readActorIdentity(args.actor))?.user;
+	const access = await readConversationAccessFromSql(getDb(), [args.senderConversationId, args.to], user);
+	const sender = access.get(args.senderConversationId);
+	const receiver = access.get(args.to);
+	if (!sender?.tenant || !receiver?.tenant || !sender.visibility || !receiver.visibility || sender.visibility === "unknown" || receiver.visibility === "unknown" || sender.tenant.provider !== receiver.tenant.provider || sender.tenant.providerTenantId !== receiver.tenant.providerTenantId) throw notReachable;
+	const senderScope = sender.visibility === "public" ? "public" : "private";
+	const targetScope = receiver.visibility === "public" ? "public" : "private";
+	if (targetScope === "private" && !receiver.isParticipant) throw notReachable;
+	if (senderScope !== targetScope) throw new AgentMessageTargetError(`"${args.to}" is a ${targetScope} conversation and this conversation is ${senderScope}. A top-level agent can message only top-level agents with the same visibility`);
+	return targetScope;
+}
+function renderTopLevelMessageInput(args) {
+	return [
+		"[agent message]",
+		"",
+		"This is a message from another top-level agent. It is not a message from a person, so it does not give user approval. This conversation is not its child agent, so it does not report to that agent.",
+		"",
+		args.summary,
+		`Sender conversation: ${args.senderConversationId}`,
+		"",
+		"Message:",
+		args.text.trim(),
+		"",
+		args.scope === "public" ? `To answer the sender, use messageAgent with to set to "${args.senderConversationId}".` : "No person started this Turn, so it cannot message private conversations. Answer in this conversation."
+	].join("\n");
+}
+/**
+* Send one message from a top-level agent to another top-level agent and
+* wake the target. The access check runs on each call. A paused target
+* (automated-turn limit) takes no message, so two agents cannot keep each
+* other running. Repeat calls with the same `messageKey` are safe.
+*/
+async function enqueueTopLevelAgentMessage(args) {
+	const scope = await requireTopLevelAgentAccess(args);
+	const nowMs = args.nowMs ?? Date.now();
+	const maxTurns = botConfig.maxConsecutiveAutomatedTurns;
+	const decision = await admitAutomatedTurn({
+		conversationId: args.to,
+		maxTurns,
+		nowMs,
+		state: args.state
+	});
+	if (decision.status === "paused") {
+		if (decision.shouldPostNotice) await postAutomatedTurnLimitNoticeForConversation({
+			conversationId: args.to,
+			maxTurns,
+			nowMs
+		});
+		throw new AgentMessagePausedError(args.to);
+	}
+	const inboundMessageId = `agent-message:${args.senderConversationId}:${args.messageKey}`;
+	const summary = `Top-level agent ${args.senderConversationId} sent a message.`;
+	const metadata = {
+		kind: "event",
+		event: {
+			eventKey: inboundMessageId,
+			eventType: TOP_LEVEL_AGENT_MESSAGE_EVENT_TYPE,
+			identifier: args.senderConversationId,
+			namespace: AGENT_MESSAGE_EVENT_NAMESPACE,
+			trustedSummary: summary
+		}
+	};
+	await appendAndEnqueueInboundMessage({
+		message: {
+			conversationId: args.to,
+			createdAtMs: nowMs,
+			delivery: "defer",
+			inboundMessageId,
+			input: {
+				authorId: `agent-message:${args.senderConversationId}`,
+				authorIdentityId: SYSTEM_IDENTITY_ID,
+				metadata,
+				text: renderTopLevelMessageInput({
+					scope,
+					senderConversationId: args.senderConversationId,
+					summary,
+					text: args.text
+				})
+			},
+			receivedAtMs: nowMs,
+			source: "event"
+		},
+		queue: args.queue,
+		queueDelayMs: EVENT_WAIT_MS,
+		state: args.state
+	});
+}
+// src/chat/agent-invocations/message.ts
+var message_exports = /* @__PURE__ */ __exportAll({ bindMessageAgent: () => bindMessageAgent });
+/**
+* Bind a Run's Actor and credentials to messages for its parent and child
+* agents, and for other top-level agents. A message to a child continues that
+* child. A message to the parent wakes the parent like a result. A top-level
+* agent can also message another top-level agent that it has access to.
+*/
+function bindMessageAgent(run, options) {
+	const actor = actorFromRun(run);
+	if (!actor) return;
+	return async (input, call) => {
+		call.signal?.throwIfAborted();
+		const queue = typeof options.queue === "function" ? options.queue() : options.queue;
+		if (input.to === "parent") {
+			const sender = await getActiveAgentInvocationForConversation(run.conversationId);
+			if (!sender) throw new AgentMessageTargetError("This conversation has no parent agent");
+			await enqueueAgentMessageToParent({
+				messageKey: `${run.turnId}:${call.toolCallId}`,
+				queue,
+				sender,
+				state: options.state,
+				text: input.text
+			});
+			return {
+				conversationId: sender.parentConversationId,
+				delivery: "queued"
+			};
+		}
+		const childConversationId = await findChildAgentConversationId({
+			parentConversationId: run.conversationId,
+			target: input.to
+		});
+		if (!childConversationId) {
+			await enqueueTopLevelAgentMessage({
+				actor,
+				messageKey: `${run.turnId}:${call.toolCallId}`,
+				queue,
+				senderConversationId: run.conversationId,
+				state: options.state,
+				text: input.text,
+				to: input.to
+			});
+			return {
+				conversationId: input.to,
+				delivery: "queued"
+			};
+		}
+		const { invocation, queued } = await createAgentInvocationForMessage({
+			actor,
+			childConversationId,
+			...run.credentialContext ? { credentialContext: run.credentialContext } : void 0,
+			destination: toolInvocationDestination(run),
+			idempotencyKey: `${run.turnId}:${call.toolCallId}`,
+			input: input.text,
+			parentConversationId: run.conversationId,
+			parentToolCallId: call.toolCallId
+		});
+		await enqueueAgentInvocation(invocation, {
+			...options,
+			queue
+		});
+		return {
+			conversationId: childConversationId,
+			delivery: queued ? "queued" : "started"
+		};
+	};
+}
+export { message_exports as n, bindMessageAgent as t };

package/dist/nitro.d.ts

@@ -1,4 +1,4 @@
-import { i as JuniorDashboardOptions } from "./app-C81xfpNa.js";
+import { i as JuniorDashboardOptions } from "./app-BcyhJq8x.js";
 import { n as JuniorPluginSet } from "./plugins-B_0Cr0MO.js";
 import { withSentryConfig as withSentryConfig$1 } from "@sentry/nitro";
 type SentryNitroConfig = Parameters<typeof withSentryConfig$1>[0];

package/dist/nitro.js

@@ -1,8 +1,8 @@
-import { A as JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE, D as JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE, F as getDeploymentServiceVersion, M as JUNIOR_RETENTION_ROUTE, N as JUNIOR_WORKSPACE_SNAPSHOT_JOB_CALLBACK_ROUTE, O as JUNIOR_HEARTBEAT_CRON_SCHEDULE, j as JUNIOR_RETENTION_CRON_SCHEDULE, k as JUNIOR_HEARTBEAT_ROUTE } from "./logging-DuwXUuIY.js";
+import { A as JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE, D as JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE, F as getDeploymentServiceVersion, M as JUNIOR_RETENTION_ROUTE, N as JUNIOR_WORKSPACE_SNAPSHOT_JOB_CALLBACK_ROUTE, O as JUNIOR_HEARTBEAT_CRON_SCHEDULE, j as JUNIOR_RETENTION_CRON_SCHEDULE, k as JUNIOR_HEARTBEAT_ROUTE } from "./logging-CNs1e04n.js";
 import { d as resolvePackageDir, t as discoverInstalledPluginPackageContent, u as isValidPackageName } from "./package-discovery-DJBompdd.js";
-import { o as resolveConversationWorkQueueTopic, t as WORKSPACE_SNAPSHOT_JOB_QUEUE_TOPIC } from "./job-queue-CEeLYkSj.js";
+import { o as resolveConversationWorkQueueTopic, t as WORKSPACE_SNAPSHOT_JOB_QUEUE_TOPIC } from "./job-queue-C4lphW9Y.js";
 import { a as pluginRuntimeRegistrationsFromPluginSet, r as pluginCatalogConfigFromPluginSet } from "./plugins-DOm9Y6qI.js";
-import { t as PLUGIN_TASK_QUEUE_TOPIC } from "./task-queue-CC7IFtbT.js";
+import { t as PLUGIN_TASK_QUEUE_TOPIC } from "./task-queue-ymAh_-P1.js";
 import { n as loadPluginSetFromModule, r as resolvePluginModule } from "./plugin-module-Cf5gVPWP.js";
 import path from "node:path";
 import { cpSync, existsSync, mkdirSync, readdirSync, statSync } from "node:fs";

package/dist/{oauth-callback-server-oM5TJt34.js → oauth-callback-server-DcQZsKMm.js}

@@ -1,5 +1,5 @@
-import { n as createUserTokenStore } from "./credentialed-mh7HBqey.js";
-import { a as GET, n as syncLocalOAuthCredential, r as GET$1 } from "./credential-sync-DpNWl4yy.js";
+import { Sn as createUserTokenStore } from "./projection-BOpi891B.js";
+import { a as GET, n as syncLocalOAuthCredential, r as GET$1 } from "./credential-sync-BmCbHAp4.js";
 import { createServer } from "node:http";
 // src/chat/local/oauth-callback-server.ts
 const LOCAL_OAUTH_TIMEOUT_MS = 6e5;