@sentry/junior 0.154.0 → 0.156.0

package/dist/{chunk-DAJZZFU7.js → chunk-53W3LZEW.js}

@@ -7,7 +7,7 @@ import {
   PluginCredentialFailureError,
   agentNameSchema,
   createPluginAuthOrchestration
-} from "./chunk-FVY7AJ46.js";
+} from "./chunk-ZNWRYNCA.js";
 import {
   authorizationId
 } from "./chunk-DIB4GX3G.js";
@@ -32,7 +32,7 @@ import {
   searchSlackUsers,
   selectPluginGrant,
   toMcpProviderError
-} from "./chunk-PTJ75ZWR.js";
+} from "./chunk-4ZZDTHFC.js";
 import {
   RetryableDeliveryError,
   actorFromRun,
@@ -48,16 +48,13 @@ import {
   getSlackMessagePermalink,
   resolveBaseUrl,
   uploadFilesToConversation
-} from "./chunk-O4AQDOKA.js";
+} from "./chunk-7RAETIYO.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
   sandboxEgressCredentialContextSchema,
   sandboxEgressCredentialLeaseSchema
-} from "./chunk-HUO3UTAQ.js";
-import {
-  isExperimentalFeatureEnabled
-} from "./chunk-5IDFPCON.js";
+} from "./chunk-7MA4HV4W.js";
 import {
   bindSandboxFileSystem,
   buildCommandScript,
@@ -77,7 +74,7 @@ import {
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-6VWMX7NS.js";
+} from "./chunk-6JUU7J2B.js";
 import {
   SCHEDULED_TASK_SYSTEM_ACTOR,
   compactEventTask,
@@ -109,10 +106,10 @@ import {
   saveEventTask,
   scheduledTaskAttributes,
   writableEventTask
-} from "./chunk-DK2FSQHS.js";
+} from "./chunk-KCA5MKHU.js";
 import {
   parseSlackThreadId
-} from "./chunk-NUG3VYHL.js";
+} from "./chunk-CK2H7CFO.js";
 import {
   AGENTS_REMOVAL_NOTICE,
   AGENTS_REPLACEMENT_NOTICE,
@@ -182,7 +179,7 @@ import {
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   truncateText
-} from "./chunk-4U4MNYGP.js";
+} from "./chunk-3L2PMOSR.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS
 } from "./chunk-3Y47VMHV.js";
@@ -198,7 +195,7 @@ import {
   getSlackToolContext,
   readActorIdentity,
   resolveChannelCapabilities
-} from "./chunk-XYMCZGH6.js";
+} from "./chunk-3FFUC32L.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -207,7 +204,7 @@ import {
   isConversationScopedChannel,
   normalizeSlackConversationId,
   withSlackRetries
-} from "./chunk-7CPN5JTA.js";
+} from "./chunk-NTNU6T2D.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
@@ -219,10 +216,12 @@ import {
   instructionActors,
   instructionProvenanceFor,
   sameActorIdentity
-} from "./chunk-Y654CTW2.js";
+} from "./chunk-IIO5PFZX.js";
 import {
+  juniorAttachments,
+  juniorConversations,
   juniorIdentities
-} from "./chunk-CZD6M57V.js";
+} from "./chunk-AIJRG227.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -234,7 +233,7 @@ import {
 } from "./chunk-EM225ITJ.js";
 import {
   getStateAdapter
-} from "./chunk-NNN2WYAD.js";
+} from "./chunk-MC57E5U5.js";
 import {
   ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
@@ -267,7 +266,7 @@ import {
   resolveGatewayCredential,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-6PJXR4BC.js";
+} from "./chunk-GKC43TLS.js";
 import {
   canExposeConversationPayload,
   resolveConversationPrivacy,
@@ -277,16 +276,16 @@ import {
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes
-} from "./chunk-6AF5GOZA.js";
+} from "./chunk-MJE7XKWP.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-CCAU73CE.js";
+} from "./chunk-SRJA6QLM.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-3567VGCN.js";
+} from "./chunk-EDJ64P2P.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -294,18 +293,16 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-MSOZLASC.js";
+} from "./chunk-WD7SEUZO.js";
 import {
   credentialUserSubjectId
-} from "./chunk-RUIXF3YQ.js";
-import {
-  isUserActor
-} from "./chunk-HZF5P5UN.js";
+} from "./chunk-BDUENQD3.js";
 import {
+  isUserActor,
   parseSlackChannelId,
   parseSlackMessageTs,
   parseSlackUserId
-} from "./chunk-F3B2YJ76.js";
+} from "./chunk-V7YE4WCP.js";
 import {
   extractGenAiUsageAttributes,
   extractGenAiUsageSummary,
@@ -324,7 +321,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-3HX67UPN.js";
+} from "./chunk-X7W45B5G.js";
 import {
   startInactiveSpan,
   withActiveSpan
@@ -10540,15 +10537,327 @@ function createSlackMessageAddReactionTool(context, state) {
 }
 
 // src/chat/slack/tools/send-files.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
+
+// src/chat/attachments/store.ts
+import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
+import { and, asc, eq, inArray, isNotNull, isNull, or } from "drizzle-orm";
+var ATTACHMENT_GC_BATCH_LIMIT = 200;
+function attachmentDigest(file) {
+  return createHash4("sha256").update(file.data).digest("hex");
+}
+function attachmentId(args) {
+  return createHash4("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(eq(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(eq(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(eq(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: randomUUID3()
+  });
+  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(
+      and(
+        eq(juniorAttachments.id, id),
+        isNotNull(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(eq(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(eq(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(
+    and(
+      eq(juniorAttachments.id, id),
+      isNotNull(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(eq(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 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(
+    and(
+      inArray(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,
+    eq(
+      juniorAttachments.conversationId,
+      juniorConversations.conversationId
+    )
+  ).where(
+    and(
+      eq(juniorAttachments.provider, args.storage.provider),
+      or(
+        isNotNull(juniorAttachments.deleteRequestedAt),
+        isNotNull(juniorConversations.transcriptPurgedAt)
+      )
+    )
+  ).orderBy(asc(juniorAttachments.createdAt), asc(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,
+    eq(
+      juniorAttachments.conversationId,
+      juniorConversations.conversationId
+    )
+  ).where(
+    and(
+      inArray(
+        juniorAttachments.id,
+        rows.map((row) => row.id)
+      ),
+      or(
+        isNotNull(juniorAttachments.deleteRequestedAt),
+        isNotNull(juniorConversations.transcriptPurgedAt)
+      )
+    )
+  );
+  if (stillEligible.length === 0) return { deleted: 0 };
+  const removed = await args.db.db().delete(juniorAttachments).where(
+    inArray(
+      juniorAttachments.id,
+      stillEligible.map((row) => row.id)
+    )
+  ).returning({
+    id: juniorAttachments.id
+  });
+  return { deleted: removed.length };
+}
+
+// src/chat/slack/tools/send-files.ts
 import { z as z42 } from "zod";
 var sendFilesResultSchema = juniorToolOutputSchema.extend({
-  target: z42.string().min(1),
-  channel_id: z42.string().min(1),
   deduplicated: z42.boolean().optional(),
-  file_count: z42.number().int().nonnegative(),
-  file_ids: z42.array(z42.string().min(1)).optional(),
-  thread_ts: z42.string().min(1)
+  attachment_refs: z42.array(
+    z42.object({
+      id: z42.string().min(1),
+      name: z42.string().min(1)
+    })
+  )
 });
 function normalizeFiles(files) {
   return files.map((file) => ({
@@ -10558,7 +10867,7 @@ function normalizeFiles(files) {
   }));
 }
 function fileContentDigest(data) {
-  return createHash4("sha256").update(data).digest("hex");
+  return createHash5("sha256").update(data).digest("hex");
 }
 function fileOperationInput(files) {
   return files.map((file) => ({
@@ -10569,7 +10878,7 @@ function fileOperationInput(files) {
     sha256: fileContentDigest(file.data)
   }));
 }
-function createSendFilesTool(context, state, materializeFile) {
+function createSendFilesTool(context, state, materializeFile, attachments) {
   return zodTool({
     annotations: {
       destructiveHint: false,
@@ -10611,22 +10920,26 @@ function createSendFilesTool(context, state, materializeFile) {
           deduplicated: true
         });
       }
+      const stored = attachments ? await storeAttachments({
+        conversationId: attachments.conversationId,
+        db: attachments.db,
+        files: materializedFiles,
+        storage: attachments.storage
+      }) : [];
       const uploads = materializedFiles.map((file) => ({
         data: file.data,
         filename: file.filename
       }));
-      const uploaded = await uploadFilesToConversation({
+      await uploadFilesToConversation({
         channelId: activeChannelId,
         files: uploads,
         threadTs
       });
-      const fileIds = uploaded?.files?.map((file) => file.id).filter((id) => Boolean(id));
       const response = {
-        target: `${activeChannelId}:${threadTs}`,
-        channel_id: activeChannelId,
-        thread_ts: threadTs,
-        file_count: uploads.length,
-        ...fileIds ? { file_ids: fileIds } : {}
+        attachment_refs: stored.map((attachment, index) => ({
+          id: attachment.id,
+          name: materializedFiles[index].filename
+        }))
       };
       state.setOperationResult(operationKey, response);
       return response;
@@ -12009,7 +12322,7 @@ function createSlackThreadReadTool(context) {
 }
 
 // src/chat/tools/user-lookup.ts
-import { and, eq, or, sql } from "drizzle-orm";
+import { and as and2, eq as eq2, or as or2, sql } from "drizzle-orm";
 import { alias } from "drizzle-orm/pg-core";
 import { z as z54 } from "zod";
 var linkedSlackIdentity = alias(juniorIdentities, "user_lookup_slack_identity");
@@ -12075,12 +12388,12 @@ async function storedSlackUserByEmail(teamId, email) {
   const emailNormalized = normalizeIdentityEmail(email);
   if (!emailNormalized) return void 0;
   const identities = await getSqlExecutor().db().select().from(juniorIdentities).where(
-    and(
-      eq(juniorIdentities.provider, "slack"),
-      eq(juniorIdentities.providerTenantId, teamId),
-      eq(juniorIdentities.kind, "user"),
-      eq(juniorIdentities.emailVerified, true),
-      eq(juniorIdentities.emailNormalized, emailNormalized)
+    and2(
+      eq2(juniorIdentities.provider, "slack"),
+      eq2(juniorIdentities.providerTenantId, teamId),
+      eq2(juniorIdentities.kind, "user"),
+      eq2(juniorIdentities.emailVerified, true),
+      eq2(juniorIdentities.emailNormalized, emailNormalized)
     )
   ).limit(2);
   if (identities.length > 1) {
@@ -12132,18 +12445,18 @@ async function resolveSlack(teamId, query) {
 async function resolveStoredProvider(teamId, provider, query) {
   const rows = await getSqlExecutor().db().select({ slack: linkedSlackIdentity }).from(juniorIdentities).innerJoin(
     linkedSlackIdentity,
-    and(
-      eq(linkedSlackIdentity.userId, juniorIdentities.userId),
-      eq(linkedSlackIdentity.kind, "user"),
-      eq(linkedSlackIdentity.provider, "slack"),
-      eq(linkedSlackIdentity.providerTenantId, teamId)
+    and2(
+      eq2(linkedSlackIdentity.userId, juniorIdentities.userId),
+      eq2(linkedSlackIdentity.kind, "user"),
+      eq2(linkedSlackIdentity.provider, "slack"),
+      eq2(linkedSlackIdentity.providerTenantId, teamId)
     )
   ).where(
-    and(
-      eq(juniorIdentities.kind, "user"),
-      eq(juniorIdentities.provider, provider),
-      or(
-        eq(juniorIdentities.providerSubjectId, query),
+    and2(
+      eq2(juniorIdentities.kind, "user"),
+      eq2(juniorIdentities.provider, provider),
+      or2(
+        eq2(juniorIdentities.providerSubjectId, query),
         sql`lower(${juniorIdentities.handle}) = lower(${query})`
       )
     )
@@ -13323,7 +13636,12 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
       tools.sendFiles = createSendFilesTool(
         slackContext,
         state,
-        (input) => readSandboxFileUpload(context.workspace, input)
+        (input) => readSandboxFileUpload(context.workspace, input),
+        context.conversationId && context.attachmentStorage ? {
+          conversationId: context.conversationId,
+          db: getSqlExecutor(),
+          storage: context.attachmentStorage
+        } : void 0
       );
     }
     tools.slackChannelListMessages = createSlackChannelListMessagesTool(slackContext);
@@ -14672,7 +14990,7 @@ function createMcpAuthOrchestration(input) {
 }
 
 // src/chat/egress/plugin.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // src/chat/sandbox/egress/credentials.ts
 var HTTP_READ_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
@@ -15409,8 +15727,8 @@ async function executeCredentialedEgressRequest(input) {
 function credentialContextForPluginEgress(credentialContext) {
   return {
     credentials: credentialContext,
-    contextId: randomUUID3(),
-    egressId: `plugin-egress:${randomUUID3()}`,
+    contextId: randomUUID4(),
+    egressId: `plugin-egress:${randomUUID4()}`,
     expiresAtMs: Date.now() + 30 * 60 * 1e3
   };
 }
@@ -15945,7 +16263,8 @@ async function wireAgentTools(args) {
   });
   const toolRuntimeContext = {
     ...commonToolRuntimeContext,
-    ...toolRoute
+    ...toolRoute,
+    attachmentStorage: args.run.environment?.attachmentStorage
   };
   const actionReview = createToolActionReview({
     context: {
@@ -18120,33 +18439,6 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
   }
 }
 
-// src/chat/runtime/agent-runner.ts
-function createAgentRunner(execute, options) {
-  const streamFn = options?.streamFn;
-  const tracePropagation = options?.tracePropagation;
-  const bindSpawnAgent = options?.bindSpawnAgent;
-  const canBindSpawn = Boolean(bindSpawnAgent) && isExperimentalFeatureEnabled("subagents");
-  return {
-    run: async (run) => {
-      const spawnAgent = bindSpawnAgent && canBindSpawn && !isAgentRunFeatureDisabled(run.disabledFeatures, "subagents") ? bindSpawnAgent(run) : void 0;
-      const nextRun = {
-        ...run,
-        environment: {
-          ...run.environment,
-          sandboxTracePropagation: run.environment?.sandboxTracePropagation ?? tracePropagation
-        },
-        ...spawnAgent ? {
-          durability: {
-            ...run.durability,
-            spawnAgent
-          }
-        } : {}
-      };
-      return await execute(nextRun, streamFn);
-    }
-  };
-}
-
 export {
   setConfigDefaults,
   getConfigDefaults,
@@ -18166,11 +18458,12 @@ export {
   deliverResourceEventSubscription,
   sanitizeScheduledTaskPrincipal,
   listThreadReplies,
+  requestAttachmentDeletion,
+  collectAttachmentGarbage,
   renderBlockText,
   renderAttachmentText,
   latestReportedProgress,
   executeCredentialedEgressRequest,
   createContextCompactor,
-  executeAgentRun,
-  createAgentRunner
+  executeAgentRun
 };