@sentry/junior 0.188.0 → 0.189.0

package/dist/chunk-LODJKINF.js

@@ -1,1502 +0,0 @@
-import {
-  createWebAuthorization,
-  deleteWebAuthorization
-} from "./chunk-PSHMPRIU.js";
-import {
-  AgentRunError,
-  executeTurn
-} from "./chunk-ERZMACYA.js";
-import {
-  buildDeliveredTurnStatePatch,
-  completeAuthPauseTurn,
-  finalizeFailedTurnReplyWithEvent,
-  getTurnUserMessage
-} from "./chunk-QDHJTKPE.js";
-import {
-  processPluginTask,
-  scheduleSessionCompletedPluginTasks
-} from "./chunk-AW77HH54.js";
-import {
-  ConversationTurnLifecycleService
-} from "./chunk-W42ENMJW.js";
-import {
-  coerceThreadConversationState,
-  getPersistedSandboxState,
-  getPersistedThreadState,
-  persistThreadStateById
-} from "./chunk-CIG6WI7Q.js";
-import {
-  healthReportSchema
-} from "./chunk-UTL3MHPC.js";
-import {
-  RESOURCE_EVENT_MESSAGE_AUTHOR,
-  RESOURCE_EVENT_SYSTEM_ACTOR,
-  isResourceEventConversationMessage,
-  isResourceEventMailboxMetadata
-} from "./chunk-VFZAUQ5V.js";
-import {
-  parseSlackThreadId
-} from "./chunk-CVBDVIF4.js";
-import {
-  appendAndEnqueueExclusiveInboundMessage,
-  appendAndEnqueueInboundMessage
-} from "./chunk-MQDIIFZM.js";
-import {
-  TurnInputCommitLostError,
-  buildDeterministicTurnId,
-  clearPendingAuth,
-  getAssistantReplyText,
-  getConversationTurnBoundaryError,
-  isTurnInputCommitLostError,
-  markTurnClosed,
-  markTurnFailed,
-  startActiveTurn
-} from "./chunk-Z5SKZE5B.js";
-import {
-  abandonTurnRecord,
-  buildConversationContext,
-  commitAcceptedReply,
-  getTurnRecord,
-  hydrateConversationMessages,
-  listTurnSummaries,
-  loadProjection,
-  markConversationMessage,
-  normalizeConversationText,
-  persistConversationMessages,
-  persistWithRetry,
-  recordDeliveredAssistantMessage,
-  saveTurnCheckpoint,
-  upsertConversationMessage
-} from "./chunk-6YGFBU3A.js";
-import {
-  normalizeSlackConversationId
-} from "./chunk-QCGNHSMA.js";
-import {
-  getConversationEventStore,
-  getConversationStore,
-  getDb
-} from "./chunk-IUUQWIG2.js";
-import {
-  juniorConversationParticipants,
-  juniorConversations,
-  juniorIdentities,
-  juniorUsers
-} from "./chunk-QVH6FW3T.js";
-import {
-  juniorDestinations
-} from "./chunk-VFUK3X5B.js";
-import {
-  getSlackBotToken
-} from "./chunk-Q7O74WOO.js";
-import {
-  canExposeConversationPayload
-} from "./chunk-FIUCHYT6.js";
-import {
-  credentialContextForActor
-} from "./chunk-CEMMLV5L.js";
-import {
-  createActor
-} from "./chunk-N7TMSOZH.js";
-import {
-  logException,
-  logWarn,
-  setTags,
-  withLogContext
-} from "./chunk-QIMN3FXL.js";
-
-// src/handlers/health.ts
-function readHealthReport() {
-  return healthReportSchema.parse({
-    status: "ok",
-    service: "junior",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  });
-}
-function GET() {
-  return Response.json(readHealthReport());
-}
-
-// src/chat/attachments/vercel.ts
-import { del, get, put } from "@vercel/blob";
-function createVercelAttachmentStorage() {
-  return {
-    provider: "vercel-blob",
-    async put(input) {
-      await put(input.key, input.body, {
-        access: "private",
-        addRandomSuffix: false,
-        allowOverwrite: true,
-        contentType: input.contentType
-      });
-    },
-    async get(key) {
-      const result = await get(key, { access: "private" });
-      return result?.statusCode === 200 ? result.stream : null;
-    },
-    async delete(keys) {
-      if (keys.length === 0) return;
-      await del(keys);
-    }
-  };
-}
-
-// src/chat/api-turns/routing.ts
-import { z } from "zod";
-import {
-  createLocalSource,
-  createWebSource
-} from "@sentry/junior-plugin-api";
-var apiTurnMailboxMetadataSchema = z.object({
-  authorEmail: z.string().email(),
-  authorFullName: z.string().min(1).optional(),
-  authorUserId: z.string().min(1),
-  authorUserName: z.string().min(1).optional(),
-  kind: z.literal("api_turn"),
-  messageId: z.string().min(1)
-}).strict();
-function turnIdentityFromConversationMessage(message) {
-  if (isResourceEventConversationMessage(message)) {
-    return {
-      actor: RESOURCE_EVENT_SYSTEM_ACTOR,
-      author: message.author ?? RESOURCE_EVENT_MESSAGE_AUTHOR,
-      source: "resource_event"
-    };
-  }
-  const actor = createActor(message.author, {
-    platform: "web",
-    userId: message.author?.userId
-  });
-  if (actor?.platform !== "web") {
-    return void 0;
-  }
-  return {
-    actor,
-    author: message.author ?? { userId: actor.userId },
-    source: "web"
-  };
-}
-function sourceFromTurnInput(args) {
-  switch (args.source) {
-    case "resource_event":
-      return createLocalSource(args.conversationId);
-    case "web":
-      return createWebSource(
-        args.conversationId,
-        args.visibility === "private" ? "private" : "public"
-      );
-  }
-}
-async function getActiveApiTurnId(conversationId) {
-  const summaries = await listTurnSummaries(conversationId);
-  const active = summaries.filter(
-    (summary) => summary.surface === "api" && !summary.dispatchId && (summary.state === "paused" || summary.state === "running")
-  );
-  if (active.length > 1) {
-    throw new Error(
-      `Conversation ${conversationId} has multiple active web turns`
-    );
-  }
-  const turnId = active[0]?.turnId;
-  if (!turnId) return void 0;
-  const record = await getTurnRecord(conversationId, turnId);
-  return record && record.surface === "api" && !record.dispatchId && (record.state === "paused" || record.state === "running") ? turnId : void 0;
-}
-async function getAuthPausedApiTurnId(conversationId) {
-  const turnId = await getActiveApiTurnId(conversationId);
-  if (!turnId) return void 0;
-  const record = await getTurnRecord(conversationId, turnId);
-  return record?.state === "paused" && record.resumeReason === "auth" ? turnId : void 0;
-}
-function parseApiTurnMessages(messages) {
-  if (messages.length === 0) {
-    return [];
-  }
-  const parsed = messages.map((message) => ({
-    message,
-    metadata: apiTurnMailboxMetadataSchema.safeParse(message.input.metadata)
-  }));
-  if (parsed.every((entry) => !entry.metadata.success)) {
-    return [];
-  }
-  if (parsed.some((entry) => !entry.metadata.success)) {
-    throw new Error("A Turn cannot combine different kinds of input");
-  }
-  return parsed.map((entry) => {
-    if (!entry.metadata.success) {
-      throw new Error("User message has invalid metadata");
-    }
-    const metadata = entry.metadata.data;
-    const actor = {
-      platform: "web",
-      userId: metadata.authorUserId,
-      email: metadata.authorEmail.trim().toLowerCase(),
-      ...metadata.authorFullName ? { fullName: metadata.authorFullName } : void 0,
-      ...metadata.authorUserName ? { userName: metadata.authorUserName } : void 0
-    };
-    return {
-      actor,
-      author: {
-        email: actor.email,
-        ...actor.fullName ? { fullName: actor.fullName } : void 0,
-        userId: actor.userId,
-        ...actor.userName ? { userName: actor.userName } : void 0
-      },
-      message: entry.message,
-      source: "web"
-    };
-  });
-}
-function parseResourceEventMessages(messages) {
-  if (messages.length === 0) {
-    return [];
-  }
-  if (!messages.every(
-    (message) => message.source === "resource_event" && isResourceEventMailboxMetadata(message.input.metadata)
-  )) {
-    return [];
-  }
-  return messages.map((message) => {
-    if (!isResourceEventMailboxMetadata(message.input.metadata)) {
-      throw new Error("Resource event has invalid metadata");
-    }
-    return {
-      actor: RESOURCE_EVENT_SYSTEM_ACTOR,
-      author: RESOURCE_EVENT_MESSAGE_AUTHOR,
-      message,
-      source: "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 = parseResourceEventMessages(context.attempt.messages);
-    if (resourceBatch.length > 0) {
-      return { kind: "mailbox", batch: resourceBatch };
-    }
-  }
-  if (context.attempt.messages.length > 0) {
-    return void 0;
-  }
-  const turnId = await getActiveApiTurnId(context.conversationId);
-  return turnId ? { kind: "resume", turnId } : void 0;
-}
-async function isApiTurnWork(context) {
-  return await resolveApiTurnWork(context) !== void 0;
-}
-
-// src/chat/api-turns/work.ts
-import { createHash } from "crypto";
-import {
-  localDestinationSchema
-} from "@sentry/junior-plugin-api";
-
-// src/chat/api-turns/assistant-message.ts
-async function commitAssistantMessage(args) {
-  const conversationMessageId = recordDeliveredAssistantMessage({
-    conversation: args.conversation,
-    sessionId: args.sessionId,
-    source: args.source,
-    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("Assistant message persistence failed"),
-      "conversation.assistant.message_persist.failed",
-      {
-        "error.type": error instanceof Error ? error.name : typeof error
-      }
-    );
-  }
-}
-
-// src/chat/api-turns/cancellation.ts
-function createApiTurnCancellation() {
-  const active = /* @__PURE__ */ new Map();
-  return {
-    begin(conversationId) {
-      if (active.has(conversationId)) {
-        return void 0;
-      }
-      const controller = new AbortController();
-      active.set(conversationId, {
-        connected: true,
-        controller,
-        parked: false
-      });
-      return controller.signal;
-    },
-    cancel(conversationId) {
-      const entry = active.get(conversationId);
-      if (!entry) {
-        return false;
-      }
-      entry.controller.abort(new DOMException("Turn cancelled", "AbortError"));
-      return true;
-    },
-    disconnect(conversationId, signal) {
-      const entry = active.get(conversationId);
-      if (entry?.controller.signal !== signal) {
-        return;
-      }
-      entry.connected = false;
-      if (entry.parked) {
-        active.delete(conversationId);
-      }
-    },
-    finish(conversationId, signal) {
-      const entry = active.get(conversationId);
-      if (entry?.controller.signal === signal) {
-        active.delete(conversationId);
-      }
-    },
-    park(conversationId, signal) {
-      const entry = active.get(conversationId);
-      if (entry?.controller.signal !== signal) {
-        return;
-      }
-      entry.parked = true;
-      if (!entry.connected) {
-        active.delete(conversationId);
-      }
-    },
-    signal(conversationId) {
-      return active.get(conversationId)?.controller.signal;
-    }
-  };
-}
-async function completeCancelledApiTurn(args) {
-  try {
-    const pendingAuthorization = args.conversation.processing.pendingAuth?.sessionId === args.turnId ? args.conversation.processing.pendingAuth : void 0;
-    await abandonTurnRecord({
-      conversationId: args.conversationId,
-      turnId: args.turnId,
-      errorMessage: "Turn cancelled"
-    });
-    clearPendingAuth(args.conversation, args.turnId);
-    markConversationMessage(args.conversation, args.userMessageId, {
-      replied: false,
-      skippedReason: "turn cancelled"
-    });
-    markTurnClosed({
-      conversation: args.conversation,
-      nowMs: Date.now(),
-      sessionId: args.turnId
-    });
-    if (pendingAuthorization) {
-      await deleteWebAuthorization({
-        actorId: pendingAuthorization.actorId,
-        conversationId: args.conversationId
-      });
-    }
-    await persistThreadStateById(args.conversationId, {
-      conversation: args.conversation,
-      sandboxRef: args.sandboxRef
-    });
-    await new ConversationTurnLifecycleService(
-      getConversationEventStore()
-    ).complete({
-      conversationId: args.conversationId,
-      createdAtMs: Date.now(),
-      outcome: "cancelled",
-      turnId: args.turnId
-    });
-  } finally {
-    if (args.signal) {
-      args.cancellation?.finish(args.conversationId, args.signal);
-    }
-  }
-  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");
-}
-
-// src/chat/api-turns/work.ts
-function normalizeEmail(email) {
-  return email.trim().toLowerCase();
-}
-function stableHex(...parts) {
-  return createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 24);
-}
-function createApiConversationId(args) {
-  return `local:web:${stableHex(
-    normalizeEmail(args.actorEmail),
-    args.idempotencyKey
-  )}`;
-}
-function apiConversationMessageId(args) {
-  return `api-msg:${stableHex(args.conversationId, args.idempotencyKey)}`;
-}
-function apiTurnIdForMessage(messageId) {
-  return buildDeterministicTurnId(messageId);
-}
-function requireLocalDestination(conversationId) {
-  const parsed = localDestinationSchema.safeParse({
-    platform: "local",
-    conversationId
-  });
-  if (!parsed.success) {
-    throw new Error(`Invalid local conversation id: ${conversationId}`);
-  }
-  return parsed.data;
-}
-function resolveApiTurnDestination(args) {
-  if (args.existing) {
-    return args.existing;
-  }
-  return requireLocalDestination(args.conversationId);
-}
-function storedActorFromApi(actor) {
-  return {
-    ...actor.email ? { email: normalizeEmail(actor.email) } : void 0,
-    ...actor.fullName ? { fullName: actor.fullName } : void 0
-  };
-}
-function webActorFromEmail(email, profile) {
-  const normalized = normalizeEmail(email);
-  return {
-    platform: "web",
-    userId: `dashboard:${stableHex(normalized)}`,
-    email: normalized,
-    ...profile?.fullName ? { fullName: profile.fullName } : void 0,
-    ...profile?.userName ? { userName: profile.userName } : void 0
-  };
-}
-function buildApiTurnInboundMessage(args) {
-  const text = args.message.trim();
-  if (!text) {
-    throw new Error("API conversation message must not be empty");
-  }
-  if (!args.actor.email) {
-    throw new Error("API conversation actor requires a verified email");
-  }
-  const destination = resolveApiTurnDestination({
-    conversationId: args.conversationId,
-    existing: args.destination
-  });
-  const nowMs = args.nowMs ?? Date.now();
-  return {
-    conversationId: args.conversationId,
-    createdAtMs: args.createdAtMs ?? nowMs,
-    delivery: "defer",
-    destination,
-    inboundMessageId: args.messageId,
-    input: {
-      authorId: args.actor.userId,
-      text,
-      metadata: {
-        authorEmail: normalizeEmail(args.actor.email),
-        ...args.actor.fullName && { authorFullName: args.actor.fullName },
-        authorUserId: args.actor.userId,
-        ...args.actor.userName && { authorUserName: args.actor.userName },
-        kind: "api_turn",
-        messageId: args.messageId
-      }
-    },
-    receivedAtMs: nowMs,
-    publishExternally: false,
-    source: "web"
-  };
-}
-async function recordApiConversationActivity(args) {
-  const store = args.conversationStore ?? getConversationStore();
-  const existing = await store.get({ conversationId: args.conversationId });
-  const destination = resolveApiTurnDestination({
-    conversationId: args.conversationId,
-    existing: existing?.destination
-  });
-  const isNewRoot = !existing;
-  const visibility = args.rootVisibility === "private" ? "private" : "public";
-  const source = isNewRoot ? sourceFromTurnInput({
-    conversationId: args.conversationId,
-    source: "web",
-    visibility
-  }) : void 0;
-  await store.recordActivity({
-    conversationId: args.conversationId,
-    destination,
-    nowMs: args.nowMs,
-    actor: storedActorFromApi(args.actor),
-    // Do not rewrite a Slack root's origin source when a dashboard participant
-    // continues it. Mailbox entries still carry source "web" per turn.
-    ...isNewRoot ? { source: "web" } : void 0,
-    ...source ? { sessionSource: source } : void 0,
-    ...isNewRoot ? { visibility } : void 0
-  });
-  return destination;
-}
-async function createAndEnqueueApiConversation(input, options) {
-  if (!input.actor.email) {
-    throw new Error("API conversation actor requires a verified email");
-  }
-  const conversationId = createApiConversationId({
-    actorEmail: input.actor.email,
-    idempotencyKey: input.idempotencyKey
-  });
-  return await appendAndEnqueueApiConversationMessage(
-    {
-      actor: input.actor,
-      conversationId,
-      idempotencyKey: input.idempotencyKey,
-      message: input.message,
-      rootVisibility: input.visibility === "private" ? "private" : "public"
-    },
-    options
-  );
-}
-async function appendAndEnqueueApiConversationMessage(input, options) {
-  const text = input.message.trim();
-  if (!text) {
-    throw new Error("API conversation message must not be empty");
-  }
-  if (!input.actor.email) {
-    throw new Error("API conversation actor requires a verified email");
-  }
-  const nowMs = options.nowMs ?? Date.now();
-  const messageId = apiConversationMessageId({
-    conversationId: input.conversationId,
-    idempotencyKey: input.idempotencyKey
-  });
-  const destination = await recordApiConversationActivity({
-    actor: input.actor,
-    conversationId: input.conversationId,
-    conversationStore: options.conversationStore,
-    nowMs,
-    ...input.rootVisibility && { rootVisibility: input.rootVisibility }
-  });
-  const enqueue = options.exclusive ? appendAndEnqueueExclusiveInboundMessage : appendAndEnqueueInboundMessage;
-  const result = await enqueue({
-    message: buildApiTurnInboundMessage({
-      actor: input.actor,
-      conversationId: input.conversationId,
-      destination,
-      message: text,
-      messageId,
-      nowMs
-    }),
-    conversationStore: options.conversationStore,
-    nowMs,
-    queue: options.queue,
-    state: options.state
-  });
-  const status = result.status === "appended" ? "accepted" : result.status;
-  return {
-    conversationId: input.conversationId,
-    messageId,
-    status
-  };
-}
-function captureApiBoundaryFailure(args) {
-  const eventId = logException(args.error, `api.turn.${args.failureCode}`, {
-    conversationId: args.conversationId,
-    ...args.runId ? { runId: args.runId } : void 0,
-    turnId: args.turnId
-  });
-  return typeof eventId === "string" ? eventId : void 0;
-}
-function hasLostTurnInputCommit(error) {
-  const cause = getConversationTurnBoundaryError(error)?.cause ?? error;
-  return isTurnInputCommitLostError(error) || isTurnInputCommitLostError(cause);
-}
-function createApiTurnWorker(agentRunner, cancellation) {
-  return async (context) => {
-    const resolved = await resolveApiTurnWork(context);
-    if (!resolved) {
-      throw new Error(
-        `Unsupported input for Conversation ${context.conversationId}`
-      );
-    }
-    if (context.publishExternally) {
-      throw new Error(
-        `publishExternally must be false for Conversation ${context.conversationId}`
-      );
-    }
-    const lifecycle = new ConversationTurnLifecycleService(
-      getConversationEventStore()
-    );
-    const isResume = resolved.kind === "resume";
-    let turnIdentity;
-    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.batch[0]?.message.destination : void 0;
-    const destination = resolveApiTurnDestination({
-      conversationId: context.conversationId,
-      existing: context.destination ?? mailboxDestination ?? storedConversation?.destination
-    });
-    if (resolved.kind === "mailbox") {
-      const first = resolved.batch[0];
-      text = joinMailboxText(resolved.batch.map((entry) => entry.message));
-      startedAtMs = first.message.createdAtMs;
-      userMessageId = first.message.inboundMessageId;
-      turnId = apiTurnIdForMessage(userMessageId);
-      inputMessageIds = resolved.batch.map(
-        (entry) => entry.message.inboundMessageId
-      );
-      turnIdentity = first;
-    } else {
-      turnId = resolved.turnId;
-    }
-    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(
-          `Unable to locate the persisted user message for Turn "${turnId}"`
-        );
-      }
-      turnIdentity = turnIdentityFromConversationMessage(userMessage);
-      userMessageId = userMessage.id;
-      text = userMessage.text;
-      startedAtMs = userMessage.createdAtMs;
-      inputMessageIds = [userMessageId];
-    }
-    if (!turnIdentity) {
-      throw new Error(
-        `Resumed Turn is missing an Actor for Conversation ${context.conversationId}`
-      );
-    }
-    const { actor, author } = turnIdentity;
-    const source = sourceFromTurnInput({
-      conversationId: context.conversationId,
-      source: turnIdentity.source,
-      visibility: storedConversation?.visibility
-    });
-    const webActor = actor.platform === "web" ? actor : void 0;
-    return await withLogContext(
-      {
-        conversationId: context.conversationId,
-        platform: actor.platform,
-        ...webActor ? {
-          userId: webActor.userId,
-          ...webActor.userName ? { userName: webActor.userName } : void 0
-        } : void 0
-      },
-      async () => {
-        let acknowledged = isResume || context.attempt.messages.length === 0;
-        const acknowledge = async () => {
-          if (acknowledged) {
-            return;
-          }
-          try {
-            await context.attempt.ack();
-          } catch {
-            throw new TurnInputCommitLostError(
-              `Conversation work lease lost before Conversation API message acknowledgement for ${context.conversationId}`
-            );
-          }
-          acknowledged = true;
-        };
-        let sandboxRef = getPersistedSandboxState(persisted);
-        const initialSandboxRef = sandboxRef;
-        const appSignal = cancellation?.signal(context.conversationId);
-        const stopSignal = context.stopSignal?.();
-        const cancellationSignal = appSignal && stopSignal ? AbortSignal.any([appSignal, stopSignal]) : appSignal ?? stopSignal;
-        const finishCancellation = () => {
-          if (appSignal) {
-            cancellation?.finish(context.conversationId, appSignal);
-          }
-        };
-        const completeCancelledTurn = async () => {
-          try {
-            await completeCancelledApiTurn({
-              acknowledge,
-              cancellation,
-              conversation,
-              conversationId: context.conversationId,
-              sandboxRef,
-              signal: appSignal,
-              turnId,
-              userMessageId
-            });
-          } catch (error) {
-            if (hasLostTurnInputCommit(error)) {
-              return { status: "lost_lease" };
-            }
-            throw error;
-          }
-          return { status: "completed" };
-        };
-        if (isResume) {
-          if (cancellationSignal?.aborted) {
-            return await completeCancelledTurn();
-          }
-        } else {
-          upsertConversationMessage(conversation, {
-            id: userMessageId,
-            role: "user",
-            text: normalizeConversationText(text),
-            createdAtMs: startedAtMs,
-            author,
-            meta: {
-              explicitMention: true,
-              replied: false,
-              ...turnIdentity.source === "web" ? { source: "web" } : void 0
-            }
-          });
-          await persistConversationMessages({
-            conversation,
-            conversationId: context.conversationId
-          });
-          await lifecycle.start({
-            conversationId: context.conversationId,
-            createdAtMs: Date.now(),
-            inputMessageIds,
-            surface: "api",
-            turnId
-          });
-          if (cancellationSignal?.aborted) {
-            return await completeCancelledTurn();
-          }
-          startActiveTurn({
-            conversation,
-            nextTurnId: turnId
-          });
-        }
-        let currentRunId;
-        let assistantMessageDelivered = false;
-        let failureCode = "persistence_failed";
-        let modelFailureEventId;
-        let modelFailureCaptureAttempted = false;
-        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;
-          await commitAssistantMessage({
-            ...agentMessage ? { agentMessage } : void 0,
-            conversation,
-            conversationId: context.conversationId,
-            sessionId: turnId,
-            ...turnIdentity.source === "web" ? { source: "web" } : void 0,
-            text: replyText,
-            userMessageId
-          });
-          failureCode = "agent_run_failed";
-        };
-        try {
-          if (cancellationSignal?.aborted) {
-            return await completeCancelledTurn();
-          }
-          if (!isResume) {
-            const pendingAuthorizationActorId = conversation.processing.pendingAuth?.actorId;
-            const authParked = (await listTurnSummaries(context.conversationId)).filter(
-              (summary) => summary.surface === "api" && !summary.dispatchId && summary.state === "paused" && summary.resumeReason === "auth"
-            );
-            for (const parked of authParked) {
-              if (cancellationSignal?.aborted) {
-                return await completeCancelledTurn();
-              }
-              await abandonTurnRecord({
-                conversationId: context.conversationId,
-                turnId: parked.turnId,
-                errorMessage: "Auth-paused Turn superseded by new input"
-              });
-              markTurnClosed({
-                conversation,
-                nowMs: Date.now(),
-                sessionId: parked.turnId
-              });
-            }
-            if (authParked.length > 0 && pendingAuthorizationActorId) {
-              await deleteWebAuthorization({
-                actorId: pendingAuthorizationActorId,
-                conversationId: context.conversationId
-              });
-            }
-          }
-          await persistThreadStateById(context.conversationId, {
-            conversation
-          });
-          if (cancellationSignal?.aborted) {
-            return await completeCancelledTurn();
-          }
-          const piMessages = await loadProjection({
-            conversationId: context.conversationId
-          });
-          failureCode = "agent_run_failed";
-          currentRunId = `api-run:${stableHex(turnId, String(startedAtMs))}`;
-          setTags({ runId: currentRunId });
-          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: storedConversation?.location ? { ...source, location: storedConversation.location } : source,
-              surface: "api",
-              ...cancellationSignal ? { signal: cancellationSignal } : void 0,
-              ...webActor ? {
-                authorization: createWebAuthorization({
-                  actorId: webActor.userId,
-                  conversationId: context.conversationId
-                })
-              } : { disabledFeatures: ["interactive-auth"] },
-              state: {
-                pendingAuth: conversation.processing.pendingAuth,
-                sandboxRef
-              },
-              delivery: { send: 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 (outcome.status !== "completed" && cancellationSignal?.aborted) {
-            return await completeCancelledTurn();
-          }
-          if (outcome.status === "suspended") {
-            return { status: "yielded" };
-          }
-          if (outcome.status === "awaiting_auth") {
-            completeAuthPauseTurn({
-              conversation,
-              sessionId: turnId
-            });
-            await persistThreadStateById(context.conversationId, {
-              conversation,
-              sandboxRef
-            });
-            if (appSignal) {
-              cancellation?.park(context.conversationId, appSignal);
-            }
-            await acknowledge();
-            return { status: "paused" };
-          }
-          if (completedSuccessfully) {
-            try {
-              await scheduleSessionCompletedPluginTasks(
-                {
-                  conversationId: context.conversationId,
-                  sessionId: turnId
-                },
-                {
-                  send: async (message) => {
-                    try {
-                      await processPluginTask(message);
-                    } catch (error) {
-                      logException(
-                        error,
-                        "api.plugin.session_completion_task.failed",
-                        {
-                          conversationId: context.conversationId,
-                          pluginName: message.plugin,
-                          taskName: message.name,
-                          turnId
-                        }
-                      );
-                    }
-                  }
-                }
-              );
-            } catch (error) {
-              logException(error, "api.plugin.session_completion_task.failed", {
-                conversationId: context.conversationId,
-                turnId
-              });
-            }
-          }
-          await acknowledge();
-          return { status: "completed" };
-        } catch (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 failure;
-          }
-          const failureEventId = modelFailureCaptureAttempted && failureCode === "agent_run_failed" ? modelFailureEventId : captureApiBoundaryFailure({
-            conversationId: context.conversationId,
-            error: failure,
-            failureCode,
-            runId: currentRunId,
-            turnId
-          });
-          try {
-            markTurnFailed({
-              conversation,
-              nowMs: Date.now(),
-              sessionId: turnId,
-              userMessageId,
-              markConversationMessage
-            });
-            await persistThreadStateById(context.conversationId, {
-              conversation,
-              sandboxRef: initialSandboxRef ?? null
-            });
-          } catch (persistenceError) {
-            captureApiBoundaryFailure({
-              conversationId: context.conversationId,
-              error: persistenceError,
-              failureCode: "persistence_failed",
-              runId: currentRunId,
-              turnId
-            });
-          }
-          await lifecycle.fail({
-            conversationId: context.conversationId,
-            createdAtMs: Date.now(),
-            ...failureEventId ? { eventId: failureEventId } : void 0,
-            failureCode,
-            turnId
-          });
-          finishCancellation();
-          await acknowledge();
-          return { status: "completed" };
-        }
-      }
-    );
-  };
-}
-function routeApiTurnWork(options) {
-  return async (context) => {
-    return await isApiTurnWork(context) ? await options.apiTurnWorker(context) : await options.fallbackWorker(context);
-  };
-}
-
-// src/api/conversations/access.ts
-import { eq as eq2, inArray as inArray2 } from "drizzle-orm";
-import { alias } from "drizzle-orm/pg-core";
-
-// src/api/conversations/membership.ts
-import {
-  and,
-  eq,
-  exists,
-  inArray,
-  isNotNull,
-  notExists,
-  or
-} from "drizzle-orm";
-function conversationHasParticipantUser(userId) {
-  const participant = getDb().select({
-    rootConversationId: juniorConversationParticipants.rootConversationId
-  }).from(juniorConversationParticipants).where(
-    and(
-      eq(
-        juniorConversationParticipants.rootConversationId,
-        juniorConversations.conversationId
-      ),
-      eq(juniorConversationParticipants.userId, userId)
-    )
-  );
-  return exists(participant);
-}
-function conversationHasParticipantEmail(email) {
-  const participant = getDb().select({
-    rootConversationId: juniorConversationParticipants.rootConversationId
-  }).from(juniorConversationParticipants).innerJoin(
-    juniorUsers,
-    eq(juniorUsers.id, juniorConversationParticipants.userId)
-  ).where(
-    and(
-      eq(
-        juniorConversationParticipants.rootConversationId,
-        juniorConversations.conversationId
-      ),
-      eq(juniorUsers.primaryEmailNormalized, email)
-    )
-  );
-  return exists(participant);
-}
-function conversationArchivedForUser(userId) {
-  const archive = getDb().select({
-    rootConversationId: juniorConversationParticipants.rootConversationId
-  }).from(juniorConversationParticipants).where(
-    and(
-      eq(
-        juniorConversationParticipants.rootConversationId,
-        juniorConversations.conversationId
-      ),
-      eq(juniorConversationParticipants.userId, userId),
-      isNotNull(juniorConversationParticipants.archivedAt)
-    )
-  );
-  return exists(archive);
-}
-function conversationNotArchivedForUser(userId) {
-  const archive = getDb().select({
-    rootConversationId: juniorConversationParticipants.rootConversationId
-  }).from(juniorConversationParticipants).where(
-    and(
-      eq(
-        juniorConversationParticipants.rootConversationId,
-        juniorConversations.conversationId
-      ),
-      eq(juniorConversationParticipants.userId, userId),
-      isNotNull(juniorConversationParticipants.archivedAt)
-    )
-  );
-  return notExists(archive);
-}
-function conversationArchivedForEmail(email) {
-  const archive = getDb().select({
-    rootConversationId: juniorConversationParticipants.rootConversationId
-  }).from(juniorConversationParticipants).innerJoin(
-    juniorUsers,
-    eq(juniorUsers.id, juniorConversationParticipants.userId)
-  ).where(
-    and(
-      eq(
-        juniorConversationParticipants.rootConversationId,
-        juniorConversations.conversationId
-      ),
-      eq(juniorUsers.primaryEmailNormalized, email),
-      isNotNull(juniorConversationParticipants.archivedAt)
-    )
-  );
-  return exists(archive);
-}
-function conversationNotArchivedForEmail(email) {
-  const archive = getDb().select({
-    rootConversationId: juniorConversationParticipants.rootConversationId
-  }).from(juniorConversationParticipants).innerJoin(
-    juniorUsers,
-    eq(juniorUsers.id, juniorConversationParticipants.userId)
-  ).where(
-    and(
-      eq(
-        juniorConversationParticipants.rootConversationId,
-        juniorConversations.conversationId
-      ),
-      eq(juniorUsers.primaryEmailNormalized, email),
-      isNotNull(juniorConversationParticipants.archivedAt)
-    )
-  );
-  return notExists(archive);
-}
-function viewerConversationMembership(args) {
-  if (args.actorMatch && args.participantMatch) {
-    return or(args.actorMatch, args.participantMatch);
-  }
-  return args.actorMatch ?? args.participantMatch;
-}
-async function conversationArchiveTimes(db, conversationIds, subject) {
-  if (!subject || conversationIds.length === 0) return /* @__PURE__ */ new Map();
-  const query = db.select({
-    archivedAt: juniorConversationParticipants.archivedAt,
-    rootConversationId: juniorConversationParticipants.rootConversationId
-  }).from(juniorConversationParticipants);
-  const rows = "userId" in subject ? await query.where(
-    and(
-      eq(juniorConversationParticipants.userId, subject.userId),
-      inArray(juniorConversationParticipants.rootConversationId, [
-        ...conversationIds
-      ]),
-      isNotNull(juniorConversationParticipants.archivedAt)
-    )
-  ) : await query.innerJoin(
-    juniorUsers,
-    eq(juniorUsers.id, juniorConversationParticipants.userId)
-  ).where(
-    and(
-      eq(juniorUsers.primaryEmailNormalized, subject.email),
-      inArray(juniorConversationParticipants.rootConversationId, [
-        ...conversationIds
-      ]),
-      isNotNull(juniorConversationParticipants.archivedAt)
-    )
-  );
-  return new Map(
-    rows.flatMap(
-      (row) => row.archivedAt ? [[row.rootConversationId, row.archivedAt.getTime()]] : []
-    )
-  );
-}
-async function conversationIdsWithParticipantUser(db, conversationIds, userId) {
-  if (conversationIds.length === 0) {
-    return /* @__PURE__ */ new Set();
-  }
-  const rows = await db.select({
-    rootConversationId: juniorConversationParticipants.rootConversationId
-  }).from(juniorConversationParticipants).where(
-    and(
-      eq(juniorConversationParticipants.userId, userId),
-      inArray(juniorConversationParticipants.rootConversationId, [
-        ...conversationIds
-      ])
-    )
-  );
-  return new Set(rows.map((row) => row.rootConversationId));
-}
-
-// src/api/conversations/access.ts
-var rootConversation = alias(juniorConversations, "access_root_conversation");
-var rootDestination = alias(juniorDestinations, "access_root_destination");
-var rootIdentity = alias(juniorIdentities, "access_root_identity");
-async function readConversationAccessFromSql(db, conversationIds, viewer) {
-  if (conversationIds.length === 0) return /* @__PURE__ */ new Map();
-  const normalizedViewerEmail = viewer?.email.trim().toLowerCase() || void 0;
-  const rows = await db.select({
-    conversationId: juniorConversations.conversationId,
-    parentConversationId: juniorConversations.parentConversationId,
-    storedRootConversationId: juniorConversations.rootConversationId,
-    rootConversationId: rootConversation.conversationId,
-    rootParentConversationId: rootConversation.parentConversationId,
-    rootRootConversationId: rootConversation.rootConversationId,
-    visibility: rootDestination.visibility,
-    rootEmailNormalized: rootIdentity.emailNormalized,
-    rootEmailVerified: rootIdentity.emailVerified,
-    rootUserId: rootIdentity.userId
-  }).from(juniorConversations).leftJoin(
-    rootConversation,
-    eq2(
-      rootConversation.conversationId,
-      juniorConversations.rootConversationId
-    )
-  ).leftJoin(
-    rootDestination,
-    eq2(rootDestination.id, rootConversation.destinationId)
-  ).leftJoin(
-    rootIdentity,
-    eq2(rootIdentity.id, rootConversation.actorIdentityId)
-  ).where(inArray2(juniorConversations.conversationId, [...conversationIds]));
-  const membershipConversationIds = /* @__PURE__ */ new Set();
-  for (const row of rows) {
-    membershipConversationIds.add(row.conversationId);
-    if (row.storedRootConversationId) {
-      membershipConversationIds.add(row.storedRootConversationId);
-    }
-  }
-  const participantRootIds = viewer !== void 0 ? await conversationIdsWithParticipantUser(
-    db,
-    [...membershipConversationIds],
-    viewer.id
-  ) : /* @__PURE__ */ new Set();
-  return new Map(
-    rows.map((row) => {
-      const hasValidRoot = row.rootConversationId !== null && row.rootConversationId === row.storedRootConversationId && row.rootRootConversationId === row.rootConversationId && row.rootParentConversationId === null && (row.parentConversationId !== null || row.storedRootConversationId === row.conversationId);
-      const validRootConversationId = hasValidRoot ? row.rootConversationId ?? void 0 : void 0;
-      const visibility = validRootConversationId === void 0 ? null : row.visibility;
-      const isRootActor = validRootConversationId !== void 0 && viewer !== void 0 && (row.rootUserId === viewer.id || normalizedViewerEmail !== void 0 && row.rootEmailVerified === true && row.rootEmailNormalized === normalizedViewerEmail);
-      const isMaterializedParticipant = participantRootIds.has(row.conversationId) || validRootConversationId !== void 0 && participantRootIds.has(validRootConversationId);
-      const isParticipant = isRootActor || isMaterializedParticipant;
-      const canViewPrivateContent = isParticipant || validRootConversationId !== void 0 && canExposeConversationPayload({
-        visibility: visibility ?? void 0
-      });
-      return [
-        row.conversationId,
-        {
-          canViewPrivateContent,
-          isParticipant,
-          visibility
-        }
-      ];
-    })
-  );
-}
-
-// 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();
-  if (!trimmed) return void 0;
-  if (type === "public_channel" || type === "private_channel" || type === "private_channel_or_group_dm") {
-    return trimmed.startsWith("#") ? trimmed : `#${trimmed}`;
-  }
-  return trimmed;
-}
-function typeFromSlackChannelType(channelType) {
-  if (channelType === "channel") return "public_channel";
-  if (channelType === "group") return "private_channel";
-  if (channelType === "mpim") return "group_dm";
-  if (channelType === "im") return "direct_message";
-  return void 0;
-}
-function typeFromChannelId(channelId, channelName) {
-  const normalized = normalizeSlackConversationId(channelId);
-  if (!normalized) return void 0;
-  if (normalized.startsWith("C")) return "public_channel";
-  if (normalized.startsWith("D")) return "direct_message";
-  if (normalized.startsWith("G")) {
-    return channelName?.trim().startsWith("mpdm-") ? "group_dm" : "private_channel_or_group_dm";
-  }
-  return void 0;
-}
-function toSlackEventChannelType(channelType) {
-  if (channelType === "channel" || channelType === "group" || channelType === "mpim" || channelType === "im") {
-    return channelType;
-  }
-  return void 0;
-}
-function conversationVisibilityFromSlackChannelType(channelType) {
-  if (!channelType) return void 0;
-  return channelType === "channel" ? "public" : "private";
-}
-function resolveSlackChannelTypeFromMessage(message) {
-  const raw = message.raw;
-  if (!raw || typeof raw !== "object") {
-    return void 0;
-  }
-  const channelType = raw.channel_type;
-  return typeof channelType === "string" ? toSlackEventChannelType(channelType.trim()) : void 0;
-}
-function resolveSlackConversationContext(input) {
-  const type = typeFromSlackChannelType(input.channelType) ?? typeFromChannelId(input.channelId, input.channelName);
-  if (!type) return void 0;
-  const name = normalizeConversationName(type, input.channelName);
-  const visibility = conversationVisibilityFromSlackChannelType(
-    input.channelType
-  );
-  return {
-    type,
-    ...name ? { name } : void 0,
-    ...visibility ? { visibility } : void 0
-  };
-}
-function resolveSlackConversationContextFromThreadId(input) {
-  const slackThread = parseSlackThreadId(input.threadId);
-  const context = resolveSlackConversationContext({
-    channelId: slackThread?.channelId,
-    channelName: input.channelName
-  });
-  if (!context || !input.visibility) {
-    return context;
-  }
-  return {
-    ...context,
-    type: input.visibility === "private" && context.type === "public_channel" ? "private_channel" : context.type,
-    visibility: input.visibility
-  };
-}
-function formatSlackConversationTypeLabel(type) {
-  if (type === "public_channel") return "Public Channel";
-  if (type === "private_channel") return "Private Channel";
-  if (type === "group_dm") return "Group DM";
-  if (type === "direct_message") return "Direct Message";
-  return "Private Channel or Group DM";
-}
-function formatSlackConversationRedactedLabel(context) {
-  if (!context) return void 0;
-  return formatSlackConversationTypeLabel(context.type);
-}
-
-export {
-  readHealthReport,
-  GET,
-  createVercelAttachmentStorage,
-  lookupSlackUser,
-  conversationVisibilityFromSlackChannelType,
-  resolveSlackChannelTypeFromMessage,
-  resolveSlackConversationContext,
-  resolveSlackConversationContextFromThreadId,
-  formatSlackConversationRedactedLabel,
-  createApiTurnCancellation,
-  getAuthPausedApiTurnId,
-  apiTurnIdForMessage,
-  webActorFromEmail,
-  recordApiConversationActivity,
-  createAndEnqueueApiConversation,
-  appendAndEnqueueApiConversationMessage,
-  createApiTurnWorker,
-  routeApiTurnWork,
-  conversationHasParticipantUser,
-  conversationHasParticipantEmail,
-  conversationArchivedForUser,
-  conversationNotArchivedForUser,
-  conversationArchivedForEmail,
-  conversationNotArchivedForEmail,
-  viewerConversationMembership,
-  conversationArchiveTimes,
-  readConversationAccessFromSql
-};