@rei-standard/amsg-server 2.5.2 → 2.6.0-next.0

package/dist/index.mjs

@@ -1,3 +1,30 @@
+import {
+  createCancelMessageHandler,
+  createD1Adapter,
+  createGetUserKeyHandler,
+  createMessagesHandler,
+  createScheduleMessageHandler,
+  createSingleUserCloudflareWorker,
+  createSingleUserServer,
+  createUpdateMessageHandler,
+  createWebCryptoWebPush,
+  decryptFromStorage,
+  decryptPayload,
+  deriveUserEncryptionKey,
+  encryptForStorage,
+  getHeader,
+  isValidISO8601,
+  isValidUUID,
+  isValidUUIDv4,
+  isValidUrl,
+  parseJsonBody,
+  runScheduledTick,
+  validateAvatarUrl,
+  validateLlmMessagesArray,
+  validateScheduleMessagePayload,
+  validateSplitPattern
+} from "./chunk-PJAW56VN.mjs";
+
 // src/server/adapters/factory.js
 async function createAdapter(config) {
   if (!config || !config.driver) {
@@ -26,248 +53,6 @@ async function createAdapter(config) {
   }
 }
 
-// src/server/lib/validation.js
-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 AVATAR_URL_MAX_LENGTH = 2048;
-function validateAvatarUrl(value) {
-  if (value === void 0 || value === null) return null;
-  if (typeof value !== "string") {
-    return "avatarUrl \u5FC5\u987B\u662F\u5B57\u7B26\u4E32";
-  }
-  if (/^data:/i.test(value)) {
-    return "\u5934\u50CF\u4E0D\u652F\u6301\u4F20\u5165 data: URI\uFF0C\u8BF7\u6539\u4E3A\u516C\u7F51\u53EF\u8BBF\u95EE\u7684 https:// \u56FE\u7247 URL";
-  }
-  if (value.length > AVATAR_URL_MAX_LENGTH) {
-    return `\u5934\u50CF URL \u957F\u5EA6 ${value.length} \u5B57\u7B26\u8D85\u8FC7 ${AVATAR_URL_MAX_LENGTH} \u4E0A\u9650\uFF0C\u8BF7\u6539\u4E3A\u66F4\u77ED\u7684\u56FE\u7247 URL`;
-  }
-  if (!isValidUrl(value)) {
-    return "avatarUrl \u4E0D\u662F\u5408\u6CD5 URL";
-  }
-  return null;
-}
-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 err = validateLlmMessagesArray(payload.messages);
-      if (err) {
-        return {
-          error: { code: "INVALID_PARAMETERS", message: err, 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/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/init-tenant.js
 function createInitTenantHandler(ctx) {
   async function POST(headers, body) {
@@ -384,560 +169,6 @@ function createInitTenantHandler(ctx) {
   return { POST };
 }
 
-// src/server/lib/encryption.js
-import { createCipheriv, createDecipheriv, createHash, randomBytes } from "crypto";
-function deriveUserEncryptionKey(userId, masterKey) {
-  return createHash("sha256").update(masterKey + userId).digest("hex").slice(0, 64);
-}
-function decryptPayload(encryptedPayload, encryptionKey) {
-  const { iv, authTag, encryptedData } = encryptedPayload;
-  const decipher = createDecipheriv(
-    "aes-256-gcm",
-    Buffer.from(encryptionKey, "hex"),
-    Buffer.from(iv, "base64")
-  );
-  decipher.setAuthTag(Buffer.from(authTag, "base64"));
-  const decrypted = Buffer.concat([
-    decipher.update(Buffer.from(encryptedData, "base64")),
-    decipher.final()
-  ]);
-  return JSON.parse(decrypted.toString("utf8"));
-}
-function encryptPayload(payload, encryptionKey) {
-  const plaintext = typeof payload === "string" ? payload : JSON.stringify(payload);
-  const iv = randomBytes(12);
-  const cipher = createCipheriv("aes-256-gcm", Buffer.from(encryptionKey, "hex"), iv);
-  const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
-  const authTag = cipher.getAuthTag();
-  return {
-    iv: iv.toString("base64"),
-    authTag: authTag.toString("base64"),
-    encryptedData: encrypted.toString("base64")
-  };
-}
-function encryptForStorage(text, encryptionKey) {
-  const iv = randomBytes(16);
-  const cipher = createCipheriv("aes-256-gcm", Buffer.from(encryptionKey, "hex"), iv);
-  const encrypted = cipher.update(text, "utf8", "hex") + cipher.final("hex");
-  const authTag = cipher.getAuthTag();
-  return `${iv.toString("hex")}:${authTag.toString("hex")}:${encrypted}`;
-}
-function decryptFromStorage(encryptedText, encryptionKey) {
-  const [ivHex, authTagHex, encryptedDataHex] = encryptedText.split(":");
-  const decipher = createDecipheriv(
-    "aes-256-gcm",
-    Buffer.from(encryptionKey, "hex"),
-    Buffer.from(ivHex, "hex")
-  );
-  decipher.setAuthTag(Buffer.from(authTagHex, "hex"));
-  return decipher.update(encryptedDataHex, "hex", "utf8") + decipher.final("utf8");
-}
-
-// 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: deriveUserEncryptionKey(userId, masterKey),
-          version: 1
-        }
-      }
-    };
-  }
-  return { GET };
-}
-
-// src/server/handlers/schedule-message.js
-import { randomUUID as randomUUID2 } from "crypto";
-
-// 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 { randomUUID } from "crypto";
-import {
-  buildContentPush,
-  buildReasoningPush
-} from "@rei-standard/amsg-shared";
-var DEFAULT_SPLIT_REGEX = /([。！？!?]+)/;
-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];
-}
-function readReasoningContent(llmResponse) {
-  if (!llmResponse || typeof llmResponse !== "object") return null;
-  const choices = (
-    /** @type {{ choices?: unknown }} */
-    llmResponse.choices
-  );
-  if (!Array.isArray(choices) || choices.length === 0) return null;
-  const message = (
-    /** @type {{ message?: { reasoning_content?: unknown, content?: unknown } }} */
-    choices[0]?.message
-  );
-  const raw = message?.reasoning_content;
-  if (typeof raw === "string") {
-    const trimmed = raw.trim();
-    if (trimmed.length > 0) return trimmed;
-  }
-  const content = message?.content;
-  if (typeof content === "string") {
-    const match = content.match(REASONING_TAG_RE);
-    if (match) {
-      const trimmed = match[2].trim();
-      if (trimmed.length > 0) return trimmed;
-    }
-  }
-  return null;
-}
-var REASONING_TAG_RE = /<(think|thinking|thought)>([\s\S]*?)<\/\1>/i;
-var REASONING_TAG_RE_G = /<(think|thinking|thought)>[\s\S]*?<\/\1>/gi;
-function stripReasoningTags(content) {
-  if (typeof content !== "string" || !content.includes("<")) return content;
-  return content.replace(REASONING_TAG_RE_G, "").trim();
-}
-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 = deriveUserEncryptionKey(task.user_id, masterKey);
-    const decryptedPayload = JSON.parse(decryptFromStorage(task.encrypted_payload, userKey));
-    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 _callAI(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 _callAI(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, 1500));
-    }
-    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, 1500));
-      }
-    }
-    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 };
-  }
-}
-async function _callAI(payload) {
-  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(3e5)
-  });
-  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 content = aiData?.choices?.[0]?.message?.content;
-  if (typeof content !== "string" || !content.trim()) {
-    throw new Error("AI API error: response missing choices[0].message.content");
-  }
-  return { response: aiData, content: content.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 (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/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;
-    let payload;
-    try {
-      const userKey2 = deriveUserEncryptionKey(userId, masterKey);
-      payload = decryptPayload(encryptedBody, userKey2);
-    } 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 || randomUUID2();
-    const userKey = deriveUserEncryptionKey(userId, masterKey);
-    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 = 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/handlers/send-notifications.js
 function createSendNotificationsHandler(ctx) {
   async function POST(urlOrHeaders, maybeHeaders) {
@@ -972,371 +203,14 @@ function createSendNotificationsHandler(ctx) {
         }
       };
     }
-    const startTime = Date.now();
-    const tasks = await db.getPendingTasks(50);
-    const MAX_CONCURRENT = 8;
-    const results = {
-      totalTasks: tasks.length,
-      successCount: 0,
-      failedCount: 0,
-      deletedOnceOffTasks: 0,
-      updatedRecurringTasks: 0,
-      failedTasks: []
-    };
-    async function handleDeliveryFailure(task, reason) {
-      results.failedCount++;
-      try {
-        if (task.retry_count >= 3) {
-          await db.updateTaskById(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 db.updateTaskById(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 db.updateTaskById(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 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 = deriveUserEncryptionKey(task.user_id, masterKey);
-        const decryptedPayload = JSON.parse(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 db.updateTaskById(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 {
-      status: 200,
-      body: {
-        success: true,
-        data: {
-          totalTasks: results.totalTasks,
-          successCount: results.successCount,
-          failedCount: results.failedCount,
-          processedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          executionTime,
-          details: {
-            deletedOnceOffTasks: results.deletedOnceOffTasks,
-            updatedRecurringTasks: results.updatedRecurringTasks,
-            failedTasks: results.failedTasks
-          }
-        }
-      }
-    };
+    const data = await runScheduledTick({ ...ctx, db, masterKey });
+    return { status: 200, body: { success: true, data } };
   }
   return { POST };
 }
 
-// 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 = deriveUserEncryptionKey(userId, masterKey);
-    let updates;
-    try {
-      updates = 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(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 = 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 = deriveUserEncryptionKey(userId, masterKey);
-    const decryptedTasks = tasks.map((task) => {
-      const decrypted = JSON.parse(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
-      };
-    });
-    const responsePayload = {
-      tasks: decryptedTasks,
-      pagination: { total, limit, offset, hasMore: offset + limit < total }
-    };
-    const encryptedResponse = encryptPayload(responsePayload, userKey);
-    return {
-      status: 200,
-      body: {
-        success: true,
-        encrypted: true,
-        version: 1,
-        data: encryptedResponse
-      }
-    };
-  }
-  return { GET };
-}
-
 // src/server/tenant/blob-store.js
-import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from "crypto";
 var inMemoryNamespaces = /* @__PURE__ */ new Map();
 function base64UrlEncode(input) {
   return Buffer.from(input).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
@@ -1351,11 +225,11 @@ function getKekBuffer(kek) {
   if (!value) {
     throw new Error("[rei-standard-amsg-server] tenant.kek is required");
   }
-  return createHash2("sha256").update(value).digest();
+  return createHash("sha256").update(value).digest();
 }
 function encryptConfig(config, kekBuffer) {
-  const iv = randomBytes2(12);
-  const cipher = createCipheriv2("aes-256-gcm", kekBuffer, iv);
+  const iv = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", kekBuffer, iv);
   const plaintext = Buffer.from(JSON.stringify(config), "utf8");
   const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
   const authTag = cipher.getAuthTag();
@@ -1369,7 +243,7 @@ function decryptConfig(encrypted, kekBuffer) {
   const iv = base64UrlDecode(parts[1]);
   const authTag = base64UrlDecode(parts[2]);
   const ciphertext = base64UrlDecode(parts[3]);
-  const decipher = createDecipheriv2("aes-256-gcm", kekBuffer, iv);
+  const decipher = createDecipheriv("aes-256-gcm", kekBuffer, iv);
   decipher.setAuthTag(authTag);
   const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8");
   return JSON.parse(plaintext);
@@ -1431,7 +305,7 @@ function createTenantBlobStore(options) {
 }
 
 // src/server/tenant/context.js
-import { createHash as createHash3, randomBytes as randomBytes3, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash2, randomBytes as randomBytes2, randomUUID } from "crypto";
 
 // src/server/tenant/token.js
 import { createHmac, timingSafeEqual } from "crypto";
@@ -1525,7 +399,7 @@ function extractBearerToken(headers = {}) {
 
 // src/server/tenant/context.js
 function fingerprint(masterKey) {
-  return createHash3("sha256").update(masterKey).digest("hex").slice(0, 16);
+  return createHash2("sha256").update(masterKey).digest("hex").slice(0, 16);
 }
 function sanitizeDbConfig(driver, connectionString) {
   const normalizedDriver = String(driver || "").trim();
@@ -1571,14 +445,14 @@ function createTenantContextManager(options) {
   }
   async function initializeTenant({ driver, connectionString, tenantId: providedTenantId }) {
     const dbConfig = sanitizeDbConfig(driver, connectionString);
-    const tenantId = String(providedTenantId || randomUUID3()).trim();
+    const tenantId = String(providedTenantId || randomUUID()).trim();
     const existing = await tenantStore.getTenantConfig(tenantId);
     if (existing) {
       throw new Error("TENANT_ALREADY_INITIALIZED");
     }
     const adapter = await getOrCreateAdapter(dbConfig);
     await adapter.initSchema();
-    const masterKey = randomBytes3(32).toString("hex");
+    const masterKey = randomBytes2(32).toString("hex");
     const now = (/* @__PURE__ */ new Date()).toISOString();
     await tenantStore.setTenantConfig({
       tenantId,
@@ -1654,11 +528,7 @@ function createTenantContextManager(options) {
 }
 
 // src/server/index.js
-function normalizeVapidSubject(email) {
-  const trimmedEmail = String(email || "").trim();
-  if (!trimmedEmail) return "";
-  return /^mailto:/i.test(trimmedEmail) ? trimmedEmail : `mailto:${trimmedEmail}`;
-}
+import { normalizeVapidSubject } from "@rei-standard/amsg-shared";
 async function createReiServer(config) {
   if (!config) throw new Error("[rei-standard-amsg-server] config is required");
   if (!config.tenant) throw new Error("[rei-standard-amsg-server] tenant config is required");
@@ -1716,8 +586,12 @@ async function createReiServer(config) {
 }
 export {
   createAdapter,
+  createD1Adapter,
   createReiServer,
+  createSingleUserCloudflareWorker,
+  createSingleUserServer,
   createTenantToken,
+  createWebCryptoWebPush,
   decryptFromStorage,
   decryptPayload,
   deriveUserEncryptionKey,
@@ -1726,6 +600,7 @@ export {
   isValidUUID,
   isValidUUIDv4,
   isValidUrl,
+  runScheduledTick,
   validateAvatarUrl,
   validateLlmMessagesArray,
   validateScheduleMessagePayload,