@sentry/junior 0.138.0 → 0.140.0

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

@@ -1,3 +1,6 @@
+import {
+  recordTaskExecution
+} from "./chunk-3B7O3GNU.js";
 import {
   pluginTaskId,
   pluginTaskParamsSchema,
@@ -22,7 +25,10 @@ import {
   persistThreadStateById,
   stripRuntimeTurnContext,
   updateConversationStats
-} from "./chunk-TUUDXEXU.js";
+} from "./chunk-BMFRFSTM.js";
+import {
+  JUNIOR_THREAD_STATE_TTL_MS
+} from "./chunk-3Y47VMHV.js";
 import {
   createPluginConversationEvents,
   createPluginEmbedder,
@@ -30,26 +36,30 @@ import {
   createPluginModel,
   createPluginState,
   getPlugins
-} from "./chunk-5MXWHTCK.js";
+} from "./chunk-4PIT6O7A.js";
 import {
+  getConversationStore,
   getDb,
   sameActorIdentity
-} from "./chunk-SIPKWSXK.js";
+} from "./chunk-WSWM6A3R.js";
 import {
   getStateAdapter
-} from "./chunk-BOLJOV5T.js";
+} from "./chunk-J5H65GY2.js";
 import {
   ProviderError,
   findProviderError,
   getProviderErrorAttributes,
   getProviderErrorUserMessage
-} from "./chunk-BYW4B4PR.js";
+} from "./chunk-S3FAOKQU.js";
+import {
+  credentialSubjectSchema
+} from "./chunk-RUIXF3YQ.js";
 import {
   parseSlackMessageTs
 } from "./chunk-F3B2YJ76.js";
 import {
   buildTurnFailureResponse
-} from "./chunk-JNNJZURV.js";
+} from "./chunk-NPL66ZWL.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-UO2IWXGA.js")).getConversationStore();
+  const conversationStore = args.conversationStore ?? (await import("./db-QOGYDDQM.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]
@@ -548,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,

package/dist/{chunk-5LTJ4ITU.js → chunk-AA2EPMUF.js}

@@ -5,14 +5,14 @@ import {
   getConversationStore,
   parseDestination,
   sameDestination
-} from "./chunk-SIPKWSXK.js";
+} from "./chunk-WSWM6A3R.js";
 import {
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-BOLJOV5T.js";
+} from "./chunk-J5H65GY2.js";
 import {
   getChatConfig
-} from "./chunk-BYW4B4PR.js";
+} from "./chunk-S3FAOKQU.js";
 import {
   parseStoredSlackActor
 } from "./chunk-HZF5P5UN.js";
@@ -20,7 +20,7 @@ import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-JNNJZURV.js";
+} from "./chunk-NPL66ZWL.js";
 
 // src/chat/task-execution/state.ts
 import { randomUUID } from "crypto";