@sentry/junior 0.204.0 → 0.206.0

package/migrations/meta/_journal.json

@@ -281,6 +281,13 @@
       "when": 1788535952747,
       "tag": "0039_attachment_provider",
       "breakpoints": true
+    },
+    {
+      "idx": 40,
+      "version": "7",
+      "when": 1788952455016,
+      "tag": "0040_conversation_briefs",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.204.0",
+  "version": "0.206.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -85,7 +85,7 @@
     "pg": "^8.16.3",
     "yaml": "^2.9.0",
     "zod": "^4.5.4",
-    "@sentry/junior-plugin-api": "0.204.0"
+    "@sentry/junior-plugin-api": "0.206.0"
   },
   "devDependencies": {
     "@emnapi/core": "^1.10.0",
@@ -104,8 +104,8 @@
     "typescript": "^6.0.3",
     "vercel": "^54.4.0",
     "vitest": "^4.1.7",
-    "@sentry/junior-github": "0.204.0",
-    "@sentry/junior-memory": "0.204.0",
+    "@sentry/junior-github": "0.206.0",
+    "@sentry/junior-memory": "0.206.0",
     "@sentry/junior-testing": "0.0.0"
   },
   "scripts": {

package/dist/history-CqTuSAdI.js

@@ -1,441 +0,0 @@
-import { c as TURN_REASONING_LEVELS, o as modelProfileSchema } from "./model-profile-CZmVoGdX.js";
-import { z } from "zod";
-import { actorSchema } from "@sentry/junior-plugin-api";
-//#region src/chat/conversations/provenance.ts
-/**
-* Durable message attribution shared by storage and projections.
-* Attribution never grants credential authority.
-*/
-const conversationMessageAuthoritySchema = z.union([z.literal("instruction"), z.literal("context")]);
-/** Canonical authority and actor metadata for one durable message event. */
-const conversationMessageProvenanceSchema = z.object({
-	authority: conversationMessageAuthoritySchema,
-	actor: actorSchema.optional()
-}).strict();
-/** Build instruction provenance for an optional actor. */
-function instructionProvenanceFor(actor) {
-	return actor ? {
-		authority: "instruction",
-		actor
-	} : { authority: "instruction" };
-}
-/** Unattributed ambient-context provenance for non-instruction messages. */
-const contextProvenance = { authority: "context" };
-function actorIdentityKey(actor) {
-	if (actor.platform === "system") return `system ${actor.name}`;
-	return actor.platform === "slack" ? `slack\u0000${actor.teamId}\u0000${actor.userId}` : `${actor.platform}\u0000${actor.userId}`;
-}
-/** Compare two actors by runtime identity only, never by display metadata. */
-function sameActorIdentity(left, right) {
-	return Boolean(left && right && actorIdentityKey(left) === actorIdentityKey(right));
-}
-/**
-* Return distinct instruction actors in first-seen order for attribution only.
-* Never use this list as credential authority.
-*/
-function instructionActors(provenance) {
-	const seen = /* @__PURE__ */ new Set();
-	const actors = [];
-	for (const entry of provenance) {
-		if (entry.authority !== "instruction" || !entry.actor) continue;
-		const identity = actorIdentityKey(entry.actor);
-		if (seen.has(identity)) continue;
-		seen.add(identity);
-		actors.push(entry.actor);
-	}
-	return actors;
-}
-//#endregion
-//#region src/chat/conversations/history.ts
-/**
-* Durable conversation event history port.
-*
-* Events append under the conversation lease in stable sequence order.
-* Compaction and handoff replace the active model history without rewriting
-* prior events. Unsupported stored events remain readable as opaque facts,
-* while malformed known events fail loudly. Provider-specific message fields
-* are validated by the Pi adapter when it restores model context.
-*/
-const userMessageEventDataSchema = z.object({
-	type: z.literal("user_message"),
-	role: z.never().optional(),
-	provenance: conversationMessageProvenanceSchema
-}).passthrough();
-const assistantMessageEventDataSchema = z.object({
-	type: z.literal("assistant_message"),
-	role: z.never().optional()
-}).passthrough();
-const toolResultEventDataSchema = z.object({
-	type: z.literal("tool_result"),
-	role: z.never().optional()
-}).passthrough();
-/**
-* One replayable agent-history item. Junior owns `type` and user provenance,
-* forbids the provider `role` discriminator, and leaves preserved message
-* fields for the Pi adapter to validate when restoring model context.
-*/
-const agentHistoryItemSchema = z.discriminatedUnion("type", [
-	userMessageEventDataSchema,
-	assistantMessageEventDataSchema,
-	toolResultEventDataSchema
-]);
-const nativeReplacementHistoryItemSchema = z.object({
-	item: agentHistoryItemSchema,
-	sourceEventSeq: z.number().int().nonnegative().optional()
-}).strict();
-/**
-* The complete agent history used immediately after a replacement. Later
-* native history events append to it. Replacement entries are replayed model
-* history, not new conversation activity.
-*/
-const replacementHistorySchema = z.array(nativeReplacementHistoryItemSchema);
-const compactionDetailsSchema = z.object({
-	reason: z.literal("capacity"),
-	estimatedInputTokens: z.number().int().nonnegative(),
-	replacementInputTokens: z.number().int().nonnegative().optional(),
-	triggerTokens: z.number().int().nonnegative(),
-	inputLimitTokens: z.number().int().positive(),
-	inputMessageCount: z.number().int().nonnegative(),
-	retainedMessageCount: z.number().int().nonnegative(),
-	summaryChars: z.number().int().nonnegative()
-}).strict();
-const historyReplacementEventDataSchema = z.discriminatedUnion("type", [z.object({
-	type: z.literal("handoff"),
-	modelProfile: modelProfileSchema,
-	modelId: z.string().min(1),
-	reasoningLevel: z.string().min(1).optional(),
-	triggeringToolCallId: z.string().min(1).optional(),
-	summary: z.string().min(1).optional(),
-	replacementHistory: replacementHistorySchema
-}).strict(), z.object({
-	type: z.literal("compaction"),
-	modelProfile: modelProfileSchema,
-	modelId: z.string().min(1),
-	details: compactionDetailsSchema.optional(),
-	summary: z.string().min(1).optional(),
-	replacementHistory: replacementHistorySchema
-}).strict()]);
-/** Validate an event that intentionally replaces active model history. */
-const historyReplacementSchema = z.object({
-	data: historyReplacementEventDataSchema,
-	createdAtMs: z.number().finite()
-}).strict();
-const mcpProviderConnectedEventDataSchema = z.object({
-	type: z.literal("mcp_provider_connected"),
-	provider: z.string().min(1),
-	credentialSubjectId: z.string().min(1)
-}).strict();
-const unownedMcpProviderConnectedEventDataSchema = z.object({
-	type: z.literal("mcp_provider_connected_unowned"),
-	provider: z.string().min(1)
-}).strict();
-const authorizationKindSchema = z.union([z.literal("plugin"), z.literal("mcp")]);
-const authorizationRequestedEventDataSchema = z.object({
-	type: z.literal("authorization_requested"),
-	kind: authorizationKindSchema,
-	provider: z.string().min(1),
-	actorId: z.string().min(1),
-	authorizationId: z.string().min(1),
-	delivery: z.union([z.literal("private_link_sent"), z.literal("private_link_reused")])
-}).strict();
-const authorizationCompletedEventDataSchema = z.object({
-	type: z.literal("authorization_completed"),
-	kind: authorizationKindSchema,
-	provider: z.string().min(1),
-	actorId: z.string().min(1),
-	authorizationId: z.string().min(1)
-}).strict();
-const toolExecutionStartedEventDataSchema = z.object({
-	type: z.literal("tool_execution_started"),
-	toolCallId: z.string().min(1),
-	toolName: z.string().min(1)
-}).strict();
-const guardianActionReviewedEventDataSchema = z.object({
-	type: z.literal("guardian_action_reviewed"),
-	turnId: z.string().min(1),
-	toolCallId: z.string().min(1),
-	toolName: z.string().min(1),
-	costUsd: z.number().finite().nonnegative().optional(),
-	decision: z.enum([
-		"allow",
-		"ask",
-		"deny"
-	]),
-	riskLevel: z.enum([
-		"low",
-		"medium",
-		"high",
-		"critical"
-	]),
-	userAuthorization: z.enum([
-		"high",
-		"medium",
-		"low",
-		"unknown"
-	])
-}).strict();
-const conversationMessageRoleSchema = z.union([
-	z.literal("user"),
-	z.literal("assistant"),
-	z.literal("system")
-]);
-const messageEventDataSchema = z.object({
-	type: z.literal("message"),
-	messageId: z.string().min(1),
-	role: conversationMessageRoleSchema,
-	text: z.string(),
-	authorIdentityId: z.string().min(1).optional(),
-	meta: z.record(z.string(), z.unknown()).optional()
-}).strict();
-const messageUpdatedEventDataSchema = messageEventDataSchema.extend({ type: z.literal("message_updated") });
-const messageHandledEventDataSchema = z.object({
-	type: z.literal("message_handled"),
-	messageId: z.string().min(1)
-}).strict();
-const messagesSummarizedEventDataSchema = z.object({
-	type: z.literal("messages_summarized"),
-	historyFromSeq: z.number().int().nonnegative(),
-	compactions: z.array(z.object({
-		coveredMessageCount: z.number().int().nonnegative(),
-		createdAtMs: z.number(),
-		id: z.string().min(1),
-		summary: z.string()
-	}).strict())
-}).strict();
-/** Product surface that owns a durable conversation turn. */
-const conversationTurnSurfaceSchema = z.enum([
-	"slack",
-	"api",
-	"scheduler",
-	"internal"
-]);
-/** Where a failed turn stopped. */
-const conversationTurnFailureCodeSchema = z.enum([
-	"agent_run_failed",
-	"delivery_failed",
-	"model_execution_failed",
-	"persistence_failed"
-]);
-/**
-* Why a failed turn stopped.
-* Values are fixed labels only. Do not store raw exception text.
-*/
-const conversationTurnFailureReasonSchema = z.enum([
-	"auth",
-	"permission",
-	"rate_limit",
-	"capacity",
-	"timeout",
-	"network",
-	"server",
-	"invalid_request",
-	"invalid_response",
-	"quota",
-	"content_policy",
-	"unknown",
-	"empty_output",
-	"tool_errors",
-	"suppressed_output"
-]);
-const turnStartedEventDataSchema = z.object({
-	type: z.literal("turn_started"),
-	turnId: z.string().min(1),
-	inputMessageIds: z.array(z.string().min(1)).min(1),
-	surface: conversationTurnSurfaceSchema
-}).strict().refine((data) => new Set(data.inputMessageIds).size === data.inputMessageIds.length, "turn input message ids must be unique");
-const turnRoutedEventDataSchema = z.object({
-	type: z.literal("turn_routed"),
-	turnId: z.string().min(1),
-	modelProfile: modelProfileSchema,
-	modelId: z.string().min(1),
-	costUsd: z.number().finite().nonnegative().optional(),
-	reasoningLevel: z.enum(TURN_REASONING_LEVELS),
-	confidence: z.number().min(0).max(1).optional(),
-	source: z.enum([
-		"configured",
-		"inherited",
-		"router"
-	])
-}).strict();
-const turnContextEventDataSchema = z.object({
-	type: z.literal("turn_context"),
-	turnId: z.string().min(1),
-	pluginName: z.string().min(1),
-	kind: z.string().min(1).max(64),
-	version: z.number().int().positive(),
-	content: z.record(z.string(), z.unknown())
-}).strict();
-const structuredConversationEventDataSchema = z.object({
-	type: z.literal("structured_event"),
-	namespace: z.string().regex(/^[a-z][a-z0-9-]*$/),
-	name: z.string().regex(/^[a-z][a-z0-9_]*$/),
-	version: z.number().int().positive(),
-	turnId: z.string().min(1).optional(),
-	content: z.record(z.string(), z.unknown())
-}).strict();
-/** Durable attachment metadata on host-owned delivery events. */
-const deliveredAttachmentSchema = z.object({
-	id: z.string().min(1),
-	filename: z.string().min(1),
-	contentType: z.string().min(1),
-	bytes: z.number().int().nonnegative()
-}).strict();
-/** Host-owned transcript item for files delivered to humans this turn. */
-const attachmentsDeliveredEventDataSchema = z.object({
-	type: z.literal("attachments_delivered"),
-	attachments: z.array(deliveredAttachmentSchema).min(1),
-	toolCallId: z.string().min(1).optional(),
-	turnId: z.string().min(1).optional()
-}).strict();
-const turnCompletedEventDataSchema = z.object({
-	type: z.literal("turn_completed"),
-	turnId: z.string().min(1),
-	outcome: z.enum([
-		"success",
-		"no_reply",
-		"cancelled"
-	])
-}).strict();
-const turnFailedEventDataSchema = z.object({
-	type: z.literal("turn_failed"),
-	turnId: z.string().min(1),
-	failureCode: conversationTurnFailureCodeSchema,
-	failureReason: conversationTurnFailureReasonSchema.optional(),
-	eventId: z.string().regex(/^[a-f0-9]{32}$/i).optional()
-}).strict();
-const subagentStartedEventDataSchema = z.object({
-	type: z.literal("subagent_started"),
-	subagentInvocationId: z.string().min(1),
-	subagentKind: z.string().min(1),
-	modelId: z.string().min(1).optional(),
-	parentToolCallId: z.string().min(1).optional(),
-	reasoningLevel: z.string().min(1).optional(),
-	childConversationId: z.string().min(1)
-}).strict();
-const subagentEndedEventDataSchema = z.object({
-	type: z.literal("subagent_ended"),
-	subagentInvocationId: z.string().min(1),
-	outcome: z.union([
-		z.literal("success"),
-		z.literal("error"),
-		z.literal("aborted")
-	]),
-	errorCode: z.string().min(1).optional()
-}).strict();
-/** Prevent ordinary appends from bypassing history-replacement validation. */
-const appendableConversationEventDataSchema = z.union([
-	messageEventDataSchema,
-	messageUpdatedEventDataSchema,
-	agentHistoryItemSchema,
-	mcpProviderConnectedEventDataSchema,
-	authorizationRequestedEventDataSchema,
-	authorizationCompletedEventDataSchema,
-	toolExecutionStartedEventDataSchema,
-	guardianActionReviewedEventDataSchema,
-	messageHandledEventDataSchema,
-	messagesSummarizedEventDataSchema,
-	turnStartedEventDataSchema,
-	turnContextEventDataSchema,
-	structuredConversationEventDataSchema,
-	attachmentsDeliveredEventDataSchema,
-	turnRoutedEventDataSchema,
-	turnCompletedEventDataSchema,
-	turnFailedEventDataSchema,
-	subagentStartedEventDataSchema,
-	subagentEndedEventDataSchema
-]);
-/** Strict event-data contract reused by the SQL row codec. */
-const conversationEventDataSchema = z.union([
-	appendableConversationEventDataSchema,
-	historyReplacementEventDataSchema,
-	unownedMcpProviderConnectedEventDataSchema
-]);
-/** Event type names recognized by current readers and observational queries. */
-const KNOWN_CONVERSATION_EVENT_TYPES = [
-	"message",
-	"message_updated",
-	"user_message",
-	"assistant_message",
-	"tool_result",
-	"mcp_provider_connected",
-	"mcp_provider_connected_unowned",
-	"authorization_requested",
-	"authorization_completed",
-	"tool_execution_started",
-	"guardian_action_reviewed",
-	"message_handled",
-	"messages_summarized",
-	"turn_started",
-	"turn_context",
-	"structured_event",
-	"attachments_delivered",
-	"turn_routed",
-	"turn_completed",
-	"turn_failed",
-	"subagent_started",
-	"subagent_ended",
-	"handoff",
-	"compaction"
-];
-const knownConversationEventTypeSchema = z.enum(KNOWN_CONVERSATION_EVENT_TYPES);
-const unknownConversationEventDataSchema = z.object({
-	type: z.literal("unknown"),
-	originalType: z.string().min(1),
-	payload: z.unknown()
-}).strict();
-const conversationEventEnvelopeSchema = z.object({
-	schemaVersion: z.number().int().nonnegative(),
-	seq: z.number().int().nonnegative(),
-	historyVersion: z.number().int().nonnegative(),
-	idempotencyKey: z.string().min(1).optional(),
-	createdAtMs: z.number().finite()
-}).strict();
-/**
-* Canonical ordered envelope for the durable conversation log.
-* `schemaVersion` is persisted with every physical event row.
-*/
-const conversationEventSchema = z.union([conversationEventEnvelopeSchema.extend({
-	schemaVersion: z.literal(1),
-	data: conversationEventDataSchema
-}), conversationEventEnvelopeSchema.extend({ data: unknownConversationEventDataSchema })]);
-const storedConversationEventSchema = conversationEventEnvelopeSchema.extend({
-	type: z.string().min(1),
-	payload: z.unknown()
-});
-/**
-* Decode a physical event row without making old or future event types
-* unreadable. Unsupported rows stay opaque until an upgrade migration defines
-* their semantics; known version-one events remain strict so corrupt canonical
-* data cannot be mistaken for compatibility data.
-*/
-function decodeStoredConversationEvent(value) {
-	const stored = storedConversationEventSchema.parse(value);
-	const { type, payload, ...envelope } = stored;
-	const knownType = knownConversationEventTypeSchema.safeParse(type).success;
-	if (stored.schemaVersion === 1 && knownType) {
-		const data = typeof payload === "object" && payload !== null && !Array.isArray(payload) ? {
-			...payload,
-			type
-		} : { type };
-		return conversationEventSchema.parse({
-			...envelope,
-			data
-		});
-	}
-	return conversationEventSchema.parse({
-		...envelope,
-		data: {
-			type: "unknown",
-			originalType: type,
-			payload
-		}
-	});
-}
-/** Validate an append without permitting model-history replacement events. */
-const newConversationEventSchema = z.object({
-	data: appendableConversationEventDataSchema,
-	idempotencyKey: z.string().min(1).optional(),
-	createdAtMs: z.number().finite()
-}).strict();
-//#endregion
-export { conversationTurnFailureReasonSchema as a, newConversationEventSchema as c, instructionProvenanceFor as d, sameActorIdentity as f, conversationTurnFailureCodeSchema as i, contextProvenance as l, agentHistoryItemSchema as n, decodeStoredConversationEvent as o, conversationEventDataSchema as r, historyReplacementSchema as s, KNOWN_CONVERSATION_EVENT_TYPES as t, instructionActors as u };

package/dist/usage-schema-CKaDkH_j.js

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

package/dist/web-authorization-RMBxAR_t.js

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