@sentry/junior 0.156.0 → 0.158.0

package/dist/{chunk-4ZZDTHFC.js → chunk-3A7VXSPJ.js}

@@ -3,38 +3,38 @@ import {
 } from "./chunk-RF6J3DIO.js";
 import {
   resolveBaseUrl
-} from "./chunk-7RAETIYO.js";
+} from "./chunk-4JAOLUDB.js";
 import {
   isExperimentalFeatureEnabled
 } from "./chunk-5IDFPCON.js";
 import {
   createPluginLogger,
   getPlugins
-} from "./chunk-3FFUC32L.js";
+} from "./chunk-NOEERHHR.js";
 import {
   getSlackClient,
   withSlackRetries
-} from "./chunk-NTNU6T2D.js";
+} from "./chunk-ROOTB7J7.js";
 import {
   getDb,
   parseDestination
-} from "./chunk-IIO5PFZX.js";
+} from "./chunk-AF4PHIP6.js";
 import {
   sleep
 } from "./chunk-EM225ITJ.js";
 import {
   acquireActiveLock,
   getStateAdapter
-} from "./chunk-MC57E5U5.js";
+} from "./chunk-PHQDXC27.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-EDJ64P2P.js";
+} from "./chunk-YEZS4TEY.js";
 import {
   fetchWithBoundedOAuthErrorBodies
-} from "./chunk-WD7SEUZO.js";
+} from "./chunk-EQ6Y37MD.js";
 import {
   isRecord
-} from "./chunk-X7W45B5G.js";
+} from "./chunk-KSZXVR5G.js";
 
 // src/chat/capabilities/router.ts
 var ProviderCredentialRouter = class {

package/dist/{chunk-7RAETIYO.js → chunk-4JAOLUDB.js}

@@ -4,19 +4,19 @@ import {
   isDmChannel,
   normalizeSlackConversationId,
   withSlackRetries
-} from "./chunk-NTNU6T2D.js";
+} from "./chunk-ROOTB7J7.js";
 import {
   parseDestination
-} from "./chunk-IIO5PFZX.js";
+} from "./chunk-AF4PHIP6.js";
 import {
   getStateAdapter
-} from "./chunk-MC57E5U5.js";
+} from "./chunk-PHQDXC27.js";
 import {
   normalizeSlackEmojiName
-} from "./chunk-GKC43TLS.js";
+} from "./chunk-FAJ6SMEE.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-EDJ64P2P.js";
+} from "./chunk-YEZS4TEY.js";
 import {
   parseSlackMessageTs,
   parseSlackUserId
@@ -25,7 +25,7 @@ import {
   isRecord,
   logInfo,
   logWarn
-} from "./chunk-X7W45B5G.js";
+} from "./chunk-KSZXVR5G.js";
 
 // src/chat/slack/outbound.ts
 var MAX_SLACK_MESSAGE_TEXT_CHARS = 4e4;

package/dist/{chunk-KCA5MKHU.js → chunk-4Q6QVTKA.js}

@@ -1,25 +1,27 @@
 import {
   ToolInputError
-} from "./chunk-3L2PMOSR.js";
+} from "./chunk-C3FYJZSA.js";
 import {
   canRouteResourceEvents,
   getPlugins
-} from "./chunk-3FFUC32L.js";
+} from "./chunk-NOEERHHR.js";
 import {
   getDb
-} from "./chunk-IIO5PFZX.js";
+} from "./chunk-AF4PHIP6.js";
 import {
+  juniorAttachments,
+  juniorConversations,
   juniorEventTasks,
   juniorSchedulerRuns,
   juniorSchedulerTasks,
   juniorStats
-} from "./chunk-AIJRG227.js";
+} from "./chunk-VURJ2NSF.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
 import {
   logInfo
-} from "./chunk-X7W45B5G.js";
+} from "./chunk-KSZXVR5G.js";
 
 // src/chat/event-tasks/store.ts
 import { and, asc, desc, eq, inArray, or, sql } from "drizzle-orm";
@@ -1553,6 +1555,346 @@ function createSchedulerSqlStore(db) {
   return new SqlSchedulerStore(db);
 }
 
+// src/chat/attachments/store.ts
+import { createHash, randomUUID } from "crypto";
+import { and as and4, asc as asc4, eq as eq3, inArray as inArray3, isNotNull as isNotNull2, isNull, or as or3 } from "drizzle-orm";
+var ATTACHMENT_GC_BATCH_LIMIT = 200;
+function attachmentDigest(file) {
+  return createHash("sha256").update(file.data).digest("hex");
+}
+function attachmentId(args) {
+  return createHash("sha256").update(
+    [
+      args.conversationId,
+      args.provider,
+      args.sha256,
+      args.filename,
+      args.contentType
+    ].join("\0")
+  ).digest("hex");
+}
+function attachmentKey(args) {
+  return `conversations/${args.conversationId}/attachments/${args.attachmentId}/${args.writeId}/${args.filename}`;
+}
+async function bestEffortDelete(storage, key) {
+  try {
+    await storage.delete([key]);
+  } catch {
+  }
+}
+async function isConversationPurged(db, conversationId) {
+  const [row] = await db.db().select({
+    transcriptPurgedAt: juniorConversations.transcriptPurgedAt
+  }).from(juniorConversations).where(eq3(juniorConversations.conversationId, conversationId));
+  return row?.transcriptPurgedAt != null;
+}
+function purgedConversationError(conversationId) {
+  return new Error(
+    `Cannot store attachment for purged conversation ${conversationId}`
+  );
+}
+async function assertConversationNotPurged(db, conversationId) {
+  if (await isConversationPurged(db, conversationId)) {
+    throw purgedConversationError(conversationId);
+  }
+}
+async function rejectPurgedAttachmentWrite(args) {
+  await args.db.db().update(juniorAttachments).set({ deleteRequestedAt: args.now }).where(eq3(juniorAttachments.id, args.id));
+  await bestEffortDelete(args.storage, args.storageKey);
+  throw purgedConversationError(args.conversationId);
+}
+async function reuseLiveAttachment(args) {
+  await bestEffortDelete(args.storage, args.storageKey);
+  await assertConversationNotPurged(args.db, args.conversationId);
+  return { id: args.id };
+}
+async function storeAttachment(args) {
+  const now = new Date(args.nowMs ?? Date.now());
+  const sha256 = attachmentDigest(args.file);
+  const id = attachmentId({
+    conversationId: args.conversationId,
+    contentType: args.file.mimeType,
+    filename: args.file.filename,
+    provider: args.storage.provider,
+    sha256
+  });
+  const [existing] = await args.db.db().select({
+    contentType: juniorAttachments.contentType,
+    conversationId: juniorAttachments.conversationId,
+    deleteRequestedAt: juniorAttachments.deleteRequestedAt,
+    filename: juniorAttachments.filename,
+    id: juniorAttachments.id,
+    provider: juniorAttachments.provider,
+    sha256: juniorAttachments.sha256,
+    storageKey: juniorAttachments.storageKey
+  }).from(juniorAttachments).where(eq3(juniorAttachments.id, id));
+  if (existing) {
+    if (existing.contentType !== args.file.mimeType || existing.conversationId !== args.conversationId || existing.filename !== args.file.filename || existing.provider !== args.storage.provider || existing.sha256 !== sha256) {
+      throw new Error(`Attachment write conflicts with ${existing.id}`);
+    }
+    if (existing.deleteRequestedAt === null) {
+      await assertConversationNotPurged(args.db, args.conversationId);
+      return { id: existing.id };
+    }
+  }
+  await assertConversationNotPurged(args.db, args.conversationId);
+  const storageKey = attachmentKey({
+    attachmentId: id,
+    conversationId: args.conversationId,
+    filename: args.file.filename,
+    writeId: randomUUID()
+  });
+  await args.storage.put({
+    body: args.file.data,
+    contentType: args.file.mimeType,
+    key: storageKey
+  });
+  if (existing?.deleteRequestedAt != null) {
+    if (await isConversationPurged(args.db, args.conversationId)) {
+      await bestEffortDelete(args.storage, storageKey);
+      throw purgedConversationError(args.conversationId);
+    }
+    const oldStorageKey = existing.storageKey;
+    const revived2 = await args.db.db().update(juniorAttachments).set({
+      deleteRequestedAt: null,
+      storageKey
+    }).where(
+      and4(
+        eq3(juniorAttachments.id, id),
+        isNotNull2(juniorAttachments.deleteRequestedAt)
+      )
+    ).returning({ id: juniorAttachments.id });
+    if (revived2.length > 0) {
+      if (await isConversationPurged(args.db, args.conversationId)) {
+        await rejectPurgedAttachmentWrite({
+          conversationId: args.conversationId,
+          db: args.db,
+          id,
+          now,
+          storage: args.storage,
+          storageKey
+        });
+      }
+      if (oldStorageKey !== storageKey) {
+        await bestEffortDelete(args.storage, oldStorageKey);
+      }
+      return { id };
+    }
+    const [afterRace2] = await args.db.db().select({
+      deleteRequestedAt: juniorAttachments.deleteRequestedAt,
+      id: juniorAttachments.id,
+      storageKey: juniorAttachments.storageKey
+    }).from(juniorAttachments).where(eq3(juniorAttachments.id, id));
+    if (afterRace2?.deleteRequestedAt === null) {
+      return reuseLiveAttachment({
+        conversationId: args.conversationId,
+        db: args.db,
+        id: afterRace2.id,
+        storage: args.storage,
+        storageKey
+      });
+    }
+  }
+  let inserted = [];
+  try {
+    inserted = await args.db.db().insert(juniorAttachments).values({
+      id,
+      conversationId: args.conversationId,
+      provider: args.storage.provider,
+      storageKey,
+      filename: args.file.filename,
+      contentType: args.file.mimeType,
+      bytes: args.file.bytes,
+      sha256,
+      createdAt: now
+    }).onConflictDoNothing({ target: juniorAttachments.id }).returning({ id: juniorAttachments.id });
+  } catch (error) {
+    await bestEffortDelete(args.storage, storageKey);
+    throw error;
+  }
+  if (inserted.length > 0) {
+    if (await isConversationPurged(args.db, args.conversationId)) {
+      await rejectPurgedAttachmentWrite({
+        conversationId: args.conversationId,
+        db: args.db,
+        id,
+        now,
+        storage: args.storage,
+        storageKey
+      });
+    }
+    return { id };
+  }
+  const [row] = await args.db.db().select({
+    deleteRequestedAt: juniorAttachments.deleteRequestedAt,
+    id: juniorAttachments.id,
+    storageKey: juniorAttachments.storageKey
+  }).from(juniorAttachments).where(eq3(juniorAttachments.id, id));
+  if (!row) {
+    await bestEffortDelete(args.storage, storageKey);
+    throw new Error(`Attachment row missing after write for ${id}`);
+  }
+  if (row.deleteRequestedAt === null) {
+    return reuseLiveAttachment({
+      conversationId: args.conversationId,
+      db: args.db,
+      id: row.id,
+      storage: args.storage,
+      storageKey
+    });
+  }
+  if (await isConversationPurged(args.db, args.conversationId)) {
+    await bestEffortDelete(args.storage, storageKey);
+    throw purgedConversationError(args.conversationId);
+  }
+  const revived = await args.db.db().update(juniorAttachments).set({
+    deleteRequestedAt: null,
+    storageKey
+  }).where(
+    and4(
+      eq3(juniorAttachments.id, id),
+      isNotNull2(juniorAttachments.deleteRequestedAt)
+    )
+  ).returning({ id: juniorAttachments.id });
+  if (revived.length > 0) {
+    if (await isConversationPurged(args.db, args.conversationId)) {
+      await rejectPurgedAttachmentWrite({
+        conversationId: args.conversationId,
+        db: args.db,
+        id,
+        now,
+        storage: args.storage,
+        storageKey
+      });
+    }
+    if (row.storageKey !== storageKey) {
+      await bestEffortDelete(args.storage, row.storageKey);
+    }
+    return { id };
+  }
+  const [afterRace] = await args.db.db().select({
+    deleteRequestedAt: juniorAttachments.deleteRequestedAt,
+    id: juniorAttachments.id
+  }).from(juniorAttachments).where(eq3(juniorAttachments.id, id));
+  if (afterRace?.deleteRequestedAt === null) {
+    return reuseLiveAttachment({
+      conversationId: args.conversationId,
+      db: args.db,
+      id: afterRace.id,
+      storage: args.storage,
+      storageKey
+    });
+  }
+  await bestEffortDelete(args.storage, storageKey);
+  throw new Error(`Attachment ${id} disappeared while reviving`);
+}
+async function readLiveAttachment(args) {
+  const [row] = await args.db.db().select({
+    bytes: juniorAttachments.bytes,
+    contentType: juniorAttachments.contentType,
+    conversationId: juniorAttachments.conversationId,
+    deleteRequestedAt: juniorAttachments.deleteRequestedAt,
+    filename: juniorAttachments.filename,
+    id: juniorAttachments.id,
+    provider: juniorAttachments.provider,
+    storageKey: juniorAttachments.storageKey
+  }).from(juniorAttachments).where(
+    and4(
+      eq3(juniorAttachments.id, args.attachmentId),
+      eq3(juniorAttachments.conversationId, args.conversationId),
+      isNull(juniorAttachments.deleteRequestedAt)
+    )
+  );
+  if (!row) return null;
+  if (await isConversationPurged(args.db, args.conversationId)) {
+    return null;
+  }
+  return {
+    bytes: row.bytes,
+    contentType: row.contentType,
+    conversationId: row.conversationId,
+    filename: row.filename,
+    id: row.id,
+    provider: row.provider,
+    storageKey: row.storageKey
+  };
+}
+async function storeAttachments(args) {
+  const stored = [];
+  for (const file of args.files) {
+    stored.push(
+      await storeAttachment({
+        conversationId: args.conversationId,
+        db: args.db,
+        file,
+        ...args.nowMs !== void 0 ? { nowMs: args.nowMs } : {},
+        storage: args.storage
+      })
+    );
+  }
+  return stored;
+}
+async function requestAttachmentDeletion(db, conversationIds, nowMs) {
+  if (conversationIds.length === 0) return;
+  await db.db().update(juniorAttachments).set({ deleteRequestedAt: new Date(nowMs) }).where(
+    and4(
+      inArray3(juniorAttachments.conversationId, conversationIds),
+      isNull(juniorAttachments.deleteRequestedAt)
+    )
+  );
+}
+async function collectAttachmentGarbage(args) {
+  void args.nowMs;
+  const rows = await args.db.db().select({
+    id: juniorAttachments.id,
+    storageKey: juniorAttachments.storageKey
+  }).from(juniorAttachments).innerJoin(
+    juniorConversations,
+    eq3(
+      juniorAttachments.conversationId,
+      juniorConversations.conversationId
+    )
+  ).where(
+    and4(
+      eq3(juniorAttachments.provider, args.storage.provider),
+      or3(
+        isNotNull2(juniorAttachments.deleteRequestedAt),
+        isNotNull2(juniorConversations.transcriptPurgedAt)
+      )
+    )
+  ).orderBy(asc4(juniorAttachments.createdAt), asc4(juniorAttachments.id)).limit(args.limit ?? ATTACHMENT_GC_BATCH_LIMIT);
+  if (rows.length === 0) return { deleted: 0 };
+  await args.storage.delete(rows.map((row) => row.storageKey));
+  const stillEligible = await args.db.db().select({ id: juniorAttachments.id }).from(juniorAttachments).innerJoin(
+    juniorConversations,
+    eq3(
+      juniorAttachments.conversationId,
+      juniorConversations.conversationId
+    )
+  ).where(
+    and4(
+      inArray3(
+        juniorAttachments.id,
+        rows.map((row) => row.id)
+      ),
+      or3(
+        isNotNull2(juniorAttachments.deleteRequestedAt),
+        isNotNull2(juniorConversations.transcriptPurgedAt)
+      )
+    )
+  );
+  if (stillEligible.length === 0) return { deleted: 0 };
+  const removed = await args.db.db().delete(juniorAttachments).where(
+    inArray3(
+      juniorAttachments.id,
+      stillEligible.map((row) => row.id)
+    )
+  ).returning({
+    id: juniorAttachments.id
+  });
+  return { deleted: removed.length };
+}
+
 export {
   juniorToolOutputSchema,
   injectContinuationToolName,
@@ -1591,6 +1933,10 @@ export {
   SCHEDULED_TASK_SYSTEM_ACTOR,
   listPublicScheduledTasksForTeams,
   createSchedulerSqlStore,
+  readLiveAttachment,
+  storeAttachments,
+  requestAttachmentDeletion,
+  collectAttachmentGarbage,
   incrementStat,
   readStats
 };

package/dist/{chunk-TN4LVILT.js → chunk-4XJ2WSTI.js}

@@ -1,18 +1,18 @@
 import {
   persistConversationMessages
-} from "./chunk-3L2PMOSR.js";
+} from "./chunk-C3FYJZSA.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS
 } from "./chunk-3Y47VMHV.js";
 import {
   getDb
-} from "./chunk-IIO5PFZX.js";
+} from "./chunk-AF4PHIP6.js";
 import {
   juniorLocationConfigurations
-} from "./chunk-AIJRG227.js";
+} from "./chunk-VURJ2NSF.js";
 import {
   getStateAdapter
-} from "./chunk-MC57E5U5.js";
+} from "./chunk-PHQDXC27.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
@@ -20,7 +20,7 @@ import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-X7W45B5G.js";
+} from "./chunk-KSZXVR5G.js";
 
 // src/chat/conversations/turn-lifecycle.ts
 var ConversationTurnLifecycleService = class {

package/dist/{chunk-OGZPRMZA.js → chunk-6GJCOUTA.js}

@@ -1,6 +1,6 @@
 import {
   JUNIOR_VERSION
-} from "./chunk-KBGMYLSV.js";
+} from "./chunk-IXYGGJRA.js";
 
 // src/deployment.ts
 var JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";

package/dist/{chunk-6CINHXIL.js → chunk-A7EDLNGU.js}

@@ -8,14 +8,14 @@ import {
   getConversationStore,
   parseDestination,
   sameDestination
-} from "./chunk-IIO5PFZX.js";
+} from "./chunk-AF4PHIP6.js";
 import {
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-MC57E5U5.js";
+} from "./chunk-PHQDXC27.js";
 import {
   getChatConfig
-} from "./chunk-GKC43TLS.js";
+} from "./chunk-FAJ6SMEE.js";
 import {
   parseStoredSlackActor
 } from "./chunk-V7YE4WCP.js";
@@ -23,7 +23,7 @@ import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-X7W45B5G.js";
+} from "./chunk-KSZXVR5G.js";
 
 // src/chat/task-execution/state.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-IIO5PFZX.js → chunk-AF4PHIP6.js}

@@ -6,12 +6,12 @@ import {
   juniorConversations,
   juniorIdentities,
   juniorUsers
-} from "./chunk-AIJRG227.js";
+} from "./chunk-VURJ2NSF.js";
 import {
   TURN_REASONING_LEVELS,
   getChatConfig,
   modelProfileSchema
-} from "./chunk-GKC43TLS.js";
+} from "./chunk-FAJ6SMEE.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
@@ -22,7 +22,7 @@ import {
 } from "./chunk-V7YE4WCP.js";
 import {
   normalizeIdentityEmail
-} from "./chunk-X7W45B5G.js";
+} from "./chunk-KSZXVR5G.js";
 
 // src/chat/conversations/sql/store.ts
 import { randomUUID as randomUUID2 } from "crypto";

package/dist/{chunk-IZEBHYI4.js → chunk-BNFGY66A.js}

@@ -1,6 +1,6 @@
 import {
   createAndEnqueueAgentInvocation
-} from "./chunk-CN2XSVKF.js";
+} from "./chunk-X4BLYIMV.js";
 import {
   actorFromRun,
   toolInvocationDestination

package/dist/{chunk-3L2PMOSR.js → chunk-C3FYJZSA.js}

@@ -13,7 +13,7 @@ import {
   instructionProvenanceFor,
   sanitizePostgresJson,
   withConversationEventLock
-} from "./chunk-IIO5PFZX.js";
+} from "./chunk-AF4PHIP6.js";
 import {
   SANDBOX_WORKSPACE_ROOT,
   sleep
@@ -23,14 +23,14 @@ import {
   fenceLock,
   getStateAdapter,
   withLock
-} from "./chunk-MC57E5U5.js";
+} from "./chunk-PHQDXC27.js";
 import {
   botConfig,
   completeText,
   escapeXml,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-GKC43TLS.js";
+} from "./chunk-FAJ6SMEE.js";
 import {
   parseSlackMessageTs,
   toStoredSlackActor
@@ -40,7 +40,7 @@ import {
   logException,
   logWarn,
   setSpanAttributes
-} from "./chunk-X7W45B5G.js";
+} from "./chunk-KSZXVR5G.js";
 
 // src/chat/turn-context-tag.ts
 var TURN_CONTEXT_TAG = "runtime-turn-context";

package/dist/{chunk-X5NZQH5U.js → chunk-CZCMFRUQ.js}

@@ -56,6 +56,10 @@ var conversationSurfaceSchema = z2.enum([
 ]);
 var conversationUsageSchema = usageSchema;
 var conversationParamsSchema = z2.object({ conversationId: z2.string().min(1) }).strict();
+var conversationAttachmentParamsSchema = z2.object({
+  attachmentId: z2.string().min(1),
+  conversationId: z2.string().min(1)
+}).strict();
 var conversationDetailQuerySchema = z2.object({
   limit: z2.coerce.number().int().min(1).max(1e3).default(500)
 }).strict();
@@ -176,6 +180,17 @@ var conversationSummaryReportSchema = z2.object({
   sourceUrl: z2.string().url().optional(),
   traceId: z2.string().optional(),
   assignedWork: z2.boolean().optional(),
+  finishedWorkAt: z2.string().datetime().optional(),
+  /**
+   * Dashboard Priority membership for this conversation summary.
+   * Present on the conversation feed. Clients must not recompute it.
+   *
+   * True only when:
+   * - unfinished work was last seen within 48 hours
+   * - finished assigned work has conversation activity after the finish time
+   * - there is no known work and the conversation was last seen within 3 hours
+   */
+  isPriority: z2.boolean().optional(),
   unfinishedWork: z2.boolean().optional()
 }).strict();
 var conversationReportMessageEventDataSchema = z2.object({
@@ -782,6 +797,7 @@ var statsReportSchema = z8.object({
 export {
   apiErrorSchema,
   conversationParamsSchema,
+  conversationAttachmentParamsSchema,
   conversationDetailQuerySchema,
   conversationEventsQuerySchema,
   conversationFeedQuerySchema,

package/dist/{chunk-CK2H7CFO.js → chunk-DTVTBZNP.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-V7YE4WCP.js";
 import {
   toOptionalString
-} from "./chunk-X7W45B5G.js";
+} from "./chunk-KSZXVR5G.js";
 
 // src/chat/slack/context.ts
 import { z } from "zod";

package/dist/{chunk-WD7SEUZO.js → chunk-EQ6Y37MD.js}

@@ -5,7 +5,7 @@ import {
   logInfo,
   logWarn,
   setSpanAttributes
-} from "./chunk-X7W45B5G.js";
+} from "./chunk-KSZXVR5G.js";
 import {
   discoverInstalledPluginPackageContent,
   normalizePluginPackageNames