@sentry/junior 0.148.0 → 0.150.0

package/dist/{chunk-VCYSOXON.js → chunk-IPGNWXA3.js}

@@ -13,7 +13,7 @@ import {
   instructionProvenanceFor,
   sanitizePostgresJson,
   withConversationEventLock
-} from "./chunk-VRHTNBA6.js";
+} from "./chunk-ILYL6YFD.js";
 import {
   SANDBOX_WORKSPACE_ROOT,
   sleep
@@ -23,18 +23,26 @@ import {
   fenceLock,
   getStateAdapter,
   withLock
-} from "./chunk-2B3PT3V2.js";
+} from "./chunk-6PFDWAK2.js";
 import {
   botConfig,
+  completeText,
+  escapeXml,
+  resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-4GXJUYJV.js";
+} from "./chunk-3ZMKDHCT.js";
 import {
   toStoredSlackActor
 } from "./chunk-HZF5P5UN.js";
+import {
+  parseSlackMessageTs
+} from "./chunk-F3B2YJ76.js";
 import {
   getActiveTraceId,
-  logException
-} from "./chunk-EAI67NTM.js";
+  logException,
+  logWarn,
+  setSpanAttributes
+} from "./chunk-JQXJ2E53.js";
 
 // src/chat/turn-context-tag.ts
 var TURN_CONTEXT_TAG = "runtime-turn-context";
@@ -173,10 +181,518 @@ function stripRuntimeTurnContext(messages) {
   });
 }
 
+// src/chat/services/context-budget.ts
+var COMPACTION_TRIGGER_RATIO = 0.9;
+var CONTEXT_INPUT_LIMIT_RATIO = 0.95;
+var COMPACTION_TARGET_RATIO = 0.8;
+var FALLBACK_CONTEXT_WINDOW_TOKENS = 4e5;
+function positiveInteger(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function estimateTextTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function calculateContextCompactionTriggerTokens(model) {
+  const contextWindow = positiveInteger(
+    model.contextWindow,
+    FALLBACK_CONTEXT_WINDOW_TOKENS
+  );
+  return Math.max(1, Math.floor(contextWindow * COMPACTION_TRIGGER_RATIO));
+}
+function calculateContextInputLimitTokens(model) {
+  const contextWindow = positiveInteger(
+    model.contextWindow,
+    FALLBACK_CONTEXT_WINDOW_TOKENS
+  );
+  return Math.max(1, Math.floor(contextWindow * CONTEXT_INPUT_LIMIT_RATIO));
+}
+function calculateContextCompactionTargetTokens(triggerTokens) {
+  return Math.max(1, Math.floor(triggerTokens * COMPACTION_TARGET_RATIO));
+}
+function getModelContextBudget(modelId) {
+  const model = resolveGatewayModel(modelId);
+  const advertisedContextWindow = positiveInteger(
+    model.contextWindow,
+    FALLBACK_CONTEXT_WINDOW_TOKENS
+  );
+  return {
+    contextWindow: Math.min(
+      botConfig.contextWindowTokens,
+      advertisedContextWindow
+    )
+  };
+}
+function getAgentContextCompactionTriggerTokens(modelId) {
+  return calculateContextCompactionTriggerTokens(
+    getModelContextBudget(modelId)
+  );
+}
+function getAgentContextInputLimitTokens(modelId) {
+  return calculateContextInputLimitTokens(getModelContextBudget(modelId));
+}
+function getConversationContextCompactionTriggerTokens() {
+  return calculateContextCompactionTriggerTokens(
+    getModelContextBudget(botConfig.fastModelId)
+  );
+}
+
+// src/chat/services/conversation-memory.ts
+var CONTEXT_MIN_LIVE_MESSAGES = 12;
+var CONTEXT_COMPACTION_BATCH_SIZE = 24;
+var CONTEXT_MAX_COMPACTIONS = 16;
+var CONTEXT_MAX_MESSAGE_CHARS = 3200;
+var SLACK_USER_ID_DISPLAY_PATTERN = /^[UW][A-Z0-9]{5,}$/;
+function generateConversationId(prefix) {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function normalizeConversationText(text) {
+  return text.replace(/\r\n?/g, "\n").trim();
+}
+function buildImageContextSuffix(message, conversation) {
+  const byFileId = conversation?.vision.byFileId;
+  const imageFileIds = message.meta?.imageFileIds ?? [];
+  if (!byFileId || imageFileIds.length === 0) {
+    return "";
+  }
+  const summaries = imageFileIds.map((fileId) => byFileId[fileId]?.summary?.trim()).filter((summary) => Boolean(summary));
+  if (summaries.length === 0) {
+    return "";
+  }
+  return ` [image context: ${summaries.join(" | ")}]`;
+}
+function renderConversationMessageLine(message, conversation) {
+  const displayName = conversationAuthorDisplayName(message);
+  const text = message.text.replace(/\s+/g, " ").slice(0, CONTEXT_MAX_MESSAGE_CHARS);
+  const markers = [];
+  if (message.meta?.replied === false) {
+    markers.push(
+      `assistant skipped: ${message.meta?.skippedReason ?? "no-reply route"}`
+    );
+  }
+  if (message.meta?.explicitMention) {
+    markers.push("explicit mention");
+  }
+  const markerSuffix = markers.length > 0 ? ` (${markers.join("; ")})` : "";
+  const imageContext = buildImageContextSuffix(message, conversation);
+  return `[${message.role}] ${displayName}: ${text}${imageContext}${markerSuffix}`;
+}
+function conversationAuthorDisplayName(message) {
+  const author = message.author;
+  const fullName = authorDisplayField(author?.fullName, author?.userId);
+  const userName = authorDisplayField(author?.userName, author?.userId);
+  return fullName ?? userName ?? (message.role === "assistant" ? botConfig.userName : message.role);
+}
+function authorDisplayField(value, userId) {
+  if (!value || value === userId || SLACK_USER_ID_DISPLAY_PATTERN.test(value)) {
+    return void 0;
+  }
+  return value;
+}
+function estimateConversationContextTokens(conversation) {
+  return estimateTextTokens(buildConversationContext(conversation) ?? "");
+}
+function upsertConversationMessage(conversation, message) {
+  const existingIndex = conversation.messages.findIndex(
+    (entry) => entry.id === message.id
+  );
+  if (existingIndex >= 0) {
+    conversation.messages[existingIndex] = {
+      ...conversation.messages[existingIndex],
+      ...message,
+      meta: {
+        ...conversation.messages[existingIndex]?.meta,
+        ...message.meta
+      }
+    };
+    return message.id;
+  }
+  conversation.messages.push(message);
+  return message.id;
+}
+function recordDeliveredAssistantMessage(args) {
+  const prefix = `${args.sessionId}:assistant:`;
+  const ordinal = args.conversation.messages.filter(
+    (message) => message.id.startsWith(prefix)
+  ).length + 1;
+  const messageId = `${prefix}${ordinal}`;
+  markConversationMessage(args.conversation, args.userMessageId, {
+    replied: true,
+    skippedReason: void 0
+  });
+  upsertConversationMessage(args.conversation, {
+    id: messageId,
+    role: "assistant",
+    text: normalizeConversationText(args.text),
+    createdAtMs: Date.now(),
+    author: {
+      userName: botConfig.userName,
+      isBot: true
+    },
+    meta: {
+      replied: true,
+      ...args.source ? { source: args.source } : {}
+    }
+  });
+  return messageId;
+}
+function turnHasReply(conversation, turnId) {
+  const assistantPrefix = `${turnId}:assistant:`;
+  return conversation.messages.some(
+    (message) => message.role === "assistant" && message.id.startsWith(assistantPrefix)
+  );
+}
+function markConversationMessage(conversation, messageId, patch) {
+  if (!messageId) return;
+  const messageIndex = conversation.messages.findIndex(
+    (entry) => entry.id === messageId
+  );
+  if (messageIndex < 0) return;
+  const current = conversation.messages[messageIndex];
+  conversation.messages[messageIndex] = {
+    ...current,
+    meta: {
+      ...current.meta ?? {},
+      ...patch
+    }
+  };
+}
+function buildConversationContext(conversation, options = {}) {
+  const messages = conversation.messages.filter(
+    (entry) => entry.id !== options.excludeMessageId
+  );
+  if (messages.length === 0 && conversation.compactions.length === 0) {
+    return void 0;
+  }
+  const lines = [];
+  if (conversation.compactions.length > 0) {
+    lines.push("<thread-compactions>");
+    for (const [index, compaction] of conversation.compactions.entries()) {
+      lines.push(
+        `  <compaction index="${index + 1}" covered_messages="${compaction.coveredMessageCount}" created_at="${new Date(compaction.createdAtMs).toISOString()}">`,
+        compaction.summary,
+        "  </compaction>"
+      );
+    }
+    lines.push("</thread-compactions>");
+  }
+  if (messages.length > 0) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push("<thread-transcript>");
+    for (const [index, message] of messages.entries()) {
+      const author = escapeXml(conversationAuthorDisplayName(message));
+      const actorIdAttr = message.author?.userId ? ` actor_id="${escapeXml(message.author.userId)}"` : "";
+      const ts = new Date(message.createdAtMs).toISOString();
+      const slackTsAttr = message.meta?.slackTs ? ` slack_ts="${escapeXml(message.meta.slackTs)}"` : "";
+      lines.push(
+        `  <message index="${index + 1}" ts="${ts}" role="${message.role}" author="${author}"${actorIdAttr}${slackTsAttr}>`,
+        renderConversationMessageLine(message, conversation),
+        "  </message>"
+      );
+    }
+    lines.push("</thread-transcript>");
+  }
+  return lines.join("\n");
+}
+function pruneCompactions(compactions) {
+  if (compactions.length <= CONTEXT_MAX_COMPACTIONS) {
+    return compactions;
+  }
+  const overflowCount = compactions.length - CONTEXT_MAX_COMPACTIONS + 1;
+  const merged = compactions.slice(0, overflowCount);
+  const mergedSummary = merged.map((entry) => entry.summary).join("\n").slice(0, 3500);
+  const coveredMessageCount = merged.reduce(
+    (count, entry) => count + entry.coveredMessageCount,
+    0
+  );
+  const compacted = {
+    id: generateConversationId("compaction"),
+    createdAtMs: Date.now(),
+    summary: mergedSummary,
+    coveredMessageCount
+  };
+  return [compacted, ...compactions.slice(overflowCount)];
+}
+async function summarizeConversationChunk(messages, conversation, context, deps) {
+  const transcript = messages.map((message) => renderConversationMessageLine(message, conversation)).join("\n");
+  try {
+    const result = await deps.completeText({
+      modelId: botConfig.fastModelId,
+      temperature: 0,
+      promptName: "junior.thread_compaction",
+      messages: [
+        {
+          role: "user",
+          content: [
+            "Summarize the following older Slack thread transcript segment for future assistant turns.",
+            "Keep the summary factual and concise. Do not invent details.",
+            "",
+            "Output exactly three XML sections in this order:",
+            "<active-asks> one bullet per outstanding user ask that has not been narrowed, answered, or replaced by a later turn. Omit the section body if none. </active-asks>",
+            "<resolved-or-replaced-asks> one bullet per ask that has been replaced, narrowed, answered, or already acted on in this segment. Include the replacement/outcome inline. Omit the section body if none. </resolved-or-replaced-asks>",
+            "<facts> one bullet per durable fact useful regardless of scope: names, ids, URLs, decisions, locations, preferences, constraints that remain true. Omit the section body if none. </facts>",
+            "",
+            "Do not output any text outside the three sections.",
+            "",
+            transcript
+          ].join("\n"),
+          timestamp: Date.now()
+        }
+      ],
+      metadata: {
+        modelId: botConfig.fastModelId,
+        threadId: context.threadId ?? "",
+        channelId: context.channelId ?? "",
+        actorId: context.actorId ?? "",
+        runId: context.runId ?? ""
+      }
+    });
+    const summary = result.text.trim();
+    if (summary.length > 0) {
+      return summary.slice(0, 3500);
+    }
+  } catch (error) {
+    logWarn("conversation.compaction.summary.failed", {
+      "exception.message": error instanceof Error ? error.message : String(error),
+      "app.compaction_messages_covered": messages.length
+    });
+  }
+  return transcript.slice(0, 2800);
+}
+function getThreadTitleSourceMessage(conversation) {
+  let firstMessage;
+  for (const message of conversation.messages) {
+    if (!isHumanConversationMessage(message)) {
+      continue;
+    }
+    if (!firstMessage) {
+      firstMessage = message;
+      continue;
+    }
+    if (message.createdAtMs < firstMessage.createdAtMs) {
+      firstMessage = message;
+      continue;
+    }
+    if (message.createdAtMs === firstMessage.createdAtMs && message.id < firstMessage.id) {
+      firstMessage = message;
+    }
+  }
+  return firstMessage;
+}
+async function compactConversationIfNeededWithDeps(conversation, context, deps) {
+  let estimatedTokens = estimateConversationContextTokens(conversation);
+  setSpanAttributes({
+    "app.context_tokens_estimated": estimatedTokens
+  });
+  const triggerTokens = getConversationContextCompactionTriggerTokens();
+  const targetTokens = calculateContextCompactionTargetTokens(triggerTokens);
+  while (estimatedTokens > triggerTokens && conversation.messages.length > CONTEXT_MIN_LIVE_MESSAGES) {
+    const compactCount = Math.min(
+      CONTEXT_COMPACTION_BATCH_SIZE,
+      conversation.messages.length - CONTEXT_MIN_LIVE_MESSAGES
+    );
+    if (compactCount <= 0) {
+      break;
+    }
+    const compactedChunk = conversation.messages.slice(0, compactCount);
+    const summary = await summarizeConversationChunk(
+      compactedChunk,
+      conversation,
+      context,
+      deps
+    );
+    conversation.compactions.push({
+      id: generateConversationId("compaction"),
+      createdAtMs: Date.now(),
+      summary,
+      coveredMessageCount: compactedChunk.length
+    });
+    conversation.compactions = pruneCompactions(conversation.compactions);
+    conversation.messages = conversation.messages.slice(compactCount);
+    estimatedTokens = estimateConversationContextTokens(conversation);
+    setSpanAttributes({
+      "app.compaction_messages_covered": compactCount,
+      "app.compaction.trigger_tokens": triggerTokens,
+      "app.compaction.target_tokens": targetTokens,
+      "app.context_tokens_estimated": estimatedTokens
+    });
+    if (estimatedTokens <= targetTokens) {
+      break;
+    }
+  }
+}
+function createConversationMemoryService(deps) {
+  return {
+    compactConversationIfNeeded: async (conversation, context) => await compactConversationIfNeededWithDeps(conversation, context, deps)
+  };
+}
+function isHumanConversationMessage(message) {
+  return message.role === "user" && message.author?.isBot !== true;
+}
+function getConversationMessageSlackTs(message) {
+  return parseSlackMessageTs(message.meta?.slackTs);
+}
+
 // src/chat/conversations/messages.ts
 import { createHash } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 
+// src/chat/services/short-title.ts
+var SHORT_TITLE_MAX_LENGTH = 60;
+var TITLE_PROMPTS = {
+  conversation: [
+    "Generate a concise 5-8 word conversation title from the first user message below.",
+    "Capture the user's main request.",
+    "Reply with ONLY the title, with no quotes or trailing punctuation."
+  ],
+  task: [
+    "Generate a concise 5-8 word task title from the task instruction below.",
+    "Capture the task's main purpose.",
+    "Reply with ONLY the title, with no quotes or trailing punctuation."
+  ]
+};
+function normalizeShortTitle(value) {
+  return value.replace(/\s+/g, " ").trim().slice(0, SHORT_TITLE_MAX_LENGTH);
+}
+function fallbackShortTitle(sourceText, fallback = "Untitled") {
+  const firstLine = sourceText.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0) ?? "";
+  return normalizeShortTitle(firstLine) || fallback;
+}
+async function generateShortTitle(args) {
+  const sourceText = args.sourceText.trim();
+  if (!sourceText) return void 0;
+  try {
+    const result = await args.completeText({
+      modelId: botConfig.fastModelId,
+      temperature: 0,
+      promptName: `junior.${args.kind}_title`,
+      messages: [
+        {
+          role: "user",
+          content: [
+            ...TITLE_PROMPTS[args.kind],
+            "",
+            args.kind === "conversation" ? `First user message: ${sourceText.slice(0, 500)}` : `Task instruction: ${sourceText.slice(0, 500)}`
+          ].join("\n"),
+          timestamp: Date.now()
+        }
+      ],
+      metadata: {
+        modelId: botConfig.fastModelId
+      }
+    });
+    const title = normalizeShortTitle(result.text);
+    return title || void 0;
+  } catch (error) {
+    logWarn(`${args.kind}.title.generation.failed`, {
+      "exception.message": error instanceof Error ? error.message : String(error)
+    });
+    return void 0;
+  }
+}
+async function resolveTaskTitle(args) {
+  const explicit = normalizeShortTitle(args.title ?? "");
+  if (explicit) return explicit;
+  return generateShortTitle({
+    completeText: args.completeText,
+    kind: "task",
+    sourceText: args.instruction
+  });
+}
+
+// src/chat/services/conversation-title.ts
+var inFlightTitles = /* @__PURE__ */ new Map();
+async function ensureConversationTitle(args) {
+  const pending = inFlightTitles.get(args.conversationId);
+  if (pending) {
+    return pending;
+  }
+  const work = ensureConversationTitleOnce(args).finally(() => {
+    inFlightTitles.delete(args.conversationId);
+  });
+  inFlightTitles.set(args.conversationId, work);
+  return work;
+}
+async function ensureConversationTitleOnce(args) {
+  if (!args.conversation.messages.some(isHumanConversationMessage)) {
+    return void 0;
+  }
+  const store = args.conversationStore ?? getConversationStore();
+  try {
+    const stored = await store.get({ conversationId: args.conversationId });
+    if (stored?.title?.trim()) {
+      return void 0;
+    }
+    if (stored?.lineage) {
+      return void 0;
+    }
+    const titleSourceMessage = getThreadTitleSourceMessage(args.conversation);
+    const sourceText = titleSourceMessage?.text.trim() ?? "";
+    if (!titleSourceMessage || !sourceText) {
+      return void 0;
+    }
+    let title;
+    try {
+      const generated = await generateShortTitle({
+        completeText,
+        kind: "conversation",
+        sourceText
+      });
+      title = generated ?? fallbackShortTitle(sourceText, "Conversation");
+    } catch (error) {
+      logWarn("conversation.title.generation.failed", {
+        "exception.message": error instanceof Error ? error.message : String(error)
+      });
+      title = fallbackShortTitle(sourceText, "Conversation");
+    }
+    const normalized = title.trim();
+    if (!normalized) {
+      return void 0;
+    }
+    const activityAtMs = titleSourceMessage.createdAtMs;
+    const nowMs = args.nowMs ?? Date.now();
+    try {
+      await store.recordActivity({
+        activityAtMs,
+        conversationId: args.conversationId,
+        nowMs,
+        title: normalized
+      });
+    } catch (error) {
+      logException(error, "conversation.title.persist.failed");
+      return void 0;
+    }
+    return normalized;
+  } catch (error) {
+    logException(error, "conversation.title.ensure.failed");
+    return void 0;
+  }
+}
+function scheduleConversationTitle(args) {
+  if (!args.conversationId) {
+    return;
+  }
+  void ensureConversationTitle({
+    conversation: args.conversation,
+    conversationId: args.conversationId
+  }).catch((error) => {
+    logException(error, "conversation.title.task.failed");
+  });
+}
+async function resolveConversationTitle(args) {
+  const pending = inFlightTitles.get(args.conversationId);
+  if (pending) {
+    const generated = await pending;
+    if (generated?.trim()) {
+      return generated.trim();
+    }
+  }
+  const store = args.conversationStore ?? getConversationStore();
+  const stored = await store.get({ conversationId: args.conversationId });
+  return stored?.title?.trim() || void 0;
+}
+
 // src/chat/conversations/message-summaries.ts
 import { isDeepStrictEqual } from "util";
 function projectConversationMessageSummaries(events) {
@@ -320,6 +836,10 @@ async function persistConversationMessages(args) {
     ...args,
     conversationId: args.conversationId
   });
+  scheduleConversationTitle({
+    conversation: args.conversation,
+    conversationId: args.conversationId
+  });
 }
 async function appendConversationMessages(eventStore, args) {
   if (args.conversation.messages.length === 0) return;
@@ -1276,7 +1796,7 @@ var RIPGREP_EXCLUDED_GLOBS = [
 ];
 var DEFAULT_SEARCH_COMMAND_TIMEOUT_MS = 3e4;
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules"]);
-function positiveInteger(value) {
+function positiveInteger2(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
     return void 0;
   }
@@ -2615,6 +3135,24 @@ export {
   stripRuntimeTurnContext,
   historyItemFromPiMessage,
   piMessageFromHistoryItem,
+  estimateTextTokens,
+  getAgentContextCompactionTriggerTokens,
+  getAgentContextInputLimitTokens,
+  normalizeConversationText,
+  estimateConversationContextTokens,
+  upsertConversationMessage,
+  recordDeliveredAssistantMessage,
+  turnHasReply,
+  markConversationMessage,
+  buildConversationContext,
+  createConversationMemoryService,
+  isHumanConversationMessage,
+  getConversationMessageSlackTs,
+  SHORT_TITLE_MAX_LENGTH,
+  fallbackShortTitle,
+  generateShortTitle,
+  resolveTaskTitle,
+  resolveConversationTitle,
   persistConversationMessageSummaries,
   hydrateConversationMessages,
   persistConversationMessages,
@@ -2638,7 +3176,7 @@ export {
   MAX_TEXT_CHARS,
   RIPGREP_EXCLUDED_GLOBS,
   DEFAULT_SEARCH_COMMAND_TIMEOUT_MS,
-  positiveInteger,
+  positiveInteger2 as positiveInteger,
   normalizeToLf,
   truncateText,
   isMissingPathError,

package/dist/{chunk-LAZGHEYU.js → chunk-IZRSLANA.js}

@@ -1,6 +1,6 @@
 import {
   JUNIOR_VERSION
-} from "./chunk-55F4QU2V.js";
+} from "./chunk-7QB2CKCW.js";
 
 // src/deployment.ts
 var JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";

package/dist/{chunk-EAI67NTM.js → chunk-JQXJ2E53.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-6GWA276C.js";
 import {
   getDeploymentTelemetryAttributes
-} from "./chunk-LAZGHEYU.js";
+} from "./chunk-IZRSLANA.js";
 
 // src/chat/logging.ts
 import path from "path";

package/dist/{chunk-HLPLT3NY.js → chunk-M5OZSVJI.js}

@@ -8,14 +8,14 @@ import {
   getConversationStore,
   parseDestination,
   sameDestination
-} from "./chunk-VRHTNBA6.js";
+} from "./chunk-ILYL6YFD.js";
 import {
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-2B3PT3V2.js";
+} from "./chunk-6PFDWAK2.js";
 import {
   getChatConfig
-} from "./chunk-4GXJUYJV.js";
+} from "./chunk-3ZMKDHCT.js";
 import {
   parseStoredSlackActor
 } from "./chunk-HZF5P5UN.js";
@@ -23,7 +23,7 @@ import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-EAI67NTM.js";
+} from "./chunk-JQXJ2E53.js";
 
 // src/chat/task-execution/state.ts
 import { randomUUID } from "crypto";
@@ -1300,6 +1300,9 @@ async function recordExecutionMetadata(args) {
     updatedAtMs: conversation.updatedAtMs
   });
 }
+async function getConversation2(args) {
+  return await getConversation(args);
+}
 async function getConversationWorkState2(args) {
   return await getConversationWorkState(args);
 }
@@ -1500,6 +1503,7 @@ export {
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
   CONVERSATION_WORK_MAX_RETRIES,
   isFinalAttempt,
+  getConversation2 as getConversation,
   getConversationWorkState2 as getConversationWorkState,
   recordConversationRetry2 as recordConversationRetry,
   countPendingConversationMessages,