@rei-standard/amsg-server 2.6.0-next.9 → 3.0.0

package/dist/chunk-S6O3MXQO.mjs

@@ -1,2834 +0,0 @@
-// src/server/lib/validation.js
-import { validateAvatarUrl } from "@rei-standard/amsg-shared";
-function isValidISO8601(dateString) {
-  const date = new Date(dateString);
-  return date instanceof Date && !isNaN(date.getTime());
-}
-function isValidUrl(urlString) {
-  try {
-    new URL(urlString);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isValidUUID(uuid) {
-  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-  return uuidRegex.test(uuid);
-}
-function isValidUUIDv4(uuid) {
-  const uuidV4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-  return uuidV4Regex.test(uuid);
-}
-var VALID_LLM_MESSAGE_ROLES = /* @__PURE__ */ new Set(["system", "user", "assistant", "tool"]);
-var SPLIT_PATTERN_MAX_LENGTH = 200;
-var SPLIT_PATTERN_MAX_ITEMS = 10;
-function validateSplitPattern(value) {
-  if (value === void 0 || value === null) return null;
-  const isArray = Array.isArray(value);
-  const items = isArray ? value : [value];
-  if (isArray && items.length === 0) return null;
-  if (items.length > SPLIT_PATTERN_MAX_ITEMS) {
-    return `splitPattern \u6570\u7EC4\u6700\u591A ${SPLIT_PATTERN_MAX_ITEMS} \u9879`;
-  }
-  for (let i = 0; i < items.length; i++) {
-    const s = items[i];
-    const label = isArray ? `splitPattern[${i}]` : "splitPattern";
-    if (typeof s !== "string") return `${label} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`;
-    if (s.length > SPLIT_PATTERN_MAX_LENGTH) {
-      return `${label} \u4E0D\u80FD\u8D85\u8FC7 ${SPLIT_PATTERN_MAX_LENGTH} \u5B57\u7B26`;
-    }
-    try {
-      new RegExp(s);
-    } catch (_) {
-      return `${label} \u4E0D\u662F\u6709\u6548\u6B63\u5219\u8868\u8FBE\u5F0F`;
-    }
-  }
-  return null;
-}
-function validateLlmMessagesArray(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) {
-    return "messages must be a non-empty array";
-  }
-  for (let i = 0; i < messages.length; i++) {
-    const m = messages[i];
-    if (!m || typeof m !== "object" || Array.isArray(m)) {
-      return `messages[${i}] must be an object`;
-    }
-    if (!VALID_LLM_MESSAGE_ROLES.has(m.role)) {
-      return `messages[${i}].role must be one of system / user / assistant / tool`;
-    }
-    if (typeof m.content === "string") {
-      if (!m.content) return `messages[${i}].content must be a non-empty string`;
-    } else if (Array.isArray(m.content)) {
-      if (m.content.length === 0) return `messages[${i}].content array must be non-empty`;
-    } else {
-      return `messages[${i}].content must be a non-empty string or a non-empty array`;
-    }
-  }
-  return null;
-}
-function validateScheduleMessagePayload(payload) {
-  if (!payload.contactName || typeof payload.contactName !== "string") {
-    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { missingFields: ["contactName"] } };
-  }
-  if (!payload.messageType || !["fixed", "prompted", "auto", "instant"].includes(payload.messageType)) {
-    return { valid: false, errorCode: "INVALID_MESSAGE_TYPE", errorMessage: "\u6D88\u606F\u7C7B\u578B\u65E0\u6548", details: { providedType: payload.messageType, allowedTypes: ["fixed", "prompted", "auto", "instant"] } };
-  }
-  if (!payload.firstSendTime || !isValidISO8601(payload.firstSendTime)) {
-    return { valid: false, errorCode: "INVALID_TIMESTAMP", errorMessage: "\u65F6\u95F4\u683C\u5F0F\u65E0\u6548", details: { field: "firstSendTime" } };
-  }
-  if (payload.firstSendTime && new Date(payload.firstSendTime) <= /* @__PURE__ */ new Date()) {
-    return { valid: false, errorCode: "INVALID_TIMESTAMP", errorMessage: "\u65F6\u95F4\u5FC5\u987B\u5728\u672A\u6765", details: { field: "firstSendTime", reason: "must be in the future" } };
-  }
-  if (!payload.pushSubscription || typeof payload.pushSubscription !== "object") {
-    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { missingFields: ["pushSubscription"] } };
-  }
-  if (payload.recurrenceType && !["none", "daily", "weekly"].includes(payload.recurrenceType)) {
-    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["recurrenceType"] } };
-  }
-  if (payload.maxTokens !== void 0 && payload.maxTokens !== null && (!Number.isInteger(payload.maxTokens) || payload.maxTokens <= 0)) {
-    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["maxTokens"] } };
-  }
-  if (payload.messageType === "fixed") {
-    if (!payload.userMessage) {
-      return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { missingFields: ["userMessage (required for fixed type)"] } };
-    }
-  }
-  const promptCheck = (() => {
-    const hasCompletePrompt = payload.completePrompt !== void 0 && payload.completePrompt !== null && payload.completePrompt !== "";
-    const hasMessages = payload.messages !== void 0 && payload.messages !== null;
-    if (hasCompletePrompt && hasMessages) {
-      return {
-        error: { code: "INVALID_PARAMETERS", message: "exactly one of `completePrompt` or `messages` must be provided\uFF08\u4E24\u8005\u4E0D\u80FD\u540C\u65F6\u51FA\u73B0\uFF09", details: { invalidFields: ["completePrompt", "messages"] } },
-        hasCompletePrompt: true,
-        hasMessages: true
-      };
-    }
-    if (hasMessages) {
-      const err2 = validateLlmMessagesArray(payload.messages);
-      if (err2) {
-        return {
-          error: { code: "INVALID_PARAMETERS", message: err2, details: { invalidFields: ["messages"] } },
-          hasCompletePrompt: false,
-          hasMessages: true
-        };
-      }
-    }
-    return { error: null, hasCompletePrompt, hasMessages };
-  })();
-  if (promptCheck.error) {
-    return { valid: false, errorCode: promptCheck.error.code, errorMessage: promptCheck.error.message, details: promptCheck.error.details };
-  }
-  const hasPrompt = promptCheck.hasCompletePrompt || promptCheck.hasMessages;
-  if (payload.messageType === "prompted" || payload.messageType === "auto") {
-    const missingAiFields = [];
-    if (!hasPrompt) missingAiFields.push("completePrompt or messages");
-    if (!payload.apiUrl) missingAiFields.push("apiUrl");
-    if (!payload.apiKey) missingAiFields.push("apiKey");
-    if (!payload.primaryModel) missingAiFields.push("primaryModel");
-    if (missingAiFields.length > 0) {
-      return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { missingFields: missingAiFields } };
-    }
-  }
-  if (payload.messageType === "instant") {
-    if (payload.recurrenceType && payload.recurrenceType !== "none") {
-      return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "instant \u7C7B\u578B\u7684 recurrenceType \u5FC5\u987B\u4E3A none", details: { invalidFields: ['recurrenceType (must be "none" for instant type)'] } };
-    }
-    const hasAiConfig = hasPrompt && payload.apiUrl && payload.apiKey && payload.primaryModel;
-    const hasUserMessage = payload.userMessage;
-    if (!hasAiConfig && !hasUserMessage) {
-      return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "instant \u7C7B\u578B\u5FC5\u987B\u63D0\u4F9B userMessage \u6216\u5B8C\u6574\u7684 AI \u914D\u7F6E", details: { missingFields: ["userMessage or ((completePrompt | messages) + apiUrl + apiKey + primaryModel)"] } };
-    }
-  }
-  if (payload.temperature !== void 0 && payload.temperature !== null && (typeof payload.temperature !== "number" || !Number.isFinite(payload.temperature))) {
-    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["temperature (must be a finite number)"] } };
-  }
-  const avatarErr = validateAvatarUrl(payload.avatarUrl);
-  if (avatarErr) {
-    console.warn("[amsg-server] avatarUrl \u4E0D\u5408\u6CD5\uFF0C\u5DF2\u7F6E\u7A7A\uFF1A", avatarErr);
-    payload.avatarUrl = null;
-  }
-  if (payload.uuid && !isValidUUID(payload.uuid)) {
-    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["uuid (invalid UUID format)"] } };
-  }
-  if (payload.messageSubtype !== void 0 && payload.messageSubtype !== null && typeof payload.messageSubtype !== "string") {
-    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\u6216\u53C2\u6570\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["messageSubtype"] } };
-  }
-  const splitErr = validateSplitPattern(payload.splitPattern);
-  if (splitErr) {
-    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: splitErr, details: { invalidFields: ["splitPattern"] } };
-  }
-  return { valid: true };
-}
-
-// src/server/lib/webcrypto-utils.js
-import { toUint8, concatBytes, base64UrlToBytes } from "@rei-standard/amsg-shared";
-var TEXT_ENCODER = new TextEncoder();
-var TEXT_DECODER = new TextDecoder("utf-8", { fatal: false });
-function utf8(str) {
-  return TEXT_ENCODER.encode(String(str));
-}
-function utf8Decode(buf) {
-  return TEXT_DECODER.decode(toUint8(buf));
-}
-function bytesToBase64(buf) {
-  const bytes = toUint8(buf);
-  let bin = "";
-  for (let i = 0; i < bytes.length; i++) {
-    bin += String.fromCharCode(bytes[i]);
-  }
-  return typeof btoa === "function" ? btoa(bin) : Buffer.from(bin, "binary").toString("base64");
-}
-function bytesToBase64Url(buf) {
-  return bytesToBase64(buf).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
-}
-function bytesToHex(buf) {
-  const bytes = toUint8(buf);
-  let out = "";
-  for (let i = 0; i < bytes.length; i++) {
-    out += bytes[i].toString(16).padStart(2, "0");
-  }
-  return out;
-}
-function hexToBytes(hex) {
-  const out = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < out.length; i++) {
-    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return out;
-}
-function jsonToBase64Url(value) {
-  return bytesToBase64Url(utf8(JSON.stringify(value)));
-}
-function randomUUID() {
-  return globalThis.crypto.randomUUID();
-}
-function randomBytes(n) {
-  const out = new Uint8Array(n);
-  globalThis.crypto.getRandomValues(out);
-  return out;
-}
-
-// src/server/lib/encryption.js
-var base64ToBytes = base64UrlToBytes;
-var TAG_LENGTH_BYTES = 16;
-function importAesKey(hexKey, usage) {
-  return globalThis.crypto.subtle.importKey(
-    "raw",
-    hexToBytes(hexKey),
-    { name: "AES-GCM" },
-    false,
-    [usage]
-  );
-}
-async function aesGcmSeal(hexKey, iv, plaintextBytes) {
-  const key = await importAesKey(hexKey, "encrypt");
-  const sealed = new Uint8Array(await globalThis.crypto.subtle.encrypt(
-    { name: "AES-GCM", iv, tagLength: TAG_LENGTH_BYTES * 8 },
-    key,
-    plaintextBytes
-  ));
-  return {
-    ciphertext: sealed.slice(0, sealed.length - TAG_LENGTH_BYTES),
-    authTag: sealed.slice(sealed.length - TAG_LENGTH_BYTES)
-  };
-}
-async function aesGcmOpen(hexKey, iv, ciphertext, authTag) {
-  const key = await importAesKey(hexKey, "decrypt");
-  const tagBits = authTag.length * 8;
-  const tagLength = tagBits >= 96 && tagBits <= 128 ? tagBits : 128;
-  const plain = await globalThis.crypto.subtle.decrypt(
-    { name: "AES-GCM", iv, tagLength },
-    key,
-    concatBytes(ciphertext, authTag)
-  );
-  return new Uint8Array(plain);
-}
-async function deriveUserEncryptionKey(userId, masterKey) {
-  const digest = await globalThis.crypto.subtle.digest("SHA-256", utf8(masterKey + userId));
-  return bytesToHex(new Uint8Array(digest)).slice(0, 64);
-}
-async function decryptPayload(encryptedPayload, encryptionKey) {
-  const { iv, authTag, encryptedData } = encryptedPayload;
-  const plain = await aesGcmOpen(
-    encryptionKey,
-    base64ToBytes(iv),
-    base64ToBytes(encryptedData),
-    base64ToBytes(authTag)
-  );
-  return JSON.parse(utf8Decode(plain));
-}
-async function encryptPayload(payload, encryptionKey) {
-  const plaintext = typeof payload === "string" ? payload : JSON.stringify(payload);
-  const iv = randomBytes(12);
-  const { ciphertext, authTag } = await aesGcmSeal(encryptionKey, iv, utf8(plaintext));
-  return {
-    iv: bytesToBase64(iv),
-    authTag: bytesToBase64(authTag),
-    encryptedData: bytesToBase64(ciphertext)
-  };
-}
-async function encryptForStorage(text, encryptionKey) {
-  const iv = randomBytes(16);
-  const { ciphertext, authTag } = await aesGcmSeal(encryptionKey, iv, utf8(text));
-  return `${bytesToHex(iv)}:${bytesToHex(authTag)}:${bytesToHex(ciphertext)}`;
-}
-async function decryptFromStorage(encryptedText, encryptionKey) {
-  const [ivHex, authTagHex, encryptedDataHex] = encryptedText.split(":");
-  const plain = await aesGcmOpen(
-    encryptionKey,
-    hexToBytes(ivHex),
-    hexToBytes(encryptedDataHex),
-    hexToBytes(authTagHex)
-  );
-  return utf8Decode(plain);
-}
-
-// src/server/lib/request.js
-var REQUEST_ERRORS = {
-  INVALID_JSON: { code: "INVALID_JSON", message: "\u8BF7\u6C42\u4F53\u4E0D\u662F\u6709\u6548\u7684 JSON" },
-  INVALID_REQUEST_BODY: { code: "INVALID_REQUEST_BODY", message: "\u8BF7\u6C42\u4F53\u683C\u5F0F\u65E0\u6548" },
-  INVALID_ENCRYPTED_PAYLOAD: { code: "INVALID_ENCRYPTED_PAYLOAD", message: "\u52A0\u5BC6\u6570\u636E\u683C\u5F0F\u9519\u8BEF" }
-};
-function parseBodyAsObject(body, options = {}) {
-  const invalidJson = options.invalidJson || REQUEST_ERRORS.INVALID_JSON;
-  const invalidType = options.invalidType || REQUEST_ERRORS.INVALID_REQUEST_BODY;
-  let parsed = body;
-  if (typeof parsed === "string") {
-    try {
-      parsed = JSON.parse(parsed);
-    } catch {
-      return { ok: false, error: invalidJson };
-    }
-  }
-  if (!isPlainObject(parsed)) {
-    return { ok: false, error: invalidType };
-  }
-  return { ok: true, data: parsed };
-}
-function parseJsonBody(body) {
-  return parseBodyAsObject(body, {
-    invalidJson: REQUEST_ERRORS.INVALID_JSON,
-    invalidType: REQUEST_ERRORS.INVALID_REQUEST_BODY
-  });
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isEncryptedEnvelope(payload) {
-  if (!isPlainObject(payload)) return false;
-  return typeof payload.iv === "string" && typeof payload.authTag === "string" && typeof payload.encryptedData === "string";
-}
-function parseEncryptedBody(body) {
-  const parsedBody = parseBodyAsObject(body, {
-    invalidJson: REQUEST_ERRORS.INVALID_ENCRYPTED_PAYLOAD,
-    invalidType: REQUEST_ERRORS.INVALID_ENCRYPTED_PAYLOAD
-  });
-  if (!parsedBody.ok) {
-    return parsedBody;
-  }
-  if (!isEncryptedEnvelope(parsedBody.data)) {
-    return { ok: false, error: REQUEST_ERRORS.INVALID_ENCRYPTED_PAYLOAD };
-  }
-  return parsedBody;
-}
-function getHeader(headers = {}, name) {
-  if (!headers || typeof headers !== "object") {
-    return "";
-  }
-  const lowerName = String(name || "").toLowerCase();
-  if (!lowerName) return "";
-  for (const [key, value] of Object.entries(headers)) {
-    if (String(key).toLowerCase() === lowerName) {
-      return String(value || "").trim();
-    }
-  }
-  return "";
-}
-
-// src/server/handlers/get-user-key.js
-function createGetUserKeyHandler(ctx) {
-  async function GET(url, headers) {
-    const effectiveHeaders = headers || url || {};
-    const tenantResult = await ctx.tenantManager.resolveTenant(effectiveHeaders);
-    if (!tenantResult.ok) {
-      return tenantResult.error;
-    }
-    const { masterKey } = tenantResult.context;
-    const userId = getHeader(effectiveHeaders, "x-user-id");
-    if (!userId) {
-      return {
-        status: 400,
-        body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26" } }
-      };
-    }
-    if (!isValidUUIDv4(userId)) {
-      return {
-        status: 400,
-        body: { success: false, error: { code: "INVALID_USER_ID_FORMAT", message: "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F" } }
-      };
-    }
-    return {
-      status: 200,
-      body: {
-        success: true,
-        data: {
-          userKey: await deriveUserEncryptionKey(userId, masterKey),
-          version: 1
-        }
-      }
-    };
-  }
-  return { GET };
-}
-
-// src/server/lib/db-errors.js
-function isUniqueViolation(error) {
-  if (!error || typeof error !== "object") return false;
-  const code = error.code;
-  if (code === "23505") return true;
-  const message = typeof error.message === "string" ? error.message.toLowerCase() : "";
-  return message.includes("duplicate key") || message.includes("unique constraint");
-}
-
-// src/server/lib/message-processor.js
-import {
-  buildContentPush,
-  buildReasoningPush,
-  readReasoningContent,
-  stripReasoningTags
-} from "@rei-standard/amsg-shared";
-
-// src/server/lib/llm.js
-async function callLlm(payload, options = {}) {
-  const requireContent = options.requireContent !== false;
-  const timeoutMs = typeof options.timeoutMs === "number" && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0 ? options.timeoutMs : 3e5;
-  const normalizedApiUrl = normalizeAiApiUrl(payload.apiUrl);
-  const requestBody = buildAiRequestBody(payload);
-  const aiResponse = await fetch(normalizedApiUrl, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${payload.apiKey}`
-    },
-    body: JSON.stringify(requestBody),
-    signal: AbortSignal.timeout(timeoutMs)
-  });
-  if (!aiResponse.ok) {
-    if (aiResponse.status === 405) {
-      throw new Error(
-        `AI API error: 405 Method Not Allowed. apiUrl must point to a full chat endpoint (for example: /chat/completions). Received: ${normalizedApiUrl}`
-      );
-    }
-    throw new Error(
-      `AI API error: ${aiResponse.status} ${aiResponse.statusText || "Unknown Error"}. Request URL: ${normalizedApiUrl}`
-    );
-  }
-  const aiData = await aiResponse.json();
-  const rawContent = aiData?.choices?.[0]?.message?.content;
-  if (requireContent && (typeof rawContent !== "string" || !rawContent.trim())) {
-    throw new Error("AI API error: response missing choices[0].message.content");
-  }
-  return { response: aiData, content: typeof rawContent === "string" ? rawContent.trim() : "" };
-}
-function buildAiRequestBody(payload) {
-  const llmMessages = Array.isArray(payload.messages) && payload.messages.length > 0 ? payload.messages : [{ role: "user", content: payload.completePrompt }];
-  const requestBody = {
-    model: payload.primaryModel,
-    messages: llmMessages
-  };
-  if (payload.temperature !== void 0 && payload.temperature !== null) {
-    requestBody.temperature = payload.temperature;
-  } else if (!Array.isArray(payload.messages)) {
-    requestBody.temperature = 0.8;
-  }
-  if (Array.isArray(payload.tools) && payload.tools.length > 0) {
-    requestBody.tools = payload.tools;
-    if (payload.toolChoice !== void 0 && payload.toolChoice !== null) {
-      requestBody.tool_choice = payload.toolChoice;
-    }
-  }
-  if (payload.maxTokens === void 0 || payload.maxTokens === null) {
-    return requestBody;
-  }
-  if (!Number.isInteger(payload.maxTokens) || payload.maxTokens <= 0) {
-    throw new Error("Invalid maxTokens: maxTokens must be a positive integer when provided.");
-  }
-  requestBody.max_tokens = payload.maxTokens;
-  return requestBody;
-}
-function normalizeAiApiUrl(apiUrl) {
-  if (typeof apiUrl !== "string" || !apiUrl.trim()) {
-    throw new Error(
-      "Invalid apiUrl: apiUrl is required. Please provide a chat endpoint URL (for example: https://api.openai.com or https://api.openai.com/v1/chat/completions)."
-    );
-  }
-  const trimmedApiUrl = apiUrl.trim();
-  let parsedUrl;
-  try {
-    parsedUrl = new URL(trimmedApiUrl);
-  } catch {
-    throw new Error(
-      `Invalid apiUrl: "${apiUrl}". Please provide a valid absolute URL.`
-    );
-  }
-  let path = parsedUrl.pathname.replace(/\/+$/, "") || "/";
-  if (/\/chat\/completions$/.test(path)) {
-  } else if (path === "/") {
-    path = "/v1/chat/completions";
-  } else if (/\/v\d+$/.test(path)) {
-    path = `${path}/chat/completions`;
-  }
-  parsedUrl.pathname = path;
-  return parsedUrl.toString();
-}
-
-// src/server/lib/agentic-fire.js
-import {
-  assertValidDecision,
-  buildSessionContext,
-  extractAssistantMessage,
-  extractToolCallsFromDecision
-} from "@rei-standard/amsg-shared";
-
-// src/server/lib/state-chunks.js
-import { chunkReasoningByUtf8Bytes } from "@rei-standard/amsg-shared";
-var STATE_CHUNK_SLICE_BYTES = 200 * 1024;
-var DEFAULT_MAX_STATE_VALUE_BYTES = 5 * 1024 * 1024;
-var INTERNAL_STATE_CHAR_RE = /[\u0000-\u001f]/;
-var SEP = "";
-var CHUNK_NS_PREFIX = `${SEP}amsg-chunks${SEP}`;
-var ROOT_MARKER_PREFIX = `${SEP}amsg-chunked${SEP}v1${SEP}`;
-function chunkNamespaceFor(namespace) {
-  return CHUNK_NS_PREFIX + namespace;
-}
-function chunkKeyFor(key, index) {
-  return `${key}${SEP}${index}`;
-}
-function chunkKeyPrefixFor(key) {
-  return `${key}${SEP}`;
-}
-function buildChunkedRootValue(chunkCount) {
-  return `${ROOT_MARKER_PREFIX}${chunkCount}`;
-}
-function parseChunkedRootCount(value) {
-  if (typeof value !== "string" || !value.startsWith(ROOT_MARKER_PREFIX)) return null;
-  const raw = value.slice(ROOT_MARKER_PREFIX.length);
-  if (!/^[1-9][0-9]*$/.test(raw)) return null;
-  return Number(raw);
-}
-function splitStateValue(value) {
-  return chunkReasoningByUtf8Bytes(value, STATE_CHUNK_SLICE_BYTES);
-}
-async function resolveClientStateEntries(rows, fetchChunkRows, decryptValue) {
-  let chunkMap = null;
-  const loadChunks = async () => {
-    if (chunkMap === null) {
-      const chunkRows = await fetchChunkRows();
-      chunkMap = new Map(chunkRows.map((row) => [row.key, row]));
-    }
-    return chunkMap;
-  };
-  const entries = [];
-  for (const row of rows) {
-    const count = parseChunkedRootCount(row.value);
-    if (count === null) {
-      entries.push({
-        namespace: row.namespace,
-        key: row.key,
-        value: await decryptValue(row.value),
-        updatedAt: row.updated_at
-      });
-      continue;
-    }
-    const map = await loadChunks();
-    const chunkRows = [];
-    let intact = true;
-    for (let i = 0; i < count; i++) {
-      const chunk = map.get(chunkKeyFor(row.key, i));
-      if (!chunk || chunk.updated_at !== row.updated_at) {
-        intact = false;
-        break;
-      }
-      chunkRows.push(chunk);
-    }
-    if (!intact) continue;
-    const parts = await Promise.all(chunkRows.map((chunk) => decryptValue(chunk.value)));
-    entries.push({
-      namespace: row.namespace,
-      key: row.key,
-      value: parts.join(""),
-      updatedAt: row.updated_at
-    });
-  }
-  return entries;
-}
-
-// src/server/lib/client-state-store.js
-var utf82 = new TextEncoder();
-var MAX_STATE_ENTRIES_PER_BATCH = 200;
-var MAX_NAMESPACE_CHARS = 128;
-var MAX_KEY_CHARS = 256;
-function stateValueBytes(value) {
-  return utf82.encode(value).length;
-}
-async function writeClientStateEntries({ db, userId, userKey, entries }) {
-  const physicalRows = [];
-  const cleanups = [];
-  const rootRowIndexes = [];
-  let deleted = 0;
-  for (const entry of entries) {
-    cleanups.push({
-      namespace: chunkNamespaceFor(entry.namespace),
-      keyPrefix: chunkKeyPrefixFor(entry.key),
-      updatedAt: entry.updatedAt
-    });
-    if (entry.value === null) {
-      cleanups.push({
-        namespace: entry.namespace,
-        key: entry.key,
-        updatedAt: entry.updatedAt
-      });
-      deleted++;
-      continue;
-    }
-    rootRowIndexes.push(physicalRows.length);
-    if (stateValueBytes(entry.value) <= STATE_CHUNK_SLICE_BYTES) {
-      physicalRows.push({
-        namespace: entry.namespace,
-        key: entry.key,
-        value: await encryptForStorage(entry.value, userKey),
-        updatedAt: entry.updatedAt
-      });
-    } else {
-      const slices = splitStateValue(entry.value);
-      physicalRows.push({
-        namespace: entry.namespace,
-        key: entry.key,
-        value: buildChunkedRootValue(slices.length),
-        updatedAt: entry.updatedAt
-      });
-      const encryptedSlices = await Promise.all(slices.map((slice) => encryptForStorage(slice, userKey)));
-      for (let c = 0; c < encryptedSlices.length; c++) {
-        physicalRows.push({
-          namespace: chunkNamespaceFor(entry.namespace),
-          key: chunkKeyFor(entry.key, c),
-          value: encryptedSlices[c],
-          updatedAt: entry.updatedAt
-        });
-      }
-    }
-  }
-  if (physicalRows.length === 0 && cleanups.length === 0) {
-    return { upserted: 0, skipped: 0, deleted: 0 };
-  }
-  const result = await db.upsertClientState(userId, physicalRows, cleanups);
-  let upserted = 0;
-  let skipped = 0;
-  if (Array.isArray(result.outcomes) && result.outcomes.length === physicalRows.length) {
-    for (const rootIndex of rootRowIndexes) {
-      if (result.outcomes[rootIndex]) upserted++;
-      else skipped++;
-    }
-  } else {
-    upserted = result.upserted;
-    skipped = result.skipped;
-  }
-  return { upserted, skipped, deleted };
-}
-
-// src/server/lib/agentic-fire.js
-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 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;
-var CREDENTIAL_PAYLOAD_KEYS = /* @__PURE__ */ new Set(["apiKey", "pushSubscription"]);
-var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-function taskNeedsLlm(decryptedPayload) {
-  const type = decryptedPayload.messageType;
-  if (type === "prompted" || type === "auto") return true;
-  if (type === "instant") {
-    return !!(decryptedPayload.apiUrl && decryptedPayload.apiKey && decryptedPayload.primaryModel);
-  }
-  return false;
-}
-function buildHookTask(task, decryptedPayload) {
-  const safe = {};
-  for (const [key, value] of Object.entries(decryptedPayload)) {
-    if (!CREDENTIAL_PAYLOAD_KEYS.has(key)) safe[key] = value;
-  }
-  return Object.freeze({
-    ...safe,
-    id: task.id ?? null,
-    uuid: task.uuid ?? null,
-    nextSendAt: task.next_send_at ?? null,
-    retryCount: task.retry_count ?? 0
-  });
-}
-function normalizeBeforeFireResult(result) {
-  if (Array.isArray(result)) {
-    return { messages: result };
-  }
-  if (result && typeof result === "object" && Array.isArray(result.messages)) {
-    return {
-      messages: result.messages,
-      maxToolIterations: result.maxToolIterations,
-      totalTimeoutMs: result.totalTimeoutMs,
-      // 归一成「有就是非空数组，否则 undefined」，让下面每轮的透传判断能直接
-      // 用真值。真正决定请求体带不带 tools 的规则住在 llm.js 的
-      // buildAiRequestBody（那边有测试钉着），这层只是不把空数组往下传。
-      tools: Array.isArray(result.tools) && result.tools.length > 0 ? result.tools : void 0,
-      toolChoice: result.toolChoice
-    };
-  }
-  throw new TypeError(
-    "AGENTIC_BAD_BEFORE_FIRE: onBeforeFire must return ChatMessage[] | { messages, maxToolIterations?, totalTimeoutMs?, tools?, toolChoice? } | { skip: true } | null"
-  );
-}
-function firstPositiveInt(values, fallback) {
-  for (const v of values) {
-    if (Number.isInteger(v) && v > 0) return v;
-  }
-  return fallback;
-}
-function firstPositiveNumber(values, fallback) {
-  for (const v of values) {
-    if (typeof v === "number" && Number.isFinite(v) && v > 0) return v;
-  }
-  return fallback;
-}
-async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
-  const hooks = ctx.hooks;
-  if (typeof hooks.onLLMOutput !== "function") {
-    throw new Error("AGENTIC_CONFIG_ERROR: hooks.onBeforeFire requires hooks.onLLMOutput to classify LLM rounds");
-  }
-  const nowFn = typeof ctx._agenticNow === "function" ? ctx._agenticNow : Date.now;
-  const sleep = typeof ctx._agenticSleep === "function" ? ctx._agenticSleep : defaultSleep;
-  const readState = async (namespace) => {
-    if (typeof namespace !== "string" || !namespace.trim()) {
-      throw new TypeError("readState(namespace) requires a non-empty string");
-    }
-    if (!ctx.db || typeof ctx.db.getClientState !== "function") return [];
-    const rows = await ctx.db.getClientState(task.user_id, namespace);
-    return resolveClientStateEntries(
-      rows,
-      () => ctx.db.getClientState(task.user_id, chunkNamespaceFor(namespace)),
-      (value) => decryptFromStorage(value, userKey)
-    );
-  };
-  const maxStateValueBytes = Number.isInteger(ctx.maxStateValueBytes) && ctx.maxStateValueBytes > 0 ? ctx.maxStateValueBytes : DEFAULT_MAX_STATE_VALUE_BYTES;
-  const writeState = async (namespace, entries) => {
-    if (typeof namespace !== "string" || !namespace.trim()) {
-      throw new TypeError("writeState(namespace, entries) requires a non-empty string namespace");
-    }
-    if (namespace.length > MAX_NAMESPACE_CHARS || INTERNAL_STATE_CHAR_RE.test(namespace)) {
-      throw new TypeError(
-        `writeState: namespace \u5FC5\u987B\u662F 1-${MAX_NAMESPACE_CHARS} \u5B57\u7B26\u4E14\u4E0D\u542B\u63A7\u5236\u5B57\u7B26\uFF08\\u0000-\\u001f \u4E3A\u5E93\u5185\u90E8\u4FDD\u7559\uFF09`
-      );
-    }
-    if (!Array.isArray(entries)) {
-      throw new TypeError("writeState(namespace, entries) requires an array of { key, value }");
-    }
-    if (entries.length === 0) return { upserted: 0, skipped: 0, deleted: 0 };
-    if (entries.length > MAX_STATE_ENTRIES_PER_BATCH) {
-      throw new RangeError(`writeState: \u5355\u6B21\u6700\u591A ${MAX_STATE_ENTRIES_PER_BATCH} \u6761\uFF0C\u6536\u5230 ${entries.length} \u6761`);
-    }
-    if (!ctx.db || typeof ctx.db.upsertClientState !== "function") {
-      throw new Error("AGENTIC_STATE_WRITE_UNSUPPORTED: \u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301 client_state \u5199\u5165");
-    }
-    const now = nowFn();
-    const normalized2 = entries.map((entry, index) => {
-      if (!entry || typeof entry !== "object") {
-        throw new TypeError(`writeState: entries[${index}] \u5FC5\u987B\u662F\u5BF9\u8C61`);
-      }
-      if (typeof entry.key !== "string" || !entry.key.trim() || entry.key.length > MAX_KEY_CHARS) {
-        throw new TypeError(`writeState: entries[${index}].key \u5FC5\u987B\u662F 1-${MAX_KEY_CHARS} \u5B57\u7B26\u7684\u5B57\u7B26\u4E32`);
-      }
-      if (INTERNAL_STATE_CHAR_RE.test(entry.key)) {
-        throw new TypeError(`writeState: entries[${index}].key \u4E0D\u80FD\u5305\u542B\u63A7\u5236\u5B57\u7B26\uFF08\\u0000-\\u001f \u4E3A\u5E93\u5185\u90E8\u4FDD\u7559\uFF09`);
-      }
-      if (entry.value !== null && typeof entry.value !== "string") {
-        throw new TypeError(`writeState: entries[${index}].value \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\uFF08\u5BBF\u4E3B\u81EA\u884C\u5E8F\u5217\u5316\uFF09\uFF0C\u6216 null \u8868\u793A\u5220\u9664`);
-      }
-      if (typeof entry.value === "string") {
-        const bytes = stateValueBytes(entry.value);
-        if (bytes > maxStateValueBytes) {
-          throw new RangeError(`writeState: entries[${index}].value \u4E3A ${bytes} \u5B57\u8282\uFF0C\u8D85\u8FC7\u5355\u6761\u4E0A\u9650 ${maxStateValueBytes} \u5B57\u8282`);
-        }
-      }
-      if (entry.updatedAt !== void 0 && (!Number.isInteger(entry.updatedAt) || entry.updatedAt <= 0)) {
-        throw new TypeError(`writeState: entries[${index}].updatedAt \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF08epoch \u6BEB\u79D2\uFF09`);
-      }
-      return {
-        namespace,
-        key: entry.key,
-        value: entry.value,
-        updatedAt: entry.updatedAt ?? now
-      };
-    });
-    return writeClientStateEntries({ db: ctx.db, userId: task.user_id, userKey, entries: normalized2 });
-  };
-  const maxScheduledTasksPerFire = Number.isInteger(ctx.maxScheduledTasksPerFire) && ctx.maxScheduledTasksPerFire >= 0 ? ctx.maxScheduledTasksPerFire : DEFAULT_MAX_SCHEDULED_TASKS_PER_FIRE;
-  let scheduledTaskCount = 0;
-  const scheduleTask = async (options) => {
-    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 }");
-    }
-    if (typeof options.firstSendTime !== "string" || !options.firstSendTime.trim()) {
-      throw new RangeError("scheduleTask: firstSendTime \u5FC5\u586B\uFF0C\u4E14\u5FC5\u987B\u662F ISO 8601 \u5B57\u7B26\u4E32");
-    }
-    const firstSendAt = new Date(options.firstSendTime);
-    if (Number.isNaN(firstSendAt.getTime())) {
-      throw new RangeError(`scheduleTask: firstSendTime \u89E3\u6790\u4E0D\u51FA\u5408\u6CD5\u65F6\u95F4\uFF1A${options.firstSendTime}`);
-    }
-    const earliest = nowFn() + MIN_SCHEDULE_LEAD_MS;
-    if (firstSendAt.getTime() < earliest) {
-      throw new RangeError(
-        `scheduleTask: firstSendTime \u81F3\u5C11\u8981\u6BD4\u73B0\u5728\u665A ${MIN_SCHEDULE_LEAD_MS / 1e3} \u79D2\uFF08\u6700\u65E9\u53EF\u6392 ${new Date(earliest).toISOString()}\uFF0C\u6536\u5230 ${firstSendAt.toISOString()}\uFF09\u2014\u2014cron \u4E00\u5206\u949F\u4E00\u8DF3\uFF0C\u6392\u5F97\u66F4\u8FD1\u7B49\u4E8E\u8BA9\u4E0B\u4E00\u8DF3\u7ACB\u523B\u6361\u8D70`
-      );
-    }
-    const nextSendAt = firstSendAt.toISOString();
-    const inheritedType = options.messageType == null;
-    const messageType = inheritedType ? decryptedPayload.messageType : options.messageType;
-    if (messageType === "instant") {
-      throw new TypeError(
-        "scheduleTask: messageType \u4E0D\u80FD\u662F 'instant'\u2014\u2014instant \u7684\u8BED\u4E49\u662F\u300C\u5EFA\u884C\u7684\u90A3\u4E00\u523B\u5C31\u6295\u9012\u300D\uFF0C\u90A3\u6761\u8DEF\u5F84\u5F52 POST /schedule-message \u7BA1\uFF1B\u4ECE fire \u91CC\u5EFA\u4E00\u6761 instant\uFF0C\u6295\u9012\u65F6\u673A\u53CD\u800C\u8BF4\u4E0D\u6E05\u3002" + (inheritedType ? "\uFF08\u8FD9\u4E2A instant \u662F\u4ECE\u5F53\u524D\u4EFB\u52A1\u7EE7\u627F\u6765\u7684\uFF0C\u663E\u5F0F\u4F20 auto / prompted / fixed \u8986\u76D6\u5B83\u3002\uFF09" : "")
-      );
-    }
-    if (!SCHEDULABLE_MESSAGE_TYPES.has(messageType)) {
-      throw new TypeError(
-        `scheduleTask: messageType \u53EA\u80FD\u662F auto / prompted / fixed\uFF0C\u6536\u5230 ${JSON.stringify(messageType)}`
-      );
-    }
-    const recurrenceType = options.recurrenceType == null ? "none" : options.recurrenceType;
-    if (!SCHEDULABLE_RECURRENCE_TYPES.has(recurrenceType)) {
-      throw new TypeError(
-        `scheduleTask: recurrenceType \u53EA\u80FD\u662F none / daily / weekly\uFF0C\u6536\u5230 ${JSON.stringify(recurrenceType)}`
-      );
-    }
-    const contactName = options.contactName === void 0 ? decryptedPayload.contactName : options.contactName;
-    if (typeof contactName !== "string" || !contactName.trim()) {
-      throw new TypeError("scheduleTask: contactName \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\uFF08\u9ED8\u8BA4\u7EE7\u627F\u5F53\u524D\u4EFB\u52A1\uFF09");
-    }
-    const userMessage = options.userMessage === void 0 ? decryptedPayload.userMessage ?? null : options.userMessage;
-    if (messageType === "fixed" && (typeof userMessage !== "string" || !userMessage.trim())) {
-      throw new TypeError(
-        "scheduleTask: messageType 'fixed' \u5FC5\u987B\u6709 userMessage\uFF08\u81EA\u5DF1\u4F20\uFF0C\u6216\u4ECE\u5F53\u524D\u4EFB\u52A1\u7EE7\u627F\u5230\uFF09\u2014\u2014\u56FA\u5B9A\u6587\u672C\u4EFB\u52A1\u6CA1\u6709\u6B63\u6587\uFF0C\u5C31\u662F\u4E00\u6761\u6C38\u8FDC\u53D1\u7A7A\u7684\u4EFB\u52A1"
-      );
-    }
-    const metadata = options.metadata === void 0 ? decryptedPayload.metadata || {} : options.metadata;
-    if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
-      throw new TypeError("scheduleTask: metadata \u5FC5\u987B\u662F\u666E\u901A\u5BF9\u8C61\uFF08\u6574\u4F53\u66FF\u6362\u5F53\u524D\u4EFB\u52A1\u7684 metadata\uFF0C\u4E0D\u505A\u6DF1\u5408\u5E76\uFF09");
-    }
-    const uuid = options.uuid == null ? randomUUID() : options.uuid;
-    if (typeof uuid !== "string" || !uuid.trim()) {
-      throw new TypeError("scheduleTask: uuid \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
-    }
-    if (scheduledTaskCount >= maxScheduledTasksPerFire) {
-      throw new RangeError(
-        `scheduleTask: \u5355\u6B21 fire \u6700\u591A\u5EFA ${maxScheduledTasksPerFire} \u6761\u4EFB\u52A1\uFF08factory \u914D\u7F6E maxScheduledTasksPerFire \u53EF\u8C03\uFF09\uFF0C\u8FD9\u662F\u7B2C ${scheduledTaskCount + 1} \u6761`
-      );
-    }
-    if (!ctx.db || typeof ctx.db.createTask !== "function") {
-      throw new Error("AGENTIC_SCHEDULE_UNSUPPORTED: \u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301\u5EFA\u4EFB\u52A1\uFF08\u7F3A createTask\uFF09");
-    }
-    scheduledTaskCount++;
-    const fullTaskData = {
-      contactName,
-      avatarUrl: options.avatarUrl === void 0 ? decryptedPayload.avatarUrl || null : options.avatarUrl || null,
-      messageType,
-      messageSubtype: (options.messageSubtype === void 0 ? decryptedPayload.messageSubtype : options.messageSubtype) || "chat",
-      userMessage: userMessage || null,
-      firstSendTime: nextSendAt,
-      recurrenceType,
-      apiUrl: decryptedPayload.apiUrl || null,
-      apiKey: decryptedPayload.apiKey || null,
-      primaryModel: decryptedPayload.primaryModel || null,
-      // 见文件头：fire-time hook 每次现场重组 prompt，旧 prompt 带过去只会在新
-      // 任务走回老链路时顶替宿主的意图。
-      completePrompt: null,
-      messages: null,
-      maxTokens: decryptedPayload.maxTokens ?? null,
-      temperature: decryptedPayload.temperature ?? null,
-      splitPattern: decryptedPayload.splitPattern ?? null,
-      pushSubscription: decryptedPayload.pushSubscription,
-      metadata
-    };
-    const encryptedPayload = await encryptForStorage(JSON.stringify(fullTaskData), userKey);
-    let created;
-    try {
-      created = await ctx.db.createTask({
-        user_id: task.user_id,
-        uuid,
-        encrypted_payload: encryptedPayload,
-        next_send_at: nextSendAt,
-        message_type: messageType
-      });
-    } catch (error) {
-      if (isUniqueViolation(error)) return { created: false, reason: "duplicate", uuid };
-      throw error;
-    }
-    if (!created) {
-      throw new Error("AGENTIC_SCHEDULE_FAILED: createTask \u6CA1\u6709\u8FD4\u56DE\u65B0\u5EFA\u7684\u4EFB\u52A1\u884C");
-    }
-    return {
-      created: true,
-      id: created.id ?? null,
-      uuid: created.uuid ?? uuid,
-      nextSendAt: created.next_send_at ?? nextSendAt
-    };
-  };
-  const scratch = {};
-  const fireCtx = Object.freeze({
-    task: buildHookTask(task, decryptedPayload),
-    userId: task.user_id,
-    readState,
-    writeState,
-    scheduleTask,
-    now: new Date(nowFn()),
-    scratch
-  });
-  const before = await hooks.onBeforeFire(fireCtx);
-  if (before == null) return { handled: false };
-  if (typeof before === "object" && before.skip === true) {
-    return { handled: true, result: { success: true, messagesSent: 0, status: "skipped", iterations: 0 } };
-  }
-  const normalized = normalizeBeforeFireResult(before);
-  const maxToolIterations = firstPositiveInt(
-    [normalized.maxToolIterations, ctx.maxToolIterations],
-    DEFAULT_MAX_TOOL_ITERATIONS
-  );
-  const totalTimeoutMs = firstPositiveNumber(
-    [normalized.totalTimeoutMs, ctx.totalTimeoutMs],
-    DEFAULT_TOTAL_TIMEOUT_MS
-  );
-  const deadline = nowFn() + totalTimeoutMs;
-  const sessionId = task.id != null ? `sess_task_${task.id}` : `sess_${randomUUID()}`;
-  let messages = normalized.messages.slice();
-  for (let iteration = 0; iteration < maxToolIterations; iteration++) {
-    if (nowFn() >= deadline) {
-      throw new Error(`AGENTIC_TOTAL_TIMEOUT: fire chain exceeded ${totalTimeoutMs}ms after ${iteration} LLM round(s)`);
-    }
-    const roundTimeoutMs = Math.max(1, Math.min(3e5, deadline - nowFn()));
-    const { response: llmResponse } = await callLlm(
-      {
-        ...decryptedPayload,
-        messages,
-        ...normalized.tools ? { tools: normalized.tools, toolChoice: normalized.toolChoice } : {}
-      },
-      { requireContent: false, timeoutMs: roundTimeoutMs }
-    );
-    const assistantMessage = extractAssistantMessage(llmResponse);
-    messages = [...messages, assistantMessage];
-    const sessionCtx = Object.freeze({
-      ...buildSessionContext({
-        sessionId,
-        messages,
-        llmResponse,
-        iteration,
-        contactName: decryptedPayload.contactName,
-        avatarUrl: decryptedPayload.avatarUrl || void 0,
-        charId: decryptedPayload.charId,
-        metadata: decryptedPayload.metadata,
-        scratch
-      }),
-      readState,
-      writeState,
-      scheduleTask
-    });
-    const decision = await hooks.onLLMOutput(sessionCtx);
-    assertValidDecision(decision, { inlineToolCalls: true });
-    if (decision.decision === "continue") {
-      messages = decision.nextHistory.slice();
-      continue;
-    }
-    if (decision.decision === "skip-push") {
-      return { handled: true, result: { success: true, messagesSent: 0, status: "skipped", iterations: iteration + 1 } };
-    }
-    if (decision.decision === "finish") {
-      const messagesSent = await sendHookPushPayloads(decision.pushPayloads, decryptedPayload, ctx, sessionId, task, sleep);
-      return { handled: true, result: { success: true, messagesSent, status: "finished", iterations: iteration + 1 } };
-    }
-    const toolCalls = extractToolCallsFromDecision(decision);
-    if (toolCalls.length === 0) {
-      throw new Error("AGENTIC_EMPTY_TOOL_REQUEST: tool-request decision carried no toolCalls (neither decision.toolCalls nor pushPayloads[].toolCalls)");
-    }
-    if (typeof hooks.executeToolCalls !== "function") {
-      throw new Error("AGENTIC_CONFIG_ERROR: onLLMOutput returned tool-request but hooks.executeToolCalls is not configured");
-    }
-    if (iteration === maxToolIterations - 1) {
-      break;
-    }
-    let toolResults;
-    try {
-      toolResults = await hooks.executeToolCalls(toolCalls, sessionCtx);
-      if (!Array.isArray(toolResults)) {
-        throw new TypeError('executeToolCalls must resolve to an array of { tool_call_id, role: "tool", content }');
-      }
-    } catch (error) {
-      toolResults = toolCalls.map((toolCall) => ({
-        tool_call_id: toolCall && typeof toolCall === "object" && typeof toolCall.id === "string" ? toolCall.id : "",
-        role: "tool",
-        content: `Tool execution failed: ${error?.message ?? String(error)}`
-      }));
-    }
-    const nativeCalls = Array.isArray(assistantMessage.tool_calls) ? assistantMessage.tool_calls : [];
-    const nativeIds = new Set(nativeCalls.map((tc) => tc && tc.id));
-    const synthesized = toolCalls.filter((tc) => !nativeIds.has(tc && tc.id));
-    const assistantWithTools = synthesized.length === 0 ? assistantMessage : { ...assistantMessage, tool_calls: [...nativeCalls, ...synthesized] };
-    messages = [...messages.slice(0, -1), assistantWithTools, ...toolResults];
-  }
-  throw new Error(`AGENTIC_LOOP_EXCEEDED: no finish/skip-push decision within ${maxToolIterations} LLM round(s)`);
-}
-async function sendHookPushPayloads(pushPayloads, decryptedPayload, ctx, sessionId, task, sleep) {
-  if (!ctx.vapid || !ctx.vapid.email || !ctx.vapid.publicKey || !ctx.vapid.privateKey) {
-    throw new Error("VAPID configuration missing - push notifications cannot be sent");
-  }
-  const pushSubscription = decryptedPayload.pushSubscription;
-  const total = pushPayloads.length;
-  const messageIdBase = task.id != null ? `msg_task_${task.id}` : `msg_${randomUUID()}`;
-  for (let i = 0; i < total; i++) {
-    const push = { ...pushPayloads[i] };
-    if (typeof push.messageId !== "string" || !push.messageId) push.messageId = `${messageIdBase}_hook_${i}`;
-    if (typeof push.sessionId !== "string" || !push.sessionId) push.sessionId = sessionId;
-    if (typeof push.timestamp !== "string" || !push.timestamp) push.timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    push.messageIndex = i + 1;
-    push.totalMessages = total;
-    await ctx.webpush.sendNotification(pushSubscription, JSON.stringify(push));
-    if (i < total - 1) await sleep(SLEEP_BETWEEN_MESSAGES_MS);
-  }
-  return total;
-}
-
-// src/server/lib/message-processor.js
-var DEFAULT_SPLIT_REGEX = /([。！？!?]+)/;
-var SLEEP_BETWEEN_MESSAGES_MS2 = 1500;
-function splitOnceByRegex(chunk, regex) {
-  const out = chunk.split(regex).reduce((acc, part, i, arr) => {
-    if (i % 2 === 0 && part.trim()) {
-      const punctuation = arr[i + 1] || "";
-      acc.push(part.trim() + punctuation);
-    }
-    return acc;
-  }, []).filter((s) => s.length > 0);
-  return out.length > 0 ? out : [chunk];
-}
-function splitMessageIntoSentences(messageContent, splitPattern = null) {
-  const sources = splitPattern == null ? null : Array.isArray(splitPattern) ? splitPattern : [splitPattern];
-  const regexes = sources && sources.length > 0 ? sources.map((s) => new RegExp(s)) : [DEFAULT_SPLIT_REGEX];
-  let chunks = [messageContent];
-  for (const regex of regexes) {
-    chunks = chunks.flatMap((c) => splitOnceByRegex(c, regex));
-  }
-  return chunks.length > 0 ? chunks : [messageContent];
-}
-async function processSingleMessage(task, ctx, providedMasterKey) {
-  try {
-    const masterKey = providedMasterKey || ctx.masterKey;
-    if (!masterKey) {
-      return { success: false, messagesSent: 0, error: "TENANT_MASTER_KEY_MISSING" };
-    }
-    const userKey = await deriveUserEncryptionKey(task.user_id, masterKey);
-    const decryptedPayload = JSON.parse(await decryptFromStorage(task.encrypted_payload, userKey));
-    if (ctx.hooks && typeof ctx.hooks.onBeforeFire === "function" && taskNeedsLlm(decryptedPayload)) {
-      const agentic = await runAgenticFire({ task, decryptedPayload, userKey, ctx });
-      if (agentic.handled) return agentic.result;
-    }
-    let messageContent;
-    let llmResponse = null;
-    if (decryptedPayload.messageType === "fixed") {
-      messageContent = decryptedPayload.userMessage;
-    } else if (decryptedPayload.messageType === "instant") {
-      const hasPrompt = !!decryptedPayload.completePrompt || Array.isArray(decryptedPayload.messages) && decryptedPayload.messages.length > 0;
-      if (hasPrompt && decryptedPayload.apiUrl && decryptedPayload.apiKey && decryptedPayload.primaryModel) {
-        const aiResult = await callLlm(decryptedPayload);
-        messageContent = aiResult.content;
-        llmResponse = aiResult.response;
-      } else if (decryptedPayload.userMessage) {
-        messageContent = decryptedPayload.userMessage;
-      } else {
-        throw new Error("Invalid instant message: no content source available");
-      }
-    } else if (decryptedPayload.messageType === "prompted" || decryptedPayload.messageType === "auto") {
-      const aiResult = await callLlm(decryptedPayload);
-      messageContent = aiResult.content;
-      llmResponse = aiResult.response;
-    } else {
-      throw new Error("Invalid message configuration: no content source available");
-    }
-    const reasoning = readReasoningContent(llmResponse);
-    if (reasoning) {
-      messageContent = stripReasoningTags(messageContent);
-    }
-    const messages = splitMessageIntoSentences(messageContent, decryptedPayload.splitPattern ?? null);
-    if (!ctx.vapid.email || !ctx.vapid.publicKey || !ctx.vapid.privateKey) {
-      throw new Error("VAPID configuration missing - push notifications cannot be sent");
-    }
-    const pushSubscription = decryptedPayload.pushSubscription;
-    const sessionId = task.id != null ? `sess_task_${task.id}` : `sess_${randomUUID()}`;
-    const source = decryptedPayload.messageType === "instant" ? "instant" : "scheduled";
-    const messageSubtype = decryptedPayload.messageSubtype || "chat";
-    const avatarUrl = decryptedPayload.avatarUrl || null;
-    const metadata = decryptedPayload.metadata || {};
-    const messageIdBase = task.id != null ? `msg_task_${task.id}` : `msg_${randomUUID()}_instant`;
-    if (reasoning) {
-      const reasoningPush = buildReasoningPush({
-        messageType: decryptedPayload.messageType,
-        source,
-        messageId: `${messageIdBase}_reasoning`,
-        sessionId,
-        reasoningContent: reasoning,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        title: `\u6765\u81EA ${decryptedPayload.contactName}`,
-        contactName: decryptedPayload.contactName,
-        avatarUrl,
-        messageSubtype,
-        metadata
-      });
-      await ctx.webpush.sendNotification(pushSubscription, JSON.stringify(reasoningPush));
-      await new Promise((resolve) => setTimeout(resolve, SLEEP_BETWEEN_MESSAGES_MS2));
-    }
-    for (let i = 0; i < messages.length; i++) {
-      const contentPush = buildContentPush({
-        messageType: decryptedPayload.messageType,
-        source,
-        messageId: `${messageIdBase}_${i}`,
-        sessionId,
-        message: messages[i],
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        title: `\u6765\u81EA ${decryptedPayload.contactName}`,
-        contactName: decryptedPayload.contactName,
-        avatarUrl,
-        messageSubtype,
-        messageIndex: i + 1,
-        totalMessages: messages.length,
-        taskId: task.id || null,
-        metadata
-      });
-      await ctx.webpush.sendNotification(pushSubscription, JSON.stringify(contentPush));
-      if (i < messages.length - 1) {
-        await new Promise((resolve) => setTimeout(resolve, SLEEP_BETWEEN_MESSAGES_MS2));
-      }
-    }
-    return { success: true, messagesSent: messages.length };
-  } catch (error) {
-    return { success: false, messagesSent: 0, error: error.message };
-  }
-}
-async function processMessagesByUuid(uuid, ctx, maxRetries = 2, userId, providedMasterKey) {
-  let retryCount = 0;
-  const masterKey = providedMasterKey || ctx.masterKey;
-  if (!masterKey) {
-    return {
-      success: false,
-      error: { code: "TENANT_MASTER_KEY_MISSING", message: "\u79DF\u6237\u4E3B\u5BC6\u94A5\u4E0D\u5B58\u5728\u6216\u914D\u7F6E\u5F02\u5E38" }
-    };
-  }
-  while (retryCount <= maxRetries) {
-    let task;
-    try {
-      task = userId ? await ctx.db.getTaskByUuid(uuid, userId) : await ctx.db.getTaskByUuidOnly(uuid);
-    } catch (error) {
-      if (retryCount < maxRetries) {
-        retryCount++;
-        await new Promise((resolve) => setTimeout(resolve, 1e3 * retryCount));
-        continue;
-      }
-      return {
-        success: false,
-        error: { code: "INTERNAL_ERROR", message: error.message, retriesAttempted: retryCount }
-      };
-    }
-    if (!task) {
-      return { success: false, error: { code: "TASK_NOT_FOUND", message: "\u4EFB\u52A1\u4E0D\u5B58\u5728\u6216\u5DF2\u5904\u7406" } };
-    }
-    const result = await processSingleMessage(task, ctx, masterKey);
-    if (!result.success) {
-      if (retryCount < maxRetries) {
-        retryCount++;
-        await new Promise((resolve) => setTimeout(resolve, 1e3 * retryCount));
-        continue;
-      }
-      try {
-        await ctx.db.updateTaskById(task.id, { status: "failed", retry_count: retryCount });
-      } catch (_updateError) {
-      }
-      return {
-        success: false,
-        error: { code: "PROCESSING_ERROR", message: result.error, retriesAttempted: retryCount }
-      };
-    }
-    try {
-      await ctx.db.deleteTaskById(task.id);
-    } catch (error) {
-      try {
-        await ctx.db.updateTaskById(task.id, { status: "sent", retry_count: 0 });
-      } catch (_markSentError) {
-      }
-      return {
-        success: false,
-        error: {
-          code: "POST_SEND_CLEANUP_FAILED",
-          message: "\u6D88\u606F\u5DF2\u53D1\u9001\uFF0C\u4F46\u4EFB\u52A1\u6E05\u7406\u5931\u8D25",
-          details: { error: error.message }
-        }
-      };
-    }
-    return { success: true, messagesSent: result.messagesSent, retriesUsed: retryCount };
-  }
-}
-
-// src/server/handlers/schedule-message.js
-function createScheduleMessageHandler(ctx) {
-  async function POST(headers, body) {
-    const tenantResult = await ctx.tenantManager.resolveTenant(headers);
-    if (!tenantResult.ok) {
-      return tenantResult.error;
-    }
-    const tenantCtx = tenantResult.context;
-    const db = tenantCtx.db;
-    const masterKey = tenantCtx.masterKey;
-    const isEncrypted = getHeader(headers, "x-payload-encrypted") === "true";
-    const encryptionVersion = getHeader(headers, "x-encryption-version");
-    const userId = getHeader(headers, "x-user-id");
-    if (!isEncrypted) {
-      return { status: 400, body: { success: false, error: { code: "ENCRYPTION_REQUIRED", message: "\u8BF7\u6C42\u4F53\u5FC5\u987B\u52A0\u5BC6" } } };
-    }
-    if (!userId) {
-      return { status: 400, body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26" } } };
-    }
-    if (!isValidUUIDv4(userId)) {
-      return { status: 400, body: { success: false, error: { code: "INVALID_USER_ID_FORMAT", message: "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F" } } };
-    }
-    if (encryptionVersion !== "1") {
-      return { status: 400, body: { success: false, error: { code: "UNSUPPORTED_ENCRYPTION_VERSION", message: "\u52A0\u5BC6\u7248\u672C\u4E0D\u652F\u6301" } } };
-    }
-    const parsedBody = parseEncryptedBody(body);
-    if (!parsedBody.ok) {
-      return { status: 400, body: { success: false, error: parsedBody.error } };
-    }
-    const encryptedBody = parsedBody.data;
-    const userKey = await deriveUserEncryptionKey(userId, masterKey);
-    let payload;
-    try {
-      payload = await decryptPayload(encryptedBody, userKey);
-    } catch (error) {
-      if (error instanceof SyntaxError) {
-        return { status: 400, body: { success: false, error: { code: "INVALID_PAYLOAD_FORMAT", message: "\u89E3\u5BC6\u540E\u7684\u6570\u636E\u4E0D\u662F\u6709\u6548 JSON" } } };
-      }
-      const message = typeof error.message === "string" ? error.message : "";
-      if (message.includes("auth") || message.includes("Unsupported state")) {
-        return { status: 400, body: { success: false, error: { code: "DECRYPTION_FAILED", message: "\u8BF7\u6C42\u4F53\u89E3\u5BC6\u5931\u8D25" } } };
-      }
-      return { status: 400, body: { success: false, error: { code: "DECRYPTION_FAILED", message: "\u8BF7\u6C42\u4F53\u89E3\u5BC6\u5931\u8D25" } } };
-    }
-    if (!isPlainObject(payload)) {
-      return { status: 400, body: { success: false, error: { code: "INVALID_PAYLOAD_FORMAT", message: "\u89E3\u5BC6\u540E\u7684\u6570\u636E\u5FC5\u987B\u662F JSON \u5BF9\u8C61" } } };
-    }
-    const validationResult = validateScheduleMessagePayload(payload);
-    if (!validationResult.valid) {
-      return { status: 400, body: { success: false, error: { code: validationResult.errorCode, message: validationResult.errorMessage, details: validationResult.details } } };
-    }
-    const taskUuid = payload.uuid || randomUUID();
-    const fullTaskData = {
-      contactName: payload.contactName,
-      avatarUrl: payload.avatarUrl || null,
-      messageType: payload.messageType,
-      messageSubtype: payload.messageSubtype || "chat",
-      userMessage: payload.userMessage || null,
-      firstSendTime: payload.firstSendTime,
-      recurrenceType: payload.recurrenceType || "none",
-      apiUrl: payload.apiUrl || null,
-      apiKey: payload.apiKey || null,
-      primaryModel: payload.primaryModel || null,
-      // Prompt is one-of: legacy completePrompt (string) OR messages (OpenAI-
-      // style array). Validation has already enforced exactly-one-of, so
-      // exactly one of these will be non-null when an AI config is provided.
-      completePrompt: payload.completePrompt || null,
-      messages: Array.isArray(payload.messages) ? payload.messages : null,
-      maxTokens: payload.maxTokens ?? null,
-      temperature: payload.temperature ?? null,
-      // 0.6.0+: optional caller-provided regex (string or string[]) used by
-      // the message processor to chunk LLM output into individual pushes.
-      // null → processor falls back to the default /([。！？!?]+)/ regex.
-      splitPattern: payload.splitPattern ?? null,
-      pushSubscription: payload.pushSubscription,
-      metadata: payload.metadata || {}
-    };
-    const encryptedPayload = await encryptForStorage(JSON.stringify(fullTaskData), userKey);
-    if (payload.messageType === "instant") {
-      if (!ctx.vapid.email || !ctx.vapid.publicKey || !ctx.vapid.privateKey) {
-        return {
-          status: 500,
-          body: {
-            success: false,
-            error: {
-              code: "VAPID_CONFIG_ERROR",
-              message: "VAPID \u914D\u7F6E\u7F3A\u5931\uFF0C\u65E0\u6CD5\u53D1\u9001\u5373\u65F6\u6D88\u606F",
-              details: {
-                missingKeys: [
-                  !ctx.vapid.email && "VAPID_EMAIL",
-                  !ctx.vapid.publicKey && "NEXT_PUBLIC_VAPID_PUBLIC_KEY",
-                  !ctx.vapid.privateKey && "VAPID_PRIVATE_KEY"
-                ].filter(Boolean)
-              }
-            }
-          }
-        };
-      }
-    }
-    let dbResult;
-    try {
-      dbResult = await db.createTask({
-        user_id: userId,
-        uuid: taskUuid,
-        encrypted_payload: encryptedPayload,
-        next_send_at: payload.firstSendTime,
-        message_type: payload.messageType
-      });
-    } catch (error) {
-      if (isUniqueViolation(error)) {
-        return {
-          status: 409,
-          body: {
-            success: false,
-            error: {
-              code: "TASK_UUID_CONFLICT",
-              message: "\u4EFB\u52A1 UUID \u5DF2\u5B58\u5728\uFF0C\u8BF7\u4F7F\u7528\u65B0\u7684 uuid \u91CD\u65B0\u63D0\u4EA4"
-            }
-          }
-        };
-      }
-      throw error;
-    }
-    if (!dbResult) {
-      return { status: 500, body: { success: false, error: { code: "TASK_CREATE_FAILED", message: "\u521B\u5EFA\u4EFB\u52A1\u5931\u8D25" } } };
-    }
-    if (payload.messageType === "instant") {
-      try {
-        const sendResult = await processMessagesByUuid(taskUuid, {
-          ...ctx,
-          db,
-          masterKey
-        }, 2, userId, masterKey);
-        if (!sendResult.success) {
-          return { status: 500, body: { success: false, error: { code: "MESSAGE_SEND_FAILED", message: "\u6D88\u606F\u53D1\u9001\u5931\u8D25", details: sendResult.error } } };
-        }
-        return {
-          status: 200,
-          body: {
-            success: true,
-            data: {
-              uuid: taskUuid,
-              contactName: payload.contactName,
-              messagesSent: sendResult.messagesSent,
-              sentAt: (/* @__PURE__ */ new Date()).toISOString(),
-              status: "sent",
-              retriesUsed: sendResult.retriesUsed || 0
-            }
-          }
-        };
-      } catch (error) {
-        return { status: 500, body: { success: false, error: { code: "MESSAGE_SEND_FAILED", message: "\u6D88\u606F\u53D1\u9001\u5931\u8D25", details: { error: error.message } } } };
-      }
-    }
-    return {
-      status: 201,
-      body: {
-        success: true,
-        data: {
-          id: dbResult.id,
-          uuid: dbResult.uuid,
-          contactName: payload.contactName,
-          nextSendAt: dbResult.next_send_at,
-          status: dbResult.status,
-          createdAt: dbResult.created_at
-        }
-      }
-    };
-  }
-  return { POST };
-}
-
-// src/server/lib/run-tick.js
-var DEFAULT_CLAIM_LEASE_MS = 10 * 60 * 1e3;
-var CLAIM_LEASE_MARGIN_MS = 2 * 60 * 1e3;
-function positiveNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
-}
-function resolveClaimLeaseMs(ctx) {
-  return positiveNumber(ctx.claimLeaseMs) || Math.max(DEFAULT_CLAIM_LEASE_MS, positiveNumber(ctx.totalTimeoutMs) + CLAIM_LEASE_MARGIN_MS);
-}
-async function runScheduledTick(ctx) {
-  const db = ctx.db;
-  const masterKey = ctx.masterKey;
-  const claimLeaseMs = resolveClaimLeaseMs(ctx);
-  const startTime = Date.now();
-  const tasks = await db.getPendingTasks(50);
-  const MAX_CONCURRENT = 8;
-  const results = {
-    totalTasks: tasks.length,
-    successCount: 0,
-    failedCount: 0,
-    claimSkippedTasks: 0,
-    deletedOnceOffTasks: 0,
-    updatedRecurringTasks: 0,
-    failedTasks: []
-  };
-  const supportsClaim = typeof db.claimTask === "function";
-  async function claimForThisTick(task) {
-    if (!supportsClaim) return true;
-    const leaseUntil = new Date(Date.now() + claimLeaseMs).toISOString();
-    return !!await db.claimTask(task.id, task.next_send_at, leaseUntil);
-  }
-  async function updateAndRelease(taskId, fields) {
-    return db.updateTaskById(taskId, supportsClaim ? { ...fields, lease_until: null } : fields);
-  }
-  async function handleDeliveryFailure(task, reason) {
-    results.failedCount++;
-    try {
-      if (task.retry_count >= 3) {
-        await updateAndRelease(task.id, { status: "failed" });
-        results.failedTasks.push({ taskId: task.id, reason, retryCount: task.retry_count, status: "permanently_failed" });
-      } else {
-        const nextRetryTime = new Date(Date.now() + (task.retry_count + 1) * 2 * 60 * 1e3);
-        await updateAndRelease(task.id, { next_send_at: nextRetryTime.toISOString(), retry_count: task.retry_count + 1 });
-        results.failedTasks.push({ taskId: task.id, reason, retryCount: task.retry_count + 1, nextRetryAt: nextRetryTime.toISOString() });
-      }
-    } catch (updateError) {
-      results.failedTasks.push({ taskId: task.id, reason, status: "retry_update_failed", updateError: updateError.message });
-    }
-  }
-  async function handlePostSendPersistenceFailure(task, reason) {
-    results.failedCount++;
-    let markedSent = false;
-    try {
-      await updateAndRelease(task.id, { status: "sent", retry_count: 0 });
-      markedSent = true;
-    } catch (_markSentError) {
-      markedSent = false;
-    }
-    results.failedTasks.push({
-      taskId: task.id,
-      reason,
-      status: markedSent ? "post_send_cleanup_failed_marked_sent" : "post_send_cleanup_failed",
-      messageDelivered: true
-    });
-  }
-  async function processTask(task) {
-    let claimed;
-    try {
-      claimed = await claimForThisTick(task);
-    } catch (error) {
-      results.failedCount++;
-      results.failedTasks.push({ taskId: task.id, reason: error.message || "\u4EFB\u52A1\u5360\u4F4D\u5931\u8D25", status: "claim_failed" });
-      return;
-    }
-    if (!claimed) {
-      results.claimSkippedTasks++;
-      return;
-    }
-    let sendResult;
-    try {
-      sendResult = await processSingleMessage(task, { ...ctx, db, masterKey }, masterKey);
-    } catch (error) {
-      await handleDeliveryFailure(task, error.message || "\u6D88\u606F\u53D1\u9001\u5931\u8D25");
-      return;
-    }
-    if (!sendResult.success) {
-      await handleDeliveryFailure(task, sendResult.error || "\u6D88\u606F\u53D1\u9001\u5931\u8D25");
-      return;
-    }
-    try {
-      const userKey = await deriveUserEncryptionKey(task.user_id, masterKey);
-      const decryptedPayload = JSON.parse(await decryptFromStorage(task.encrypted_payload, userKey));
-      if (decryptedPayload.recurrenceType === "none") {
-        await db.deleteTaskById(task.id);
-        results.deletedOnceOffTasks++;
-      } else {
-        let nextSendAt;
-        const currentSendAt = new Date(task.next_send_at);
-        if (decryptedPayload.recurrenceType === "daily") {
-          nextSendAt = new Date(currentSendAt.getTime() + 24 * 60 * 60 * 1e3);
-        } else if (decryptedPayload.recurrenceType === "weekly") {
-          nextSendAt = new Date(currentSendAt.getTime() + 7 * 24 * 60 * 60 * 1e3);
-        }
-        await updateAndRelease(task.id, { next_send_at: nextSendAt.toISOString(), retry_count: 0 });
-        results.updatedRecurringTasks++;
-      }
-      results.successCount++;
-    } catch (error) {
-      await handlePostSendPersistenceFailure(task, error.message || "\u53D1\u9001\u540E\u72B6\u6001\u66F4\u65B0\u5931\u8D25");
-    }
-  }
-  const taskQueue = [...tasks];
-  const processing = [];
-  while (taskQueue.length > 0 || processing.length > 0) {
-    while (processing.length < MAX_CONCURRENT && taskQueue.length > 0) {
-      const task = taskQueue.shift();
-      const promise = processTask(task);
-      processing.push(promise);
-      promise.finally(() => {
-        const index = processing.indexOf(promise);
-        if (index > -1) processing.splice(index, 1);
-      });
-    }
-    if (processing.length > 0) {
-      await Promise.race(processing);
-    }
-  }
-  await db.cleanupOldTasks(7);
-  const executionTime = Date.now() - startTime;
-  return {
-    totalTasks: results.totalTasks,
-    successCount: results.successCount,
-    failedCount: results.failedCount,
-    processedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    executionTime,
-    details: {
-      claimSkippedTasks: results.claimSkippedTasks,
-      deletedOnceOffTasks: results.deletedOnceOffTasks,
-      updatedRecurringTasks: results.updatedRecurringTasks,
-      failedTasks: results.failedTasks
-    }
-  };
-}
-
-// src/server/handlers/update-message.js
-function createUpdateMessageHandler(ctx) {
-  async function PUT(url, headers, body) {
-    const tenantResult = await ctx.tenantManager.resolveTenant(headers, { url });
-    if (!tenantResult.ok) {
-      return tenantResult.error;
-    }
-    const tenantCtx = tenantResult.context;
-    const db = tenantCtx.db;
-    const masterKey = tenantCtx.masterKey;
-    const u = new URL(url, "https://dummy");
-    const taskUuid = u.searchParams.get("id");
-    if (!taskUuid) {
-      return { status: 400, body: { success: false, error: { code: "TASK_ID_REQUIRED", message: "\u7F3A\u5C11\u4EFB\u52A1ID" } } };
-    }
-    const userId = getHeader(headers, "x-user-id");
-    if (!userId) {
-      return { status: 400, body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26" } } };
-    }
-    if (!isValidUUIDv4(userId)) {
-      return { status: 400, body: { success: false, error: { code: "INVALID_USER_ID_FORMAT", message: "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F" } } };
-    }
-    const isEncrypted = getHeader(headers, "x-payload-encrypted") === "true";
-    const encryptionVersion = getHeader(headers, "x-encryption-version");
-    if (!isEncrypted) {
-      return { status: 400, body: { success: false, error: { code: "ENCRYPTION_REQUIRED", message: "\u8BF7\u6C42\u4F53\u5FC5\u987B\u52A0\u5BC6" } } };
-    }
-    if (encryptionVersion !== "1") {
-      return { status: 400, body: { success: false, error: { code: "UNSUPPORTED_ENCRYPTION_VERSION", message: "\u52A0\u5BC6\u7248\u672C\u4E0D\u652F\u6301" } } };
-    }
-    const parsedBody = parseEncryptedBody(body);
-    if (!parsedBody.ok) {
-      return { status: 400, body: { success: false, error: parsedBody.error } };
-    }
-    const encryptedBody = parsedBody.data;
-    const userKey = await deriveUserEncryptionKey(userId, masterKey);
-    let updates;
-    try {
-      updates = await decryptPayload(encryptedBody, userKey);
-    } catch (_error) {
-      return { status: 400, body: { success: false, error: { code: "DECRYPTION_FAILED", message: "\u8BF7\u6C42\u4F53\u89E3\u5BC6\u5931\u8D25" } } };
-    }
-    if (!isPlainObject(updates)) {
-      return { status: 400, body: { success: false, error: { code: "INVALID_UPDATE_DATA", message: "\u66F4\u65B0\u6570\u636E\u683C\u5F0F\u9519\u8BEF" } } };
-    }
-    if (updates.nextSendAt && !isValidISO8601(updates.nextSendAt)) {
-      return { status: 400, body: { success: false, error: { code: "INVALID_UPDATE_DATA", message: "\u66F4\u65B0\u6570\u636E\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["nextSendAt"] } } } };
-    }
-    if (updates.recurrenceType && !["none", "daily", "weekly"].includes(updates.recurrenceType)) {
-      return { status: 400, body: { success: false, error: { code: "INVALID_UPDATE_DATA", message: "\u66F4\u65B0\u6570\u636E\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["recurrenceType"] } } } };
-    }
-    if (Object.prototype.hasOwnProperty.call(updates, "maxTokens") && updates.maxTokens !== null && (!Number.isInteger(updates.maxTokens) || updates.maxTokens <= 0)) {
-      return { status: 400, body: { success: false, error: { code: "INVALID_UPDATE_DATA", message: "\u66F4\u65B0\u6570\u636E\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["maxTokens"] } } } };
-    }
-    if (updates.completePrompt && updates.messages !== void 0 && updates.messages !== null) {
-      return { status: 400, body: { success: false, error: { code: "INVALID_UPDATE_DATA", message: "completePrompt \u4E0E messages \u4E0D\u80FD\u540C\u65F6\u66F4\u65B0\uFF08\u4E8C\u9009\u4E00\uFF09", details: { invalidFields: ["completePrompt", "messages"] } } } };
-    }
-    if (updates.messages !== void 0 && updates.messages !== null) {
-      const msgErr = validateLlmMessagesArray(updates.messages);
-      if (msgErr) {
-        return { status: 400, body: { success: false, error: { code: "INVALID_UPDATE_DATA", message: msgErr, details: { invalidFields: ["messages"] } } } };
-      }
-    }
-    if (Object.prototype.hasOwnProperty.call(updates, "temperature") && updates.temperature !== null && (typeof updates.temperature !== "number" || !Number.isFinite(updates.temperature))) {
-      return { status: 400, body: { success: false, error: { code: "INVALID_UPDATE_DATA", message: "\u66F4\u65B0\u6570\u636E\u683C\u5F0F\u9519\u8BEF", details: { invalidFields: ["temperature"] } } } };
-    }
-    if (Object.prototype.hasOwnProperty.call(updates, "splitPattern")) {
-      const splitErr = validateSplitPattern(updates.splitPattern);
-      if (splitErr) {
-        return { status: 400, body: { success: false, error: { code: "INVALID_UPDATE_DATA", message: splitErr, details: { invalidFields: ["splitPattern"] } } } };
-      }
-    }
-    if (Object.prototype.hasOwnProperty.call(updates, "avatarUrl")) {
-      const avatarErr = validateAvatarUrl(updates.avatarUrl);
-      if (avatarErr) {
-        console.warn("[amsg-server] update-message avatarUrl \u4E0D\u5408\u6CD5\uFF0C\u5DF2\u5FFD\u7565\uFF1A", avatarErr);
-        delete updates.avatarUrl;
-      }
-    }
-    const existingTask = await db.getTaskByUuid(taskUuid, userId);
-    if (!existingTask) {
-      const taskStatus = await db.getTaskStatus(taskUuid, userId);
-      if (!taskStatus) {
-        return { status: 404, body: { success: false, error: { code: "TASK_NOT_FOUND", message: "\u6307\u5B9A\u7684\u4EFB\u52A1\u4E0D\u5B58\u5728\u6216\u5DF2\u88AB\u5220\u9664" } } };
-      }
-      return { status: 409, body: { success: false, error: { code: "TASK_ALREADY_COMPLETED", message: "\u4EFB\u52A1\u5DF2\u5B8C\u6210\u6216\u5DF2\u5931\u8D25\uFF0C\u65E0\u6CD5\u66F4\u65B0" } } };
-    }
-    const existingData = JSON.parse(await decryptFromStorage(existingTask.encrypted_payload, userKey));
-    const promptUpdates = {};
-    if (updates.completePrompt) {
-      promptUpdates.completePrompt = updates.completePrompt;
-      promptUpdates.messages = null;
-    } else if (updates.messages !== void 0 && updates.messages !== null) {
-      promptUpdates.messages = updates.messages;
-      promptUpdates.completePrompt = null;
-    }
-    const updatedData = {
-      ...existingData,
-      ...promptUpdates,
-      ...updates.userMessage && { userMessage: updates.userMessage },
-      ...updates.recurrenceType && { recurrenceType: updates.recurrenceType },
-      ...updates.avatarUrl && { avatarUrl: updates.avatarUrl },
-      ...updates.metadata && { metadata: updates.metadata },
-      ...Object.prototype.hasOwnProperty.call(updates, "maxTokens") && { maxTokens: updates.maxTokens ?? null },
-      ...Object.prototype.hasOwnProperty.call(updates, "temperature") && { temperature: updates.temperature ?? null },
-      // splitPattern: hasOwnProperty so that explicit `null` (= revert to
-      // default) doesn't get swallowed by truthy-spread the way the optional
-      // string fields above are.
-      ...Object.prototype.hasOwnProperty.call(updates, "splitPattern") && { splitPattern: updates.splitPattern ?? null }
-    };
-    const encryptedPayload = await encryptForStorage(JSON.stringify(updatedData), userKey);
-    const extraFields = updates.nextSendAt ? { next_send_at: updates.nextSendAt } : void 0;
-    const result = await db.updateTaskByUuid(taskUuid, userId, encryptedPayload, extraFields);
-    if (!result) {
-      return { status: 409, body: { success: false, error: { code: "UPDATE_CONFLICT", message: "\u4EFB\u52A1\u66F4\u65B0\u5931\u8D25\uFF0C\u4EFB\u52A1\u53EF\u80FD\u5DF2\u88AB\u4FEE\u6539\u6216\u5220\u9664" } } };
-    }
-    return {
-      status: 200,
-      body: {
-        success: true,
-        data: {
-          uuid: taskUuid,
-          updatedFields: Object.keys(updates),
-          updatedAt: result.updated_at
-        }
-      }
-    };
-  }
-  return { PUT };
-}
-
-// src/server/handlers/cancel-message.js
-function createCancelMessageHandler(ctx) {
-  async function DELETE(url, headers) {
-    const tenantResult = await ctx.tenantManager.resolveTenant(headers, { url });
-    if (!tenantResult.ok) {
-      return tenantResult.error;
-    }
-    const db = tenantResult.context.db;
-    const u = new URL(url, "https://dummy");
-    const taskUuid = u.searchParams.get("id");
-    if (!taskUuid) {
-      return { status: 400, body: { success: false, error: { code: "TASK_ID_REQUIRED", message: "\u7F3A\u5C11\u4EFB\u52A1ID" } } };
-    }
-    const userId = getHeader(headers, "x-user-id");
-    if (!userId) {
-      return { status: 400, body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26" } } };
-    }
-    if (!isValidUUIDv4(userId)) {
-      return { status: 400, body: { success: false, error: { code: "INVALID_USER_ID_FORMAT", message: "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F" } } };
-    }
-    const deleted = await db.deleteTaskByUuid(taskUuid, userId);
-    if (!deleted) {
-      return {
-        status: 404,
-        body: { success: false, error: { code: "TASK_NOT_FOUND", message: "\u6307\u5B9A\u7684\u4EFB\u52A1\u4E0D\u5B58\u5728\u6216\u5DF2\u88AB\u5220\u9664" } }
-      };
-    }
-    return {
-      status: 200,
-      body: {
-        success: true,
-        data: { uuid: taskUuid, message: "\u4EFB\u52A1\u5DF2\u6210\u529F\u53D6\u6D88", deletedAt: (/* @__PURE__ */ new Date()).toISOString() }
-      }
-    };
-  }
-  return { DELETE };
-}
-
-// src/server/handlers/messages.js
-function createMessagesHandler(ctx) {
-  async function GET(url, headers) {
-    const tenantResult = await ctx.tenantManager.resolveTenant(headers, { url });
-    if (!tenantResult.ok) {
-      return tenantResult.error;
-    }
-    const tenantCtx = tenantResult.context;
-    const db = tenantCtx.db;
-    const masterKey = tenantCtx.masterKey;
-    const userId = getHeader(headers, "x-user-id");
-    if (!userId) {
-      return {
-        status: 400,
-        body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u5FC5\u987B\u63D0\u4F9B X-User-Id \u8BF7\u6C42\u5934" } }
-      };
-    }
-    if (!isValidUUIDv4(userId)) {
-      return {
-        status: 400,
-        body: { success: false, error: { code: "INVALID_USER_ID_FORMAT", message: "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F" } }
-      };
-    }
-    const u = new URL(url, "https://dummy");
-    const status = u.searchParams.get("status") || "all";
-    const limit = Math.min(parseInt(u.searchParams.get("limit") || "20", 10), 100);
-    const offset = parseInt(u.searchParams.get("offset") || "0", 10);
-    if (isNaN(limit) || limit < 1) {
-      return { status: 400, body: { success: false, error: { code: "INVALID_PARAMETERS", message: "limit \u53C2\u6570\u65E0\u6548\uFF0C\u5FC5\u987B\u4E3A\u6B63\u6574\u6570" } } };
-    }
-    if (isNaN(offset) || offset < 0) {
-      return { status: 400, body: { success: false, error: { code: "INVALID_PARAMETERS", message: "offset \u53C2\u6570\u65E0\u6548\uFF0C\u5FC5\u987B\u4E3A\u975E\u8D1F\u6574\u6570" } } };
-    }
-    const { tasks, total } = await db.listTasks(userId, { status, limit, offset });
-    const userKey = await deriveUserEncryptionKey(userId, masterKey);
-    const decryptedTasks = await Promise.all(tasks.map(async (task) => {
-      const decrypted = JSON.parse(await decryptFromStorage(task.encrypted_payload, userKey));
-      return {
-        id: task.id,
-        uuid: task.uuid,
-        contactName: decrypted.contactName,
-        messageType: task.message_type,
-        messageSubtype: decrypted.messageSubtype,
-        nextSendAt: task.next_send_at,
-        recurrenceType: decrypted.recurrenceType,
-        status: task.status,
-        retryCount: task.retry_count,
-        createdAt: task.created_at,
-        updatedAt: task.updated_at,
-        // Character ownership / client-side task identity, pulled from the
-        // scheduling host's metadata so it can filter tasks by character
-        // (contactName can collide across characters). Only these two
-        // metadata fields are surfaced — the rest of metadata may hold
-        // host-private data and stays server-side. Absent → null.
-        charId: decrypted.metadata?.charId ?? null,
-        clientTaskId: decrypted.metadata?.amsgClientTaskId ?? null
-      };
-    }));
-    const responsePayload = {
-      tasks: decryptedTasks,
-      pagination: { total, limit, offset, hasMore: offset + limit < total }
-    };
-    const encryptedResponse = await encryptPayload(responsePayload, userKey);
-    return {
-      status: 200,
-      body: {
-        success: true,
-        encrypted: true,
-        version: 1,
-        data: encryptedResponse
-      }
-    };
-  }
-  return { GET };
-}
-
-// src/server/adapters/schema.sqlite.js
-var SQLITE_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS scheduled_messages (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    user_id TEXT NOT NULL,
-    uuid TEXT,
-    encrypted_payload TEXT NOT NULL,
-    message_type TEXT NOT NULL CHECK (message_type IN ('fixed', 'prompted', 'auto', 'instant')),
-    next_send_at TEXT NOT NULL,
-    lease_until TEXT,
-    status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent', 'failed')),
-    retry_count INTEGER NOT NULL DEFAULT 0,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL
-  )
-`;
-var SQLITE_MIGRATIONS = [
-  {
-    name: "add_lease_until",
-    sql: "ALTER TABLE scheduled_messages ADD COLUMN lease_until TEXT",
-    description: "Task claim lease (2.6.0)"
-  }
-];
-var SQLITE_INDEXES = [
-  {
-    name: "idx_pending_tasks_optimized",
-    sql: `CREATE INDEX IF NOT EXISTS idx_pending_tasks_optimized
-          ON scheduled_messages (status, next_send_at, id, retry_count)
-          WHERE status = 'pending'`,
-    description: "Main query index (Cron Job finds pending tasks)",
-    critical: false
-  },
-  {
-    name: "idx_cleanup_completed",
-    sql: `CREATE INDEX IF NOT EXISTS idx_cleanup_completed
-          ON scheduled_messages (status, updated_at)
-          WHERE status IN ('sent', 'failed')`,
-    description: "Cleanup query index",
-    critical: false
-  },
-  {
-    name: "idx_failed_retry",
-    sql: `CREATE INDEX IF NOT EXISTS idx_failed_retry
-          ON scheduled_messages (status, retry_count, next_send_at)
-          WHERE status = 'failed' AND retry_count < 3`,
-    description: "Failed retry index",
-    critical: false
-  },
-  {
-    name: "idx_user_id",
-    sql: `CREATE INDEX IF NOT EXISTS idx_user_id
-          ON scheduled_messages (user_id)`,
-    description: "User task query index",
-    critical: false
-  },
-  {
-    name: "uidx_uuid",
-    sql: `CREATE UNIQUE INDEX IF NOT EXISTS uidx_uuid
-          ON scheduled_messages (uuid)
-          WHERE uuid IS NOT NULL`,
-    description: "UUID uniqueness guard",
-    critical: true
-  }
-];
-var CLIENT_STATE_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS client_state (
-    user_id TEXT NOT NULL,
-    namespace TEXT NOT NULL,
-    key TEXT NOT NULL,
-    value TEXT NOT NULL,
-    updated_at INTEGER NOT NULL,
-    PRIMARY KEY (user_id, namespace, key)
-  )
-`;
-
-// src/server/adapters/d1.js
-var UPDATABLE_COLUMNS = /* @__PURE__ */ new Set([
-  "user_id",
-  "uuid",
-  "encrypted_payload",
-  "message_type",
-  "next_send_at",
-  "lease_until",
-  "status",
-  "retry_count",
-  "created_at",
-  "updated_at"
-]);
-function escapeLikePrefix(prefix) {
-  return prefix.replace(/[\\%_]/g, (ch) => `\\${ch}`);
-}
-var D1Adapter = class {
-  /** @param {{ prepare: (sql: string) => any }} db - Cloudflare D1 binding */
-  constructor(db) {
-    this._db = db;
-  }
-  /** @private */
-  _now() {
-    return (/* @__PURE__ */ new Date()).toISOString();
-  }
-  /** @private */
-  _iso(value) {
-    const d = new Date(value);
-    if (Number.isNaN(d.getTime())) {
-      throw new Error(`[amsg-server D1] invalid timestamp: ${value}`);
-    }
-    return d.toISOString();
-  }
-  async initSchema() {
-    await this._db.prepare(SQLITE_TABLE_SQL).run();
-    await this._db.prepare(CLIENT_STATE_TABLE_SQL).run();
-    for (const migration of SQLITE_MIGRATIONS) {
-      try {
-        await this._db.prepare(migration.sql).run();
-      } catch (error) {
-        if (!/duplicate column name/i.test(error.message || "")) throw error;
-      }
-    }
-    const indexResults = [];
-    for (const index of SQLITE_INDEXES) {
-      try {
-        await this._db.prepare(index.sql).run();
-        indexResults.push({ name: index.name, status: "success", description: index.description, critical: !!index.critical });
-      } catch (error) {
-        indexResults.push({ name: index.name, status: "failed", description: index.description, critical: !!index.critical, error: error.message });
-      }
-    }
-    const criticalFailures = indexResults.filter((i) => i.critical && i.status === "failed");
-    if (criticalFailures.length > 0) {
-      const names = criticalFailures.map((i) => i.name).join(", ");
-      throw new Error(
-        `Critical index creation failed (${names}). Please remove duplicate UUID rows and run initSchema again.`
-      );
-    }
-    return {
-      columnsCreated: 11,
-      indexesCreated: indexResults.filter((r) => r.status === "success").length,
-      indexesFailed: indexResults.filter((r) => r.status === "failed").length,
-      columns: [],
-      indexes: indexResults
-    };
-  }
-  async dropSchema() {
-    await this._db.prepare("DROP TABLE IF EXISTS scheduled_messages").run();
-    await this._db.prepare("DROP TABLE IF EXISTS client_state").run();
-  }
-  async createTask(params) {
-    const now = this._now();
-    const nextSendAt = this._iso(params.next_send_at);
-    const res = await this._db.prepare(
-      `INSERT INTO scheduled_messages
-        (user_id, uuid, encrypted_payload, next_send_at, message_type, status, retry_count, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, 'pending', 0, ?, ?)`
-    ).bind(params.user_id, params.uuid, params.encrypted_payload, nextSendAt, params.message_type, now, now).run();
-    const id = res.meta.last_row_id;
-    return this._db.prepare(
-      `SELECT id, uuid, next_send_at, status, created_at FROM scheduled_messages WHERE id = ?`
-    ).bind(id).first();
-  }
-  async getTaskByUuid(uuid, userId) {
-    return this._db.prepare(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
-       FROM scheduled_messages
-       WHERE uuid = ? AND user_id = ? AND status = 'pending'
-       LIMIT 1`
-    ).bind(uuid, userId).first();
-  }
-  async getTaskByUuidOnly(uuid) {
-    return this._db.prepare(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
-       FROM scheduled_messages
-       WHERE uuid = ? AND status = 'pending'
-       LIMIT 1`
-    ).bind(uuid).first();
-  }
-  async updateTaskById(taskId, updates) {
-    const sets = [];
-    const values = [];
-    for (const [key, value] of Object.entries(updates)) {
-      if (!UPDATABLE_COLUMNS.has(key)) {
-        throw new Error(`[amsg-server D1] rejected unknown update column: ${key}`);
-      }
-      sets.push(`${key} = ?`);
-      values.push(key === "next_send_at" ? this._iso(value) : value);
-    }
-    if (!Object.prototype.hasOwnProperty.call(updates, "updated_at")) {
-      sets.push("updated_at = ?");
-      values.push(this._now());
-    }
-    values.push(taskId);
-    await this._db.prepare(
-      `UPDATE scheduled_messages SET ${sets.join(", ")} WHERE id = ?`
-    ).bind(...values).run();
-    return this._db.prepare("SELECT * FROM scheduled_messages WHERE id = ?").bind(taskId).first();
-  }
-  async updateTaskByUuid(uuid, userId, encryptedPayload, extraFields) {
-    const now = this._now();
-    const sets = ["encrypted_payload = ?", "updated_at = ?"];
-    const values = [encryptedPayload, now];
-    if (extraFields) {
-      for (const [key, value] of Object.entries(extraFields)) {
-        if (!UPDATABLE_COLUMNS.has(key)) {
-          throw new Error(`[amsg-server D1] rejected unknown update column: ${key}`);
-        }
-        sets.push(`${key} = ?`);
-        values.push(key === "next_send_at" ? this._iso(value) : value);
-      }
-    }
-    values.push(uuid, userId);
-    const res = await this._db.prepare(
-      `UPDATE scheduled_messages SET ${sets.join(", ")}
-       WHERE uuid = ? AND user_id = ? AND status = 'pending'`
-    ).bind(...values).run();
-    if (!res.meta.changes) return null;
-    return { uuid, updated_at: now };
-  }
-  async deleteTaskById(taskId) {
-    const res = await this._db.prepare("DELETE FROM scheduled_messages WHERE id = ?").bind(taskId).run();
-    return res.meta.changes > 0;
-  }
-  async deleteTaskByUuid(uuid, userId) {
-    const res = await this._db.prepare(
-      "DELETE FROM scheduled_messages WHERE uuid = ? AND user_id = ?"
-    ).bind(uuid, userId).run();
-    return res.meta.changes > 0;
-  }
-  async getPendingTasks(limit = 50) {
-    const now = this._now();
-    const res = await this._db.prepare(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
-       FROM scheduled_messages
-       WHERE status = 'pending' AND next_send_at <= ?
-         AND (lease_until IS NULL OR lease_until <= ?)
-       ORDER BY next_send_at ASC
-       LIMIT ?`
-    ).bind(now, now, limit).all();
-    return res.results || [];
-  }
-  /**
-   * 领取一条到点的任务：在 lease_until 上写下「这条归我管到什么时候」，
-   * 本次投递期间别的 tick 领不走它。
-   *
-   * 租约写在自己的列上，next_send_at 全程不动——那一列是用户设的触发时刻，
-   * 任务列表要读它、循环任务推进下一次也要拿它当基准。
-   *
-   * 两个 tick 抢同一行时只有一个能改到行，另一个拿到 changes = 0，据此跳过。
-   * WHERE 里的两个条件各管一件事：
-   *   - lease_until 为空或已过期：没人正在跑这条。领了任务的 tick 中途没了
-   *     也不会把行焊死，租约到期后自然可以被接手。
-   *   - next_send_at 等于读这行时看到的值：读出来之后用户又改了排期的话，
-   *     这一跳就不该再按旧时刻发。
-   *
-   * 不加一个 'sending' 状态来表达「正在跑」：建表语句里 status 有
-   * CHECK (status IN ('pending','sent','failed'))，加值要重建表。
-   *
-   * expectedNextSendAt 按读到的原样比对，不做时区归一化——老部署里可能还留
-   * 着非归一化写法的行（如 +08:00 结尾），归一化后反而对不上，那条任务会永
-   * 远领不到。
-   *
-   * @param {number} taskId
-   * @param {string} expectedNextSendAt - 读这行时拿到的 next_send_at 原值
-   * @param {string|Date} leaseUntil - 租期末尾
-   * @returns {Promise<boolean>} true = 领到了；false = 别人正拿着租约、排期被改过、或行已不是 pending
-   */
-  async claimTask(taskId, expectedNextSendAt, leaseUntil) {
-    const expected = typeof expectedNextSendAt === "string" ? expectedNextSendAt : this._iso(expectedNextSendAt);
-    const res = await this._db.prepare(
-      `UPDATE scheduled_messages
-          SET lease_until = ?, updated_at = ?
-        WHERE id = ? AND status = 'pending' AND next_send_at = ?
-          AND (lease_until IS NULL OR lease_until <= ?)`
-    ).bind(this._iso(leaseUntil), this._now(), taskId, expected, this._now()).run();
-    return (res.meta.changes || 0) > 0;
-  }
-  async listTasks(userId, opts = {}) {
-    const { status = "all", limit = 20, offset = 0 } = opts;
-    const conditions = ["user_id = ?"];
-    const params = [userId];
-    if (status !== "all") {
-      conditions.push("status = ?");
-      params.push(status);
-    }
-    const where = conditions.join(" AND ");
-    const countRow = await this._db.prepare(
-      `SELECT COUNT(*) as count FROM scheduled_messages WHERE ${where}`
-    ).bind(...params).first();
-    const total = Number(countRow.count) || 0;
-    const res = await this._db.prepare(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, created_at, updated_at
-       FROM scheduled_messages
-       WHERE ${where}
-       ORDER BY next_send_at ASC
-       LIMIT ? OFFSET ?`
-    ).bind(...params, limit, offset).all();
-    return { tasks: res.results || [], total };
-  }
-  async cleanupOldTasks(days = 7) {
-    const safeDays = Math.max(1, Math.floor(Number(days)));
-    const cutoff = new Date(Date.now() - safeDays * 24 * 60 * 60 * 1e3).toISOString();
-    const res = await this._db.prepare(
-      `DELETE FROM scheduled_messages
-       WHERE status IN ('sent', 'failed') AND updated_at < ?`
-    ).bind(cutoff).run();
-    return res.meta.changes || 0;
-  }
-  async getTaskStatus(uuid, userId) {
-    const row = await this._db.prepare(
-      "SELECT status FROM scheduled_messages WHERE uuid = ? AND user_id = ? LIMIT 1"
-    ).bind(uuid, userId).first();
-    return row ? row.status : null;
-  }
-  // ── client_state (single-user cloud state mirror) ──────────────────────
-  /**
-   * Batch upsert. Last-write-wins per (namespace, key): an entry older
-   * than the stored row (updatedAt strictly lower) is skipped; equal or
-   * newer overwrites. Values arrive pre-encrypted (the handler encrypts).
-   *
-   * `cleanups` 是删除项：在同一 batch 里先于 upsert 执行，`updated_at <= ?`
-   * 条件保证陈旧批次删不动更新写入的行。两种形态——
-   *   - `{ namespace, keyPrefix, updatedAt }` 删 key 前缀下的所有行，用来清掉
-   *     大值旧写入留下的切片行（见 lib/state-chunks.js）；
-   *   - `{ namespace, key, updatedAt }` 删这一个 key，用来删整条状态（前缀会
-   *     连带删掉同前缀的兄弟 key，删单条必须走精确匹配）。
-   *
-   * 删掉一整条状态就是这两种各来一条（切片行走前缀、根行走精确 key），
-   * `entries` 传空数组即可——见 lib/client-state-store.js。
-   *
-   * Uses D1's batch() — one network round trip for the whole set (implicit
-   * transaction). The client calls this endpoint inside its few-seconds
-   * background window, so N sequential round trips could eat the whole
-   * window. Bindings without batch() (e.g. the sqlite test shim, custom
-   * adapters) fall back to a sequential loop.
-   *
-   * @param {string} userId
-   * @param {Array<{ namespace: string, key: string, value: string, updatedAt: number }>} entries
-   * @param {Array<{ namespace: string, key?: string, keyPrefix?: string, updatedAt: number }>} [cleanups]
-   * @returns {Promise<{ upserted: number, skipped: number, outcomes: boolean[] }>}
-   *   `outcomes[i]` 对应 entries[i] 是否真的写入（changes > 0）。
-   */
-  async upsertClientState(userId, entries, cleanups = []) {
-    const UPSERT_SQL = `INSERT INTO client_state (user_id, namespace, key, value, updated_at)
-       VALUES (?, ?, ?, ?, ?)
-       ON CONFLICT (user_id, namespace, key) DO UPDATE SET
-         value = excluded.value,
-         updated_at = excluded.updated_at
-       WHERE excluded.updated_at >= client_state.updated_at`;
-    const CLEANUP_PREFIX_SQL = `DELETE FROM client_state
-       WHERE user_id = ? AND namespace = ? AND key LIKE ? ESCAPE '\\' AND updated_at <= ?`;
-    const CLEANUP_KEY_SQL = `DELETE FROM client_state
-       WHERE user_id = ? AND namespace = ? AND key = ? AND updated_at <= ?`;
-    const buildStatements = () => [
-      ...cleanups.map((c) => typeof c.key === "string" ? this._db.prepare(CLEANUP_KEY_SQL).bind(userId, c.namespace, c.key, c.updatedAt) : this._db.prepare(CLEANUP_PREFIX_SQL).bind(userId, c.namespace, `${escapeLikePrefix(c.keyPrefix)}%`, c.updatedAt)),
-      ...entries.map(
-        (entry) => this._db.prepare(UPSERT_SQL).bind(userId, entry.namespace, entry.key, entry.value, entry.updatedAt)
-      )
-    ];
-    let results;
-    if (typeof this._db.batch === "function") {
-      results = await this._db.batch(buildStatements());
-    } else {
-      results = [];
-      for (const stmt of buildStatements()) {
-        results.push(await stmt.run());
-      }
-    }
-    const outcomes = results.slice(cleanups.length).map((res) => res.meta.changes > 0);
-    let upserted = 0;
-    let skipped = 0;
-    for (const wrote of outcomes) {
-      if (wrote) upserted++;
-      else skipped++;
-    }
-    return { upserted, skipped, outcomes };
-  }
-  /**
-   * All entries of one namespace (values still encrypted).
-   *
-   * @param {string} userId
-   * @param {string} namespace
-   * @returns {Promise<Array<{ namespace: string, key: string, value: string, updated_at: number }>>}
-   */
-  async getClientState(userId, namespace) {
-    const res = await this._db.prepare(
-      `SELECT namespace, key, value, updated_at
-       FROM client_state
-       WHERE user_id = ? AND namespace = ?
-       ORDER BY key ASC`
-    ).bind(userId, namespace).all();
-    return res.results || [];
-  }
-  /**
-   * Wipe every entry of this user.
-   *
-   * @param {string} userId
-   * @returns {Promise<number>} rows deleted
-   */
-  async clearClientState(userId) {
-    const res = await this._db.prepare("DELETE FROM client_state WHERE user_id = ?").bind(userId).run();
-    return res.meta.changes || 0;
-  }
-};
-function createD1Adapter(db) {
-  if (!db || typeof db.prepare !== "function") {
-    throw new Error("[amsg-server] createD1Adapter requires a D1 database binding (env.DB)");
-  }
-  return new D1Adapter(db);
-}
-
-// src/server/lib/constant-time.js
-async function constantTimeEqual(a, b) {
-  const enc = new TextEncoder();
-  const keyBytes = globalThis.crypto.getRandomValues(new Uint8Array(32));
-  const key = await globalThis.crypto.subtle.importKey(
-    "raw",
-    keyBytes,
-    { name: "HMAC", hash: "SHA-256" },
-    false,
-    ["sign"]
-  );
-  const da = new Uint8Array(await globalThis.crypto.subtle.sign("HMAC", key, enc.encode(String(a))));
-  const db = new Uint8Array(await globalThis.crypto.subtle.sign("HMAC", key, enc.encode(String(b))));
-  let diff = 0;
-  for (let i = 0; i < da.length; i++) {
-    diff |= da[i] ^ db[i];
-  }
-  return diff === 0;
-}
-
-// src/server/tenant/single-user-context.js
-function createSingleUserContextManager({ db, masterKey, serverToken } = {}) {
-  if (!db) throw new Error("[amsg-server single-user] db (adapter) is required");
-  if (!masterKey) throw new Error("[amsg-server single-user] masterKey is required");
-  const token = String(serverToken || "").trim();
-  async function isAuthorized(headers) {
-    if (!token) return true;
-    const provided = getHeader(headers, "x-client-token");
-    if (!provided) return false;
-    return constantTimeEqual(provided, token);
-  }
-  async function resolveTenant(headers) {
-    if (!await isAuthorized(headers)) {
-      return {
-        ok: false,
-        error: {
-          status: 401,
-          body: { success: false, error: { code: "INVALID_CLIENT_TOKEN", message: "\u5171\u4EAB\u5BC6\u94A5\u65E0\u6548\u6216\u7F3A\u5931" } }
-        }
-      };
-    }
-    return {
-      ok: true,
-      context: { tenantId: "single", tokenType: "tenant", db, masterKey }
-    };
-  }
-  async function initializeTenant() {
-    const schema = await db.initSchema();
-    return { tenantId: "single", schema };
-  }
-  return { resolveTenant, initializeTenant };
-}
-
-// src/server/handlers/single-user-init.js
-function createSingleUserInitHandler(ctx) {
-  async function POST(headers) {
-    const auth = await ctx.tenantManager.resolveTenant(headers || {});
-    if (!auth.ok) {
-      return auth.error;
-    }
-    try {
-      const result = await ctx.tenantManager.initializeTenant();
-      return {
-        status: 200,
-        body: { success: true, data: { tenantId: result.tenantId, schema: result.schema } }
-      };
-    } catch (error) {
-      return {
-        status: 500,
-        body: { success: false, error: { code: "INIT_FAILED", message: error.message } }
-      };
-    }
-  }
-  return { POST };
-}
-
-// src/server/handlers/vapid-public-key.js
-function createVapidPublicKeyHandler(ctx) {
-  async function GET(url, headers) {
-    const effectiveHeaders = headers || url || {};
-    const tenantResult = await ctx.tenantManager.resolveTenant(effectiveHeaders);
-    if (!tenantResult.ok) {
-      return tenantResult.error;
-    }
-    const publicKey = ctx.vapid && ctx.vapid.publicKey;
-    if (!publicKey) {
-      return {
-        status: 503,
-        body: {
-          success: false,
-          error: {
-            code: "VAPID_NOT_CONFIGURED",
-            message: "VAPID \u516C\u94A5\u672A\u914D\u7F6E\uFF1A\u8BF7\u4E3A\u672C Worker \u8BBE\u7F6E VAPID_PUBLIC_KEY"
-          }
-        }
-      };
-    }
-    return {
-      status: 200,
-      body: { success: true, publicKey }
-    };
-  }
-  return { GET };
-}
-
-// src/server/handlers/client-state.js
-var MAX_STATE_ENTRIES_PER_REQUEST = MAX_STATE_ENTRIES_PER_BATCH;
-function err(status, code, message, details) {
-  const error = details === void 0 ? { code, message } : { code, message, details };
-  return { status, body: { success: false, error } };
-}
-function requireUserId(headers) {
-  const userId = getHeader(headers, "x-user-id");
-  if (!userId) return { error: err(400, "USER_ID_REQUIRED", "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26") };
-  if (!isValidUUIDv4(userId)) return { error: err(400, "INVALID_USER_ID_FORMAT", "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F") };
-  return { userId };
-}
-function rejectEntry(entry, index, code, message, extra) {
-  const rejection = { index, code, message, ...extra || {} };
-  if (entry && typeof entry === "object") {
-    if (typeof entry.namespace === "string") rejection.namespace = entry.namespace;
-    if (typeof entry.key === "string") rejection.key = entry.key;
-  }
-  return rejection;
-}
-function validateEntry(entry, index, maxValueBytes) {
-  if (!isPlainObject(entry)) {
-    return rejectEntry(entry, index, "INVALID_STATE_ENTRY", `entries[${index}] \u5FC5\u987B\u662F\u5BF9\u8C61`);
-  }
-  if (typeof entry.namespace !== "string" || !entry.namespace.trim() || entry.namespace.length > MAX_NAMESPACE_CHARS) {
-    return rejectEntry(entry, index, "INVALID_STATE_NAMESPACE", `entries[${index}].namespace \u5FC5\u987B\u662F 1-${MAX_NAMESPACE_CHARS} \u5B57\u7B26\u7684\u5B57\u7B26\u4E32`);
-  }
-  if (INTERNAL_STATE_CHAR_RE.test(entry.namespace)) {
-    return rejectEntry(entry, index, "INVALID_STATE_NAMESPACE", `entries[${index}].namespace \u4E0D\u80FD\u5305\u542B\u63A7\u5236\u5B57\u7B26\uFF08\\u0000-\\u001f \u4E3A\u5E93\u5185\u90E8\u4FDD\u7559\uFF09`);
-  }
-  if (typeof entry.key !== "string" || !entry.key.trim() || entry.key.length > MAX_KEY_CHARS) {
-    return rejectEntry(entry, index, "INVALID_STATE_KEY", `entries[${index}].key \u5FC5\u987B\u662F 1-${MAX_KEY_CHARS} \u5B57\u7B26\u7684\u5B57\u7B26\u4E32`);
-  }
-  if (INTERNAL_STATE_CHAR_RE.test(entry.key)) {
-    return rejectEntry(entry, index, "INVALID_STATE_KEY", `entries[${index}].key \u4E0D\u80FD\u5305\u542B\u63A7\u5236\u5B57\u7B26\uFF08\\u0000-\\u001f \u4E3A\u5E93\u5185\u90E8\u4FDD\u7559\uFF09`);
-  }
-  if (typeof entry.value !== "string") {
-    return rejectEntry(entry, index, "INVALID_STATE_VALUE", `entries[${index}].value \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\uFF08\u5BBF\u4E3B\u81EA\u884C\u5E8F\u5217\u5316\uFF09`);
-  }
-  const bytes = stateValueBytes(entry.value);
-  if (bytes > maxValueBytes) {
-    return rejectEntry(entry, index, "STATE_VALUE_TOO_LARGE", `entries[${index}].value \u8D85\u8FC7\u5355\u6761\u603B\u4E0A\u9650`, { bytes, maxBytes: maxValueBytes });
-  }
-  if (!Number.isInteger(entry.updatedAt) || entry.updatedAt <= 0) {
-    return rejectEntry(entry, index, "INVALID_STATE_UPDATED_AT", `entries[${index}].updatedAt \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF08epoch \u6BEB\u79D2\uFF09`);
-  }
-  return null;
-}
-function createClientStateHandler(ctx) {
-  async function PUT(headers, body) {
-    const tenantResult = await ctx.tenantManager.resolveTenant(headers);
-    if (!tenantResult.ok) return tenantResult.error;
-    const { db, masterKey } = tenantResult.context;
-    if (getHeader(headers, "x-payload-encrypted") !== "true") {
-      return err(400, "ENCRYPTION_REQUIRED", "\u8BF7\u6C42\u4F53\u5FC5\u987B\u52A0\u5BC6");
-    }
-    const gate = requireUserId(headers);
-    if (gate.error) return gate.error;
-    const { userId } = gate;
-    if (getHeader(headers, "x-encryption-version") !== "1") {
-      return err(400, "UNSUPPORTED_ENCRYPTION_VERSION", "\u52A0\u5BC6\u7248\u672C\u4E0D\u652F\u6301");
-    }
-    const parsedBody = parseEncryptedBody(body);
-    if (!parsedBody.ok) return { status: 400, body: { success: false, error: parsedBody.error } };
-    const userKey = await deriveUserEncryptionKey(userId, masterKey);
-    let payload;
-    try {
-      payload = await decryptPayload(parsedBody.data, userKey);
-    } catch (error) {
-      if (error instanceof SyntaxError) {
-        return err(400, "INVALID_PAYLOAD_FORMAT", "\u89E3\u5BC6\u540E\u7684\u6570\u636E\u4E0D\u662F\u6709\u6548 JSON");
-      }
-      return err(400, "DECRYPTION_FAILED", "\u8BF7\u6C42\u4F53\u89E3\u5BC6\u5931\u8D25");
-    }
-    if (!isPlainObject(payload)) return err(400, "INVALID_PAYLOAD_FORMAT", "\u89E3\u5BC6\u540E\u7684\u6570\u636E\u5FC5\u987B\u662F JSON \u5BF9\u8C61");
-    const entries = payload.entries;
-    if (!Array.isArray(entries) || entries.length === 0) {
-      return err(400, "INVALID_STATE_ENTRIES", "entries \u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4");
-    }
-    if (entries.length > MAX_STATE_ENTRIES_PER_REQUEST) {
-      return err(400, "TOO_MANY_STATE_ENTRIES", `\u5355\u6B21\u6700\u591A ${MAX_STATE_ENTRIES_PER_REQUEST} \u6761`, { count: entries.length });
-    }
-    const maxValueBytes = Number.isInteger(ctx.maxStateValueBytes) && ctx.maxStateValueBytes > 0 ? ctx.maxStateValueBytes : DEFAULT_MAX_STATE_VALUE_BYTES;
-    const accepted = [];
-    const rejected = [];
-    for (let i = 0; i < entries.length; i++) {
-      const rejection = validateEntry(entries[i], i, maxValueBytes);
-      if (rejection) rejected.push(rejection);
-      else accepted.push(entries[i]);
-    }
-    if (typeof db.upsertClientState !== "function") {
-      return err(501, "CLIENT_STATE_NOT_SUPPORTED", "\u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301 client_state");
-    }
-    const { upserted, skipped } = await writeClientStateEntries({ db, userId, userKey, entries: accepted });
-    const data = { upserted, skipped };
-    if (rejected.length > 0) data.rejected = rejected;
-    return { status: 200, body: { success: true, data } };
-  }
-  async function GET(url, headers) {
-    const tenantResult = await ctx.tenantManager.resolveTenant(headers);
-    if (!tenantResult.ok) return tenantResult.error;
-    const { db, masterKey } = tenantResult.context;
-    const gate = requireUserId(headers);
-    if (gate.error) return gate.error;
-    const { userId } = gate;
-    const namespace = new URL(url, "https://dummy").searchParams.get("namespace") || "";
-    if (!namespace.trim()) return err(400, "NAMESPACE_REQUIRED", "\u5FC5\u987B\u63D0\u4F9B namespace \u67E5\u8BE2\u53C2\u6570");
-    if (INTERNAL_STATE_CHAR_RE.test(namespace)) {
-      return err(400, "INVALID_STATE_NAMESPACE", "namespace \u4E0D\u80FD\u5305\u542B\u63A7\u5236\u5B57\u7B26\uFF08\\u0000-\\u001f \u4E3A\u5E93\u5185\u90E8\u4FDD\u7559\uFF09");
-    }
-    if (typeof db.getClientState !== "function") {
-      return err(501, "CLIENT_STATE_NOT_SUPPORTED", "\u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301 client_state");
-    }
-    const userKey = await deriveUserEncryptionKey(userId, masterKey);
-    const rows = await db.getClientState(userId, namespace);
-    const decrypted = await resolveClientStateEntries(
-      rows,
-      () => db.getClientState(userId, chunkNamespaceFor(namespace)),
-      (value) => decryptFromStorage(value, userKey)
-    );
-    const encryptedResponse = await encryptPayload({ namespace, entries: decrypted }, userKey);
-    return { status: 200, body: { success: true, encrypted: true, version: 1, data: encryptedResponse } };
-  }
-  async function DELETE(url, headers) {
-    const tenantResult = await ctx.tenantManager.resolveTenant(headers);
-    if (!tenantResult.ok) return tenantResult.error;
-    const { db } = tenantResult.context;
-    const gate = requireUserId(headers);
-    if (gate.error) return gate.error;
-    const { userId } = gate;
-    if (typeof db.clearClientState !== "function") {
-      return err(501, "CLIENT_STATE_NOT_SUPPORTED", "\u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301 client_state");
-    }
-    const deleted = await db.clearClientState(userId);
-    return { status: 200, body: { success: true, data: { deleted } } };
-  }
-  return { PUT, GET, DELETE };
-}
-
-// src/server/lib/version.js
-var SERVER_VERSION = true ? "2.6.0-next.9" : "0.0.0-dev";
-
-// src/server/handlers/capabilities.js
-var SERVER_FEATURES = Object.freeze([
-  "client-state",
-  "client-state-chunking",
-  "client-state-partial-failure",
-  "agentic-hooks",
-  "agentic-scratch",
-  "agentic-write-state",
-  "agentic-fire-tools",
-  "agentic-schedule-task",
-  "vapid-public-key"
-]);
-function createCapabilitiesHandler(ctx) {
-  async function GET(url, headers) {
-    const effectiveHeaders = headers || url || {};
-    const tenantResult = await ctx.tenantManager.resolveTenant(effectiveHeaders);
-    if (!tenantResult.ok) {
-      return tenantResult.error;
-    }
-    return {
-      status: 200,
-      body: { success: true, serverVersion: SERVER_VERSION, features: [...SERVER_FEATURES] }
-    };
-  }
-  return { GET };
-}
-
-// src/server/single-user.js
-function createSingleUserServer(config) {
-  if (!config || !config.db) throw new Error("[amsg-server single-user] config.db is required");
-  if (!config.masterKey) throw new Error("[amsg-server single-user] config.masterKey is required");
-  const vapid = config.vapid || {};
-  const tenantManager = createSingleUserContextManager({
-    db: config.db,
-    masterKey: config.masterKey,
-    serverToken: config.serverToken
-  });
-  const ctx = {
-    vapid: {
-      email: vapid.email || "",
-      publicKey: vapid.publicKey || "",
-      privateKey: vapid.privateKey || ""
-    },
-    webpush: config.webpush || null,
-    tenantManager,
-    // Fire-time hooks (optional): the in-server instant path fires through
-    // processMessagesByUuid with this ctx, so instant-type tasks can take
-    // the agentic path too.
-    hooks: config.hooks || null,
-    maxToolIterations: config.maxToolIterations,
-    totalTimeoutMs: config.totalTimeoutMs,
-    maxStateValueBytes: config.maxStateValueBytes,
-    // hook 的 ctx.scheduleTask() 单次 fire 建任务的条数上限（默认 2）。
-    maxScheduledTasksPerFire: config.maxScheduledTasksPerFire
-  };
-  return {
-    ctx,
-    handlers: {
-      init: createSingleUserInitHandler(ctx),
-      getUserKey: createGetUserKeyHandler(ctx),
-      scheduleMessage: createScheduleMessageHandler(ctx),
-      updateMessage: createUpdateMessageHandler(ctx),
-      cancelMessage: createCancelMessageHandler(ctx),
-      messages: createMessagesHandler(ctx),
-      vapidPublicKey: createVapidPublicKeyHandler(ctx),
-      clientState: createClientStateHandler(ctx),
-      capabilities: createCapabilitiesHandler(ctx)
-    }
-  };
-}
-
-// src/server/lib/webpush-webcrypto.js
-import { normalizeVapidSubject } from "@rei-standard/amsg-shared";
-var KEY_INFO_PREFIX = utf8("WebPush: info\0");
-var CEK_INFO = utf8("Content-Encoding: aes128gcm\0");
-var NONCE_INFO = utf8("Content-Encoding: nonce\0");
-var VAPID_DEFAULT_TTL = 60;
-var VAPID_TOKEN_LIFETIME = 12 * 3600;
-var RECORD_SIZE = 4096;
-var WEB_PUSH_MAX_BODY_BYTES = 4096;
-var WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES = 16 + 4 + 1 + 65 + 1 + 16;
-var MAX_PUSH_PAYLOAD_BYTES = WEB_PUSH_MAX_BODY_BYTES - WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES;
-var payloadEncoder = new TextEncoder();
-function measurePushPayload(payload) {
-  const bytes = payloadEncoder.encode(typeof payload === "string" ? payload : String(payload)).length;
-  return {
-    bytes,
-    maxBytes: MAX_PUSH_PAYLOAD_BYTES,
-    remainingBytes: MAX_PUSH_PAYLOAD_BYTES - bytes,
-    withinLimit: bytes <= MAX_PUSH_PAYLOAD_BYTES
-  };
-}
-async function sendWebPush({ subscription, payload, vapid, ttl, fetch: fetchImpl }) {
-  if (!subscription || typeof subscription.endpoint !== "string") {
-    throw new Error("sendWebPush: invalid subscription");
-  }
-  if (typeof payload !== "string") {
-    throw new Error("sendWebPush: payload must be a string");
-  }
-  if (!vapid || !vapid.email || !vapid.publicKey || !vapid.privateKey) {
-    throw new Error("VAPID_CONFIG_MISSING");
-  }
-  const subscriptionKeys = subscription.keys || {};
-  if (typeof subscriptionKeys.p256dh !== "string" || typeof subscriptionKeys.auth !== "string") {
-    throw new Error("sendWebPush: subscription.keys.p256dh and .auth are required");
-  }
-  const size = measurePushPayload(payload);
-  if (!size.withinLimit) {
-    const err2 = new Error(
-      `sendWebPush: payload is ${size.bytes} bytes, over the ${MAX_PUSH_PAYLOAD_BYTES}-byte limit (push services cap the encrypted body at ${WEB_PUSH_MAX_BODY_BYTES} bytes; aes128gcm adds ${WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES} bytes)`
-    );
-    err2.code = "PUSH_PAYLOAD_TOO_LARGE";
-    err2.bytes = size.bytes;
-    err2.maxBytes = MAX_PUSH_PAYLOAD_BYTES;
-    throw err2;
-  }
-  const encryptedBody = await encryptPushPayload({
-    plaintext: utf8(payload),
-    uaPublicKey: base64UrlToBytes(subscriptionKeys.p256dh),
-    authSecret: base64UrlToBytes(subscriptionKeys.auth)
-  });
-  const jwt = await buildVapidJwt({
-    audience: originOf(subscription.endpoint),
-    subject: normalizeVapidSubject(vapid.email),
-    publicKey: vapid.publicKey,
-    privateKey: vapid.privateKey
-  });
-  const fetchFn = fetchImpl || globalThis.fetch;
-  if (typeof fetchFn !== "function") {
-    throw new Error("sendWebPush: no fetch implementation available");
-  }
-  const res = await fetchFn(subscription.endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/octet-stream",
-      "Content-Encoding": "aes128gcm",
-      "TTL": String(Number.isFinite(ttl) ? ttl : VAPID_DEFAULT_TTL),
-      "Authorization": `vapid t=${jwt}, k=${vapid.publicKey}`
-    },
-    body: encryptedBody
-  });
-  if (!res.ok) {
-    const text = await safeReadText(res);
-    const err2 = new Error(
-      `Web Push delivery failed: ${res.status} ${res.statusText || ""}${text ? ` \u2014 ${text}` : ""}`
-    );
-    err2.code = "PUSH_SEND_FAILED";
-    err2.statusCode = res.status;
-    throw err2;
-  }
-  return {
-    statusCode: res.status,
-    body: await safeReadText(res),
-    headers: res.headers
-  };
-}
-async function encryptPushPayload({ plaintext, uaPublicKey, authSecret }) {
-  const asKeyPair = await globalThis.crypto.subtle.generateKey(
-    { name: "ECDH", namedCurve: "P-256" },
-    true,
-    ["deriveBits"]
-  );
-  const asPublicRaw = new Uint8Array(
-    await globalThis.crypto.subtle.exportKey("raw", asKeyPair.publicKey)
-  );
-  const uaPublicCryptoKey = await globalThis.crypto.subtle.importKey(
-    "raw",
-    uaPublicKey,
-    { name: "ECDH", namedCurve: "P-256" },
-    false,
-    []
-  );
-  const ecdhSecret = new Uint8Array(
-    await globalThis.crypto.subtle.deriveBits(
-      { name: "ECDH", public: uaPublicCryptoKey },
-      asKeyPair.privateKey,
-      256
-    )
-  );
-  const keyInfo = concatBytes(KEY_INFO_PREFIX, uaPublicKey, asPublicRaw);
-  const ikm = await hkdfSha256(authSecret, ecdhSecret, keyInfo, 32);
-  const salt = randomBytes(16);
-  const cekBytes = await hkdfSha256(salt, ikm, CEK_INFO, 16);
-  const cek = await globalThis.crypto.subtle.importKey(
-    "raw",
-    cekBytes,
-    { name: "AES-GCM" },
-    false,
-    ["encrypt"]
-  );
-  const nonce = await hkdfSha256(salt, ikm, NONCE_INFO, 12);
-  const padded = concatBytes(plaintext, new Uint8Array([2]));
-  const ciphertext = new Uint8Array(
-    await globalThis.crypto.subtle.encrypt({ name: "AES-GCM", iv: nonce }, cek, padded)
-  );
-  const header = new Uint8Array(16 + 4 + 1 + asPublicRaw.byteLength);
-  header.set(salt, 0);
-  writeUint32BE(header, 16, RECORD_SIZE);
-  header[20] = asPublicRaw.byteLength;
-  header.set(asPublicRaw, 21);
-  return concatBytes(header, ciphertext);
-}
-async function hkdfSha256(salt, ikm, info, length) {
-  const baseKey = await globalThis.crypto.subtle.importKey(
-    "raw",
-    toUint8(ikm),
-    { name: "HKDF" },
-    false,
-    ["deriveBits"]
-  );
-  const bits = await globalThis.crypto.subtle.deriveBits(
-    {
-      name: "HKDF",
-      hash: "SHA-256",
-      salt: toUint8(salt),
-      info: toUint8(info)
-    },
-    baseKey,
-    length * 8
-  );
-  return new Uint8Array(bits);
-}
-async function buildVapidJwt({ audience, subject, publicKey, privateKey }) {
-  const header = jsonToBase64Url({ typ: "JWT", alg: "ES256" });
-  const payload = jsonToBase64Url({
-    aud: audience,
-    exp: Math.floor(Date.now() / 1e3) + VAPID_TOKEN_LIFETIME,
-    sub: subject
-  });
-  const signingInput = utf8(`${header}.${payload}`);
-  const pubBytes = base64UrlToBytes(publicKey);
-  const privBytes = base64UrlToBytes(privateKey);
-  if (pubBytes.length !== 65 || pubBytes[0] !== 4) {
-    throw new Error("VAPID publicKey must be a 65-byte uncompressed P-256 point (base64url).");
-  }
-  if (privBytes.length !== 32) {
-    throw new Error("VAPID privateKey must be a 32-byte scalar (base64url).");
-  }
-  const jwk = {
-    kty: "EC",
-    crv: "P-256",
-    d: bytesToBase64Url(privBytes),
-    x: bytesToBase64Url(pubBytes.subarray(1, 33)),
-    y: bytesToBase64Url(pubBytes.subarray(33, 65)),
-    ext: true
-  };
-  const key = await globalThis.crypto.subtle.importKey(
-    "jwk",
-    jwk,
-    { name: "ECDSA", namedCurve: "P-256" },
-    false,
-    ["sign"]
-  );
-  const sig = await globalThis.crypto.subtle.sign(
-    { name: "ECDSA", hash: "SHA-256" },
-    key,
-    signingInput
-  );
-  return `${header}.${payload}.${bytesToBase64Url(sig)}`;
-}
-function originOf(endpoint) {
-  return new URL(endpoint).origin;
-}
-function writeUint32BE(buf, offset, value) {
-  buf[offset] = value >>> 24 & 255;
-  buf[offset + 1] = value >>> 16 & 255;
-  buf[offset + 2] = value >>> 8 & 255;
-  buf[offset + 3] = value & 255;
-}
-async function safeReadText(res) {
-  try {
-    return await res.text();
-  } catch {
-    return "";
-  }
-}
-var SCHEDULED_DEFAULT_TTL = 2419200;
-function createWebCryptoWebPush(vapid = {}, { ttl = SCHEDULED_DEFAULT_TTL } = {}) {
-  return {
-    async sendNotification(subscription, payload) {
-      return sendWebPush({
-        subscription,
-        payload,
-        ttl,
-        vapid: {
-          email: vapid.email,
-          publicKey: vapid.publicKey,
-          privateKey: vapid.privateKey
-        },
-        fetch: globalThis.fetch
-      });
-    }
-  };
-}
-
-// src/server/cloudflare/single-user-worker.js
-function headersToObject(h) {
-  const out = {};
-  for (const [k, v] of h) out[k] = v;
-  return out;
-}
-function jsonResponse(status, body, extraHeaders) {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json; charset=utf-8", ...extraHeaders || {} }
-  });
-}
-var CORS_ALLOW_HEADERS = "Content-Type, X-User-Id, X-Payload-Encrypted, X-Encryption-Version, X-Response-Encrypted, X-Client-Token";
-var CORS_ALLOW_METHODS = "GET, POST, PUT, DELETE, OPTIONS";
-function corsHeadersFor(cors, requestOrigin) {
-  if (!cors || cors.origin == null) return null;
-  const allowOrigin = typeof cors.origin === "function" ? cors.origin(requestOrigin) || null : cors.origin;
-  if (!allowOrigin) return null;
-  const headers = {
-    "Access-Control-Allow-Origin": allowOrigin,
-    "Access-Control-Allow-Methods": CORS_ALLOW_METHODS,
-    "Access-Control-Allow-Headers": cors.allowHeaders || CORS_ALLOW_HEADERS,
-    "Access-Control-Max-Age": String(cors.maxAge ?? 86400)
-  };
-  if (allowOrigin !== "*") headers["Vary"] = "Origin";
-  return headers;
-}
-function createSingleUserCloudflareWorker(buildConfig) {
-  async function resolveConfig(env) {
-    const cfg = await buildConfig(env);
-    if (!cfg.db) cfg.db = createD1Adapter(env.DB);
-    return cfg;
-  }
-  async function fetch2(request, env) {
-    try {
-      const cfg = await resolveConfig(env);
-      const cors = corsHeadersFor(cfg.cors, request.headers.get("origin") || "");
-      const method = request.method.toUpperCase();
-      if (method === "OPTIONS") {
-        return cors ? new Response(null, { status: 204, headers: cors }) : jsonResponse(404, { success: false, error: { code: "NOT_FOUND", message: "Unknown route" } });
-      }
-      const server = createSingleUserServer(cfg);
-      const url = request.url;
-      const pathname = new URL(url).pathname.replace(/\/+$/, "") || "/";
-      const headers = headersToObject(request.headers);
-      let result;
-      if (method === "POST" && pathname.endsWith("/init-tenant")) {
-        result = await server.handlers.init.POST(headers, await request.text());
-      } else if (method === "GET" && pathname.endsWith("/get-user-key")) {
-        result = await server.handlers.getUserKey.GET(url, headers);
-      } else if (method === "POST" && pathname.endsWith("/schedule-message")) {
-        result = await server.handlers.scheduleMessage.POST(headers, await request.text());
-      } else if (method === "GET" && pathname.endsWith("/messages")) {
-        result = await server.handlers.messages.GET(url, headers);
-      } else if (method === "PUT" && pathname.endsWith("/update-message")) {
-        result = await server.handlers.updateMessage.PUT(url, headers, await request.text());
-      } else if (method === "DELETE" && pathname.endsWith("/cancel-message")) {
-        result = await server.handlers.cancelMessage.DELETE(url, headers);
-      } else if (method === "GET" && pathname.endsWith("/vapid-public-key")) {
-        result = await server.handlers.vapidPublicKey.GET(url, headers);
-      } else if (method === "GET" && pathname.endsWith("/capabilities")) {
-        result = await server.handlers.capabilities.GET(url, headers);
-      } else if (method === "PUT" && pathname.endsWith("/client-state")) {
-        result = await server.handlers.clientState.PUT(headers, await request.text());
-      } else if (method === "GET" && pathname.endsWith("/client-state")) {
-        result = await server.handlers.clientState.GET(url, headers);
-      } else if (method === "DELETE" && pathname.endsWith("/client-state")) {
-        result = await server.handlers.clientState.DELETE(url, headers);
-      } else {
-        result = { status: 404, body: { success: false, error: { code: "NOT_FOUND", message: "Unknown route" } } };
-      }
-      return jsonResponse(result.status, result.body, cors);
-    } catch (error) {
-      console.error("[amsg single-user] fetch() unhandled error:", error && error.message);
-      return jsonResponse(500, { success: false, error: { code: "INTERNAL_ERROR", message: "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF" } });
-    }
-  }
-  async function scheduled(event, env) {
-    const cfg = await resolveConfig(env);
-    const vapid = cfg.vapid || {};
-    if (!cfg.webpush || !vapid.email || !vapid.publicKey || !vapid.privateKey) {
-      console.error("[amsg single-user] scheduled(): VAPID/webpush not configured; skipping tick");
-      return;
-    }
-    try {
-      await runScheduledTick({
-        db: cfg.db,
-        masterKey: cfg.masterKey,
-        vapid,
-        webpush: cfg.webpush,
-        // Fire-time hooks (optional; see lib/agentic-fire.js). runScheduledTick
-        // spreads its ctx into processSingleMessage, so these ride along.
-        hooks: cfg.hooks || null,
-        maxToolIterations: cfg.maxToolIterations,
-        totalTimeoutMs: cfg.totalTimeoutMs,
-        // hook 的 ctx.writeState() 用它判断单条 value 的上限，和 PUT /client-state 同一个配置。
-        maxStateValueBytes: cfg.maxStateValueBytes,
-        // hook 的 ctx.scheduleTask() 单次 fire 建任务的条数上限（默认 2）。
-        maxScheduledTasksPerFire: cfg.maxScheduledTasksPerFire,
-        // 任务占位租期（默认 10 分钟，随 totalTimeoutMs 抬高）。
-        claimLeaseMs: cfg.claimLeaseMs
-      });
-    } catch (error) {
-      console.error("[amsg single-user] scheduled(): tick failed:", error && error.message);
-    }
-  }
-  return { fetch: fetch2, scheduled };
-}
-
-export {
-  validateAvatarUrl,
-  isValidISO8601,
-  isValidUrl,
-  isValidUUID,
-  isValidUUIDv4,
-  validateSplitPattern,
-  validateLlmMessagesArray,
-  validateScheduleMessagePayload,
-  parseJsonBody,
-  getHeader,
-  deriveUserEncryptionKey,
-  decryptPayload,
-  encryptForStorage,
-  decryptFromStorage,
-  createGetUserKeyHandler,
-  createScheduleMessageHandler,
-  runScheduledTick,
-  createUpdateMessageHandler,
-  createCancelMessageHandler,
-  createMessagesHandler,
-  createD1Adapter,
-  createSingleUserServer,
-  WEB_PUSH_MAX_BODY_BYTES,
-  WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES,
-  MAX_PUSH_PAYLOAD_BYTES,
-  measurePushPayload,
-  createWebCryptoWebPush,
-  createSingleUserCloudflareWorker
-};