@sentry/junior 0.162.0 → 0.164.0

package/dist/app.js

@@ -1,15 +1,15 @@
 import {
   processConversationWork
-} from "./chunk-HW4BW3PC.js";
+} from "./chunk-CGCNFEAU.js";
 import {
   bindSpawnAgent
-} from "./chunk-H2KW7AZC.js";
+} from "./chunk-XAIRI54J.js";
 import {
   createAgentInvocationWorker,
   enqueueAgentInvocation,
   listPendingAgentInvocationMailboxAppends,
   routeAgentInvocationWork
-} from "./chunk-AJ7J2HWY.js";
+} from "./chunk-Y2B6AXZQ.js";
 import {
   GET as GET2,
   GET2 as GET3,
@@ -36,23 +36,30 @@ import {
   startSlackProcessingReaction,
   stripLeadingBotMention,
   wakePausedTurn
-} from "./chunk-C3KUKA27.js";
+} from "./chunk-3L23VTY7.js";
 import "./chunk-FA6POGLH.js";
 import {
   getTurnRequestDeadline,
   runWithTurnRequestDeadline
-} from "./chunk-MMBMDSRK.js";
+} from "./chunk-RYYEHWIL.js";
 import {
   GET,
+  apiTurnIdForMessage,
+  appendAndEnqueueApiConversationMessage,
+  authenticatePersonalToken,
   conversationVisibilityFromSlackChannelType,
+  createApiTurnCancellation,
   createApiTurnWorker,
   createVercelAttachmentStorage,
   lookupSlackUser,
+  readConversationAccessFromSql,
+  recordApiConversationActivity,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext,
-  routeApiTurnWork
-} from "./chunk-JRVURR3H.js";
-import "./chunk-RDV4BQRZ.js";
+  routeApiTurnWork,
+  webActorFromEmail
+} from "./chunk-FKDY7NTC.js";
+import "./chunk-5FWQ73UZ.js";
 import {
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
   appendAndEnqueueInboundMessage,
@@ -63,7 +70,7 @@ import {
   isInvalidConversationRecordError,
   listActiveConversationIds,
   removeActiveConversation
-} from "./chunk-5NEBOHRG.js";
+} from "./chunk-NAGI2XH3.js";
 import {
   buildDeliveredTurnStatePatch,
   claimDispatchMailboxAppend,
@@ -94,7 +101,7 @@ import {
   requireTurnFailureEventId,
   resolveTurnSessionRouting,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-KQSO4DJ4.js";
+} from "./chunk-ZUTAGCPH.js";
 import {
   ConversationTurnLifecycleService,
   coerceThreadConversationState,
@@ -104,7 +111,7 @@ import {
   persistThreadRuntimeState,
   persistThreadState,
   persistThreadStateById
-} from "./chunk-OPNJRQDP.js";
+} from "./chunk-2K25MRZK.js";
 import "./chunk-UTL3MHPC.js";
 import {
   getVercelConversationWorkQueue,
@@ -123,7 +130,7 @@ import {
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-JJ3VXFDI.js";
+} from "./chunk-4GTOFUQF.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -158,11 +165,11 @@ import {
   shouldEmitDevAgentTrace,
   shouldPropagateSandboxEgressTrace,
   unpublishedArtifactHeaders
-} from "./chunk-EHQLTK3X.js";
+} from "./chunk-7WKWMMYQ.js";
 import {
   AuthorizationFlowDisabledError,
   PluginCredentialFailureError
-} from "./chunk-K7IV6UV3.js";
+} from "./chunk-6BXV63YX.js";
 import "./chunk-DIB4GX3G.js";
 import {
   createAgentRunner,
@@ -170,7 +177,7 @@ import {
   deleteMcpAuthSessionsForUserProvider,
   deleteMcpServerSessionId,
   deleteMcpStoredOAuthCredentials
-} from "./chunk-OBFRMQBY.js";
+} from "./chunk-H36GJVJV.js";
 import {
   RetryableDeliveryError
 } from "./chunk-RF6J3DIO.js";
@@ -178,16 +185,17 @@ import {
   formatProviderLabel,
   postSlackMessage,
   startOAuthFlow
-} from "./chunk-O6P7DZ6O.js";
+} from "./chunk-JW23XD4I.js";
 import "./chunk-7MA4HV4W.js";
 import {
   getExperimentalFeatures,
+  isExperimentalFeatureEnabled,
   setExperimentalFeatures
-} from "./chunk-5IDFPCON.js";
+} from "./chunk-VRS6WDK5.js";
 import {
   getSandboxResourceConfig,
   setSandboxResourceConfig
-} from "./chunk-6BJFIWEV.js";
+} from "./chunk-RJHZNPDH.js";
 import {
   collectAttachmentGarbage,
   createSchedulerSqlStore,
@@ -195,10 +203,10 @@ import {
   logScheduledTaskRunSkipped,
   requestAttachmentDeletion,
   scheduledTaskRunAttributes
-} from "./chunk-4WYGQ47U.js";
+} from "./chunk-6ENAACWN.js";
 import {
   parseSlackThreadId
-} from "./chunk-WHAJ3QVY.js";
+} from "./chunk-WJUKESU2.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
@@ -238,6 +246,7 @@ import {
   persistConversationMessageSummaries,
   persistConversationMessages,
   persistWithRetry,
+  projectConversationMessages,
   recordDeliveredAssistantMessage,
   recordSubscribedReplyRoute,
   recordTurnSummary,
@@ -248,7 +257,7 @@ import {
   trimTrailingAssistantMessages,
   turnHasReply,
   upsertConversationMessage
-} from "./chunk-V7QL4QMW.js";
+} from "./chunk-HHW6ZVIZ.js";
 import "./chunk-3Y47VMHV.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
@@ -268,6 +277,7 @@ import {
   getWorkspaceTeamId,
   isDmChannel,
   normalizeSlackConversationId,
+  resolveViewerUser,
   runWithSlackInstallationToken,
   runWithWorkspaceTeamId,
   setDashboardConversationLinkOptions,
@@ -276,7 +286,7 @@ import {
   verifyEventTaskCredentialSubject,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-QHCIZLIX.js";
+} from "./chunk-YHCTPDXS.js";
 import {
   contextProvenance,
   createSlackDestination,
@@ -289,19 +299,21 @@ import {
   requireSlackDestination,
   withConversationEventLock,
   withConversationMutationLock
-} from "./chunk-DDQ43S5Q.js";
+} from "./chunk-LPLVNMVN.js";
 import {
   juniorAgentBindings,
   juniorAgentInvocations,
   juniorConversationEvents,
   juniorConversations
-} from "./chunk-CZ6EHOU5.js";
-import "./chunk-EM225ITJ.js";
+} from "./chunk-ZSNABC2E.js";
+import {
+  sleep
+} from "./chunk-BVREIWBD.js";
 import {
   acquireActiveLock,
   getStateAdapter,
   withActiveLock
-} from "./chunk-DZC3F2UI.js";
+} from "./chunk-BXBZDV3C.js";
 import {
   STANDARD_MODEL_PROFILE,
   botConfig,
@@ -319,16 +331,16 @@ import {
   modelIdForProfile,
   setSlackReactionConfig,
   standardModelId
-} from "./chunk-MNCEGXEH.js";
+} from "./chunk-FX4PX3SA.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
-import "./chunk-7DTPFFQX.js";
-import "./chunk-FEWT5KPP.js";
+import "./chunk-RBV4JHCP.js";
+import "./chunk-NLTQRYNP.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-FESUWAYU.js";
-import "./chunk-EBEHJPFF.js";
+} from "./chunk-RULIISEI.js";
+import "./chunk-VV2DN24T.js";
 import {
   credentialContextForActor
 } from "./chunk-BDUENQD3.js";
@@ -360,7 +372,7 @@ import {
   withContext,
   withLogContext,
   withSpan
-} from "./chunk-Y75ZDQB5.js";
+} from "./chunk-VHSEMJTS.js";
 import {
   continueTrace
 } from "./chunk-6GWA276C.js";
@@ -368,10 +380,10 @@ import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
 import {
   JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE
-} from "./chunk-THXMSSFZ.js";
+} from "./chunk-26JYGL2L.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-BPZQWAZJ.js";
+} from "./chunk-5GLGQHO3.js";
 import "./chunk-MLKGABMK.js";
 
 // src/app.ts
@@ -8402,6 +8414,7 @@ async function runNextPausedTurnInContext(conversationId, options, runOptions) {
 
 // src/chat/app/conversation-work.ts
 function createConversationWork(options) {
+  const apiTurnCancellation = createApiTurnCancellation();
   const services = {
     ...options.services,
     replyExecutor: {
@@ -8457,11 +8470,13 @@ function createConversationWork(options) {
     fallbackWorker: slackWorker
   });
   return {
+    apiTurnCancellation,
     conversationStore: options.conversationStore,
     queue: options.queue,
     run: routeApiTurnWork({
       apiTurnWorker: createApiTurnWorker({
-        agentRunner: options.agentRunner
+        agentRunner: options.agentRunner,
+        cancellation: apiTurnCancellation
       }),
       fallbackWorker: routeAgentInvocationWork({
         invocationWorker: createAgentInvocationWorker({
@@ -8774,6 +8789,415 @@ 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);
+  }
+  const access = (await readConversationAccessFromSql(getDb(), [sessionId], user)).get(sessionId);
+  if (!access?.isParticipant) {
+    throw acp.RequestError.resourceNotFound(sessionId);
+  }
+}
+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);
+  }
+  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`
+    );
+  }
+  return text;
+}
+function requestIdKey(requestId) {
+  if (requestId === null) return "null";
+  return `${typeof requestId}:${requestId}`;
+}
+async function latestEventSeq(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"
+        );
+      }
+    }
+  }
+}
+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
+    },
+    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 {};
+      }
+    );
+  }).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)
+        });
+      }
+    );
+  }).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,
+          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 (request.method === "DELETE" && response.ok && connectionId) {
+      connectionActors.delete(connectionId);
+    }
+    return response;
+  };
+}
+
 // src/app.ts
 var DASHBOARD_PACKAGE_NAME = "@sentry/junior-dashboard";
 async function defaultWaitUntil() {
@@ -8975,6 +9399,8 @@ function dashboardHostRoutePaths(dashboard) {
     "/api/people/*",
     "/api/personal-tokens",
     "/api/personal-tokens/*",
+    "/api/workspaces",
+    "/api/workspaces/*",
     "/api/config",
     "/api/me",
     authPath,
@@ -9065,11 +9491,11 @@ function validateDashboardRouteOwnership(args) {
 function mountRoutes(app, routes) {
   for (const route of routes) {
     const handler = (c) => route.handler(c.req.raw);
-    const methods = Array.isArray(route.method) ? route.method : [route.method ?? "ALL"];
-    const explicitMethods = methods.filter(
+    const methods2 = Array.isArray(route.method) ? route.method : [route.method ?? "ALL"];
+    const explicitMethods = methods2.filter(
       (method) => method !== "ALL"
     );
-    if (methods.includes("ALL")) {
+    if (methods2.includes("ALL")) {
       app.all(route.path, handler);
     } else if (explicitMethods.length > 0) {
       app.on(explicitMethods, route.path, handler);
@@ -9245,6 +9671,24 @@ async function createApp(options) {
     });
     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();