@sentry/junior 0.179.0 → 0.181.0

package/dist/chunk-HJ27A6YB.js

@@ -0,0 +1,218 @@
+import {
+  abandonTurnRecord,
+  extractAssistantText
+} from "./chunk-NQTA72Q3.js";
+
+// src/chat/state/turn-id.ts
+function buildDeterministicTurnId(messageId) {
+  const sanitized = messageId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return `turn_${sanitized}`;
+}
+function buildDeterministicAssistantMessageId(turnId) {
+  return `${turnId}:assistant:1`;
+}
+
+// src/chat/runtime/turn.ts
+var ConversationTurnBoundaryError = class extends Error {
+  eventId;
+  failureCode;
+  constructor(args) {
+    super(
+      args.cause instanceof Error ? args.cause.message : String(args.cause),
+      {
+        cause: args.cause
+      }
+    );
+    this.name = "ConversationTurnBoundaryError";
+    this.eventId = args.eventId;
+    this.failureCode = args.failureCode;
+  }
+};
+function getConversationTurnBoundaryError(error) {
+  return error instanceof ConversationTurnBoundaryError ? error : void 0;
+}
+var CooperativeTurnYieldError = class extends Error {
+  code = "cooperative_turn_yield";
+  constructor(message = "Agent turn yielded at a safe boundary") {
+    super(message);
+    this.name = "CooperativeTurnYieldError";
+  }
+};
+function isCooperativeTurnYieldError(error) {
+  return error instanceof CooperativeTurnYieldError;
+}
+var TurnInputCommitLostError = class extends Error {
+  code = "turn_input_commit_lost";
+  constructor(message = "Turn input commit lost its durable owner") {
+    super(message);
+    this.name = "TurnInputCommitLostError";
+  }
+};
+function isTurnInputCommitLostError(error) {
+  return error instanceof TurnInputCommitLostError;
+}
+var TurnInputDeferredError = class extends Error {
+  code = "turn_input_deferred";
+  constructor(message = "Turn input is deferred until the active resume ends") {
+    super(message);
+    this.name = "TurnInputDeferredError";
+  }
+};
+function isTurnInputDeferredError(error) {
+  return error instanceof TurnInputDeferredError;
+}
+function startActiveTurn(args) {
+  args.conversation.processing.activeTurnId = args.nextTurnId;
+}
+function clearActiveTurn(conversation, sessionId) {
+  if (!sessionId || conversation.processing.activeTurnId === sessionId) {
+    conversation.processing.activeTurnId = void 0;
+  }
+}
+function markTurnClosed(args) {
+  clearActiveTurn(args.conversation, args.sessionId);
+  args.conversation.processing.lastCompletedAtMs = args.nowMs;
+}
+function markTurnCompleted(args) {
+  clearActiveTurn(args.conversation, args.sessionId);
+  args.conversation.processing.lastCompletedAtMs = args.nowMs;
+}
+function markTurnFailed(args) {
+  clearActiveTurn(args.conversation, args.sessionId);
+  args.conversation.processing.lastCompletedAtMs = args.nowMs;
+  args.markConversationMessage(args.conversation, args.userMessageId, {
+    replied: false,
+    skippedReason: "reply failed"
+  });
+}
+
+// src/chat/no-reply.ts
+var NO_REPLY_MARKER = "[[NO_REPLY]]";
+function isNoReplyMarker(text) {
+  return text.trim() === NO_REPLY_MARKER;
+}
+function containsNoReplyMarker(text) {
+  return text.includes(NO_REPLY_MARKER);
+}
+
+// src/chat/services/assistant-reply.ts
+var THINKING_XML_BLOCK_PATTERN = /[ \t]*<thinking\b[^>]*>[\s\S]*?<\/thinking>[ \t]*(?:\r?\n)?/gi;
+var FENCED_CODE_BLOCK_PATTERN = /```[\s\S]*?```/g;
+function sanitizeAssistantText(text) {
+  let result = "";
+  let cursor = 0;
+  for (const match of text.matchAll(FENCED_CODE_BLOCK_PATTERN)) {
+    const start = match.index;
+    if (start === void 0) continue;
+    result += text.slice(cursor, start).replace(THINKING_XML_BLOCK_PATTERN, "");
+    result += match[0];
+    cursor = start + match[0].length;
+  }
+  return (result + text.slice(cursor).replace(THINKING_XML_BLOCK_PATTERN, "")).trim();
+}
+function decideReply(message) {
+  if (message.content.some((part) => part.type === "toolCall")) {
+    return { kind: "suppress" };
+  }
+  const text = sanitizeAssistantText(extractAssistantText(message));
+  if (!text) return { kind: "empty" };
+  if (isNoReplyMarker(text) || containsNoReplyMarker(text)) {
+    return { kind: "suppress" };
+  }
+  return { kind: "deliver", text };
+}
+function getAssistantReplyText(message) {
+  const decision = decideReply(message);
+  return decision.kind === "deliver" ? decision.text : void 0;
+}
+
+// src/chat/services/pending-auth.ts
+var AUTH_LINK_REUSE_WINDOW_MS = 10 * 60 * 1e3;
+var NON_REQUEST_SKIPPED_REASON_PREFIXES = [
+  "directed_to_other_party:",
+  "side_conversation:"
+];
+function isSkippedNonRequest(reason) {
+  return NON_REQUEST_SKIPPED_REASON_PREFIXES.some(
+    (prefix) => reason?.startsWith(prefix)
+  );
+}
+function canReusePendingAuthLink(args) {
+  const { pendingAuth } = args;
+  if (!pendingAuth) {
+    return false;
+  }
+  return pendingAuth.kind === args.kind && pendingAuth.provider === args.provider && pendingAuth.actorId === args.actorId && pendingAuth.scope === args.scope && pendingAuth.sessionId === args.sessionId && pendingAuth.linkSentAtMs + AUTH_LINK_REUSE_WINDOW_MS > (args.nowMs ?? Date.now());
+}
+function getConversationPendingAuth(args) {
+  const pendingAuth = args.conversation.processing.pendingAuth;
+  if (!pendingAuth) {
+    return void 0;
+  }
+  if (pendingAuth.kind !== args.kind || pendingAuth.provider !== args.provider || pendingAuth.actorId !== args.actorId || pendingAuth.scope !== args.scope) {
+    return void 0;
+  }
+  return pendingAuth;
+}
+function clearPendingAuth(conversation, sessionId) {
+  if (!conversation.processing.pendingAuth) {
+    return;
+  }
+  if (sessionId && conversation.processing.pendingAuth.sessionId !== sessionId) {
+    return;
+  }
+  conversation.processing.pendingAuth = void 0;
+}
+async function abandonReplacedPendingAuth(args) {
+  if (args.previousPendingAuth && args.previousPendingAuth.sessionId !== args.nextPendingAuth.sessionId && args.conversationId) {
+    await abandonTurnRecord({
+      conversationId: args.conversationId,
+      turnId: args.previousPendingAuth.sessionId,
+      errorMessage: "Abandoned by a newer auth-blocked request in the same conversation."
+    });
+  }
+}
+function isPendingAuthLatestRequest(conversation, pendingAuth) {
+  for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
+    const message = conversation.messages[index];
+    if (message?.role !== "user") {
+      continue;
+    }
+    if (message.author?.isBot) {
+      continue;
+    }
+    if (isSkippedNonRequest(message.meta?.skippedReason)) {
+      continue;
+    }
+    return buildDeterministicTurnId(message.id) === pendingAuth.sessionId;
+  }
+  return false;
+}
+
+export {
+  buildDeterministicTurnId,
+  buildDeterministicAssistantMessageId,
+  ConversationTurnBoundaryError,
+  getConversationTurnBoundaryError,
+  CooperativeTurnYieldError,
+  isCooperativeTurnYieldError,
+  TurnInputCommitLostError,
+  isTurnInputCommitLostError,
+  TurnInputDeferredError,
+  isTurnInputDeferredError,
+  startActiveTurn,
+  markTurnClosed,
+  markTurnCompleted,
+  markTurnFailed,
+  NO_REPLY_MARKER,
+  isNoReplyMarker,
+  containsNoReplyMarker,
+  sanitizeAssistantText,
+  decideReply,
+  getAssistantReplyText,
+  canReusePendingAuthLink,
+  getConversationPendingAuth,
+  clearPendingAuth,
+  abandonReplacedPendingAuth,
+  isPendingAuthLatestRequest
+};

package/dist/{chunk-R5NWWYIS.js → chunk-HZHUMCNV.js}

@@ -1,6 +1,6 @@
 import {
   createAndEnqueueAgentInvocation
-} from "./chunk-GPLAT6H7.js";
+} from "./chunk-LCNPXLE7.js";
 import {
   actorFromRun,
   toolInvocationDestination
@@ -18,16 +18,16 @@ function bindSpawnAgent(run, options) {
     const invocation = await createAndEnqueueAgentInvocation(
       {
         actor,
-        ...input.name ? { agentName: input.name } : {},
-        ...run.credentialContext ? { credentialContext: run.credentialContext } : {},
+        ...input.name ? { agentName: input.name } : void 0,
+        ...run.credentialContext ? { credentialContext: run.credentialContext } : void 0,
         destination: toolInvocationDestination(run),
         ...run.destinationVisibility ? {
           destinationVisibility: run.destinationVisibility
-        } : {},
+        } : void 0,
         idempotencyKey: `${run.turnId}:${call.toolCallId}`,
         input: input.task,
         parentConversationId: run.conversationId,
-        ...input.reasoningLevel ? { reasoningLevel: input.reasoningLevel } : {},
+        ...input.reasoningLevel ? { reasoningLevel: input.reasoningLevel } : void 0,
         source: run.source
       },
       { ...options, queue }

package/dist/{chunk-RTRBYSF3.js → chunk-IJ6SS4WB.js}

@@ -1,6 +1,6 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-YFNAMRGE.js";
+} from "./chunk-HEBMSITT.js";
 
 // src/chat/plugins/validation.ts
 import { isDeepStrictEqual } from "util";

package/dist/{chunk-B6ECUSVX.js → chunk-IKKETMQC.js}

@@ -6,14 +6,14 @@ import {
   isStale,
   runNonInteractiveCommand,
   sleep
-} from "./chunk-JMJNFEDC.js";
+} from "./chunk-KMBU4PJP.js";
 import {
   getStateAdapter
-} from "./chunk-3TM3FYLQ.js";
+} from "./chunk-PL57B6NC.js";
 import {
   setSpanAttributes,
   withSpan
-} from "./chunk-HQNE5APD.js";
+} from "./chunk-EBMRB6Z6.js";
 
 // src/chat/sandbox/resources.ts
 var configuredResources;
@@ -57,9 +57,9 @@ function setSnapshotSpanAttributes(snapshot) {
     "app.sandbox.source": snapshot.snapshotId ? "snapshot" : "created",
     "app.sandbox.snapshot.cache_hit": snapshot.cacheHit,
     "app.sandbox.snapshot.resolve_outcome": snapshot.resolveOutcome,
-    ...snapshot.profileHash ? { "app.sandbox.snapshot.profile_hash": snapshot.profileHash } : {},
+    ...snapshot.profileHash ? { "app.sandbox.snapshot.profile_hash": snapshot.profileHash } : void 0,
     "app.sandbox.snapshot.dependency_count": snapshot.dependencyCount,
-    ...snapshot.rebuildReason ? { "app.sandbox.snapshot.rebuild_reason": snapshot.rebuildReason } : {}
+    ...snapshot.rebuildReason ? { "app.sandbox.snapshot.rebuild_reason": snapshot.rebuildReason } : void 0
   });
 }
 async function trace(name, op, attributes, callback) {
@@ -283,7 +283,7 @@ async function postinstall(sandbox, commands, signal, timeoutMs) {
           pathPrefix: `${SANDBOX_WORKSPACE_ROOT}/.junior/bin:$PATH`,
           signal,
           timeoutMs,
-          ...command.sudo !== void 0 ? { sudo: command.sudo } : {}
+          ...command.sudo !== void 0 ? { sudo: command.sudo } : void 0
         });
         if (result.exitCode !== 0) {
           const detail = result.stderr.trim() || result.stdout.trim() || "command failed";
@@ -460,7 +460,7 @@ async function build(value, runtime, timeoutMs, signal, prepare) {
           runtime,
           signal,
           ...sandboxCredentials ?? {},
-          ...resources ? { resources } : {}
+          ...resources ? { resources } : void 0
         })
       );
       try {
@@ -680,7 +680,7 @@ async function resolve(params) {
         ),
         createdAtMs: lockResult.createdAtMs,
         buildDurationMs: lockResult.buildDurationMs,
-        ...rebuildReason ? { rebuildReason } : {}
+        ...rebuildReason ? { rebuildReason } : void 0
       };
     }
   );

package/dist/{chunk-R6U7N4FS.js → chunk-KKSVCHDO.js}

@@ -1,10 +1,10 @@
-import {
-  DEFAULT_SQL_STATEMENT_TIMEOUT_MS
-} from "./chunk-GENV6KF2.js";
 import {
   juniorDestinations,
   timestamptz
 } from "./chunk-VFUK3X5B.js";
+import {
+  DEFAULT_SQL_STATEMENT_TIMEOUT_MS
+} from "./chunk-XYTJUHRZ.js";
 
 // src/db/neon.ts
 import { AsyncLocalStorage } from "async_hooks";
@@ -655,6 +655,7 @@ var juniorSchedulerRuns = pgTable16(
 // src/db/schema/snapshots.ts
 import { sql as sql6 } from "drizzle-orm";
 import {
+  bigint as bigint4,
   check as check2,
   index as index13,
   integer as integer6,
@@ -699,6 +700,8 @@ var juniorSnapshots = pgTable18(
     // Ready artifact facts.
     snapshotId: text18("snapshot_id"),
     buildDurationMs: integer6("build_duration_ms"),
+    // Provider snapshot size when the capture response includes it.
+    sizeBytes: bigint4("size_bytes", { mode: "number" }),
     generatedAt: timestamptz("generated_at"),
     // Builder references for check-in and snapshot-owner cleanup.
     buildStartedAt: timestamptz("build_started_at"),
@@ -730,6 +733,10 @@ var juniorSnapshots = pgTable18(
       "junior_snapshots_build_duration_check",
       sql6`${table.buildDurationMs} is null or ${table.buildDurationMs} >= 0`
     ),
+    check2(
+      "junior_snapshots_size_bytes_check",
+      sql6`${table.sizeBytes} is null or ${table.sizeBytes} >= 0`
+    ),
     // Provider snapshot ids are unique. Nulls stay allowed for in-flight rows.
     uniqueIndex8("junior_snapshots_snapshot_id_uidx").on(table.snapshotId),
     index13("junior_snapshots_workspace_idx").on(table.workspaceId),

package/dist/{chunk-JMJNFEDC.js → chunk-KMBU4PJP.js}

@@ -1,13 +1,13 @@
 import {
   toOptionalTrimmed
-} from "./chunk-GENV6KF2.js";
+} from "./chunk-XYTJUHRZ.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-YFNAMRGE.js";
+} from "./chunk-HEBMSITT.js";
 import {
   setSpanAttributes,
   setSpanStatus
-} from "./chunk-HQNE5APD.js";
+} from "./chunk-EBMRB6Z6.js";
 
 // src/chat/sandbox/paths.ts
 function normalizeWorkspaceRoot(input) {
@@ -98,10 +98,10 @@ function buildNonInteractiveCommand(input) {
 async function runNonInteractiveCommand(sandbox, input) {
   const command = {
     ...buildNonInteractiveCommand(input),
-    ...input.cwd ? { cwd: input.cwd } : {},
-    ...input.signal ? { signal: input.signal } : {},
-    ...input.sudo !== void 0 ? { sudo: input.sudo } : {},
-    ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {}
+    ...input.cwd ? { cwd: input.cwd } : void 0,
+    ...input.signal ? { signal: input.signal } : void 0,
+    ...input.sudo !== void 0 ? { sudo: input.sudo } : void 0,
+    ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : void 0
   };
   return await sandbox.runCommand(command);
 }
@@ -344,7 +344,7 @@ function create(runtime, workspace) {
       rebuildEpoch,
       dependencies,
       postinstall,
-      ...workspace ? { workspace: workspaceRecipe(workspace) } : {}
+      ...workspace ? { workspace: workspaceRecipe(workspace) } : void 0
     })
   ).digest("hex");
   return {
@@ -399,44 +399,6 @@ function getVercelSandboxCredentials() {
   return void 0;
 }
 
-// src/chat/sandbox/snapshot/waiting-error.ts
-var WorkspaceSnapshotWaitingError = class extends Error {
-  code = "workspace_snapshot_waiting";
-  workspaceName;
-  constructor(workspaceName) {
-    super(
-      `Workspace ${workspaceName} snapshot is still building; yielded for requeue`
-    );
-    this.name = "WorkspaceSnapshotWaitingError";
-    this.workspaceName = workspaceName;
-  }
-};
-function isWorkspaceSnapshotWaitingResult(details) {
-  if (!details || typeof details !== "object" || Array.isArray(details)) {
-    return false;
-  }
-  const record = details;
-  return record.timed_out === true && record.waiting === "workspace_snapshot" && typeof record.workspace?.name === "string" && record.workspace.name.length > 0;
-}
-function workspaceNameFromWaitingResult(details) {
-  if (!isWorkspaceSnapshotWaitingResult(details)) return void 0;
-  const name = details.workspace?.name;
-  return typeof name === "string" ? name : void 0;
-}
-function isWorkspaceSnapshotWaitingError(error) {
-  const seen = /* @__PURE__ */ new Set();
-  let current = error;
-  while (current && !seen.has(current)) {
-    if (current instanceof WorkspaceSnapshotWaitingError) return true;
-    if (current instanceof Error && (current.name === "WorkspaceSnapshotWaitingError" || current.code === "workspace_snapshot_waiting")) {
-      return true;
-    }
-    seen.add(current);
-    current = typeof current === "object" ? current.cause : void 0;
-  }
-  return false;
-}
-
 // src/chat/sandbox/http-error-details.ts
 var DEFAULT_PREVIEW_LIMIT = 512;
 function toTrimmedString(value, maxChars) {
@@ -653,9 +615,6 @@ function isSandboxCommandStreamInterruptedError(error) {
   });
 }
 function wrapSandboxSetupError(error) {
-  if (isWorkspaceSnapshotWaitingError(error)) {
-    return error instanceof Error ? error : new Error(String(error));
-  }
   try {
     const details = getSandboxErrorDetails(error);
     if (details.summary) {
@@ -683,7 +642,7 @@ function throwSandboxOperationError(action, error, includeMissingPath = false) {
     ...details.attributes,
     ...includeMissingPath ? {
       "app.sandbox.api_error.missing_path": details.searchableText.includes("no such file") || details.searchableText.includes("enoent")
-    } : {},
+    } : void 0,
     "app.sandbox.success": false
   });
   setSpanStatus("error");
@@ -703,10 +662,6 @@ export {
   sandboxSkillDir,
   sandboxSkillFile,
   sandboxSkillPathResolution,
-  WorkspaceSnapshotWaitingError,
-  isWorkspaceSnapshotWaitingResult,
-  workspaceNameFromWaitingResult,
-  isWorkspaceSnapshotWaitingError,
   sleep,
   buildCommandScript,
   buildNonInteractiveShellScript,

package/dist/chunk-KQZX24QQ.js

@@ -0,0 +1,164 @@
+import {
+  QUEUE_SIGNATURE_MAX_AGE_MS,
+  createVercelQueueClient,
+  signQueueMessage,
+  verifyQueueMessage
+} from "./chunk-7H2VZTWN.js";
+import {
+  runWithTurnRequestDeadline
+} from "./chunk-GPA3ZSYY.js";
+import {
+  logWarn
+} from "./chunk-EBMRB6Z6.js";
+
+// src/chat/plugins/task-queue.ts
+import { createHash } from "crypto";
+import { z } from "zod";
+
+// src/chat/queue/callback.ts
+import {
+  handleCallback,
+  registerDevConsumer
+} from "@vercel/queue";
+function queueCallback(options) {
+  const handler = async (value, metadata) => {
+    if (options.skip?.(metadata)) {
+      return;
+    }
+    const checked = options.verify(value);
+    if (checked.status === "rejected") {
+      options.onRejected(checked.reason, metadata);
+      return;
+    }
+    if (checked.status === "unavailable") {
+      throw new Error(
+        `Queue message verification unavailable: ${checked.reason}`
+      );
+    }
+    try {
+      await runWithTurnRequestDeadline(
+        () => options.run(checked.message, metadata)
+      );
+    } catch (error) {
+      const reason = options.permanentError?.(error);
+      if (!reason) {
+        throw error;
+      }
+      options.onRejected(reason, metadata, error);
+    }
+  };
+  const retry = (error, metadata) => {
+    const reason = options.permanentError?.(error);
+    if (reason) {
+      options.onRejected(reason, metadata, error);
+      return { acknowledge: true };
+    }
+    if (options.maxDeliveries !== null && metadata.deliveryCount >= options.maxDeliveries) {
+      return { acknowledge: true };
+    }
+    return void 0;
+  };
+  const visibility = options.visibilityTimeoutSeconds === void 0 ? {} : { visibilityTimeoutSeconds: options.visibilityTimeoutSeconds };
+  return {
+    create: () => handleCallback(handler, { retry, ...visibility }),
+    registerDev: () => {
+      if (process.env.NODE_ENV !== "development") {
+        return void 0;
+      }
+      return registerDevConsumer({
+        client: createVercelQueueClient(),
+        consumerGroup: options.consumerGroup,
+        handler,
+        retry,
+        topic: options.topic,
+        ...visibility
+      });
+    }
+  };
+}
+
+// src/chat/plugins/task-queue.ts
+var PLUGIN_TASK_QUEUE_TOPIC = "junior_plugin_tasks";
+var PLUGIN_TASK_DEV_CONSUMER_GROUP = "junior_plugin_tasks_dev";
+var PLUGIN_TASK_MAX_DELIVERIES = 5;
+var PLUGIN_TASK_SIGN_CONTEXT = "junior.plugin_task_queue.v1";
+var PLUGIN_TASK_SIGN_VERSION = "v1";
+var pluginTaskParamsSchema = z.object({
+  conversationId: z.string().min(1),
+  sessionId: z.string().min(1)
+}).strict();
+var pluginTaskQueueMessageSchema = z.object({
+  name: z.string().min(1),
+  params: pluginTaskParamsSchema,
+  plugin: z.string().min(1)
+}).strict();
+var pluginTaskSign = {
+  context: PLUGIN_TASK_SIGN_CONTEXT,
+  schema: pluginTaskQueueMessageSchema,
+  signatureVersion: PLUGIN_TASK_SIGN_VERSION,
+  parts: (message) => [
+    message.plugin,
+    message.name,
+    message.params.conversationId,
+    message.params.sessionId
+  ]
+};
+function pluginTaskId(args) {
+  const digest = createHash("sha256").update(args.plugin).update("\0").update(args.name).update("\0").update(args.params.conversationId).update("\0").update(args.params.sessionId).digest("hex").slice(0, 32);
+  return `plugin-task_${digest}`;
+}
+function signPluginTaskQueueMessage(message, nowMs = Date.now()) {
+  return signQueueMessage(pluginTaskSign, message, nowMs);
+}
+function verifyPluginTaskQueueMessage(value, nowMs = Date.now()) {
+  return verifyQueueMessage(pluginTaskSign, value, nowMs);
+}
+function logPluginTaskQueueMessageRejected(reason, metadata) {
+  logWarn("plugin.task.queue_message.rejected", {
+    "app.queue.consumer_group": metadata.consumerGroup,
+    "app.queue.delivery_count": metadata.deliveryCount,
+    "app.queue.message_id": metadata.messageId,
+    "app.queue.reject_reason": reason,
+    "app.queue.topic_name": metadata.topicName
+  });
+}
+function pluginTaskCallback() {
+  return queueCallback({
+    consumerGroup: PLUGIN_TASK_DEV_CONSUMER_GROUP,
+    maxDeliveries: PLUGIN_TASK_MAX_DELIVERIES,
+    onRejected: logPluginTaskQueueMessageRejected,
+    // Load the runner on first use so this module can send without a cycle.
+    run: async (message) => {
+      const { processPluginTask } = await import("./task-runner-4IXKKZHL.js");
+      await processPluginTask(message);
+    },
+    topic: PLUGIN_TASK_QUEUE_TOPIC,
+    verify: verifyPluginTaskQueueMessage
+  });
+}
+async function sendVercelPluginTask(message) {
+  await createVercelQueueClient().send(
+    PLUGIN_TASK_QUEUE_TOPIC,
+    signPluginTaskQueueMessage(message),
+    {
+      idempotencyKey: pluginTaskId(message),
+      retentionSeconds: QUEUE_SIGNATURE_MAX_AGE_MS / 1e3
+    }
+  );
+}
+function createVercelPluginTaskCallback() {
+  return pluginTaskCallback().create();
+}
+function registerVercelPluginTaskDevConsumer() {
+  return pluginTaskCallback().registerDev();
+}
+
+export {
+  queueCallback,
+  PLUGIN_TASK_QUEUE_TOPIC,
+  pluginTaskParamsSchema,
+  pluginTaskId,
+  sendVercelPluginTask,
+  createVercelPluginTaskCallback,
+  registerVercelPluginTaskDevConsumer
+};