@rei-standard/amsg-server 2.6.0-next.3 → 2.6.0-next.4

package/dist/{chunk-PPPWETND.mjs → chunk-OVGQHTSE.mjs}

@@ -485,6 +485,81 @@ import {
   extractAssistantMessage,
   extractToolCallsFromDecision
 } from "@rei-standard/amsg-shared";
+
+// src/server/lib/state-chunks.js
+import { chunkReasoningByUtf8Bytes } from "@rei-standard/amsg-shared";
+var STATE_CHUNK_SLICE_BYTES = 200 * 1024;
+var DEFAULT_MAX_STATE_VALUE_BYTES = 5 * 1024 * 1024;
+var INTERNAL_STATE_CHAR_RE = /[\u0000-\u001f]/;
+var SEP = "";
+var CHUNK_NS_PREFIX = `${SEP}amsg-chunks${SEP}`;
+var ROOT_MARKER_PREFIX = `${SEP}amsg-chunked${SEP}v1${SEP}`;
+function chunkNamespaceFor(namespace) {
+  return CHUNK_NS_PREFIX + namespace;
+}
+function chunkKeyFor(key, index) {
+  return `${key}${SEP}${index}`;
+}
+function chunkKeyPrefixFor(key) {
+  return `${key}${SEP}`;
+}
+function buildChunkedRootValue(chunkCount) {
+  return `${ROOT_MARKER_PREFIX}${chunkCount}`;
+}
+function parseChunkedRootCount(value) {
+  if (typeof value !== "string" || !value.startsWith(ROOT_MARKER_PREFIX)) return null;
+  const raw = value.slice(ROOT_MARKER_PREFIX.length);
+  if (!/^[1-9][0-9]*$/.test(raw)) return null;
+  return Number(raw);
+}
+function splitStateValue(value) {
+  return chunkReasoningByUtf8Bytes(value, STATE_CHUNK_SLICE_BYTES);
+}
+async function resolveClientStateEntries(rows, fetchChunkRows, decryptValue) {
+  let chunkMap = null;
+  const loadChunks = async () => {
+    if (chunkMap === null) {
+      const chunkRows = await fetchChunkRows();
+      chunkMap = new Map(chunkRows.map((row) => [row.key, row]));
+    }
+    return chunkMap;
+  };
+  const entries = [];
+  for (const row of rows) {
+    const count = parseChunkedRootCount(row.value);
+    if (count === null) {
+      entries.push({
+        namespace: row.namespace,
+        key: row.key,
+        value: await decryptValue(row.value),
+        updatedAt: row.updated_at
+      });
+      continue;
+    }
+    const map = await loadChunks();
+    const chunkRows = [];
+    let intact = true;
+    for (let i = 0; i < count; i++) {
+      const chunk = map.get(chunkKeyFor(row.key, i));
+      if (!chunk || chunk.updated_at !== row.updated_at) {
+        intact = false;
+        break;
+      }
+      chunkRows.push(chunk);
+    }
+    if (!intact) continue;
+    const parts = await Promise.all(chunkRows.map((chunk) => decryptValue(chunk.value)));
+    entries.push({
+      namespace: row.namespace,
+      key: row.key,
+      value: parts.join(""),
+      updatedAt: row.updated_at
+    });
+  }
+  return entries;
+}
+
+// src/server/lib/agentic-fire.js
 var DEFAULT_MAX_TOOL_ITERATIONS = 5;
 var DEFAULT_TOTAL_TIMEOUT_MS = 24e4;
 var SLEEP_BETWEEN_MESSAGES_MS = 1500;
@@ -551,18 +626,19 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
     }
     if (!ctx.db || typeof ctx.db.getClientState !== "function") return [];
     const rows = await ctx.db.getClientState(task.user_id, namespace);
-    return Promise.all(rows.map(async (row) => ({
-      namespace: row.namespace,
-      key: row.key,
-      value: await decryptFromStorage(row.value, userKey),
-      updatedAt: row.updated_at
-    })));
+    return resolveClientStateEntries(
+      rows,
+      () => ctx.db.getClientState(task.user_id, chunkNamespaceFor(namespace)),
+      (value) => decryptFromStorage(value, userKey)
+    );
   };
+  const scratch = {};
   const fireCtx = Object.freeze({
     task: buildHookTask(task, decryptedPayload),
     userId: task.user_id,
     readState,
-    now: new Date(nowFn())
+    now: new Date(nowFn()),
+    scratch
   });
   const before = await hooks.onBeforeFire(fireCtx);
   if (before == null) return { handled: false };
@@ -597,7 +673,8 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
       contactName: decryptedPayload.contactName,
       avatarUrl: decryptedPayload.avatarUrl || void 0,
       charId: decryptedPayload.charId,
-      metadata: decryptedPayload.metadata
+      metadata: decryptedPayload.metadata,
+      scratch
     });
     const decision = await hooks.onLLMOutput(sessionCtx);
     assertValidDecision(decision, { inlineToolCalls: true });
@@ -1439,6 +1516,9 @@ var UPDATABLE_COLUMNS = /* @__PURE__ */ new Set([
   "created_at",
   "updated_at"
 ]);
+function escapeLikePrefix(prefix) {
+  return prefix.replace(/[\\%_]/g, (ch) => `\\${ch}`);
+}
 var D1Adapter = class {
   /** @param {{ prepare: (sql: string) => any }} db - Cloudflare D1 binding */
   constructor(db) {
@@ -1620,6 +1700,10 @@ var D1Adapter = class {
    * than the stored row (updatedAt strictly lower) is skipped; equal or
    * newer overwrites. Values arrive pre-encrypted (the handler encrypts).
    *
+   * `cleanups` 是分块存储的清理项（见 lib/state-chunks.js）：在同一 batch 里
+   * 先于 upsert 执行，按 (namespace, key 前缀) 删掉旧写入留下的切片行；
+   * `updated_at <= ?` 条件保证陈旧批次删不动更新写入的行。
+   *
    * Uses D1's batch() — one network round trip for the whole set (implicit
    * transaction). The client calls this endpoint inside its few-seconds
    * background window, so N sequential round trips could eat the whole
@@ -1628,36 +1712,44 @@ var D1Adapter = class {
    *
    * @param {string} userId
    * @param {Array<{ namespace: string, key: string, value: string, updatedAt: number }>} entries
-   * @returns {Promise<{ upserted: number, skipped: number }>}
+   * @param {Array<{ namespace: string, keyPrefix: string, updatedAt: number }>} [cleanups]
+   * @returns {Promise<{ upserted: number, skipped: number, outcomes: boolean[] }>}
+   *   `outcomes[i]` 对应 entries[i] 是否真的写入（changes > 0）。
    */
-  async upsertClientState(userId, entries) {
+  async upsertClientState(userId, entries, cleanups = []) {
     const UPSERT_SQL = `INSERT INTO client_state (user_id, namespace, key, value, updated_at)
        VALUES (?, ?, ?, ?, ?)
        ON CONFLICT (user_id, namespace, key) DO UPDATE SET
          value = excluded.value,
          updated_at = excluded.updated_at
        WHERE excluded.updated_at >= client_state.updated_at`;
+    const CLEANUP_SQL = `DELETE FROM client_state
+       WHERE user_id = ? AND namespace = ? AND key LIKE ? ESCAPE '\\' AND updated_at <= ?`;
+    const buildStatements = () => [
+      ...cleanups.map(
+        (c) => this._db.prepare(CLEANUP_SQL).bind(userId, c.namespace, `${escapeLikePrefix(c.keyPrefix)}%`, c.updatedAt)
+      ),
+      ...entries.map(
+        (entry) => this._db.prepare(UPSERT_SQL).bind(userId, entry.namespace, entry.key, entry.value, entry.updatedAt)
+      )
+    ];
     let results;
     if (typeof this._db.batch === "function") {
-      const statements = entries.map(
-        (entry) => this._db.prepare(UPSERT_SQL).bind(userId, entry.namespace, entry.key, entry.value, entry.updatedAt)
-      );
-      results = await this._db.batch(statements);
+      results = await this._db.batch(buildStatements());
     } else {
       results = [];
-      for (const entry of entries) {
-        results.push(
-          await this._db.prepare(UPSERT_SQL).bind(userId, entry.namespace, entry.key, entry.value, entry.updatedAt).run()
-        );
+      for (const stmt of buildStatements()) {
+        results.push(await stmt.run());
       }
     }
+    const outcomes = results.slice(cleanups.length).map((res) => res.meta.changes > 0);
     let upserted = 0;
     let skipped = 0;
-    for (const res of results) {
-      if (res.meta.changes > 0) upserted++;
+    for (const wrote of outcomes) {
+      if (wrote) upserted++;
       else skipped++;
     }
-    return { upserted, skipped };
+    return { upserted, skipped, outcomes };
   }
   /**
    * All entries of one namespace (values still encrypted).
@@ -1799,7 +1891,6 @@ function createVapidPublicKeyHandler(ctx) {
 }
 
 // src/server/handlers/client-state.js
-var MAX_STATE_VALUE_BYTES = 200 * 1024;
 var MAX_STATE_ENTRIES_PER_REQUEST = 200;
 var MAX_NAMESPACE_CHARS = 128;
 var MAX_KEY_CHARS = 256;
@@ -1814,23 +1905,39 @@ function requireUserId(headers) {
   if (!isValidUUIDv4(userId)) return { error: err(400, "INVALID_USER_ID_FORMAT", "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F") };
   return { userId };
 }
-function validateEntry(entry, index) {
-  if (!isPlainObject(entry)) return err(400, "INVALID_STATE_ENTRY", `entries[${index}] \u5FC5\u987B\u662F\u5BF9\u8C61`);
+function rejectEntry(entry, index, code, message, extra) {
+  const rejection = { index, code, message, ...extra || {} };
+  if (entry && typeof entry === "object") {
+    if (typeof entry.namespace === "string") rejection.namespace = entry.namespace;
+    if (typeof entry.key === "string") rejection.key = entry.key;
+  }
+  return rejection;
+}
+function validateEntry(entry, index, maxValueBytes) {
+  if (!isPlainObject(entry)) {
+    return rejectEntry(entry, index, "INVALID_STATE_ENTRY", `entries[${index}] \u5FC5\u987B\u662F\u5BF9\u8C61`);
+  }
   if (typeof entry.namespace !== "string" || !entry.namespace.trim() || entry.namespace.length > MAX_NAMESPACE_CHARS) {
-    return err(400, "INVALID_STATE_NAMESPACE", `entries[${index}].namespace \u5FC5\u987B\u662F 1-${MAX_NAMESPACE_CHARS} \u5B57\u7B26\u7684\u5B57\u7B26\u4E32`);
+    return rejectEntry(entry, index, "INVALID_STATE_NAMESPACE", `entries[${index}].namespace \u5FC5\u987B\u662F 1-${MAX_NAMESPACE_CHARS} \u5B57\u7B26\u7684\u5B57\u7B26\u4E32`);
+  }
+  if (INTERNAL_STATE_CHAR_RE.test(entry.namespace)) {
+    return rejectEntry(entry, index, "INVALID_STATE_NAMESPACE", `entries[${index}].namespace \u4E0D\u80FD\u5305\u542B\u63A7\u5236\u5B57\u7B26\uFF08\\u0000-\\u001f \u4E3A\u5E93\u5185\u90E8\u4FDD\u7559\uFF09`);
   }
   if (typeof entry.key !== "string" || !entry.key.trim() || entry.key.length > MAX_KEY_CHARS) {
-    return err(400, "INVALID_STATE_KEY", `entries[${index}].key \u5FC5\u987B\u662F 1-${MAX_KEY_CHARS} \u5B57\u7B26\u7684\u5B57\u7B26\u4E32`);
+    return rejectEntry(entry, index, "INVALID_STATE_KEY", `entries[${index}].key \u5FC5\u987B\u662F 1-${MAX_KEY_CHARS} \u5B57\u7B26\u7684\u5B57\u7B26\u4E32`);
+  }
+  if (INTERNAL_STATE_CHAR_RE.test(entry.key)) {
+    return rejectEntry(entry, index, "INVALID_STATE_KEY", `entries[${index}].key \u4E0D\u80FD\u5305\u542B\u63A7\u5236\u5B57\u7B26\uFF08\\u0000-\\u001f \u4E3A\u5E93\u5185\u90E8\u4FDD\u7559\uFF09`);
   }
   if (typeof entry.value !== "string") {
-    return err(400, "INVALID_STATE_VALUE", `entries[${index}].value \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\uFF08\u5BBF\u4E3B\u81EA\u884C\u5E8F\u5217\u5316\uFF09`);
+    return rejectEntry(entry, index, "INVALID_STATE_VALUE", `entries[${index}].value \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\uFF08\u5BBF\u4E3B\u81EA\u884C\u5E8F\u5217\u5316\uFF09`);
   }
   const bytes = utf82.encode(entry.value).length;
-  if (bytes > MAX_STATE_VALUE_BYTES) {
-    return err(413, "STATE_VALUE_TOO_LARGE", `entries[${index}].value \u8D85\u8FC7\u5355\u6761\u4E0A\u9650`, { index, key: entry.key, bytes, maxBytes: MAX_STATE_VALUE_BYTES });
+  if (bytes > maxValueBytes) {
+    return rejectEntry(entry, index, "STATE_VALUE_TOO_LARGE", `entries[${index}].value \u8D85\u8FC7\u5355\u6761\u603B\u4E0A\u9650`, { bytes, maxBytes: maxValueBytes });
   }
   if (!Number.isInteger(entry.updatedAt) || entry.updatedAt <= 0) {
-    return err(400, "INVALID_STATE_UPDATED_AT", `entries[${index}].updatedAt \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF08epoch \u6BEB\u79D2\uFF09`);
+    return rejectEntry(entry, index, "INVALID_STATE_UPDATED_AT", `entries[${index}].updatedAt \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF08epoch \u6BEB\u79D2\uFF09`);
   }
   return null;
 }
@@ -1868,21 +1975,70 @@ function createClientStateHandler(ctx) {
     if (entries.length > MAX_STATE_ENTRIES_PER_REQUEST) {
       return err(400, "TOO_MANY_STATE_ENTRIES", `\u5355\u6B21\u6700\u591A ${MAX_STATE_ENTRIES_PER_REQUEST} \u6761`, { count: entries.length });
     }
+    const maxValueBytes = Number.isInteger(ctx.maxStateValueBytes) && ctx.maxStateValueBytes > 0 ? ctx.maxStateValueBytes : DEFAULT_MAX_STATE_VALUE_BYTES;
+    const accepted = [];
+    const rejected = [];
     for (let i = 0; i < entries.length; i++) {
-      const invalid = validateEntry(entries[i], i);
-      if (invalid) return invalid;
+      const rejection = validateEntry(entries[i], i, maxValueBytes);
+      if (rejection) rejected.push(rejection);
+      else accepted.push(entries[i]);
     }
     if (typeof db.upsertClientState !== "function") {
       return err(501, "CLIENT_STATE_NOT_SUPPORTED", "\u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301 client_state");
     }
-    const encryptedEntries = await Promise.all(entries.map(async (entry) => ({
-      namespace: entry.namespace,
-      key: entry.key,
-      value: await encryptForStorage(entry.value, userKey),
-      updatedAt: entry.updatedAt
-    })));
-    const { upserted, skipped } = await db.upsertClientState(userId, encryptedEntries);
-    return { status: 200, body: { success: true, data: { upserted, skipped } } };
+    const physicalRows = [];
+    const cleanups = [];
+    const rootRowIndexes = [];
+    for (const entry of accepted) {
+      cleanups.push({
+        namespace: chunkNamespaceFor(entry.namespace),
+        keyPrefix: chunkKeyPrefixFor(entry.key),
+        updatedAt: entry.updatedAt
+      });
+      rootRowIndexes.push(physicalRows.length);
+      if (utf82.encode(entry.value).length <= STATE_CHUNK_SLICE_BYTES) {
+        physicalRows.push({
+          namespace: entry.namespace,
+          key: entry.key,
+          value: await encryptForStorage(entry.value, userKey),
+          updatedAt: entry.updatedAt
+        });
+      } else {
+        const slices = splitStateValue(entry.value);
+        physicalRows.push({
+          namespace: entry.namespace,
+          key: entry.key,
+          value: buildChunkedRootValue(slices.length),
+          updatedAt: entry.updatedAt
+        });
+        const encryptedSlices = await Promise.all(slices.map((slice) => encryptForStorage(slice, userKey)));
+        for (let c = 0; c < encryptedSlices.length; c++) {
+          physicalRows.push({
+            namespace: chunkNamespaceFor(entry.namespace),
+            key: chunkKeyFor(entry.key, c),
+            value: encryptedSlices[c],
+            updatedAt: entry.updatedAt
+          });
+        }
+      }
+    }
+    let upserted = 0;
+    let skipped = 0;
+    if (physicalRows.length > 0) {
+      const result = await db.upsertClientState(userId, physicalRows, cleanups);
+      if (Array.isArray(result.outcomes) && result.outcomes.length === physicalRows.length) {
+        for (const rootIndex of rootRowIndexes) {
+          if (result.outcomes[rootIndex]) upserted++;
+          else skipped++;
+        }
+      } else {
+        upserted = result.upserted;
+        skipped = result.skipped;
+      }
+    }
+    const data = { upserted, skipped };
+    if (rejected.length > 0) data.rejected = rejected;
+    return { status: 200, body: { success: true, data } };
   }
   async function GET(url, headers) {
     const tenantResult = await ctx.tenantManager.resolveTenant(headers);
@@ -1893,17 +2049,19 @@ function createClientStateHandler(ctx) {
     const { userId } = gate;
     const namespace = new URL(url, "https://dummy").searchParams.get("namespace") || "";
     if (!namespace.trim()) return err(400, "NAMESPACE_REQUIRED", "\u5FC5\u987B\u63D0\u4F9B namespace \u67E5\u8BE2\u53C2\u6570");
+    if (INTERNAL_STATE_CHAR_RE.test(namespace)) {
+      return err(400, "INVALID_STATE_NAMESPACE", "namespace \u4E0D\u80FD\u5305\u542B\u63A7\u5236\u5B57\u7B26\uFF08\\u0000-\\u001f \u4E3A\u5E93\u5185\u90E8\u4FDD\u7559\uFF09");
+    }
     if (typeof db.getClientState !== "function") {
       return err(501, "CLIENT_STATE_NOT_SUPPORTED", "\u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301 client_state");
     }
     const userKey = await deriveUserEncryptionKey(userId, masterKey);
     const rows = await db.getClientState(userId, namespace);
-    const decrypted = await Promise.all(rows.map(async (row) => ({
-      namespace: row.namespace,
-      key: row.key,
-      value: await decryptFromStorage(row.value, userKey),
-      updatedAt: row.updated_at
-    })));
+    const decrypted = await resolveClientStateEntries(
+      rows,
+      () => db.getClientState(userId, chunkNamespaceFor(namespace)),
+      (value) => decryptFromStorage(value, userKey)
+    );
     const encryptedResponse = await encryptPayload({ namespace, entries: decrypted }, userKey);
     return { status: 200, body: { success: true, encrypted: true, version: 1, data: encryptedResponse } };
   }
@@ -1923,6 +2081,33 @@ function createClientStateHandler(ctx) {
   return { PUT, GET, DELETE };
 }
 
+// src/server/lib/version.js
+var SERVER_VERSION = true ? "2.6.0-next.4" : "0.0.0-dev";
+
+// src/server/handlers/capabilities.js
+var SERVER_FEATURES = Object.freeze([
+  "client-state",
+  "client-state-chunking",
+  "client-state-partial-failure",
+  "agentic-hooks",
+  "agentic-scratch",
+  "vapid-public-key"
+]);
+function createCapabilitiesHandler(ctx) {
+  async function GET(url, headers) {
+    const effectiveHeaders = headers || url || {};
+    const tenantResult = await ctx.tenantManager.resolveTenant(effectiveHeaders);
+    if (!tenantResult.ok) {
+      return tenantResult.error;
+    }
+    return {
+      status: 200,
+      body: { success: true, serverVersion: SERVER_VERSION, features: [...SERVER_FEATURES] }
+    };
+  }
+  return { GET };
+}
+
 // src/server/single-user.js
 function createSingleUserServer(config) {
   if (!config || !config.db) throw new Error("[amsg-server single-user] config.db is required");
@@ -1946,7 +2131,8 @@ function createSingleUserServer(config) {
     // the agentic path too.
     hooks: config.hooks || null,
     maxToolIterations: config.maxToolIterations,
-    totalTimeoutMs: config.totalTimeoutMs
+    totalTimeoutMs: config.totalTimeoutMs,
+    maxStateValueBytes: config.maxStateValueBytes
   };
   return {
     ctx,
@@ -1958,7 +2144,8 @@ function createSingleUserServer(config) {
       cancelMessage: createCancelMessageHandler(ctx),
       messages: createMessagesHandler(ctx),
       vapidPublicKey: createVapidPublicKeyHandler(ctx),
-      clientState: createClientStateHandler(ctx)
+      clientState: createClientStateHandler(ctx),
+      capabilities: createCapabilitiesHandler(ctx)
     }
   };
 }
@@ -2224,6 +2411,8 @@ function createSingleUserCloudflareWorker(buildConfig) {
         result = await server.handlers.cancelMessage.DELETE(url, headers);
       } else if (method === "GET" && pathname.endsWith("/vapid-public-key")) {
         result = await server.handlers.vapidPublicKey.GET(url, headers);
+      } else if (method === "GET" && pathname.endsWith("/capabilities")) {
+        result = await server.handlers.capabilities.GET(url, headers);
       } else if (method === "PUT" && pathname.endsWith("/client-state")) {
         result = await server.handlers.clientState.PUT(headers, await request.text());
       } else if (method === "GET" && pathname.endsWith("/client-state")) {