@sentry/junior 0.203.0 → 0.205.0

package/dist/chunk-SP3QKZXJ.js

@@ -1,820 +0,0 @@
-import {
-  coerceThreadConversationState,
-  getPersistedThreadState
-} from "./chunk-ASTEMBKJ.js";
-import {
-  recordTaskExecution
-} from "./chunk-PZUSUL55.js";
-import {
-  pluginTaskId,
-  pluginTaskParamsSchema,
-  sendVercelPluginTask
-} from "./chunk-3YJSKOWF.js";
-import {
-  getPiMessageRole,
-  getTurnRecord,
-  hydrateConversationMessages,
-  instructionTextForProjection,
-  isToolResultError,
-  isToolResultMessage,
-  normalizeToolNameFromResult,
-  stripRuntimeTurnContext
-} from "./chunk-F4MGCZOX.js";
-import {
-  createPluginConversationEvents,
-  createPluginEmbedder,
-  createPluginLogger,
-  createPluginModel,
-  createPluginState,
-  getPlugins,
-  readActorIdentity
-} from "./chunk-IZ5B5IHQ.js";
-import {
-  JUNIOR_THREAD_STATE_TTL_MS
-} from "./chunk-3Y47VMHV.js";
-import {
-  getConversationStore,
-  getDb
-} from "./chunk-GKEOHJL5.js";
-import {
-  getStateAdapter
-} from "./chunk-P6KTRNVC.js";
-import {
-  sameActorIdentity
-} from "./chunk-7NL7T6VU.js";
-import {
-  credentialSubjectSchema
-} from "./chunk-CEMMLV5L.js";
-import {
-  parseSlackMessageTs
-} from "./chunk-N7TMSOZH.js";
-
-// src/chat/plugins/task-runner.ts
-import { pluginRunContextSchema } from "@sentry/junior-plugin-api";
-
-// src/chat/services/turn-session-routing.ts
-async function loadConversationChain(conversationId, conversationStore) {
-  const chain = [];
-  const seen = /* @__PURE__ */ new Set();
-  let cursor = conversationId;
-  while (cursor && !seen.has(cursor)) {
-    seen.add(cursor);
-    const conversation = await conversationStore.get({
-      conversationId: cursor
-    });
-    if (!conversation) {
-      break;
-    }
-    chain.push(conversation);
-    cursor = conversation.parentConversationId;
-  }
-  return chain;
-}
-function slackSourceForDestination(args) {
-  if (args.source?.kind !== "slack" || args.source.channelId !== args.destination.channelId) {
-    return void 0;
-  }
-  const threadTs = args.source.threadTs?.trim();
-  return {
-    kind: "slack",
-    visibility: args.source.visibility ?? "public",
-    teamId: args.source.teamId?.trim() || args.destination.teamId,
-    channelId: args.source.channelId,
-    ...threadTs ? { threadTs } : void 0
-  };
-}
-async function resolveConversationRouting(args) {
-  const conversationStore = args.conversationStore ?? (await import("./db-NGDJV7YH.js")).getConversationStore();
-  const chain = await loadConversationChain(
-    args.conversationId,
-    conversationStore
-  );
-  let destination;
-  let source;
-  let location;
-  for (const conversation of chain) {
-    destination ??= conversation.destination;
-    source ??= conversation.sessionSource;
-    location ??= conversation.location;
-    if (destination && source) {
-      break;
-    }
-  }
-  if (!destination) {
-    return void 0;
-  }
-  if (destination.platform === "slack") {
-    const slackSource = slackSourceForDestination({ destination, source });
-    return {
-      destination,
-      ...location ? { location } : void 0,
-      ...slackSource ? { source: slackSource } : void 0
-    };
-  }
-  return {
-    destination,
-    ...location ? { location } : void 0,
-    ...source ? { source } : void 0
-  };
-}
-async function resolveTurnSessionRouting(args) {
-  const routing = await resolveConversationRouting(args);
-  if (!routing?.destination || !routing.source) {
-    throw new Error(
-      `Conversation ${args.conversationId} is missing durable routing metadata`
-    );
-  }
-  return {
-    destination: routing.destination,
-    ...routing.location ? { location: routing.location } : void 0,
-    source: routing.source
-  };
-}
-
-// 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"]
-    });
-  }
-});
-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 = dispatchRecordSchema.safeParse(value);
-  return parsed.success ? parsed.data : void 0;
-}
-function getDispatchConversationId(dispatch) {
-  return `agent-dispatch:${dispatch.id}`;
-}
-function getDispatchInputMessageId(dispatchId) {
-  return `agent-dispatch:${dispatchId}`;
-}
-function getDispatchTurnId(dispatchId) {
-  return `dispatch:${dispatchId}`;
-}
-function toDispatchProjection(record) {
-  return {
-    id: record.id,
-    status: record.status,
-    ...record.resultMessageTs ? { resultMessageTs: record.resultMessageTs } : void 0,
-    ...record.errorMessage ? { errorMessage: record.errorMessage } : void 0
-  };
-}
-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 } : void 0,
-      destination: args.options.destination,
-      destinationVisibility: args.options.destinationVisibility,
-      id,
-      idempotencyKey: args.options.idempotencyKey,
-      input: args.options.input,
-      ...metadata ? { metadata } : void 0,
-      plugin: args.plugin,
-      ...args.options.replyAttribution ? { replyAttribution: args.options.replyAttribution } : void 0,
-      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 } : void 0,
-    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 } : void 0,
-      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 } : void 0,
-      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 } : void 0,
-      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) {
-  return await withDispatchLock(id, async (state) => {
-    return parseDispatchRecord(await state.get(getDispatchStorageKey(id)));
-  });
-}
-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) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function textPart(value) {
-  if (isRecord(value) && value.type === "text" && typeof value.text === "string") {
-    return value.text;
-  }
-  return void 0;
-}
-function messageText(message) {
-  const content = message.content;
-  if (typeof content === "string") {
-    return sanitizeText(content);
-  }
-  if (!Array.isArray(content)) {
-    return "";
-  }
-  return sanitizeText(content.map(textPart).filter(Boolean).join("\n"));
-}
-function toolResultText(message) {
-  const record = message;
-  const parts = [
-    messageText(message),
-    record.output,
-    record.result,
-    record.stdout,
-    record.stderr,
-    record.toolResult
-  ].filter(
-    (value) => typeof value === "string" && value.length > 0
-  );
-  return sanitizeText(parts.join("\n"));
-}
-function sanitizeText(text) {
-  return text.replace(
-    /<data_base64>[\s\S]*?<\/data_base64>/g,
-    "<data_base64>[omitted]</data_base64>"
-  ).replace(
-    /data:image\/[a-z0-9.+-]+;base64,[a-z0-9+/=]+/gi,
-    "[image data omitted]"
-  ).replaceAll("\0", " ").trim();
-}
-function messageProvenance(provenance) {
-  return {
-    authority: provenance.authority,
-    ...provenance.actor ? { actor: provenance.actor } : void 0
-  };
-}
-function runTranscriptEntry(message, provenance, runActor) {
-  const role = getPiMessageRole(message);
-  if (role === "user" || role === "assistant") {
-    const text2 = role === "user" ? instructionTextForProjection(messageText(message)) : messageText(message);
-    if (!text2) {
-      return void 0;
-    }
-    if (role === "assistant") {
-      return { type: "message", role, text: text2 };
-    }
-    return {
-      type: "message",
-      role,
-      text: text2,
-      provenance: messageProvenance(provenance),
-      isRunActor: sameActorIdentity(provenance.actor, runActor)
-    };
-  }
-  if (!isToolResultMessage(message)) {
-    return void 0;
-  }
-  const toolName = normalizeToolNameFromResult(message);
-  if (!toolName) {
-    return void 0;
-  }
-  const text = toolResultText(message);
-  return {
-    type: "toolResult",
-    toolName,
-    isError: isToolResultError(message),
-    ...text ? { text } : void 0
-  };
-}
-function turnMessagesWithProvenance(record) {
-  const startIndex = record.turnStartMessageIndex ?? 0;
-  const messages = record.piMessages.slice(startIndex);
-  const provenance = record.piMessageProvenance.slice(startIndex);
-  const paired = [];
-  for (const [index, message] of messages.entries()) {
-    for (const stripped of stripRuntimeTurnContext([message])) {
-      paired.push({
-        message: stripped,
-        provenance: provenance[index] ?? { authority: "context" }
-      });
-    }
-  }
-  return paired;
-}
-function slackContextAuthor(location, message) {
-  const userId = message.author?.userId?.trim();
-  if (!userId) {
-    return void 0;
-  }
-  return {
-    platform: "slack",
-    teamId: location.teamId,
-    userId,
-    ...message.author?.userName ? { userName: message.author.userName } : void 0,
-    ...message.author?.fullName ? { fullName: message.author.fullName } : void 0
-  };
-}
-function slackTimestampMs(value) {
-  const timestamp = parseSlackMessageTs(value);
-  if (!timestamp) {
-    return void 0;
-  }
-  const timestampMs = Number(timestamp) * 1e3;
-  return Number.isFinite(timestampMs) ? timestampMs : void 0;
-}
-function conversationMessageTimestampMs(message) {
-  if (message.meta?.slackTs !== void 0) {
-    return slackTimestampMs(message.meta.slackTs);
-  }
-  return Number.isFinite(message.createdAtMs) ? message.createdAtMs : void 0;
-}
-function messageExistedAtRunCompletion(message, completedAtMs) {
-  const messageTimestampMs = conversationMessageTimestampMs(message);
-  return messageTimestampMs !== void 0 && messageTimestampMs <= completedAtMs;
-}
-async function loadConversationContextTranscriptEntries(record, location, visibility, runActor) {
-  if (location?.provider !== "slack" || visibility !== "public") {
-    return [];
-  }
-  const state = await getPersistedThreadState(record.conversationId);
-  const conversation = coerceThreadConversationState(state);
-  await hydrateConversationMessages({
-    conversation,
-    conversationId: record.conversationId
-  });
-  const entries = [];
-  for (const message of conversation.messages) {
-    if (message.role !== "user") {
-      continue;
-    }
-    if (!messageExistedAtRunCompletion(message, record.updatedAtMs)) {
-      continue;
-    }
-    const text = sanitizeText(message.text);
-    if (!text) {
-      continue;
-    }
-    const author = slackContextAuthor(location, message);
-    entries.push({
-      type: "message",
-      role: "user",
-      text,
-      provenance: {
-        authority: "context",
-        ...author ? { actor: author } : void 0
-      },
-      isRunActor: sameActorIdentity(author, runActor)
-    });
-  }
-  return entries;
-}
-async function withPluginTaskLock(taskId, callback) {
-  const state = getStateAdapter();
-  await state.connect();
-  const lock = await state.acquireLock(
-    `plugin:task:${taskId}`,
-    PLUGIN_TASK_LOCK_TTL_MS
-  );
-  if (!lock) {
-    throw new Error(`Could not acquire plugin task lock for ${taskId}`);
-  }
-  try {
-    return await callback();
-  } finally {
-    await state.releaseLock(lock);
-  }
-}
-async function loadPluginRun(params) {
-  const record = await getTurnRecord(params.conversationId, params.sessionId);
-  if (!record) {
-    throw new Error("Completed plugin task session record is unavailable");
-  }
-  if (record.state !== "completed") {
-    throw new Error("Completed plugin task session record is not completed");
-  }
-  const conversationStore = getConversationStore();
-  const routing = await resolveConversationRouting({
-    conversationId: params.conversationId,
-    conversationStore
-  });
-  if (!routing) {
-    throw new Error(
-      `Conversation ${params.conversationId} is missing durable routing metadata`
-    );
-  }
-  const source = record.source ?? routing.source;
-  if (!source) {
-    throw new Error("Completed plugin task session record is missing Source");
-  }
-  const conversation = await conversationStore.get({
-    conversationId: params.conversationId
-  });
-  const runActor = record.actor ?? record.actors[0] ?? (record.dispatchId ? (await getDispatchRecord(record.dispatchId))?.actor : void 0);
-  const actorUser = runActor ? (await readActorIdentity(runActor))?.user : void 0;
-  const runEntries = turnMessagesWithProvenance(record).map(
-    ({ 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,
-    conversation?.location,
-    conversation?.visibility,
-    runActor
-  )).filter(
-    (entry) => entry.type !== "message" || !runMessageTexts.has(entry.text)
-  );
-  return pluginRunContextSchema.parse({
-    ...actorUser ? { actorUserId: actorUser.id } : void 0,
-    completedAtMs: record.updatedAtMs,
-    conversationId: record.conversationId,
-    destination: routing.destination,
-    ...routing.location ? { locationId: routing.location.id } : void 0,
-    // Read Actors from the full run record, not the shorter transcript.
-    // This includes every Actor that supplied an instruction.
-    actors: record.actors,
-    ...runActor ? { actor: runActor } : void 0,
-    runId: record.turnId,
-    source,
-    transcript: [...contextEntries, ...runEntries]
-  });
-}
-function taskPluginContext(plugin, message, options = {}) {
-  const pluginName = plugin.manifest.name;
-  const sessionParams = pluginTaskParamsSchema.parse(message.params);
-  return {
-    db: getDb(),
-    embedder: createPluginEmbedder(pluginName, {
-      signal: options.signal
-    }),
-    events: createPluginConversationEvents({
-      conversationId: sessionParams.conversationId,
-      operationId: pluginTaskId(message),
-      plugin,
-      turnId: sessionParams.sessionId
-    }),
-    id: pluginTaskId(message),
-    log: createPluginLogger(pluginName),
-    model: createPluginModel(pluginName, plugin.model, {
-      signal: options.signal
-    }),
-    name: message.name,
-    plugin: { name: pluginName },
-    run: {
-      async load() {
-        return await loadPluginRun(sessionParams);
-      }
-    },
-    state: createPluginState(pluginName)
-  };
-}
-function findPluginTask(message) {
-  const plugin = getPlugins().find(
-    (candidate) => candidate.manifest.name === message.plugin
-  );
-  if (!plugin?.tasks || !Object.hasOwn(plugin.tasks, message.name)) {
-    return void 0;
-  }
-  const task = plugin.tasks[message.name];
-  return { plugin, task };
-}
-async function scheduleSessionCompletedPluginTasks(params, options = {}) {
-  const coreParams = pluginTaskParamsSchema.parse(params);
-  const taskRegistrations = getPlugins().flatMap(
-    (plugin) => Object.keys(plugin.tasks ?? {}).map((name) => ({ name, plugin }))
-  );
-  if (taskRegistrations.length === 0) {
-    return;
-  }
-  const record = await getTurnRecord(
-    coreParams.conversationId,
-    coreParams.sessionId
-  );
-  if (!record || record.state !== "completed") {
-    throw new Error("Completed plugin task session record is not ready");
-  }
-  const send = options.send ?? sendVercelPluginTask;
-  const messages = taskRegistrations.map(({ name, plugin }) => ({
-    name,
-    params: coreParams,
-    plugin: plugin.manifest.name
-  }));
-  await Promise.all(
-    messages.map(async (message) => {
-      await send(message);
-    })
-  );
-}
-async function processPluginTask(message, options = {}) {
-  await withPluginTaskLock(pluginTaskId(message), async () => {
-    const resolved = findPluginTask(message);
-    if (!resolved) {
-      throw new Error(
-        `Plugin task "${message.plugin}.${message.name}" is not registered`
-      );
-    }
-    await resolved.task.run(
-      taskPluginContext(resolved.plugin, message, options)
-    );
-  });
-}
-
-export {
-  getDispatchConversationId,
-  getDispatchInputMessageId,
-  getDispatchTurnId,
-  isTerminalDispatchStatus,
-  getDispatchRecord,
-  createOrGetDispatch,
-  markDispatchRunning,
-  markDispatchAwaitingResume,
-  markDispatchBlocked,
-  markDispatchCompleted,
-  markDispatchFailed,
-  confirmDispatchMailboxAppend,
-  listPendingDispatchMailboxAppends,
-  claimDispatchMailboxAppend,
-  getPluginDispatchProjection,
-  resolveTurnSessionRouting,
-  scheduleSessionCompletedPluginTasks,
-  processPluginTask
-};