@sentry/junior 0.203.0 → 0.205.0

package/dist/logging-BMJzdDlP.js

@@ -0,0 +1,1210 @@
+import { 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, v as withScope } from "./sentry-CD3SdJl-.js";
+import { t as JUNIOR_VERSION } from "./version-oD-oPrbO.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";
+//#region src/chat/coerce.ts
+/** Narrow an unknown value to a non-empty string, or undefined. */
+function toOptionalString(value) {
+	return typeof value === "string" && value.trim() ? value : void 0;
+}
+/** Narrow an unknown value to a finite number, or undefined. */
+function toOptionalNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+/** Type-guard: true when value is a non-null object (usable as Record). */
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+//#region src/chat/log-context.ts
+/** Async attribute domain consumed directly by LogTape. */
+const logContextStorage = new AsyncLocalStorage();
+/** Typed context domain retained for consumers such as native Sentry scope fields. */
+const typedLogContextStorage = new AsyncLocalStorage();
+function definedLogContext(context) {
+	return Object.fromEntries(Object.entries(context).filter(([, value]) => value !== void 0));
+}
+function definedAttributes(attributes) {
+	return Object.fromEntries(Object.entries(attributes).filter((entry) => entry[1] !== void 0));
+}
+/** Convert provider-neutral domain context to stable telemetry attributes. */
+function logContextToAttributes(context) {
+	return definedAttributes({
+		"gen_ai.conversation.id": context.conversationId,
+		"app.platform": context.platform,
+		"app.request.id": context.requestId,
+		"messaging.system": context.platform === "slack" ? "slack" : context.platform,
+		"messaging.message.conversation_id": context.messageConversationId,
+		"messaging.destination.name": context.destinationName,
+		"enduser.id": context.userId,
+		"enduser.pseudo.id": context.userName,
+		"app.run.id": context.runId,
+		"app.actor.type": context.actorType,
+		"app.actor.id": context.actorId,
+		"gen_ai.agent.name": context.assistantUserName,
+		"gen_ai.request.model": context.modelId,
+		"app.skill.name": context.skillName,
+		"http.request.method": context.httpMethod,
+		"url.path": context.httpPath,
+		"url.full": context.urlFull,
+		"user_agent.original": context.userAgent
+	});
+}
+/** Run an operation with merged context, restoring its parent on completion. */
+function runWithLogContext(context, attributes, callback) {
+	return typedLogContextStorage.run({
+		...typedLogContextStorage.getStore(),
+		...definedLogContext(context)
+	}, () => logContextStorage.run({
+		...logContextStorage.getStore(),
+		...attributes
+	}, callback));
+}
+/** Merge context and attributes into the current scoped operation. */
+function updateLogContext(context, attributes) {
+	const currentContext = typedLogContextStorage.getStore();
+	if (currentContext) Object.assign(currentContext, definedLogContext(context));
+	const currentAttributes = logContextStorage.getStore();
+	if (currentAttributes) Object.assign(currentAttributes, attributes);
+}
+/** Read the typed context bound to the current operation. */
+function getBoundLogContext() {
+	return typedLogContextStorage.getStore() ?? {};
+}
+/** Read the attributes bound to the current operation. */
+function getBoundLogAttributes() {
+	return logContextStorage.getStore() ?? {};
+}
+//#endregion
+//#region src/chat/identities/identity.ts
+/** Canonicalize email addresses for identity lookup and linking. */
+function normalizeIdentityEmail(email) {
+	return email?.trim().toLowerCase() || void 0;
+}
+//#endregion
+//#region src/deployment.ts
+const JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";
+const JUNIOR_HEARTBEAT_CRON_SCHEDULE = "* * * * *";
+const JUNIOR_RETENTION_ROUTE = "/api/internal/retention";
+const JUNIOR_RETENTION_CRON_SCHEDULE = "0 4 * * *";
+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";
+function toOptionalTrimmed(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+/** Resolve the deployment version used for release and telemetry correlation. */
+function getDeploymentServiceVersion() {
+	const configuredRelease = toOptionalTrimmed(process.env.SENTRY_RELEASE);
+	if (configuredRelease) return configuredRelease;
+	const deploymentRevision = toOptionalTrimmed(process.env.VERCEL_GIT_COMMIT_SHA);
+	return deploymentRevision ? `${JUNIOR_VERSION}+${deploymentRevision}` : void 0;
+}
+/** Resolve deployment-scoped telemetry attributes from host environment. */
+function getDeploymentTelemetryAttributes() {
+	const attributes = {};
+	const serviceVersion = getDeploymentServiceVersion();
+	const deploymentId = toOptionalTrimmed(process.env.VERCEL_DEPLOYMENT_ID);
+	attributes["app.junior.version"] = JUNIOR_VERSION;
+	if (serviceVersion) attributes["service.version"] = serviceVersion;
+	if (deploymentId) attributes["deployment.id"] = deploymentId;
+	return attributes;
+}
+//#endregion
+//#region src/chat/logging.ts
+/**
+* Structured logging for Junior runtime events.
+*
+* Application code should call `logInfo`, `logWarn`, `logError`, or
+* `logException` with a stable dot-namespaced event name and only attributes
+* specific to that occurrence:
+*
+* `logWarn("agent.turn.empty_output.exhausted", {
+*   "app.ai.empty_output.attempt": 1,
+* })`
+*
+* Event names describe the semantic domain, operation, and outcome. They are
+* lowercase, use dots for namespaces, use snake case within a namespace
+* component, and never contain identifiers or other occurrence-specific data.
+* Use singular domain and operation nouns unless one event represents a real
+* collection. End completed events with a past participle such as `completed`,
+* `failed`, or `skipped`; reserve present participles such as `retrying` for
+* work currently underway, and adjectives such as `busy` for observed states.
+*
+* Correlation context is implicit. Bind authoritative request, conversation,
+* actor, destination, and run context once with `withContext`,
+* `withLogContext`, or `withSpan`; nested logs inherit it through
+* AsyncLocalStorage, and active trace/span IDs are attached during emission.
+* Durable boundaries such as queues and callbacks must still carry and
+* reconstruct their context explicitly before binding it.
+*
+* Internal event calls do not provide a human-readable body. Export adapters
+* derive any required display message from the event name. Free-form messages
+* received from libraries or plugins belong in safe attributes at the adapter
+* boundary.
+*/
+const MAX_STRING_VALUE = 1200;
+const EVENT_NAME_PATTERN = /^[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)+$/;
+const SECRETS_RE = [
+	/\b(sk-[A-Za-z0-9_-]{20,})\b/g,
+	/\b(xox[baprs]-[A-Za-z0-9-]{10,})\b/g,
+	/\bBearer\s+([A-Za-z0-9._\-+=]{20,})\b/gi,
+	/\b[A-Z0-9_]+(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD)\s*[=:]\s*([^\s"']{8,})/gi
+];
+const LEGACY_KEY_MAP = {
+	error: "exception.message",
+	"error.stack": "exception.stacktrace",
+	"gen_ai.system": "gen_ai.provider.name",
+	"gen_ai.request.messages": "gen_ai.input.messages",
+	"gen_ai.response.text": "gen_ai.output.messages",
+	"messaging.conversation.id": "messaging.message.conversation_id",
+	bytes: "file.size",
+	media_type: "app.file.mime_type",
+	skillDir: "file.path",
+	root: "file.directory",
+	originalLength: "app.output.original_length",
+	parsedLength: "app.output.parsed_length",
+	directiveMode: "app.output.directive_mode",
+	fileCount: "app.output.file_count",
+	attempt: "app.retry.attempt",
+	steps: "app.ai.steps",
+	toolCalls: "app.ai.tool_calls",
+	toolResults: "app.ai.tool_results",
+	finishReason: "gen_ai.response.finish_reasons",
+	sources: "app.ai.sources",
+	generatedFiles: "app.ai.generated_files",
+	resultFiles: "app.ai.result_files",
+	responseMessages: "app.ai.response_messages",
+	stepDiagnostics: "app.ai.step_diagnostics",
+	inferredSkill: "app.skill.name",
+	inferredScore: "app.skill.score"
+};
+/** Normalize runtime finish reasons to the telemetry spelling we emit. */
+function normalizeGenAiFinishReason(reason) {
+	return reason === "toolUse" ? "tool_call" : reason;
+}
+/** Truncate message text for log attributes. */
+function summarizeMessageText(text) {
+	const normalized = text.trim().replace(/\s+/g, " ");
+	if (!normalized) return "[empty]";
+	return normalized.length > 1200 ? `${normalized.slice(0, 1200)}...` : normalized;
+}
+function normalizeGenAiFinishReasons(value) {
+	if (typeof value === "string" && value.trim()) return [normalizeGenAiFinishReason(value)];
+	if (!Array.isArray(value)) return value;
+	return value.map((reason) => typeof reason === "string" ? normalizeGenAiFinishReason(reason) : reason);
+}
+const logRecordSinks = /* @__PURE__ */ new Set();
+const deploymentLogAttributes = getDeploymentTelemetryAttributes();
+const LOGTAPE_BODY_KEY = "__logtape_body";
+const ROOT_LOGGER_CATEGORY = ["junior"];
+const CONSOLE_PRIORITY_INDEX = new Map([
+	"gen_ai.conversation.id",
+	"event.name",
+	"app.log.source",
+	"exception.message",
+	"messaging.message.id",
+	"trace_id",
+	"span_id",
+	"messaging.message.conversation_id",
+	"messaging.destination.name",
+	"app.run.id",
+	"app.message.kind"
+].map((key, index) => [key, index]));
+const CONSOLE_ALWAYS_HIDDEN_KEYS = /* @__PURE__ */ new Set([
+	"gen_ai.agent.name",
+	"app.platform",
+	"enduser.id",
+	"enduser.pseudo.id",
+	"http.request.method",
+	"messaging.system",
+	"url.full",
+	"url.path",
+	"user_agent.original"
+]);
+const CONSOLE_DROP_WHEN_COUNTED_KEYS = /* @__PURE__ */ new Set(["app.config.keys"]);
+const CONSOLE_PREVIEW_KEYS = /* @__PURE__ */ new Set([
+	"gen_ai.input.messages",
+	"gen_ai.output.messages",
+	"gen_ai.tool.call.arguments",
+	"gen_ai.tool.call.result"
+]);
+const SENTRY_TAG_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
+	"app.platform",
+	"messaging.system",
+	"app.actor.type",
+	"gen_ai.agent.name",
+	"gen_ai.request.model",
+	"app.skill.name",
+	"http.request.method",
+	"url.path"
+]);
+function getSentryEnvironment() {
+	return (process.env.SENTRY_ENVIRONMENT ?? process.env.VERCEL_ENV ?? process.env.NODE_ENV ?? "").trim().toLowerCase();
+}
+function shouldSuppressInfoLog(level) {
+	return getSentryEnvironment() === "production" && level === "info";
+}
+function shouldEmitConsole(level) {
+	if (process.env.NODE_ENV === "test") return level === "error";
+	return true;
+}
+function isDevelopmentLoggingMode() {
+	if (process.env.NODE_ENV !== "development") return false;
+	if (process.env.CI) return false;
+	return true;
+}
+function shouldUseDevelopmentConsoleFormat() {
+	if (!isDevelopmentLoggingMode()) return false;
+	return process.env.JUNIOR_LOG_FORMAT?.trim().toLowerCase() !== "structured";
+}
+function shouldUsePrettyConsole(level) {
+	if (level === "warn" || level === "error") return false;
+	return shouldUseDevelopmentConsoleFormat();
+}
+function shouldUseConsoleColor() {
+	if (!shouldUseDevelopmentConsoleFormat()) return false;
+	if (process.env.NO_COLOR) return false;
+	return process.env.FORCE_COLOR?.trim() === "1" || Boolean(process.stdout?.isTTY) || Boolean(process.stderr?.isTTY);
+}
+function formatConsoleTimestamp(timestamp) {
+	if (shouldUseDevelopmentConsoleFormat()) return timestamp.toTimeString().slice(0, 8);
+	return timestamp.toISOString();
+}
+function findNextBlankLineBoundary(input, start) {
+	const lfBoundary = input.indexOf("\n\n", start);
+	const crlfBoundary = input.indexOf("\r\n\r\n", start);
+	if (lfBoundary === -1 && crlfBoundary === -1) return null;
+	if (lfBoundary === -1) return {
+		start: crlfBoundary,
+		end: crlfBoundary + 4
+	};
+	if (crlfBoundary === -1 || lfBoundary < crlfBoundary) return {
+		start: lfBoundary,
+		end: lfBoundary + 2
+	};
+	return {
+		start: crlfBoundary,
+		end: crlfBoundary + 4
+	};
+}
+function redactPrivateKeyBlocks(input) {
+	const beginPrefix = "-----BEGIN ";
+	const footerMarker = "-----";
+	let cursor = 0;
+	let output = "";
+	while (cursor < input.length) {
+		const begin = input.indexOf(beginPrefix, cursor);
+		if (begin === -1) {
+			output += input.slice(cursor);
+			break;
+		}
+		const labelStart = begin + 11;
+		const labelEnd = input.indexOf(footerMarker, labelStart);
+		if (labelEnd === -1) {
+			output += input.slice(cursor);
+			break;
+		}
+		const label = input.slice(labelStart, labelEnd);
+		if (!label.endsWith("PRIVATE KEY")) {
+			output += input.slice(cursor, labelEnd + 5);
+			cursor = labelEnd + 5;
+			continue;
+		}
+		const header = input.slice(begin, labelEnd + 5);
+		const footer = `-----END ${label}-----`;
+		const footerStart = input.indexOf(footer, labelEnd + 5);
+		if (footerStart === -1) {
+			const resumeBoundary = findNextBlankLineBoundary(input, labelEnd + 5);
+			output += input.slice(cursor, begin);
+			output += `${header}\n...redacted...`;
+			if (!resumeBoundary) break;
+			output += input.slice(resumeBoundary.start, resumeBoundary.end);
+			cursor = resumeBoundary.end;
+			continue;
+		}
+		output += input.slice(cursor, begin);
+		output += `${header}\n...redacted...\n${footer}`;
+		cursor = footerStart + footer.length;
+	}
+	return output;
+}
+function redactSecrets(input) {
+	let out = redactPrivateKeyBlocks(input);
+	for (const pattern of SECRETS_RE) out = out.replace(pattern, (full, token) => {
+		if (typeof token !== "string") return "***";
+		if (token.length < 12) return full.replace(token, "***");
+		return full.replace(token, `${token.slice(0, 4)}...${token.slice(-4)}`);
+	});
+	return out;
+}
+function toSnakeCase(value) {
+	return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9_]+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+}
+function normalizeEventName(value) {
+	const segments = value.trim().split(".").map(toSnakeCase).filter(Boolean);
+	const normalized = segments.length === 0 ? "log.record.emitted" : segments.length === 1 ? `app.${segments[0]}` : segments.join(".");
+	if (process.env.NODE_ENV !== "production" && (!EVENT_NAME_PATTERN.test(value) || value !== normalized)) throw new Error(`Invalid log event name "${value}"; use lowercase dot-delimited namespaces`);
+	return normalized;
+}
+function isSemanticKey(key) {
+	return /^[a-z][a-z0-9_]*(\.[a-z0-9_][a-z0-9_-]*)+$/.test(key);
+}
+function normalizeAttributeKey(key) {
+	const mapped = LEGACY_KEY_MAP[key];
+	if (mapped) return mapped;
+	if (key === "trace_id" || key === "span_id" || key === "trace_flags") return key;
+	if (isSemanticKey(key)) return key;
+	if (key === "platform") return "app.platform";
+	if (key === "request.id") return "app.request.id";
+	const snake = toSnakeCase(key);
+	if (!snake) return "app.attribute";
+	return `app.${snake}`;
+}
+function sanitizePrimitive(value) {
+	if (value === null || value === void 0) return void 0;
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (!trimmed) return void 0;
+		const redacted = redactSecrets(trimmed);
+		return redacted.length > MAX_STRING_VALUE ? `${redacted.slice(0, MAX_STRING_VALUE)}...` : redacted;
+	}
+	if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+	if (typeof value === "boolean") return value;
+	if (value instanceof Error) return redactSecrets(value.message);
+	try {
+		const json = JSON.stringify(value);
+		if (!json) return void 0;
+		const redacted = redactSecrets(json);
+		return redacted.length > MAX_STRING_VALUE ? `${redacted.slice(0, MAX_STRING_VALUE)}...` : redacted;
+	} catch {
+		return;
+	}
+}
+function sanitizeValue(value) {
+	if (Array.isArray(value)) {
+		const sanitized = value.filter((entry) => typeof entry === "string").map((entry) => sanitizePrimitive(entry)).filter((entry) => typeof entry === "string");
+		return sanitized.length > 0 ? sanitized : void 0;
+	}
+	return sanitizePrimitive(value);
+}
+function contextToAttributes(context) {
+	return mergeAttributes(logContextToAttributes(context));
+}
+function getTraceCorrelationAttributes() {
+	try {
+		const span = getActiveSpan();
+		if (!span) return {};
+		const json = spanToJSON(span);
+		const attrs = {};
+		if (json.trace_id) attrs.trace_id = json.trace_id;
+		if (json.span_id) attrs.span_id = json.span_id;
+		return attrs;
+	} catch {
+		return {};
+	}
+}
+function mergeAttributes(...maps) {
+	const merged = {};
+	for (const map of maps) {
+		if (!map) continue;
+		for (const [rawKey, rawValue] of Object.entries(map)) {
+			const key = normalizeAttributeKey(rawKey);
+			const value = sanitizeValue(key === "gen_ai.response.finish_reasons" ? normalizeGenAiFinishReasons(rawValue) : rawValue);
+			if (value !== void 0) merged[key] = value;
+		}
+	}
+	return merged;
+}
+function fromLogTapeLevel(level) {
+	if (level === "warning") return "warn";
+	if (level === "fatal") return "error";
+	if (level === "trace") return "debug";
+	return level;
+}
+function getLogSource(category) {
+	if (category.length <= ROOT_LOGGER_CATEGORY.length) return;
+	const sourceParts = category.slice(ROOT_LOGGER_CATEGORY.length);
+	return sourceParts.length > 0 ? sourceParts.join(".") : void 0;
+}
+function toEmittedLogRecord(record) {
+	const properties = { ...record.properties };
+	const rawBody = properties[LOGTAPE_BODY_KEY];
+	delete properties[LOGTAPE_BODY_KEY];
+	const attributes = mergeAttributes(properties);
+	const source = getLogSource(record.category);
+	if (source && attributes["app.log.source"] === void 0) attributes["app.log.source"] = source;
+	const body = toOptionalString(rawBody) ?? record.message.map((segment) => typeof segment === "string" ? segment : String(segment ?? "")).join("");
+	const eventName = toOptionalString(attributes["event.name"]) ?? "log.record.emitted";
+	return {
+		level: fromLogTapeLevel(record.level),
+		eventName,
+		body,
+		attributes
+	};
+}
+function createConsoleSink() {
+	return (record) => {
+		const emitted = toEmittedLogRecord(record);
+		emitConsole(emitted.level, emitted.eventName, emitted.body, emitted.attributes);
+	};
+}
+function createSentrySink() {
+	return (record) => {
+		const emitted = toEmittedLogRecord(record);
+		emitSentry(emitted.level, emitted.body, emitted.attributes);
+	};
+}
+function createRecordSink() {
+	return (record) => {
+		const emitted = toEmittedLogRecord(record);
+		for (const sink of logRecordSinks) try {
+			sink(emitted);
+		} catch {}
+	};
+}
+let rootLogger;
+let ownsLogTapeBackend = false;
+let usesDirectEmissionFallback = false;
+function ensureLoggerBackend() {
+	if (rootLogger || usesDirectEmissionFallback) return;
+	if (getConfig() !== null) {
+		usesDirectEmissionFallback = true;
+		return;
+	}
+	try {
+		configureSync({
+			sinks: {
+				console: createConsoleSink(),
+				sentry: createSentrySink(),
+				records: createRecordSink()
+			},
+			loggers: [{
+				category: [...ROOT_LOGGER_CATEGORY],
+				sinks: [
+					"console",
+					"sentry",
+					"records"
+				],
+				lowestLevel: "debug"
+			}, {
+				category: ["logtape"],
+				sinks: ["console"],
+				lowestLevel: "error"
+			}],
+			contextLocalStorage: logContextStorage
+		});
+		ownsLogTapeBackend = true;
+		rootLogger = getLogger([...ROOT_LOGGER_CATEGORY]);
+	} catch (error) {
+		if (error instanceof ConfigError && getConfig() !== null) {
+			usesDirectEmissionFallback = true;
+			return;
+		}
+		throw error;
+	}
+}
+function getLogTapeLogger(category = []) {
+	ensureLoggerBackend();
+	if (!rootLogger) throw new Error("LogTape backend is unavailable");
+	let logger = rootLogger;
+	for (const part of category) logger = logger.getChild(part);
+	return logger;
+}
+function emitSentry(level, body, attributes) {
+	if (shouldSuppressInfoLog(level)) return;
+	const loggerFn = logger?.[level];
+	if (typeof loggerFn === "function") {
+		loggerFn(body, attributes);
+		return;
+	}
+	const sentryLevel = level === "warn" ? "warning" : level;
+	withScope((scope) => {
+		for (const [key, value] of Object.entries(attributes)) scope.setExtra(key, value);
+		captureMessage(body, sentryLevel);
+	});
+}
+function formatConsoleLevel(level) {
+	if (level === "debug") return "DBG";
+	if (level === "info") return "INF";
+	if (level === "warn") return "WRN";
+	return "ERR";
+}
+function consoleLevelStyle(level) {
+	if (level === "error") return "red";
+	if (level === "warn") return "yellow";
+	if (level === "info") return "green";
+	return "blue";
+}
+function quoteConsoleValue(value) {
+	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function formatConsoleValue(value) {
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) return quoteConsoleValue(JSON.stringify(value));
+	if (/^[A-Za-z0-9._:/@+-]+$/.test(value)) return value;
+	return quoteConsoleValue(value);
+}
+function shouldShowConsoleDestinationName(eventName) {
+	return /^(app_home|oauth|queue|slash_command|slack|webhook)\./.test(eventName);
+}
+function shouldShowConsoleModel(level, eventName) {
+	if (level === "warn" || level === "error") return true;
+	return eventName.startsWith("ai.") || eventName.startsWith("assistant.") || eventName === "agent.turn.started" || eventName === "agent.turn.completed" || eventName === "agent.turn.provider_error";
+}
+function shouldHideConsoleAttribute(level, eventName, key, attributes) {
+	if (CONSOLE_ALWAYS_HIDDEN_KEYS.has(key)) return true;
+	if (CONSOLE_DROP_WHEN_COUNTED_KEYS.has(key)) return true;
+	if (key === "messaging.message.conversation_id" && attributes[key] === attributes["gen_ai.conversation.id"]) return true;
+	if (key === "app.message.id" && attributes[key] === attributes["messaging.message.id"]) return true;
+	if (key === "messaging.destination.name" && !shouldShowConsoleDestinationName(eventName)) return true;
+	if (key === "gen_ai.request.model" && !shouldShowConsoleModel(level, eventName)) return true;
+	if (key === "gen_ai.provider.name" && eventName.startsWith("agent.tool_call.") && level !== "warn" && level !== "error") return true;
+	if (key === "gen_ai.operation.name" && eventName.startsWith("agent.tool_call.")) return true;
+	return false;
+}
+function summarizeConsoleString(value, maxChars) {
+	const collapsed = value.replace(/\s+/g, " ").trim();
+	if (collapsed.length <= maxChars) return collapsed;
+	return `${collapsed.slice(0, maxChars)}... [${collapsed.length} chars]`;
+}
+function abbreviateConsoleId(value) {
+	if (value.length <= 20) return value;
+	return `${value.slice(0, 12)}...${value.slice(-4)}`;
+}
+function toRelativeConsolePath(value) {
+	const normalized = value.trim();
+	if (!normalized) return normalized;
+	try {
+		const relative = path.relative(process.cwd(), normalized);
+		if (relative.length > 0 && !relative.startsWith("..") && !path.isAbsolute(relative)) return relative;
+	} catch {}
+	return normalized;
+}
+function pushPrettyConsoleToken(tokens, token) {
+	if (!token || tokens.includes(token)) return;
+	tokens.push(token);
+}
+function numericConsoleToken(label, value) {
+	return typeof value === "number" ? `${label}=${value}` : void 0;
+}
+function stringConsoleToken(label, value) {
+	const normalized = toOptionalString(value);
+	return normalized ? `${label}=${normalized}` : void 0;
+}
+function booleanConsoleToken(label, value) {
+	return typeof value === "boolean" ? `${label}=${value ? "yes" : "no"}` : void 0;
+}
+function shouldShowPrettyCorrelation(eventName) {
+	return !(eventName === "plugin.loaded" || eventName === "startup.discovery.completed" || eventName.endsWith(".loaded"));
+}
+function getPrettyConsoleSummaryTokens(level, eventName, attributes) {
+	const tokens = [];
+	pushPrettyConsoleToken(tokens, toOptionalString(attributes["app.log.source"]) ?? void 0);
+	pushPrettyConsoleToken(tokens, eventName.startsWith("plugin.heartbeat.") ? stringConsoleToken("plugin", attributes["app.plugin.name"]) : toOptionalString(attributes["app.plugin.name"]) ?? void 0);
+	pushPrettyConsoleToken(tokens, numericConsoleToken("config", attributes["app.plugin.config_key_count"]));
+	pushPrettyConsoleToken(tokens, booleanConsoleToken("mcp", attributes["app.plugin.has_mcp"]));
+	pushPrettyConsoleToken(tokens, numericConsoleToken("plugins", attributes["app.plugin.count"]));
+	pushPrettyConsoleToken(tokens, numericConsoleToken("dispatches", attributes["app.dispatch.count"]));
+	pushPrettyConsoleToken(tokens, numericConsoleToken("skills", attributes["app.skill.count"]));
+	pushPrettyConsoleToken(tokens, numericConsoleToken("config", attributes["app.config.key_count"]));
+	pushPrettyConsoleToken(tokens, numericConsoleToken("chars", attributes["app.message.length"]));
+	pushPrettyConsoleToken(tokens, numericConsoleToken("attachments", attributes["app.message.attachment_count"]));
+	const rawAttachmentCount = toOptionalNumber(attributes["app.message.attachment_count"]);
+	const promptAttachmentCount = toOptionalNumber(attributes["app.message.prompt_attachment_count"]);
+	if (promptAttachmentCount !== void 0 && promptAttachmentCount !== rawAttachmentCount) pushPrettyConsoleToken(tokens, numericConsoleToken("prompt_attachments", promptAttachmentCount));
+	const filePath = toOptionalString(attributes["file.path"]);
+	if (filePath && eventName.endsWith(".loaded")) pushPrettyConsoleToken(tokens, toRelativeConsolePath(filePath));
+	if (shouldShowPrettyCorrelation(eventName)) {
+		const conversationId = toOptionalString(attributes["gen_ai.conversation.id"]);
+		const messageId = toOptionalString(attributes["messaging.message.id"]);
+		if (conversationId) pushPrettyConsoleToken(tokens, `conv=${abbreviateConsoleId(conversationId)}`);
+		if (messageId) pushPrettyConsoleToken(tokens, `msg=${abbreviateConsoleId(messageId)}`);
+	}
+	const model = toOptionalString(attributes["gen_ai.request.model"]);
+	if (model && shouldShowConsoleModel(level, eventName)) pushPrettyConsoleToken(tokens, `model=${model}`);
+	return tokens;
+}
+function projectConsoleValue(level, key, value) {
+	if ((level === "debug" || level === "info") && CONSOLE_PREVIEW_KEYS.has(key) && typeof value === "string") return summarizeConsoleString(value, key === "gen_ai.tool.call.result" ? 220 : 140);
+	return value;
+}
+function projectConsoleAttributes(level, eventName, attributes) {
+	const projected = {};
+	for (const [key, value] of Object.entries(attributes)) {
+		if (shouldHideConsoleAttribute(level, eventName, key, attributes)) continue;
+		const nextValue = projectConsoleValue(level, key, value);
+		if (nextValue !== void 0) projected[key] = nextValue;
+	}
+	return projected;
+}
+function formatConsoleLine(level, eventName, body, attributes) {
+	const timestamp = /* @__PURE__ */ new Date();
+	const useColor = shouldUseConsoleColor();
+	const levelStyle = consoleLevelStyle(level);
+	const colorize = (text, style) => useColor ? styleText(style, text) : text;
+	if (shouldUsePrettyConsole(level)) {
+		const summary = [body, ...getPrettyConsoleSummaryTokens(level, eventName, attributes)].join(" ");
+		return [
+			colorize(formatConsoleTimestamp(timestamp), "gray"),
+			colorize(formatConsoleLevel(level), levelStyle),
+			summary
+		].join(" ");
+	}
+	const parts = [`${colorize(formatConsoleTimestamp(timestamp), "gray")} ${colorize(formatConsoleLevel(level), levelStyle)} ${body}`];
+	const projectedAttributes = projectConsoleAttributes(level, eventName, attributes);
+	const sortedAttributes = Object.entries(projectedAttributes).sort(([left], [right]) => {
+		const leftRank = CONSOLE_PRIORITY_INDEX.get(left);
+		const rightRank = CONSOLE_PRIORITY_INDEX.get(right);
+		if (leftRank !== void 0 || rightRank !== void 0) {
+			if (leftRank === void 0) return 1;
+			if (rightRank === void 0) return -1;
+			return leftRank - rightRank;
+		}
+		return left.localeCompare(right);
+	});
+	for (const [key, value] of sortedAttributes) {
+		const rendered = `${colorize(key, "cyan")}=${colorize(formatConsoleValue(value), "dim")}`;
+		parts.push(rendered);
+	}
+	return parts.join(" ");
+}
+function emitConsole(level, eventName, body, attributes) {
+	if (!shouldEmitConsole(level)) return;
+	const line = formatConsoleLine(level, eventName, body, attributes);
+	if (level === "error") {
+		console.error(line);
+		return;
+	}
+	if (level === "warn") {
+		console.warn(line);
+		return;
+	}
+	if (level === "info") {
+		console.info(line);
+		return;
+	}
+	console.debug(line);
+}
+function emitDirect(level, eventName, body, attributes) {
+	for (const sink of logRecordSinks) try {
+		sink({
+			level,
+			eventName,
+			body,
+			attributes
+		});
+	} catch {}
+	emitConsole(level, eventName, body, attributes);
+	emitSentry(level, body, attributes);
+}
+function emitRecord(category, level, eventName, attrs = {}, body) {
+	ensureLoggerBackend();
+	const traceAttributes = getTraceCorrelationAttributes();
+	const normalizedEventName = normalizeEventName(eventName);
+	const message = body ? redactSecrets(body) : normalizedEventName;
+	const source = getLogSource([...ROOT_LOGGER_CATEGORY, ...category]);
+	const attributes = mergeAttributes(ownsLogTapeBackend ? void 0 : getBoundLogAttributes(), traceAttributes, {
+		"event.name": normalizedEventName,
+		...source ? { "app.log.source": source } : void 0,
+		...attrs
+	}, deploymentLogAttributes);
+	if (usesDirectEmissionFallback) {
+		emitDirect(level, normalizedEventName, message, attributes);
+		return;
+	}
+	const logger = getLogTapeLogger(category);
+	const properties = {
+		[LOGTAPE_BODY_KEY]: message,
+		...attributes
+	};
+	if (level === "error") {
+		logger.error(`{${LOGTAPE_BODY_KEY}}`, properties);
+		return;
+	}
+	if (level === "warn") {
+		logger.warn(`{${LOGTAPE_BODY_KEY}}`, properties);
+		return;
+	}
+	if (level === "info") {
+		logger.info(`{${LOGTAPE_BODY_KEY}}`, properties);
+		return;
+	}
+	logger.debug(`{${LOGTAPE_BODY_KEY}}`, properties);
+}
+function emit(level, eventName, attrs = {}, body) {
+	emitRecord([], level, eventName, attrs, body);
+}
+/**
+* Low-level adapter logger.
+*
+* Application runtime code should use the severity helpers below. This surface
+* exists for adapters that must preserve an external free-form body.
+*/
+const log = {
+	debug(eventName, attrs = {}, body) {
+		emit("debug", eventName, attrs, body);
+	},
+	info(eventName, attrs = {}, body) {
+		emit("info", eventName, attrs, body);
+	},
+	warn(eventName, attrs = {}, body) {
+		emit("warn", eventName, attrs, body);
+	},
+	error(eventName, attrs = {}, body) {
+		emit("error", eventName, attrs, body);
+	},
+	exception(eventName, error, attrs = {}, body) {
+		const normalizedError = error instanceof Error ? error : new Error(String(error));
+		emit("error", eventName, {
+			...attrs,
+			"error.type": normalizedError.name,
+			"exception.type": normalizedError.name,
+			"exception.message": normalizedError.message,
+			"exception.stacktrace": normalizedError.stack
+		}, body);
+		let eventId;
+		withScope((scope) => {
+			setSentryScopeContext(scope, getBoundLogContext());
+			const mergedAttributes = mergeAttributes(getBoundLogAttributes(), attrs);
+			for (const [key, value] of Object.entries(mergedAttributes)) {
+				scope.setExtra(key, value);
+				if (SENTRY_TAG_ATTRIBUTE_KEYS.has(key) && typeof value === "string" && value.length > 0) scope.setTag(key, value);
+			}
+			const capturedEventId = captureException(normalizedError);
+			eventId = typeof capturedEventId === "string" ? capturedEventId : void 0;
+		});
+		return eventId;
+	}
+};
+const CHAT_SDK_LEVEL_PRIORITY = {
+	debug: 10,
+	info: 20,
+	warn: 30,
+	error: 40
+};
+function resolveChatSdkLogLevel() {
+	if (isDevelopmentLoggingMode()) return "warn";
+	return "info";
+}
+function shouldEmitChatSdkLevel(level, minimumLevel) {
+	if (minimumLevel === "silent") return false;
+	return CHAT_SDK_LEVEL_PRIORITY[level] >= CHAT_SDK_LEVEL_PRIORITY[minimumLevel];
+}
+function renderChatSdkArgument(value) {
+	if (value === null || value === void 0) return "";
+	if (typeof value === "string") return value;
+	if (value instanceof Error) return value.message;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+function formatChatSdkBody(message, args) {
+	const renderedArgs = args.map((arg) => renderChatSdkArgument(arg).trim()).filter((arg) => arg.length > 0);
+	if (renderedArgs.length === 0) return message;
+	return `${message} ${renderedArgs.join(" ")}`;
+}
+function createChatSdkLoggerImpl(category, minimumLevel) {
+	const emitChatSdkLog = (level, message, args) => {
+		if (!shouldEmitChatSdkLevel(level, minimumLevel)) return;
+		emitRecord(category, level === "warn" ? "warn" : level, level === "error" ? "chat_sdk.log.error" : level === "warn" ? "chat_sdk.log.warn" : "chat_sdk.log", args.length > 0 ? { "app.log.args": args.length === 1 ? args[0] : args } : {}, formatChatSdkBody(message, args));
+	};
+	return {
+		child(prefix) {
+			return createChatSdkLoggerImpl([...category, prefix], minimumLevel);
+		},
+		debug(message, ...args) {
+			emitChatSdkLog("debug", message, args);
+		},
+		info(message, ...args) {
+			emitChatSdkLog("info", message, args);
+		},
+		warn(message, ...args) {
+			emitChatSdkLog("warn", message, args);
+		},
+		error(message, ...args) {
+			emitChatSdkLog("error", message, args);
+		}
+	};
+}
+/** Create a Chat SDK logger that routes records through Junior's logging backend. */
+function createChatSdkLogger() {
+	return createChatSdkLoggerImpl(["chat-sdk"], resolveChatSdkLogLevel());
+}
+/**
+* Run one operation with inherited correlation context.
+*
+* Call this at execution boundaries after reconstructing authoritative
+* context. Nested application logs should not receive the same context again.
+*/
+function withLogContext(context, callback) {
+	return runWithLogContext(context, contextToAttributes(context), callback);
+}
+function getLogContextAttributes() {
+	return getBoundLogAttributes();
+}
+/** Return inherited log context filtered to attributes valid for the span operation. */
+function getLogContextAttributesForSpan(op) {
+	const attributes = { ...getLogContextAttributes() };
+	if (op === "gen_ai.invoke_agent" || op === "gen_ai.execute_tool") {
+		delete attributes["gen_ai.request.model"];
+		return attributes;
+	}
+	if (op === "gen_ai.chat" || op === "gen_ai.embeddings") {
+		delete attributes["gen_ai.agent.name"];
+		delete attributes["gen_ai.request.model"];
+		return attributes;
+	}
+	delete attributes["gen_ai.agent.name"];
+	delete attributes["gen_ai.request.model"];
+	return attributes;
+}
+function createLogContextFromRequest(request, context = {}) {
+	const url = new URL(request.url);
+	return {
+		...context,
+		requestId: context.requestId ?? request.headers.get("x-request-id") ?? void 0,
+		httpMethod: request.method,
+		httpPath: url.pathname,
+		urlFull: url.toString(),
+		userAgent: request.headers.get("user-agent") ?? void 0
+	};
+}
+/** Attach filterable non-user context tags to Sentry. */
+function setSentryTagsFromContext(context) {
+	const attrs = contextToAttributes(context);
+	for (const [key, value] of Object.entries(attrs)) {
+		if (!SENTRY_TAG_ATTRIBUTE_KEYS.has(key)) continue;
+		if (typeof value === "string" && value.length > 0) setTag(key, value);
+	}
+}
+function sentryUserIdentityFromContext(context) {
+	if (context.userId) {
+		const email = normalizeIdentityEmail(context.userEmail);
+		return {
+			id: context.userId,
+			...context.userName ? { username: context.userName } : void 0,
+			...email ? { email } : void 0
+		};
+	}
+}
+function sentryUserFromIdentity(identity) {
+	return {
+		id: identity.id,
+		ip_address: null,
+		...identity.username ? { username: identity.username } : void 0,
+		...identity.email ? { email: identity.email } : void 0
+	};
+}
+/** Bind actor identity to Sentry's native user fields. */
+function setSentryUser(identity) {
+	if (!identity) return;
+	setUser(sentryUserFromIdentity(identity));
+}
+/** Attach scoped Sentry context for isolated exception capture. */
+function setSentryScopeContext(scope, context) {
+	const attrs = contextToAttributes(context);
+	for (const [key, value] of Object.entries(attrs)) {
+		if (!SENTRY_TAG_ATTRIBUTE_KEYS.has(key)) continue;
+		if (typeof value === "string" && value.length > 0) scope.setTag(key, value);
+	}
+	const identity = sentryUserIdentityFromContext(context);
+	if (identity) scope.setUser(sentryUserFromIdentity(identity));
+	scope.setContext("app", attrs);
+}
+function toSpanAttributeValue(value) {
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (!Array.isArray(value)) return;
+	const sanitized = value.filter((entry) => typeof entry === "string");
+	return sanitized.length > 0 ? sanitized : void 0;
+}
+function normalizeSpanAttributes(attributes) {
+	const normalized = {};
+	for (const [rawKey, value] of Object.entries(attributes)) {
+		const key = normalizeAttributeKey(rawKey);
+		const normalizedValue = toSpanAttributeValue(key === "gen_ai.response.finish_reasons" ? normalizeGenAiFinishReasons(value) : value);
+		if (normalizedValue !== void 0) normalized[key] = normalizedValue;
+	}
+	return normalized;
+}
+function setAttributesOnSpan(span, attributes) {
+	for (const [key, value] of Object.entries(normalizeSpanAttributes(attributes))) span.setAttribute(key, value);
+}
+/**
+* Emit an informational event with occurrence-specific attributes.
+*
+* Bind correlation context at the owning operation boundary instead of
+* passing it here.
+*/
+function logInfo(eventName, attributes = {}) {
+	log.info(eventName, attributes);
+}
+/**
+* Emit a warning event with occurrence-specific attributes.
+*
+* Bind correlation context at the owning operation boundary instead of
+* passing it here.
+*/
+function logWarn(eventName, attributes = {}) {
+	log.warn(eventName, attributes);
+}
+/**
+* Emit an error event without capturing an exception.
+*
+* Use `logException` when an actual exception instance owns the failure.
+*/
+function logError(eventName, attributes = {}) {
+	log.error(eventName, attributes);
+}
+/**
+* Emit an exception event and capture the exception with bound context.
+*
+* Exception event names should end in `.exception` when they describe a
+* generic operation exception. Existing domain failure events may retain a
+* `.failed` outcome when the event also covers non-exception failures.
+*/
+function logException(error, eventName, attributes = {}) {
+	const normalizedError = error instanceof Error ? error : new Error(String(error));
+	return log.exception(eventName, normalizedError, attributes);
+}
+/** Run an optional side effect without changing the successful primary outcome. */
+async function runBestEffort(operation, eventName, attributes = {}) {
+	try {
+		await operation();
+	} catch (error) {
+		logException(error, eventName, attributes);
+	}
+}
+/** Add context to the current operation and Sentry scope. */
+function setTags(context = {}) {
+	updateLogContext(context, contextToAttributes(context));
+	setSentryTagsFromContext(context);
+	setSentryUser(sentryUserIdentityFromContext(context));
+}
+/** Create a LogContext from an incoming HTTP request. */
+function createRequestContext(request, context = {}) {
+	return createLogContextFromRequest(request, context);
+}
+/** Run a callback within a scoped log context. */
+async function withContext(context, callback) {
+	return withLogContext(context, callback);
+}
+/** Run a callback within a Sentry span and scoped log context. */
+async function withSpan(name, op, context, callback, attributes = {}) {
+	const normalizedAttributes = normalizeSpanAttributes(attributes);
+	return withLogContext(context, () => {
+		const inheritedAttributes = getLogContextAttributesForSpan(op);
+		return startSpan({
+			name,
+			op,
+			attributes: {
+				...inheritedAttributes,
+				...normalizedAttributes
+			}
+		}, async (span) => {
+			try {
+				return await callback((attributes) => setAttributesOnSpan(span, attributes));
+			} catch (error) {
+				setAttributesOnSpan(span, { "error.type": error instanceof Error ? error.name : typeof error });
+				throw error;
+			}
+		});
+	});
+}
+/** Return Sentry-standard trace propagation headers for the active span. */
+function getTracePropagationHeaders() {
+	const traceData = getTraceData({ propagateTraceparent: true });
+	if (!traceData) return {};
+	const headers = {};
+	for (const key of [
+		"sentry-trace",
+		"baggage",
+		"traceparent"
+	]) {
+		const value = traceData[key];
+		if (typeof value === "string" && value.trim()) headers[key] = value;
+	}
+	return headers;
+}
+/** Set attributes on the currently active Sentry span. */
+function setSpanAttributes(attributes) {
+	const span = getActiveSpan();
+	if (!span) return;
+	setAttributesOnSpan(span, attributes);
+}
+/** Set the status of the currently active Sentry span. */
+function setSpanStatus(status) {
+	const span = getActiveSpan();
+	if (!span) return;
+	span.setStatus(status === "ok" ? { code: 1 } : {
+		code: 2,
+		message: "internal_error"
+	});
+}
+/** Return the trace ID from the active Sentry span, if any. */
+function getActiveTraceId() {
+	try {
+		const span = getActiveSpan();
+		if (!span) return;
+		return toOptionalString(spanToJSON(span).trace_id);
+	} catch {
+		return;
+	}
+}
+const TURN_FAILURE_RESPONSE_TEMPLATE = "I ran into an internal error while processing that. Reference: `event_id={eventId}`.";
+/** Build the static user-facing response for a failed turn. */
+function buildTurnFailureResponse(eventId) {
+	return TURN_FAILURE_RESPONSE_TEMPLATE.replace("{eventId}", eventId);
+}
+const GEN_AI_DEFAULT_MAX_ATTRIBUTE_CHARS = 1e5;
+const GEN_AI_MAX_ARRAY_ITEMS = 50;
+const GEN_AI_MAX_OBJECT_KEYS = 50;
+function truncateGenAiString(value, maxChars) {
+	return value.length > maxChars ? "" : value;
+}
+function sanitizeGenAiValue(value, seen, depth, keyName) {
+	if (value === null || value === void 0) return;
+	if (typeof value === "string") {
+		if ((keyName === "data" || keyName === "base64" || keyName?.endsWith("_base64") === true) && value.length > 256) return `[omitted:${value.length}]`;
+		return redactSecrets(value);
+	}
+	if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+	if (typeof value === "boolean") return value;
+	if (depth >= 8) return "[depth_limit]";
+	if (Array.isArray(value)) return value.slice(0, GEN_AI_MAX_ARRAY_ITEMS).map((entry) => sanitizeGenAiValue(entry, seen, depth + 1)).filter((entry) => entry !== void 0);
+	if (typeof value !== "object") return redactSecrets(String(value));
+	if (seen.has(value)) return "[circular]";
+	seen.add(value);
+	const record = value;
+	const out = {};
+	for (const [key, entryValue] of Object.entries(record).slice(0, GEN_AI_MAX_OBJECT_KEYS)) {
+		const sanitized = sanitizeGenAiValue(entryValue, seen, depth + 1, key);
+		if (sanitized !== void 0) out[key] = sanitized;
+	}
+	return out;
+}
+/** Serialize a bounded AI value, omitting it when valid JSON cannot fit. */
+function serializeGenAiAttribute(value, maxChars = GEN_AI_DEFAULT_MAX_ATTRIBUTE_CHARS) {
+	const sanitized = sanitizeGenAiValue(value, /* @__PURE__ */ new WeakSet(), 0);
+	if (sanitized === void 0) return;
+	const serialized = typeof sanitized === "string" ? sanitized : JSON.stringify(sanitized);
+	if (!serialized) return;
+	return truncateGenAiString(redactSecrets(serialized), maxChars) || void 0;
+}
+function asRecord(value) {
+	return value && typeof value === "object" ? value : void 0;
+}
+function toFiniteTokenCount(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return;
+	const rounded = Math.floor(value);
+	return rounded >= 0 ? rounded : void 0;
+}
+function toFiniteCost(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function addCost(left, right) {
+	return Math.round(((left ?? 0) + right) * 0xe8d4a51000) / 0xe8d4a51000;
+}
+function sumTokenCounts(...values) {
+	let total = 0;
+	let hasValue = false;
+	for (const value of values) {
+		if (value === void 0) continue;
+		total += value;
+		hasValue = true;
+	}
+	return hasValue ? total : void 0;
+}
+const PI_USAGE_FIELDS = [
+	["input", "inputTokens"],
+	["output", "outputTokens"],
+	["cacheRead", "cachedInputTokens"],
+	["cacheWrite", "cacheCreationTokens"],
+	["reasoning", "reasoningTokens"],
+	["totalTokens", "totalTokens"]
+];
+const PI_COST_FIELDS = [
+	"input",
+	"output",
+	"cacheRead",
+	"cacheWrite",
+	"total"
+];
+function readPiUsage(source) {
+	const record = asRecord(source);
+	if (!record) return {};
+	const usage = asRecord(record.usage) ?? record;
+	const summary = {};
+	for (const [piKey, ourKey] of PI_USAGE_FIELDS) {
+		const value = toFiniteTokenCount(usage[piKey]) ?? toFiniteTokenCount(usage[ourKey]);
+		if (value !== void 0) summary[ourKey] = value;
+	}
+	const piCost = asRecord(usage.cost);
+	if (piCost) {
+		const cost = {};
+		for (const field of PI_COST_FIELDS) {
+			const value = toFiniteCost(piCost[field]);
+			if (value !== void 0) cost[field] = value;
+		}
+		if (Object.keys(cost).length > 0) summary.cost = cost;
+	}
+	return summary;
+}
+/**
+* Sum pi-ai `Usage` counters across every source into an `AgentTurnUsage`.
+*
+* Callers pass every assistant message produced during a turn so the result
+* reflects the aggregate usage for the entire turn rather than a single model
+* call. Sources without a recognized usage record contribute nothing.
+*/
+function extractGenAiUsageSummary(...sources) {
+	const summary = {};
+	const cost = {};
+	for (const source of sources) {
+		const single = readPiUsage(source);
+		for (const field of [
+			"inputTokens",
+			"outputTokens",
+			"cachedInputTokens",
+			"cacheCreationTokens",
+			"reasoningTokens",
+			"totalTokens"
+		]) {
+			const value = single[field];
+			if (value === void 0) continue;
+			summary[field] = (summary[field] ?? 0) + value;
+		}
+		for (const field of PI_COST_FIELDS) {
+			const value = single.cost?.[field];
+			if (value === void 0) continue;
+			cost[field] = addCost(cost[field], value);
+		}
+	}
+	if (Object.keys(cost).length > 0) summary.cost = cost;
+	return summary;
+}
+/** Extract GenAI token and estimated USD cost attributes for tracing. */
+function extractGenAiUsageAttributes(...sources) {
+	const { inputTokens, outputTokens, cachedInputTokens, cacheCreationTokens, reasoningTokens, cost } = extractGenAiUsageSummary(...sources);
+	const semanticInputTokens = sumTokenCounts(inputTokens, cachedInputTokens, cacheCreationTokens);
+	return {
+		...semanticInputTokens !== void 0 ? { "gen_ai.usage.input_tokens": semanticInputTokens } : void 0,
+		...outputTokens !== void 0 ? { "gen_ai.usage.output_tokens": outputTokens } : void 0,
+		...cachedInputTokens !== void 0 ? { "gen_ai.usage.cache_read.input_tokens": cachedInputTokens } : void 0,
+		...cacheCreationTokens !== void 0 ? { "gen_ai.usage.cache_creation.input_tokens": cacheCreationTokens } : void 0,
+		...reasoningTokens !== void 0 ? { "gen_ai.usage.reasoning.output_tokens": reasoningTokens } : void 0,
+		...cost?.input !== void 0 ? { "app.cost.input_usd": cost.input } : void 0,
+		...cost?.output !== void 0 ? { "app.cost.output_usd": cost.output } : void 0,
+		...cost?.cacheRead !== void 0 ? { "app.cost.cache_read_usd": cost.cacheRead } : void 0,
+		...cost?.cacheWrite !== void 0 ? { "app.cost.cache_write_usd": cost.cacheWrite } : void 0,
+		...cost?.total !== void 0 ? { "app.cost.total_usd": cost.total } : void 0
+	};
+}
+//#endregion
+export { JUNIOR_WORKSPACE_SNAPSHOT_JOB_CALLBACK_ROUTE as A, withSpan as C, JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE as D, JUNIOR_HEARTBEAT_ROUTE as E, isRecord as F, toOptionalNumber as I, toOptionalString as L, getDeploymentServiceVersion as M, getDeploymentTelemetryAttributes as N, JUNIOR_RETENTION_CRON_SCHEDULE as O, normalizeIdentityEmail as P, withLogContext as S, JUNIOR_HEARTBEAT_CRON_SCHEDULE as T, setSpanAttributes as _, extractGenAiUsageSummary as a, summarizeMessageText as b, getTracePropagationHeaders as c, logInfo as d, logWarn as f, setSentryUser as g, serializeGenAiAttribute as h, extractGenAiUsageAttributes as i, LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION as j, JUNIOR_RETENTION_ROUTE as k, logError as l, runBestEffort as m, createChatSdkLogger as n, getActiveTraceId as o, normalizeGenAiFinishReason as p, createRequestContext as r, getLogContextAttributesForSpan as s, buildTurnFailureResponse as t, logException as u, setSpanStatus as v, JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE as w, withContext as x, setTags as y };