@sentry/junior 0.187.0 → 0.189.0

package/dist/{chunk-6FKNNUSN.js → chunk-PCPSX4ES.js}

@@ -1,3 +1,6 @@
+import {
+  isExperimentalFeatureEnabled
+} from "./chunk-2LYHWMR4.js";
 import {
   SlackActionError,
   applyPluginFormatMarkdown,
@@ -5,19 +8,19 @@ import {
   isDmChannel,
   normalizeSlackConversationId,
   withSlackRetries
-} from "./chunk-DUE4EUNL.js";
+} from "./chunk-MI6ZBDTS.js";
 import {
   parseDestination
-} from "./chunk-WKIS4VRK.js";
+} from "./chunk-CUYFCI4G.js";
 import {
   getStateAdapter
-} from "./chunk-U6ZQHRIP.js";
+} from "./chunk-5CXCGDIL.js";
 import {
   normalizeSlackEmojiName
-} from "./chunk-URZ7UD4P.js";
+} from "./chunk-BYBSI5TI.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-QH3I7ZOK.js";
+} from "./chunk-E3PDZPGV.js";
 import {
   parseSlackMessageTs,
   parseSlackUserId
@@ -26,7 +29,198 @@ import {
   isRecord,
   logInfo,
   logWarn
-} from "./chunk-6YCIYOVA.js";
+} from "./chunk-PY3EIEAF.js";
+
+// src/chat/agent/types.ts
+var RetryableDeliveryError = class extends Error {
+  constructor(cause) {
+    super("Assistant delivery was transient or ambiguous", { cause });
+    this.name = "RetryableDeliveryError";
+  }
+};
+function isAgentRunFeatureDisabled(disabledFeatures, feature) {
+  return disabledFeatures?.includes(feature) ?? false;
+}
+function actorFromRun(run) {
+  if (run.dispatch?.actor) {
+    return run.dispatch.actor;
+  }
+  if (run.actor) {
+    return run.actor;
+  }
+  if (run.credentialContext && !("type" in run.credentialContext.actor)) {
+    return run.credentialContext.actor;
+  }
+  return void 0;
+}
+function assertRunConsistency(run) {
+  const { destination, source } = run;
+  switch (source.platform) {
+    case "slack": {
+      if (destination.platform !== "slack") {
+        throw new TypeError(
+          "Run source and destination platforms do not match"
+        );
+      }
+      if (source.teamId !== destination.teamId) {
+        throw new TypeError("Slack source and destination teams do not match");
+      }
+      break;
+    }
+    case "local": {
+      if (destination.platform !== "local") {
+        throw new TypeError(
+          "Run source and destination platforms do not match"
+        );
+      }
+      if (source.conversationId !== destination.conversationId) {
+        throw new TypeError(
+          "Source and destination conversation IDs do not match"
+        );
+      }
+      if (run.surface !== "internal" && destination.conversationId !== run.conversationId) {
+        throw new TypeError(
+          "Source, destination, and run conversation IDs do not match"
+        );
+      }
+      break;
+    }
+    case "web": {
+      if (run.surface !== "internal" && source.conversationId !== run.conversationId) {
+        throw new TypeError("Web source and run conversation IDs do not match");
+      }
+      switch (destination.platform) {
+        case "local": {
+          if (source.conversationId !== destination.conversationId) {
+            throw new TypeError(
+              "Source and destination conversation IDs do not match"
+            );
+          }
+          if (run.surface !== "internal" && destination.conversationId !== run.conversationId) {
+            throw new TypeError(
+              "Source, destination, and run conversation IDs do not match"
+            );
+          }
+          break;
+        }
+        case "slack":
+          break;
+      }
+      break;
+    }
+  }
+  const actor = run.dispatch?.actor ?? run.actor;
+  if (!actor || actor.platform === "system") {
+    return;
+  }
+  if (actor.platform !== source.platform) {
+    throw new TypeError(
+      `Actor platform "${actor.platform}" does not match Source platform "${source.platform}"`
+    );
+  }
+  if (actor.platform === "slack" && source.platform === "slack" && actor.teamId !== source.teamId) {
+    throw new TypeError("Slack Actor team does not match Source team");
+  }
+}
+function toolInvocationDestination(run) {
+  if (run.destination.platform !== "slack" || !run.toolChannelId) {
+    return run.destination;
+  }
+  return {
+    platform: "slack",
+    teamId: run.destination.teamId,
+    channelId: run.toolChannelId
+  };
+}
+function surfaceFromRun(run) {
+  if (run.surface) {
+    return run.surface;
+  }
+  if (run.source.platform === "slack") {
+    return "slack";
+  }
+  if (run.source.platform === "web") {
+    return "api";
+  }
+  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);
+    }
+  }
+}
 
 // src/chat/slack/outbound.ts
 var MAX_SLACK_MESSAGE_TEXT_CHARS = 4e4;
@@ -705,6 +899,12 @@ async function startOAuthFlow(provider, input) {
 }
 
 export {
+  RetryableDeliveryError,
+  isAgentRunFeatureDisabled,
+  actorFromRun,
+  assertRunConsistency,
+  toolInvocationDestination,
+  surfaceFromRun,
   getSlackMessagePermalink,
   postSlackMessage,
   uploadFilesToConversation,
@@ -719,5 +919,7 @@ export {
   formatProviderLabel,
   resolveBaseUrl,
   deliverOAuthAuthorization,
-  startOAuthFlow
+  startOAuthFlow,
+  createAgentRunner,
+  runAgentWithTimeout
 };

package/dist/{chunk-6YCIYOVA.js → chunk-PY3EIEAF.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-PEQXYSSE.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-7LRRVMPH.js";
+} from "./chunk-NY2F7BZA.js";
 
 // src/deployment.ts
 var JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";