@sentry/junior 0.202.0 → 0.204.0

package/dist/auth-pause-state-DosEalIG.js

@@ -0,0 +1,168 @@
+import { M as getProviderErrorAttributes, N as getProviderErrorUserMessage, j as findProviderError, k as ProviderError } from "./config-nGCW1OTG.js";
+import { t as buildTurnFailureResponse } from "./logging-BzAk1S_s.js";
+import { _ as parseSlackMessageTs } from "./context-B45_WqVX.js";
+import { Q as hydrateConversationMessages, lt as markConversationMessage } from "./checkpoint-CNrPyRJN.js";
+import { Gt as buildDeterministicTurnId } from "./stats-DTUbAb88.js";
+import { b as markTurnCompleted, r as clearPendingAuth, y as markTurnClosed } from "./pending-auth-CWmSdZVg.js";
+import { o as persistThreadStateById, r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-CRc9jTJS.js";
+//#region src/chat/runtime/delivered-turn-state.ts
+/** Build state after destination delivery or intentional no-reply completion. */
+function buildDeliveredTurnStatePatch(args) {
+	const conversation = structuredClone(args.conversation);
+	clearPendingAuth(conversation, args.sessionId);
+	markConversationMessage(conversation, args.userMessageId, {
+		replied: true,
+		skippedReason: void 0
+	});
+	markTurnCompleted({
+		conversation,
+		nowMs: Date.now(),
+		sessionId: args.sessionId
+	});
+	return {
+		conversation,
+		sandboxRef: args.reply.sandboxRef
+	};
+}
+//#endregion
+//#region src/chat/runtime/turn-user-message.ts
+/** Return the user message for a persisted turn/session, if one exists. */
+function getTurnUserMessage(conversation, sessionId) {
+	for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
+		const message = conversation.messages[index];
+		if (message?.role !== "user") continue;
+		if (buildDeterministicTurnId(message.id) === sessionId) return message;
+	}
+}
+/** Return the persisted user-message id for a turn/session, if one exists. */
+function getTurnUserMessageId(conversation, sessionId) {
+	return getTurnUserMessage(conversation, sessionId)?.id;
+}
+/** Return the Slack timestamp for the user message that a resumed turn acts on. */
+function getTurnUserSlackMessageTs(message) {
+	return parseSlackMessageTs(message?.meta?.slackTs);
+}
+/** Rebuild attachment context for a resumed turn from the persisted user message. */
+function getTurnUserReplyAttachmentContext(message) {
+	const inboundAttachmentCount = message?.meta?.attachmentCount ?? 0;
+	const imageAttachmentCount = message?.meta?.imageAttachmentCount ?? 0;
+	const imagesHydrated = message?.meta?.imagesHydrated === true;
+	return {
+		...inboundAttachmentCount > 0 ? { inboundAttachmentCount } : void 0,
+		...!imagesHydrated && imageAttachmentCount > 0 ? { omittedImageAttachmentCount: imageAttachmentCount } : void 0
+	};
+}
+//#endregion
+//#region src/chat/interruption-marker.ts
+const INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
+/** Return the marker added when a visible reply ended mid-execution. */
+function getInterruptionMarker() {
+	return INTERRUPTED_MARKER;
+}
+//#endregion
+//#region src/chat/services/turn-failure-response.ts
+/** Require captured turn failures to carry a real Sentry event reference. */
+function requireTurnFailureEventId(eventId, eventName) {
+	if (!eventId) throw new Error(`Sentry did not return an event ID for ${eventName}`);
+	return eventId;
+}
+function getExecutionFailureReason(reply) {
+	const errorMessage = reply.diagnostics.errorMessage?.trim();
+	if (errorMessage) return errorMessage;
+	if (reply.diagnostics.toolErrorCount > 0) return `${reply.diagnostics.toolErrorCount} tool result error(s)`;
+	if (reply.diagnostics.assistantMessageCount > 0) return "assistant returned no text";
+	return "empty assistant turn";
+}
+/** Return a fixed reason label for a failed model turn. */
+function getTurnFailureReason(reply) {
+	if (reply.diagnostics.outcome === "success") return;
+	if (reply.diagnostics.outcome === "provider_error") return findProviderError(reply.diagnostics.providerError)?.kind ?? "unknown";
+	if (reply.diagnostics.toolErrorCount > 0) return "tool_errors";
+	if (reply.diagnostics.usedPrimaryText && reply.diagnostics.assistantMessageCount > 0) return "suppressed_output";
+	return "empty_output";
+}
+function getFailureCapture(reply) {
+	if (reply.diagnostics.outcome === "provider_error") {
+		const providerError = findProviderError(reply.diagnostics.providerError);
+		return {
+			eventName: "agent.turn.provider_error",
+			error: reply.diagnostics.providerError ?? new Error(reply.diagnostics.errorMessage ?? "Provider error without explicit message"),
+			attributes: providerError ? getProviderErrorAttributes(providerError) : {},
+			body: "Agent turn failed with provider error"
+		};
+	}
+	const failureReason = getExecutionFailureReason(reply);
+	return {
+		eventName: "agent.turn.execution.failed",
+		error: /* @__PURE__ */ new Error(`Agent turn execution failure: ${failureReason}`),
+		attributes: { "app.ai.execution_failure_reason": failureReason },
+		body: "Agent turn completed with execution failure"
+	};
+}
+/** Keep failed-turn Sentry captures and completion spans on the same keys. */
+function getAgentTurnDiagnosticsAttributes(reply) {
+	return {
+		"app.ai.outcome": reply.diagnostics.outcome,
+		"app.ai.assistant_messages": reply.diagnostics.assistantMessageCount,
+		"app.ai.tool_results": reply.diagnostics.toolResultCount,
+		"app.ai.tool_error_results": reply.diagnostics.toolErrorCount,
+		"app.ai.tool_call_count": reply.diagnostics.toolCalls.length,
+		"app.ai.used_primary_text": reply.diagnostics.usedPrimaryText,
+		...reply.diagnostics.reasoningLevel ? { "gen_ai.request.reasoning.level": reply.diagnostics.reasoningLevel } : void 0,
+		...reply.diagnostics.stopReason ? { "gen_ai.response.finish_reasons": [reply.diagnostics.stopReason] } : void 0,
+		...reply.diagnostics.errorMessage && reply.diagnostics.outcome !== "provider_error" ? { "exception.message": reply.diagnostics.errorMessage } : void 0
+	};
+}
+/** Enforce one captured failure response and return its structured correlation. */
+function finalizeFailedTurnReplyWithEvent(args) {
+	if (args.reply.diagnostics.outcome === "success") return { reply: args.reply };
+	const failureReason = getTurnFailureReason(args.reply);
+	const capture = getFailureCapture(args.reply);
+	const eventId = requireTurnFailureEventId(args.logException(capture.error, capture.eventName, {
+		...getAgentTurnDiagnosticsAttributes(args.reply),
+		...args.attributes,
+		...capture.attributes,
+		...failureReason ? { "app.ai.failure_reason": failureReason } : void 0
+	}), capture.eventName);
+	const providerPartialText = args.reply.diagnostics.outcome === "provider_error" && args.reply.diagnostics.assistantMessageCount > 0 ? args.reply.text.trim() : "";
+	const providerUserMessage = args.reply.diagnostics.providerError instanceof ProviderError ? getProviderErrorUserMessage(args.reply.diagnostics.providerError) : "";
+	const failureText = providerUserMessage ? `${providerUserMessage} Reference: \`event_id=${eventId}\`.` : buildTurnFailureResponse(eventId);
+	return {
+		eventId,
+		...failureReason ? { failureReason } : void 0,
+		reply: {
+			...args.reply,
+			text: providerPartialText ? `${providerPartialText}${getInterruptionMarker()}` : failureText
+		}
+	};
+}
+//#endregion
+//#region src/chat/runtime/auth-pause-state.ts
+/** Mark an auth-paused turn complete after private authorization link delivery. */
+function completeAuthPauseTurn(args) {
+	markConversationMessage(args.conversation, getTurnUserMessageId(args.conversation, args.sessionId), {
+		replied: true,
+		skippedReason: void 0
+	});
+	markTurnClosed({
+		conversation: args.conversation,
+		nowMs: Date.now(),
+		sessionId: args.sessionId
+	});
+}
+/** Reload thread state, mark the auth pause as parked, and persist it. */
+async function persistAuthPauseTurnState(args) {
+	const currentState = await getPersistedThreadState(args.threadStateId);
+	const conversation = coerceThreadConversationState(currentState);
+	await hydrateConversationMessages({
+		conversation,
+		conversationId: args.threadStateId
+	});
+	completeAuthPauseTurn({
+		conversation,
+		sessionId: args.sessionId
+	});
+	await persistThreadStateById(args.threadStateId, { conversation });
+}
+//#endregion
+export { requireTurnFailureEventId as a, getTurnUserMessageId as c, buildDeliveredTurnStatePatch as d, getAgentTurnDiagnosticsAttributes as i, getTurnUserReplyAttachmentContext as l, persistAuthPauseTurnState as n, getInterruptionMarker as o, finalizeFailedTurnReplyWithEvent as r, getTurnUserMessage as s, completeAuthPauseTurn as t, getTurnUserSlackMessageTs as u };

package/dist/catalog-runtime-BReos-D4.js

@@ -0,0 +1,7 @@
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
+import { t as createPluginCatalogRuntime } from "./registry-DH1xUo2N.js";
+//#region src/chat/plugins/catalog-runtime.ts
+var catalog_runtime_exports = /* @__PURE__ */ __exportAll({ pluginCatalogRuntime: () => pluginCatalogRuntime });
+const pluginCatalogRuntime = createPluginCatalogRuntime();
+//#endregion
+export { pluginCatalogRuntime as n, catalog_runtime_exports as t };