@rei-standard/amsg-server 2.6.0-next.2 → 2.6.0-next.21

package/dist/chunk-GN5QTMCL.cjs

@@ -1,1870 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/server/lib/validation.js
-var _amsgshared = require('@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 (e) {
-    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 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 = _amsgshared.validateAvatarUrl.call(void 0, 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
-
-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(_amsgshared.toUint8.call(void 0, buf));
-}
-function bytesToBase64(buf) {
-  const bytes = _amsgshared.toUint8.call(void 0, 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 = _amsgshared.toUint8.call(void 0, 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 = _amsgshared.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,
-    _amsgshared.concatBytes.call(void 0, 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 (e2) {
-      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
-
-
-
-
-
-
-var DEFAULT_SPLIT_REGEX = /([。！？!?]+)/;
-var SLEEP_BETWEEN_MESSAGES_MS = 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));
-    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 = _amsgshared.readReasoningContent.call(void 0, llmResponse);
-    if (reasoning) {
-      messageContent = _amsgshared.stripReasoningTags.call(void 0, messageContent);
-    }
-    const messages = splitMessageIntoSentences(messageContent, _nullishCoalesce(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 = _amsgshared.buildReasoningPush.call(void 0, {
-        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_MS));
-    }
-    for (let i = 0; i < messages.length; i++) {
-      const contentPush = _amsgshared.buildContentPush.call(void 0, {
-        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_MS));
-      }
-    }
-    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 = _optionalChain([aiData, 'optionalAccess', _2 => _2.choices, 'optionalAccess', _3 => _3[0], 'optionalAccess', _4 => _4.message, 'optionalAccess', _5 => _5.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 (e3) {
-    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;
-    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: _nullishCoalesce(payload.maxTokens, () => ( null)),
-      temperature: _nullishCoalesce(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: _nullishCoalesce(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
-async function runScheduledTick(ctx) {
-  const db = ctx.db;
-  const masterKey = ctx.masterKey;
-  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 = 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 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 {
-    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
-    }
-  };
-}
-
-// 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 = _amsgshared.validateAvatarUrl.call(void 0, 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: _nullishCoalesce(updates.maxTokens, () => ( null)) },
-      ...Object.prototype.hasOwnProperty.call(updates, "temperature") && { temperature: _nullishCoalesce(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: _nullishCoalesce(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
-      };
-    }));
-    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,
-    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_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
-  }
-];
-
-// src/server/adapters/d1.js
-var UPDATABLE_COLUMNS = /* @__PURE__ */ new Set([
-  "user_id",
-  "uuid",
-  "encrypted_payload",
-  "message_type",
-  "next_send_at",
-  "status",
-  "retry_count",
-  "created_at",
-  "updated_at"
-]);
-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();
-    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: 10,
-      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();
-  }
-  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 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 <= ?
-       ORDER BY next_send_at ASC
-       LIMIT ?`
-    ).bind(this._now(), limit).all();
-    return res.results || [];
-  }
-  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;
-  }
-};
-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/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
-  };
-  return {
-    ctx,
-    handlers: {
-      init: createSingleUserInitHandler(ctx),
-      getUserKey: createGetUserKeyHandler(ctx),
-      scheduleMessage: createScheduleMessageHandler(ctx),
-      updateMessage: createUpdateMessageHandler(ctx),
-      cancelMessage: createCancelMessageHandler(ctx),
-      messages: createMessagesHandler(ctx),
-      vapidPublicKey: createVapidPublicKeyHandler(ctx)
-    }
-  };
-}
-
-// src/server/lib/webpush-webcrypto.js
-
-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;
-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 encryptedBody = await encryptPushPayload({
-    plaintext: utf8(payload),
-    uaPublicKey: _amsgshared.base64UrlToBytes.call(void 0, subscriptionKeys.p256dh),
-    authSecret: _amsgshared.base64UrlToBytes.call(void 0, subscriptionKeys.auth)
-  });
-  const jwt = await buildVapidJwt({
-    audience: originOf(subscription.endpoint),
-    subject: _amsgshared.normalizeVapidSubject.call(void 0, 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 err = new Error(
-      `Web Push delivery failed: ${res.status} ${res.statusText || ""}${text ? ` \u2014 ${text}` : ""}`
-    );
-    err.code = "PUSH_SEND_FAILED";
-    err.statusCode = res.status;
-    throw err;
-  }
-  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 = _amsgshared.concatBytes.call(void 0, 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 = _amsgshared.concatBytes.call(void 0, 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 _amsgshared.concatBytes.call(void 0, header, ciphertext);
-}
-async function hkdfSha256(salt, ikm, info, length) {
-  const baseKey = await globalThis.crypto.subtle.importKey(
-    "raw",
-    _amsgshared.toUint8.call(void 0, ikm),
-    { name: "HKDF" },
-    false,
-    ["deriveBits"]
-  );
-  const bits = await globalThis.crypto.subtle.deriveBits(
-    {
-      name: "HKDF",
-      hash: "SHA-256",
-      salt: _amsgshared.toUint8.call(void 0, salt),
-      info: _amsgshared.toUint8.call(void 0, 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 = _amsgshared.base64UrlToBytes.call(void 0, publicKey);
-  const privBytes = _amsgshared.base64UrlToBytes.call(void 0, 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 (e4) {
-    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(_nullishCoalesce(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 {
-        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 });
-    } catch (error) {
-      console.error("[amsg single-user] scheduled(): tick failed:", error && error.message);
-    }
-  }
-  return { fetch: fetch2, scheduled };
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.validateAvatarUrl = _amsgshared.validateAvatarUrl; exports.isValidISO8601 = isValidISO8601; exports.isValidUrl = isValidUrl; exports.isValidUUID = isValidUUID; exports.isValidUUIDv4 = isValidUUIDv4; exports.validateSplitPattern = validateSplitPattern; exports.validateLlmMessagesArray = validateLlmMessagesArray; exports.validateScheduleMessagePayload = validateScheduleMessagePayload; exports.parseJsonBody = parseJsonBody; exports.getHeader = getHeader; exports.deriveUserEncryptionKey = deriveUserEncryptionKey; exports.decryptPayload = decryptPayload; exports.encryptForStorage = encryptForStorage; exports.decryptFromStorage = decryptFromStorage; exports.createGetUserKeyHandler = createGetUserKeyHandler; exports.createScheduleMessageHandler = createScheduleMessageHandler; exports.runScheduledTick = runScheduledTick; exports.createUpdateMessageHandler = createUpdateMessageHandler; exports.createCancelMessageHandler = createCancelMessageHandler; exports.createMessagesHandler = createMessagesHandler; exports.createD1Adapter = createD1Adapter; exports.createSingleUserServer = createSingleUserServer; exports.createWebCryptoWebPush = createWebCryptoWebPush; exports.createSingleUserCloudflareWorker = createSingleUserCloudflareWorker;