@sentry/junior 0.156.0 → 0.157.0

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

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

package/dist/{chunk-6JUU7J2B.js → chunk-GO2W3VZY.js}

@@ -4,18 +4,18 @@ import {
 } from "./chunk-EM225ITJ.js";
 import {
   getStateAdapter
-} from "./chunk-MC57E5U5.js";
+} from "./chunk-I3OQVVMV.js";
 import {
   toOptionalTrimmed
-} from "./chunk-GKC43TLS.js";
+} from "./chunk-UJYA75N5.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-EDJ64P2P.js";
+} from "./chunk-6MI43QZO.js";
 import {
   setSpanAttributes,
   setSpanStatus,
   withSpan
-} from "./chunk-X7W45B5G.js";
+} from "./chunk-MKA3T2R6.js";
 
 // src/chat/sandbox/resources.ts
 var configuredResources;

package/dist/{chunk-KCA5MKHU.js → chunk-HJ3EZHIX.js}

@@ -1,25 +1,27 @@
 import {
   ToolInputError
-} from "./chunk-3L2PMOSR.js";
+} from "./chunk-GEY6IFXH.js";
 import {
   canRouteResourceEvents,
   getPlugins
-} from "./chunk-3FFUC32L.js";
+} from "./chunk-MGJW3SW4.js";
 import {
   getDb
-} from "./chunk-IIO5PFZX.js";
+} from "./chunk-G2FN3I66.js";
 import {
+  juniorAttachments,
+  juniorConversations,
   juniorEventTasks,
   juniorSchedulerRuns,
   juniorSchedulerTasks,
   juniorStats
-} from "./chunk-AIJRG227.js";
+} from "./chunk-3GS7O66Z.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
 import {
   logInfo
-} from "./chunk-X7W45B5G.js";
+} from "./chunk-MKA3T2R6.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-MC57E5U5.js → chunk-I3OQVVMV.js}

@@ -1,6 +1,6 @@
 import {
   getChatConfig
-} from "./chunk-GKC43TLS.js";
+} from "./chunk-UJYA75N5.js";
 
 // src/chat/state/adapter.ts
 import { createMemoryState } from "@chat-adapter/state-memory";

package/dist/{chunk-NTNU6T2D.js → chunk-MDZQ62PB.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-EM225ITJ.js";
 import {
   getSlackBotToken
-} from "./chunk-GKC43TLS.js";
+} from "./chunk-UJYA75N5.js";
 import {
   parseSlackChannelReferenceId
 } from "./chunk-V7YE4WCP.js";
@@ -12,7 +12,7 @@ import {
   setSpanAttributes,
   setSpanStatus,
   withSpan
-} from "./chunk-X7W45B5G.js";
+} from "./chunk-MKA3T2R6.js";
 
 // src/chat/slack/client.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";

package/dist/{chunk-3FFUC32L.js → chunk-MGJW3SW4.js}

@@ -4,30 +4,30 @@ import {
   isConversationScopedChannel,
   isDmChannel,
   normalizeSlackConversationId
-} from "./chunk-NTNU6T2D.js";
+} from "./chunk-MDZQ62PB.js";
 import {
   getConversationEventStore,
   getDb
-} from "./chunk-IIO5PFZX.js";
+} from "./chunk-G2FN3I66.js";
 import {
   juniorConversationAnnotations,
   juniorConversationEvents,
   juniorIdentities,
   juniorUsers
-} from "./chunk-AIJRG227.js";
+} from "./chunk-3GS7O66Z.js";
 import {
   SANDBOX_WORKSPACE_ROOT
 } from "./chunk-EM225ITJ.js";
 import {
   getStateAdapter
-} from "./chunk-MC57E5U5.js";
+} from "./chunk-I3OQVVMV.js";
 import {
   botConfig,
   completeObject,
   embedTexts,
   getSlackBotToken,
   standardModelId
-} from "./chunk-GKC43TLS.js";
+} from "./chunk-UJYA75N5.js";
 import {
   isActorUserId,
   parseActorUserId,
@@ -40,7 +40,7 @@ import {
   logInfo,
   logWarn,
   normalizeIdentityEmail
-} from "./chunk-X7W45B5G.js";
+} from "./chunk-MKA3T2R6.js";
 
 // src/chat/plugins/agent-hooks.ts
 import {

package/dist/{chunk-X7W45B5G.js → chunk-MKA3T2R6.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-6GWA276C.js";
 import {
   getDeploymentTelemetryAttributes
-} from "./chunk-OGZPRMZA.js";
+} from "./chunk-F7VOY4VQ.js";
 
 // src/chat/logging.ts
 import path from "path";

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

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