@sentry/junior 0.55.0 → 0.56.0

package/dist/app.js

@@ -32,7 +32,7 @@ import {
   runNonInteractiveCommand,
   sandboxSkillDir,
   sandboxSkillFile
-} from "./chunk-XI3CFWTA.js";
+} from "./chunk-AA5TIFN5.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -10745,6 +10745,21 @@ function parseEnv(raw) {
     Object.entries(raw).filter(([, value]) => typeof value === "string").map(([key, value]) => [key, value])
   );
 }
+function sandboxStreamInterruptedResult(toolName) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Sandbox command stream was interrupted during ${toolName}. The operation did not complete reliably. It may have produced side effects; inspect the workspace or retry only if it is safe.`
+      }
+    ],
+    details: {
+      ok: false,
+      error: "stream_interrupted",
+      tool: toolName
+    }
+  };
+}
 function createSandboxExecutor(options) {
   let availableSkills = [];
   let referenceFiles = [];
@@ -11096,23 +11111,30 @@ function createSandboxExecutor(options) {
       }
       return await executeBashTool(rawInput, bashCommand);
     }
-    if (params.toolName === "readFile") {
-      return await executeReadFileTool(rawInput);
-    }
-    if (params.toolName === "editFile") {
-      return await executeEditFileTool(rawInput);
-    }
-    if (params.toolName === "grep") {
-      return await executeGrepTool(rawInput);
-    }
-    if (params.toolName === "findFiles") {
-      return await executeFindFilesTool(rawInput);
-    }
-    if (params.toolName === "listDir") {
-      return await executeListDirTool(rawInput);
-    }
-    if (params.toolName === "writeFile") {
-      return await executeWriteFileTool(rawInput);
+    try {
+      if (params.toolName === "readFile") {
+        return await executeReadFileTool(rawInput);
+      }
+      if (params.toolName === "editFile") {
+        return await executeEditFileTool(rawInput);
+      }
+      if (params.toolName === "grep") {
+        return await executeGrepTool(rawInput);
+      }
+      if (params.toolName === "findFiles") {
+        return await executeFindFilesTool(rawInput);
+      }
+      if (params.toolName === "listDir") {
+        return await executeListDirTool(rawInput);
+      }
+      if (params.toolName === "writeFile") {
+        return await executeWriteFileTool(rawInput);
+      }
+    } catch (error) {
+      if (!isSandboxCommandStreamInterruptedError(error)) {
+        throw error;
+      }
+      return { result: sandboxStreamInterruptedResult(params.toolName) };
     }
     throw new Error(`unsupported sandbox tool: ${params.toolName}`);
   };
@@ -14087,7 +14109,7 @@ function buildUserTurnInput(args) {
   }
   return { routerBlocks, userContentParts };
 }
-async function generateAssistantReply(messageText, context = {}) {
+async function generateAssistantReply(messageText2, context = {}) {
   const replyStartedAtMs = Date.now();
   let timeoutResumeConversationId;
   let timeoutResumeSessionId;
@@ -14156,7 +14178,7 @@ async function generateAssistantReply(messageText, context = {}) {
     }
     let baseInstructions = "";
     let configurationValues;
-    const userInput = messageText;
+    const userInput = messageText2;
     if (shouldTrace) {
       const inboundAttachmentCount = context.inboundAttachmentCount ?? 0;
       const promptAttachmentCount = context.userAttachments?.length ?? 0;
@@ -14886,9 +14908,56 @@ async function generateAssistantReply(messageText, context = {}) {
   }
 }
 
+// src/chat/services/context-budget.ts
+var COMPACTION_TRIGGER_INPUT_RATIO = 0.75;
+var COMPACTION_OUTPUT_RESERVE_RATIO = 0.25;
+var COMPACTION_TARGET_RATIO = 0.8;
+var FALLBACK_CONTEXT_WINDOW_TOKENS = 4e5;
+var FALLBACK_MAX_OUTPUT_TOKENS = 128e3;
+function positiveInteger2(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 = positiveInteger2(
+    model.contextWindow,
+    FALLBACK_CONTEXT_WINDOW_TOKENS
+  );
+  const maxTokens = positiveInteger2(
+    model.maxTokens,
+    FALLBACK_MAX_OUTPUT_TOKENS
+  );
+  const outputReserve = Math.min(
+    maxTokens,
+    Math.floor(contextWindow * COMPACTION_OUTPUT_RESERVE_RATIO)
+  );
+  const usableInputTokens = Math.max(1, contextWindow - outputReserve);
+  return Math.max(
+    1,
+    Math.floor(usableInputTokens * COMPACTION_TRIGGER_INPUT_RATIO)
+  );
+}
+function calculateContextCompactionTargetTokens(triggerTokens) {
+  return Math.max(1, Math.floor(triggerTokens * COMPACTION_TARGET_RATIO));
+}
+function getAgentContextCompactionTriggerTokens() {
+  const model = resolveGatewayModel(botConfig.modelId);
+  return calculateContextCompactionTriggerTokens({
+    contextWindow: botConfig.modelContextWindowTokens ?? model.contextWindow,
+    maxTokens: model.maxTokens
+  });
+}
+function getConversationContextCompactionTriggerTokens() {
+  const model = resolveGatewayModel(botConfig.fastModelId);
+  return calculateContextCompactionTriggerTokens({
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens
+  });
+}
+
 // src/chat/services/conversation-memory.ts
-var CONTEXT_COMPACTION_TRIGGER_TOKENS = 9e3;
-var CONTEXT_COMPACTION_TARGET_TOKENS = 7e3;
 var CONTEXT_MIN_LIVE_MESSAGES = 12;
 var CONTEXT_COMPACTION_BATCH_SIZE = 24;
 var CONTEXT_MAX_COMPACTIONS = 16;
@@ -14899,9 +14968,6 @@ function generateConversationId(prefix) {
 function normalizeConversationText(text) {
   return text.trim().replace(/\s+/g, " ").slice(0, CONTEXT_MAX_MESSAGE_CHARS);
 }
-function estimateTokenCount(text) {
-  return Math.ceil(text.length / 4);
-}
 function buildImageContextSuffix(message, conversation) {
   const byFileId = conversation?.vision.byFileId;
   const imageFileIds = message.meta?.imageFileIds ?? [];
@@ -14931,7 +14997,7 @@ function renderConversationMessageLine(message, conversation) {
 }
 function updateConversationStats(conversation) {
   const contextText = buildConversationContext(conversation);
-  conversation.stats.estimatedContextTokens = estimateTokenCount(
+  conversation.stats.estimatedContextTokens = estimateTextTokens(
     contextText ?? ""
   );
   conversation.stats.totalMessageCount = conversation.messages.length;
@@ -15128,7 +15194,9 @@ async function compactConversationIfNeededWithDeps(conversation, context, deps)
   setSpanAttributes({
     "app.context_tokens_estimated": estimatedTokens
   });
-  while (estimatedTokens > CONTEXT_COMPACTION_TRIGGER_TOKENS && conversation.messages.length > CONTEXT_MIN_LIVE_MESSAGES) {
+  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
@@ -15156,9 +15224,11 @@ async function compactConversationIfNeededWithDeps(conversation, context, deps)
     estimatedTokens = conversation.stats.estimatedContextTokens;
     setSpanAttributes({
       "app.compaction_messages_covered": compactCount,
+      "app.compaction.trigger_tokens": triggerTokens,
+      "app.compaction.target_tokens": targetTokens,
       "app.context_tokens_estimated": estimatedTokens
     });
-    if (estimatedTokens <= CONTEXT_COMPACTION_TARGET_TOKENS) {
+    if (estimatedTokens <= targetTokens) {
       break;
     }
   }
@@ -16815,9 +16885,13 @@ function createAssistantStatusScheduler(args) {
     }
   };
   return {
-    start() {
+    start(status) {
       active = true;
       clearPending();
+      if (status) {
+        void postRenderedStatus(status);
+        return;
+      }
       currentKey = "initial";
       void postStatus(getInitialStatusText(), loadingMessages);
     },
@@ -17731,13 +17805,13 @@ async function persistCompletedReplyState(channelId, threadTs, sessionId, reply)
   const currentState = await getPersistedThreadState(threadId);
   const conversation = coerceThreadConversationState(currentState);
   const artifacts = coerceThreadArtifactsState(currentState);
-  const userMessage = getTurnUserMessage(conversation, sessionId);
+  const userMessage2 = getTurnUserMessage(conversation, sessionId);
   const statePatch = buildDeliveredTurnStatePatch({
     artifacts,
     conversation,
     reply,
     sessionId,
-    userMessageId: userMessage?.id
+    userMessageId: userMessage2?.id
   });
   await persistThreadStateById(threadId, {
     ...statePatch
@@ -17800,7 +17874,7 @@ async function resumeAuthorizedMcpTurn(args) {
     requesterId: authSession.userId
   });
   const resolvedSessionId = pendingAuth?.sessionId ?? authSession.sessionId;
-  const userMessage = getTurnUserMessage(conversation, resolvedSessionId);
+  const userMessage2 = getTurnUserMessage(conversation, resolvedSessionId);
   if (pendingAuth) {
     if (!isPendingAuthLatestRequest(conversation, pendingAuth)) {
       clearPendingAuth(conversation, pendingAuth.sessionId);
@@ -17815,14 +17889,14 @@ async function resumeAuthorizedMcpTurn(args) {
   } else if (conversation.processing.activeTurnId !== authSession.sessionId) {
     return;
   }
-  if (!userMessage) {
+  if (!userMessage2) {
     return;
   }
   await resumeAuthorizedRequest({
-    messageText: userMessage.text,
+    messageText: userMessage2.text,
     channelId: authSession.channelId,
     threadTs: authSession.threadTs,
-    messageTs: getTurnUserSlackMessageTs(userMessage),
+    messageTs: getTurnUserSlackMessageTs(userMessage2),
     lockKey: threadId,
     connectedText: "",
     beforeStart: async () => {
@@ -18188,13 +18262,13 @@ async function persistCompletedOAuthReplyState(args) {
   const currentState = await getPersistedThreadState(args.conversationId);
   const conversation = coerceThreadConversationState(currentState);
   const artifacts = coerceThreadArtifactsState(currentState);
-  const userMessage = getTurnUserMessage(conversation, args.sessionId);
+  const userMessage2 = getTurnUserMessage(conversation, args.sessionId);
   const statePatch = buildDeliveredTurnStatePatch({
     artifacts,
     conversation,
     reply: args.reply,
     sessionId: args.sessionId,
-    userMessageId: userMessage?.id
+    userMessageId: userMessage2?.id
   });
   await persistThreadStateById(args.conversationId, {
     ...statePatch
@@ -18269,7 +18343,7 @@ async function resumeCheckpointedOAuthTurn(stored) {
     requesterId: stored.userId
   });
   const resolvedSessionId = pendingAuth?.sessionId ?? stored.resumeSessionId;
-  const userMessage = resolvedSessionId ? getTurnUserMessage(conversation, resolvedSessionId) : void 0;
+  const userMessage2 = resolvedSessionId ? getTurnUserMessage(conversation, resolvedSessionId) : void 0;
   if (pendingAuth) {
     if (!isPendingAuthLatestRequest(conversation, pendingAuth)) {
       clearPendingAuth(conversation, pendingAuth.sessionId);
@@ -18284,21 +18358,21 @@ async function resumeCheckpointedOAuthTurn(stored) {
       return true;
     }
   } else {
-    if (!userMessage?.author?.userId) {
+    if (!userMessage2?.author?.userId) {
       return false;
     }
     if (conversation.processing.activeTurnId !== stored.resumeSessionId) {
       return true;
     }
   }
-  if (!userMessage?.author?.userId || !resolvedSessionId) {
+  if (!userMessage2?.author?.userId || !resolvedSessionId) {
     return false;
   }
   await resumeSlackTurn({
-    messageText: stored.pendingMessage ?? userMessage.text,
+    messageText: stored.pendingMessage ?? userMessage2.text,
     channelId: stored.channelId,
     threadTs: stored.threadTs,
-    messageTs: getTurnUserSlackMessageTs(userMessage),
+    messageTs: getTurnUserSlackMessageTs(userMessage2),
     lockKey: stored.resumeConversationId,
     initialText: "",
     beforeStart: async () => {
@@ -19229,7 +19303,7 @@ async function persistCompletedReplyState2(args) {
   );
   const conversation = coerceThreadConversationState(currentState);
   const artifacts = coerceThreadArtifactsState(currentState);
-  const userMessage = getTurnUserMessage(
+  const userMessage2 = getTurnUserMessage(
     conversation,
     args.checkpoint.sessionId
   );
@@ -19238,7 +19312,7 @@ async function persistCompletedReplyState2(args) {
     conversation,
     reply: args.reply,
     sessionId: args.checkpoint.sessionId,
-    userMessageId: userMessage?.id
+    userMessageId: userMessage2?.id
   });
   await persistThreadStateById(args.checkpoint.conversationId, {
     ...statePatch
@@ -19310,8 +19384,8 @@ async function resumeTimedOutTurn(payload) {
       );
       const conversation = coerceThreadConversationState(currentState);
       const artifacts = coerceThreadArtifactsState(currentState);
-      const userMessage = getTurnUserMessage(conversation, payload.sessionId);
-      if (!userMessage?.author?.userId) {
+      const userMessage2 = getTurnUserMessage(conversation, payload.sessionId);
+      if (!userMessage2?.author?.userId) {
         throw new Error(
           `Unable to locate the persisted user message for timeout resume session "${payload.sessionId}"`
         );
@@ -19323,24 +19397,24 @@ async function resumeTimedOutTurn(payload) {
         thread.channelId
       );
       const conversationContext = buildConversationContext(conversation, {
-        excludeMessageId: userMessage.id
+        excludeMessageId: userMessage2.id
       });
       const sandbox = getPersistedSandboxState(currentState);
       return {
-        messageText: userMessage.text,
-        messageTs: getTurnUserSlackMessageTs(userMessage),
+        messageText: userMessage2.text,
+        messageTs: getTurnUserSlackMessageTs(userMessage2),
         replyContext: {
           requester: {
-            userId: userMessage.author.userId,
-            userName: userMessage.author.userName,
-            fullName: userMessage.author.fullName
+            userId: userMessage2.author.userId,
+            userName: userMessage2.author.userName,
+            fullName: userMessage2.author.fullName
           },
           correlation: {
             conversationId: payload.conversationId,
             turnId: payload.sessionId,
             channelId: thread.channelId,
             threadTs: thread.threadTs,
-            requesterId: userMessage.author.userId
+            requesterId: userMessage2.author.userId
           },
           toolChannelId: artifacts.assistantContextChannelId ?? thread.channelId,
           artifactState: artifacts,
@@ -19359,7 +19433,7 @@ async function resumeTimedOutTurn(payload) {
               conversation
             });
           },
-          ...getTurnUserReplyAttachmentContext(userMessage)
+          ...getTurnUserReplyAttachmentContext(userMessage2)
         },
         onSuccess: async (reply) => {
           await persistCompletedReplyState2({ checkpoint, reply });
@@ -20178,6 +20252,294 @@ function createSlackTurnRuntime(deps) {
   };
 }
 
+// src/chat/services/context-compaction.ts
+import {
+  estimateContextTokens,
+  estimateTokens
+} from "@earendil-works/pi-agent-core";
+var RETAINED_USER_MESSAGE_TOKENS = 2e4;
+var MAX_SUMMARY_INPUT_CHARS = 8e4;
+var MAX_VISIBLE_CONTEXT_CHARS = 2e4;
+var MAX_SUMMARY_CHARS = 6e3;
+var MAX_RENDERED_MESSAGE_CHARS = 4e3;
+var COMPACTION_SUMMARY_PREFIX = "Context handoff summary for future Junior turns:";
+var OMITTED_OLDER_CONTEXT_NOTICE = "[older context omitted]";
+function textPart(value) {
+  if (value && typeof value === "object" && value.type === "text" && typeof value.text === "string") {
+    return value.text;
+  }
+  return void 0;
+}
+function messageText(message) {
+  const content = message.content;
+  if (!Array.isArray(content)) {
+    return typeof content === "string" ? content : "";
+  }
+  return content.map(textPart).filter(Boolean).join("\n").trim();
+}
+function sanitizeText(text) {
+  return text.replace(
+    /<data_base64>[\s\S]*?<\/data_base64>/g,
+    "<data_base64>[omitted]</data_base64>"
+  ).replace(
+    /data:image\/[a-z0-9.+-]+;base64,[a-z0-9+/=]+/gi,
+    "[image data omitted]"
+  ).replaceAll("\0", " ").trim();
+}
+function truncateToTokenBudget(text, maxTokens) {
+  const maxChars = Math.max(0, maxTokens * 4);
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
+}
+function isCompactionSummary(text) {
+  return text.trimStart().startsWith(COMPACTION_SUMMARY_PREFIX);
+}
+function isPayloadHeavy(text) {
+  return /<data_base64>[\s\S]*?<\/data_base64>|data:image\/[a-z0-9.+-]+;base64,/i.test(
+    text
+  );
+}
+function userMessage(text) {
+  return {
+    role: "user",
+    content: [{ type: "text", text }],
+    timestamp: Date.now()
+  };
+}
+function selectRetainedUserMessages(messages, maxTokens = RETAINED_USER_MESSAGE_TOKENS) {
+  const stripped = stripRuntimeTurnContext(messages);
+  const selected = [];
+  let remaining = maxTokens;
+  for (const message of [...stripped].reverse()) {
+    if (message.role !== "user" || remaining <= 0) {
+      continue;
+    }
+    const text = sanitizeText(messageText(message));
+    if (!text || isCompactionSummary(text) || isPayloadHeavy(text)) {
+      continue;
+    }
+    const tokens = estimateTextTokens(text);
+    if (tokens <= remaining) {
+      selected.push(text);
+      remaining -= tokens;
+      continue;
+    }
+    const truncated = truncateToTokenBudget(text, remaining);
+    if (truncated) {
+      selected.push(truncated);
+    }
+    break;
+  }
+  return selected.reverse().map(userMessage);
+}
+function renderMessageForSummary(message) {
+  const role = message.role;
+  if (typeof role !== "string") {
+    return void 0;
+  }
+  const text = sanitizeText(messageText(message));
+  if (!text) {
+    return void 0;
+  }
+  const trimmed = text.length > MAX_RENDERED_MESSAGE_CHARS ? `${text.slice(0, MAX_RENDERED_MESSAGE_CHARS).trimEnd()}...` : text;
+  return `[${role}] ${trimmed}`;
+}
+function keepTail(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  const prefix = `${OMITTED_OLDER_CONTEXT_NOTICE}
+`;
+  return `${prefix}${text.slice(Math.max(0, text.length - maxChars + prefix.length))}`;
+}
+function renderSummaryInput(piMessages, conversationContext) {
+  const lines = [];
+  const visibleContext = conversationContext?.trim();
+  if (visibleContext) {
+    lines.push(
+      "<visible-thread-context>",
+      keepTail(visibleContext, MAX_VISIBLE_CONTEXT_CHARS),
+      "</visible-thread-context>",
+      ""
+    );
+  }
+  const renderedPiMessages = stripRuntimeTurnContext(piMessages).map(renderMessageForSummary).filter((line) => Boolean(line));
+  if (renderedPiMessages.length > 0) {
+    const piEnvelopeChars = "<pi-history>\n</pi-history>".length + 2;
+    const piHistory = keepTail(
+      renderedPiMessages.join("\n"),
+      Math.max(
+        1,
+        MAX_SUMMARY_INPUT_CHARS - lines.join("\n").length - piEnvelopeChars
+      )
+    );
+    lines.push("<pi-history>", piHistory, "</pi-history>");
+  }
+  return keepTail(lines.join("\n"), MAX_SUMMARY_INPUT_CHARS);
+}
+async function summarizeContext(args, deps) {
+  const source = renderSummaryInput(args.piMessages, args.conversationContext);
+  const result = await deps.completeText({
+    modelId: botConfig.fastModelId,
+    messageAttributeMode: "metadata",
+    temperature: 0,
+    messages: [
+      {
+        role: "user",
+        content: [
+          "You are performing a CONTEXT CHECKPOINT COMPACTION for Junior.",
+          "Create a concise handoff summary for another model that will continue this Slack thread.",
+          "",
+          "Include:",
+          "- Current outstanding asks",
+          "- Key decisions, completed work, and outcomes",
+          "- Durable constraints, user preferences, IDs, URLs, artifacts, canvas links, sandbox references, and auth state",
+          "- Clear next steps and unresolved blockers",
+          "",
+          "Do not invent details. Do not include raw secrets or credentials.",
+          "",
+          source
+        ].join("\n"),
+        timestamp: Date.now()
+      }
+    ],
+    metadata: {
+      modelId: botConfig.fastModelId,
+      threadId: args.metadata?.threadId ?? "",
+      channelId: args.metadata?.channelId ?? "",
+      requesterId: args.metadata?.requesterId ?? "",
+      runId: args.metadata?.runId ?? ""
+    }
+  });
+  const summary = result.text.trim();
+  if (!summary) {
+    throw new Error("Compaction summary was empty");
+  }
+  return summary.slice(0, MAX_SUMMARY_CHARS);
+}
+function estimateHistoryTokens(messages) {
+  const stripped = stripRuntimeTurnContext(messages);
+  const usageEstimate = estimateContextTokens(stripped).tokens;
+  const structuralEstimate = stripped.reduce(
+    (total, message) => total + estimateTokens(message),
+    0
+  );
+  return Math.max(usageEstimate, structuralEstimate);
+}
+function buildReplacementHistory(args) {
+  return [
+    ...selectRetainedUserMessages(args.messages),
+    userMessage(`${COMPACTION_SUMMARY_PREFIX}
+${args.summary}`)
+  ];
+}
+function createCompactionSessionId(previousSessionId) {
+  return `compaction_${previousSessionId}`;
+}
+async function loadCompactionSource(args) {
+  const checkpoint = await getAgentTurnSessionCheckpoint(
+    args.conversationId,
+    args.previousSessionId
+  );
+  if (!checkpoint) {
+    return { reason: "missing_context" };
+  }
+  if (checkpoint.state !== "completed") {
+    return { reason: "not_completed" };
+  }
+  const messages = checkpoint.piMessages;
+  if (messages.length) {
+    return {
+      estimatedTokens: estimateHistoryTokens(messages),
+      messages
+    };
+  }
+  return { reason: "missing_context" };
+}
+async function maybeCompactWithDeps(args, deps) {
+  const source = await loadCompactionSource({
+    conversationId: args.conversationId,
+    previousSessionId: args.previousSessionId
+  });
+  if ("reason" in source) {
+    return { compacted: false, reason: source.reason };
+  }
+  const triggerTokens = deps.autoCompactionTriggerTokens ?? getAgentContextCompactionTriggerTokens();
+  if (source.estimatedTokens <= triggerTokens) {
+    return { compacted: false, reason: "below_threshold" };
+  }
+  args.onCompactionStart?.();
+  let summary;
+  try {
+    summary = await summarizeContext(
+      {
+        conversationContext: args.conversationContext,
+        piMessages: source.messages,
+        metadata: args.metadata
+      },
+      deps
+    );
+  } catch (error) {
+    logWarn(
+      "context_compaction_summary_failed",
+      {
+        slackThreadId: args.metadata?.threadId,
+        slackUserId: args.metadata?.requesterId,
+        slackChannelId: args.metadata?.channelId,
+        runId: args.metadata?.runId,
+        assistantUserName: botConfig.userName,
+        modelId: botConfig.fastModelId
+      },
+      {
+        "exception.message": error instanceof Error ? error.message : String(error)
+      },
+      "Context compaction failed; continuing with prior history"
+    );
+    return { compacted: false, reason: "summary_failed" };
+  }
+  return await writeCompactedThreadContext(args, source.messages, summary, {
+    estimatedTokens: source.estimatedTokens,
+    triggerTokens
+  });
+}
+async function writeCompactedThreadContext(args, sourceMessages, summary, context) {
+  const replacement = buildReplacementHistory({
+    messages: trimTrailingAssistantMessages(sourceMessages),
+    summary
+  });
+  const nextSessionId = createCompactionSessionId(args.previousSessionId);
+  await upsertAgentTurnSessionCheckpoint({
+    conversationId: args.conversationId,
+    sessionId: nextSessionId,
+    sliceId: 1,
+    state: "completed",
+    piMessages: replacement
+  });
+  args.conversation.processing.lastSessionId = nextSessionId;
+  updateConversationStats(args.conversation);
+  setSpanAttributes({
+    "app.compaction.input_messages": sourceMessages.length,
+    "app.compaction.retained_messages": replacement.length - 1,
+    "app.compaction.summary_chars": summary.length,
+    "app.compaction.previous_session_id": args.previousSessionId,
+    "app.compaction.next_session_id": nextSessionId,
+    ...context.triggerTokens !== void 0 ? { "app.compaction.trigger_tokens": context.triggerTokens } : {},
+    "app.context_tokens_estimated": context.estimatedTokens
+  });
+  return {
+    compacted: true,
+    piMessages: replacement,
+    sessionId: nextSessionId
+  };
+}
+function createContextCompactor(deps) {
+  return {
+    maybeCompact: async (args) => await maybeCompactWithDeps(args, deps)
+  };
+}
+
 // src/chat/slack/user.ts
 var USER_CACHE_TTL_MS = 5 * 60 * 1e3;
 var userCache = /* @__PURE__ */ new Map();
@@ -20814,6 +21176,10 @@ function createJuniorRuntimeServices(overrides = {}) {
   const conversationMemory = createConversationMemoryService({
     completeText: overrides.conversationMemory?.completeText ?? completeText
   });
+  const contextCompactor = createContextCompactor({
+    completeText: overrides.contextCompactor?.completeText ?? completeText,
+    autoCompactionTriggerTokens: overrides.contextCompactor?.autoCompactionTriggerTokens
+  });
   const visionContext = createVisionContextService({
     completeText: overrides.visionContext?.completeText ?? completeText,
     listThreadReplies: overrides.visionContext?.listThreadReplies ?? listThreadReplies,
@@ -20821,7 +21187,9 @@ function createJuniorRuntimeServices(overrides = {}) {
   });
   return {
     conversationMemory,
+    contextCompactor,
     replyExecutor: {
+      contextCompactor: overrides.replyExecutor?.contextCompactor ?? contextCompactor,
       generateAssistantReply: overrides.replyExecutor?.generateAssistantReply ?? generateAssistantReply,
       getAwaitingTurnContinuationRequest: overrides.replyExecutor?.getAwaitingTurnContinuationRequest ?? getAwaitingTurnContinuationRequest,
       lookupSlackUser: overrides.replyExecutor?.lookupSlackUser ?? lookupSlackUser,
@@ -20967,7 +21335,7 @@ function buildCanvasRecoveryReply(canvasUrl) {
 async function loadPiMessagesForTurn(args) {
   const fallback = args.fallback.length > 0 ? [...args.fallback] : void 0;
   if (!args.conversationId) {
-    return fallback;
+    return { piMessages: fallback };
   }
   if (args.activeTurnId) {
     const checkpoint2 = await getAgentTurnSessionCheckpoint(
@@ -20975,19 +21343,27 @@ async function loadPiMessagesForTurn(args) {
       args.activeTurnId
     );
     if (checkpoint2?.piMessages.length) {
-      return stripRuntimeTurnContext(
-        trimTrailingAssistantMessages(checkpoint2.piMessages)
-      );
+      return {
+        piMessages: stripRuntimeTurnContext(
+          trimTrailingAssistantMessages(checkpoint2.piMessages)
+        )
+      };
     }
   }
   if (!args.lastSessionId) {
-    return fallback;
+    return { piMessages: fallback };
   }
   const checkpoint = await getAgentTurnSessionCheckpoint(
     args.conversationId,
     args.lastSessionId
   );
-  return checkpoint?.state === "completed" && checkpoint.piMessages.length > 0 ? stripRuntimeTurnContext(checkpoint.piMessages) : fallback;
+  if (checkpoint?.state === "completed" && checkpoint.piMessages.length > 0) {
+    return {
+      compactionSessionId: args.lastSessionId,
+      piMessages: stripRuntimeTurnContext(checkpoint.piMessages)
+    };
+  }
+  return { piMessages: fallback };
 }
 function createReplyToThread(deps) {
   return async function replyToThread(thread, message, options = {}) {
@@ -21218,17 +21594,14 @@ function createReplyToThread(deps) {
           }
         );
         const omittedImageAttachmentCount = !isVisionEnabled() && hasPotentialImageAttachment(message.attachments) ? countPotentialImageAttachments(message.attachments) : 0;
-        const piMessages = await loadPiMessagesForTurn({
-          conversationId,
-          activeTurnId,
-          lastSessionId: lastSessionIdForHistory,
-          fallback: preparedState.conversation.piMessages
-        });
         const status = createSlackAdapterAssistantStatusSession({
           channelId: assistantThreadContext?.channelId,
           threadTs: assistantThreadContext?.threadTs,
           getSlackAdapter: deps.getSlackAdapter
         });
+        const compactingStatus = {
+          text: "Compacting context"
+        };
         const postThreadReply = async (payload, stage) => {
           await beforeFirstResponsePost();
           try {
@@ -21248,24 +21621,52 @@ function createReplyToThread(deps) {
             throw error;
           }
         };
-        status.start();
-        const assistantTitleTask = maybeUpdateAssistantTitle({
-          assistantThreadContext,
-          assistantUserName: botConfig.userName,
-          artifacts: preparedState.artifacts,
-          channelId,
-          conversation: preparedState.conversation,
-          generateThreadTitle: deps.services.generateThreadTitle,
-          getSlackAdapter: deps.getSlackAdapter,
-          modelId: botConfig.fastModelId,
-          requesterId: message.author.userId,
-          runId,
-          threadId
-        });
         let persistedAtLeastOnce = false;
         let shouldPersistFailureState = true;
         let latestArtifacts = preparedState.artifacts;
         try {
+          const loadedPiMessages = await loadPiMessagesForTurn({
+            conversationId,
+            activeTurnId,
+            lastSessionId: lastSessionIdForHistory,
+            fallback: preparedState.conversation.piMessages
+          });
+          let piMessages = loadedPiMessages.piMessages;
+          if (conversationId && loadedPiMessages.compactionSessionId && piMessages?.length) {
+            const compaction = await deps.services.contextCompactor.maybeCompact({
+              conversation: preparedState.conversation,
+              conversationContext: preparedState.routingContext ?? preparedState.conversationContext,
+              conversationId,
+              metadata: {
+                threadId,
+                requesterId: message.author.userId,
+                channelId,
+                runId
+              },
+              onCompactionStart: () => status.start(compactingStatus),
+              previousSessionId: loadedPiMessages.compactionSessionId
+            });
+            if (compaction.compacted) {
+              piMessages = compaction.piMessages;
+              await persistThreadState(thread, {
+                conversation: preparedState.conversation
+              });
+            }
+          }
+          status.start();
+          const assistantTitleTask = maybeUpdateAssistantTitle({
+            assistantThreadContext,
+            assistantUserName: botConfig.userName,
+            artifacts: preparedState.artifacts,
+            channelId,
+            conversation: preparedState.conversation,
+            generateThreadTitle: deps.services.generateThreadTitle,
+            getSlackAdapter: deps.getSlackAdapter,
+            modelId: botConfig.fastModelId,
+            requesterId: message.author.userId,
+            runId,
+            threadId
+          });
           const toolChannelId = preparedState.artifacts.assistantContextChannelId ?? channelId;
           let reply = await deps.services.generateAssistantReply(userText, {
             requester: {

package/dist/chat/app/services.d.ts

@@ -1,15 +1,18 @@
 import { type ConversationMemoryDeps, type ConversationMemoryService } from "@/chat/services/conversation-memory";
+import { type ContextCompactor, type ContextCompactorDeps } from "@/chat/services/context-compaction";
 import { type SubscribedReplyPolicy, type SubscribedReplyPolicyDeps } from "@/chat/services/subscribed-reply-policy";
 import type { ReplyExecutorServices } from "@/chat/runtime/reply-executor";
 import { type VisionContextDeps, type VisionContextService } from "@/chat/services/vision-context";
 export interface JuniorRuntimeServices {
     conversationMemory: ConversationMemoryService;
+    contextCompactor: ContextCompactor;
     replyExecutor: ReplyExecutorServices;
     subscribedReplyPolicy: SubscribedReplyPolicy;
     visionContext: VisionContextService;
 }
 export interface JuniorRuntimeServiceOverrides {
     conversationMemory?: Partial<ConversationMemoryDeps>;
+    contextCompactor?: Partial<ContextCompactorDeps>;
     replyExecutor?: Partial<Omit<ReplyExecutorServices, "generateThreadTitle">>;
     subscribedReplyPolicy?: Partial<SubscribedReplyPolicyDeps>;
     visionContext?: Partial<VisionContextDeps>;

package/dist/chat/config.d.ts

@@ -5,6 +5,7 @@ export interface BotConfig {
     fastModelId: string;
     loadingMessages: string[];
     modelId: string;
+    modelContextWindowTokens?: number;
     visionModelId?: string;
     turnTimeoutMs: number;
     userName: string;

package/dist/chat/pi/client.d.ts

@@ -23,6 +23,7 @@ export declare function completeText(params: {
     modelId: string;
     system?: string;
     messages: Message[];
+    messageAttributeMode?: "content" | "metadata";
     thinkingLevel?: ThinkingLevel;
     temperature?: number;
     maxTokens?: number;

package/dist/chat/runtime/reply-executor.d.ts

@@ -3,9 +3,11 @@ import type { SlackAdapter } from "@chat-adapter/slack";
 import { generateAssistantReply as generateAssistantReplyImpl } from "@/chat/respond";
 import type { PreparedTurnState } from "@/chat/runtime/turn-preparation";
 import { type ConversationMemoryService } from "@/chat/services/conversation-memory";
+import type { ContextCompactor } from "@/chat/services/context-compaction";
 import { lookupSlackUser } from "@/chat/slack/user";
 import type { TurnContinuationRequest } from "@/chat/services/timeout-resume";
 export interface ReplyExecutorServices {
+    contextCompactor: ContextCompactor;
     generateAssistantReply: typeof generateAssistantReplyImpl;
     generateThreadTitle: ConversationMemoryService["generateThreadTitle"];
     getAwaitingTurnContinuationRequest: (args: {

package/dist/chat/services/context-budget.d.ts

@@ -0,0 +1,14 @@
+export interface ModelContextBudget {
+    contextWindow: number;
+    maxTokens: number;
+}
+/** Estimate text tokens with the shared coarse heuristic used for local budgets. */
+export declare function estimateTextTokens(text: string): number;
+/** Derive the automatic compaction threshold from model context capacity. */
+export declare function calculateContextCompactionTriggerTokens(model: ModelContextBudget): number;
+/** Derive the post-compaction target from the automatic trigger threshold. */
+export declare function calculateContextCompactionTargetTokens(triggerTokens: number): number;
+/** Resolve the automatic compaction threshold for the active agent model. */
+export declare function getAgentContextCompactionTriggerTokens(): number;
+/** Resolve the visible conversation compaction threshold for the auxiliary model. */
+export declare function getConversationContextCompactionTriggerTokens(): number;

package/dist/chat/services/context-compaction.d.ts

@@ -0,0 +1,33 @@
+import type { completeText } from "@/chat/pi/client";
+import type { PiMessage } from "@/chat/pi/messages";
+import type { ThreadConversationState } from "@/chat/state/conversation";
+export interface ContextCompactorDeps {
+    completeText: typeof completeText;
+    autoCompactionTriggerTokens?: number;
+}
+export interface ContextCompactor {
+    maybeCompact: (args: CompactContextArgs) => Promise<CompactContextResult>;
+}
+export interface CompactContextArgs {
+    conversation: ThreadConversationState;
+    conversationContext?: string;
+    conversationId: string;
+    onCompactionStart?: () => void;
+    previousSessionId: string;
+    metadata?: {
+        channelId?: string;
+        requesterId?: string;
+        runId?: string;
+        threadId?: string;
+    };
+}
+export interface CompactContextResult {
+    compacted: boolean;
+    piMessages?: PiMessage[];
+    reason?: "below_threshold" | "missing_context" | "not_completed" | "summary_failed";
+    sessionId?: string;
+}
+/** Build retained user messages for a compacted Pi replacement history. */
+export declare function selectRetainedUserMessages(messages: PiMessage[], maxTokens?: number): PiMessage[];
+/** Build the service that owns local context compaction and checkpoint forks. */
+export declare function createContextCompactor(deps: ContextCompactorDeps): ContextCompactor;

package/dist/chat/slack/assistant-thread/status-scheduler.d.ts

@@ -1,7 +1,7 @@
 import { type AssistantStatusSpec } from "@/chat/slack/assistant-thread/status-render";
 export type TimerHandle = ReturnType<typeof setTimeout>;
 export interface AssistantStatusSession {
-    start: () => void;
+    start: (status?: AssistantStatusSpec) => void;
     stop: () => Promise<void>;
     update: (status: AssistantStatusSpec) => void;
 }

package/dist/{chunk-XI3CFWTA.js → chunk-AA5TIFN5.js}

@@ -54,6 +54,35 @@ function getPiGatewayApiKeyOverride() {
 function extractText(message) {
   return (message.content ?? []).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text ?? "").join("").trim();
 }
+function contentMetadata(content) {
+  if (typeof content === "string") {
+    return [{ type: "text", chars: content.length }];
+  }
+  if (!Array.isArray(content)) {
+    return { type: typeof content };
+  }
+  return content.map((part) => {
+    if (!part || typeof part !== "object") {
+      return { type: typeof part };
+    }
+    const record = part;
+    const type = typeof record.type === "string" ? record.type : "unknown";
+    return {
+      type,
+      ...typeof record.text === "string" ? { chars: record.text.length } : {},
+      ...typeof record.mimeType === "string" ? { mimeType: record.mimeType } : {},
+      ...typeof record.mediaType === "string" ? { mediaType: record.mediaType } : {},
+      ...typeof record.data === "string" ? { dataChars: record.data.length } : {}
+    };
+  });
+}
+function toMessageMetadata(message) {
+  const record = message;
+  return {
+    role: record.role,
+    content: contentMetadata(record.content)
+  };
+}
 function parseJsonCandidate(text) {
   const trimmed = text.trim();
   if (!trimmed) return void 0;
@@ -126,8 +155,13 @@ function resolveGatewayModel(modelId) {
 async function completeText(params) {
   const model = resolveGatewayModel(params.modelId);
   const apiKey = getPiGatewayApiKeyOverride();
-  const requestMessagesAttribute = serializeGenAiAttribute(params.messages);
-  const systemInstructionsAttribute = params.system ? serializeGenAiAttribute([{ type: "text", content: params.system }]) : void 0;
+  const messageAttributeMode = params.messageAttributeMode ?? "content";
+  const requestMessagesAttribute = serializeGenAiAttribute(
+    messageAttributeMode === "metadata" ? params.messages.map(toMessageMetadata) : params.messages
+  );
+  const systemInstructionsAttribute = params.system ? serializeGenAiAttribute(
+    messageAttributeMode === "metadata" ? [{ type: "text", chars: params.system.length }] : [{ type: "text", content: params.system }]
+  ) : void 0;
   const baseAttributes = {
     "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
     "gen_ai.operation.name": GEN_AI_OPERATION_CHAT,
@@ -161,12 +195,19 @@ async function completeText(params) {
         }
       );
       const outputText = extractText(message);
-      const outputMessagesAttribute = serializeGenAiAttribute([
-        {
-          role: "assistant",
-          content: outputText ? [{ type: "text", text: outputText }] : []
-        }
-      ]);
+      const outputMessagesAttribute = serializeGenAiAttribute(
+        messageAttributeMode === "metadata" ? [
+          {
+            role: "assistant",
+            content: outputText ? [{ type: "text", chars: outputText.length }] : []
+          }
+        ] : [
+          {
+            role: "assistant",
+            content: outputText ? [{ type: "text", text: outputText }] : []
+          }
+        ]
+      );
       const usageAttributes = extractGenAiUsageAttributes(message);
       const endAttributes = {
         ...baseAttributes,
@@ -336,6 +377,17 @@ function parseAdvisorThinkingLevel(rawValue) {
     `AI_ADVISOR_THINKING_LEVEL must be one of: minimal, low, medium, high, xhigh`
   );
 }
+function parseOptionalPositiveInteger(envName, rawValue) {
+  const trimmed = toOptionalTrimmed(rawValue);
+  if (trimmed === void 0) {
+    return void 0;
+  }
+  const value = Number.parseInt(trimmed, 10);
+  if (!Number.isSafeInteger(value) || value <= 0 || String(value) !== trimmed) {
+    throw new Error(`${envName} must be a positive integer`);
+  }
+  return value;
+}
 var DEFAULT_MODEL_ID = getModel("vercel-ai-gateway", "openai/gpt-5.4").id;
 var DEFAULT_FAST_MODEL_ID = getModel(
   "vercel-ai-gateway",
@@ -363,6 +415,10 @@ function readBotConfig(env) {
   return {
     userName: env.JUNIOR_BOT_NAME ?? "junior",
     modelId: validateGatewayModelId(env.AI_MODEL) ?? DEFAULT_MODEL_ID,
+    modelContextWindowTokens: parseOptionalPositiveInteger(
+      "AI_MODEL_CONTEXT_WINDOW_TOKENS",
+      env.AI_MODEL_CONTEXT_WINDOW_TOKENS
+    ),
     fastModelId: validateGatewayModelId(env.AI_FAST_MODEL ?? env.AI_MODEL) ?? DEFAULT_FAST_MODEL_ID,
     loadingMessages: parseLoadingMessages(env.JUNIOR_LOADING_MESSAGES),
     visionModelId: validateGatewayModelId(env.AI_VISION_MODEL),

package/dist/cli/snapshot-warmup.js

@@ -1,7 +1,7 @@
 import {
   disconnectStateAdapter,
   resolveRuntimeDependencySnapshot
-} from "../chunk-XI3CFWTA.js";
+} from "../chunk-AA5TIFN5.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -46,7 +46,7 @@
     "node-html-markdown": "^2.0.0",
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.55.0"
+    "@sentry/junior-plugin-api": "0.56.0"
   },
   "peerDependencies": {
     "@sentry/node": ">=10.0.0"