@sentry/junior 0.113.0 → 0.115.0

package/dist/{chunk-ZRSUCJGA.js → chunk-FHC4JUSF.js}

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "@sentry/junior",
-  version: "0.113.0",
+  version: "0.115.0",
   private: false,
   publishConfig: {
     access: "public"

package/dist/{chunk-6Y5L4BOM.js → chunk-FXOYURO4.js}

@@ -1,9 +1,11 @@
+import {
+  toOptionalString
+} from "./chunk-OB42YVAE.js";
 import {
   parseSlackChannelId,
   parseSlackMessageTs,
-  parseSlackTeamId,
-  toOptionalString
-} from "./chunk-42WRQLJ6.js";
+  parseSlackTeamId
+} from "./chunk-F3B2YJ76.js";
 
 // src/chat/conversation-privacy.ts
 import { AsyncLocalStorage } from "async_hooks";

package/dist/{chunk-UKGNSJQQ.js → chunk-G36V2YGB.js}

@@ -5,9 +5,37 @@ import {
   juniorDestinationKindSchema
 } from "./chunk-VFUK3X5B.js";
 
-// src/api/schema/common.ts
+// src/api/activity.ts
 import { z } from "zod";
-var apiErrorSchema = z.object({ error: z.string().min(1) }).strict();
+var dailyConversationActivitySchema = z.object({
+  active: z.number(),
+  conversations: z.number(),
+  date: z.string(),
+  durationMs: z.number(),
+  failed: z.number(),
+  tokens: z.number().optional()
+}).strict();
+function emptyActivityDay(date) {
+  return {
+    active: 0,
+    conversations: 0,
+    date,
+    durationMs: 0,
+    failed: 0
+  };
+}
+function activityDays(days, nowMs, count) {
+  const items = [];
+  const end = new Date(nowMs);
+  end.setUTCHours(0, 0, 0, 0);
+  const start = new Date(end);
+  start.setUTCDate(start.getUTCDate() - (count - 1));
+  for (const cursor = new Date(start); cursor.getTime() <= end.getTime(); cursor.setUTCDate(cursor.getUTCDate() + 1)) {
+    const date = cursor.toISOString().slice(0, 10);
+    items.push(days.get(date) ?? emptyActivityDay(date));
+  }
+  return items;
+}
 
 // src/api/schema/conversation.ts
 import { z as z2 } from "zod";
@@ -117,13 +145,38 @@ var conversationReportTurnLifecycleEventDataSchema = z2.discriminatedUnion(
     }).strict()
   ]
 );
-var conversationReportCompactionEventDataSchema = z2.object({ type: z2.literal("compaction") }).strict();
+var conversationReportTurnRoutedEventDataSchema = z2.object({
+  type: z2.literal("turn_routed"),
+  turnId: z2.string().min(1),
+  modelProfile: z2.string().min(1),
+  modelId: z2.string().min(1),
+  reasoningLevel: z2.string().min(1),
+  confidence: z2.number().min(0).max(1).optional(),
+  source: z2.enum(["configured", "inherited", "router"])
+}).strict();
+var conversationReportCompactionEventDataSchema = z2.object({
+  type: z2.literal("compaction"),
+  modelProfile: z2.string().min(1).optional(),
+  modelId: z2.string().min(1).optional(),
+  summary: z2.string().min(1).optional(),
+  details: z2.object({
+    reason: z2.literal("capacity"),
+    estimatedInputTokens: z2.number().int().nonnegative(),
+    replacementInputTokens: z2.number().int().nonnegative().optional(),
+    triggerTokens: z2.number().int().nonnegative(),
+    inputLimitTokens: z2.number().int().positive(),
+    inputMessageCount: z2.number().int().nonnegative(),
+    retainedMessageCount: z2.number().int().nonnegative(),
+    summaryChars: z2.number().int().nonnegative()
+  }).strict().optional()
+}).strict();
 var conversationReportHandoffEventDataSchema = z2.object({
   type: z2.literal("handoff"),
   modelProfile: z2.string().min(1),
   modelId: z2.string().min(1),
   reasoningLevel: z2.string().min(1).optional(),
-  triggeringToolCallId: z2.string().min(1).optional()
+  triggeringToolCallId: z2.string().min(1).optional(),
+  summary: z2.string().min(1).optional()
 }).strict();
 var conversationReportSubagentEventDataSchema = z2.object({
   type: z2.literal("subagent"),
@@ -139,6 +192,7 @@ var conversationReportEventDataSchema = z2.discriminatedUnion("type", [
   conversationReportMessageHandledEventDataSchema,
   conversationReportToolCallsEventDataSchema,
   conversationReportTurnLifecycleEventDataSchema,
+  conversationReportTurnRoutedEventDataSchema,
   conversationReportCompactionEventDataSchema,
   conversationReportHandoffEventDataSchema,
   conversationReportSubagentEventDataSchema
@@ -258,37 +312,58 @@ var conversationStatsReportSchema = z2.object({
   windowStart: z2.string()
 }).strict();
 
-// src/api/activity.ts
+// src/api/schema/person.ts
 import { z as z3 } from "zod";
-var dailyConversationActivitySchema = z3.object({
+var personParamsSchema = z3.object({ email: z3.string().trim().min(1) }).strict();
+var peopleConversationStatsItemSchema = conversationStatsItemSchema.omit({ costUsd: true });
+var actorActivityDayReportSchema = z3.object({
   active: z3.number(),
   conversations: z3.number(),
+  costUsd: z3.number().optional(),
   date: z3.string(),
   durationMs: z3.number(),
   failed: z3.number(),
   tokens: z3.number().optional()
 }).strict();
-function emptyActivityDay(date) {
-  return {
-    active: 0,
-    conversations: 0,
-    date,
-    durationMs: 0,
-    failed: 0
-  };
-}
-function activityDays(days, nowMs, count) {
-  const items = [];
-  const end = new Date(nowMs);
-  end.setUTCHours(0, 0, 0, 0);
-  const start = new Date(end);
-  start.setUTCDate(start.getUTCDate() - (count - 1));
-  for (const cursor = new Date(start); cursor.getTime() <= end.getTime(); cursor.setUTCDate(cursor.getUTCDate() + 1)) {
-    const date = cursor.toISOString().slice(0, 10);
-    items.push(days.get(date) ?? emptyActivityDay(date));
-  }
-  return items;
-}
+var peopleActivityDayReportSchema = z3.object({
+  activePeople: z3.number(),
+  conversations: z3.number(),
+  date: z3.string()
+}).strict();
+var actorTotalsReportSchema = z3.object({
+  active: z3.number(),
+  activeDays: z3.number(),
+  conversations: z3.number(),
+  durationMs: z3.number(),
+  failed: z3.number(),
+  tokens: z3.number().optional()
+}).strict();
+var identifiedActorSchema = actorIdentitySchema.extend({ email: z3.string().min(1) }).strict();
+var actorSummaryReportSchema = actorTotalsReportSchema.extend({
+  firstSeenAt: z3.string(),
+  lastSeenAt: z3.string(),
+  actor: identifiedActorSchema
+}).strict();
+var actorDirectoryReportSchema = z3.object({
+  activityDays: z3.array(peopleActivityDayReportSchema),
+  generatedAt: z3.string(),
+  people: z3.array(actorSummaryReportSchema),
+  source: z3.literal("conversation_index"),
+  windowEnd: z3.string(),
+  windowStart: z3.string()
+}).strict();
+var actorProfileReportSchema = z3.object({
+  activityDays: z3.array(actorActivityDayReportSchema),
+  generatedAt: z3.string(),
+  locations: z3.array(peopleConversationStatsItemSchema),
+  recentConversations: z3.array(conversationSummaryReportSchema),
+  actor: identifiedActorSchema,
+  source: z3.literal("conversation_index"),
+  surfaces: z3.array(peopleConversationStatsItemSchema),
+  totals: actorTotalsReportSchema,
+  windowEnd: z3.string(),
+  windowStart: z3.string()
+}).strict();
 
 // src/api/schema/location.ts
 import { z as z4 } from "zod";
@@ -327,58 +402,9 @@ var locationDetailReportSchema = locationSummaryReportSchema.extend({
   windowStart: z4.string()
 }).strict();
 
-// src/api/schema/person.ts
+// src/api/schema/common.ts
 import { z as z5 } from "zod";
-var personParamsSchema = z5.object({ email: z5.string().trim().min(1) }).strict();
-var peopleConversationStatsItemSchema = conversationStatsItemSchema.omit({ costUsd: true });
-var actorActivityDayReportSchema = z5.object({
-  active: z5.number(),
-  conversations: z5.number(),
-  costUsd: z5.number().optional(),
-  date: z5.string(),
-  durationMs: z5.number(),
-  failed: z5.number(),
-  tokens: z5.number().optional()
-}).strict();
-var peopleActivityDayReportSchema = z5.object({
-  activePeople: z5.number(),
-  conversations: z5.number(),
-  date: z5.string()
-}).strict();
-var actorTotalsReportSchema = z5.object({
-  active: z5.number(),
-  activeDays: z5.number(),
-  conversations: z5.number(),
-  durationMs: z5.number(),
-  failed: z5.number(),
-  tokens: z5.number().optional()
-}).strict();
-var identifiedActorSchema = actorIdentitySchema.extend({ email: z5.string().min(1) }).strict();
-var actorSummaryReportSchema = actorTotalsReportSchema.extend({
-  firstSeenAt: z5.string(),
-  lastSeenAt: z5.string(),
-  actor: identifiedActorSchema
-}).strict();
-var actorDirectoryReportSchema = z5.object({
-  activityDays: z5.array(peopleActivityDayReportSchema),
-  generatedAt: z5.string(),
-  people: z5.array(actorSummaryReportSchema),
-  source: z5.literal("conversation_index"),
-  windowEnd: z5.string(),
-  windowStart: z5.string()
-}).strict();
-var actorProfileReportSchema = z5.object({
-  activityDays: z5.array(actorActivityDayReportSchema),
-  generatedAt: z5.string(),
-  locations: z5.array(peopleConversationStatsItemSchema),
-  recentConversations: z5.array(conversationSummaryReportSchema),
-  actor: identifiedActorSchema,
-  source: z5.literal("conversation_index"),
-  surfaces: z5.array(peopleConversationStatsItemSchema),
-  totals: actorTotalsReportSchema,
-  windowEnd: z5.string(),
-  windowStart: z5.string()
-}).strict();
+var apiErrorSchema = z5.object({ error: z5.string().min(1) }).strict();
 
 export {
   apiErrorSchema,
@@ -398,11 +424,11 @@ export {
   conversationStatsReportSchema,
   dailyConversationActivitySchema,
   activityDays,
+  personParamsSchema,
+  actorDirectoryReportSchema,
+  actorProfileReportSchema,
   locationParamsSchema,
   locationActivityDayReportSchema,
   locationDirectoryReportSchema,
-  locationDetailReportSchema,
-  personParamsSchema,
-  actorDirectoryReportSchema,
-  actorProfileReportSchema
+  locationDetailReportSchema
 };

package/dist/{chunk-K5BXPM74.js → chunk-G5SX4UPR.js}

@@ -1,15 +1,12 @@
 import {
   healthReportSchema
-} from "./chunk-2ZTTXTSZ.js";
+} from "./chunk-6OPTF4BQ.js";
 import {
   normalizeSlackConversationId
-} from "./chunk-QTS66GMR.js";
+} from "./chunk-CWEZEPD4.js";
 import {
   parseSlackThreadId
-} from "./chunk-6Y5L4BOM.js";
-import {
-  getClient
-} from "./chunk-6GWA276C.js";
+} from "./chunk-FXOYURO4.js";
 
 // src/handlers/health.ts
 function readHealthReport() {
@@ -23,42 +20,6 @@ function GET() {
   return Response.json(readHealthReport());
 }
 
-// src/chat/sentry-links.ts
-function getSentryOrgSlug() {
-  const slug = process.env.SENTRY_ORG_SLUG?.trim();
-  return slug || 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 buildSentryConversationUrl(conversationId) {
-  const client = getClient();
-  const dsn = client?.getDsn();
-  if (!dsn?.host || !dsn.projectId) {
-    return void 0;
-  }
-  const orgSlug = getSentryOrgSlug();
-  if (!orgSlug) {
-    return void 0;
-  }
-  const encodedId = encodeURIComponent(conversationId);
-  const params = new URLSearchParams();
-  params.set("project", dsn.projectId);
-  const path = `explore/conversations/${encodedId}/?${params.toString()}`;
-  if (isSentrySaasDsnHost(dsn.host)) {
-    return `https://${orgSlug}.sentry.io/${path}`;
-  }
-  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
-}
-
 // src/chat/slack/conversation-context.ts
 function normalizeConversationName(type, channelName) {
   const trimmed = channelName?.trim();
@@ -144,7 +105,6 @@ function formatSlackConversationRedactedLabel(context) {
 export {
   readHealthReport,
   GET,
-  buildSentryConversationUrl,
   conversationVisibilityFromSlackChannelType,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext,

package/dist/chunk-HDSDCEPK.js

@@ -0,0 +1,80 @@
+import {
+  credentialContextSchema
+} from "./chunk-W3U3YQYI.js";
+
+// src/chat/sandbox/egress/schemas.ts
+import { z } from "zod";
+import {
+  pluginAuthorizationSchema,
+  pluginCredentialHeaderTransformSchema,
+  pluginGrantSchema,
+  pluginProviderAccountSchema
+} from "@sentry/junior-plugin-api";
+var finiteNumberSchema = z.number().refine(Number.isFinite);
+var httpStatusSchema = z.number().int().min(100).max(599);
+var providerNameSchema = z.string().regex(/^[a-z][a-z0-9-]*$/);
+var credentialSignalKindSchema = z.enum(["auth_required", "unavailable"]);
+var sandboxEgressGrantSchema = pluginGrantSchema;
+var sandboxEgressCredentialContextSchema = z.object({
+  credentials: credentialContextSchema,
+  egressId: z.string().min(1),
+  expiresAtMs: finiteNumberSchema,
+  contextId: z.string().min(1)
+}).strict();
+var sandboxEgressCredentialLeaseSchema = z.object({
+  account: pluginProviderAccountSchema.optional(),
+  authorization: pluginAuthorizationSchema.optional(),
+  grant: sandboxEgressGrantSchema,
+  provider: providerNameSchema,
+  expiresAt: z.string().min(1),
+  headerTransforms: z.array(pluginCredentialHeaderTransformSchema).min(1)
+}).strict();
+var sandboxEgressAuthRequiredSignalSchema = z.object({
+  authorization: pluginAuthorizationSchema.optional(),
+  grant: sandboxEgressGrantSchema,
+  kind: credentialSignalKindSchema.default("auth_required"),
+  provider: providerNameSchema,
+  message: z.string().optional(),
+  createdAtMs: finiteNumberSchema
+}).strict().superRefine((signal, ctx) => {
+  if (signal.authorization && signal.authorization.provider !== signal.provider) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Auth signal authorization provider must match provider",
+      path: ["authorization", "provider"]
+    });
+  }
+});
+var sandboxEgressPermissionDeniedSignalSchema = z.object({
+  account: pluginProviderAccountSchema.optional(),
+  acceptedPermissions: z.string().optional(),
+  grant: sandboxEgressGrantSchema,
+  message: z.string().min(1),
+  provider: providerNameSchema,
+  source: z.literal("upstream"),
+  sso: z.string().optional(),
+  status: httpStatusSchema,
+  upstreamHost: z.string().min(1),
+  upstreamPath: z.string().min(1),
+  createdAtMs: finiteNumberSchema
+}).strict();
+var sandboxEgressSignalsResponseSchema = z.object({
+  auth_required: sandboxEgressAuthRequiredSignalSchema.optional(),
+  permission_denied: sandboxEgressPermissionDeniedSignalSchema.optional()
+}).strict();
+function parseSandboxEgressAuthRequiredSignal(value) {
+  const result = sandboxEgressAuthRequiredSignalSchema.safeParse(value);
+  return result.success ? result.data : void 0;
+}
+function parseSandboxEgressPermissionDeniedSignal(value) {
+  const result = sandboxEgressPermissionDeniedSignalSchema.safeParse(value);
+  return result.success ? result.data : void 0;
+}
+
+export {
+  sandboxEgressCredentialContextSchema,
+  sandboxEgressCredentialLeaseSchema,
+  sandboxEgressSignalsResponseSchema,
+  parseSandboxEgressAuthRequiredSignal,
+  parseSandboxEgressPermissionDeniedSignal
+};

package/dist/{chunk-LLKDNPYV.js → chunk-HWCQRGLL.js}

@@ -6,19 +6,20 @@ import {
   juniorUsers
 } from "./chunk-JQFJO5WH.js";
 import {
+  TURN_REASONING_LEVELS,
   getChatConfig,
   modelProfileSchema
-} from "./chunk-RCBUZGIT.js";
+} from "./chunk-SYJT7AKB.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
 import {
   normalizeIdentityEmail
-} from "./chunk-36UJA3OD.js";
+} from "./chunk-NVUQSFWX.js";
 import {
   parseSlackChannelReferenceId,
   parseSlackTeamId
-} from "./chunk-42WRQLJ6.js";
+} from "./chunk-F3B2YJ76.js";
 
 // src/chat/conversations/sql/store.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -809,6 +810,16 @@ var replacementHistoryMessageSchema = conversationMessageDataSchema.extend({
   sourceEventSeq: z2.number().int().nonnegative().optional()
 });
 var replacementHistorySchema = z2.array(replacementHistoryMessageSchema);
+var compactionDetailsSchema = z2.object({
+  reason: z2.literal("capacity"),
+  estimatedInputTokens: z2.number().int().nonnegative(),
+  replacementInputTokens: z2.number().int().nonnegative().optional(),
+  triggerTokens: z2.number().int().nonnegative(),
+  inputLimitTokens: z2.number().int().positive(),
+  inputMessageCount: z2.number().int().nonnegative(),
+  retainedMessageCount: z2.number().int().nonnegative(),
+  summaryChars: z2.number().int().nonnegative()
+}).strict();
 var historyReplacementEventDataSchema = z2.discriminatedUnion("type", [
   z2.object({
     type: z2.literal("handoff"),
@@ -816,12 +827,15 @@ var historyReplacementEventDataSchema = z2.discriminatedUnion("type", [
     modelId: z2.string().min(1),
     reasoningLevel: z2.string().min(1).optional(),
     triggeringToolCallId: z2.string().min(1).optional(),
+    summary: z2.string().min(1).optional(),
     replacementHistory: replacementHistorySchema
   }).strict(),
   z2.object({
     type: z2.literal("compaction"),
     modelProfile: modelProfileSchema,
     modelId: z2.string().min(1),
+    details: compactionDetailsSchema.optional(),
+    summary: z2.string().min(1).optional(),
     replacementHistory: replacementHistorySchema
   }).strict()
 ]);
@@ -919,6 +933,15 @@ var turnStartedEventDataSchema = z2.object({
   (data) => new Set(data.inputMessageIds).size === data.inputMessageIds.length,
   "turn input message ids must be unique"
 );
+var turnRoutedEventDataSchema = z2.object({
+  type: z2.literal("turn_routed"),
+  turnId: z2.string().min(1),
+  modelProfile: modelProfileSchema,
+  modelId: z2.string().min(1),
+  reasoningLevel: z2.enum(TURN_REASONING_LEVELS),
+  confidence: z2.number().min(0).max(1).optional(),
+  source: z2.enum(["configured", "inherited", "router"])
+}).strict();
 var turnCompletedEventDataSchema = z2.object({
   type: z2.literal("turn_completed"),
   turnId: z2.string().min(1),
@@ -960,6 +983,7 @@ var appendableConversationEventDataSchema = z2.union([
   messageHandledEventDataSchema,
   messagesSummarizedEventDataSchema,
   turnStartedEventDataSchema,
+  turnRoutedEventDataSchema,
   turnCompletedEventDataSchema,
   turnFailedEventDataSchema,
   subagentStartedEventDataSchema,
@@ -981,6 +1005,7 @@ var knownConversationEventTypeSchema = z2.enum([
   "message_handled",
   "messages_summarized",
   "turn_started",
+  "turn_routed",
   "turn_completed",
   "turn_failed",
   "subagent_started",
@@ -1219,6 +1244,15 @@ var SqlConversationEventStore = class {
     ).orderBy(asc2(juniorConversationEvents.seq));
     return rows.map(eventFromRow);
   }
+  async loadByIdempotencyKey(conversationId, idempotencyKey) {
+    const [row] = await this.executor.db().select().from(juniorConversationEvents).where(
+      and3(
+        eq3(juniorConversationEvents.conversationId, conversationId),
+        eq3(juniorConversationEvents.idempotencyKey, idempotencyKey)
+      )
+    ).limit(1);
+    return row ? eventFromRow(row) : void 0;
+  }
   async loadHistoryContaining(conversationId, seq, throughSeq) {
     const [boundary] = await this.executor.db().select({ historyVersion: juniorConversationEvents.historyVersion }).from(juniorConversationEvents).where(
       and3(

package/dist/{chunk-C4MZ3GP5.js → chunk-HZF5P5UN.js}

@@ -1,6 +1,6 @@
 import {
   parseSlackTeamId
-} from "./chunk-42WRQLJ6.js";
+} from "./chunk-F3B2YJ76.js";
 
 // src/chat/actor.ts
 import { z } from "zod";