@sentry/junior 0.184.0 → 0.186.0

package/dist/{chunk-UBOIHNTH.js → chunk-7EU4YSZ4.js}

@@ -1,36 +1,45 @@
 import {
   createWebAuthorization,
   deleteWebAuthorization
-} from "./chunk-LCP4EDKR.js";
+} from "./chunk-PZZOGHVR.js";
+import {
+  AgentRunError,
+  executeTurn
+} from "./chunk-GQMQCY7H.js";
 import {
   buildDeliveredTurnStatePatch,
   completeAuthPauseTurn,
   finalizeFailedTurnReplyWithEvent,
   getTurnUserMessage
-} from "./chunk-M5YWNMTE.js";
+} from "./chunk-OZG7E22Y.js";
 import {
   processPluginTask,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-6WGC3SO4.js";
+} from "./chunk-MCLWOBPN.js";
 import {
   ConversationTurnLifecycleService
-} from "./chunk-M3QYTBQ6.js";
+} from "./chunk-STOCCPWH.js";
 import {
   coerceThreadConversationState,
   getPersistedSandboxState,
   getPersistedThreadState,
   persistThreadStateById
-} from "./chunk-E57WPXWY.js";
+} from "./chunk-CM6RTYSO.js";
 import {
   healthReportSchema
 } from "./chunk-UTL3MHPC.js";
+import {
+  RESOURCE_EVENT_AUTHOR_ID,
+  isResourceEventConversationMessage,
+  isResourceEventMailboxMetadata
+} from "./chunk-DHYZ4VKG.js";
 import {
   parseSlackThreadId
-} from "./chunk-YKX6MTLU.js";
+} from "./chunk-7EOWT62G.js";
 import {
   appendAndEnqueueExclusiveInboundMessage,
   appendAndEnqueueInboundMessage
-} from "./chunk-Z3QAXJR7.js";
+} from "./chunk-2IBDVE62.js";
 import {
   TurnInputCommitLostError,
   buildDeterministicTurnId,
@@ -41,10 +50,11 @@ import {
   markTurnClosed,
   markTurnFailed,
   startActiveTurn
-} from "./chunk-JA43DV4Y.js";
+} from "./chunk-VOGOTEW7.js";
 import {
   abandonTurnRecord,
   buildConversationContext,
+  commitAcceptedReply,
   getTurnRecord,
   hydrateConversationMessages,
   listTurnSummaries,
@@ -56,35 +66,39 @@ import {
   recordDeliveredAssistantMessage,
   saveTurnCheckpoint,
   upsertConversationMessage
-} from "./chunk-2ZQPVX7C.js";
+} from "./chunk-H7X2G2KS.js";
 import {
   normalizeSlackConversationId
-} from "./chunk-4CNDGK25.js";
+} from "./chunk-JFPY6XFF.js";
 import {
   getConversationEventStore,
   getConversationStore,
   getDb
-} from "./chunk-IZDYYYGP.js";
+} from "./chunk-43LODHJM.js";
 import {
   juniorConversationParticipants,
   juniorConversations,
   juniorIdentities,
   juniorUsers
-} from "./chunk-BCHYQS4B.js";
+} from "./chunk-VXL2LBPK.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
+import {
+  getSlackBotToken
+} from "./chunk-AD64YMEC.js";
 import {
   canExposeConversationPayload
-} from "./chunk-BHYRYYLY.js";
+} from "./chunk-FFYDRLXW.js";
 import {
   credentialContextForActor
 } from "./chunk-CEMMLV5L.js";
 import {
   logException,
+  logWarn,
   setTags,
   withLogContext
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-3CVEE6LA.js";
 
 // src/handlers/health.ts
 function readHealthReport() {
@@ -174,11 +188,33 @@ function parseApiTurnMessages(messages) {
     return { message: entry.message, metadata: entry.metadata.data };
   });
 }
+function parseLocalResourceEventMessages(messages) {
+  if (messages.length === 0) {
+    return [];
+  }
+  if (!messages.every(
+    (message) => message.source === "resource_event" && isResourceEventMailboxMetadata(message.input.metadata)
+  )) {
+    return [];
+  }
+  return messages.map((message) => ({
+    message,
+    kind: "resource_event"
+  }));
+}
 async function resolveApiTurnWork(context) {
   const batch = parseApiTurnMessages(context.attempt.messages);
   if (batch.length > 0) {
     return { kind: "mailbox", batch };
   }
+  if (context.destination?.platform === "local") {
+    const resourceBatch = parseLocalResourceEventMessages(
+      context.attempt.messages
+    );
+    if (resourceBatch.length > 0) {
+      return { kind: "resource_event", batch: resourceBatch };
+    }
+  }
   if (context.attempt.messages.length > 0) {
     return void 0;
   }
@@ -192,10 +228,40 @@ async function isApiTurnWork(context) {
 // src/chat/api-turns/work.ts
 import { createHash } from "crypto";
 import {
+  createLocalSource,
   createWebSource,
   localDestinationSchema
 } from "@sentry/junior-plugin-api";
 
+// src/chat/api-turns/accepted-reply.ts
+async function commitWebAcceptedReply(args) {
+  const conversationMessageId = recordDeliveredAssistantMessage({
+    conversation: args.conversation,
+    sessionId: args.sessionId,
+    source: "web",
+    text: args.text,
+    userMessageId: args.userMessageId
+  });
+  try {
+    await persistWithRetry(
+      () => commitAcceptedReply({
+        ...args.agentMessage ? { agentMessage: args.agentMessage } : void 0,
+        conversation: args.conversation,
+        conversationMessageId,
+        conversationId: args.conversationId
+      })
+    );
+  } catch (error) {
+    logException(
+      new Error("Accepted assistant message persistence failed"),
+      "api.assistant.message_post_delivery_persist.failed",
+      {
+        "error.type": error instanceof Error ? error.name : typeof error
+      }
+    );
+  }
+}
+
 // src/chat/api-turns/cancellation.ts
 function createApiTurnCancellation() {
   const active = /* @__PURE__ */ new Map();
@@ -217,7 +283,7 @@ function createApiTurnCancellation() {
       if (!entry) {
         return false;
       }
-      entry.controller.abort(new Error("API Turn cancelled"));
+      entry.controller.abort(new DOMException("Turn cancelled", "AbortError"));
       return true;
     },
     disconnect(conversationId, signal) {
@@ -257,7 +323,7 @@ async function completeCancelledApiTurn(args) {
     await abandonTurnRecord({
       conversationId: args.conversationId,
       turnId: args.turnId,
-      errorMessage: "API Turn cancelled"
+      errorMessage: "Turn cancelled"
     });
     clearPendingAuth(args.conversation, args.turnId);
     markConversationMessage(args.conversation, args.userMessageId, {
@@ -279,7 +345,9 @@ async function completeCancelledApiTurn(args) {
       conversation: args.conversation,
       sandboxRef: args.sandboxRef
     });
-    await args.lifecycle.complete({
+    await new ConversationTurnLifecycleService(
+      getConversationEventStore()
+    ).complete({
       conversationId: args.conversationId,
       createdAtMs: Date.now(),
       outcome: "cancelled",
@@ -293,6 +361,19 @@ async function completeCancelledApiTurn(args) {
   await args.acknowledge();
 }
 
+// src/chat/api-turns/mailbox-input.ts
+function joinMailboxText(messages) {
+  return messages.map((message) => message.input.text.trim()).filter(Boolean).join("\n\n");
+}
+function localResourceEventActor() {
+  return {
+    platform: "local",
+    userId: RESOURCE_EVENT_AUTHOR_ID,
+    userName: "junior-event",
+    fullName: "Junior event"
+  };
+}
+
 // src/chat/api-turns/work.ts
 function normalizeEmail(email) {
   return email.trim().toLowerCase();
@@ -504,66 +585,97 @@ function hasLostTurnInputCommit(error) {
   const cause = getConversationTurnBoundaryError(error)?.cause ?? error;
   return isTurnInputCommitLostError(error) || isTurnInputCommitLostError(cause);
 }
-function createApiTurnWorker(options) {
+function createApiTurnWorker(agentRunner, cancellation) {
   return async (context) => {
     const resolved = await resolveApiTurnWork(context);
     if (!resolved) {
       throw new Error(
-        `API turn worker received non-API work for ${context.conversationId}`
+        `Conversation API worker received other work for ${context.conversationId}`
       );
     }
     if (context.publishExternally) {
       throw new Error(
-        `API turn work must not publish externally for ${context.conversationId}`
+        `Conversation API work cannot publish to a provider for ${context.conversationId}`
       );
     }
-    const lifecycle = options.turnLifecycle ?? new ConversationTurnLifecycleService(getConversationEventStore());
+    const lifecycle = new ConversationTurnLifecycleService(
+      getConversationEventStore()
+    );
     const isResume = resolved.kind === "resume";
+    let isResourceEvent = resolved.kind === "resource_event";
     let actor;
-    let text;
-    let turnId;
-    let userMessageId;
-    let startedAtMs;
-    let inputMessageIds;
+    let text = "";
+    let turnId = "";
+    let userMessageId = "";
+    let startedAtMs = Date.now();
+    let inputMessageIds = [];
     const storedConversation = await getConversationStore().get({
       conversationId: context.conversationId
     });
+    const mailboxDestination = resolved.kind === "mailbox" || resolved.kind === "resource_event" ? resolved.batch[0]?.message.destination : void 0;
+    const destination = resolveApiTurnDestination({
+      conversationId: context.conversationId,
+      existing: context.destination ?? mailboxDestination ?? storedConversation?.destination
+    });
+    const sourceFor = (resourceEvent) => resourceEvent ? createLocalSource(context.conversationId) : webSourceForConversation({
+      conversationId: context.conversationId,
+      visibility: storedConversation?.visibility
+    });
+    let source = sourceFor(isResourceEvent);
     if (resolved.kind === "mailbox") {
       const first = resolved.batch[0];
-      text = resolved.batch.map((entry) => entry.message.input.text.trim()).filter(Boolean).join("\n\n");
+      text = joinMailboxText(resolved.batch.map((entry) => entry.message));
       actor = actorFromMetadata(first.metadata);
       turnId = apiTurnIdForMessage(first.metadata.messageId);
       userMessageId = first.metadata.messageId;
       startedAtMs = first.message.createdAtMs;
       inputMessageIds = resolved.batch.map((entry) => entry.metadata.messageId);
+    } else if (resolved.kind === "resource_event") {
+      const first = resolved.batch[0];
+      text = joinMailboxText(resolved.batch.map((entry) => entry.message));
+      actor = localResourceEventActor();
+      turnId = apiTurnIdForMessage(first.message.inboundMessageId);
+      userMessageId = first.message.inboundMessageId;
+      startedAtMs = first.message.createdAtMs;
+      inputMessageIds = resolved.batch.map(
+        (entry) => entry.message.inboundMessageId
+      );
     } else {
       turnId = resolved.turnId;
-      const resumedActor = actorFromStoredConversation(
-        storedConversation?.actor
-      );
-      if (!resumedActor) {
+      actor = actorFromStoredConversation(storedConversation?.actor);
+    }
+    const persisted = await getPersistedThreadState(context.conversationId);
+    const conversation = coerceThreadConversationState(persisted);
+    await hydrateConversationMessages({
+      conversation,
+      conversationId: context.conversationId
+    });
+    if (isResume) {
+      const userMessage = getTurnUserMessage(conversation, turnId);
+      if (!userMessage) {
         throw new Error(
-          `API turn resume missing actor for ${context.conversationId}`
+          `Unable to locate the persisted user message for Turn "${turnId}"`
         );
       }
-      actor = resumedActor;
-      text = "";
-      userMessageId = "";
-      startedAtMs = Date.now();
-      inputMessageIds = [];
+      if (isResourceEventConversationMessage(userMessage)) {
+        isResourceEvent = true;
+        actor = localResourceEventActor();
+        source = sourceFor(true);
+      }
+      userMessageId = userMessage.id;
+      text = userMessage.text;
+      startedAtMs = userMessage.createdAtMs;
+      inputMessageIds = [userMessageId];
+    }
+    if (!actor) {
+      throw new Error(
+        `Conversation API resume missing actor for ${context.conversationId}`
+      );
     }
-    const destination = resolveApiTurnDestination({
-      conversationId: context.conversationId,
-      existing: context.destination ?? (resolved.kind === "mailbox" ? resolved.batch[0]?.message.destination : void 0) ?? storedConversation?.destination
-    });
-    const source = webSourceForConversation({
-      conversationId: context.conversationId,
-      visibility: storedConversation?.visibility
-    });
     return await withLogContext(
       {
         conversationId: context.conversationId,
-        platform: "web",
+        platform: isResourceEvent ? "local" : "web",
         userId: actor.userId,
         ...actor.userName ? { userName: actor.userName } : void 0
       },
@@ -577,25 +689,19 @@ function createApiTurnWorker(options) {
             await context.attempt.ack();
           } catch {
             throw new TurnInputCommitLostError(
-              `Conversation work lease lost before API turn inbox ack for ${context.conversationId}`
+              `Conversation work lease lost before Conversation API message acknowledgement for ${context.conversationId}`
             );
           }
           acknowledged = true;
         };
-        const persisted = await getPersistedThreadState(context.conversationId);
-        const conversation = coerceThreadConversationState(persisted);
-        await hydrateConversationMessages({
-          conversation,
-          conversationId: context.conversationId
-        });
         let sandboxRef = getPersistedSandboxState(persisted);
         const initialSandboxRef = sandboxRef;
-        const appSignal = options.cancellation?.signal(context.conversationId);
+        const appSignal = cancellation?.signal(context.conversationId);
         const stopSignal = context.stopSignal?.();
         const cancellationSignal = appSignal && stopSignal ? AbortSignal.any([appSignal, stopSignal]) : appSignal ?? stopSignal;
         const finishCancellation = () => {
           if (appSignal) {
-            options.cancellation?.finish(context.conversationId, appSignal);
+            cancellation?.finish(context.conversationId, appSignal);
           }
         };
         const completeCancelledTurn = async () => {
@@ -603,10 +709,9 @@ function createApiTurnWorker(options) {
             await completeCancelledApiTurn({
               acknowledge,
               actorId: actor.userId,
-              cancellation: options.cancellation,
+              cancellation,
               conversation,
               conversationId: context.conversationId,
-              lifecycle,
               sandboxRef,
               signal: appSignal,
               turnId,
@@ -621,16 +726,6 @@ function createApiTurnWorker(options) {
           return { status: "completed" };
         };
         if (isResume) {
-          const userMessage = getTurnUserMessage(conversation, turnId);
-          if (!userMessage) {
-            throw new Error(
-              `Unable to locate the persisted user message for API turn "${turnId}"`
-            );
-          }
-          userMessageId = userMessage.id;
-          text = userMessage.text;
-          startedAtMs = userMessage.createdAtMs;
-          inputMessageIds = [userMessageId];
           if (cancellationSignal?.aborted) {
             return await completeCancelledTurn();
           }
@@ -649,7 +744,7 @@ function createApiTurnWorker(options) {
             meta: {
               explicitMention: true,
               replied: false,
-              source: "web"
+              ...isResourceEvent ? void 0 : { source: "web" }
             }
           });
           await persistConversationMessages({
@@ -676,37 +771,23 @@ function createApiTurnWorker(options) {
         let failureCode = "persistence_failed";
         let modelFailureEventId;
         let modelFailureCaptureAttempted = false;
-        let reply;
+        let completedSuccessfully = false;
         const deliverAssistantMessage = async (value) => {
+          const agentMessage = typeof value === "string" ? void 0 : value;
           const replyText = typeof value === "string" ? value : getAssistantReplyText(value);
           if (!replyText?.trim()) {
             return;
           }
           failureCode = "delivery_failed";
           assistantMessageDelivered = true;
-          recordDeliveredAssistantMessage({
+          await commitWebAcceptedReply({
+            ...agentMessage ? { agentMessage } : void 0,
             conversation,
+            conversationId: context.conversationId,
             sessionId: turnId,
-            source: "web",
             text: replyText,
             userMessageId
           });
-          try {
-            await persistWithRetry(
-              () => persistConversationMessages({
-                conversation,
-                conversationId: context.conversationId
-              })
-            );
-          } catch (error) {
-            logException(
-              new Error("Accepted assistant message persistence failed"),
-              "api.assistant.message_post_delivery_persist.failed",
-              {
-                "error.type": error instanceof Error ? error.name : typeof error
-              }
-            );
-          }
           failureCode = "agent_run_failed";
         };
         try {
@@ -751,53 +832,112 @@ function createApiTurnWorker(options) {
           failureCode = "agent_run_failed";
           currentRunId = `api-run:${stableHex(turnId, String(startedAtMs))}`;
           setTags({ runId: currentRunId });
-          const outcome = await options.agentRunner.run({
-            conversationId: context.conversationId,
-            turnId,
-            runId: currentRunId,
-            instruction: {
-              text,
-              context: buildConversationContext(conversation, {
-                excludeMessageId: userMessageId
-              })
-            },
-            history: piMessages,
-            actor,
-            credentialContext: credentialContextForActor(actor),
-            destination,
-            publishExternally: false,
-            source,
-            surface: "api",
-            ...cancellationSignal ? { signal: cancellationSignal } : void 0,
-            authorization: createWebAuthorization({
-              actorId: actor.userId,
-              conversationId: context.conversationId
-            }),
-            state: {
-              pendingAuth: conversation.processing.pendingAuth,
-              sandboxRef
-            },
-            delivery: deliverAssistantMessage,
-            durability: {
-              onInputCommitted: acknowledge,
-              shouldYield: context.shouldYield,
-              onSandboxRefChanged: async (nextSandboxRef) => {
-                sandboxRef = nextSandboxRef;
-                await persistThreadStateById(context.conversationId, {
-                  conversation,
-                  sandboxRef
-                });
+          const outcome = await executeTurn(
+            agentRunner,
+            {
+              conversationId: context.conversationId,
+              turnId,
+              runId: currentRunId,
+              instruction: {
+                text,
+                context: buildConversationContext(conversation, {
+                  excludeMessageId: userMessageId
+                })
+              },
+              history: piMessages,
+              actor,
+              credentialContext: credentialContextForActor(actor),
+              destination,
+              publishExternally: false,
+              source,
+              surface: "api",
+              ...cancellationSignal ? { signal: cancellationSignal } : void 0,
+              authorization: createWebAuthorization({
+                actorId: actor.userId,
+                conversationId: context.conversationId
+              }),
+              state: {
+                pendingAuth: conversation.processing.pendingAuth,
+                sandboxRef
               },
-              recordPendingAuth: async (pendingAuth) => {
-                conversation.processing.pendingAuth = pendingAuth;
-                await persistThreadStateById(context.conversationId, {
-                  conversation,
-                  sandboxRef
+              delivery: deliverAssistantMessage,
+              durability: {
+                onInputCommitted: acknowledge,
+                shouldYield: context.shouldYield,
+                onSandboxRefChanged: async (nextSandboxRef) => {
+                  sandboxRef = nextSandboxRef;
+                  await persistThreadStateById(context.conversationId, {
+                    conversation,
+                    sandboxRef
+                  });
+                },
+                recordPendingAuth: async (pendingAuth) => {
+                  conversation.processing.pendingAuth = pendingAuth;
+                  await persistThreadStateById(context.conversationId, {
+                    conversation,
+                    sandboxRef
+                  });
+                }
+              }
+            },
+            async (result) => {
+              if (cancellationSignal?.aborted) {
+                throw cancellationSignal.reason ?? new DOMException("Turn cancelled", "AbortError");
+              }
+              finishCancellation();
+              modelFailureCaptureAttempted = result.diagnostics.outcome !== "success";
+              const finalized = finalizeFailedTurnReplyWithEvent({
+                reply: result,
+                logException
+              });
+              const modelFailureReason = finalized.failureReason;
+              const reply = finalized.reply;
+              modelFailureEventId = finalized.eventId;
+              if (reply.diagnostics.outcome !== "success") {
+                await deliverAssistantMessage(reply.text);
+              }
+              const completedState = buildDeliveredTurnStatePatch({
+                conversation,
+                reply,
+                sessionId: turnId,
+                userMessageId
+              });
+              await persistThreadStateById(context.conversationId, {
+                conversation: completedState.conversation,
+                sandboxRef: reply.sandboxRef ?? sandboxRef
+              });
+              if (reply.piMessages?.length) {
+                const latest = await getTurnRecord(
+                  context.conversationId,
+                  turnId
+                );
+                await saveTurnCheckpoint({
+                  mode: "completed",
+                  conversationId: context.conversationId,
+                  turnId,
+                  sliceId: latest?.sliceId ?? 1,
+                  messages: reply.piMessages,
+                  durationMs: reply.diagnostics.durationMs,
+                  usage: reply.diagnostics.usage,
+                  destination,
+                  publishExternally: false,
+                  source,
+                  actor,
+                  surface: "api"
                 });
               }
+              completedSuccessfully = reply.diagnostics.outcome === "success";
+              return completedSuccessfully ? {
+                outcome: assistantMessageDelivered ? "success" : "no_reply"
+              } : {
+                ...modelFailureEventId ? { eventId: modelFailureEventId } : void 0,
+                failureCode: "model_execution_failed",
+                ...modelFailureReason ? { failureReason: modelFailureReason } : void 0,
+                outcome: "failed"
+              };
             }
-          });
-          if (cancellationSignal?.aborted) {
+          );
+          if (outcome.status !== "completed" && cancellationSignal?.aborted) {
             return await completeCancelledTurn();
           }
           if (outcome.status === "suspended") {
@@ -813,57 +953,12 @@ function createApiTurnWorker(options) {
               sandboxRef
             });
             if (appSignal) {
-              options.cancellation?.park(context.conversationId, appSignal);
+              cancellation?.park(context.conversationId, appSignal);
             }
             await acknowledge();
             return { status: "paused" };
           }
-          finishCancellation();
-          reply = outcome.result;
-          modelFailureCaptureAttempted = reply.diagnostics.outcome !== "success";
-          const finalized = finalizeFailedTurnReplyWithEvent({
-            reply,
-            logException
-          });
-          reply = finalized.reply;
-          modelFailureEventId = finalized.eventId;
-          if (reply.diagnostics.outcome !== "success") {
-            await deliverAssistantMessage(reply.text);
-          }
-          const completedState = buildDeliveredTurnStatePatch({
-            conversation,
-            reply,
-            sessionId: turnId,
-            userMessageId
-          });
-          await persistThreadStateById(context.conversationId, {
-            conversation: completedState.conversation,
-            sandboxRef: reply.sandboxRef ?? sandboxRef
-          });
-          if (reply.piMessages?.length) {
-            const latest = await getTurnRecord(context.conversationId, turnId);
-            await saveTurnCheckpoint({
-              mode: "completed",
-              conversationId: context.conversationId,
-              turnId,
-              sliceId: latest?.sliceId ?? 1,
-              messages: reply.piMessages,
-              durationMs: reply.diagnostics.durationMs,
-              usage: reply.diagnostics.usage,
-              destination,
-              publishExternally: false,
-              source,
-              actor,
-              surface: "api"
-            });
-          }
-          if (reply.diagnostics.outcome === "success") {
-            await lifecycle.complete({
-              conversationId: context.conversationId,
-              createdAtMs: Date.now(),
-              outcome: assistantMessageDelivered ? "success" : "no_reply",
-              turnId
-            });
+          if (completedSuccessfully) {
             try {
               await scheduleSessionCompletedPluginTasks(
                 {
@@ -895,30 +990,23 @@ function createApiTurnWorker(options) {
                 turnId
               });
             }
-          } else {
-            await lifecycle.fail({
-              conversationId: context.conversationId,
-              createdAtMs: Date.now(),
-              ...modelFailureEventId ? { eventId: modelFailureEventId } : void 0,
-              failureCode: "model_execution_failed",
-              turnId
-            });
           }
           await acknowledge();
           return { status: "completed" };
         } catch (error) {
-          if (hasLostTurnInputCommit(error)) {
+          const failure = error instanceof AgentRunError ? error.cause : error;
+          if (hasLostTurnInputCommit(failure)) {
             return { status: "lost_lease" };
           }
           if (cancellationSignal?.aborted) {
             return await completeCancelledTurn();
           }
           if (!context.attempt.isFinalAttempt) {
-            throw error;
+            throw failure;
           }
           const failureEventId = modelFailureCaptureAttempted && failureCode === "agent_run_failed" ? modelFailureEventId : captureApiBoundaryFailure({
             conversationId: context.conversationId,
-            error,
+            error: failure,
             failureCode,
             runId: currentRunId,
             turnId
@@ -1197,6 +1285,91 @@ async function readConversationAccessFromSql(db, conversationIds, viewer) {
   );
 }
 
+// src/chat/slack/user.ts
+import { z as z2 } from "zod";
+var slackUserInfoSchema = z2.object({
+  ok: z2.literal(true),
+  user: z2.object({
+    name: z2.string().nullish(),
+    profile: z2.object({
+      email: z2.string().nullish(),
+      real_name: z2.string().nullish()
+    }).optional()
+  })
+});
+var USER_CACHE_TTL_MS = 5 * 60 * 1e3;
+var userCache = /* @__PURE__ */ new Map();
+function userCacheKey(teamId, userId) {
+  return `${teamId}:${userId}`;
+}
+function readFromCache(teamId, userId) {
+  const hit = userCache.get(userCacheKey(teamId, userId));
+  if (!hit) return null;
+  if (hit.expiresAt < Date.now()) {
+    userCache.delete(userCacheKey(teamId, userId));
+    return null;
+  }
+  return hit.value;
+}
+function writeToCache(teamId, userId, value) {
+  userCache.set(userCacheKey(teamId, userId), {
+    value,
+    expiresAt: Date.now() + USER_CACHE_TTL_MS
+  });
+}
+async function lookupSlackUser(teamId, userId) {
+  if (!teamId || !userId) {
+    return null;
+  }
+  const cached = readFromCache(teamId, userId);
+  if (cached) {
+    return cached;
+  }
+  const token = getSlackBotToken();
+  if (!token) {
+    return null;
+  }
+  try {
+    const response = await fetch(
+      `https://slack.com/api/users.info?user=${encodeURIComponent(userId)}`,
+      {
+        headers: {
+          authorization: `Bearer ${token}`
+        }
+      }
+    );
+    if (!response.ok) {
+      logWarn("slack.user.lookup.failed", {
+        "enduser.id": userId,
+        "app.slack.team_id": teamId,
+        "http.response.status_code": response.status
+      });
+      return null;
+    }
+    const parsed = slackUserInfoSchema.safeParse(await response.json());
+    if (!parsed.success) {
+      return null;
+    }
+    const payload = parsed.data;
+    const userName = payload.user.name?.trim() || void 0;
+    const fullName = payload.user.profile?.real_name?.trim() || void 0;
+    const result = {
+      userName,
+      fullName,
+      email: payload.user.profile?.email?.trim() || void 0
+    };
+    writeToCache(teamId, userId, result);
+    return result;
+  } catch (error) {
+    logWarn("slack.user.lookup.failed", {
+      "enduser.id": userId,
+      "app.slack.team_id": teamId,
+      "exception.message": error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+
 // src/chat/slack/conversation-context.ts
 function normalizeConversationName(type, channelName) {
   const trimmed = channelName?.trim();
@@ -1285,6 +1458,7 @@ export {
   readHealthReport,
   GET,
   createVercelAttachmentStorage,
+  lookupSlackUser,
   conversationVisibilityFromSlackChannelType,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext,