@sentry/junior 0.203.0 → 0.204.0

package/dist/pending-auth-CWmSdZVg.js

@@ -0,0 +1,185 @@
+import { i as abandonTurnRecord, yt as extractAssistantText } from "./checkpoint-CNrPyRJN.js";
+import { Gt as buildDeterministicTurnId } from "./stats-DTUbAb88.js";
+//#region src/chat/runtime/turn.ts
+/** Classified Slack turn failure carrying the owning Sentry capture outward. */
+var ConversationTurnBoundaryError = class extends Error {
+	eventId;
+	failureCode;
+	constructor(args) {
+		super(args.cause instanceof Error ? args.cause.message : String(args.cause), { cause: args.cause });
+		this.name = "ConversationTurnBoundaryError";
+		this.eventId = args.eventId;
+		this.failureCode = args.failureCode;
+	}
+};
+/** Return a classified Slack boundary failure without erasing its cause. */
+function getConversationTurnBoundaryError(error) {
+	return error instanceof ConversationTurnBoundaryError ? error : void 0;
+}
+/**
+* Queue-worker yield routing: respond.ts returns a suspended AgentRunOutcome
+* and the Slack executor raises this at the worker boundary so the lease owner
+* requeues the conversation.
+*/
+var CooperativeTurnYieldError = class extends Error {
+	code = "cooperative_turn_yield";
+	constructor(message = "Agent turn yielded at a safe boundary") {
+		super(message);
+		this.name = "CooperativeTurnYieldError";
+	}
+};
+function isCooperativeTurnYieldError(error) {
+	return error instanceof CooperativeTurnYieldError;
+}
+/** Error indicating durable turn input could not be committed by the worker owner. */
+var TurnInputCommitLostError = class extends Error {
+	code = "turn_input_commit_lost";
+	constructor(message = "Turn input commit lost its durable owner") {
+		super(message);
+		this.name = "TurnInputCommitLostError";
+	}
+};
+/** Return whether an error means the durable worker lost input ownership. */
+function isTurnInputCommitLostError(error) {
+	return error instanceof TurnInputCommitLostError;
+}
+/** Error indicating durable turn input should stay pending for a later worker. */
+var TurnInputDeferredError = class extends Error {
+	code = "turn_input_deferred";
+	constructor(message = "Turn input is deferred until the active resume ends") {
+		super(message);
+		this.name = "TurnInputDeferredError";
+	}
+};
+/** Return whether an error means the durable worker should redeliver input later. */
+function isTurnInputDeferredError(error) {
+	return error instanceof TurnInputDeferredError;
+}
+/** Mark a turn as the active turn in conversation state. */
+function startActiveTurn(args) {
+	args.conversation.processing.activeTurnId = args.nextTurnId;
+}
+function clearActiveTurn(conversation, sessionId) {
+	if (!sessionId || conversation.processing.activeTurnId === sessionId) conversation.processing.activeTurnId = void 0;
+}
+/**
+* Close the active turn without marking a Pi session reusable for future
+* history. Use this for auth handoffs and recovery replies that end the live
+* turn but do not produce a completed Pi session.
+*/
+function markTurnClosed(args) {
+	clearActiveTurn(args.conversation, args.sessionId);
+	args.conversation.processing.lastCompletedAtMs = args.nowMs;
+}
+/**
+* Mark a turn as completed after its assistant output has been handled.
+*/
+function markTurnCompleted(args) {
+	clearActiveTurn(args.conversation, args.sessionId);
+	args.conversation.processing.lastCompletedAtMs = args.nowMs;
+}
+/**
+* Mark a turn as failed when execution or final user-visible reply delivery
+* cannot be completed. If `sessionId` is provided, `activeTurnId` is only
+* cleared when it still matches the failing turn.
+*/
+function markTurnFailed(args) {
+	clearActiveTurn(args.conversation, args.sessionId);
+	args.conversation.processing.lastCompletedAtMs = args.nowMs;
+	args.markConversationMessage(args.conversation, args.userMessageId, {
+		replied: false,
+		skippedReason: "reply failed"
+	});
+}
+//#endregion
+//#region src/chat/no-reply.ts
+const NO_REPLY_MARKER = "[[NO_REPLY]]";
+/**
+* True when one assistant message ends with the silence marker.
+* Mid-sentence mentions do not match. Detection is per message only.
+*/
+function isNoReplyMarker(text) {
+	return text.trimEnd().endsWith(NO_REPLY_MARKER);
+}
+//#endregion
+//#region src/chat/services/assistant-reply.ts
+const THINKING_XML_BLOCK_PATTERN = /[ \t]*<thinking\b[^>]*>[\s\S]*?<\/thinking>[ \t]*(?:\r?\n)?/gi;
+const FENCED_CODE_BLOCK_PATTERN = /```[\s\S]*?```/g;
+/** Remove provider reasoning wrappers while preserving fenced code examples. */
+function sanitizeAssistantText(text) {
+	let result = "";
+	let cursor = 0;
+	for (const match of text.matchAll(FENCED_CODE_BLOCK_PATTERN)) {
+		const start = match.index;
+		if (start === void 0) continue;
+		result += text.slice(cursor, start).replace(THINKING_XML_BLOCK_PATTERN, "");
+		result += match[0];
+		cursor = start + match[0].length;
+	}
+	return (result + text.slice(cursor).replace(THINKING_XML_BLOCK_PATTERN, "")).trim();
+}
+/** Decide whether one completed assistant message becomes a reply. */
+function decideReply(message) {
+	if (message.content.some((part) => part.type === "toolCall")) return { kind: "suppress" };
+	const text = sanitizeAssistantText(extractAssistantText(message));
+	if (!text) return { kind: "empty" };
+	if (isNoReplyMarker(text)) return { kind: "suppress" };
+	return {
+		kind: "deliver",
+		text
+	};
+}
+/** Return destination-visible reply text when the message is deliverable. */
+function getAssistantReplyText(message) {
+	const decision = decideReply(message);
+	return decision.kind === "deliver" ? decision.text : void 0;
+}
+//#endregion
+//#region src/chat/services/pending-auth.ts
+const AUTH_LINK_REUSE_WINDOW_MS = 6e5;
+const NON_REQUEST_SKIPPED_REASON_PREFIXES = ["directed_to_other_party:", "side_conversation:"];
+function isSkippedNonRequest(reason) {
+	return NON_REQUEST_SKIPPED_REASON_PREFIXES.some((prefix) => reason?.startsWith(prefix));
+}
+/** Decide whether the same agent-run session can reuse its fresh auth link. */
+function canReusePendingAuthLink(args) {
+	const { pendingAuth } = args;
+	if (!pendingAuth) return false;
+	return pendingAuth.kind === args.kind && pendingAuth.provider === args.provider && pendingAuth.actorId === args.actorId && pendingAuth.scope === args.scope && pendingAuth.sessionId === args.sessionId && pendingAuth.linkSentAtMs + AUTH_LINK_REUSE_WINDOW_MS > (args.nowMs ?? Date.now());
+}
+function getConversationPendingAuth(args) {
+	const pendingAuth = args.conversation.processing.pendingAuth;
+	if (!pendingAuth) return;
+	if (pendingAuth.kind !== args.kind || pendingAuth.provider !== args.provider || pendingAuth.actorId !== args.actorId || pendingAuth.scope !== args.scope) return;
+	return pendingAuth;
+}
+function clearPendingAuth(conversation, sessionId) {
+	if (!conversation.processing.pendingAuth) return;
+	if (sessionId && conversation.processing.pendingAuth.sessionId !== sessionId) return;
+	conversation.processing.pendingAuth = void 0;
+}
+/** Mark the prior blocked turn abandoned after a new auth attempt replaces it. */
+async function abandonReplacedPendingAuth(args) {
+	if (args.previousPendingAuth && args.previousPendingAuth.sessionId !== args.nextPendingAuth.sessionId && args.conversationId) await abandonTurnRecord({
+		conversationId: args.conversationId,
+		turnId: args.previousPendingAuth.sessionId,
+		errorMessage: "Abandoned by a newer auth-blocked request in the same conversation."
+	});
+}
+/**
+* Decide whether an auth callback still belongs to the latest real human
+* request, ignoring bot-authored and passive bystander rows while treating
+* failed human turns and opt-outs as newer freshness blockers.
+*/
+function isPendingAuthLatestRequest(conversation, pendingAuth) {
+	for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
+		const message = conversation.messages[index];
+		if (message?.role !== "user") continue;
+		if (message.author?.isBot) continue;
+		if (isSkippedNonRequest(message.meta?.skippedReason)) continue;
+		return buildDeterministicTurnId(message.id) === pendingAuth.sessionId;
+	}
+	return false;
+}
+//#endregion
+export { startActiveTurn as S, isTurnInputCommitLostError as _, isPendingAuthLatestRequest as a, markTurnCompleted as b, sanitizeAssistantText as c, ConversationTurnBoundaryError as d, CooperativeTurnYieldError as f, isCooperativeTurnYieldError as g, getConversationTurnBoundaryError as h, getConversationPendingAuth as i, NO_REPLY_MARKER as l, TurnInputDeferredError as m, canReusePendingAuthLink as n, decideReply as o, TurnInputCommitLostError as p, clearPendingAuth as r, getAssistantReplyText as s, abandonReplacedPendingAuth as t, isNoReplyMarker as u, isTurnInputDeferredError as v, markTurnFailed as x, markTurnClosed as y };

package/dist/plugin-module-BKGOXca2.js

@@ -0,0 +1,81 @@
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import path from "node:path";
+import { statSync } from "node:fs";
+//#region src/plugin-module.ts
+const PLUGIN_MODULE_EXTENSIONS = [
+	"",
+	".ts",
+	".tsx",
+	".mts",
+	".mjs",
+	".js",
+	".cjs"
+];
+/** Resolve a relative plugin module path using Junior's supported extension order. */
+function resolveRelativePluginModule(cwd, specifier) {
+	const basePath = path.resolve(cwd, specifier);
+	for (const extension of PLUGIN_MODULE_EXTENSIONS) {
+		const candidate = `${basePath}${extension}`;
+		try {
+			if (statSync(candidate).isFile()) return candidate;
+		} catch {}
+	}
+	for (const extension of PLUGIN_MODULE_EXTENSIONS) {
+		const candidate = path.join(basePath, `index${extension}`);
+		try {
+			if (statSync(candidate).isFile()) return candidate;
+		} catch {}
+	}
+	throw new Error(`Plugin module "${specifier}" could not be resolved`);
+}
+/** Resolve the runtime-safe plugin module used by Junior app wiring. */
+function resolvePluginModule(cwd, input) {
+	const moduleSpecifier = typeof input === "string" ? input : input.module;
+	const exportName = typeof input === "string" ? "plugins" : input.exportName ?? "plugins";
+	if (!moduleSpecifier.trim()) throw new Error("Plugin module specifier must not be empty");
+	if (moduleSpecifier.startsWith(".") || path.isAbsolute(moduleSpecifier)) {
+		const resolvedPath = resolveRelativePluginModule(cwd, moduleSpecifier);
+		return {
+			exportName,
+			importPath: resolvedPath,
+			importUrl: pathToFileURL(resolvedPath).href,
+			kind: "file",
+			sourceSpecifier: moduleSpecifier
+		};
+	}
+	const resolvedPath = createRequire(path.join(cwd, "package.json")).resolve(moduleSpecifier);
+	return {
+		exportName,
+		importPath: resolvedPath,
+		importUrl: pathToFileURL(resolvedPath).href,
+		kind: "package",
+		sourceSpecifier: moduleSpecifier
+	};
+}
+/** Assert that a module export is a Junior plugin set. */
+function assertPluginSet(value, source) {
+	if (!value || typeof value !== "object" || !Array.isArray(value.packageNames) || !Array.isArray(value.registrations)) throw new Error(`Plugin module ${source} must export a defineJuniorPlugins(...) set`);
+	const pluginSet = value;
+	if (pluginSet.packageNames?.find((packageName) => typeof packageName !== "string") !== void 0) throw new Error(`Plugin module ${source} must export string package names`);
+	if (pluginSet.registrations?.find((registration) => !registration || typeof registration !== "object" || !("manifest" in registration) || !registration.manifest || typeof registration.manifest !== "object" || !("name" in registration.manifest) || typeof registration.manifest.name !== "string")) throw new Error(`Plugin module ${source} must export plugin registrations with manifest names`);
+	return value;
+}
+/** Load a resolved plugin module and return its configured plugin set. */
+async function loadPluginSetFromModule(moduleRef, importModule = async (ref) => await import(ref.importUrl)) {
+	const mod = await importModule(moduleRef);
+	return assertPluginSet(moduleRef.exportName === "default" ? mod.default : mod[moduleRef.exportName], `${moduleRef.importUrl}#${moduleRef.exportName}`);
+}
+/** Load an app-local `./plugins` module when one exists. */
+async function loadAppPluginSet(cwd, importModule) {
+	let pluginModule;
+	try {
+		pluginModule = resolvePluginModule(cwd, "./plugins");
+	} catch (error) {
+		if (error instanceof Error && error.message === "Plugin module \"./plugins\" could not be resolved") return;
+		throw error;
+	}
+	return await loadPluginSetFromModule(pluginModule, importModule);
+}
+//#endregion
+export { loadPluginSetFromModule as n, resolvePluginModule as r, loadAppPluginSet as t };

package/dist/plugins-BI9A1vKA.d.ts

@@ -0,0 +1,95 @@
+import { PluginRegistration, PluginRuntimePostinstallCommand } from "@sentry/junior-plugin-api";
+//#region src/chat/plugins/types.d.ts
+interface PluginOAuthConfig {
+  clientIdEnv: string;
+  clientSecretEnv: string;
+  authorizeEndpoint: string;
+  tokenEndpoint: string;
+  scope?: string;
+  /**
+   * Set true when the provider returns an empty scope string even for authorized
+   * grants (e.g. GitHub App user-to-server tokens always return `scope: ""`
+   * regardless of what was requested). When enabled, an empty response scope
+   * uses the configured `scope` value instead of being treated as
+   * "no scopes granted".
+   */
+  treatEmptyScopeAsUnreported?: boolean;
+  authorizeParams?: Record<string, string>;
+  tokenAuthMethod?: "body" | "basic";
+  tokenExtraHeaders?: Record<string, string>;
+}
+interface PluginEnvVarDeclaration {
+  default?: string;
+  exposeToCommandEnv?: boolean;
+}
+type PluginRuntimeDependencyConfig = {
+  type: "npm";
+  package: string;
+  version?: string;
+} | {
+  type: "system";
+  package: string;
+} | {
+  type: "system";
+  url: string;
+  sha256: string;
+};
+interface PluginOAuthConfigPatch extends Omit<Partial<PluginOAuthConfig>, "authorizeParams" | "tokenExtraHeaders"> {
+  authorizeParams?: Record<string, string | null> | null;
+  tokenExtraHeaders?: Record<string, string | null> | null;
+}
+type PluginCredentialConfigBase = {
+  domains?: string[];
+  authTokenEnv?: string;
+  authTokenPlaceholder?: string | null;
+};
+type PluginCredentialConfig = PluginCredentialConfigBase & {
+  apiHeaders?: Record<string, string | null> | null;
+  type?: "oauth-bearer";
+};
+/** Install-level changes applied to one plugin manifest before validation. */
+interface PluginManifestConfig {
+  displayName?: string;
+  description?: string;
+  configKeys?: string[];
+  domains?: string[] | null;
+  apiHeaders?: Record<string, string | null> | null;
+  commandEnv?: Record<string, string | null> | null;
+  envVars?: Record<string, PluginEnvVarDeclaration | null> | null;
+  credentials?: PluginCredentialConfig | null;
+  runtimeDependencies?: PluginRuntimeDependencyConfig[] | null;
+  runtimePostinstall?: PluginRuntimePostinstallCommand[] | null;
+  mcp?: {
+    transport?: "http";
+    url?: string;
+    headers?: Record<string, string | null> | null;
+    allowedTools?: string[] | null;
+    wrappedTools?: string[] | null;
+  } | null;
+  oauth?: PluginOAuthConfigPatch | null;
+  target?: {
+    type?: string;
+    configKey?: string;
+    commandFlags?: string[] | null;
+  } | null;
+}
+//#endregion
+//#region src/plugins.d.ts
+type JuniorPluginInput = PluginRegistration | string;
+interface JuniorPluginSetOptions {
+  /** Install-level manifest overrides applied before validation. */
+  manifests?: Record<string, PluginManifestConfig>;
+}
+/** Reusable plugin registrations and manifest overrides. */
+interface JuniorPluginSet {
+  /** Install-level manifest overrides applied before validation. */
+  manifests?: Record<string, PluginManifestConfig>;
+  /** Manifest-only plugin packages included by package name. */
+  packageNames: string[];
+  /** JavaScript plugin definitions included by package factories. */
+  registrations: PluginRegistration[];
+}
+/** Define package-name plugins and JS plugin definitions for one app. */
+declare function defineJuniorPlugins(inputs: JuniorPluginInput[], options?: JuniorPluginSetOptions): JuniorPluginSet;
+//#endregion
+export { defineJuniorPlugins as i, JuniorPluginSet as n, JuniorPluginSetOptions as r, JuniorPluginInput as t };

package/dist/plugins-egKWjgue.js

@@ -0,0 +1,99 @@
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
+//#region src/plugins.ts
+var plugins_exports = /* @__PURE__ */ __exportAll({
+	defineJuniorPlugins: () => defineJuniorPlugins,
+	pluginCatalogConfigFromEnv: () => pluginCatalogConfigFromEnv,
+	pluginCatalogConfigFromPluginSet: () => pluginCatalogConfigFromPluginSet,
+	pluginCliRegistrationsFromPluginSet: () => pluginCliRegistrationsFromPluginSet,
+	pluginRuntimeRegistrationsFromPluginSet: () => pluginRuntimeRegistrationsFromPluginSet
+});
+function cloneManifests(manifests) {
+	return manifests ? structuredClone(manifests) : void 0;
+}
+function cloneInlineManifests(registrations) {
+	const inlineManifests = registrations.flatMap((plugin) => plugin.manifest ? [{
+		manifest: {
+			...structuredClone(plugin.manifest),
+			configKeys: plugin.manifest.configKeys?.map((key) => key.includes(".") ? key : `${plugin.manifest.name}.${key}`) ?? [],
+			...plugin.manifest.target ? { target: {
+				...plugin.manifest.target,
+				configKey: plugin.manifest.target.configKey.includes(".") ? plugin.manifest.target.configKey : `${plugin.manifest.name}.${plugin.manifest.target.configKey}`
+			} } : void 0
+		},
+		...plugin.packageName ? { packageName: plugin.packageName } : void 0
+	}] : []);
+	return inlineManifests.length > 0 ? inlineManifests : void 0;
+}
+function assertUniquePluginNames(registrations) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const plugin of registrations) {
+		const name = plugin.manifest.name;
+		if (seen.has(name)) throw new Error(`Duplicate plugin registration name "${name}"`);
+		seen.add(name);
+	}
+}
+function assertUniquePackageNames(packageNames) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const packageName of packageNames) {
+		if (seen.has(packageName)) throw new Error(`Duplicate plugin package name "${packageName}"`);
+		seen.add(packageName);
+	}
+}
+function normalizePluginInput(input) {
+	if (typeof input === "string") return { packageName: input };
+	return { registration: input };
+}
+/** Define package-name plugins and JS plugin definitions for one app. */
+function defineJuniorPlugins(inputs, options = {}) {
+	const normalized = inputs.map(normalizePluginInput);
+	const packageNames = normalized.flatMap((input) => input.packageName ? [input.packageName] : []);
+	const registrations = normalized.flatMap((input) => input.registration ? [input.registration] : []);
+	assertUniquePackageNames(packageNames);
+	assertUniquePluginNames(registrations);
+	const manifests = cloneManifests(options.manifests);
+	return {
+		packageNames,
+		registrations: registrations.map((plugin) => ({ ...plugin })),
+		...manifests ? { manifests } : void 0
+	};
+}
+/** Build the manifest catalog config implied by one plugin set. */
+function pluginCatalogConfigFromPluginSet(pluginSet) {
+	if (!pluginSet) return;
+	const packages = [.../* @__PURE__ */ new Set([...pluginSet.packageNames, ...pluginSet.registrations.flatMap((plugin) => plugin.packageName ? [plugin.packageName] : [])])];
+	const manifests = cloneManifests(pluginSet.manifests);
+	const inlineManifests = cloneInlineManifests(pluginSet.registrations);
+	if (packages.length === 0 && !manifests && !inlineManifests) return;
+	return {
+		...inlineManifests ? { inlineManifests } : void 0,
+		...packages.length > 0 ? { packages } : void 0,
+		...manifests ? { manifests } : void 0
+	};
+}
+function readEnvPluginPackages(env = process.env) {
+	const value = env.JUNIOR_PLUGIN_PACKAGES;
+	if (!value) return;
+	let parsed;
+	try {
+		parsed = JSON.parse(value);
+	} catch (error) {
+		throw new Error("JUNIOR_PLUGIN_PACKAGES must be valid JSON", { cause: error });
+	}
+	if (!Array.isArray(parsed) || parsed.some((item) => typeof item !== "string" || !item.trim())) throw new Error("JUNIOR_PLUGIN_PACKAGES must be a JSON array of package names");
+	return parsed;
+}
+/** Build the manifest catalog config implied by plugin package env. */
+function pluginCatalogConfigFromEnv(env = process.env) {
+	const packages = readEnvPluginPackages(env);
+	return packages ? { packages } : void 0;
+}
+/** Return registrations that expose in-process runtime code. */
+function pluginRuntimeRegistrationsFromPluginSet(pluginSet) {
+	return pluginSet?.registrations.filter((plugin) => plugin.hooks || plugin.tasks || plugin.userPages?.length) ?? [];
+}
+/** Return registrations that expose host CLI commands. */
+function pluginCliRegistrationsFromPluginSet(pluginSet) {
+	return pluginSet?.registrations.filter((plugin) => plugin.cli) ?? [];
+}
+//#endregion
+export { pluginRuntimeRegistrationsFromPluginSet as a, pluginCliRegistrationsFromPluginSet as i, pluginCatalogConfigFromEnv as n, plugins_exports as o, pluginCatalogConfigFromPluginSet as r, defineJuniorPlugins as t };

package/dist/private-trace-result-BLvBjy_e.js

@@ -0,0 +1,16 @@
+import { randomUUID } from "node:crypto";
+//#region src/chat/tool-support/private-trace-result.ts
+const PRIVATE_TRACE_RESULT_ATTRIBUTE = "gen_ai.tool.call.result.exposure";
+const privateTraceResultToken = randomUUID();
+/** Mark one tool result as an adapter-approved private trace projection. */
+function privateTraceResultAttributes() {
+	return { [PRIVATE_TRACE_RESULT_ATTRIBUTE]: privateTraceResultToken };
+}
+/** Consume and remove the adapter-owned private trace projection marker. */
+function consumePrivateTraceResultMarker(attributes) {
+	const projected = attributes[PRIVATE_TRACE_RESULT_ATTRIBUTE] === privateTraceResultToken;
+	delete attributes[PRIVATE_TRACE_RESULT_ATTRIBUTE];
+	return projected;
+}
+//#endregion
+export { privateTraceResultAttributes as n, consumePrivateTraceResultMarker as t };