@sentry/junior 0.137.0 → 0.139.0

package/dist/{chunk-SYCX4DOK.js → chunk-5GSZWRE2.js}

@@ -1,3 +1,6 @@
+import {
+  recordTaskExecution
+} from "./chunk-GI52BW74.js";
 import {
   pluginTaskId,
   pluginTaskParamsSchema,
@@ -22,7 +25,10 @@ import {
   persistThreadStateById,
   stripRuntimeTurnContext,
   updateConversationStats
-} from "./chunk-POBSY47Q.js";
+} from "./chunk-PJW6U46K.js";
+import {
+  JUNIOR_THREAD_STATE_TTL_MS
+} from "./chunk-3Y47VMHV.js";
 import {
   createPluginConversationEvents,
   createPluginEmbedder,
@@ -30,26 +36,30 @@ import {
   createPluginModel,
   createPluginState,
   getPlugins
-} from "./chunk-WPPXIAFB.js";
+} from "./chunk-IIESAYDL.js";
 import {
+  getConversationStore,
   getDb,
   sameActorIdentity
-} from "./chunk-ZFS67WIR.js";
+} from "./chunk-QTBKPZDA.js";
 import {
   getStateAdapter
-} from "./chunk-5G34IEK2.js";
+} from "./chunk-MXTVUV3I.js";
 import {
   ProviderError,
   findProviderError,
   getProviderErrorAttributes,
   getProviderErrorUserMessage
-} from "./chunk-UG6ZYPBI.js";
+} from "./chunk-75I3UBIL.js";
+import {
+  credentialSubjectSchema
+} from "./chunk-RUIXF3YQ.js";
 import {
   parseSlackMessageTs
 } from "./chunk-F3B2YJ76.js";
 import {
   buildTurnFailureResponse
-} from "./chunk-T6Z5S6PQ.js";
+} from "./chunk-2ECYPYKP.js";
 
 // src/chat/runtime/delivered-turn-state.ts
 function buildDeliveredTurnStatePatch(args) {
@@ -85,7 +95,7 @@ import {
 
 // src/chat/services/turn-session-routing.ts
 async function resolveTurnSessionRouting(args) {
-  const conversationStore = args.conversationStore ?? (await import("./db-66E7VDNC.js")).getConversationStore();
+  const conversationStore = args.conversationStore ?? (await import("./db-UXPPGHDF.js")).getConversationStore();
   const conversation = await conversationStore.get({
     conversationId: args.conversationId
   });
@@ -100,6 +110,397 @@ async function resolveTurnSessionRouting(args) {
   };
 }
 
+// src/chat/agent-dispatch/store.ts
+import { createHash } from "crypto";
+import {
+  destinationSchema,
+  destinationVisibilitySchema,
+  isSlackDestination,
+  replyAttributionSchema,
+  sourceSchema
+} from "@sentry/junior-plugin-api";
+import { z } from "zod";
+var DISPATCH_PREFIX = "junior:agent_dispatch";
+var DISPATCH_LOCK_TTL_MS = 10 * 60 * 1e3;
+var DISPATCH_MAILBOX_APPEND_INDEX_LOCK_TTL_MS = 1e4;
+var DISPATCH_MAILBOX_APPEND_INDEX_MAX_LENGTH = 1e4;
+var nonEmptyExactStringSchema = z.string().min(1).refine(
+  (value) => value === value.trim() && value.toLowerCase() !== "unknown"
+);
+var pendingDispatchMailboxAppendIndexSchema = z.array(
+  nonEmptyExactStringSchema
+);
+var dispatchStatusSchema = z.enum([
+  "pending",
+  "running",
+  "awaiting_resume",
+  "completed",
+  "failed",
+  "blocked"
+]);
+var dispatchActorSchema = z.object({
+  platform: z.literal("system"),
+  name: nonEmptyExactStringSchema
+}).strict();
+var dispatchRecordSchema = z.object({
+  actor: dispatchActorSchema,
+  createdAtMs: z.number().finite(),
+  credentialSubject: credentialSubjectSchema.optional(),
+  destination: destinationSchema,
+  destinationVisibility: destinationVisibilitySchema,
+  errorMessage: z.string().optional(),
+  id: nonEmptyExactStringSchema,
+  idempotencyKey: z.string().min(1),
+  input: z.string().min(1),
+  metadata: z.record(z.string(), z.string()).optional(),
+  plugin: nonEmptyExactStringSchema,
+  replyAttribution: replyAttributionSchema.optional(),
+  resultMessageTs: z.string().optional(),
+  source: sourceSchema,
+  status: dispatchStatusSchema,
+  updatedAtMs: z.number().finite()
+}).strict().superRefine((record, ctx) => {
+  if (!isSlackDestination(record.destination)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Dispatch destination platform must be slack",
+      path: ["destination"]
+    });
+    return;
+  }
+  const subject = record.credentialSubject;
+  if (!subject) {
+    return;
+  }
+  if (subject.allowedWhen === "private-direct-conversation") {
+    if (!record.destination.channelId.startsWith("D")) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Dispatch credentialSubject requires a private direct Slack destination",
+        path: ["credentialSubject"]
+      });
+      return;
+    }
+    if (subject.binding.type !== "slack-direct-conversation" || subject.binding.teamId !== record.destination.teamId || subject.binding.channelId !== record.destination.channelId) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Dispatch credentialSubject binding must match destination",
+        path: ["credentialSubject", "binding"]
+      });
+    }
+    return;
+  }
+  if (subject.binding.type !== subject.allowedWhen || subject.binding.plugin !== record.plugin || subject.binding.taskId !== subject.taskId) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Dispatch credentialSubject binding must match task",
+      path: ["credentialSubject", "binding"]
+    });
+  }
+});
+var storedDispatchRecordSchema = dispatchRecordSchema.extend({
+  attempt: z.number().int().nonnegative().optional(),
+  lastCallbackAtMs: z.number().finite().optional(),
+  leaseExpiresAtMs: z.number().finite().optional(),
+  maxAttempts: z.number().int().positive().optional(),
+  version: z.number().int().positive().optional()
+});
+function getDispatchStorageKey(id) {
+  return `${DISPATCH_PREFIX}:record:${id}`;
+}
+function dispatchLockKey(id) {
+  return `${DISPATCH_PREFIX}:lock:${id}`;
+}
+function pendingDispatchMailboxAppendIndexKey() {
+  return `${DISPATCH_PREFIX}:incomplete`;
+}
+function pendingDispatchMailboxAppendIndexLockKey() {
+  return `${DISPATCH_PREFIX}:incomplete:lock`;
+}
+function normalizeMetadata(metadata) {
+  if (!metadata) {
+    return void 0;
+  }
+  const entries = Object.entries(metadata).filter(
+    (entry) => typeof entry[0] === "string" && typeof entry[1] === "string"
+  );
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function buildDispatchId(plugin, idempotencyKey) {
+  const digest = createHash("sha256").update(plugin).update("\0").update(idempotencyKey).digest("hex").slice(0, 32);
+  return `dispatch_${digest}`;
+}
+function parseDispatchRecord(value) {
+  const parsed = parseStoredDispatchRecord(value);
+  return parsed?.record;
+}
+function parseStoredDispatchRecord(value) {
+  const parsed = storedDispatchRecordSchema.safeParse(value);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const {
+    attempt: _attempt,
+    lastCallbackAtMs: _lastCallbackAtMs,
+    leaseExpiresAtMs: _leaseExpiresAtMs,
+    maxAttempts: _maxAttempts,
+    version: _version,
+    ...record
+  } = parsed.data;
+  return {
+    ...typeof parsed.data.leaseExpiresAtMs === "number" ? { legacyLeaseExpiresAtMs: parsed.data.leaseExpiresAtMs } : {},
+    record
+  };
+}
+function getDispatchConversationId(dispatch) {
+  return `agent-dispatch:${dispatch.id}`;
+}
+function getDispatchInputMessageId(dispatchId) {
+  return `agent-dispatch:${dispatchId}`;
+}
+function getLegacyDispatchInputMessageId(dispatchId) {
+  return `dispatch:${dispatchId}:user`;
+}
+function getDispatchInputMessageIds(dispatchId) {
+  return [
+    getDispatchInputMessageId(dispatchId),
+    getLegacyDispatchInputMessageId(dispatchId)
+  ];
+}
+function getDispatchTurnId(dispatchId) {
+  return `dispatch:${dispatchId}`;
+}
+function toDispatchProjection(record) {
+  return {
+    id: record.id,
+    status: record.status,
+    ...record.resultMessageTs ? { resultMessageTs: record.resultMessageTs } : {},
+    ...record.errorMessage ? { errorMessage: record.errorMessage } : {}
+  };
+}
+function isTerminalDispatchStatus(status) {
+  return status === "completed" || status === "failed" || status === "blocked";
+}
+async function withDispatchLock(dispatchId, task) {
+  const state = getStateAdapter();
+  await state.connect();
+  const lock = await state.acquireLock(
+    dispatchLockKey(dispatchId),
+    DISPATCH_LOCK_TTL_MS
+  );
+  if (!lock) {
+    throw new Error(`Could not acquire dispatch lock for ${dispatchId}`);
+  }
+  try {
+    return await task(state);
+  } finally {
+    await state.releaseLock(lock);
+  }
+}
+async function putRecord(state, record) {
+  const parsed = dispatchRecordSchema.safeParse(record);
+  if (!parsed.success) {
+    throw new Error(
+      `Dispatch record is invalid: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"} ${issue.message}`).join("; ")}`
+    );
+  }
+  const next = parsed.data;
+  await state.set(
+    getDispatchStorageKey(next.id),
+    next,
+    JUNIOR_THREAD_STATE_TTL_MS
+  );
+}
+async function updatePendingDispatchMailboxAppendIndex(state, update) {
+  const lock = await state.acquireLock(
+    pendingDispatchMailboxAppendIndexLockKey(),
+    DISPATCH_MAILBOX_APPEND_INDEX_LOCK_TTL_MS
+  );
+  if (!lock) {
+    throw new Error("Could not acquire dispatch mailbox append index lock");
+  }
+  try {
+    const stored = await state.get(pendingDispatchMailboxAppendIndexKey());
+    const ids = stored === void 0 || stored === null ? [] : pendingDispatchMailboxAppendIndexSchema.parse(stored);
+    const next = [...new Set(update([...new Set(ids)]))].slice(
+      -DISPATCH_MAILBOX_APPEND_INDEX_MAX_LENGTH
+    );
+    if (next.length === ids.length && next.every((id, index) => id === ids[index])) {
+      return;
+    }
+    await state.set(
+      pendingDispatchMailboxAppendIndexKey(),
+      next,
+      JUNIOR_THREAD_STATE_TTL_MS
+    );
+  } finally {
+    await state.releaseLock(lock);
+  }
+}
+async function getDispatchRecord(id) {
+  const state = getStateAdapter();
+  await state.connect();
+  return parseDispatchRecord(await state.get(getDispatchStorageKey(id)));
+}
+async function createOrGetDispatch(args) {
+  const id = buildDispatchId(args.plugin, args.options.idempotencyKey);
+  return await withDispatchLock(id, async (state) => {
+    const existing = parseDispatchRecord(
+      await state.get(getDispatchStorageKey(id))
+    );
+    if (existing) {
+      return { record: existing, status: "already_exists" };
+    }
+    const metadata = normalizeMetadata(args.options.metadata);
+    const record = {
+      actor: { platform: "system", name: args.plugin },
+      createdAtMs: args.nowMs,
+      ...args.options.credentialSubject ? { credentialSubject: args.options.credentialSubject } : {},
+      destination: args.options.destination,
+      destinationVisibility: args.options.destinationVisibility,
+      id,
+      idempotencyKey: args.options.idempotencyKey,
+      input: args.options.input,
+      ...metadata ? { metadata } : {},
+      plugin: args.plugin,
+      ...args.options.replyAttribution ? { replyAttribution: args.options.replyAttribution } : {},
+      status: "pending",
+      source: args.options.source,
+      updatedAtMs: args.nowMs
+    };
+    await updatePendingDispatchMailboxAppendIndex(
+      state,
+      (ids) => ids.includes(id) ? ids : [...ids, id]
+    );
+    await putRecord(state, record);
+    return { record, status: "created" };
+  });
+}
+async function transitionDispatch(id, transition) {
+  return await withDispatchLock(id, async (state) => {
+    const current = parseDispatchRecord(
+      await state.get(getDispatchStorageKey(id))
+    );
+    if (!current) {
+      return void 0;
+    }
+    const transitioned = transition(current);
+    if (transitioned === current) {
+      return current;
+    }
+    const next = {
+      ...transitioned,
+      updatedAtMs: Date.now()
+    };
+    await putRecord(state, next);
+    return next;
+  });
+}
+async function markDispatchRunning(id) {
+  return await transitionDispatch(
+    id,
+    (record) => isTerminalDispatchStatus(record.status) ? record : { ...record, status: "running", errorMessage: void 0 }
+  );
+}
+async function markDispatchAwaitingResume(id) {
+  return await transitionDispatch(
+    id,
+    (record) => isTerminalDispatchStatus(record.status) ? record : {
+      ...record,
+      status: "awaiting_resume"
+    }
+  );
+}
+async function recordEventTaskExecution(previous, next, status) {
+  if (!next || next.status !== status || previous?.status === status) return;
+  if (next.plugin !== "junior") return;
+  const eventTaskId = next.metadata?.eventTaskId;
+  if (!eventTaskId) return;
+  const conversationId = getDispatchConversationId(next);
+  const conversation = await getConversationStore().get({ conversationId });
+  await recordTaskExecution("event", eventTaskId, {
+    ...conversation ? { conversationId } : {},
+    executionId: next.id,
+    nowMs: next.updatedAtMs,
+    status
+  });
+}
+async function markDispatchBlocked(id, errorMessage, resultMessageTs) {
+  const previous = await getDispatchRecord(id);
+  const next = await transitionDispatch(
+    id,
+    (record) => isTerminalDispatchStatus(record.status) ? record : {
+      ...record,
+      errorMessage,
+      ...resultMessageTs ? { resultMessageTs } : {},
+      status: "blocked"
+    }
+  );
+  await recordEventTaskExecution(previous, next, "blocked");
+  return next;
+}
+async function markDispatchCompleted(id, resultMessageTs) {
+  const previous = await getDispatchRecord(id);
+  const next = await transitionDispatch(
+    id,
+    (record) => isTerminalDispatchStatus(record.status) ? record : {
+      ...record,
+      errorMessage: void 0,
+      ...resultMessageTs ? { resultMessageTs } : {},
+      status: "completed"
+    }
+  );
+  await recordEventTaskExecution(previous, next, "completed");
+  return next;
+}
+async function markDispatchFailed(id, errorMessage, resultMessageTs) {
+  const previous = await getDispatchRecord(id);
+  const next = await transitionDispatch(
+    id,
+    (record) => isTerminalDispatchStatus(record.status) ? record : {
+      ...record,
+      errorMessage,
+      ...resultMessageTs ? { resultMessageTs } : {},
+      status: "failed"
+    }
+  );
+  await recordEventTaskExecution(previous, next, "failed");
+  return next;
+}
+async function confirmDispatchMailboxAppend(id) {
+  const state = getStateAdapter();
+  await state.connect();
+  await updatePendingDispatchMailboxAppendIndex(
+    state,
+    (ids) => ids.filter((candidate) => candidate !== id)
+  );
+}
+async function listPendingDispatchMailboxAppends() {
+  const state = getStateAdapter();
+  await state.connect();
+  const stored = await state.get(pendingDispatchMailboxAppendIndexKey());
+  return stored === void 0 || stored === null ? [] : [...new Set(pendingDispatchMailboxAppendIndexSchema.parse(stored))];
+}
+async function claimDispatchMailboxAppend(id, nowMs) {
+  return await withDispatchLock(id, async (state) => {
+    const stored = parseStoredDispatchRecord(
+      await state.get(getDispatchStorageKey(id))
+    );
+    if (!stored || stored.legacyLeaseExpiresAtMs && stored.legacyLeaseExpiresAtMs > nowMs) {
+      return void 0;
+    }
+    await putRecord(state, stored.record);
+    return stored.record;
+  });
+}
+async function getPluginDispatchProjection(args) {
+  const record = await getDispatchRecord(args.id);
+  if (!record || record.plugin !== args.plugin) {
+    return void 0;
+  }
+  return toDispatchProjection(record);
+}
+
 // src/chat/plugins/task-runner.ts
 var PLUGIN_TASK_LOCK_TTL_MS = 5 * 60 * 1e3;
 function isRecord(value) {
@@ -229,7 +630,7 @@ function messageExistedAtRunCompletion(message, completedAtMs) {
   const messageTimestampMs = conversationMessageTimestampMs(message);
   return messageTimestampMs !== void 0 && messageTimestampMs <= completedAtMs;
 }
-async function loadConversationContextTranscriptEntries(record, source) {
+async function loadConversationContextTranscriptEntries(record, source, runActor) {
   if (source.platform !== "slack" || isPrivateSource(source)) {
     return [];
   }
@@ -260,7 +661,7 @@ async function loadConversationContextTranscriptEntries(record, source) {
         authority: "context",
         ...author ? { actor: author } : {}
       },
-      isRunActor: sameActorIdentity(author, record.actor)
+      isRunActor: sameActorIdentity(author, runActor)
     });
   }
   return entries;
@@ -295,13 +696,18 @@ async function loadPluginRun(params) {
   const routing = await resolveTurnSessionRouting({
     conversationId: params.conversationId
   });
+  const runActor = record.actors[0] ?? (record.dispatchId ? (await getDispatchRecord(record.dispatchId))?.actor : void 0);
   const runEntries = turnMessagesWithProvenance(record).map(
-    ({ message, provenance }) => runTranscriptEntry(message, provenance, record.actor)
+    ({ message, provenance }) => runTranscriptEntry(message, provenance, runActor)
   ).filter((entry) => Boolean(entry));
   const runMessageTexts = new Set(
     runEntries.filter((entry) => entry.type === "message").map((entry) => entry.text)
   );
-  const contextEntries = (await loadConversationContextTranscriptEntries(record, routing.source)).filter(
+  const contextEntries = (await loadConversationContextTranscriptEntries(
+    record,
+    routing.source,
+    runActor
+  )).filter(
     (entry) => entry.type !== "message" || !runMessageTexts.has(entry.text)
   );
   return pluginRunContextSchema.parse({
@@ -311,7 +717,7 @@ async function loadPluginRun(params) {
     // 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 } : {},
+    ...runActor ? { actor: runActor } : {},
     runId: record.sessionId,
     source: routing.source,
     transcript: [...contextEntries, ...runEntries]
@@ -487,58 +893,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) {
@@ -600,6 +954,22 @@ async function persistAuthPauseTurnState(args) {
 }
 
 export {
+  getDispatchConversationId,
+  getDispatchInputMessageId,
+  getDispatchInputMessageIds,
+  getDispatchTurnId,
+  isTerminalDispatchStatus,
+  getDispatchRecord,
+  createOrGetDispatch,
+  markDispatchRunning,
+  markDispatchAwaitingResume,
+  markDispatchBlocked,
+  markDispatchCompleted,
+  markDispatchFailed,
+  confirmDispatchMailboxAppend,
+  listPendingDispatchMailboxAppends,
+  claimDispatchMailboxAppend,
+  getPluginDispatchProjection,
   buildDeliveredTurnStatePatch,
   getTurnUserMessage,
   getTurnUserMessageId,
@@ -612,7 +982,6 @@ export {
   requireTurnFailureEventId,
   getAgentTurnDiagnosticsAttributes,
   finalizeFailedTurnReplyWithEvent,
-  ConversationTurnLifecycleService,
   completeAuthPauseTurn,
   persistAuthPauseTurnState
 };

package/dist/chunk-5IDFPCON.js

@@ -0,0 +1,46 @@
+// src/chat/experimental.ts
+var EXPERIMENTAL_FEATURES = ["subagents"];
+var EXPERIMENTAL_FEATURE_SET = new Set(EXPERIMENTAL_FEATURES);
+var configuredExperimental = {};
+function isExperimentalFeature(value) {
+  return EXPERIMENTAL_FEATURE_SET.has(value);
+}
+function setExperimentalFeatures(config) {
+  const previous = { ...configuredExperimental };
+  if (config === void 0) {
+    configuredExperimental = {};
+    return previous;
+  }
+  const next = {};
+  for (const [rawName, enabled] of Object.entries(config)) {
+    if (enabled === void 0) {
+      continue;
+    }
+    if (typeof enabled !== "boolean") {
+      throw new Error(
+        `experimental.${rawName} must be a boolean when provided`
+      );
+    }
+    if (!isExperimentalFeature(rawName)) {
+      throw new Error(
+        `experimental.${rawName} is not a known experimental feature. Known features: ${EXPERIMENTAL_FEATURES.join(", ")}`
+      );
+    }
+    next[rawName] = enabled;
+  }
+  configuredExperimental = next;
+  return previous;
+}
+function getExperimentalFeatures() {
+  return { ...configuredExperimental };
+}
+function isExperimentalFeatureEnabled(feature) {
+  return configuredExperimental[feature] === true;
+}
+
+export {
+  EXPERIMENTAL_FEATURES,
+  setExperimentalFeatures,
+  getExperimentalFeatures,
+  isExperimentalFeatureEnabled
+};

package/dist/{chunk-36EG34YI.js → chunk-6OHTDR4F.js}

@@ -1,6 +1,6 @@
 import {
   createPluginCatalogRuntime
-} from "./chunk-BZAMASJP.js";
+} from "./chunk-CXH25EL4.js";
 
 // src/chat/plugins/catalog-runtime.ts
 var pluginCatalogRuntime = createPluginCatalogRuntime();