@sentry/junior 0.61.0 → 0.62.0

package/dist/app.js

@@ -6585,15 +6585,22 @@ function summarizeMessageText(text) {
   }
   return normalized.length > 1200 ? `${normalized.slice(0, 1200)}...` : normalized;
 }
+function isStructuredThreadContext(context) {
+  return /^<thread-(compactions|transcript)>/.test(context);
+}
+function renderThreadContextForPrompt(context) {
+  if (isStructuredThreadContext(context)) {
+    return context;
+  }
+  return ["<thread-background>", context, "</thread-background>"].join("\n");
+}
 function buildUserTurnText(userInput, conversationContext) {
   const trimmedContext = conversationContext?.trim();
   if (!trimmedContext) {
     return userInput;
   }
   return [
-    "<thread-background>",
-    trimmedContext,
-    "</thread-background>",
+    renderThreadContextForPrompt(trimmedContext),
     "",
     "<current-instruction>",
     userInput,
@@ -8619,6 +8626,7 @@ async function syncSkillsToSandbox(params) {
 
 // src/chat/sandbox/session.ts
 var DEFAULT_MAX_OUTPUT_LENGTH = 3e4;
+var DEFAULT_BASH_COMMAND_TIMEOUT_MS = 5 * 60 * 1e3;
 var SANDBOX_RUNTIME = "node22";
 var SANDBOX_RUNTIME_BIN_DIR = `${SANDBOX_WORKSPACE_ROOT}/.junior/bin`;
 var SNAPSHOT_BOOT_RETRY_COUNT = 3;
@@ -8691,6 +8699,16 @@ function getCommandStreamInterruptedResult() {
     stderrTruncated: false
   };
 }
+function getCommandAbortedResult() {
+  return {
+    stdout: "",
+    stderr: "Command aborted because the agent turn was cancelled.",
+    exitCode: 130,
+    stdoutTruncated: false,
+    stderrTruncated: false,
+    aborted: true
+  };
+}
 function createSandboxSessionManager(options) {
   let sandbox = null;
   let sandboxIdHint = options?.sandboxId;
@@ -8946,7 +8964,9 @@ function createSandboxSessionManager(options) {
       "sandbox_hint_discarded_profile_mismatch",
       traceContext,
       {
-        ...options?.sandboxDependencyProfileHash ? { "app.sandbox.previous_profile_hash": options.sandboxDependencyProfileHash } : {},
+        ...options?.sandboxDependencyProfileHash ? {
+          "app.sandbox.previous_profile_hash": options.sandboxDependencyProfileHash
+        } : {},
         ...dependencyProfileHash ? { "app.sandbox.current_profile_hash": dependencyProfileHash } : {}
       },
       "Dependency profile changed; discarding sandbox hint and creating fresh session"
@@ -9114,37 +9134,63 @@ function createSandboxSessionManager(options) {
     return {
       bash: async (input) => {
         let timedOut = false;
+        let aborted = false;
         let timeoutId;
+        let onAbort;
         try {
+          if (input.signal?.aborted) {
+            return getCommandAbortedResult();
+          }
           await refreshNetworkPolicy(sandboxInstance);
+          if (input.signal?.aborted) {
+            return getCommandAbortedResult();
+          }
           const sandboxCommandEnv = await resolveCommandEnv();
+          if (input.signal?.aborted) {
+            return getCommandAbortedResult();
+          }
           const script = buildNonInteractiveShellScript(input.command, {
             env: { ...sandboxCommandEnv, ...input.env ?? {} },
             pathPrefix: `${SANDBOX_RUNTIME_BIN_DIR}:$PATH`
           });
-          const controller = input.timeoutMs && input.timeoutMs > 0 ? new AbortController() : void 0;
-          timeoutId = controller ? setTimeout(() => {
+          const controller = new AbortController();
+          const timeoutMs2 = input.timeoutMs && input.timeoutMs > 0 ? input.timeoutMs : DEFAULT_BASH_COMMAND_TIMEOUT_MS;
+          onAbort = () => {
+            aborted = true;
+            controller.abort(input.signal?.reason);
+          };
+          if (input.signal) {
+            input.signal.addEventListener("abort", onAbort, { once: true });
+            if (input.signal.aborted) {
+              onAbort();
+            }
+          }
+          timeoutId = setTimeout(() => {
             timedOut = true;
             controller.abort();
-          }, input.timeoutMs) : void 0;
+          }, timeoutMs2);
+          timeoutId.unref?.();
           const commandResult2 = await sandboxInstance.runCommand({
             cmd: "bash",
             args: ["-c", script],
             cwd: SANDBOX_WORKSPACE_ROOT,
-            ...controller ? { signal: controller.signal } : {}
+            signal: controller.signal
           });
           return await readCommandOutput(commandResult2);
         } catch (error) {
           if (timedOut) {
             return {
               stdout: "",
-              stderr: `Command timed out after ${input.timeoutMs}ms`,
+              stderr: `Command timed out after ${input.timeoutMs && input.timeoutMs > 0 ? input.timeoutMs : DEFAULT_BASH_COMMAND_TIMEOUT_MS}ms`,
               exitCode: 124,
               stdoutTruncated: false,
               stderrTruncated: false,
               timedOut: true
             };
           }
+          if (aborted || input.signal?.aborted) {
+            return getCommandAbortedResult();
+          }
           if (isSandboxCommandStreamInterruptedError(error)) {
             return getCommandStreamInterruptedResult();
           }
@@ -9153,6 +9199,9 @@ function createSandboxSessionManager(options) {
           if (timeoutId) {
             clearTimeout(timeoutId);
           }
+          if (input.signal && onAbort) {
+            input.signal.removeEventListener("abort", onAbort);
+          }
         }
       },
       readFile: async (input) => await executeReadFile(input, {
@@ -9328,7 +9377,7 @@ function createSandboxExecutor(options) {
       "Sandbox boot requested"
     );
   };
-  const executeBashTool = async (rawInput, command) => {
+  const executeBashTool = async (rawInput, command, signal) => {
     const env = parseEnv(rawInput.env);
     const timeoutMs = positiveInteger(rawInput.timeoutMs);
     logSandboxBootRequest("tool.bash", {
@@ -9346,7 +9395,8 @@ function createSandboxExecutor(options) {
           const response = await executeBash({
             command,
             ...env ? { env } : {},
-            ...timeoutMs ? { timeoutMs } : {}
+            ...timeoutMs ? { timeoutMs } : {},
+            ...signal ? { signal } : {}
           });
           setSpanAttributes({
             "process.exit.code": response.exitCode,
@@ -9616,7 +9666,7 @@ function createSandboxExecutor(options) {
           return { result: custom.result };
         }
       }
-      return await executeBashTool(rawInput, bashCommand);
+      return await executeBashTool(rawInput, bashCommand, params.signal);
     }
     try {
       if (params.toolName === "readFile") {
@@ -10455,7 +10505,7 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
     parameters: toolDef.inputSchema,
     prepareArguments: toolDef.prepareArguments,
     executionMode: toolDef.executionMode,
-    execute: async (toolCallId, params) => {
+    execute: async (toolCallId, params, signal) => {
       const normalizedToolCallId = typeof toolCallId === "string" && toolCallId.length > 0 ? toolCallId : void 0;
       const toolArgumentsAttribute = serializeToolPayload(params);
       const toolArgumentsMetadata = toGenAiPayloadTraceAttributes(
@@ -10503,9 +10553,11 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
             const isSandbox = Boolean(sandboxExecutor?.canExecute(toolName));
             const result = isSandbox ? await sandboxExecutor.execute({
               toolName,
-              input: sandboxInput
+              input: sandboxInput,
+              ...signal ? { signal } : {}
             }) : await toolDef.execute(toolInput, {
-              experimental_context: sandbox
+              experimental_context: sandbox,
+              ...signal ? { signal } : {}
             });
             const normalized = normalizeToolResult(result, isSandbox);
             if (bashCommand && pluginAuthOrchestration) {
@@ -11484,13 +11536,13 @@ function buildClassifierSystemPrompt() {
     "Choose exactly one bucket: none, low, medium, high, or xhigh.",
     "",
     "Use none only for greetings, acknowledgments, and turns that need no substantive assistant work.",
-    "Use low rarely: only for deterministic one-step answers or transformations with no tools, no current/external facts, no thread-background interpretation, and no source verification.",
+    "Use low rarely: only for deterministic one-step answers or transformations with no tools, no current/external facts, no prior thread-context interpretation, and no source verification.",
     "Use medium for normal assistant work: explanations, source-backed checks, thread follow-ups, tool choice, likely tool use, ambiguous asks, multi-step analysis, or anything where a confident but shallow answer would be risky.",
     "Use high for research-heavy work, non-trivial drafting, or explicit requests to be thorough.",
     "Use xhigh for the most complex tasks: code changes, debugging/root-cause analysis, broad refactors, architecture decisions, multi-file implementation, or any task where deep reasoning across multiple systems or files is required.",
     "When unsure between two non-none buckets, choose the higher bucket. Do not use low as the default.",
     "",
-    "Classify based on the substance of the task, not the length of the current message. When the current instruction is a short affirmation (for example: 'go', 'do it', 'yes please', 'proceed') and the thread-background contains a pending task, classify the pending task \u2014 not the affirmation.",
+    "Classify based on the substance of the task, not the length of the current message. When the current instruction is a short affirmation (for example: 'go', 'do it', 'yes please', 'proceed') and prior thread context contains a pending task, classify the pending task \u2014 not the affirmation.",
     "",
     "Return JSON only with thinking_level, confidence, and reason.",
     "confidence must be a number from 0 to 1, not a word label."
@@ -11499,12 +11551,17 @@ function buildClassifierSystemPrompt() {
 function buildClassifierPrompt(args) {
   const sections = [];
   if (args.conversationContext) {
-    sections.push(
-      "<thread-background>",
-      args.conversationContext.text,
-      "</thread-background>",
-      ""
-    );
+    const contextText = args.conversationContext.text;
+    if (/^<thread-(compactions|transcript)>/.test(contextText)) {
+      sections.push(contextText, "");
+    } else {
+      sections.push(
+        "<thread-background>",
+        contextText,
+        "</thread-background>",
+        ""
+      );
+    }
   }
   sections.push(
     "<current-instruction>",
@@ -12296,9 +12353,38 @@ function createMcpAuthOrchestration(deps, abortAgent) {
 
 // src/chat/respond.ts
 var PROVIDER_RETRY_DELAYS_MS = [1e3, 2e3];
+var AGENT_ABORT_SETTLE_GRACE_MS = 5e3;
 function sleep3(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function waitForAbortSettlement(promise, timeoutMs) {
+  return new Promise((resolve) => {
+    let done = false;
+    const timeoutId = setTimeout(() => {
+      if (!done) {
+        done = true;
+        resolve(false);
+      }
+    }, timeoutMs);
+    timeoutId.unref?.();
+    promise.then(
+      () => {
+        if (!done) {
+          done = true;
+          clearTimeout(timeoutId);
+          resolve(true);
+        }
+      },
+      () => {
+        if (!done) {
+          done = true;
+          clearTimeout(timeoutId);
+          resolve(true);
+        }
+      }
+    );
+  });
+}
 var startupDiscoveryLogged = false;
 var MAX_ROUTER_ATTACHMENT_PREVIEW_CHARS = 2e3;
 function buildOmittedImageAttachmentNotice(count) {
@@ -13054,8 +13140,20 @@ async function generateAssistantReply(messageText2, context = {}) {
                   },
                   "Agent turn timed out and was aborted"
                 );
-                await run2.catch(() => {
-                });
+                const settled = await waitForAbortSettlement(
+                  run2,
+                  AGENT_ABORT_SETTLE_GRACE_MS
+                );
+                if (!settled) {
+                  logWarn(
+                    "agent_turn_abort_settle_timeout",
+                    {},
+                    {
+                      "app.ai.abort_settle_grace_ms": AGENT_ABORT_SETTLE_GRACE_MS
+                    },
+                    "Timed-out agent run did not settle after abort before resume snapshot"
+                  );
+                }
                 timeoutResumeMessages = [...agent.state.messages];
               }
               if (getPendingAuthPause()) {
@@ -13447,20 +13545,25 @@ function buildConversationContext(conversation, options = {}) {
         "  </compaction>"
       );
     }
-    lines.push("</thread-compactions>", "");
+    lines.push("</thread-compactions>");
   }
-  lines.push("<thread-transcript>");
-  for (const [index, message] of messages.entries()) {
-    const author = escapeXml(message.author?.userName ?? message.role);
-    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}"${slackTsAttr}>`,
-      renderConversationMessageLine(message, conversation),
-      "  </message>"
-    );
+  if (messages.length > 0) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push("<thread-transcript>");
+    for (const [index, message] of messages.entries()) {
+      const author = escapeXml(message.author?.userName ?? message.role);
+      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}"${slackTsAttr}>`,
+        renderConversationMessageLine(message, conversation),
+        "  </message>"
+      );
+    }
+    lines.push("</thread-transcript>");
   }
-  lines.push("</thread-transcript>");
   return lines.join("\n");
 }
 function pruneCompactions(compactions) {
@@ -20117,7 +20220,7 @@ function createReplyToThread(deps) {
           if (conversationId && loadedPiMessages.canCompact && piMessages?.length) {
             const compaction = await deps.services.contextCompactor.maybeCompact({
               conversation: preparedState.conversation,
-              conversationContext: preparedState.routingContext ?? preparedState.conversationContext,
+              conversationContext: preparedState.conversationContext,
               conversationId,
               metadata: {
                 threadId,
@@ -20159,7 +20262,7 @@ function createReplyToThread(deps) {
                 fullName: message.author.fullName ?? fallbackIdentity?.fullName,
                 email: fallbackIdentity?.email
               },
-              conversationContext: preparedState.routingContext ?? preparedState.conversationContext,
+              conversationContext: preparedState.conversationContext,
               artifactState: preparedState.artifacts,
               piMessages,
               pendingAuth: preparedState.conversation.processing.pendingAuth,
@@ -20720,8 +20823,7 @@ function createPrepareTurnState(deps) {
       requesterId: args.context.requesterId,
       runId: args.context.runId
     });
-    const conversationContext = buildConversationContext(conversation);
-    const routingContext = buildConversationContext(conversation, {
+    const conversationContext = buildConversationContext(conversation, {
       excludeMessageId: userMessageId
     });
     setSpanAttributes({
@@ -20736,7 +20838,6 @@ function createPrepareTurnState(deps) {
       sandboxId: existingSandboxId,
       sandboxDependencyProfileHash: existingSandboxDependencyProfileHash,
       conversationContext,
-      routingContext,
       userMessageId
     };
   };
@@ -20783,7 +20884,7 @@ function createSlackRuntime(options) {
         conversation: preparedState.conversation
       });
     },
-    getPreparedConversationContext: (preparedState) => preparedState.routingContext ?? preparedState.conversationContext,
+    getPreparedConversationContext: (preparedState) => preparedState.conversationContext,
     decideSubscribedReply: services.subscribedReplyPolicy,
     recordSkippedSubscribedMessage: async ({
       thread,

package/dist/chat/respond-helpers.d.ts

@@ -44,7 +44,7 @@ export declare function toObservablePromptPart(part: {
 export declare function summarizeMessageText(text: string): string;
 /**
  * Put prior thread text before the current instruction when no Pi history
- * exists. These are top-level sibling blocks in the user message.
+ * exists. Structured thread XML is already a top-level prompt block.
  */
 export declare function buildUserTurnText(userInput: string, conversationContext?: string): string;
 /** Encode a non-image attachment as base64 XML for the prompt. */

package/dist/chat/runtime/turn-preparation.d.ts

@@ -8,7 +8,6 @@ export interface PreparedTurnState {
     channelConfiguration?: ChannelConfigurationService;
     conversation: ThreadConversationState;
     conversationContext?: string;
-    routingContext?: string;
     sandboxId?: string;
     sandboxDependencyProfileHash?: string;
     userMessageId?: string;

package/dist/chat/sandbox/sandbox.d.ts

@@ -5,6 +5,7 @@ import type { SkillMetadata } from "@/chat/skills";
 interface SandboxExecutionInput {
     toolName: string;
     input: unknown;
+    signal?: AbortSignal;
 }
 export interface SandboxExecutionEnvelope<T = unknown> {
     result: T;

package/dist/chat/sandbox/session.d.ts

@@ -6,6 +6,7 @@ interface SandboxToolExecutors {
     bash: (input: {
         command: string;
         env?: Record<string, string>;
+        signal?: AbortSignal;
         timeoutMs?: number;
     }) => Promise<{
         stdout: string;
@@ -13,6 +14,7 @@ interface SandboxToolExecutors {
         exitCode: number;
         stdoutTruncated: boolean;
         stderrTruncated: boolean;
+        aborted?: boolean;
         timedOut?: boolean;
     }>;
     readFile: (input: {

package/dist/chat/tools/definition.d.ts

@@ -21,6 +21,7 @@ export interface ToolDefinition<TInputSchema extends TSchema = TSchema> {
     executionMode?: ToolExecutionMode;
     execute?: (input: Static<TInputSchema>, options: {
         experimental_context?: unknown;
+        signal?: AbortSignal;
     }) => Promise<unknown> | unknown;
 }
 /** Infer execute parameter types from the inputSchema via generic binding. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.61.0",
+  "version": "0.62.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -64,7 +64,7 @@
     "node-html-markdown": "^2.0.0",
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.61.0"
+    "@sentry/junior-plugin-api": "0.62.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
@@ -76,7 +76,7 @@
     "typescript": "^6.0.3",
     "vercel": "^54.4.0",
     "vitest": "^4.1.7",
-    "@sentry/junior-scheduler": "0.61.0"
+    "@sentry/junior-scheduler": "0.62.0"
   },
   "scripts": {
     "build": "tsup && tsc -p tsconfig.build.json --emitDeclarationOnly",