@sentry/junior 0.184.0 → 0.186.0

package/dist/{chunk-2ZQPVX7C.js → chunk-H7X2G2KS.js}

@@ -2,39 +2,38 @@ import {
   usageSchema
 } from "./chunk-PDO5BLNM.js";
 import {
-  ToolInputError
-} from "./chunk-4CNDGK25.js";
-import {
-  agentHistoryItemSchema,
   bindProviderConversation,
-  contextProvenance,
   createSqlConversationEventStore,
   getConversationEventStore,
   getConversationStore,
   getSqlExecutor,
-  instructionActors,
-  instructionProvenanceFor,
   sanitizePostgresJson,
   withConversationEventLock
-} from "./chunk-IZDYYYGP.js";
+} from "./chunk-43LODHJM.js";
 import {
   SANDBOX_REPOS_ROOT,
   SANDBOX_WORKSPACE_ROOT,
   sleep
-} from "./chunk-SHJK75Z2.js";
+} from "./chunk-HWXP6RHG.js";
 import {
   MUTATION_LOCK_TTL_MS,
   fenceLock,
   getStateAdapter,
   withLock
-} from "./chunk-DUKIDPF6.js";
+} from "./chunk-DOP3FIQC.js";
+import {
+  agentHistoryItemSchema,
+  contextProvenance,
+  instructionActors,
+  instructionProvenanceFor
+} from "./chunk-GFBR4S3Q.js";
 import {
   botConfig,
   completeText,
   escapeXml,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-6UDPINOX.js";
+} from "./chunk-AD64YMEC.js";
 import {
   parseSlackMessageTs,
   toStoredSlackActor
@@ -44,7 +43,7 @@ import {
   logException,
   logWarn,
   setSpanAttributes
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-3CVEE6LA.js";
 
 // src/chat/turn-context-tag.ts
 var TURN_CONTEXT_TAG = "runtime-turn-context";
@@ -1746,6 +1745,16 @@ import path2 from "path";
 
 // src/chat/tools/sandbox/file-utils.ts
 import path from "path";
+
+// src/chat/tools/execution/tool-input-error.ts
+var ToolInputError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ToolInputError";
+  }
+};
+
+// src/chat/tools/sandbox/file-utils.ts
 var MAX_TEXT_CHARS = 6e4;
 var RIPGREP_EXCLUDED_GLOBS = [
   "!**/.git/**",
@@ -2299,6 +2308,9 @@ async function recordConversationActivityMetadata(args) {
   });
   const isChild = Boolean(conversation?.lineage);
   const destination = isChild ? void 0 : args.destination;
+  if (!isChild && !destination && !conversation) {
+    return;
+  }
   const activitySource = isChild ? "internal" : args.source?.platform === "web" ? "web" : destination?.platform === "local" ? "local" : destination ? args.summary.surface : void 0;
   await conversationStore.recordActivity({
     activityAtMs: args.summary.updatedAtMs,
@@ -3133,6 +3145,7 @@ export {
   recordToolExecutionStarted,
   recordAttachmentsDelivered,
   recordGuardianActionReviewed,
+  ToolInputError,
   MAX_TEXT_CHARS,
   RIPGREP_EXCLUDED_GLOBS,
   DEFAULT_SEARCH_COMMAND_TIMEOUT_MS,

package/dist/{chunk-WQFEWULF.js → chunk-HKFLRIBD.js}

@@ -1,12 +1,12 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-PJPRXO2T.js";
+} from "./chunk-NRMAOGRS.js";
 import {
   skillRoots
 } from "./chunk-TXKUKMVO.js";
 import {
   logWarn
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-3CVEE6LA.js";
 
 // src/chat/skills.ts
 import fs from "fs/promises";

package/dist/{chunk-SHJK75Z2.js → chunk-HWXP6RHG.js}

@@ -1,13 +1,13 @@
 import {
   toOptionalTrimmed
-} from "./chunk-6UDPINOX.js";
+} from "./chunk-AD64YMEC.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-PJPRXO2T.js";
+} from "./chunk-NRMAOGRS.js";
 import {
   setSpanAttributes,
   setSpanStatus
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-3CVEE6LA.js";
 
 // src/chat/sandbox/paths.ts
 function normalizeWorkspaceRoot(input) {
@@ -399,6 +399,32 @@ function getVercelSandboxCredentials() {
   return void 0;
 }
 
+// src/chat/sandbox/snapshot/not-ready-error.ts
+var WorkspaceSnapshotNotReadyError = class extends Error {
+  workspaceName;
+  constructor(workspaceName) {
+    super(`Workspace ${workspaceName} snapshot is not ready`);
+    this.name = "WorkspaceSnapshotNotReadyError";
+    this.workspaceName = workspaceName;
+  }
+};
+function getWorkspaceSnapshotNotReadyError(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current instanceof Error && !seen.has(current)) {
+    if (current instanceof WorkspaceSnapshotNotReadyError) return current;
+    seen.add(current);
+    current = current.cause;
+  }
+  return void 0;
+}
+function isWorkspaceSnapshotNotReadyError(error) {
+  return getWorkspaceSnapshotNotReadyError(error) !== void 0;
+}
+function workspaceSnapshotNotReadyUserMessage(error) {
+  return `The ${error.workspaceName} workspace is still preparing its sandbox. Wait for that preparation to finish, then try again.`;
+}
+
 // src/chat/sandbox/http-error-details.ts
 var DEFAULT_PREVIEW_LIMIT = 512;
 function toTrimmedString(value, maxChars) {
@@ -591,7 +617,7 @@ function isAbortError(error) {
     if (!(candidate instanceof Error)) return false;
     if (candidate.name === "AbortError") return true;
     const message = candidate.message.toLowerCase();
-    return message === "api turn cancelled" || message === "api turn canceled" || message.startsWith("executeagentrun timed out after");
+    return message.startsWith("executeagentrun timed out after");
   });
 }
 function isSandboxApiTransientError(error) {
@@ -615,6 +641,10 @@ function isSandboxCommandStreamInterruptedError(error) {
   });
 }
 function wrapSandboxSetupError(error) {
+  const notReady = getWorkspaceSnapshotNotReadyError(error);
+  if (notReady) {
+    return notReady;
+  }
   try {
     const details = getSandboxErrorDetails(error);
     if (details.summary) {
@@ -667,6 +697,10 @@ export {
   buildNonInteractiveShellScript,
   runNonInteractiveCommand,
   getVercelSandboxCredentials,
+  WorkspaceSnapshotNotReadyError,
+  getWorkspaceSnapshotNotReadyError,
+  isWorkspaceSnapshotNotReadyError,
+  workspaceSnapshotNotReadyUserMessage,
   isAlreadyExistsError,
   isSandboxUnavailableError,
   isSandboxMissingError,

package/dist/{chunk-RF6J3DIO.js → chunk-INQHUE72.js}

@@ -1,3 +1,7 @@
+import {
+  isExperimentalFeatureEnabled
+} from "./chunk-2LYHWMR4.js";
+
 // src/chat/agent/types.ts
 var RetryableDeliveryError = class extends Error {
   constructor(cause) {
@@ -124,11 +128,90 @@ function surfaceFromRun(run) {
   return "internal";
 }
 
+// src/chat/runtime/agent-runner.ts
+var AGENT_ABORT_SETTLE_GRACE_MS = 5e3;
+function createAgentRunner(execute, options) {
+  const attachmentStorage = options?.attachmentStorage;
+  const streamFn = options?.streamFn;
+  const tracePropagation = options?.tracePropagation;
+  const bindSpawnAgent = options?.bindSpawnAgent;
+  const canBindSpawn = Boolean(bindSpawnAgent) && isExperimentalFeatureEnabled("subagents");
+  return {
+    run: async (run) => {
+      const spawnAgent = bindSpawnAgent && canBindSpawn && !isAgentRunFeatureDisabled(run.disabledFeatures, "subagents") ? bindSpawnAgent(run) : void 0;
+      const nextRun = {
+        ...run,
+        environment: {
+          ...run.environment,
+          attachmentStorage: run.environment?.attachmentStorage ?? attachmentStorage,
+          sandboxTracePropagation: run.environment?.sandboxTracePropagation ?? tracePropagation
+        },
+        ...spawnAgent ? {
+          durability: {
+            ...run.durability,
+            spawnAgent
+          }
+        } : void 0
+      };
+      return await execute(nextRun, streamFn);
+    }
+  };
+}
+async function waitForAgentSettlement(runPromise) {
+  let timeoutId;
+  const settleGrace = new Promise((resolve) => {
+    timeoutId = setTimeout(resolve, AGENT_ABORT_SETTLE_GRACE_MS);
+    timeoutId.unref?.();
+  });
+  await Promise.race([
+    runPromise.then(
+      () => void 0,
+      () => void 0
+    ),
+    settleGrace
+  ]);
+  if (timeoutId) {
+    clearTimeout(timeoutId);
+  }
+}
+async function runAgentWithTimeout(agentRunner, run, timeoutMs) {
+  if (typeof timeoutMs !== "number") {
+    return await agentRunner.run(run);
+  }
+  const timeoutError = new Error(
+    `executeAgentRun timed out after ${timeoutMs}ms`
+  );
+  const abortController = new AbortController();
+  const signal = run.signal ? AbortSignal.any([run.signal, abortController.signal]) : abortController.signal;
+  const runPromise = agentRunner.run({ ...run, signal });
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      abortController.abort(timeoutError);
+      reject(timeoutError);
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([runPromise, timeoutPromise]);
+  } catch (error) {
+    if (abortController.signal.aborted) {
+      await waitForAgentSettlement(runPromise);
+    }
+    throw error;
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+
 export {
   RetryableDeliveryError,
   isAgentRunFeatureDisabled,
   actorFromRun,
   assertRunConsistency,
   toolInvocationDestination,
-  surfaceFromRun
+  surfaceFromRun,
+  createAgentRunner,
+  runAgentWithTimeout
 };