@sentry/junior 0.181.1 → 0.183.0

package/dist/app.js

@@ -1,15 +1,15 @@
 import {
   processConversationWork
-} from "./chunk-MR36BRPE.js";
+} from "./chunk-3HJ4F4L7.js";
 import {
   bindSpawnAgent
-} from "./chunk-GITIZ6TZ.js";
+} from "./chunk-VOV3SCM3.js";
 import {
   createAgentInvocationWorker,
   enqueueAgentInvocation,
   listPendingAgentInvocationMailboxAppends,
   routeAgentInvocationWork
-} from "./chunk-DINF4LMR.js";
+} from "./chunk-IO6KFXYE.js";
 import {
   GET as GET2,
   GET2 as GET3,
@@ -36,25 +36,25 @@ import {
   startSlackProcessingReaction,
   stripLeadingBotMention,
   wakePausedTurn
-} from "./chunk-J4ID4ZI6.js";
+} from "./chunk-T5MTGX2E.js";
 import "./chunk-FA6POGLH.js";
 import {
   GET,
   apiTurnIdForMessage,
   appendAndEnqueueApiConversationMessage,
-  authenticatePersonalToken,
   conversationVisibilityFromSlackChannelType,
   createApiTurnCancellation,
   createApiTurnWorker,
   createVercelAttachmentStorage,
+  getAuthPausedApiTurnId,
   readConversationAccessFromSql,
   recordApiConversationActivity,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext,
   routeApiTurnWork,
   webActorFromEmail
-} from "./chunk-HG6HNOTQ.js";
-import "./chunk-CJRUBOJI.js";
+} from "./chunk-AYW7J6K4.js";
+import "./chunk-4WGFWHWP.js";
 import {
   buildDeliveredTurnStatePatch,
   completeAuthPauseTurn,
@@ -65,7 +65,7 @@ import {
   getTurnUserSlackMessageTs,
   persistAuthPauseTurnState,
   requireTurnFailureEventId
-} from "./chunk-HPFHC7YR.js";
+} from "./chunk-WOKJRLM2.js";
 import {
   claimDispatchMailboxAppend,
   confirmDispatchMailboxAppend,
@@ -85,7 +85,7 @@ import {
   recordTaskExecution,
   resolveTurnSessionRouting,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-XL3C4NAR.js";
+} from "./chunk-W5JMPEBO.js";
 import {
   ConversationTurnLifecycleService
 } from "./chunk-M3QYTBQ6.js";
@@ -97,17 +97,17 @@ import {
   persistThreadRuntimeState,
   persistThreadState,
   persistThreadStateById
-} from "./chunk-PJ7EGFME.js";
+} from "./chunk-PLZT45VC.js";
 import "./chunk-UTL3MHPC.js";
 import {
   createVercelPluginTaskCallback,
   queueCallback,
   registerVercelPluginTaskDevConsumer
-} from "./chunk-NRF23QZ4.js";
+} from "./chunk-V64JCZUV.js";
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-4WYHL4EH.js";
+} from "./chunk-3L7CWDQQ.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -155,11 +155,11 @@ import {
   unpublishedArtifactHeaders,
   verifySlackSignature,
   withNormalizedThreadId
-} from "./chunk-IWRPJ3J5.js";
+} from "./chunk-QZV76CM4.js";
 import {
   AuthorizationFlowDisabledError,
   PluginCredentialFailureError
-} from "./chunk-XQ56HNH5.js";
+} from "./chunk-35PM4YY5.js";
 import "./chunk-6Y5B5PEX.js";
 import "./chunk-DIB4GX3G.js";
 import {
@@ -168,7 +168,7 @@ import {
   deleteMcpAuthSessionsForUserProvider,
   deleteMcpServerSessionId,
   deleteMcpStoredOAuthCredentials
-} from "./chunk-RULGB5NX.js";
+} from "./chunk-2EPYYVJC.js";
 import {
   RetryableDeliveryError
 } from "./chunk-RF6J3DIO.js";
@@ -176,14 +176,15 @@ import {
   formatProviderLabel,
   postSlackMessage,
   startOAuthFlow
-} from "./chunk-ZQQWJMHE.js";
+} from "./chunk-QI5JW5AG.js";
 import {
   getExperimentalFeatures,
   isExperimentalFeatureEnabled,
   setExperimentalFeatures
-} from "./chunk-VRS6WDK5.js";
+} from "./chunk-2LYHWMR4.js";
 import {
   collectAttachmentGarbage,
+  collectEventTaskMatchKeys,
   findMatchingEventTasks,
   getResourceEventCatalog,
   listScheduledTasks,
@@ -196,21 +197,25 @@ import {
   scheduledRunId,
   scheduledRunSchema,
   withScheduledTaskLock
-} from "./chunk-YFJDRORU.js";
+} from "./chunk-R767Y7QV.js";
 import {
   parseSlackThreadId
-} from "./chunk-4OSVTPYQ.js";
+} from "./chunk-SQHFVIMZ.js";
 import {
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
   appendAndEnqueueInboundMessage,
   clearExpiredConversationLease,
   ensureConversationWake,
+  getConversation,
   getConversationWorkState,
   hasRunnableConversationWork,
+  hasRunnableConversationWork2,
   isInvalidConversationRecordError,
   listActiveConversationIds,
-  removeActiveConversation
-} from "./chunk-4GOZBB22.js";
+  removeActiveConversation,
+  requestConversationWork,
+  stopConversationWork
+} from "./chunk-HUK5XIZL.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
@@ -228,7 +233,7 @@ import {
   markTurnCompleted,
   markTurnFailed,
   startActiveTurn
-} from "./chunk-VHSBLFNT.js";
+} from "./chunk-56XONJPF.js";
 import {
   abandonTurnRecord,
   appendThreadContextMessages,
@@ -264,11 +269,11 @@ import {
   trimTrailingAssistantMessages,
   turnHasReply,
   upsertConversationMessage
-} from "./chunk-DTRCZOHE.js";
+} from "./chunk-24OJZ5OU.js";
 import {
   getSandboxResourceConfig,
   setSandboxResourceConfig
-} from "./chunk-6TB7JN63.js";
+} from "./chunk-37IQ6DGU.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
 import {
@@ -287,13 +292,14 @@ import {
 import "./chunk-7H2VZTWN.js";
 import {
   getTurnRequestDeadline
-} from "./chunk-HRTW7FFX.js";
+} from "./chunk-FJMTMGBC.js";
 import {
   SlackActionError,
   bindEventTaskCredentialSubject,
   bindScheduledTaskCredentialSubject,
   bindSlackDirectCredentialSubject,
   cancelSubscriptions,
+  collectResourceEventMatchKeys,
   createPluginLogger,
   createPluginState,
   createResourceEventTeamIdResolver,
@@ -305,7 +311,6 @@ import {
   getWorkspaceTeamId,
   isDmChannel,
   normalizeSlackConversationId,
-  resolveViewerUser,
   runWithWorkspaceTeamId,
   setDashboardConversationLinkOptions,
   setPlugins,
@@ -313,7 +318,7 @@ import {
   verifyEventTaskCredentialSubject,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-WDNA4LML.js";
+} from "./chunk-AHMWPFIW.js";
 import "./chunk-3Y47VMHV.js";
 import {
   contextProvenance,
@@ -326,7 +331,7 @@ import {
   requireSlackDestination,
   withConversationEventLock,
   withConversationMutationLock
-} from "./chunk-YCW6RZGX.js";
+} from "./chunk-AX3UDIMA.js";
 import {
   juniorAgentBindings,
   juniorAgentInvocations,
@@ -334,15 +339,13 @@ import {
   juniorConversations,
   juniorSchedulerRuns,
   juniorSchedulerTasks
-} from "./chunk-ULM7P4EQ.js";
-import {
-  sleep
-} from "./chunk-QA6RE6IB.js";
+} from "./chunk-6UXDTPEN.js";
+import "./chunk-X52ESOBP.js";
 import {
   acquireActiveLock,
   getStateAdapter,
   withActiveLock
-} from "./chunk-H6MPFFBE.js";
+} from "./chunk-G2B2XZQW.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
@@ -363,13 +366,13 @@ import {
   modelIdForProfile,
   setProfiles,
   setSlackReactionConfig
-} from "./chunk-S63LNPIV.js";
-import "./chunk-Z2UG4FBT.js";
-import "./chunk-KH2SL2HT.js";
+} from "./chunk-LMNMMESF.js";
+import "./chunk-2ADFGSUS.js";
+import "./chunk-KTXOGLNE.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-DXK3VTVP.js";
-import "./chunk-7UF37LNL.js";
+} from "./chunk-E3OBGRHN.js";
+import "./chunk-EENQGEIP.js";
 import {
   credentialContextForActor
 } from "./chunk-CEMMLV5L.js";
@@ -404,13 +407,13 @@ import {
   withContext,
   withLogContext,
   withSpan
-} from "./chunk-2CZ63QCL.js";
+} from "./chunk-LZBPGX5A.js";
 import {
   continueTrace
 } from "./chunk-PEQXYSSE.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-S5X2VQOD.js";
+} from "./chunk-W46NIB5H.js";
 
 // src/app.ts
 import { createRequire } from "module";
@@ -514,7 +517,7 @@ async function recoverConversationWork(args) {
           }
           return;
         }
-        if (work.execution.lease || !hasRunnableConversationWork(work)) {
+        if (work.execution.lease || !hasRunnableConversationWork2(work)) {
           return;
         }
         const wake = await ensureConversationWake({
@@ -4044,17 +4047,9 @@ async function decideSubscribedThreadReply(args) {
   if (preflightDecision) {
     return preflightDecision;
   }
-  const evidence = buildRouterEvidence(args.input);
   if (!text && !args.input.hasAttachments) {
     return { shouldReply: false, reason: "empty_message" /* EmptyMessage */ };
   }
-  if (!args.input.isExplicitMention && !args.input.hasAttachments && isAcknowledgmentOnly(text)) {
-    return {
-      shouldReply: false,
-      reason: "side_conversation" /* SideConversation */,
-      reasonDetail: "acknowledgment"
-    };
-  }
   if (args.input.isExplicitMention) {
     if (isThreadOptOutInstruction(rawText, text)) {
       return {
@@ -4069,6 +4064,21 @@ async function decideSubscribedThreadReply(args) {
       reason: "explicit_mention" /* ExplicitMention */
     };
   }
+  if (!isExperimentalFeatureEnabled("passive-routing")) {
+    return {
+      shouldReply: false,
+      reason: "passive_disabled" /* PassiveDisabled */,
+      reasonDetail: "passive-routing"
+    };
+  }
+  if (!args.input.hasAttachments && isAcknowledgmentOnly(text)) {
+    return {
+      shouldReply: false,
+      reason: "side_conversation" /* SideConversation */,
+      reasonDetail: "acknowledgment"
+    };
+  }
+  const evidence = buildRouterEvidence(args.input);
   if (evidence.assistantWasLastSpeaker && evidence.humanMessagesSinceLastAssistant === 0 && !evidence.currentMessageHasAttachments && (evidence.currentMessageHasDirectedFollowUpCue || evidence.currentMessageIsTerseClarification)) {
     return {
       shouldReply: true,
@@ -4200,7 +4210,7 @@ function combineTurnText(queuedMessages, latestText) {
   };
 }
 
-// src/chat/runtime/slack-runtime.ts
+// src/chat/providers/slack/runtime.ts
 var THREAD_OPTOUT_ACK = "Understood. I'll stay out of this thread unless someone @mentions me again.";
 function shouldRethrowTurnControlError(error) {
   return isCooperativeTurnYieldError(error) || isTurnInputCommitLostError(error) || isTurnInputDeferredError(error) || isProviderRetryError(error);
@@ -4579,7 +4589,7 @@ function createSlackTurnRuntime(deps) {
             }),
             stripLeadingBotMention: deps.stripLeadingBotMention
           });
-          await deps.replyToThread(thread, message, {
+          await deps.executeSlackTurn(thread, message, {
             explicitMention: true,
             beforeFirstResponsePost: hooks.beforeFirstResponsePost,
             conversationId: hooks.conversationId,
@@ -4745,6 +4755,31 @@ function createSlackTurnRuntime(deps) {
             });
             return;
           }
+          if (!isResourceEventNotification && !turnIsExplicitMention && !isExperimentalFeatureEnabled("passive-routing")) {
+            const decision2 = await deps.decideSubscribedReply({
+              rawText: combinedText.rawText,
+              text: combinedText.userText,
+              hasAttachments: content.hasAttachments || queuedMessages.some(
+                (queued) => queued.message.attachments.length > 0
+              ),
+              isExplicitMention: false,
+              context: threadContext
+            });
+            await maybeHandleThreadOptOutDecision({
+              thread,
+              decision: decision2,
+              beforeFirstResponsePost: hooks.beforeFirstResponsePost
+            });
+            await skipSubscribedMessage({
+              thread,
+              message,
+              decision: decision2,
+              context: threadContext,
+              ack: hooks.ack,
+              text: combinedText
+            });
+            return;
+          }
           const preparedState = await deps.prepareTurnState({
             thread,
             message,
@@ -4844,7 +4879,7 @@ function createSlackTurnRuntime(deps) {
             processingReaction,
             hooks
           );
-          await deps.replyToThread(thread, message, {
+          await deps.executeSlackTurn(thread, message, {
             explicitMention: Boolean(message.isMention),
             conversationId: hooks.conversationId,
             destination: hooks.destination,
@@ -5483,7 +5518,7 @@ function createJuniorRuntimeServices(overrides = {}) {
   };
 }
 
-// src/chat/runtime/reply-executor.ts
+// src/chat/providers/slack/turn.ts
 import { createSlackSource as createSlackSource2 } from "@sentry/junior-plugin-api";
 
 // src/chat/slack/message/identity.ts
@@ -5581,7 +5616,7 @@ async function maybeApplyProviderDefaultConfigRequest(args) {
   };
 }
 
-// src/chat/runtime/reply-executor.ts
+// src/chat/providers/slack/turn.ts
 async function persistThreadRuntimeStateWithRetry(thread, patch) {
   await persistWithRetry(() => persistThreadRuntimeState(thread, patch));
 }
@@ -5706,8 +5741,8 @@ async function loadPiMessagesForTurn(args) {
 function shouldPublishExternally2(publishExternally) {
   return publishExternally !== false;
 }
-function createReplyToThread(deps) {
-  return async function replyToThread(thread, message, options) {
+function createSlackTurn(deps) {
+  return async function executeSlackTurn(thread, message, options) {
     if (message.author.isMe) {
       return;
     }
@@ -7115,7 +7150,7 @@ function createSlackDispatchTurnRunner(options) {
     let errorMessage;
     let resultMessageTs;
     const routing = buildDispatchRoutingContext(dispatch2);
-    await options.replyToThread(thread, message, {
+    await options.executeSlackTurn(thread, message, {
       ack: hooks.ack,
       conversationId,
       destination: dispatch2.destination,
@@ -7195,7 +7230,7 @@ function createSlackRuntime(options) {
       );
     }
   });
-  const replyToThread = createReplyToThread({
+  const executeSlackTurn = createSlackTurn({
     getSlackAdapter: options.getSlackAdapter,
     prepareTurnState,
     resolveUserAttachments: services.visionContext.resolveUserAttachments,
@@ -7294,7 +7329,7 @@ function createSlackRuntime(options) {
         conversation: preparedState.conversation
       });
     },
-    replyToThread,
+    executeSlackTurn,
     initializeAssistantThread: async ({
       channelId,
       threadTs,
@@ -7325,7 +7360,7 @@ function createSlackRuntime(options) {
     runDispatchTurn: createSlackDispatchTurnRunner({
       getLocationConfiguration: getLocationConfigurationService,
       getSlackAdapter: options.getSlackAdapter,
-      replyToThread
+      executeSlackTurn
     })
   };
 }
@@ -7918,9 +7953,7 @@ function createConversationWork(options) {
         turnLifecycle: services.replyExecutor?.turnLifecycle
       }),
       fallbackWorker: routeAgentInvocationWork({
-        invocationWorker: createAgentInvocationWorker({
-          agentRunner: options.agentRunner
-        }),
+        invocationWorker: createAgentInvocationWorker(options.agentRunner),
         fallbackWorker: providerWorker
       })
     }),
@@ -8118,416 +8151,203 @@ async function ingestEventTasks(input, options) {
   return { dispatched };
 }
 
-// src/api/acp/route.ts
-import { randomUUID } from "crypto";
-import * as acp from "@agentclientprotocol/sdk";
-import { AcpServer } from "@agentclientprotocol/sdk/experimental/server";
-var ACP_CONNECTION_ID_HEADER = "Acp-Connection-Id";
-var ACP_CONVERSATION_PREFIX = "local:acp:";
-var EVENT_PAGE_SIZE = 50;
-var EVENT_POLL_INTERVAL_MS = 25;
-var MAX_PROMPT_TEXT_LENGTH = 32e3;
-function bearerToken(request) {
-  const authorization = request.headers.get("Authorization");
-  const match = authorization?.match(/^Bearer ([^\s]+)$/);
-  return match?.[1];
-}
-async function authenticateRequest(request) {
-  const token = bearerToken(request);
-  if (!token) return void 0;
-  const email = await authenticatePersonalToken(token);
-  if (!email) return void 0;
-  const user = await resolveViewerUser(email);
-  if (!user) return void 0;
-  return {
-    actor: webActorFromEmail(
-      user.email ?? email,
-      user.displayName ? { fullName: user.displayName } : void 0
-    ),
-    user
-  };
-}
-function rejectUnsupportedMcpServers(mcpServers) {
-  if (mcpServers.length > 0) {
-    throw acp.RequestError.invalidParams(
-      { field: "mcpServers" },
-      "Junior does not accept client MCP servers"
-    );
-  }
-}
-async function requireOwnedSession(sessionId, user) {
-  if (!sessionId.startsWith(ACP_CONVERSATION_PREFIX)) {
-    throw acp.RequestError.resourceNotFound(sessionId);
+// src/chat/api-turns/stop.ts
+async function stopApiConversationTurn(args) {
+  const nowMs = args.nowMs ?? Date.now();
+  const stop = async () => await stopConversationWork({
+    conversationId: args.conversationId,
+    conversationStore: args.conversationStore,
+    nowMs,
+    state: args.state
+  });
+  let result = await stop();
+  if (result.status === "no_work" && await getAuthPausedApiTurnId(args.conversationId)) {
+    const conversation = await getConversation({
+      conversationId: args.conversationId,
+      state: args.state
+    });
+    await requestConversationWork({
+      conversationId: args.conversationId,
+      conversationStore: args.conversationStore,
+      destination: conversation?.destination,
+      nowMs,
+      state: args.state
+    });
+    result = await stop();
   }
-  const access = (await readConversationAccessFromSql(getDb(), [sessionId], user)).get(sessionId);
-  if (!access?.isParticipant) {
-    throw acp.RequestError.resourceNotFound(sessionId);
+  if (result.status === "requested") {
+    await ensureConversationWake({
+      conversationId: args.conversationId,
+      conversationStore: args.conversationStore,
+      idempotencyKey: `api-stop:${args.conversationId}:${result.runId}`,
+      nowMs,
+      queue: args.queue,
+      replaceExistingWake: true,
+      state: args.state
+    });
   }
+  return result;
 }
-function promptText(prompt) {
-  if (prompt.length === 0) {
-    throw acp.RequestError.invalidParams(
-      { field: "prompt" },
-      "Junior accepts one or more text blocks only"
-    );
-  }
-  const blocks = [];
-  for (const block of prompt) {
-    if (block.type !== "text") {
-      throw acp.RequestError.invalidParams(
-        { field: "prompt" },
-        "Junior accepts one or more text blocks only"
-      );
-    }
-    if (!block.text.trim()) {
-      throw acp.RequestError.invalidParams(
-        { field: "prompt" },
-        "Junior accepts non-empty text blocks only"
-      );
-    }
-    blocks.push(block.text);
+
+// src/chat/api-turns/adapter-conversations.ts
+var EVENT_PAGE_SIZE = 50;
+function actorFromUser(user) {
+  return webActorFromEmail(
+    user.email,
+    user.displayName ? { fullName: user.displayName } : void 0
+  );
+}
+async function hasConversationAccess(conversationId, user) {
+  const access = (await readConversationAccessFromSql(getDb(), [conversationId], user)).get(conversationId);
+  return Boolean(access?.isParticipant);
+}
+async function turnTerminalIsReady(args) {
+  const conversation = await getConversation({
+    conversationId: args.conversationId,
+    state: args.state
+  });
+  if (conversation?.execution.pendingMessages.some(
+    (message) => message.inboundMessageId === args.messageId
+  )) {
+    return false;
   }
-  const text = blocks.join("\n");
-  if (text.length > MAX_PROMPT_TEXT_LENGTH) {
-    throw acp.RequestError.invalidParams(
-      { field: "prompt" },
-      `Junior accepts at most ${MAX_PROMPT_TEXT_LENGTH} prompt characters`
-    );
+  if (!conversation || !hasRunnableConversationWork(conversation)) {
+    return true;
   }
-  return text;
-}
-function requestIdKey(requestId) {
-  if (requestId === null) return "null";
-  return `${typeof requestId}:${requestId}`;
+  const later = await args.eventStore.query(args.conversationId, {
+    afterSeq: args.terminalSeq,
+    limit: 1,
+    types: ["turn_started"]
+  });
+  return later.events.some(
+    (event) => event.data.type === "turn_started" && event.data.turnId !== args.turnId
+  );
 }
-async function latestEventSeq(eventStore, conversationId) {
+async function latestEventCursor(eventStore, conversationId) {
   const page = await eventStore.query(conversationId, { limit: 1 });
   return page.events.at(-1)?.seq ?? 0;
 }
-async function replaySession(eventStore, sessionId, client) {
-  const history = await eventStore.loadMessageHistory(sessionId);
-  for (const message of projectConversationMessages(history)) {
-    if (message.role === "system") continue;
-    await client.notify(acp.methods.client.session.update, {
-      sessionId,
-      update: {
-        sessionUpdate: message.role === "user" ? "user_message_chunk" : "agent_message_chunk",
-        content: { type: "text", text: message.text },
-        messageId: message.id
-      }
-    });
-  }
-}
-async function waitForTurn(args) {
-  let cursor = args.afterSeq;
-  const assistantPrefix = `${args.turnId}:assistant:`;
-  const sentMessageIds = /* @__PURE__ */ new Set();
-  while (true) {
-    if (args.signal.aborted) {
-      throw acp.RequestError.requestCancelled();
-    }
-    const page = await args.eventStore.query(args.sessionId, {
-      afterSeq: cursor,
-      limit: EVENT_PAGE_SIZE,
-      types: ["message", "turn_completed", "turn_failed"]
-    });
-    if (page.events.length === 0) {
-      try {
-        await sleep(EVENT_POLL_INTERVAL_MS, args.signal);
-      } catch (error) {
-        if (args.signal.aborted) {
-          throw acp.RequestError.requestCancelled();
-        }
-        throw error;
-      }
-      continue;
-    }
-    for (const event of page.events) {
-      cursor = event.seq;
-      const data = event.data;
-      if (data.type === "message" && data.role === "assistant" && data.messageId.startsWith(assistantPrefix) && !sentMessageIds.has(data.messageId)) {
-        sentMessageIds.add(data.messageId);
-        await args.client.notify(acp.methods.client.session.update, {
-          sessionId: args.sessionId,
-          update: {
-            sessionUpdate: "agent_message_chunk",
-            content: { type: "text", text: data.text },
-            messageId: data.messageId
-          }
-        });
-        continue;
-      }
-      if (data.type === "turn_completed" && data.turnId === args.turnId) {
-        args.cancellation.finish(args.sessionId, args.cancellationSignal);
-        return {
-          stopReason: data.outcome === "cancelled" ? "cancelled" : "end_turn"
-        };
-      }
-      if (data.type === "turn_failed" && data.turnId === args.turnId) {
-        args.cancellation.finish(args.sessionId, args.cancellationSignal);
-        throw acp.RequestError.internalError(
-          { failureCode: data.failureCode },
-          "Junior Turn failed"
-        );
+function createAdapterConversations(options) {
+  return {
+    async cancel({ conversationId, user }) {
+      if (!await hasConversationAccess(conversationId, user)) {
+        return "not_found";
       }
-    }
-  }
-}
-async function runAcpOperation(authenticated, operation, conversationId, callback) {
-  const name = `acp.${operation}`;
-  return await withSpan(
-    name,
-    name,
-    {
-      actorId: authenticated.actor.userId,
-      conversationId,
-      platform: "acp",
-      userId: authenticated.actor.userId
+      await stopApiConversationTurn({
+        conversationId,
+        conversationStore: options.conversationStore,
+        queue: options.queue,
+        state: options.state
+      });
+      return "cancelled";
     },
-    async () => {
-      try {
-        return await callback();
-      } catch (error) {
-        if (!(error instanceof acp.RequestError)) {
-          logException(error, `${name}.failed`);
-        }
-        throw error;
-      }
-    }
-  );
-}
-function createActorAgent(authenticated, connectionNonce, options) {
-  const conversationStore = options.conversationStore ?? getConversationStore();
-  const eventStore = getConversationEventStore();
-  return acp.agent({ name: "junior" }).onRequest(
-    acp.methods.agent.initialize,
-    () => runAcpOperation(authenticated, "initialize", void 0, () => ({
-      protocolVersion: acp.PROTOCOL_VERSION,
-      agentCapabilities: {
-        loadSession: true,
-        promptCapabilities: {
-          image: false,
-          audio: false,
-          embeddedContext: false
-        }
-      },
-      authMethods: [],
-      agentInfo: { name: "junior", version: JUNIOR_VERSION }
-    }))
-  ).onRequest(acp.methods.agent.session.new, async (context) => {
-    return await runAcpOperation(
-      authenticated,
-      "session_new",
-      void 0,
-      async () => {
-        rejectUnsupportedMcpServers(context.params.mcpServers);
-        const sessionId = `${ACP_CONVERSATION_PREFIX}${randomUUID()}`;
-        await recordApiConversationActivity({
-          actor: authenticated.actor,
-          conversationId: sessionId,
-          conversationStore,
-          nowMs: Date.now(),
-          rootVisibility: "private"
-        });
-        return { sessionId };
-      }
-    );
-  }).onRequest(acp.methods.agent.session.load, async (context) => {
-    return await runAcpOperation(
-      authenticated,
-      "session_load",
-      context.params.sessionId,
-      async () => {
-        rejectUnsupportedMcpServers(context.params.mcpServers);
-        await requireOwnedSession(
-          context.params.sessionId,
-          authenticated.user
-        );
-        await replaySession(
-          eventStore,
-          context.params.sessionId,
-          context.client
-        );
-        return {};
+    async create({ conversationId, user }) {
+      await recordApiConversationActivity({
+        actor: actorFromUser(user),
+        conversationId,
+        conversationStore: options.conversationStore,
+        nowMs: Date.now(),
+        rootVisibility: "private"
+      });
+    },
+    async hasAccess({ conversationId, user }) {
+      return await hasConversationAccess(conversationId, user);
+    },
+    async prompt({ conversationId, idempotencyKey, text, user }) {
+      if (!await hasConversationAccess(conversationId, user)) {
+        return { status: "not_found" };
       }
-    );
-  }).onRequest(acp.methods.agent.session.prompt, async (context) => {
-    return await runAcpOperation(
-      authenticated,
-      "session_prompt",
-      context.params.sessionId,
-      async () => {
-        await requireOwnedSession(
-          context.params.sessionId,
-          authenticated.user
-        );
-        const text = promptText(context.params.prompt);
-        const currentSeq = await latestEventSeq(
-          eventStore,
-          context.params.sessionId
-        );
-        const cancellationSignal = options.cancellation.begin(
-          context.params.sessionId
-        );
-        if (!cancellationSignal) {
-          throw acp.RequestError.invalidParams(
-            { field: "sessionId" },
-            "This ACP session already has an active prompt"
-          );
-        }
-        const recordDisconnect = () => options.cancellation.disconnect(
-          context.params.sessionId,
-          cancellationSignal
-        );
-        if (context.signal.aborted) {
-          recordDisconnect();
-        } else {
-          context.signal.addEventListener("abort", recordDisconnect, {
-            once: true
-          });
-        }
-        let accepted;
-        try {
-          accepted = await appendAndEnqueueApiConversationMessage(
-            {
-              actor: authenticated.actor,
-              conversationId: context.params.sessionId,
-              idempotencyKey: `${connectionNonce}:${requestIdKey(context.requestId)}`,
-              message: text
-            },
-            {
-              conversationStore,
-              queue: options.queue,
-              state: options.state
-            }
-          );
-        } catch (error) {
-          options.cancellation.finish(
-            context.params.sessionId,
-            cancellationSignal
-          );
-          throw error;
-        }
-        const afterSeq = accepted.status === "duplicate" ? 0 : currentSeq;
-        return await waitForTurn({
-          afterSeq,
-          cancellation: options.cancellation,
-          cancellationSignal,
-          client: context.client,
-          eventStore,
-          sessionId: context.params.sessionId,
-          signal: context.signal,
-          turnId: apiTurnIdForMessage(accepted.messageId)
-        });
+      const currentCursor = await latestEventCursor(
+        options.eventStore,
+        conversationId
+      );
+      if (await getAuthPausedApiTurnId(conversationId)) {
+        return { status: "active" };
       }
-    );
-  }).onNotification(acp.methods.agent.session.cancel, async (context) => {
-    await runAcpOperation(
-      authenticated,
-      "session_cancel",
-      context.params.sessionId,
-      async () => {
-        await requireOwnedSession(
-          context.params.sessionId,
-          authenticated.user
-        );
-        if (!options.cancellation.cancel(context.params.sessionId)) {
-          return;
-        }
-        const nowMs = Date.now();
-        await ensureConversationWake({
-          conversationId: context.params.sessionId,
-          conversationStore,
-          idempotencyKey: `acp-cancel:${context.params.sessionId}:${nowMs}`,
-          nowMs,
+      const admission = await appendAndEnqueueApiConversationMessage(
+        {
+          actor: actorFromUser(user),
+          conversationId,
+          idempotencyKey,
+          message: text
+        },
+        {
+          conversationStore: options.conversationStore,
+          exclusive: true,
           queue: options.queue,
-          replaceExistingWake: true,
           state: options.state
-        });
-      }
-    );
-  });
-}
-function isJsonRpcId(value) {
-  return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
-}
-async function hasSafeAcpEnvelope(request) {
-  if (request.method !== "POST") return true;
-  let value;
-  try {
-    value = await request.clone().json();
-  } catch {
-    return true;
-  }
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return true;
-  }
-  if (!("jsonrpc" in value) || value.jsonrpc !== "2.0") {
-    return false;
-  }
-  if (!("method" in value) || typeof value.method !== "string") {
-    return false;
-  }
-  return !("id" in value) || isJsonRpcId(value.id);
-}
-async function initializationSucceeded(response) {
-  try {
-    const value = await response.clone().json();
-    return typeof value === "object" && value !== null && "result" in value;
-  } catch {
-    return false;
-  }
-}
-function createAcpHttpHandler(options) {
-  const server = new AcpServer({ agent: acp.agent({ name: "junior" }) });
-  const connectionActors = /* @__PURE__ */ new Map();
-  return async (request) => {
-    const authenticated = await authenticateRequest(request);
-    if (!authenticated) {
-      return new Response("Unauthorized", { status: 401 });
-    }
-    const connectionId = request.headers.get(ACP_CONNECTION_ID_HEADER);
-    const connectionActorId = connectionId ? connectionActors.get(connectionId) : void 0;
-    if (connectionId && connectionActorId === void 0) {
-      return new Response("Unknown Acp-Connection-Id", { status: 404 });
-    }
-    if (connectionActorId !== void 0 && connectionActorId !== authenticated.actor.userId) {
-      return new Response("Unknown Acp-Connection-Id", { status: 404 });
-    }
-    if (!await hasSafeAcpEnvelope(request)) {
-      return new Response("Invalid JSON-RPC message", { status: 400 });
-    }
-    const response = await server.handleRequest(request, {
-      agent: createActorAgent(authenticated, randomUUID(), options)
-    });
-    const responseConnectionId = response.headers.get(ACP_CONNECTION_ID_HEADER);
-    if (response.ok && responseConnectionId && !connectionId) {
-      if (await initializationSucceeded(response)) {
-        connectionActors.set(responseConnectionId, authenticated.actor.userId);
-      } else {
-        await server.handleRequest(
-          new Request(request.url, {
-            method: "DELETE",
-            headers: { [ACP_CONNECTION_ID_HEADER]: responseConnectionId }
-          })
-        );
-        const headers = new Headers(response.headers);
-        headers.delete(ACP_CONNECTION_ID_HEADER);
-        return new Response(response.body, {
-          headers,
-          status: response.status,
-          statusText: response.statusText
-        });
+        }
+      );
+      if (admission.status === "active") return { status: "active" };
+      return {
+        afterCursor: admission.status === "duplicate" ? 0 : currentCursor,
+        messageId: admission.messageId,
+        status: "accepted",
+        turnId: apiTurnIdForMessage(admission.messageId)
+      };
+    },
+    async readMessages(conversationId) {
+      const history = await options.eventStore.loadMessageHistory(conversationId);
+      return projectConversationMessages(history).filter(
+        (message) => message.role !== "system"
+      ).map(({ id, role, text }) => ({ id, role, text }));
+    },
+    async readTurn({ afterCursor, conversationId, messageId, turnId }) {
+      const page = await options.eventStore.query(conversationId, {
+        afterSeq: afterCursor,
+        limit: EVENT_PAGE_SIZE,
+        types: ["message", "turn_completed", "turn_failed"]
+      });
+      const cursor = page.events.at(-1)?.seq ?? afterCursor;
+      const assistantPrefix = `${turnId}:assistant:`;
+      const messages = page.events.flatMap((event) => {
+        const data = event.data;
+        return data.type === "message" && data.role === "assistant" && data.messageId.startsWith(assistantPrefix) ? [
+          {
+            id: data.messageId,
+            role: "assistant",
+            text: data.text
+          }
+        ] : [];
+      });
+      let terminal;
+      const terminalEvent = await options.eventStore.loadByIdempotencyKey(
+        conversationId,
+        `turn:${turnId}:terminal`
+      );
+      if (terminalEvent && terminalEvent.seq <= cursor && await turnTerminalIsReady({
+        conversationId,
+        eventStore: options.eventStore,
+        messageId,
+        state: options.state,
+        terminalSeq: terminalEvent.seq,
+        turnId
+      })) {
+        const data = terminalEvent.data;
+        if (data.type === "turn_completed" && data.turnId === turnId) {
+          terminal = {
+            outcome: data.outcome === "cancelled" ? "cancelled" : "completed",
+            status: "completed"
+          };
+        } else if (data.type === "turn_failed" && data.turnId === turnId) {
+          terminal = { failureCode: data.failureCode, status: "failed" };
+        }
       }
+      const turnPage = { cursor, messages };
+      if (terminal) turnPage.terminal = terminal;
+      return turnPage;
     }
-    if (request.method === "DELETE" && response.ok && connectionId) {
-      connectionActors.delete(connectionId);
-    }
-    return response;
   };
 }
 
 // src/app.ts
+function resolveAdapterBaseURL(dashboard) {
+  const configured = dashboard?.baseURL?.trim() || process.env.JUNIOR_BASE_URL?.trim();
+  if (configured) return configured;
+  const vercelURL = process.env.VERCEL_PROJECT_PRODUCTION_URL?.trim() || process.env.VERCEL_URL?.trim();
+  if (!vercelURL) return void 0;
+  return /^https?:\/\//.test(vercelURL) ? vercelURL : `https://${vercelURL}`;
+}
 var DASHBOARD_PACKAGE_NAME = "@sentry/junior-dashboard";
 async function defaultWaitUntil() {
   try {
@@ -8625,6 +8445,7 @@ async function createDashboardRouteRegistrations(args) {
   }
   const createDashboardApp = args.createDashboardApp ?? await loadDashboardAppFactory();
   return dashboardRouteRegistrations({
+    authenticatedRoutes: args.authenticatedRoutes,
     dashboard: args.dashboard,
     createDashboardApp,
     pluginRoutes: args.pluginRoutes
@@ -8672,7 +8493,7 @@ function normalizeDashboardPath(path, fallback) {
   const withSlash = value.startsWith("/") ? value : `/${value}`;
   return stripTrailingSlashes(withSlash);
 }
-function dashboardHostRoutePaths(dashboard) {
+function dashboardHostRoutePaths(dashboard, authenticatedRoutes = []) {
   const basePath = normalizeDashboardPath(dashboard.basePath, "/");
   const authPath = normalizeDashboardPath(dashboard.authPath, "/api/auth");
   const pagePath = (suffix) => basePath === "/" ? `/${suffix}` : `${basePath}/${suffix}`;
@@ -8680,6 +8501,7 @@ function dashboardHostRoutePaths(dashboard) {
   const peoplePath = pagePath("people");
   const pagePaths = [
     basePath,
+    pagePath("code"),
     conversationsPath,
     `${conversationsPath}/*`,
     pagePath("locations"),
@@ -8719,6 +8541,7 @@ function dashboardHostRoutePaths(dashboard) {
     "/api/tasks",
     "/api/tasks/*",
     "/api/skills",
+    "/api/code",
     "/api/stats",
     "/api/conversations",
     "/api/conversations/*",
@@ -8732,6 +8555,7 @@ function dashboardHostRoutePaths(dashboard) {
     "/api/workspaces/*",
     "/api/config",
     "/api/me",
+    ...authenticatedRoutes.map((route) => route.path),
     authPath,
     `${authPath}/*`
   ];
@@ -8782,35 +8606,43 @@ function routePatternOverlaps(ownedPath, routePath) {
     (example) => routePatternMatchesConcretePath(routePath, example)
   );
 }
-function dashboardOwnedRoutePath(routePath, dashboard) {
-  return dashboardHostRoutePaths(dashboard).some(
+function dashboardOwnedRoutePath(routePath, dashboard, authenticatedRoutes = []) {
+  return dashboardHostRoutePaths(dashboard, authenticatedRoutes).some(
     (path) => routePatternOverlaps(path, routePath)
   );
 }
 function dashboardRouteRegistrations(args) {
   let app;
   const fetch2 = (request) => {
-    app ??= args.createDashboardApp({
+    const dashboardOptions = {
       ...args.dashboard,
       agentName: botConfig.userName,
+      authenticatedRoutes: args.authenticatedRoutes,
       pluginRoutes: args.pluginRoutes
-    });
+    };
+    app ??= args.createDashboardApp(dashboardOptions);
     if (!app || typeof app.fetch !== "function") {
       throw new Error("createDashboardApp() must return an app with fetch()");
     }
     return app.fetch(request);
   };
-  return dashboardHostRoutePaths(args.dashboard).map((path) => ({
-    handler: fetch2,
-    path
-  }));
+  return dashboardHostRoutePaths(args.dashboard, args.authenticatedRoutes).map(
+    (path) => ({
+      handler: fetch2,
+      path
+    })
+  );
 }
 function validateDashboardRouteOwnership(args) {
   if (!args.dashboard || args.dashboard.disabled) {
     return;
   }
   for (const route of args.routes) {
-    if (dashboardOwnedRoutePath(route.path, args.dashboard)) {
+    if (dashboardOwnedRoutePath(
+      route.path,
+      args.dashboard,
+      args.authenticatedRoutes
+    )) {
       throw new Error(
         `Plugin "${route.pluginName}" route "${route.path}" conflicts with core dashboard routes`
       );
@@ -8820,11 +8652,11 @@ function validateDashboardRouteOwnership(args) {
 function mountRoutes(app, routes) {
   for (const route of routes) {
     const handler = (c) => route.handler(c.req.raw);
-    const methods2 = Array.isArray(route.method) ? route.method : [route.method ?? "ALL"];
-    const explicitMethods = methods2.filter(
+    const methods = typeof route.method === "string" ? [route.method] : route.method ?? ["ALL"];
+    const explicitMethods = methods.filter(
       (method) => method !== "ALL"
     );
-    if (methods2.includes("ALL")) {
+    if (methods.includes("ALL")) {
       app.all(route.path, handler);
     } else if (explicitMethods.length > 0) {
       app.on(explicitMethods, route.path, handler);
@@ -8858,10 +8690,42 @@ async function createApp(options) {
   const previousSandboxResources = getSandboxResourceConfig();
   const previousExperimentalFeatures = getExperimentalFeatures();
   const previousDashboardLinkOptions = setDashboardConversationLinkOptions(dashboard);
+  const restoreRuntimeConfig = () => {
+    pluginCatalogRuntime.setConfig(previousPluginCatalogConfig);
+    setPlugins(previousPlugins);
+    setConfigDefaults(previousConfigDefaults);
+    botConfig.defaultProfile = previousDefaultProfile;
+    botConfig.profiles = previousModelProfiles;
+    setSlackReactionConfig(previousSlackReactionConfig);
+    setSandboxResourceConfig(previousSandboxResources);
+    setExperimentalFeatures(previousExperimentalFeatures);
+    setDashboardConversationLinkOptions(previousDashboardLinkOptions);
+  };
   let pluginRoutes = [];
   let pluginApiRoutes = [];
   const resolveResourceEventTeamId = createResourceEventTeamIdResolver();
   const resourceEvents = {
+    async neededMatchKeys(input) {
+      const teamId = await resolveResourceEventTeamId();
+      if (!teamId) return [];
+      const conversationWork = getConversationWorkOptions();
+      const [watchKeys, taskKeys] = await Promise.all([
+        collectResourceEventMatchKeys({
+          eventTypes: input.eventTypes,
+          identifiers: input.identifiers,
+          namespace: input.namespace,
+          state: conversationWork.state,
+          teamId
+        }),
+        collectEventTaskMatchKeys(getDb(), {
+          eventTypes: input.eventTypes,
+          identifiers: input.identifiers,
+          namespace: input.namespace,
+          teamId
+        })
+      ]);
+      return [.../* @__PURE__ */ new Set([...watchKeys, ...taskKeys])].sort();
+    },
     async publish(event) {
       const teamId = await resolveResourceEventTeamId();
       if (!teamId) {
@@ -8909,20 +8773,11 @@ async function createApp(options) {
       );
     }
     pluginRoutes = getPluginRoutes({ resourceEvents });
-    validateDashboardRouteOwnership({ dashboard, routes: pluginRoutes });
     if (dashboard && !dashboard.disabled) {
       pluginApiRoutes = getPluginApiRoutes();
     }
   } catch (error) {
-    pluginCatalogRuntime.setConfig(previousPluginCatalogConfig);
-    setPlugins(previousPlugins);
-    setConfigDefaults(previousConfigDefaults);
-    botConfig.defaultProfile = previousDefaultProfile;
-    botConfig.profiles = previousModelProfiles;
-    setSlackReactionConfig(previousSlackReactionConfig);
-    setSandboxResourceConfig(previousSandboxResources);
-    setExperimentalFeatures(previousExperimentalFeatures);
-    setDashboardConversationLinkOptions(previousDashboardLinkOptions);
+    restoreRuntimeConfig();
     throw error;
   }
   const waitUntil = options?.waitUntil ?? await defaultWaitUntil();
@@ -8938,6 +8793,54 @@ async function createApp(options) {
     replyExecutor: { agentRunner },
     sandbox: { tracePropagation }
   };
+  let conversationWorkOptions;
+  const getConversationWorkOptions = () => {
+    conversationWorkOptions ??= options?.conversationWork ?? createProductionConversationWorkOptions({
+      agentRunner,
+      services: runtimeServiceOverrides
+    });
+    return conversationWorkOptions;
+  };
+  let adapterRoutes = [];
+  let authenticatedRoutes = [];
+  try {
+    const adapterOutputs = await Promise.all(
+      (options?.adapters ?? []).map(async (adapter) => {
+        const work = getConversationWorkOptions();
+        const state = work.state ?? getStateAdapter();
+        return await adapter({
+          agentName: botConfig.userName,
+          baseURL: resolveAdapterBaseURL(dashboard),
+          conversations: createAdapterConversations({
+            conversationStore: work.conversationStore,
+            eventStore: getConversationEventStore(),
+            queue: work.queue ?? getVercelConversationWorkQueue(),
+            state
+          }),
+          reportError: (error, event, attributes) => void logException(error, event, attributes),
+          state,
+          version: JUNIOR_VERSION
+        });
+      })
+    );
+    adapterRoutes = adapterOutputs.flatMap((output) => output.routes ?? []);
+    authenticatedRoutes = adapterOutputs.flatMap(
+      (output) => output.authenticatedRoutes ?? []
+    );
+    if (authenticatedRoutes.length > 0 && (!dashboard || dashboard.disabled)) {
+      throw new Error(
+        "createApp() adapters with authenticated routes require an enabled dashboard"
+      );
+    }
+    validateDashboardRouteOwnership({
+      authenticatedRoutes,
+      dashboard,
+      routes: pluginRoutes
+    });
+  } catch (error) {
+    restoreRuntimeConfig();
+    throw error;
+  }
   const slackWebhookServices = createProductionSlackWebhookServices({
     services: runtimeServiceOverrides
   });
@@ -8954,9 +8857,11 @@ async function createApp(options) {
     );
   });
   mountRoutes(app, pluginRoutes);
+  mountRoutes(app, adapterRoutes);
   mountRoutes(
     app,
     await createDashboardRouteRegistrations({
+      authenticatedRoutes,
       dashboard,
       createDashboardApp: virtualConfig?.createDashboardApp,
       pluginRoutes: pluginApiRoutes
@@ -8994,32 +8899,6 @@ async function createApp(options) {
   });
   let agentContinuePOST;
   let pluginTaskPOST;
-  let conversationWorkOptions;
-  const getConversationWorkOptions = () => {
-    conversationWorkOptions ??= options?.conversationWork ?? createProductionConversationWorkOptions({
-      agentRunner,
-      services: runtimeServiceOverrides
-    });
-    return conversationWorkOptions;
-  };
-  if (isExperimentalFeatureEnabled("acp")) {
-    const work = getConversationWorkOptions();
-    const cancellation = work.apiTurnCancellation;
-    if (!cancellation) {
-      throw new Error("Experimental ACP requires API Turn cancellation wiring");
-    }
-    const handleAcpRequest = createAcpHttpHandler({
-      cancellation,
-      conversationStore: work.conversationStore,
-      queue: work.queue ?? getVercelConversationWorkQueue(),
-      state: work.state
-    });
-    app.on(
-      ["GET", "POST", "DELETE"],
-      "/api/acp",
-      (c) => handleAcpRequest(c.req.raw)
-    );
-  }
   if (process.env.NODE_ENV === "development") {
     registerVercelConversationWorkDevConsumer(getConversationWorkOptions());
     registerVercelPluginTaskDevConsumer();