@rei-standard/amsg-server 2.6.0-next.31 → 2.6.0-next.33

package/README.md

@@ -364,6 +364,16 @@ hook 在 `pushPayloads` 里自己写了这几个字段的话会被库覆盖：
 
 配上 `hooks: { onBeforeFire, onLLMOutput, executeToolCalls }` 之后，AI 类任务的 prompt 不再是排程那一刻冻结的文本，而是 cron 触发时现场组装，工具也在服务端就地跑完，全程不需要客户端在线。完整用法见 [`examples/cloudflare-single-user/README.md`](https://github.com/Tosd0/ReiStandard/blob/main/packages/rei-standard-amsg/server/examples/cloudflare-single-user/README.md) 的「Fire 时刻 hooks」。
 
+`onBeforeFire` 的返回值决定这次触发怎么走：
+
+| 返回值 | 这次触发怎么走 |
+|---|---|
+| 消息数组，或 `{ messages, maxToolIterations?, totalTimeoutMs?, tools?, toolChoice? }` | 用这份 prompt 生成 |
+| `{ skip: true }` | 这次不发，按零推送的成功收场：一次性任务删掉、循环任务推进到下一次 |
+| `{ defer: { afterMs } }` | 现在不合适，`afterMs` 毫秒后再来问。见下面[推迟这次触发](#推迟这次触发defer) |
+| `null` | 交还给排程时冻结的 prompt |
+| 抛错 | 按投递失败处理：占一次重试、写 `last_error`、2 / 4 / 6 分钟退避 |
+
 三个 hook 拿到的 ctx 上都有这几个口子：
 
 | ctx 上的口子 | 干什么 |
@@ -383,6 +393,41 @@ hook 在 `pushPayloads` 里自己写了这几个字段的话会被库覆盖：
 
 `sessionId` 是给日志和去重用的不透明字符串，格式随版本变，别拆它拿上面这些值。
 
+### 推迟这次触发（defer）
+
+任务到点了，但宿主这会儿不方便生成——比如同一段对话里正有另一轮回复在生成，想等它结束再说。`onBeforeFire` 返回 `{ defer: { afterMs } }`：
+
+```js
+async onBeforeFire(ctx) {
+  if (await isConversationBusy(ctx)) return { defer: { afterMs: 30_000 } };
+  return buildMessages(ctx);
+}
+```
+
+这一次不调 LLM、不推送，也不调 `onLLMOutput` / `onAfterSend`。任务行上只有两处变化：`retry_after` 写成现在 + `afterMs`，租约放掉。到点之后 cron 把它重新捞起来，从 `onBeforeFire` 再走一遍，那时可以继续推迟。
+
+跟抛错重试的区别：
+
+| | 抛错 | `{ defer }` |
+|---|---|---|
+| `retry_count` | 加一，用完就终审 | 不变 |
+| `last_error` | 写上这次的原因 | 不写，也不清已有的 |
+| 多久之后再来 | 固定 2 / 4 / 6 分钟 | 宿主给的 `afterMs` |
+| `onFireSettled` 的 `status` | `failed` | `deferred`，带 `retryAfter` |
+
+两边相同的是 `next_send_at` 都不动：它一直是这次触发的名义时刻，`ctx.task.nextSendAt`、`occurrenceMs`、推送的 `messageId` 在推迟前后都是同一套。循环任务被推迟时不会推进到下一次。
+
+几条规矩：
+
+- `afterMs` 必须是有限正数，最大 24 小时（导出为 `MAX_DEFER_AFTER_MS`）。不合法的值按 hook 契约违约处理（`AGENTIC_BAD_BEFORE_FIRE`，一跳终审）。没有下限，但 cron 一分钟一跳，实际是「到点之后的第一跳」才会再问；用 `runTask` 自己触发的话，到点之前调它会得到 `retry_pending`。
+- 推迟不会让任务永远挂着。名义时刻过去超过 `staleAfterMs`（默认 60 分钟）的任务照常按过期处理：一次性任务标 `failed`、循环任务快进到下一次，并调 `onStaleSkip`。某次推迟的唤醒时刻已经越过这条线时，库不再等那一轮，当场按过期收场——这时宿主会先收到 `status: 'deferred'` 的 `onFireSettled`，紧接着收到 `onStaleSkip`。
+- 每次被重新问到都是一次新的 fire：`scratch` 是新的，`onFireSettled` 各调各的。
+- 只有定时投递（`runScheduledTick`、单用户 Worker 的 `scheduled()`、`runTask`）支持推迟，并且适配器要实现 `claimTask`（任务表有 `retry_after` 列，内置适配器都有）。`messageType: 'instant'` 在请求里当场投递的任务、以及没实现 `claimTask` 的自定义适配器返回 `{ defer }` 会得到 `AGENTIC_DEFER_UNSUPPORTED`，按[部署配错了算可重试](#部署配错了算可重试)处理。
+- 内容已经落进收件箱、只是推送没发完的重试不调 `onBeforeFire`（见[生成成功之后推送失败：只补推送](#生成成功之后推送失败只补推送)），那一跳也就不会被推迟。
+- 配了 `serializeBy` 时，被推迟的任务不占着分组：同组里排在它后面的任务可以先跑。
+
+tick 汇总的 `details.deferredTasks`（`{ taskId, retryAfter }`）列出这一跳被推迟的任务，它们不计入 `successCount` / `failedCount`。`GET /capabilities` 的 features 里有 `before-fire-defer`。
+
 ### config 级 hook
 
 这两个挂在 worker 工厂 config 的顶层（不在 `hooks` 里）：
@@ -390,7 +435,7 @@ hook 在 `pushPayloads` 里自己写了这几个字段的话会被库覆盖：
 | hook | 什么时候调 | 载荷 |
 |---|---|---|
 | `onAfterSend` | fire 的 pushPayloads 逐段发完，或中途发挂 | `{ task, sentCount, pushedCount, total, error, usage, usageTotal, llmCalls, outboxed, scratch, readState, writeState, emitResult }` |
-| `onFireSettled` | 一次 fire 收尾——只要 `onBeforeFire` 被调用过，什么结局都调一次 | `{ task, status, skipReason, sentCount, pushedCount, total, iterations, error, metadata, usage, usageTotal, llmCalls, outboxed, scratch, readState, writeState, emitResult }` |
+| `onFireSettled` | 一次 fire 收尾——只要 `onBeforeFire` 被调用过，什么结局都调一次 | `{ task, status, skipReason, retryAfter, sentCount, pushedCount, total, iterations, error, metadata, usage, usageTotal, llmCalls, outboxed, scratch, readState, writeState, emitResult }` |
 | `onStaleSkip` | 任务错过触发时刻超过 60 分钟、这一次（或这几次）不再补发 | `{ reason, action, metadata, recurrenceType, occurrenceMs, skippedCount, skippedOccurrences, skippedTruncated, nextSendAt, readState, writeState, emitResult }` |
 
 三个 hook 都自带 `readState` / `writeState` / `emitResult`，作用于当前用户，语义与 fire 级那套一致。`onStaleSkip` 尤其需要：服务停摆恢复后的第一跳里可能一次 fire 都没跑过，而那正是它要留痕迹的时候。
@@ -405,7 +450,9 @@ hook 在 `pushPayloads` 里自己写了这几个字段的话会被库覆盖：
 |---|---|
 | `sent` | pushPayloads 全部发完（`sentCount === total`） |
 | `skipped` | 这次不发。`skipReason` 区分是 `onBeforeFire` 直接 `{ skip: true }`（`'before-fire'`）还是模型跑完后判定不发（`'skip-push'`） |
+| `deferred` | `onBeforeFire` 返回了 `{ defer: { afterMs } }`：这次没生成也没发，任务还在。`retryAfter`（ISO 时刻）之后会从 `onBeforeFire` 重新走一遍；这个字段在其余结局都是 `null` |
 | `failed` | 链路抛错，`error` 带原始错误。发到第 k 段挂了也是这个：`sentCount = k`、`total` 是原本要发的段数 |
+| `cancelled` | 任务在投递期间被取消或顶替，见[取消正在执行的任务](#取消正在执行的生成与工具) |
 | `not-handled` | `onBeforeFire` 返回 `null`，这条任务交还给排程时冻结的 prompt 老链路。那条链路不归 fire hook 管，它后面发没发出去不体现在这里 |
 
 **用量记账**看这三个字段，两个 hook 都带，`onFireSettled` 的每种结局（发完、跳过、失败）都带——失败也花了钱：
@@ -507,7 +554,7 @@ const { messageId, pushed } = await ctx.emitResult({
 
 ### hook 契约违约算确定性失败
 
-宿主 hook 返回了库不认的东西（`onBeforeFire` 的返回形状、`onLLMOutput` 的决策标签），或者建后续任务时 `createTask` 没把行交回来——这些错误带 `permanent: true` 和一个稳定的 `code`（`AGENTIC_BAD_BEFORE_FIRE` / `AGENTIC_BAD_DECISION` / `AGENTIC_SCHEDULE_FAILED` / `TASK_PAYLOAD_TOO_LARGE`），投递侧据此跳过退避阶梯：一次性任务直接标 `failed`，循环任务作废本次 occurrence。重试也是同一个结果，而每重试一轮都要把 `onBeforeFire` 和一整轮 LLM 重跑一遍。
+宿主 hook 返回了库不认的东西（`onBeforeFire` 的返回形状、`{ defer }` 里不合法的 `afterMs`、`onLLMOutput` 的决策标签），或者建后续任务时 `createTask` 没把行交回来——这些错误带 `permanent: true` 和一个稳定的 `code`（`AGENTIC_BAD_BEFORE_FIRE` / `AGENTIC_BAD_DECISION` / `AGENTIC_SCHEDULE_FAILED` / `TASK_PAYLOAD_TOO_LARGE`），投递侧据此跳过退避阶梯：一次性任务直接标 `failed`，循环任务作废本次 occurrence。重试也是同一个结果，而每重试一轮都要把 `onBeforeFire` 和一整轮 LLM 重跑一遍。
 
 分界线是「谁写错了」：契约由宿主代码定死，重掷一次还是同一个形状；而模型这一轮掷出了什么则是每轮都可能不同的。所以「tool-request 决策里没有能解析的 `toolCalls`」（`AGENTIC_EMPTY_TOOL_REQUEST`）和「轮数用尽也没等到 `finish` / `skip-push`」（`AGENTIC_LOOP_EXCEEDED`）带 `code` 但不带 `permanent`，留在退避阶梯上——隔两分钟重掷一次多半就正常收尾了，判终态的话一次性任务第一次掷歪就永久 `failed`，行离开 `pending` 之后连 `PUT /update-message` 都救不回来（回 409）。
 
@@ -940,3 +987,30 @@ VERCEL_PROTECTION_BYPASS=YOUR_BYPASS_KEY
 - [SW 包 README](https://github.com/Tosd0/ReiStandard/blob/main/packages/rei-standard-amsg/sw/README.md)
 - [API 技术规范](https://github.com/Tosd0/ReiStandard/blob/main/standards/active-messaging-api.md)
 - [Service Worker 规范](https://github.com/Tosd0/ReiStandard/blob/main/standards/service-worker-specification.md)
+
+
+## 取消正在执行的生成与工具
+
+任务被 `DELETE /cancel-message` 取消或被新任务顶替后，租约心跳发现任务已经失效，会中断正在等待的模型请求，阻止新的模型轮次、工具阶段和推送。`leaseHeartbeatMs` 默认仍为 30000；需要及时停止的交互应用可配置为 1000（每个正在执行的任务每秒续租一次）。这是跨请求的数据库检测，延迟取决于心跳和数据库响应，不承诺瞬时中断。自定义适配器需要支持 `claimTask` / `renewTaskLease`；关掉心跳时也关掉了这条主动检测路径。
+
+`onBeforeFire`、`onLLMOutput`、`executeToolCalls` 的 context 以及 `onFireSettled` 回执新增：
+
+- `signal: AbortSignal`：传给工具内部的 `fetch`，与工具自己的超时信号合并。
+- `isCancelled(): boolean`：当前是否已收到取消信号。
+- `throwIfCancelled(): void`：已取消时抛出 `code: 'TASK_CANCELLED'` 的错误。每个副作用开始前检查，工具 catch 中也要先调用它，以免取消被转成普通工具失败后继续执行。
+
+```js
+async function executeToolCalls(calls, ctx) {
+  const results = [];
+  for (const call of calls) {
+    ctx.throwIfCancelled();
+    const response = await fetch(toolUrl(call), { signal: ctx.signal });
+    results.push({ tool_call_id: call.id, role: 'tool', content: await response.text() });
+  }
+  return results;
+}
+```
+
+取消收尾使用 `onFireSettled({ status: 'cancelled', willRetry: false, error, ... })`，不是生成失败。应用应在这里释放资源、结算已发生的用量，避免发出失败提示或把未送达内容记为已回复。取消时已经开始写入的 outbox 批次会在写完后检查信号并撤掉未投递部分；已经发到客户端的消息仍由客户端处理。应用需要记录停止的任务身份，拦住迟到推送、补收以及尚未显示的本地内容。已完成的外部副作用无法撤销；不支持 AbortSignal 的工具也需要自己在执行步骤之间检查取消。
+
+执行阶段的 `ctx.writeState`、`scheduleTask`、`cancelTask`、`renewTask` 和 `emitResult` 会拒绝取消后新发起的操作。`onFireSettled` 的 `info.writeState` 特意仍可用，供宿主释放锁、保存账单等收尾；它不能用于继续生成阶段的业务动作。已经开始的数据库写入不支持回滚，宿主仍需处理并发状态版本。

package/dist/{chunk-7TM3MH3Q.cjs → chunk-AM2MMY46.cjs}

@@ -1636,6 +1636,7 @@ var DEFAULT_MAX_TOOL_ITERATIONS = 5;
 var DEFAULT_TOTAL_TIMEOUT_MS = 24e4;
 var DEFAULT_MAX_SCHEDULED_TASKS_PER_FIRE = 2;
 var MIN_SCHEDULE_LEAD_MS = 6e4;
+var MAX_DEFER_AFTER_MS = 24 * 60 * 60 * 1e3;
 var SCHEDULABLE_MESSAGE_TYPES = /* @__PURE__ */ new Set(["auto", "prompted", "fixed"]);
 var SCHEDULABLE_RECURRENCE_TYPES = /* @__PURE__ */ new Set(["none", "daily", "weekly"]);
 var SLEEP_BETWEEN_MESSAGES_MS = 1500;
@@ -1670,6 +1671,22 @@ function buildHookTask(task, decryptedPayload) {
     retryCount: _nullishCoalesce(task.retry_count, () => ( 0))
   });
 }
+var BAD_BEFORE_FIRE_MESSAGE = "AGENTIC_BAD_BEFORE_FIRE: onBeforeFire must return ChatMessage[] | { messages, maxToolIterations?, totalTimeoutMs?, tools?, toolChoice? } | { skip: true } | { defer: { afterMs } } | null";
+function readDeferAfterMs(defer) {
+  const afterMs = defer && typeof defer === "object" ? (
+    /** @type {any} */
+    defer.afterMs
+  ) : void 0;
+  if (typeof afterMs !== "number" || !Number.isFinite(afterMs) || afterMs <= 0 || afterMs > MAX_DEFER_AFTER_MS) {
+    throw markPermanent(
+      new TypeError(
+        `${BAD_BEFORE_FIRE_MESSAGE}\uFF08defer.afterMs \u5FC5\u987B\u662F\u6709\u9650\u6B63\u6570\uFF0C\u4E14\u4E0D\u8D85\u8FC7 ${MAX_DEFER_AFTER_MS} \u6BEB\u79D2\uFF09`
+      ),
+      "AGENTIC_BAD_BEFORE_FIRE"
+    );
+  }
+  return afterMs;
+}
 function normalizeBeforeFireResult(result) {
   if (Array.isArray(result)) {
     return { messages: result };
@@ -1686,12 +1703,7 @@ function normalizeBeforeFireResult(result) {
       toolChoice: result.toolChoice
     };
   }
-  throw markPermanent(
-    new TypeError(
-      "AGENTIC_BAD_BEFORE_FIRE: onBeforeFire must return ChatMessage[] | { messages, maxToolIterations?, totalTimeoutMs?, tools?, toolChoice? } | { skip: true } | null"
-    ),
-    "AGENTIC_BAD_BEFORE_FIRE"
-  );
+  throw markPermanent(new TypeError(BAD_BEFORE_FIRE_MESSAGE), "AGENTIC_BAD_BEFORE_FIRE");
 }
 function firstPositiveInt(values, fallback) {
   for (const v of values) {
@@ -1707,6 +1719,17 @@ function firstPositiveNumber(values, fallback) {
 }
 async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
   const hooks = ctx.hooks;
+  const signal = ctx.signal || new AbortController().signal;
+  const isCancelled = () => signal.aborted || _optionalChain([ctx, 'access', _5 => _5.isTaskCancelled, 'optionalCall', _6 => _6()]) === true;
+  const throwIfCancelled = () => {
+    if (!isCancelled()) return;
+    if (isTaskCancelledError(signal.reason)) throw signal.reason;
+    const error = new Error("Task was cancelled or superseded");
+    error.code = "TASK_CANCELLED";
+    throw error;
+  };
+  const cancellation = { signal, isCancelled, throwIfCancelled };
+  ctx = { ...ctx, ...cancellation };
   if (typeof hooks.onLLMOutput !== "function") {
     throw new DeploymentConfigError(
       "AGENTIC_CONFIG_ERROR: hooks.onBeforeFire requires hooks.onLLMOutput to classify LLM rounds",
@@ -1715,13 +1738,17 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
   }
   const nowFn = typeof ctx._agenticNow === "function" ? ctx._agenticNow : Date.now;
   const sleep = typeof ctx._agenticSleep === "function" ? ctx._agenticSleep : defaultSleep;
-  const { readState, writeState } = createStateAccessors({
+  const { readState, writeState: writeSettledState } = createStateAccessors({
     db: ctx.db,
     userId: task.user_id,
     userKey,
     maxStateValueBytes: ctx.maxStateValueBytes,
     now: nowFn
   });
+  const writeState = async (namespace, entries) => {
+    throwIfCancelled();
+    return writeSettledState(namespace, entries);
+  };
   const sessionId = task.id != null ? `sess_task_${task.id}${occurrenceSuffix(task)}` : `sess_${_amsgshared.randomUUID.call(void 0, )}`;
   const messageIdBase = task.id != null ? `msg_task_${task.id}${occurrenceSuffix(task)}` : `msg_${_amsgshared.randomUUID.call(void 0, )}`;
   const occurrenceMs = occurrenceMsOf(task);
@@ -1737,7 +1764,7 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
     now: nowFn,
     // run-tick 在投递 ctx 上挂的取消信号（与 guardWebpushWithLease 读的是同一
     // 个租约状态），emitResult 不发推送的那条路要靠它拦下已取消任务的落行。
-    isCancelled: typeof ctx.isTaskCancelled === "function" ? ctx.isTaskCancelled : null
+    isCancelled
   });
   const maxScheduledTasksPerFire = Number.isInteger(ctx.maxScheduledTasksPerFire) && ctx.maxScheduledTasksPerFire >= 0 ? ctx.maxScheduledTasksPerFire : DEFAULT_MAX_SCHEDULED_TASKS_PER_FIRE;
   let scheduledTaskCount = 0;
@@ -1754,6 +1781,7 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
     }
   }
   const scheduleTask = async (options) => {
+    throwIfCancelled();
     if (!options || typeof options !== "object" || Array.isArray(options)) {
       throw new TypeError("scheduleTask(options) \u9700\u8981\u4E00\u4E2A\u5BF9\u8C61\uFF0C\u81F3\u5C11\u5305\u542B { firstSendTime }");
     }
@@ -1874,6 +1902,7 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
     }
     scheduledTaskCount++;
     const encryptedPayload = await encryptForStorage(serializedTaskData, userKey);
+    throwIfCancelled();
     let created;
     try {
       created = await ctx.db.createTask({
@@ -1908,6 +1937,7 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
     };
   };
   const cancelTask = async (uuid) => {
+    throwIfCancelled();
     if (typeof uuid !== "string" || !uuid.trim()) {
       throw new TypeError("cancelTask(uuid) \u9700\u8981\u975E\u7A7A\u5B57\u7B26\u4E32 uuid");
     }
@@ -1922,6 +1952,7 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
         { code: "AGENTIC_CANCEL_UNSUPPORTED" }
       );
     }
+    throwIfCancelled();
     const cancelled = await ctx.db.deleteTaskByUuid(uuid, task.user_id);
     if (cancelled) {
       await discardUndeliveredPushesForTask({ db: ctx.db, userId: task.user_id, taskUuid: uuid });
@@ -1929,6 +1960,7 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
     return { cancelled: !!cancelled };
   };
   const renewTask = async (uuid, nextSendAt) => {
+    throwIfCancelled();
     if (typeof uuid !== "string" || !uuid.trim()) {
       throw new TypeError("renewTask(uuid, nextSendAt) \u9700\u8981\u975E\u7A7A\u5B57\u7B26\u4E32 uuid");
     }
@@ -1959,6 +1991,7 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
     const payload = JSON.parse(await decryptFromStorage(row.encrypted_payload, userKey));
     const nextSendAtIso = sendAt.toISOString();
     const encrypted = await encryptForStorage(JSON.stringify({ ...payload, firstSendTime: nextSendAtIso }), userKey);
+    throwIfCancelled();
     const updated = await ctx.db.updateTaskByUuid(uuid, task.user_id, encrypted, {
       next_send_at: nextSendAtIso,
       retry_count: 0,
@@ -1979,6 +2012,7 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
   };
   const scratch = {};
   const fireCtx = Object.freeze({
+    ...cancellation,
     task: buildHookTask(task, decryptedPayload),
     userId: task.user_id,
     readState,
@@ -2004,6 +2038,7 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
   };
   let settledStatus = "failed";
   let settledError = null;
+  let settledRetryAfter = null;
   try {
     const outcome = await runFireChain({
       task,
@@ -2027,17 +2062,32 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
       messageIdBase,
       occurrenceMs
     });
-    settledStatus = !outcome.handled ? "not-handled" : outcome.result.status === "skipped" ? "skipped" : "sent";
+    throwIfCancelled();
+    if (!outcome.handled) settledStatus = "not-handled";
+    else if (outcome.result.status === "deferred") {
+      settledStatus = "deferred";
+      settledRetryAfter = outcome.result.retryAfter;
+    } else settledStatus = outcome.result.status === "skipped" ? "skipped" : "sent";
     return outcome;
   } catch (error) {
+    if (isCancelled() && !isTaskCancelledError(error)) {
+      try {
+        throwIfCancelled();
+      } catch (cancelled) {
+        error = cancelled;
+      }
+    }
+    if (isTaskCancelledError(error)) settledStatus = "cancelled";
     settledError = error;
     throw error;
   } finally {
     await notifyFireSettled(ctx, {
       task,
+      ...cancellation,
       status: settledStatus,
-      ...settledStatus === "failed" && ctx._deliveryState ? failureRetryDecision(ctx._deliveryState, settledError) : { willRetry: null, failureStage: null },
+      ...settledStatus === "cancelled" ? { willRetry: false, failureStage: null } : settledStatus === "failed" && ctx._deliveryState ? failureRetryDecision(ctx._deliveryState, settledError) : { willRetry: null, failureStage: null },
       skipReason: settledStatus === "skipped" ? progress.skipReason : null,
+      retryAfter: settledStatus === "deferred" ? settledRetryAfter : null,
       sentCount: progress.sentCount,
       pushedCount: progress.pushedCount,
       total: progress.total,
@@ -2060,7 +2110,7 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
       outboxed: progress.outboxed,
       scratch,
       readState,
-      writeState,
+      writeState: writeSettledState,
       emitResult
     });
   }
@@ -2087,12 +2137,35 @@ async function runFireChain({
   messageIdBase,
   occurrenceMs
 }) {
+  ctx.throwIfCancelled();
   const before = await hooks.onBeforeFire(fireCtx);
+  ctx.throwIfCancelled();
   if (before == null) return { handled: false };
   if (typeof before === "object" && before.skip === true) {
     progress.skipReason = "before-fire";
     return { handled: true, result: { success: true, messagesSent: 0, status: "skipped", iterations: 0 } };
   }
+  if (typeof before === "object" && !Array.isArray(before) && before.defer != null) {
+    const afterMs = readDeferAfterMs(before.defer);
+    if (ctx._deferSupported !== true) {
+      throw new DeploymentConfigError(
+        "AGENTIC_DEFER_UNSUPPORTED: onBeforeFire \u8FD4\u56DE\u4E86 { defer }\uFF0C\u4F46\u8FD9\u6761\u6295\u9012\u8DEF\u5F84\u4E0D\u652F\u6301\u63A8\u8FDF\u2014\u2014\u53EA\u6709 runScheduledTick / runTask \u4E14\u9002\u914D\u5668\u5B9E\u73B0\u4E86 claimTask\uFF08\u4EFB\u52A1\u8868\u6709 retry_after \u5217\uFF09\u65F6\u53EF\u7528\uFF0C\u8BF7\u6C42\u5185\u5F53\u573A\u6295\u9012\u7684 instant \u4EFB\u52A1\u4E0D\u53EF\u7528",
+        { code: "AGENTIC_DEFER_UNSUPPORTED" }
+      );
+    }
+    return {
+      handled: true,
+      result: {
+        success: false,
+        deferred: true,
+        // 用真实时钟：这个时刻要落进 retry_after，跟数据库捞取条件里的「现在」比。
+        retryAfter: new Date(Date.now() + afterMs).toISOString(),
+        messagesSent: 0,
+        status: "deferred",
+        iterations: 0
+      }
+    };
+  }
   const normalized = normalizeBeforeFireResult(before);
   const maxToolIterations = firstPositiveInt(
     [normalized.maxToolIterations, ctx.maxToolIterations],
@@ -2111,6 +2184,7 @@ async function runFireChain({
     decryptedPayload
   });
   for (let iteration = 0; iteration < maxToolIterations; iteration++) {
+    ctx.throwIfCancelled();
     if (nowFn() >= deadline) {
       throw new Error(`AGENTIC_TOTAL_TIMEOUT: fire chain exceeded ${totalTimeoutMs}ms after ${iteration} LLM round(s)`);
     }
@@ -2124,13 +2198,17 @@ async function runFireChain({
         messages,
         ...normalized.tools ? { tools: normalized.tools, toolChoice: normalized.toolChoice } : {}
       },
-      { requireContent: false, timeoutMs: roundTimeoutMs }
+      { requireContent: false, timeoutMs: roundTimeoutMs, signal: ctx.signal }
     );
     const assistantMessage = _amsgshared.extractAssistantMessage.call(void 0, llmResponse);
     messages = [...messages, assistantMessage];
     progress.usage = llmResponse && typeof llmResponse === "object" && llmResponse.usage || null;
     progress.usageTotal = accumulateUsage(progress.usageTotal, progress.usage);
+    ctx.throwIfCancelled();
     const sessionCtx = Object.freeze({
+      signal: ctx.signal,
+      isCancelled: ctx.isCancelled,
+      throwIfCancelled: ctx.throwIfCancelled,
       ..._amsgshared.buildSessionContext.call(void 0, {
         sessionId,
         messages,
@@ -2154,6 +2232,7 @@ async function runFireChain({
       resolveLlmCredential: resolveLlmCredential2
     });
     const decision = await hooks.onLLMOutput(sessionCtx);
+    ctx.throwIfCancelled();
     try {
       _amsgshared.assertValidDecision.call(void 0, decision, { inlineToolCalls: true });
     } catch (error) {
@@ -2204,15 +2283,19 @@ async function runFireChain({
     }
     let toolResults;
     try {
+      ctx.throwIfCancelled();
       toolResults = await hooks.executeToolCalls(toolCalls, sessionCtx);
+      ctx.throwIfCancelled();
       if (!Array.isArray(toolResults)) {
         throw new TypeError('executeToolCalls must resolve to an array of { tool_call_id, role: "tool", content }');
       }
     } catch (error) {
+      ctx.throwIfCancelled();
+      if (isTaskCancelledError(error)) throw error;
       toolResults = toolCalls.map((toolCall) => ({
         tool_call_id: toolCall && typeof toolCall === "object" && typeof toolCall.id === "string" ? toolCall.id : "",
         role: "tool",
-        content: `Tool execution failed: ${_nullishCoalesce(_optionalChain([error, 'optionalAccess', _5 => _5.message]), () => ( String(error)))}`
+        content: `Tool execution failed: ${_nullishCoalesce(_optionalChain([error, 'optionalAccess', _7 => _7.message]), () => ( String(error)))}`
       }));
     }
     const nativeCalls = Array.isArray(assistantMessage.tool_calls) ? assistantMessage.tool_calls : [];
@@ -2298,9 +2381,11 @@ async function sendHookPushPayloads({
       stampTaskIdentity(push, task, decryptedPayload, occurrenceMs);
       finalized.push(push);
     }
+    ctx.throwIfCancelled();
     outboxed = await appendPushesToOutbox({ db: ctx.db, userId: task.user_id, userKey, pushes: finalized });
     progress.outboxed = outboxed;
     if (ctx._deliveryState) ctx._deliveryState.outboxed = outboxed;
+    ctx.throwIfCancelled();
     if (!ctx.vapid || !ctx.vapid.email || !ctx.vapid.publicKey || !ctx.vapid.privateKey) {
       throw new Error("VAPID configuration missing - push notifications cannot be sent");
     }
@@ -2314,6 +2399,7 @@ async function sendHookPushPayloads({
     const willPush = finalized.map((push) => shouldSendPush(push, pushGate));
     const lastPushIndex = willPush.lastIndexOf(true);
     for (let i = 0; i < total; i++) {
+      ctx.throwIfCancelled();
       if (willPush[i]) {
         await sendTaggedPush(ctx.webpush, pushSubscription, JSON.stringify(finalized[i]));
         pushedCount++;
@@ -2577,7 +2663,7 @@ async function processSingleMessage(task, ctx, providedMasterKey, predecrypted =
       const hasChatSource = hasChatCredRef(decryptedPayload) || !!(decryptedPayload.apiUrl && decryptedPayload.apiKey && decryptedPayload.primaryModel);
       if (hasPrompt && hasChatSource) {
         const chatCred = await resolveFireCredentials({ db: ctx.db, userId: task.user_id, userKey, decryptedPayload });
-        const aiResult = await callLlm(chatCred ? { ...decryptedPayload, ...chatCred } : decryptedPayload);
+        const aiResult = await callLlm(chatCred ? { ...decryptedPayload, ...chatCred } : decryptedPayload, { signal: ctx.signal });
         messageContent = aiResult.content;
         llmResponse = aiResult.response;
       } else if (decryptedPayload.userMessage) {
@@ -2587,7 +2673,7 @@ async function processSingleMessage(task, ctx, providedMasterKey, predecrypted =
       }
     } else if (decryptedPayload.messageType === "prompted" || decryptedPayload.messageType === "auto") {
       const chatCred = await resolveFireCredentials({ db: ctx.db, userId: task.user_id, userKey, decryptedPayload });
-      const aiResult = await callLlm(chatCred ? { ...decryptedPayload, ...chatCred } : decryptedPayload);
+      const aiResult = await callLlm(chatCred ? { ...decryptedPayload, ...chatCred } : decryptedPayload, { signal: ctx.signal });
       messageContent = aiResult.content;
       llmResponse = aiResult.response;
     } else {
@@ -3193,6 +3279,7 @@ async function deliverTasks(ctx, tasks) {
     deletedOnceOffTasks: 0,
     updatedRecurringTasks: 0,
     staleTasks: [],
+    deferredTasks: [],
     cancelledTasks: [],
     reasoningSkippedTasks: [],
     redeliveredTasks: [],
@@ -3208,7 +3295,8 @@ async function deliverTasks(ctx, tasks) {
     return !!await db.claimTask(task.id, task.next_send_at, leaseUntil, serializeGroup);
   }
   function startLeaseHeartbeat(task) {
-    const lease = { lost: false, released: false, stop: () => {
+    const controller = new AbortController();
+    const lease = { lost: false, released: false, signal: controller.signal, stop: () => {
     } };
     if (!heartbeatEnabled) return lease;
     let stopped = false;
@@ -3224,6 +3312,9 @@ async function deliverTasks(ctx, tasks) {
       if (renewed === false) {
         if (stopped || lease.released) return;
         lease.lost = true;
+        const error = new Error("Task was cancelled or superseded");
+        error.code = TASK_CANCELLED_CODE;
+        controller.abort(error);
         console.warn(`[amsg-server] \u4EFB\u52A1 ${task.id} \u7684\u79DF\u7EA6\u5DF2\u5931\u6548\uFF08\u884C\u88AB\u53D6\u6D88\u6216\u9876\u66FF\uFF09\uFF0C\u5269\u4F59\u63A8\u9001\u5C06\u4E2D\u6B62`);
         return;
       }
@@ -3482,7 +3573,7 @@ async function deliverTasks(ctx, tasks) {
     const occurrenceMs = Date.parse(task.next_send_at);
     const retryAfterMs = task.retry_after ? Date.parse(task.retry_after) : NaN;
     const notOnFreshRetryChain = (task.retry_count || 0) === 0 || Number.isFinite(retryAfterMs) && Date.now() - retryAfterMs > staleAfterMs;
-    if (Number.isFinite(occurrenceMs) && Date.now() - occurrenceMs > staleAfterMs && notOnFreshRetryChain) {
+    const settleAsStale = async () => {
       try {
         const stateAccessors = createStateAccessors({
           db,
@@ -3542,8 +3633,32 @@ async function deliverTasks(ctx, tasks) {
         results.failedCount++;
         results.failedTasks.push({ taskId: task.id, reason: error.message || "\u8FC7\u671F\u4EFB\u52A1\u5904\u7406\u5931\u8D25", status: "stale_update_failed" });
       }
+    };
+    if (Number.isFinite(occurrenceMs) && Date.now() - occurrenceMs > staleAfterMs && notOnFreshRetryChain) {
+      await settleAsStale();
       return;
     }
+    const handleDeferred = async (retryAfter) => {
+      const wakeMs = Date.parse(retryAfter);
+      if (Number.isFinite(occurrenceMs) && wakeMs - occurrenceMs > staleAfterMs) {
+        await settleAsStale();
+        return;
+      }
+      try {
+        const updated = await updateTaskWithLastError(task.id, {
+          retry_after: retryAfter,
+          lease_until: null
+        });
+        if (rowVanished(updated)) {
+          await recordCancelled(task, "cancelled_mid_delivery");
+          return;
+        }
+        results.deferredTasks.push({ taskId: task.id, retryAfter });
+      } catch (error) {
+        results.failedCount++;
+        results.failedTasks.push({ taskId: task.id, reason: error.message || "\u63A8\u8FDF\u5199\u5E93\u5931\u8D25", status: "defer_update_failed" });
+      }
+    };
     let sendResult;
     try {
       sendResult = await processSingleMessage(
@@ -3553,7 +3668,12 @@ async function deliverTasks(ctx, tasks) {
           db,
           masterKey,
           webpush: guardWebpushWithLease(ctx.webpush, lease),
-          isTaskCancelled: () => lease.lost
+          isTaskCancelled: () => lease.lost,
+          signal: lease.signal,
+          // onBeforeFire 的 { defer } 要靠 retry_after 这一列落地，没实现
+          // claimTask 的适配器没有这一列（见 lib/agentic-fire.js 的
+          // AGENTIC_DEFER_UNSUPPORTED）。
+          _deferSupported: supportsClaim
         },
         masterKey,
         { userKey, payload: decryptedPayload }
@@ -3573,6 +3693,14 @@ async function deliverTasks(ctx, tasks) {
       );
       return;
     }
+    if (sendResult.deferred) {
+      if (lease.lost) {
+        await recordCancelled(task, "cancelled_mid_delivery");
+        return;
+      }
+      await handleDeferred(sendResult.retryAfter);
+      return;
+    }
     if (!sendResult.success) {
       if (lease.lost) {
         await recordCancelled(task, "cancelled_mid_delivery");
@@ -3665,6 +3793,9 @@ async function deliverTasks(ctx, tasks) {
       deletedOnceOffTasks: results.deletedOnceOffTasks,
       updatedRecurringTasks: results.updatedRecurringTasks,
       staleTasks: results.staleTasks,
+      // onBeforeFire 返回 { defer } 被推迟的任务（{ taskId, retryAfter }）：这一
+      // 跳没生成也没发，到 retryAfter 之后再问。不计入 successCount / failedCount。
+      deferredTasks: results.deferredTasks,
       // 投递期间行被取消 / 顶替的任务。`cancelled_mid_delivery` = 推送在发出去
       // 之前被拦下；`cancelled_after_delivery` = 推送已经发完，收尾写库才发现
       // 行没了。两种都不计入 successCount / failedCount。
@@ -5099,7 +5230,7 @@ var D1Adapter = class {
       result.cleanupOutcomes = probeIndexes.map((probeAt) => {
         if (probeAt === null) return null;
         const row = results[probeAt] && Array.isArray(results[probeAt].results) ? results[probeAt].results[0] : null;
-        return Number(_nullishCoalesce(_optionalChain([row, 'optionalAccess', _6 => _6.n]), () => ( 0))) === 0;
+        return Number(_nullishCoalesce(_optionalChain([row, 'optionalAccess', _8 => _8.n]), () => ( 0))) === 0;
       });
     }
     return result;
@@ -5960,7 +6091,7 @@ function createClientStateNamespacesHandler(ctx) {
 }
 
 // src/server/lib/version.js
-var SERVER_VERSION = true ? "2.6.0-next.31" : "0.0.0-dev";
+var SERVER_VERSION = true ? "2.6.0-next.33" : "0.0.0-dev";
 
 // src/server/handlers/capabilities.js
 var SERVER_FEATURES = Object.freeze([
@@ -6073,7 +6204,10 @@ var SERVER_FEATURES = Object.freeze([
   // 工厂配置认 maxDeliveryRetries（投递失败的重试次数上限，默认 3）。
   "max-delivery-retries",
   // Per-task pre-commit retry limit and fire receipt retry decision.
-  "max-generation-retries"
+  "max-generation-retries",
+  // onBeforeFire 认 { defer: { afterMs } }：这次不生成，过一会儿再来问（不占重试
+  // 次数）；onFireSettled 的 status 多一种 'deferred'，带 retryAfter。
+  "before-fire-defer"
 ]);
 function createCapabilitiesHandler(ctx) {
   async function GET(url, headers) {
@@ -6701,4 +6835,5 @@ function createSingleUserCloudflareWorker(buildConfig, options = {}) {
 
 
 
-exports.isValidTimeZoneId = isValidTimeZoneId; exports.advanceOccurrence = advanceOccurrence; exports.planNextOccurrence = planNextOccurrence; exports.nextFutureOccurrence = nextFutureOccurrence; exports.base64UrlToBytes = _amsgshared.base64UrlToBytes; exports.utf8 = _amsgshared.utf8; exports.utf8Decode = _amsgshared.utf8Decode; exports.bytesToBase64Url = _amsgshared.bytesToBase64Url; exports.timingSafeEqualBytes = _amsgshared.timingSafeEqualBytes; exports.deriveUserEncryptionKey = deriveUserEncryptionKey; exports.decryptPayload = decryptPayload; exports.encryptForStorage = encryptForStorage; exports.decryptFromStorage = decryptFromStorage; exports.CRED_ID_MAX_LENGTH = CRED_ID_MAX_LENGTH; exports.CRED_PUT_BATCH_MAX = CRED_PUT_BATCH_MAX; exports.CRED_ROWS_PER_USER_MAX = CRED_ROWS_PER_USER_MAX; exports.CRED_REFS_MAX_ENTRIES = CRED_REFS_MAX_ENTRIES; exports.supportsLlmCredentialsStore = supportsLlmCredentialsStore; exports.isValidCredId = isValidCredId; exports.validateCredValue = validateCredValue; exports.validateCredRefs = validateCredRefs; exports.hasChatCredRef = hasChatCredRef; exports.resolveLlmCredential = resolveLlmCredential; exports.isValidUrl = _amsgshared.isValidUrl; exports.validateAvatarUrl = _amsgshared.validateAvatarUrl; exports.isValidISO8601 = isValidISO8601; exports.isValidUUID = isValidUUID; exports.isValidUUIDv4 = isValidUUIDv4; exports.validateSplitPattern = validateSplitPattern; exports.validateLlmMessagesArray = validateLlmMessagesArray; exports.MAX_TASK_PAYLOAD_BYTES = MAX_TASK_PAYLOAD_BYTES; exports.validateScheduleMessagePayload = validateScheduleMessagePayload; exports.DEFAULT_MAX_REQUEST_BODY_BYTES = DEFAULT_MAX_REQUEST_BODY_BYTES; exports.readRequestBody = readRequestBody; exports.parseJsonBody = parseJsonBody; exports.getHeader = getHeader; exports.createGetUserKeyHandler = createGetUserKeyHandler; exports.NonRetryableError = NonRetryableError; exports.isNonRetryableError = isNonRetryableError; exports.DeploymentConfigError = DeploymentConfigError; exports.sanitizeErrorSummary = sanitizeErrorSummary; exports.summarizeErrorCause = summarizeErrorCause; exports.DEFAULT_MAX_DELIVERY_RETRIES = DEFAULT_MAX_DELIVERY_RETRIES; exports.WEB_PUSH_MAX_BODY_BYTES = WEB_PUSH_MAX_BODY_BYTES; exports.WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES = WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES; exports.MAX_PUSH_PAYLOAD_BYTES = MAX_PUSH_PAYLOAD_BYTES; exports.PUSH_ENVELOPE_RESERVED_BYTES = PUSH_ENVELOPE_RESERVED_BYTES; exports.measurePushPayload = measurePushPayload; exports.createWebCryptoWebPush = createWebCryptoWebPush; exports.DEFAULT_MAX_TOOL_ITERATIONS = DEFAULT_MAX_TOOL_ITERATIONS; exports.DEFAULT_TOTAL_TIMEOUT_MS = DEFAULT_TOTAL_TIMEOUT_MS; exports.DEFAULT_MAX_SCHEDULED_TASKS_PER_FIRE = DEFAULT_MAX_SCHEDULED_TASKS_PER_FIRE; exports.MIN_SCHEDULE_LEAD_MS = MIN_SCHEDULE_LEAD_MS; exports.createScheduleMessageHandler = createScheduleMessageHandler; exports.DEFAULT_CLAIM_LEASE_MS = DEFAULT_CLAIM_LEASE_MS; exports.DEFAULT_LEASE_HEARTBEAT_MS = DEFAULT_LEASE_HEARTBEAT_MS; exports.DEFAULT_HEARTBEAT_LEASE_TTL_MS = DEFAULT_HEARTBEAT_LEASE_TTL_MS; exports.runScheduledTick = runScheduledTick; exports.runTask = runTask; exports.createUpdateMessageHandler = createUpdateMessageHandler; exports.createCancelMessageHandler = createCancelMessageHandler; exports.createMessagesHandler = createMessagesHandler; exports.createGetMessageHandler = createGetMessageHandler; exports.createPushSubscriptionHandler = createPushSubscriptionHandler; exports.createLlmCredentialsHandler = createLlmCredentialsHandler; exports.createD1Adapter = createD1Adapter; exports.createSingleUserServer = createSingleUserServer; exports.SCHEMA_VERSION = SCHEMA_VERSION; exports.getSchemaVersion = getSchemaVersion; exports.ensureSchema = ensureSchema; exports.CORS_ALLOW_HEADERS = CORS_ALLOW_HEADERS; exports.CORS_ALLOW_METHODS = CORS_ALLOW_METHODS; exports.createSingleUserCloudflareWorker = createSingleUserCloudflareWorker;
+
+exports.isValidTimeZoneId = isValidTimeZoneId; exports.advanceOccurrence = advanceOccurrence; exports.planNextOccurrence = planNextOccurrence; exports.nextFutureOccurrence = nextFutureOccurrence; exports.base64UrlToBytes = _amsgshared.base64UrlToBytes; exports.utf8 = _amsgshared.utf8; exports.utf8Decode = _amsgshared.utf8Decode; exports.bytesToBase64Url = _amsgshared.bytesToBase64Url; exports.timingSafeEqualBytes = _amsgshared.timingSafeEqualBytes; exports.deriveUserEncryptionKey = deriveUserEncryptionKey; exports.decryptPayload = decryptPayload; exports.encryptForStorage = encryptForStorage; exports.decryptFromStorage = decryptFromStorage; exports.CRED_ID_MAX_LENGTH = CRED_ID_MAX_LENGTH; exports.CRED_PUT_BATCH_MAX = CRED_PUT_BATCH_MAX; exports.CRED_ROWS_PER_USER_MAX = CRED_ROWS_PER_USER_MAX; exports.CRED_REFS_MAX_ENTRIES = CRED_REFS_MAX_ENTRIES; exports.supportsLlmCredentialsStore = supportsLlmCredentialsStore; exports.isValidCredId = isValidCredId; exports.validateCredValue = validateCredValue; exports.validateCredRefs = validateCredRefs; exports.hasChatCredRef = hasChatCredRef; exports.resolveLlmCredential = resolveLlmCredential; exports.isValidUrl = _amsgshared.isValidUrl; exports.validateAvatarUrl = _amsgshared.validateAvatarUrl; exports.isValidISO8601 = isValidISO8601; exports.isValidUUID = isValidUUID; exports.isValidUUIDv4 = isValidUUIDv4; exports.validateSplitPattern = validateSplitPattern; exports.validateLlmMessagesArray = validateLlmMessagesArray; exports.MAX_TASK_PAYLOAD_BYTES = MAX_TASK_PAYLOAD_BYTES; exports.validateScheduleMessagePayload = validateScheduleMessagePayload; exports.DEFAULT_MAX_REQUEST_BODY_BYTES = DEFAULT_MAX_REQUEST_BODY_BYTES; exports.readRequestBody = readRequestBody; exports.parseJsonBody = parseJsonBody; exports.getHeader = getHeader; exports.createGetUserKeyHandler = createGetUserKeyHandler; exports.NonRetryableError = NonRetryableError; exports.isNonRetryableError = isNonRetryableError; exports.DeploymentConfigError = DeploymentConfigError; exports.sanitizeErrorSummary = sanitizeErrorSummary; exports.summarizeErrorCause = summarizeErrorCause; exports.DEFAULT_MAX_DELIVERY_RETRIES = DEFAULT_MAX_DELIVERY_RETRIES; exports.WEB_PUSH_MAX_BODY_BYTES = WEB_PUSH_MAX_BODY_BYTES; exports.WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES = WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES; exports.MAX_PUSH_PAYLOAD_BYTES = MAX_PUSH_PAYLOAD_BYTES; exports.PUSH_ENVELOPE_RESERVED_BYTES = PUSH_ENVELOPE_RESERVED_BYTES; exports.measurePushPayload = measurePushPayload; exports.createWebCryptoWebPush = createWebCryptoWebPush; exports.DEFAULT_MAX_TOOL_ITERATIONS = DEFAULT_MAX_TOOL_ITERATIONS; exports.DEFAULT_TOTAL_TIMEOUT_MS = DEFAULT_TOTAL_TIMEOUT_MS; exports.DEFAULT_MAX_SCHEDULED_TASKS_PER_FIRE = DEFAULT_MAX_SCHEDULED_TASKS_PER_FIRE; exports.MIN_SCHEDULE_LEAD_MS = MIN_SCHEDULE_LEAD_MS; exports.MAX_DEFER_AFTER_MS = MAX_DEFER_AFTER_MS; exports.createScheduleMessageHandler = createScheduleMessageHandler; exports.DEFAULT_CLAIM_LEASE_MS = DEFAULT_CLAIM_LEASE_MS; exports.DEFAULT_LEASE_HEARTBEAT_MS = DEFAULT_LEASE_HEARTBEAT_MS; exports.DEFAULT_HEARTBEAT_LEASE_TTL_MS = DEFAULT_HEARTBEAT_LEASE_TTL_MS; exports.runScheduledTick = runScheduledTick; exports.runTask = runTask; exports.createUpdateMessageHandler = createUpdateMessageHandler; exports.createCancelMessageHandler = createCancelMessageHandler; exports.createMessagesHandler = createMessagesHandler; exports.createGetMessageHandler = createGetMessageHandler; exports.createPushSubscriptionHandler = createPushSubscriptionHandler; exports.createLlmCredentialsHandler = createLlmCredentialsHandler; exports.createD1Adapter = createD1Adapter; exports.createSingleUserServer = createSingleUserServer; exports.SCHEMA_VERSION = SCHEMA_VERSION; exports.getSchemaVersion = getSchemaVersion; exports.ensureSchema = ensureSchema; exports.CORS_ALLOW_HEADERS = CORS_ALLOW_HEADERS; exports.CORS_ALLOW_METHODS = CORS_ALLOW_METHODS; exports.createSingleUserCloudflareWorker = createSingleUserCloudflareWorker;