@sentry/junior 0.136.1 → 0.138.0

package/dist/{chunk-3SUK3UXX.js → chunk-ELKW5FIB.js}

@@ -3,19 +3,19 @@ import {
 } from "./chunk-UTL3MHPC.js";
 import {
   parseSlackThreadId
-} from "./chunk-TYNMSQKA.js";
+} from "./chunk-FNLBTB4K.js";
 import {
   normalizeSlackConversationId
-} from "./chunk-KLBYCSLJ.js";
+} from "./chunk-TCS76X5D.js";
 import {
   getDb
-} from "./chunk-HIRIWTWD.js";
+} from "./chunk-SIPKWSXK.js";
 import {
   juniorTaskExecutions
-} from "./chunk-MW2QRPGW.js";
+} from "./chunk-DCLLQGS6.js";
 import {
   logWarn
-} from "./chunk-XWPA5KZF.js";
+} from "./chunk-JNNJZURV.js";
 
 // src/handlers/health.ts
 function readHealthReport() {

package/dist/chunk-EM225ITJ.js

@@ -0,0 +1,56 @@
+// src/chat/sandbox/paths.ts
+function normalizeWorkspaceRoot(input) {
+  const candidate = (input ?? "").trim();
+  if (!candidate) {
+    return "/vercel/sandbox";
+  }
+  const normalized = candidate.replace(/\/+$/, "");
+  return normalized.startsWith("/") ? normalized : `/${normalized}`;
+}
+var SANDBOX_WORKSPACE_ROOT = normalizeWorkspaceRoot(
+  process.env.VERCEL_SANDBOX_WORKSPACE_DIR
+);
+var SANDBOX_SKILLS_ROOT = `${SANDBOX_WORKSPACE_ROOT}/skills`;
+var SANDBOX_DATA_ROOT = `${SANDBOX_WORKSPACE_ROOT}/data`;
+function sandboxSkillDir(skillName) {
+  return `${SANDBOX_SKILLS_ROOT}/${skillName}`;
+}
+function sandboxSkillFile(skillName) {
+  return `${sandboxSkillDir(skillName)}/SKILL.md`;
+}
+function sandboxSkillPathResolution(skillName) {
+  const skillDir = sandboxSkillDir(skillName);
+  return `Resolve relative paths in this skill against ${skillDir}. For bash commands from this skill, cd to ${skillDir} first or use absolute paths.`;
+}
+
+// src/chat/sleep.ts
+function sleep(ms, signal) {
+  if (!signal) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timeoutId);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+export {
+  SANDBOX_WORKSPACE_ROOT,
+  SANDBOX_SKILLS_ROOT,
+  SANDBOX_DATA_ROOT,
+  sandboxSkillDir,
+  sandboxSkillFile,
+  sandboxSkillPathResolution,
+  sleep
+};

package/dist/{chunk-Y6JNHTRD.js → chunk-FEUNPTGV.js}

@@ -22,7 +22,7 @@ import {
   persistThreadStateById,
   stripRuntimeTurnContext,
   updateConversationStats
-} from "./chunk-NVVBEJUB.js";
+} from "./chunk-TUUDXEXU.js";
 import {
   createPluginConversationEvents,
   createPluginEmbedder,
@@ -30,26 +30,26 @@ import {
   createPluginModel,
   createPluginState,
   getPlugins
-} from "./chunk-KLBYCSLJ.js";
+} from "./chunk-5MXWHTCK.js";
 import {
   getDb,
   sameActorIdentity
-} from "./chunk-HIRIWTWD.js";
+} from "./chunk-SIPKWSXK.js";
 import {
   getStateAdapter
-} from "./chunk-4YQ6I6VF.js";
+} from "./chunk-BOLJOV5T.js";
 import {
   ProviderError,
   findProviderError,
   getProviderErrorAttributes,
   getProviderErrorUserMessage
-} from "./chunk-XCZ6COFO.js";
+} from "./chunk-BYW4B4PR.js";
 import {
   parseSlackMessageTs
 } from "./chunk-F3B2YJ76.js";
 import {
   buildTurnFailureResponse
-} from "./chunk-XWPA5KZF.js";
+} from "./chunk-JNNJZURV.js";
 
 // src/chat/runtime/delivered-turn-state.ts
 function buildDeliveredTurnStatePatch(args) {
@@ -82,6 +82,25 @@ import {
   isPrivateSource,
   pluginRunContextSchema
 } from "@sentry/junior-plugin-api";
+
+// src/chat/services/turn-session-routing.ts
+async function resolveTurnSessionRouting(args) {
+  const conversationStore = args.conversationStore ?? (await import("./db-UO2IWXGA.js")).getConversationStore();
+  const conversation = await conversationStore.get({
+    conversationId: args.conversationId
+  });
+  if (!conversation?.destination || !conversation.sessionSource) {
+    throw new Error(
+      `Conversation ${args.conversationId} is missing durable routing metadata`
+    );
+  }
+  return {
+    destination: conversation.destination,
+    source: conversation.sessionSource
+  };
+}
+
+// src/chat/plugins/task-runner.ts
 var PLUGIN_TASK_LOCK_TTL_MS = 5 * 60 * 1e3;
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -210,9 +229,8 @@ function messageExistedAtRunCompletion(message, completedAtMs) {
   const messageTimestampMs = conversationMessageTimestampMs(message);
   return messageTimestampMs !== void 0 && messageTimestampMs <= completedAtMs;
 }
-async function loadConversationContextTranscriptEntries(record) {
-  const source = record.source;
-  if (source?.platform !== "slack" || isPrivateSource(source)) {
+async function loadConversationContextTranscriptEntries(record, source) {
+  if (source.platform !== "slack" || isPrivateSource(source)) {
     return [];
   }
   const state = await getPersistedThreadState(record.conversationId);
@@ -274,30 +292,28 @@ async function loadPluginRun(params) {
   if (record.state !== "completed") {
     throw new Error("Completed plugin task session record is not completed");
   }
-  if (!record.source || !record.destination) {
-    throw new Error(
-      "Completed plugin task session record is missing source or destination"
-    );
-  }
+  const routing = await resolveTurnSessionRouting({
+    conversationId: params.conversationId
+  });
   const runEntries = turnMessagesWithProvenance(record).map(
     ({ message, provenance }) => runTranscriptEntry(message, provenance, record.actor)
   ).filter((entry) => Boolean(entry));
   const runMessageTexts = new Set(
     runEntries.filter((entry) => entry.type === "message").map((entry) => entry.text)
   );
-  const contextEntries = (await loadConversationContextTranscriptEntries(record)).filter(
+  const contextEntries = (await loadConversationContextTranscriptEntries(record, routing.source)).filter(
     (entry) => entry.type !== "message" || !runMessageTexts.has(entry.text)
   );
   return pluginRunContextSchema.parse({
     completedAtMs: record.updatedAtMs,
     conversationId: record.conversationId,
-    destination: record.destination,
+    destination: routing.destination,
     // Derived from the full run provenance on the record, not the sliced or
     // stripped transcript, so it reflects every committed instruction actor.
     actors: record.actors,
     ...record.actor ? { actor: record.actor } : {},
     runId: record.sessionId,
-    source: record.source,
+    source: routing.source,
     transcript: [...contextEntries, ...runEntries]
   });
 }
@@ -471,58 +487,6 @@ function finalizeFailedTurnReplyWithEvent(args) {
   };
 }
 
-// src/chat/conversations/turn-lifecycle.ts
-var ConversationTurnLifecycleService = class {
-  constructor(events) {
-    this.events = events;
-  }
-  events;
-  /** Record the turn start once after every input message is durable. */
-  async start(input) {
-    await this.events.append(input.conversationId, [
-      {
-        idempotencyKey: `turn:${input.turnId}:started`,
-        createdAtMs: input.createdAtMs,
-        data: {
-          type: "turn_started",
-          turnId: input.turnId,
-          inputMessageIds: input.inputMessageIds,
-          surface: input.surface
-        }
-      }
-    ]);
-  }
-  /** Record successful or intentional-silence completion once. */
-  async complete(input) {
-    await this.events.append(input.conversationId, [
-      {
-        idempotencyKey: `turn:${input.turnId}:terminal`,
-        createdAtMs: input.createdAtMs,
-        data: {
-          type: "turn_completed",
-          turnId: input.turnId,
-          outcome: input.outcome
-        }
-      }
-    ]);
-  }
-  /** Record a classified failure once without accepting raw error details. */
-  async fail(input) {
-    await this.events.append(input.conversationId, [
-      {
-        idempotencyKey: `turn:${input.turnId}:terminal`,
-        createdAtMs: input.createdAtMs,
-        data: {
-          type: "turn_failed",
-          turnId: input.turnId,
-          failureCode: input.failureCode,
-          ...input.eventId ? { eventId: input.eventId } : {}
-        }
-      }
-    ]);
-  }
-};
-
 // src/chat/runtime/turn-user-message.ts
 function getTurnUserMessage(conversation, sessionId) {
   for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
@@ -589,13 +553,13 @@ export {
   getTurnUserMessageId,
   getTurnUserSlackMessageTs,
   getTurnUserReplyAttachmentContext,
+  resolveTurnSessionRouting,
   scheduleSessionCompletedPluginTasks,
   processPluginTask,
   getInterruptionMarker,
   requireTurnFailureEventId,
   getAgentTurnDiagnosticsAttributes,
   finalizeFailedTurnReplyWithEvent,
-  ConversationTurnLifecycleService,
   completeAuthPauseTurn,
   persistAuthPauseTurnState
 };

package/dist/{chunk-TYNMSQKA.js → chunk-FNLBTB4K.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-F3B2YJ76.js";
 import {
   toOptionalString
-} from "./chunk-XWPA5KZF.js";
+} from "./chunk-JNNJZURV.js";
 
 // src/chat/slack/context.ts
 import { z } from "zod";

package/dist/{chunk-TRZSM67C.js → chunk-HCIVH3JS.js}

@@ -433,6 +433,7 @@ var conversationStatsItemSchema = z2.object({
   tokens: z2.number().optional()
 }).strict();
 var conversationMetricDaySchema = z2.object({
+  conversations: z2.number(),
   costUsd: z2.number().optional(),
   date: z2.string(),
   durationMs: z2.number(),