@sentry/junior 0.155.0 → 0.157.0

package/dist/{chunk-2AHVM3HK.js → chunk-AFQ47JQ7.js}

@@ -3,38 +3,38 @@ import {
 } from "./chunk-RF6J3DIO.js";
 import {
   resolveBaseUrl
-} from "./chunk-KBT2I5ER.js";
+} from "./chunk-VDAEXEBB.js";
 import {
   isExperimentalFeatureEnabled
 } from "./chunk-5IDFPCON.js";
 import {
   createPluginLogger,
   getPlugins
-} from "./chunk-V57LZDHN.js";
+} from "./chunk-MGJW3SW4.js";
 import {
   getSlackClient,
   withSlackRetries
-} from "./chunk-TKJ7277U.js";
+} from "./chunk-MDZQ62PB.js";
 import {
   getDb,
   parseDestination
-} from "./chunk-JJX77MB7.js";
+} from "./chunk-G2FN3I66.js";
 import {
   sleep
 } from "./chunk-EM225ITJ.js";
 import {
   acquireActiveLock,
   getStateAdapter
-} from "./chunk-SDRJ2LE3.js";
+} from "./chunk-I3OQVVMV.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-TVXAN43I.js";
+} from "./chunk-6MI43QZO.js";
 import {
   fetchWithBoundedOAuthErrorBodies
-} from "./chunk-RN3AWYEP.js";
+} from "./chunk-77QB5FNI.js";
 import {
   isRecord
-} from "./chunk-7NYEB2TM.js";
+} from "./chunk-MKA3T2R6.js";
 
 // src/chat/capabilities/router.ts
 var ProviderCredentialRouter = class {
@@ -149,6 +149,7 @@ async function issueProviderCredentialLease(input) {
 // src/chat/runtime/agent-runner.ts
 var AGENT_ABORT_SETTLE_GRACE_MS = 5e3;
 function createAgentRunner(execute, options) {
+  const attachmentStorage = options?.attachmentStorage;
   const streamFn = options?.streamFn;
   const tracePropagation = options?.tracePropagation;
   const bindSpawnAgent = options?.bindSpawnAgent;
@@ -160,6 +161,7 @@ function createAgentRunner(execute, options) {
         ...run,
         environment: {
           ...run.environment,
+          attachmentStorage: run.environment?.attachmentStorage ?? attachmentStorage,
           sandboxTracePropagation: run.environment?.sandboxTracePropagation ?? tracePropagation
         },
         ...spawnAgent ? {

package/dist/{chunk-ELOTIL5F.js → chunk-BLCVTEE7.js}

@@ -8,14 +8,14 @@ import {
   getConversationStore,
   parseDestination,
   sameDestination
-} from "./chunk-JJX77MB7.js";
+} from "./chunk-G2FN3I66.js";
 import {
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-SDRJ2LE3.js";
+} from "./chunk-I3OQVVMV.js";
 import {
   getChatConfig
-} from "./chunk-XFZLQANQ.js";
+} from "./chunk-UJYA75N5.js";
 import {
   parseStoredSlackActor
 } from "./chunk-V7YE4WCP.js";
@@ -23,7 +23,7 @@ import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-7NYEB2TM.js";
+} from "./chunk-MKA3T2R6.js";
 
 // src/chat/task-execution/state.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-ZLSFOSDK.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();
@@ -175,13 +179,25 @@ var conversationSummaryReportSchema = z2.object({
   sentryTraceUrl: z2.string().optional(),
   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({
   type: z2.literal("message"),
   messageId: z2.string().min(1),
   role: z2.enum(["assistant", "system", "user"]),
-  source: z2.literal("web").optional(),
+  source: z2.enum(["slack", "web"]).optional(),
   actorIdentity: actorIdentitySchema.optional(),
   eventType: z2.string().min(1).optional(),
   explicitMention: z2.boolean().optional(),
@@ -781,6 +797,7 @@ var statsReportSchema = z8.object({
 export {
   apiErrorSchema,
   conversationParamsSchema,
+  conversationAttachmentParamsSchema,
   conversationDetailQuerySchema,
   conversationEventsQuerySchema,
   conversationFeedQuerySchema,

package/dist/{chunk-2WLJDM23.js → chunk-D7BNWRYL.js}

@@ -1,6 +1,6 @@
 import {
   logWarn
-} from "./chunk-7NYEB2TM.js";
+} from "./chunk-MKA3T2R6.js";
 
 // src/chat/conversation-privacy.ts
 import { AsyncLocalStorage } from "async_hooks";

package/dist/{chunk-EORR34UB.js → chunk-F7VOY4VQ.js}

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

package/dist/{chunk-JJX77MB7.js → chunk-G2FN3I66.js}

@@ -6,12 +6,12 @@ import {
   juniorConversations,
   juniorIdentities,
   juniorUsers
-} from "./chunk-773XC7P4.js";
+} from "./chunk-3GS7O66Z.js";
 import {
   TURN_REASONING_LEVELS,
   getChatConfig,
   modelProfileSchema
-} from "./chunk-XFZLQANQ.js";
+} from "./chunk-UJYA75N5.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
@@ -22,7 +22,7 @@ import {
 } from "./chunk-V7YE4WCP.js";
 import {
   normalizeIdentityEmail
-} from "./chunk-7NYEB2TM.js";
+} from "./chunk-MKA3T2R6.js";
 
 // src/chat/conversations/sql/store.ts
 import { randomUUID as randomUUID2 } from "crypto";

package/dist/{chunk-J2SYI36O.js → chunk-GEY6IFXH.js}

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

package/dist/{chunk-37G5HJ2X.js → chunk-GO2W3VZY.js}

@@ -4,18 +4,18 @@ import {
 } from "./chunk-EM225ITJ.js";
 import {
   getStateAdapter
-} from "./chunk-SDRJ2LE3.js";
+} from "./chunk-I3OQVVMV.js";
 import {
   toOptionalTrimmed
-} from "./chunk-XFZLQANQ.js";
+} from "./chunk-UJYA75N5.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-TVXAN43I.js";
+} from "./chunk-6MI43QZO.js";
 import {
   setSpanAttributes,
   setSpanStatus,
   withSpan
-} from "./chunk-7NYEB2TM.js";
+} from "./chunk-MKA3T2R6.js";
 
 // src/chat/sandbox/resources.ts
 var configuredResources;

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

@@ -1,25 +1,27 @@
 import {
   ToolInputError
-} from "./chunk-J2SYI36O.js";
+} from "./chunk-GEY6IFXH.js";
 import {
   canRouteResourceEvents,
   getPlugins
-} from "./chunk-V57LZDHN.js";
+} from "./chunk-MGJW3SW4.js";
 import {
   getDb
-} from "./chunk-JJX77MB7.js";
+} from "./chunk-G2FN3I66.js";
 import {
+  juniorAttachments,
+  juniorConversations,
   juniorEventTasks,
   juniorSchedulerRuns,
   juniorSchedulerTasks,
   juniorStats
-} from "./chunk-773XC7P4.js";
+} from "./chunk-3GS7O66Z.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
 import {
   logInfo
-} from "./chunk-7NYEB2TM.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-SDRJ2LE3.js → chunk-I3OQVVMV.js}

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

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

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