@rei-standard/amsg-server 1.2.1 → 2.0.1

package/dist/index.mjs

@@ -1,7 +1,3 @@
-import {
-  REQUIRED_COLUMNS
-} from "./chunk-H5EQVHAY.mjs";
-
 // src/server/adapters/factory.js
 async function createAdapter(config) {
   if (!config || !config.driver) {
@@ -16,11 +12,11 @@ async function createAdapter(config) {
   }
   switch (config.driver) {
     case "neon": {
-      const { NeonAdapter } = await import("./neon-YS3VCCSU.mjs");
+      const { NeonAdapter } = await import("./neon-CU5N3CSW.mjs");
       return new NeonAdapter(config.connectionString);
     }
     case "pg": {
-      const { PgAdapter } = await import("./pg-2CLYF2XS.mjs");
+      const { PgAdapter } = await import("./pg-QO6NKTGL.mjs");
       return new PgAdapter(config.connectionString);
     }
     default:
@@ -30,123 +26,6 @@ async function createAdapter(config) {
   }
 }
 
-// src/server/handlers/init-database.js
-function createInitDatabaseHandler(ctx) {
-  async function GET() {
-    const result = await ctx.db.initSchema();
-    const columnNames = result.columns.map((c) => c.name);
-    const missingColumns = REQUIRED_COLUMNS.filter((col) => !columnNames.includes(col));
-    if (missingColumns.length > 0) {
-      console.warn("[init-database] \u26A0\uFE0F  Missing columns:", missingColumns);
-    }
-    return {
-      status: 200,
-      body: {
-        success: true,
-        message: "\u6570\u636E\u5E93\u521D\u59CB\u5316\u6210\u529F\uFF01\u5EFA\u8BAE\u7ACB\u5373\u5220\u9664\u6B64 API \u6587\u4EF6\u3002",
-        data: {
-          tables: ["scheduled_messages", "system_config"],
-          columnsCreated: result.columnsCreated,
-          indexesCreated: result.indexesCreated,
-          indexesFailed: result.indexesFailed,
-          details: { columns: result.columns, indexes: result.indexes },
-          nextSteps: [
-            "1. \u8C03\u7528 /api/v1/init-master-key \u4E00\u6B21\u6027\u751F\u6210\u4E3B\u5BC6\u94A5\u5E76\u79BB\u7EBF\u4FDD\u5B58",
-            "2. \u5BA2\u6237\u7AEF\u4F7F\u7528 UUID v4 \u4F5C\u4E3A X-User-Id",
-            "3. \u5BA2\u6237\u7AEF\u8C03\u7528 /api/v1/get-user-key \u83B7\u53D6 userKey \u5E76\u7F13\u5B58"
-          ]
-        }
-      }
-    };
-  }
-  return { GET };
-}
-
-// src/server/handlers/init-master-key.js
-import { createHash, randomBytes } from "crypto";
-function makeFingerprint(masterKey) {
-  return createHash("sha256").update(masterKey).digest("hex").slice(0, 16);
-}
-function createInitMasterKeyHandler(ctx) {
-  async function POST() {
-    const masterKey = randomBytes(32).toString("hex");
-    const inserted = await ctx.db.setMasterKeyOnce(masterKey);
-    if (!inserted) {
-      return {
-        status: 409,
-        body: {
-          success: false,
-          error: {
-            code: "MASTER_KEY_ALREADY_INITIALIZED",
-            message: "\u4E3B\u5BC6\u94A5\u5DF2\u521D\u59CB\u5316\uFF0C\u65E0\u6CD5\u518D\u6B21\u83B7\u53D6"
-          }
-        }
-      };
-    }
-    return {
-      status: 201,
-      body: {
-        success: true,
-        data: {
-          masterKey,
-          fingerprint: makeFingerprint(masterKey),
-          version: 1
-        }
-      }
-    };
-  }
-  return { POST };
-}
-
-// src/server/lib/encryption.js
-import { createCipheriv, createDecipheriv, createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
-function deriveUserEncryptionKey(userId, masterKey) {
-  return createHash2("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 = randomBytes2(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 = randomBytes2(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/lib/validation.js
 function isValidISO8601(dateString) {
   const date = new Date(dateString);
@@ -187,6 +66,9 @@ function validateScheduleMessagePayload(payload) {
   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)"] } };
@@ -224,55 +106,6 @@ function validateScheduleMessagePayload(payload) {
   return { valid: true };
 }
 
-// src/server/handlers/get-user-key.js
-function createGetUserKeyHandler(ctx) {
-  async function GET(headers) {
-    const userId = 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 masterKey = await ctx.db.getMasterKey();
-    if (!masterKey) {
-      return {
-        status: 503,
-        body: { success: false, error: { code: "MASTER_KEY_NOT_INITIALIZED", message: "\u4E3B\u5BC6\u94A5\u5C1A\u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u8C03\u7528 /api/v1/init-master-key" } }
-      };
-    }
-    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/request.js
 var REQUEST_ERRORS = {
   INVALID_JSON: { code: "INVALID_JSON", message: "\u8BF7\u6C42\u4F53\u4E0D\u662F\u6709\u6548\u7684 JSON" },
@@ -295,6 +128,12 @@ function parseBodyAsObject(body, options = {}) {
   }
   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);
 }
@@ -315,14 +154,240 @@ function parseEncryptedBody(body) {
   }
   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) {
+    const initSecret = getHeader(headers, "x-init-secret");
+    if (ctx.tenant.initSecret && initSecret !== ctx.tenant.initSecret) {
+      return {
+        status: 401,
+        body: {
+          success: false,
+          error: {
+            code: "INVALID_INIT_AUTH",
+            message: "\u521D\u59CB\u5316\u9274\u6743\u5931\u8D25"
+          }
+        }
+      };
+    }
+    const parsed = parseJsonBody(body);
+    if (!parsed.ok) {
+      return {
+        status: 400,
+        body: {
+          success: false,
+          error: parsed.error
+        }
+      };
+    }
+    const payload = parsed.data;
+    const tenantId = payload.tenantId || void 0;
+    const driver = payload.driver;
+    const databaseUrl = payload.databaseUrl || payload.connectionString;
+    if (tenantId && !isValidUUIDv4(tenantId)) {
+      return {
+        status: 400,
+        body: {
+          success: false,
+          error: {
+            code: "INVALID_TENANT_ID",
+            message: "tenantId \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F"
+          }
+        }
+      };
+    }
+    if (!databaseUrl || !driver) {
+      return {
+        status: 400,
+        body: {
+          success: false,
+          error: {
+            code: "INVALID_PARAMETERS",
+            message: "\u7F3A\u5C11 driver \u6216 databaseUrl \u53C2\u6570"
+          }
+        }
+      };
+    }
+    try {
+      const result = await ctx.tenantManager.initializeTenant({
+        tenantId,
+        driver,
+        connectionString: databaseUrl
+      });
+      return {
+        status: 201,
+        body: {
+          success: true,
+          data: {
+            tenantId: result.tenantId,
+            tenantToken: result.tenantToken,
+            cronToken: result.cronToken,
+            cronWebhookUrl: result.cronWebhookUrl,
+            masterKeyFingerprint: result.masterKeyFingerprint
+          }
+        }
+      };
+    } catch (error) {
+      if (error.message === "INVALID_DRIVER") {
+        return {
+          status: 400,
+          body: {
+            success: false,
+            error: {
+              code: "INVALID_DRIVER",
+              message: "driver \u5FC5\u987B\u662F neon \u6216 pg"
+            }
+          }
+        };
+      }
+      if (error.message === "INVALID_DATABASE_URL") {
+        return {
+          status: 400,
+          body: {
+            success: false,
+            error: {
+              code: "INVALID_DATABASE_URL",
+              message: "databaseUrl \u4E0D\u80FD\u4E3A\u7A7A"
+            }
+          }
+        };
+      }
+      if (error.message === "TENANT_ALREADY_INITIALIZED") {
+        return {
+          status: 409,
+          body: {
+            success: false,
+            error: {
+              code: "TENANT_ALREADY_INITIALIZED",
+              message: "tenantId \u5DF2\u5B58\u5728\uFF0C\u4E0D\u80FD\u91CD\u590D\u521D\u59CB\u5316"
+            }
+          }
+        };
+      }
+      throw error;
+    }
+  }
+  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";
 async function processSingleMessage(task, ctx, providedMasterKey) {
   try {
-    const masterKey = providedMasterKey || await ctx.db.getMasterKey();
+    const masterKey = providedMasterKey || ctx.masterKey;
     if (!masterKey) {
-      return { success: false, messagesSent: 0, error: "MASTER_KEY_NOT_INITIALIZED" };
+      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));
@@ -382,11 +447,11 @@ async function processSingleMessage(task, ctx, providedMasterKey) {
 }
 async function processMessagesByUuid(uuid, ctx, maxRetries = 2, userId, providedMasterKey) {
   let retryCount = 0;
-  const masterKey = providedMasterKey || await ctx.db.getMasterKey();
+  const masterKey = providedMasterKey || ctx.masterKey;
   if (!masterKey) {
     return {
       success: false,
-      error: { code: "MASTER_KEY_NOT_INITIALIZED", message: "\u4E3B\u5BC6\u94A5\u5C1A\u672A\u521D\u59CB\u5316" }
+      error: { code: "TENANT_MASTER_KEY_MISSING", message: "\u79DF\u6237\u4E3B\u5BC6\u94A5\u4E0D\u5B58\u5728\u6216\u914D\u7F6E\u5F02\u5E38" }
     };
   }
   while (retryCount <= maxRetries) {
@@ -443,33 +508,81 @@ async function processMessagesByUuid(uuid, ctx, maxRetries = 2, userId, provided
   }
 }
 async function _callAI(payload) {
-  const aiResponse = await fetch(payload.apiUrl, {
+  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({
-      model: payload.primaryModel,
-      messages: [{ role: "user", content: payload.completePrompt }],
-      max_tokens: 500,
-      temperature: 0.8
-    }),
+    body: JSON.stringify(requestBody),
     signal: AbortSignal.timeout(3e5)
   });
   if (!aiResponse.ok) {
-    throw new Error(`AI API error: ${aiResponse.status} ${aiResponse.statusText}`);
+    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();
-  return aiData.choices[0].message.content.trim();
+  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 content.trim();
+}
+function buildAiRequestBody(payload) {
+  const requestBody = {
+    model: payload.primaryModel,
+    messages: [{ role: "user", content: payload.completePrompt }],
+    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 full chat endpoint URL (for example: 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 that points to a full chat endpoint.`
+    );
+  }
+  parsedUrl.pathname = parsedUrl.pathname.replace(/\/+$/, "") || "/";
+  return parsedUrl.toString();
 }
 
 // src/server/handlers/schedule-message.js
 function createScheduleMessageHandler(ctx) {
   async function POST(headers, body) {
-    const isEncrypted = headers["x-payload-encrypted"] === "true";
-    const encryptionVersion = headers["x-encryption-version"];
-    const userId = headers["x-user-id"];
+    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" } } };
     }
@@ -482,10 +595,6 @@ function createScheduleMessageHandler(ctx) {
     if (encryptionVersion !== "1") {
       return { status: 400, body: { success: false, error: { code: "UNSUPPORTED_ENCRYPTION_VERSION", message: "\u52A0\u5BC6\u7248\u672C\u4E0D\u652F\u6301" } } };
     }
-    const masterKey = await ctx.db.getMasterKey();
-    if (!masterKey) {
-      return { status: 503, body: { success: false, error: { code: "MASTER_KEY_NOT_INITIALIZED", message: "\u4E3B\u5BC6\u94A5\u5C1A\u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u8C03\u7528 /api/v1/init-master-key" } } };
-    }
     const parsedBody = parseEncryptedBody(body);
     if (!parsedBody.ok) {
       return { status: 400, body: { success: false, error: parsedBody.error } };
@@ -526,6 +635,7 @@ function createScheduleMessageHandler(ctx) {
       apiKey: payload.apiKey || null,
       primaryModel: payload.primaryModel || null,
       completePrompt: payload.completePrompt || null,
+      maxTokens: payload.maxTokens ?? null,
       pushSubscription: payload.pushSubscription,
       metadata: payload.metadata || {}
     };
@@ -553,7 +663,7 @@ function createScheduleMessageHandler(ctx) {
     }
     let dbResult;
     try {
-      dbResult = await ctx.db.createTask({
+      dbResult = await db.createTask({
         user_id: userId,
         uuid: taskUuid,
         encrypted_payload: encryptedPayload,
@@ -580,7 +690,11 @@ function createScheduleMessageHandler(ctx) {
     }
     if (payload.messageType === "instant") {
       try {
-        const sendResult = await processMessagesByUuid(taskUuid, ctx, 2, userId, masterKey);
+        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 } } };
         }
@@ -622,7 +736,19 @@ function createScheduleMessageHandler(ctx) {
 
 // src/server/handlers/send-notifications.js
 function createSendNotificationsHandler(ctx) {
-  async function POST(headers) {
+  async function POST(urlOrHeaders, maybeHeaders) {
+    const url = typeof urlOrHeaders === "string" ? urlOrHeaders : "";
+    const headers = maybeHeaders || (typeof urlOrHeaders === "object" ? urlOrHeaders : {});
+    const tenantResult = await ctx.tenantManager.resolveTenant(headers, {
+      allowCronToken: true,
+      url
+    });
+    if (!tenantResult.ok) {
+      return tenantResult.error;
+    }
+    const tenantCtx = tenantResult.context;
+    const db = tenantCtx.db;
+    const masterKey = tenantCtx.masterKey;
     if (!ctx.vapid.email || !ctx.vapid.publicKey || !ctx.vapid.privateKey) {
       return {
         status: 500,
@@ -642,26 +768,8 @@ function createSendNotificationsHandler(ctx) {
         }
       };
     }
-    const authHeader = (headers["authorization"] || "").trim();
-    const expectedAuth = `Bearer ${ctx.cronSecret}`;
-    if (authHeader !== expectedAuth) {
-      return { status: 401, body: { success: false, error: { code: "UNAUTHORIZED", message: "Cron Secret \u9A8C\u8BC1\u5931\u8D25" } } };
-    }
-    const masterKey = await ctx.db.getMasterKey();
-    if (!masterKey) {
-      return {
-        status: 503,
-        body: {
-          success: false,
-          error: {
-            code: "MASTER_KEY_NOT_INITIALIZED",
-            message: "\u4E3B\u5BC6\u94A5\u5C1A\u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u8C03\u7528 /api/v1/init-master-key"
-          }
-        }
-      };
-    }
     const startTime = Date.now();
-    const tasks = await ctx.db.getPendingTasks(50);
+    const tasks = await db.getPendingTasks(50);
     const MAX_CONCURRENT = 8;
     const results = {
       totalTasks: tasks.length,
@@ -675,11 +783,11 @@ function createSendNotificationsHandler(ctx) {
       results.failedCount++;
       try {
         if (task.retry_count >= 3) {
-          await ctx.db.updateTaskById(task.id, { status: "failed" });
+          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 ctx.db.updateTaskById(task.id, { next_send_at: nextRetryTime.toISOString(), retry_count: task.retry_count + 1 });
+          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) {
@@ -695,7 +803,7 @@ function createSendNotificationsHandler(ctx) {
       results.failedCount++;
       let markedSent = false;
       try {
-        await ctx.db.updateTaskById(task.id, { status: "sent", retry_count: 0 });
+        await db.updateTaskById(task.id, { status: "sent", retry_count: 0 });
         markedSent = true;
       } catch (_markSentError) {
         markedSent = false;
@@ -710,7 +818,11 @@ function createSendNotificationsHandler(ctx) {
     async function processTask(task) {
       let sendResult;
       try {
-        sendResult = await processSingleMessage(task, ctx);
+        sendResult = await processSingleMessage(task, {
+          ...ctx,
+          db,
+          masterKey
+        }, masterKey);
       } catch (error) {
         await handleDeliveryFailure(task, error.message || "\u6D88\u606F\u53D1\u9001\u5931\u8D25");
         return;
@@ -723,7 +835,7 @@ function createSendNotificationsHandler(ctx) {
         const userKey = deriveUserEncryptionKey(task.user_id, masterKey);
         const decryptedPayload = JSON.parse(decryptFromStorage(task.encrypted_payload, userKey));
         if (decryptedPayload.recurrenceType === "none") {
-          await ctx.db.deleteTaskById(task.id);
+          await db.deleteTaskById(task.id);
           results.deletedOnceOffTasks++;
         } else {
           let nextSendAt;
@@ -733,7 +845,7 @@ function createSendNotificationsHandler(ctx) {
           } else if (decryptedPayload.recurrenceType === "weekly") {
             nextSendAt = new Date(currentSendAt.getTime() + 7 * 24 * 60 * 60 * 1e3);
           }
-          await ctx.db.updateTaskById(task.id, { next_send_at: nextSendAt.toISOString(), retry_count: 0 });
+          await db.updateTaskById(task.id, { next_send_at: nextSendAt.toISOString(), retry_count: 0 });
           results.updatedRecurringTasks++;
         }
         results.successCount++;
@@ -757,7 +869,7 @@ function createSendNotificationsHandler(ctx) {
         await Promise.race(processing);
       }
     }
-    await ctx.db.cleanupOldTasks(7);
+    await db.cleanupOldTasks(7);
     const executionTime = Date.now() - startTime;
     return {
       status: 200,
@@ -784,30 +896,33 @@ function createSendNotificationsHandler(ctx) {
 // 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 = headers["x-user-id"];
+    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 = headers["x-payload-encrypted"] === "true";
-    const encryptionVersion = headers["x-encryption-version"];
+    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 masterKey = await ctx.db.getMasterKey();
-    if (!masterKey) {
-      return { status: 503, body: { success: false, error: { code: "MASTER_KEY_NOT_INITIALIZED", message: "\u4E3B\u5BC6\u94A5\u5C1A\u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u8C03\u7528 /api/v1/init-master-key" } } };
-    }
     const parsedBody = parseEncryptedBody(body);
     if (!parsedBody.ok) {
       return { status: 400, body: { success: false, error: parsedBody.error } };
@@ -829,9 +944,12 @@ function createUpdateMessageHandler(ctx) {
     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"] } } } };
     }
-    const existingTask = await ctx.db.getTaskByUuid(taskUuid, userId);
+    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"] } } } };
+    }
+    const existingTask = await db.getTaskByUuid(taskUuid, userId);
     if (!existingTask) {
-      const taskStatus = await ctx.db.getTaskStatus(taskUuid, userId);
+      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" } } };
       }
@@ -844,11 +962,12 @@ function createUpdateMessageHandler(ctx) {
       ...updates.userMessage && { userMessage: updates.userMessage },
       ...updates.recurrenceType && { recurrenceType: updates.recurrenceType },
       ...updates.avatarUrl && { avatarUrl: updates.avatarUrl },
-      ...updates.metadata && { metadata: updates.metadata }
+      ...updates.metadata && { metadata: updates.metadata },
+      ...Object.prototype.hasOwnProperty.call(updates, "maxTokens") && { maxTokens: updates.maxTokens ?? null }
     };
     const encryptedPayload = encryptForStorage(JSON.stringify(updatedData), userKey);
     const extraFields = updates.nextSendAt ? { next_send_at: updates.nextSendAt } : void 0;
-    const result = await ctx.db.updateTaskByUuid(taskUuid, userId, encryptedPayload, extraFields);
+    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" } } };
     }
@@ -870,19 +989,24 @@ function createUpdateMessageHandler(ctx) {
 // 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 = headers["x-user-id"];
+    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 ctx.db.deleteTaskByUuid(taskUuid, userId);
+    const deleted = await db.deleteTaskByUuid(taskUuid, userId);
     if (!deleted) {
       return {
         status: 404,
@@ -903,7 +1027,14 @@ function createCancelMessageHandler(ctx) {
 // src/server/handlers/messages.js
 function createMessagesHandler(ctx) {
   async function GET(url, headers) {
-    const userId = headers["x-user-id"];
+    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,
@@ -926,14 +1057,7 @@ function createMessagesHandler(ctx) {
     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 ctx.db.listTasks(userId, { status, limit, offset });
-    const masterKey = await ctx.db.getMasterKey();
-    if (!masterKey) {
-      return {
-        status: 503,
-        body: { success: false, error: { code: "MASTER_KEY_NOT_INITIALIZED", message: "\u4E3B\u5BC6\u94A5\u5C1A\u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u8C03\u7528 /api/v1/init-master-key" } }
-      };
-    }
+    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));
@@ -969,6 +1093,318 @@ function createMessagesHandler(ctx) {
   return { GET };
 }
 
+// src/server/tenant/blob-store.js
+import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
+var inMemoryNamespaces = /* @__PURE__ */ new Map();
+function base64UrlEncode(input) {
+  return Buffer.from(input).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function base64UrlDecode(input) {
+  const normalized = input.replace(/-/g, "+").replace(/_/g, "/");
+  const padLength = (4 - normalized.length % 4) % 4;
+  return Buffer.from(normalized + "=".repeat(padLength), "base64");
+}
+function getKekBuffer(kek) {
+  const value = String(kek || "").trim();
+  if (!value) {
+    throw new Error("[rei-standard-amsg-server] tenant.kek is required");
+  }
+  return createHash2("sha256").update(value).digest();
+}
+function encryptConfig(config, kekBuffer) {
+  const iv = randomBytes2(12);
+  const cipher = createCipheriv2("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();
+  return `v1.${base64UrlEncode(iv)}.${base64UrlEncode(authTag)}.${base64UrlEncode(ciphertext)}`;
+}
+function decryptConfig(encrypted, kekBuffer) {
+  const parts = String(encrypted || "").split(".");
+  if (parts.length !== 4 || parts[0] !== "v1") {
+    throw new Error("INVALID_TENANT_CONFIG");
+  }
+  const iv = base64UrlDecode(parts[1]);
+  const authTag = base64UrlDecode(parts[2]);
+  const ciphertext = base64UrlDecode(parts[3]);
+  const decipher = createDecipheriv2("aes-256-gcm", kekBuffer, iv);
+  decipher.setAuthTag(authTag);
+  const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8");
+  return JSON.parse(plaintext);
+}
+function createInMemoryStore(namespace) {
+  if (!inMemoryNamespaces.has(namespace)) {
+    inMemoryNamespaces.set(namespace, /* @__PURE__ */ new Map());
+  }
+  const namespaceMap = inMemoryNamespaces.get(namespace);
+  return {
+    async get(key) {
+      return namespaceMap.has(key) ? namespaceMap.get(key) : null;
+    },
+    async set(key, value) {
+      namespaceMap.set(key, value);
+    },
+    async delete(key) {
+      namespaceMap.delete(key);
+    }
+  };
+}
+async function resolveBlobStore(namespace) {
+  if (globalThis.__REI_BLOB_STORE__ && typeof globalThis.__REI_BLOB_STORE__.get === "function") {
+    return globalThis.__REI_BLOB_STORE__;
+  }
+  try {
+    const blobModule = await import("@netlify/blobs");
+    const getStore = blobModule.getStore || blobModule.default?.getStore;
+    if (typeof getStore === "function") {
+      return getStore({ name: namespace });
+    }
+  } catch (_error) {
+  }
+  return createInMemoryStore(namespace);
+}
+function createTenantBlobStore(options) {
+  const namespace = String(options.namespace || "rei-tenants").trim() || "rei-tenants";
+  const kekBuffer = getKekBuffer(options.kek);
+  function getTenantKey(tenantId) {
+    return `tenant/${tenantId}`;
+  }
+  return {
+    async getTenantConfig(tenantId) {
+      const store = await resolveBlobStore(namespace);
+      const encrypted = await store.get(getTenantKey(tenantId), { type: "text" });
+      if (!encrypted) return null;
+      return decryptConfig(encrypted, kekBuffer);
+    },
+    async setTenantConfig(config) {
+      const store = await resolveBlobStore(namespace);
+      const encrypted = encryptConfig(config, kekBuffer);
+      await store.set(getTenantKey(config.tenantId), encrypted);
+    },
+    async deleteTenantConfig(tenantId) {
+      const store = await resolveBlobStore(namespace);
+      await store.delete(getTenantKey(tenantId));
+    }
+  };
+}
+
+// src/server/tenant/context.js
+import { createHash as createHash3, randomBytes as randomBytes3, randomUUID as randomUUID3 } from "crypto";
+
+// src/server/tenant/token.js
+import { createHmac, timingSafeEqual } from "crypto";
+function base64UrlEncode2(input) {
+  return Buffer.from(input).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function base64UrlDecode2(input) {
+  const normalized = input.replace(/-/g, "+").replace(/_/g, "/");
+  const padLength = (4 - normalized.length % 4) % 4;
+  return Buffer.from(normalized + "=".repeat(padLength), "base64");
+}
+function sign(input, secret) {
+  return base64UrlEncode2(createHmac("sha256", secret).update(input).digest());
+}
+function nowEpochSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+function createTenantToken(params, secret) {
+  const issuedAt = nowEpochSeconds();
+  const expiresInSeconds = Number(params.expiresInSeconds || 60 * 60 * 24 * 30);
+  const payload = {
+    tid: params.tenantId,
+    typ: params.type,
+    iat: issuedAt,
+    exp: issuedAt + expiresInSeconds,
+    v: 1
+  };
+  const header = { alg: "HS256", typ: "JWT" };
+  const encodedHeader = base64UrlEncode2(JSON.stringify(header));
+  const encodedPayload = base64UrlEncode2(JSON.stringify(payload));
+  const signingInput = `${encodedHeader}.${encodedPayload}`;
+  const signature = sign(signingInput, secret);
+  return `${signingInput}.${signature}`;
+}
+function verifyTenantToken(token, secret, options = {}) {
+  if (!token || typeof token !== "string") {
+    throw new Error("INVALID_TENANT_AUTH");
+  }
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    throw new Error("INVALID_TENANT_AUTH");
+  }
+  const [encodedHeader, encodedPayload, receivedSignature] = parts;
+  const signingInput = `${encodedHeader}.${encodedPayload}`;
+  const expectedSignature = sign(signingInput, secret);
+  const receivedBuffer = Buffer.from(receivedSignature);
+  const expectedBuffer = Buffer.from(expectedSignature);
+  if (receivedBuffer.length !== expectedBuffer.length || !timingSafeEqual(receivedBuffer, expectedBuffer)) {
+    throw new Error("INVALID_TENANT_AUTH");
+  }
+  let payload;
+  try {
+    payload = JSON.parse(base64UrlDecode2(encodedPayload).toString("utf8"));
+  } catch {
+    throw new Error("INVALID_TENANT_AUTH");
+  }
+  if (!payload || typeof payload !== "object" || payload.v !== 1) {
+    throw new Error("INVALID_TENANT_AUTH");
+  }
+  if (!payload.tid || !payload.typ || !payload.exp) {
+    throw new Error("INVALID_TENANT_AUTH");
+  }
+  if (payload.exp <= nowEpochSeconds()) {
+    throw new Error("INVALID_TENANT_AUTH");
+  }
+  const expectedTypes = options.expectedTypes || [];
+  if (expectedTypes.length > 0 && !expectedTypes.includes(payload.typ)) {
+    throw new Error("INVALID_TENANT_AUTH");
+  }
+  return payload;
+}
+function extractBearerToken(headers = {}) {
+  let authorization = "";
+  for (const [key, value] of Object.entries(headers || {})) {
+    if (String(key).toLowerCase() === "authorization") {
+      authorization = String(value || "").trim();
+      break;
+    }
+  }
+  if (!authorization.toLowerCase().startsWith("bearer ")) {
+    return "";
+  }
+  return authorization.slice(7).trim();
+}
+
+// src/server/tenant/context.js
+function fingerprint(masterKey) {
+  return createHash3("sha256").update(masterKey).digest("hex").slice(0, 16);
+}
+function sanitizeDbConfig(driver, connectionString) {
+  const normalizedDriver = String(driver || "").trim();
+  const normalizedConnectionString = String(connectionString || "").trim();
+  if (!["neon", "pg"].includes(normalizedDriver)) {
+    throw new Error("INVALID_DRIVER");
+  }
+  if (!normalizedConnectionString) {
+    throw new Error("INVALID_DATABASE_URL");
+  }
+  return {
+    driver: normalizedDriver,
+    connectionString: normalizedConnectionString
+  };
+}
+function parseTokenFromUrl(url) {
+  if (!url || typeof url !== "string") {
+    return "";
+  }
+  try {
+    const parsed = new URL(url, "https://dummy.local");
+    return String(parsed.searchParams.get("token") || "").trim();
+  } catch {
+    return "";
+  }
+}
+function createTenantContextManager(options) {
+  const tenantStore = options.tenantStore;
+  const tokenSigningKey = String(options.tokenSigningKey || "").trim();
+  const publicBaseUrl = String(options.publicBaseUrl || "").replace(/\/$/, "");
+  const adapterFactory = options.adapterFactory || createAdapter;
+  const adapterCache = /* @__PURE__ */ new Map();
+  if (!tokenSigningKey) {
+    throw new Error("[rei-standard-amsg-server] tenant.tokenSigningKey is required");
+  }
+  async function getOrCreateAdapter(dbConfig) {
+    const cacheKey = `${dbConfig.driver}:${dbConfig.connectionString}`;
+    if (!adapterCache.has(cacheKey)) {
+      const adapter = await adapterFactory(dbConfig);
+      adapterCache.set(cacheKey, adapter);
+    }
+    return adapterCache.get(cacheKey);
+  }
+  async function initializeTenant({ driver, connectionString, tenantId: providedTenantId }) {
+    const dbConfig = sanitizeDbConfig(driver, connectionString);
+    const tenantId = String(providedTenantId || randomUUID3()).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 now = (/* @__PURE__ */ new Date()).toISOString();
+    await tenantStore.setTenantConfig({
+      tenantId,
+      db: dbConfig,
+      masterKey,
+      createdAt: now,
+      updatedAt: now
+    });
+    const tenantToken = createTenantToken({ tenantId, type: "tenant" }, tokenSigningKey);
+    const cronToken = createTenantToken({ tenantId, type: "cron" }, tokenSigningKey);
+    return {
+      tenantId,
+      masterKeyFingerprint: fingerprint(masterKey),
+      tenantToken,
+      cronToken,
+      cronWebhookUrl: publicBaseUrl ? `${publicBaseUrl}/api/v1/send-notifications?token=${cronToken}` : ""
+    };
+  }
+  async function resolveTenant(headers, options2 = {}) {
+    const allowCronToken = options2.allowCronToken === true;
+    const url = options2.url || "";
+    const bearerToken = extractBearerToken(headers);
+    const tokenFromQuery = allowCronToken ? parseTokenFromUrl(url) : "";
+    const token = bearerToken || tokenFromQuery;
+    if (!token) {
+      return {
+        ok: false,
+        error: {
+          status: 401,
+          body: { success: false, error: { code: "INVALID_TENANT_AUTH", message: "\u7F3A\u5C11\u79DF\u6237\u9274\u6743\u4FE1\u606F" } }
+        }
+      };
+    }
+    let payload;
+    try {
+      payload = verifyTenantToken(token, tokenSigningKey, {
+        expectedTypes: allowCronToken ? ["cron"] : ["tenant"]
+      });
+    } catch (_error) {
+      return {
+        ok: false,
+        error: {
+          status: 401,
+          body: { success: false, error: { code: "INVALID_TENANT_AUTH", message: "\u79DF\u6237\u4EE4\u724C\u65E0\u6548\u6216\u5DF2\u8FC7\u671F" } }
+        }
+      };
+    }
+    const tenantConfig = await tenantStore.getTenantConfig(payload.tid);
+    if (!tenantConfig) {
+      return {
+        ok: false,
+        error: {
+          status: 401,
+          body: { success: false, error: { code: "INVALID_TENANT_AUTH", message: "\u79DF\u6237\u914D\u7F6E\u4E0D\u5B58\u5728\u6216\u5DF2\u5931\u6548" } }
+        }
+      };
+    }
+    const adapter = await getOrCreateAdapter(tenantConfig.db);
+    return {
+      ok: true,
+      context: {
+        tenantId: tenantConfig.tenantId,
+        tokenType: payload.typ,
+        db: adapter,
+        masterKey: tenantConfig.masterKey
+      }
+    };
+  }
+  return {
+    initializeTenant,
+    resolveTenant
+  };
+}
+
 // src/server/index.js
 function normalizeVapidSubject(email) {
   const trimmedEmail = String(email || "").trim();
@@ -977,7 +1413,7 @@ function normalizeVapidSubject(email) {
 }
 async function createReiServer(config) {
   if (!config) throw new Error("[rei-standard-amsg-server] config is required");
-  const adapter = await createAdapter(config.db);
+  if (!config.tenant) throw new Error("[rei-standard-amsg-server] tenant config is required");
   let webpushModule;
   try {
     const webpushImport = await import("web-push");
@@ -995,33 +1431,45 @@ async function createReiServer(config) {
       vapid.privateKey
     );
   }
+  const tenantStore = createTenantBlobStore({
+    namespace: config.tenant.blobNamespace || "rei-tenants",
+    kek: config.tenant.kek
+  });
+  const tenantManager = createTenantContextManager({
+    tenantStore,
+    tokenSigningKey: config.tenant.tokenSigningKey,
+    publicBaseUrl: config.tenant.publicBaseUrl,
+    adapterFactory: config.tenant.adapterFactory
+  });
+  const initSecret = String(config.tenant.initSecret || "").trim();
   const ctx = {
-    db: adapter,
-    cronSecret: config.cronSecret || "",
     vapid: {
       email: vapid.email || "",
       publicKey: vapid.publicKey || "",
       privateKey: vapid.privateKey || ""
     },
-    webpush: webpushModule
+    webpush: webpushModule,
+    tenant: {
+      initSecret
+    },
+    tenantManager
   };
   return {
     handlers: {
-      initDatabase: createInitDatabaseHandler(ctx),
-      initMasterKey: createInitMasterKeyHandler(ctx),
+      initTenant: createInitTenantHandler(ctx),
       getUserKey: createGetUserKeyHandler(ctx),
       scheduleMessage: createScheduleMessageHandler(ctx),
       sendNotifications: createSendNotificationsHandler(ctx),
       updateMessage: createUpdateMessageHandler(ctx),
       cancelMessage: createCancelMessageHandler(ctx),
       messages: createMessagesHandler(ctx)
-    },
-    adapter
+    }
   };
 }
 export {
   createAdapter,
   createReiServer,
+  createTenantToken,
   decryptFromStorage,
   decryptPayload,
   deriveUserEncryptionKey,
@@ -1030,5 +1478,6 @@ export {
   isValidUUID,
   isValidUUIDv4,
   isValidUrl,
-  validateScheduleMessagePayload
+  validateScheduleMessagePayload,
+  verifyTenantToken
 };