@sentry/junior 0.65.0 → 0.65.1

package/dist/{chunk-7KZXQNA6.js → chunk-X2HJLKQT.js}

@@ -4,14 +4,16 @@ import {
   botConfig,
   getChatConfig,
   getConnectedStateContext,
+  getSlackBotToken,
   getStateAdapter,
+  parseSlackThreadId,
   sandboxSkillDir
-} from "./chunk-OMQ5X5QH.js";
+} from "./chunk-ZOV3XJAH.js";
 import {
   isRecord,
   logInfo,
   logWarn
-} from "./chunk-EDHJIYHS.js";
+} from "./chunk-657CJCUO.js";
 import {
   sentry_exports
 } from "./chunk-Z3YD6NHK.js";
@@ -656,7 +658,9 @@ function buildWorldSection() {
 }
 function buildRuntimeSection(params) {
   const lines = [
-    params.conversationId ? `- gen_ai.conversation.id: ${escapeXml(params.conversationId)}` : ""
+    params.conversationId ? `- gen_ai.conversation.id: ${escapeXml(params.conversationId)}` : "",
+    params.slackConversation?.type ? `- slack.conversation.type: ${escapeXml(params.slackConversation.type)}` : "",
+    params.slackConversation?.name ? `- slack.conversation.name: ${escapeXml(params.slackConversation.name)}` : ""
   ].filter(Boolean);
   if (lines.length === 0) {
     return null;
@@ -1022,20 +1026,20 @@ function commitEntries(existingMessages, nextMessages, sessionId, entries) {
   return [resetEntry(nextMessages, nextSessionId(entries))];
 }
 function redisStore(redisStateAdapter) {
-  const client = redisStateAdapter.getClient();
+  const client2 = redisStateAdapter.getClient();
   return {
     async append({ entries, scope, ttlMs }) {
       const listKey = key(scope);
       if (entries.length > 0) {
-        await client.rPush(
+        await client2.rPush(
           listKey,
           entries.map((entry) => JSON.stringify(entry))
         );
       }
-      await client.pExpire(listKey, Math.max(1, ttlMs));
+      await client2.pExpire(listKey, Math.max(1, ttlMs));
     },
     async read(scope) {
-      const values = await client.lRange(key(scope), 0, -1);
+      const values = await client2.lRange(key(scope), 0, -1);
       return values.map(decode);
     }
   };
@@ -1280,7 +1284,7 @@ function parseAgentTurnSessionFields(parsed) {
         (value) => typeof value === "string"
       )
     } : {},
-    ...parsed.resumeReason === "timeout" || parsed.resumeReason === "auth" ? { resumeReason: parsed.resumeReason } : {},
+    ...parsed.resumeReason === "timeout" || parsed.resumeReason === "auth" || parsed.resumeReason === "yield" ? { resumeReason: parsed.resumeReason } : {},
     ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {},
     ...typeof parsed.resumedFromSliceId === "number" ? { resumedFromSliceId: parsed.resumedFromSliceId } : {},
     ...typeof parsed.traceId === "string" ? { traceId: parsed.traceId } : {}
@@ -1638,8 +1642,8 @@ function buildSentryWebBaseUrl(dsn) {
   return `${dsn.protocol}://${dsn.host}${port}${path2}`;
 }
 function buildSentryConversationUrl(conversationId) {
-  const client = sentry_exports.getClient();
-  const dsn = client?.getDsn();
+  const client2 = sentry_exports.getClient();
+  const dsn = client2?.getDsn();
   if (!dsn?.host || !dsn.projectId) {
     return void 0;
   }
@@ -1657,8 +1661,8 @@ function buildSentryConversationUrl(conversationId) {
   return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path2}`;
 }
 function buildSentryTraceUrl(traceId) {
-  const client = sentry_exports.getClient();
-  const dsn = client?.getDsn();
+  const client2 = sentry_exports.getClient();
+  const dsn = client2?.getDsn();
   if (!dsn?.host || !dsn.projectId) {
     return void 0;
   }
@@ -1676,7 +1680,354 @@ function buildSentryTraceUrl(traceId) {
   return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path2}`;
 }
 
+// src/chat/slack/client.ts
+import { WebClient } from "@slack/web-api";
+var SlackActionError = class extends Error {
+  code;
+  apiError;
+  needed;
+  provided;
+  statusCode;
+  requestId;
+  errorData;
+  retryAfterSeconds;
+  detail;
+  detailLine;
+  detailRule;
+  constructor(message, code, options = {}) {
+    super(message);
+    this.name = "SlackActionError";
+    this.code = code;
+    this.apiError = options.apiError;
+    this.needed = options.needed;
+    this.provided = options.provided;
+    this.statusCode = options.statusCode;
+    this.requestId = options.requestId;
+    this.errorData = options.errorData;
+    this.retryAfterSeconds = options.retryAfterSeconds;
+    this.detail = options.detail;
+    this.detailLine = options.detailLine;
+    this.detailRule = options.detailRule;
+  }
+};
+function serializeSlackErrorData(data) {
+  if (!data || typeof data !== "object") {
+    return void 0;
+  }
+  const filtered = Object.fromEntries(
+    Object.entries(data).filter(
+      ([key2]) => key2 !== "error"
+    )
+  );
+  if (Object.keys(filtered).length === 0) {
+    return void 0;
+  }
+  try {
+    const serialized = JSON.stringify(filtered);
+    return serialized.length <= 600 ? serialized : `${serialized.slice(0, 597)}...`;
+  } catch {
+    return void 0;
+  }
+}
+function getHeaderString(headers, name) {
+  if (!headers || typeof headers !== "object") {
+    return void 0;
+  }
+  const key2 = name.toLowerCase();
+  const entries = headers;
+  for (const [entryKey, value] of Object.entries(entries)) {
+    if (entryKey.toLowerCase() !== key2) continue;
+    if (typeof value === "string") return value;
+    if (Array.isArray(value)) {
+      const first = value.find((entry) => typeof entry === "string");
+      return typeof first === "string" ? first : void 0;
+    }
+  }
+  return void 0;
+}
+function parseSlackCanvasDetail(detail) {
+  if (typeof detail !== "string") {
+    return {};
+  }
+  const trimmed = detail.trim();
+  if (!trimmed) {
+    return {};
+  }
+  const parsed = {
+    detail: trimmed
+  };
+  const lineMatch = trimmed.match(/line\s+(\d+):/i);
+  if (lineMatch) {
+    const line = Number.parseInt(lineMatch[1] ?? "", 10);
+    if (Number.isFinite(line)) {
+      parsed.detailLine = line;
+    }
+  }
+  if (/unsupported heading depth/i.test(trimmed)) {
+    parsed.detailRule = "unsupported_heading_depth";
+  }
+  return parsed;
+}
+var client = null;
+function normalizeSlackConversationId(channelId) {
+  if (!channelId) return void 0;
+  const trimmed = channelId.trim();
+  if (!trimmed) return void 0;
+  if (!trimmed.startsWith("slack:")) {
+    return trimmed;
+  }
+  const parts = trimmed.split(":");
+  return parts[1]?.trim() || void 0;
+}
+function getClient2() {
+  if (client) return client;
+  const token = getSlackBotToken();
+  if (!token) {
+    throw new SlackActionError(
+      "SLACK_BOT_TOKEN (or SLACK_BOT_USER_TOKEN) is required for Slack canvas/list actions in this service",
+      "missing_token"
+    );
+  }
+  client = new WebClient(token);
+  return client;
+}
+function mapSlackError(error) {
+  if (error instanceof SlackActionError) {
+    return error;
+  }
+  const candidate = error;
+  const apiError = candidate.data?.error;
+  const message = candidate.message ?? "Slack action failed";
+  const baseOptions = {
+    apiError,
+    statusCode: candidate.statusCode,
+    requestId: getHeaderString(candidate.headers, "x-slack-req-id"),
+    errorData: serializeSlackErrorData(candidate.data),
+    ...parseSlackCanvasDetail(candidate.data?.detail)
+  };
+  if (apiError === "missing_scope") {
+    return new SlackActionError(message, "missing_scope", {
+      ...baseOptions,
+      needed: candidate.data?.needed,
+      provided: candidate.data?.provided
+    });
+  }
+  if (apiError === "not_in_channel") {
+    return new SlackActionError(message, "not_in_channel", baseOptions);
+  }
+  if (apiError === "already_reacted") {
+    return new SlackActionError(message, "already_reacted", baseOptions);
+  }
+  if (apiError === "no_reaction") {
+    return new SlackActionError(message, "no_reaction", baseOptions);
+  }
+  if (apiError === "invalid_arguments") {
+    return new SlackActionError(message, "invalid_arguments", baseOptions);
+  }
+  if (apiError === "invalid_cursor") {
+    return new SlackActionError(message, "invalid_arguments", baseOptions);
+  }
+  if (apiError === "invalid_name") {
+    return new SlackActionError(message, "invalid_arguments", baseOptions);
+  }
+  if (apiError === "not_found" || apiError === "channel_not_found" || apiError === "message_not_found") {
+    return new SlackActionError(message, "not_found", baseOptions);
+  }
+  if (apiError === "feature_not_enabled" || apiError === "not_allowed_token_type") {
+    return new SlackActionError(message, "feature_unavailable", baseOptions);
+  }
+  if (apiError === "canvas_creation_failed") {
+    return new SlackActionError(message, "canvas_creation_failed", baseOptions);
+  }
+  if (apiError === "canvas_editing_failed") {
+    return new SlackActionError(message, "canvas_editing_failed", baseOptions);
+  }
+  if (candidate.code === "slack_webapi_rate_limited_error" || candidate.statusCode === 429) {
+    return new SlackActionError(message, "rate_limited", {
+      ...baseOptions,
+      retryAfterSeconds: candidate.retryAfter
+    });
+  }
+  return new SlackActionError(message, "internal_error", baseOptions);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withSlackRetries(task, maxAttempts = 3, context = {}) {
+  let attempt = 0;
+  while (attempt < maxAttempts) {
+    attempt += 1;
+    try {
+      return await task();
+    } catch (error) {
+      const mapped = mapSlackError(error);
+      const isRetryable = mapped.code === "rate_limited";
+      const baseLogAttributes = {
+        "app.slack.action": context.action ?? "unknown",
+        "app.slack.error_code": mapped.code,
+        ...mapped.apiError ? { "app.slack.api_error": mapped.apiError } : {},
+        ...mapped.detail ? { "app.slack.detail": mapped.detail } : {},
+        ...mapped.detailLine !== void 0 ? { "app.slack.detail_line": mapped.detailLine } : {},
+        ...mapped.detailRule ? { "app.slack.detail_rule": mapped.detailRule } : {},
+        ...mapped.requestId ? { "app.slack.request_id": mapped.requestId } : {},
+        ...mapped.statusCode !== void 0 ? { "http.response.status_code": mapped.statusCode } : {},
+        ...context.attributes ?? {}
+      };
+      if (!isRetryable || attempt >= maxAttempts) {
+        logWarn(
+          "slack_action_failed",
+          {},
+          {
+            ...baseLogAttributes,
+            ...mapped.errorData ? { "app.slack.error_data": mapped.errorData } : {}
+          },
+          "Slack action failed"
+        );
+        throw mapped;
+      }
+      logWarn(
+        "slack_action_retrying",
+        {},
+        {
+          ...baseLogAttributes,
+          "app.slack.retry_attempt": attempt
+        },
+        "Retrying Slack action after transient failure"
+      );
+      const retryAfterMs = mapped.code === "rate_limited" && mapped.retryAfterSeconds && mapped.retryAfterSeconds > 0 ? mapped.retryAfterSeconds * 1e3 : void 0;
+      const backoffMs = Math.min(2e3, 250 * 2 ** (attempt - 1));
+      await sleep(retryAfterMs ?? backoffMs);
+    }
+  }
+  throw new SlackActionError(
+    "Slack action exhausted retries",
+    "internal_error"
+  );
+}
+function getSlackClient() {
+  return getClient2();
+}
+function isDmChannel(channelId) {
+  const normalized = normalizeSlackConversationId(channelId);
+  return Boolean(normalized && normalized.startsWith("D"));
+}
+function isConversationScopedChannel(channelId) {
+  const normalized = normalizeSlackConversationId(channelId);
+  if (!normalized) return false;
+  return normalized.startsWith("C") || normalized.startsWith("G") || normalized.startsWith("D");
+}
+function isConversationChannel(channelId) {
+  const normalized = normalizeSlackConversationId(channelId);
+  if (!normalized) return false;
+  return normalized.startsWith("C") || normalized.startsWith("G");
+}
+async function getFilePermalink(fileId) {
+  const client2 = getClient2();
+  const response = await withSlackRetries(
+    () => client2.files.info({
+      file: fileId
+    })
+  );
+  return response.file?.permalink;
+}
+async function downloadPrivateSlackFile(url) {
+  const token = getSlackBotToken();
+  if (!token) {
+    throw new SlackActionError(
+      "SLACK_BOT_TOKEN (or SLACK_BOT_USER_TOKEN) is required for Slack file downloads in this service",
+      "missing_token"
+    );
+  }
+  const response = await fetch(url, {
+    headers: {
+      Authorization: `Bearer ${token}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Slack file download failed: ${response.status}`);
+  }
+  return Buffer.from(await response.arrayBuffer());
+}
+
+// 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 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);
+  return {
+    type,
+    ...name ? { name } : {}
+  };
+}
+function resolveSlackConversationContextFromThreadId(input) {
+  const slackThread = parseSlackThreadId(input.threadId);
+  return resolveSlackConversationContext({
+    channelId: slackThread?.channelId,
+    channelName: input.channelName
+  });
+}
+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 {
+  SlackActionError,
+  getHeaderString,
+  normalizeSlackConversationId,
+  withSlackRetries,
+  getSlackClient,
+  isDmChannel,
+  isConversationScopedChannel,
+  isConversationChannel,
+  getFilePermalink,
+  downloadPrivateSlackFile,
   GET,
   TURN_CONTEXT_TAG,
   getInterruptionMarker,
@@ -1702,5 +2053,9 @@ export {
   abandonAgentTurnSessionRecord,
   failAgentTurnSessionRecord,
   buildSentryConversationUrl,
-  buildSentryTraceUrl
+  buildSentryTraceUrl,
+  resolveSlackChannelTypeFromMessage,
+  resolveSlackConversationContext,
+  resolveSlackConversationContextFromThreadId,
+  formatSlackConversationRedactedLabel
 };

package/dist/{chunk-OMQ5X5QH.js → chunk-ZOV3XJAH.js}

@@ -6,7 +6,7 @@ import {
   setSpanAttributes,
   toOptionalString,
   withSpan
-} from "./chunk-EDHJIYHS.js";
+} from "./chunk-657CJCUO.js";
 
 // src/chat/slack/context.ts
 function toTrimmedSlackString(value) {
@@ -499,7 +499,7 @@ async function completeObject(params) {
 // src/chat/config.ts
 var MIN_AGENT_TURN_TIMEOUT_MS = 10 * 1e3;
 var DEFAULT_AGENT_TURN_TIMEOUT_MS = 12 * 60 * 1e3;
-var DEFAULT_FUNCTION_MAX_DURATION_SECONDS = 800;
+var DEFAULT_FUNCTION_MAX_DURATION_SECONDS = 300;
 var ADVISOR_THINKING_LEVELS = [
   "minimal",
   "low",
@@ -938,6 +938,7 @@ export {
   resolveGatewayModel,
   completeText,
   completeObject,
+  FUNCTION_TIMEOUT_BUFFER_SECONDS,
   getChatConfig,
   botConfig,
   getSlackBotToken,

package/dist/cli/check.js

@@ -1,10 +1,15 @@
 import {
   parseSkillFile
-} from "../chunk-PYU2YB35.js";
+} from "../chunk-F57QSMOJ.js";
 import {
   parsePluginManifest
-} from "../chunk-EDHJIYHS.js";
+} from "../chunk-657CJCUO.js";
 import "../chunk-Z3YD6NHK.js";
+import {
+  JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,
+  JUNIOR_HEARTBEAT_ROUTE,
+  LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION
+} from "../chunk-6YY4Q3D4.js";
 import "../chunk-KVZL5NZS.js";
 import "../chunk-2KG3PWR4.js";
 
@@ -65,6 +70,13 @@ async function readJsonFile(targetPath) {
     return void 0;
   }
 }
+async function readTextFile(targetPath) {
+  try {
+    return await fs.readFile(targetPath, "utf8");
+  } catch {
+    return void 0;
+  }
+}
 async function readRootPackageJson(rootDir) {
   return await readJsonFile(path.join(rootDir, "package.json"));
 }
@@ -383,6 +395,94 @@ function reportSkillGroup(label, skillResults, io) {
 function reportAppSkills(skillResults, io) {
   reportSkillGroup("app skills", skillResults, io);
 }
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+async function hasJuniorDeploymentMarkers(rootDir, packages, nitroConfig) {
+  if (packages.some(
+    (declaredPackage) => declaredPackage.name === "@sentry/junior"
+  )) {
+    return true;
+  }
+  for (const source of [
+    nitroConfig,
+    await readTextFile(path.join(rootDir, "server.ts")),
+    await readTextFile(path.join(rootDir, "server.js"))
+  ]) {
+    if (source?.includes("@sentry/junior") || /\bjuniorNitro\s*\(/.test(source ?? "")) {
+      return true;
+    }
+  }
+  const appDir = path.resolve(rootDir, "app");
+  return await pathIsDirectory(appDir) && await hasJuniorAppMarkers(appDir);
+}
+async function validateDeploymentConfig(rootDir, packages) {
+  const errors = [];
+  const warnings = [];
+  let checked = false;
+  const nitroConfigPath = path.join(rootDir, "nitro.config.ts");
+  const nitroConfig = await readTextFile(nitroConfigPath);
+  const hasJuniorMarkers = await hasJuniorDeploymentMarkers(
+    rootDir,
+    packages,
+    nitroConfig
+  );
+  if (nitroConfig !== void 0 && hasJuniorMarkers) {
+    checked = true;
+    if (!/\bjuniorNitro\s*\(/.test(nitroConfig)) {
+      errors.push(
+        `${nitroConfigPath}: missing juniorNitro(). The Nitro module emits Junior's Vercel queue trigger and heartbeat cron into the deployed build output.`
+      );
+    }
+  }
+  const vercelConfigPath = path.join(rootDir, "vercel.json");
+  const vercelConfigText = await readTextFile(vercelConfigPath);
+  if (vercelConfigText === void 0) {
+    return { checked, errors, warnings };
+  }
+  const containsLegacyJuniorQueuePath = vercelConfigText.includes(
+    LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION
+  );
+  if (!hasJuniorMarkers && !containsLegacyJuniorQueuePath) {
+    return { checked, errors, warnings };
+  }
+  let vercelConfig;
+  try {
+    vercelConfig = JSON.parse(vercelConfigText);
+  } catch (error) {
+    errors.push(
+      `${vercelConfigPath}: invalid JSON (${error instanceof Error ? error.message : String(error)})`
+    );
+    return { checked, errors, warnings };
+  }
+  if (hasJuniorMarkers && vercelConfig.framework !== void 0 && vercelConfig.framework !== "nitro") {
+    checked = true;
+    errors.push(
+      `${vercelConfigPath}: framework must be "nitro" for Junior's Vercel deployment wiring.`
+    );
+  }
+  if (isRecord(vercelConfig.functions)) {
+    const legacyFunctionConfig = vercelConfig.functions[LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION];
+    if (legacyFunctionConfig !== void 0) {
+      checked = true;
+      errors.push(
+        `${vercelConfigPath}: functions.${LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION} targets a source file that Nitro does not deploy. Remove it; juniorNitro() emits the ${JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE} queue trigger through Nitro functionRules.`
+      );
+    }
+  }
+  if (hasJuniorMarkers && Array.isArray(vercelConfig.crons)) {
+    const hasHeartbeatCron = vercelConfig.crons.some(
+      (cron) => isRecord(cron) && cron.path === JUNIOR_HEARTBEAT_ROUTE
+    );
+    if (hasHeartbeatCron) {
+      checked = true;
+      warnings.push(
+        `${vercelConfigPath}: ${JUNIOR_HEARTBEAT_ROUTE} cron is now emitted by juniorNitro() into Nitro's Vercel Build Output config. Remove the root cron entry to avoid deployment drift.`
+      );
+    }
+  }
+  return { checked, errors, warnings };
+}
 async function validateAppSourceFiles(rootDir, registeredConfigKeys) {
   const errors = [];
   const warnings = [];
@@ -524,6 +624,12 @@ async function runCheck(rootDir = process.cwd(), io = DEFAULT_IO) {
   const pluginResults = [];
   const skillResultsByDir = /* @__PURE__ */ new Map();
   warnings.push(...packageWarnings);
+  const deploymentConfigResult = await validateDeploymentConfig(
+    resolvedRoot,
+    packages
+  );
+  warnings.push(...deploymentConfigResult.warnings);
+  errors.push(...deploymentConfigResult.errors);
   for (const { pluginDir, packageName } of pluginDirs) {
     const pluginNameMap = packageName ? duplicatePackagedPluginNames : duplicatePluginNames;
     const providerDomainMap = packageName ? duplicatePackagedProviderDomains : duplicateProviderDomains;
@@ -604,6 +710,13 @@ async function runCheck(rootDir = process.cwd(), io = DEFAULT_IO) {
     );
     io.info(formatHeading(appFileStatus, "app files"));
   }
+  if (deploymentConfigResult.checked) {
+    const deploymentConfigStatus = formatStatus(
+      deploymentConfigResult.errors.length,
+      deploymentConfigResult.warnings.length
+    );
+    io.info(formatHeading(deploymentConfigStatus, "deployment config"));
+  }
   for (const pluginResult of pluginResults) {
     reportPluginResult(pluginResult, io);
   }

package/dist/cli/init.js

@@ -1,6 +1,6 @@
 import {
   juniorVercelConfig
-} from "../chunk-SCQPBJAU.js";
+} from "../chunk-QUXPUKBH.js";
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/init.ts
@@ -20,6 +20,17 @@ export default app;
 `
   );
 }
+function writeQueueConsumerEntry(targetDir) {
+  const queueConsumerDir = path.join(targetDir, "api", "internal", "agent");
+  fs.mkdirSync(queueConsumerDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(queueConsumerDir, "continue.ts"),
+    `import app from "../../../server.ts";
+
+export const POST = (request: Request) => app.fetch(request);
+`
+  );
+}
 function writeNitroConfig(targetDir) {
   fs.writeFileSync(
     path.join(targetDir, "nitro.config.ts"),
@@ -186,6 +197,7 @@ SENTRY_ORG_SLUG=
 `
   );
   writeServerEntry(target);
+  writeQueueConsumerEntry(target);
   writeNitroConfig(target);
   writeViteConfig(target);
   writeVercelJson(target);

package/dist/cli/snapshot-warmup.js

@@ -1,14 +1,14 @@
 import {
   resolveRuntimeDependencySnapshot
-} from "../chunk-K3JNVV4Q.js";
+} from "../chunk-HRQQS63X.js";
 import {
   disconnectStateAdapter
-} from "../chunk-OMQ5X5QH.js";
+} from "../chunk-ZOV3XJAH.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,
   getPluginRuntimePostinstall
-} from "../chunk-EDHJIYHS.js";
+} from "../chunk-657CJCUO.js";
 import "../chunk-Z3YD6NHK.js";
 import "../chunk-KVZL5NZS.js";
 import "../chunk-2KG3PWR4.js";

package/dist/deployment.d.ts

@@ -0,0 +1,4 @@
+export declare const JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";
+export declare const JUNIOR_HEARTBEAT_CRON_SCHEDULE = "* * * * *";
+export declare const JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE = "/api/internal/agent/continue";
+export declare const LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION = "api/internal/agent/continue.ts";

package/dist/handlers/heartbeat.d.ts

@@ -1,3 +1,7 @@
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
 import type { WaitUntilFn } from "@/handlers/types";
+export interface HeartbeatHandlerOptions {
+    conversationWorkQueue?: ConversationWorkQueue;
+}
 /** Handle the authenticated internal heartbeat. */
-export declare function GET(request: Request, waitUntil: WaitUntilFn): Promise<Response>;
+export declare function GET(request: Request, waitUntil: WaitUntilFn, options?: HeartbeatHandlerOptions): Promise<Response>;