@sentry/junior 0.147.0 → 0.148.0

package/dist/chunk-ZPL2RR7F.js

@@ -0,0 +1,798 @@
+import {
+  appendAndEnqueueInboundMessage
+} from "./chunk-HLPLT3NY.js";
+import {
+  buildConversationContext,
+  buildDeliveredTurnStatePatch,
+  finalizeFailedTurnReplyWithEvent,
+  getTurnUserMessage,
+  markConversationMessage,
+  normalizeConversationText,
+  processPluginTask,
+  recordDeliveredAssistantMessage,
+  scheduleSessionCompletedPluginTasks,
+  upsertConversationMessage
+} from "./chunk-RRJV5UR5.js";
+import {
+  ConversationTurnLifecycleService,
+  coerceThreadConversationState,
+  getPersistedSandboxState,
+  getPersistedThreadState,
+  persistThreadStateById
+} from "./chunk-IL4EDBMV.js";
+import {
+  healthReportSchema
+} from "./chunk-UTL3MHPC.js";
+import {
+  parseSlackThreadId
+} from "./chunk-WOONT5ZP.js";
+import {
+  TurnInputCommitLostError,
+  buildDeterministicTurnId,
+  getAssistantReplyText,
+  getConversationTurnBoundaryError,
+  getTurnRecord,
+  hydrateConversationMessages,
+  isTurnInputCommitLostError,
+  listTurnSummaries,
+  loadProjection,
+  markTurnFailed,
+  persistConversationMessages,
+  persistWithRetry,
+  saveTurnCheckpoint,
+  startActiveTurn
+} from "./chunk-VCYSOXON.js";
+import {
+  normalizeSlackConversationId
+} from "./chunk-V2FXMOEA.js";
+import {
+  getConversationEventStore,
+  getConversationStore
+} from "./chunk-VRHTNBA6.js";
+import {
+  credentialContextForActor
+} from "./chunk-RUIXF3YQ.js";
+import {
+  logException,
+  setTags,
+  withLogContext
+} from "./chunk-EAI67NTM.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/api-turns/work.ts
+import { createHash } from "crypto";
+import { z } from "zod";
+import {
+  createWebSource,
+  localDestinationSchema
+} 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 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 apiMessageId(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 webSourceForConversation(args) {
+  return createWebSource(
+    args.conversationId,
+    args.visibility === "private" ? "private" : "public"
+  );
+}
+function actorFromMetadata(metadata) {
+  return {
+    platform: "web",
+    userId: metadata.authorUserId,
+    email: normalizeEmail(metadata.authorEmail),
+    ...metadata.authorFullName ? { fullName: metadata.authorFullName } : {},
+    ...metadata.authorUserName ? { userName: metadata.authorUserName } : {}
+  };
+}
+function storedActorFromApi(actor) {
+  return {
+    ...actor.email ? { email: normalizeEmail(actor.email) } : {},
+    ...actor.fullName ? { fullName: actor.fullName } : {}
+  };
+}
+function webActorFromEmail(email, profile) {
+  const normalized = normalizeEmail(email);
+  return {
+    platform: "web",
+    userId: `dashboard:${stableHex(normalized)}`,
+    email: normalized,
+    ...profile?.fullName ? { fullName: profile.fullName } : {},
+    ...profile?.userName ? { userName: profile.userName } : {}
+  };
+}
+function actorFromStoredConversation(stored) {
+  const email = stored?.email?.trim().toLowerCase();
+  if (!email) {
+    return void 0;
+  }
+  return webActorFromEmail(
+    email,
+    stored?.fullName ? { fullName: stored.fullName } : 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 source = isNewRoot ? webSourceForConversation({ conversationId: args.conversationId }) : 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" } : {},
+    ...source ? { sessionSource: source } : {},
+    ...isNewRoot ? { visibility: "public" } : {}
+  });
+  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
+    },
+    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 = apiMessageId({
+    conversationId: input.conversationId,
+    idempotencyKey: input.idempotencyKey
+  });
+  const destination = await recordApiConversationActivity({
+    actor: input.actor,
+    conversationId: input.conversationId,
+    conversationStore: options.conversationStore,
+    nowMs
+  });
+  const result = await appendAndEnqueueInboundMessage({
+    message: buildApiTurnInboundMessage({
+      actor: input.actor,
+      conversationId: input.conversationId,
+      destination,
+      message: text,
+      messageId,
+      nowMs
+    }),
+    conversationStore: options.conversationStore,
+    nowMs,
+    queue: options.queue,
+    state: options.state
+  });
+  return {
+    conversationId: input.conversationId,
+    messageId,
+    status: result.status === "duplicate" ? "duplicate" : "accepted"
+  };
+}
+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("Conversation mailbox mixes web turns and other input");
+  }
+  return parsed.map((entry) => {
+    if (!entry.metadata.success) {
+      throw new Error("API turn mailbox metadata failed validation");
+    }
+    return { message: entry.message, metadata: entry.metadata.data };
+  });
+}
+async function resolveApiTurnWork(context) {
+  const batch = parseApiTurnMessages(context.attempt.messages);
+  if (batch.length > 0) {
+    return { kind: "mailbox", batch };
+  }
+  if (context.attempt.messages.length > 0) {
+    return void 0;
+  }
+  const summaries = await listTurnSummaries(context.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 ${context.conversationId} has multiple active web turns`
+    );
+  }
+  const turnId = active[0]?.turnId;
+  if (!turnId) {
+    return void 0;
+  }
+  const record = await getTurnRecord(context.conversationId, turnId);
+  if (!record || record.surface !== "api" || Boolean(record.dispatchId) || record.state !== "paused" && record.state !== "running") {
+    return void 0;
+  }
+  return { kind: "resume", turnId };
+}
+async function isApiTurnWork(context) {
+  return await resolveApiTurnWork(context) !== void 0;
+}
+function captureApiBoundaryFailure(args) {
+  const eventId = logException(args.error, `api.turn.${args.failureCode}`, {
+    conversationId: args.conversationId,
+    ...args.runId ? { runId: args.runId } : {},
+    turnId: args.turnId
+  });
+  return typeof eventId === "string" ? eventId : void 0;
+}
+function createApiTurnWorker(options) {
+  return async (context) => {
+    const resolved = await resolveApiTurnWork(context);
+    if (!resolved) {
+      throw new Error(
+        `API turn worker received non-API work for ${context.conversationId}`
+      );
+    }
+    if (context.publishExternally) {
+      throw new Error(
+        `API turn work must not publish externally for ${context.conversationId}`
+      );
+    }
+    const lifecycle = options.turnLifecycle ?? new ConversationTurnLifecycleService(getConversationEventStore());
+    const isResume = resolved.kind === "resume";
+    let actor;
+    let text;
+    let turnId;
+    let userMessageId;
+    let startedAtMs;
+    let inputMessageIds;
+    const storedConversation = await getConversationStore().get({
+      conversationId: context.conversationId
+    });
+    if (resolved.kind === "mailbox") {
+      const first = resolved.batch[0];
+      text = resolved.batch.map((entry) => entry.message.input.text.trim()).filter(Boolean).join("\n\n");
+      actor = actorFromMetadata(first.metadata);
+      turnId = apiTurnIdForMessage(first.metadata.messageId);
+      userMessageId = first.metadata.messageId;
+      startedAtMs = first.message.createdAtMs;
+      inputMessageIds = resolved.batch.map((entry) => entry.metadata.messageId);
+    } else {
+      turnId = resolved.turnId;
+      const resumedActor = actorFromStoredConversation(
+        storedConversation?.actor
+      );
+      if (!resumedActor) {
+        throw new Error(
+          `API turn resume missing actor for ${context.conversationId}`
+        );
+      }
+      actor = resumedActor;
+      text = "";
+      userMessageId = "";
+      startedAtMs = Date.now();
+      inputMessageIds = [];
+    }
+    const destination = resolveApiTurnDestination({
+      conversationId: context.conversationId,
+      existing: context.destination ?? (resolved.kind === "mailbox" ? resolved.batch[0]?.message.destination : void 0) ?? storedConversation?.destination
+    });
+    const source = webSourceForConversation({
+      conversationId: context.conversationId,
+      visibility: storedConversation?.visibility
+    });
+    return await withLogContext(
+      {
+        conversationId: context.conversationId,
+        platform: "web",
+        userId: actor.userId,
+        ...actor.userName ? { userName: actor.userName } : {}
+      },
+      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 API turn inbox ack for ${context.conversationId}`
+            );
+          }
+          acknowledged = true;
+        };
+        const persisted = await getPersistedThreadState(context.conversationId);
+        const conversation = coerceThreadConversationState(persisted);
+        await hydrateConversationMessages({
+          conversation,
+          conversationId: context.conversationId
+        });
+        let sandboxRef = getPersistedSandboxState(persisted);
+        const initialSandboxRef = sandboxRef;
+        if (isResume) {
+          const userMessage = getTurnUserMessage(conversation, turnId);
+          if (!userMessage) {
+            throw new Error(
+              `Unable to locate the persisted user message for API turn "${turnId}"`
+            );
+          }
+          userMessageId = userMessage.id;
+          text = userMessage.text;
+          startedAtMs = userMessage.createdAtMs;
+          inputMessageIds = [userMessageId];
+        } else {
+          upsertConversationMessage(conversation, {
+            id: userMessageId,
+            role: "user",
+            text: normalizeConversationText(text),
+            createdAtMs: startedAtMs,
+            author: {
+              ...actor.fullName ? { fullName: actor.fullName } : {},
+              userId: actor.userId,
+              ...actor.userName ? { userName: actor.userName } : {}
+            },
+            meta: {
+              explicitMention: true,
+              replied: false
+            }
+          });
+          await persistConversationMessages({
+            conversation,
+            conversationId: context.conversationId
+          });
+          await lifecycle.start({
+            conversationId: context.conversationId,
+            createdAtMs: Date.now(),
+            inputMessageIds,
+            surface: "api",
+            turnId
+          });
+          startActiveTurn({
+            conversation,
+            nextTurnId: turnId
+          });
+        }
+        let currentRunId;
+        let assistantMessageDelivered = false;
+        let failureCode = "persistence_failed";
+        let modelFailureEventId;
+        let modelFailureCaptureAttempted = false;
+        let reply;
+        const deliverAssistantMessage = async (value) => {
+          const replyText = typeof value === "string" ? value : getAssistantReplyText(value);
+          if (!replyText?.trim()) {
+            return;
+          }
+          failureCode = "delivery_failed";
+          assistantMessageDelivered = true;
+          recordDeliveredAssistantMessage({
+            conversation,
+            sessionId: turnId,
+            text: replyText,
+            userMessageId
+          });
+          try {
+            await persistWithRetry(
+              () => persistConversationMessages({
+                conversation,
+                conversationId: context.conversationId
+              })
+            );
+          } catch (error) {
+            logException(
+              new Error("Accepted assistant message persistence failed"),
+              "api.assistant.message_post_delivery_persist.failed",
+              {
+                "error.type": error instanceof Error ? error.name : typeof error
+              }
+            );
+          }
+          failureCode = "agent_run_failed";
+        };
+        try {
+          await persistThreadStateById(context.conversationId, {
+            conversation
+          });
+          const piMessages = await loadProjection({
+            conversationId: context.conversationId
+          });
+          failureCode = "agent_run_failed";
+          currentRunId = `api-run:${stableHex(turnId, String(startedAtMs))}`;
+          setTags({ runId: currentRunId });
+          const outcome = await options.agentRunner.run({
+            conversationId: context.conversationId,
+            turnId,
+            runId: currentRunId,
+            input: {
+              messageText: text,
+              conversationContext: buildConversationContext(conversation, {
+                excludeMessageId: userMessageId
+              }),
+              piMessages
+            },
+            routing: {
+              actor,
+              credentialContext: credentialContextForActor(actor),
+              destination,
+              publishExternally: false,
+              source,
+              surface: "api"
+            },
+            policy: {
+              disabledFeatures: ["interactive-auth"]
+            },
+            state: {
+              pendingAuth: conversation.processing.pendingAuth,
+              sandboxRef
+            },
+            delivery: deliverAssistantMessage,
+            durability: {
+              onInputCommitted: acknowledge,
+              shouldYield: context.shouldYield,
+              onSandboxRefChanged: async (nextSandboxRef) => {
+                sandboxRef = nextSandboxRef;
+                await persistThreadStateById(context.conversationId, {
+                  conversation,
+                  sandboxRef
+                });
+              }
+            }
+          });
+          if (outcome.status === "suspended") {
+            return { status: "yielded" };
+          }
+          if (outcome.status !== "completed") {
+            throw new Error(`API agent run ended with ${outcome.status}`);
+          }
+          reply = outcome.result;
+          modelFailureCaptureAttempted = reply.diagnostics.outcome !== "success";
+          const finalized = finalizeFailedTurnReplyWithEvent({
+            reply,
+            logException
+          });
+          reply = finalized.reply;
+          modelFailureEventId = finalized.eventId;
+          if (reply.diagnostics.outcome !== "success") {
+            await deliverAssistantMessage(reply.text);
+          }
+          const completedState = buildDeliveredTurnStatePatch({
+            conversation,
+            reply,
+            sessionId: turnId,
+            userMessageId
+          });
+          await persistThreadStateById(context.conversationId, {
+            conversation: completedState.conversation,
+            sandboxRef: reply.sandboxRef ?? sandboxRef
+          });
+          if (reply.piMessages?.length) {
+            const latest = await getTurnRecord(context.conversationId, turnId);
+            await saveTurnCheckpoint({
+              mode: "completed",
+              conversationId: context.conversationId,
+              turnId,
+              sliceId: latest?.sliceId ?? 1,
+              messages: reply.piMessages,
+              durationMs: reply.diagnostics.durationMs,
+              usage: reply.diagnostics.usage,
+              destination,
+              publishExternally: false,
+              source,
+              actor,
+              surface: "api"
+            });
+          }
+          if (reply.diagnostics.outcome === "success") {
+            await lifecycle.complete({
+              conversationId: context.conversationId,
+              createdAtMs: Date.now(),
+              outcome: assistantMessageDelivered ? "success" : "no_reply",
+              turnId
+            });
+            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
+              });
+            }
+          } else {
+            await lifecycle.fail({
+              conversationId: context.conversationId,
+              createdAtMs: Date.now(),
+              ...modelFailureEventId ? { eventId: modelFailureEventId } : {},
+              failureCode: "model_execution_failed",
+              turnId
+            });
+          }
+          await acknowledge();
+          return { status: "completed" };
+        } catch (error) {
+          const cause = getConversationTurnBoundaryError(error)?.cause ?? error;
+          if (isTurnInputCommitLostError(error) || isTurnInputCommitLostError(cause)) {
+            return { status: "lost_lease" };
+          }
+          if (!context.attempt.isFinalAttempt) {
+            throw error;
+          }
+          const failureEventId = modelFailureCaptureAttempted && failureCode === "agent_run_failed" ? modelFailureEventId : captureApiBoundaryFailure({
+            conversationId: context.conversationId,
+            error,
+            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 } : {},
+            failureCode,
+            turnId
+          });
+          await acknowledge();
+          return { status: "completed" };
+        }
+      }
+    );
+  };
+}
+function routeApiTurnWork(options) {
+  return async (context) => {
+    return await isApiTurnWork(context) ? await options.apiTurnWorker(context) : await options.fallbackWorker(context);
+  };
+}
+
+// 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 } : {},
+    ...visibility ? { visibility } : {}
+  };
+}
+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,
+  conversationVisibilityFromSlackChannelType,
+  resolveSlackChannelTypeFromMessage,
+  resolveSlackConversationContext,
+  resolveSlackConversationContextFromThreadId,
+  formatSlackConversationRedactedLabel,
+  webActorFromEmail,
+  createAndEnqueueApiConversation,
+  appendAndEnqueueApiConversationMessage,
+  createApiTurnWorker,
+  routeApiTurnWork
+};