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

package/dist/{neon-QJ7KYHEX.mjs → neon-GKLT4UY3.mjs}

@@ -1,10 +1,28 @@
+import {
+  claimTask,
+  createTaskSuperseding,
+  deleteLlmCredentials,
+  deletePushSubscription,
+  getLlmCredentials,
+  getPushSubscription,
+  getTaskStatusInfo,
+  listLlmCredentials,
+  renewTaskLease,
+  upsertLlmCredentials,
+  upsertPushSubscription
+} from "./chunk-XKUWMYVF.mjs";
 import {
   COLUMNS_SQL,
   INDEXES,
+  LLM_CREDENTIALS_TABLE_SQL,
   MIGRATIONS,
+  PUSH_SUBSCRIPTION_TABLE_SQL,
   TABLE_SQL,
+  TASK_DELIVERY_COLUMNS,
+  TASK_DETAIL_COLUMNS,
+  UPDATABLE_COLUMNS,
   VERIFY_TABLE_SQL
-} from "./chunk-GOBCWCJP.mjs";
+} from "./chunk-GN44PST5.mjs";
 
 // src/server/adapters/neon.js
 import { neon } from "@neondatabase/serverless";
@@ -14,7 +32,13 @@ var NeonAdapter = class {
     this._connectionString = connectionString;
     this._sql = null;
   }
-  /** @private */
+  /**
+   * neon() 的 HTTP 驱动：一次查询一个 fetch，两次查询之间不留连接。所以它没有
+   * pg 那种「空闲连接被服务端掐断」的问题——连接层面的错误只会让当次调用的
+   * Promise 失败，落在调用方的 try/catch 里，不会变成进程级未捕获异常。
+   *
+   * @private
+   */
   _getSql() {
     if (!this._sql) {
       this._sql = neon(this._connectionString);
@@ -24,6 +48,8 @@ var NeonAdapter = class {
   async initSchema() {
     const sql = this._getSql();
     await sql.query(TABLE_SQL);
+    await sql.query(PUSH_SUBSCRIPTION_TABLE_SQL);
+    await sql.query(LLM_CREDENTIALS_TABLE_SQL);
     for (const migration of MIGRATIONS) {
       await sql.query(migration.sql);
     }
@@ -72,6 +98,8 @@ var NeonAdapter = class {
   async dropSchema() {
     const sql = this._getSql();
     await sql.query("DROP TABLE IF EXISTS scheduled_messages CASCADE");
+    await sql.query("DROP TABLE IF EXISTS push_subscriptions CASCADE");
+    await sql.query("DROP TABLE IF EXISTS llm_credentials CASCADE");
   }
   async createTask(params) {
     const sql = this._getSql();
@@ -84,10 +112,15 @@ var NeonAdapter = class {
     );
     return rows[0] || null;
   }
+  // 建新任务 + 删掉被顶替的旧任务，一条语句一起成败（SQL 与语义见 pg-shared.js）。
+  async createTaskSuperseding(params, supersedesUuid) {
+    const sql = this._getSql();
+    return createTaskSuperseding((text, args) => sql.query(text, args), params, supersedesUuid);
+  }
   async getTaskByUuid(uuid, userId) {
     const sql = this._getSql();
     const rows = await sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
+      `SELECT ${TASK_DETAIL_COLUMNS}
        FROM scheduled_messages
        WHERE uuid = $1 AND user_id = $2 AND status = 'pending'
        LIMIT 1`,
@@ -98,7 +131,7 @@ var NeonAdapter = class {
   async getTaskByUuidOnly(uuid) {
     const sql = this._getSql();
     const rows = await sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
+      `SELECT ${TASK_DELIVERY_COLUMNS}
        FROM scheduled_messages
        WHERE uuid = $1 AND status = 'pending'
        LIMIT 1`,
@@ -106,12 +139,30 @@ var NeonAdapter = class {
     );
     return rows[0] || null;
   }
+  /**
+   * 这条 uuid 现在是什么状态——不限用户，也不限状态（上面那个只看 pending
+   * 行）。`runTask` 用它把「这条已经跑完了」和「压根没这条」分开回报。
+   *
+   * @param {string} uuid
+   * @returns {Promise<{ status: string }|null>}
+   */
+  async getTaskStatusByUuidOnly(uuid) {
+    const sql = this._getSql();
+    const rows = await sql.query(
+      `SELECT status FROM scheduled_messages WHERE uuid = $1 LIMIT 1`,
+      [uuid]
+    );
+    return rows[0] ? { status: rows[0].status } : null;
+  }
   async updateTaskById(taskId, updates) {
     const sql = this._getSql();
     const sets = [];
     const values = [];
     let idx = 1;
     for (const [key, value] of Object.entries(updates)) {
+      if (!UPDATABLE_COLUMNS.has(key)) {
+        throw new Error(`[amsg-server neon] rejected unknown update column: ${key}`);
+      }
       sets.push(`${key} = $${idx}`);
       values.push(value);
       idx++;
@@ -124,6 +175,15 @@ var NeonAdapter = class {
     );
     return rows[0] || null;
   }
+  /**
+   * 按 uuid 改一条 pending 任务（PUT /update-message、fire hook 的 renewTask）。
+   *
+   * 改排期（extraFields 里带 next_send_at）时多一道租约门：这条任务正被一次投递
+   * 占着的话不改，返回 null。投递收尾会按自己领取时看到的排期推进下一次（一次性
+   * 任务干脆标成已发送），这期间写进去的新时刻随后就被盖掉，接口却已经回了成功
+   * ——用户以为改期生效了，实际什么都没留下。正文这类字段不受这道门约束：它们
+   * 只影响以后的触发，收尾那边本来就不会覆盖（见 run-tick 的收尾守卫）。
+   */
   async updateTaskByUuid(uuid, userId, encryptedPayload, extraFields) {
     const sql = this._getSql();
     const sets = ["encrypted_payload = $1", "updated_at = NOW()"];
@@ -131,15 +191,19 @@ var NeonAdapter = class {
     let idx = 2;
     if (extraFields) {
       for (const [key, value] of Object.entries(extraFields)) {
+        if (!UPDATABLE_COLUMNS.has(key)) {
+          throw new Error(`[amsg-server neon] rejected unknown update column: ${key}`);
+        }
         sets.push(`${key} = $${idx}`);
         values.push(value);
         idx++;
       }
     }
     values.push(uuid, userId);
+    const leaseGate = extraFields && Object.prototype.hasOwnProperty.call(extraFields, "next_send_at") ? " AND (lease_until IS NULL OR lease_until <= NOW())" : "";
     const rows = await sql.query(
       `UPDATE scheduled_messages SET ${sets.join(", ")}
-       WHERE uuid = $${idx} AND user_id = $${idx + 1} AND status = 'pending'
+       WHERE uuid = $${idx} AND user_id = $${idx + 1} AND status = 'pending'${leaseGate}
        RETURNING uuid, updated_at`,
       values
     );
@@ -161,53 +225,26 @@ var NeonAdapter = class {
   async getPendingTasks(limit = 50) {
     const sql = this._getSql();
     return sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
+      `SELECT ${TASK_DELIVERY_COLUMNS}
        FROM scheduled_messages
        WHERE status = 'pending' AND next_send_at <= NOW()
          AND (lease_until IS NULL OR lease_until <= NOW())
+         AND (retry_after IS NULL OR retry_after <= NOW())
        ORDER BY next_send_at ASC
        LIMIT $1`,
       [limit]
     );
   }
-  /**
-   * 领取一条到点的任务：在 lease_until 上写下「这条归我管到什么时候」，
-   * 本次投递期间别的 tick 领不走它。
-   *
-   * 租约写在自己的列上，next_send_at 全程不动——那一列是用户设的触发时刻，
-   * 任务列表要读它、循环任务推进下一次也要拿它当基准。
-   *
-   * 两个 tick 抢同一行时只有一个改得动，另一个拿不到 RETURNING 行，据此跳
-   * 过。WHERE 里的两个条件各管一件事：
-   *   - lease_until 为空或已过期：没人正在跑这条。领了任务的 tick 中途没了
-   *     也不会把行焊死，租约到期后自然可以被接手。
-   *   - next_send_at 等于读这行时看到的值：读出来之后用户又改了排期的话，
-   *     这一跳就不该再按旧时刻发。
-   *
-   * 不加一个 'sending' 状态来表达「正在跑」：status 上有 CHECK 约束，加值
-   * 要改表。
-   *
-   * 比 next_send_at 时两边都截到毫秒：列是 timestamptz（微秒精度），驱动读
-   * 出来是 JS Date（毫秒精度），原值送回去可能因为亚毫秒差对不上。
-   *
-   * @param {number} taskId
-   * @param {string|Date} expectedNextSendAt - 读这行时拿到的 next_send_at 原值
-   * @param {string|Date} leaseUntil - 租期末尾
-   * @returns {Promise<boolean>} true = 领到了；false = 别人正拿着租约、排期被改过、或行已不是 pending
-   */
-  async claimTask(taskId, expectedNextSendAt, leaseUntil) {
+  // 领取一条到点的任务。SQL 与并发语义在 pg-shared.js（pg / neon 共用一份，
+  // 语义说明也在那里）。
+  async claimTask(taskId, expectedNextSendAt, leaseUntil, serializeGroup = null) {
     const sql = this._getSql();
-    const rows = await sql.query(
-      `UPDATE scheduled_messages
-          SET lease_until = $1, updated_at = NOW()
-        WHERE id = $2 AND status = 'pending'
-          AND date_trunc('milliseconds', next_send_at)
-            = date_trunc('milliseconds', $3::timestamptz)
-          AND (lease_until IS NULL OR lease_until <= NOW())
-       RETURNING id`,
-      [leaseUntil, taskId, expectedNextSendAt]
-    );
-    return rows.length > 0;
+    return claimTask((text, params) => sql.query(text, params), taskId, expectedNextSendAt, leaseUntil, serializeGroup);
+  }
+  // 投递期间的租约续期（run-tick 心跳；语义见 pg-shared.js）。
+  async renewTaskLease(taskId, leaseUntil) {
+    const sql = this._getSql();
+    return renewTaskLease((text, params) => sql.query(text, params), taskId, leaseUntil);
   }
   async listTasks(userId, opts = {}) {
     const sql = this._getSql();
@@ -228,7 +265,7 @@ var NeonAdapter = class {
     const total = parseInt(countRows[0].count, 10);
     const taskParams = [...params, limit, offset];
     const tasks = await sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, created_at, updated_at
+      `SELECT ${TASK_DETAIL_COLUMNS}
        FROM scheduled_messages
        WHERE ${where}
        ORDER BY next_send_at ASC
@@ -257,6 +294,41 @@ var NeonAdapter = class {
     );
     return rows.length > 0 ? rows[0].status : null;
   }
+  // 状态 + 失败摘要（GET /message 对已失败的行透出原因；语义见 pg-shared.js）。
+  async getTaskStatusInfo(uuid, userId) {
+    const sql = this._getSql();
+    return getTaskStatusInfo((text, params) => sql.query(text, params), uuid, userId);
+  }
+  // ── push_subscriptions（实现见 pg-shared.js，pg / neon 共用一份）─────────
+  async getPushSubscription(userId) {
+    const sql = this._getSql();
+    return getPushSubscription((text, params) => sql.query(text, params), userId);
+  }
+  async upsertPushSubscription(userId, encryptedSubscription, updatedAt) {
+    const sql = this._getSql();
+    return upsertPushSubscription((text, params) => sql.query(text, params), userId, encryptedSubscription, updatedAt);
+  }
+  async deletePushSubscription(userId) {
+    const sql = this._getSql();
+    return deletePushSubscription((text, params) => sql.query(text, params), userId);
+  }
+  // ── llm_credentials（实现见 pg-shared.js，pg / neon 共用一份）───────────
+  async upsertLlmCredentials(userId, entries) {
+    const sql = this._getSql();
+    return upsertLlmCredentials((text, params) => sql.query(text, params), userId, entries, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  async getLlmCredentials(userId, credIds) {
+    const sql = this._getSql();
+    return getLlmCredentials((text, params) => sql.query(text, params), userId, credIds);
+  }
+  async listLlmCredentials(userId) {
+    const sql = this._getSql();
+    return listLlmCredentials((text, params) => sql.query(text, params), userId);
+  }
+  async deleteLlmCredentials(userId, credIds = null) {
+    const sql = this._getSql();
+    return deleteLlmCredentials((text, params) => sql.query(text, params), userId, credIds);
+  }
 };
 export {
   NeonAdapter

package/dist/{neon-V4VOH55N.cjs → neon-XHPJZESV.cjs}

@@ -4,7 +4,25 @@
 
 
 
-var _chunkDCKCAGFVcjs = require('./chunk-DCKCAGFV.cjs');
+
+
+
+
+
+
+var _chunkTKDISKCFcjs = require('./chunk-TKDISKCF.cjs');
+
+
+
+
+
+
+
+
+
+
+
+var _chunk7NMQFTDJcjs = require('./chunk-7NMQFTDJ.cjs');
 
 // src/server/adapters/neon.js
 var _serverless = require('@neondatabase/serverless');
@@ -14,7 +32,13 @@ var NeonAdapter = class {
     this._connectionString = connectionString;
     this._sql = null;
   }
-  /** @private */
+  /**
+   * neon() 的 HTTP 驱动：一次查询一个 fetch，两次查询之间不留连接。所以它没有
+   * pg 那种「空闲连接被服务端掐断」的问题——连接层面的错误只会让当次调用的
+   * Promise 失败，落在调用方的 try/catch 里，不会变成进程级未捕获异常。
+   *
+   * @private
+   */
   _getSql() {
     if (!this._sql) {
       this._sql = _serverless.neon.call(void 0, this._connectionString);
@@ -23,12 +47,14 @@ var NeonAdapter = class {
   }
   async initSchema() {
     const sql = this._getSql();
-    await sql.query(_chunkDCKCAGFVcjs.TABLE_SQL);
-    for (const migration of _chunkDCKCAGFVcjs.MIGRATIONS) {
+    await sql.query(_chunk7NMQFTDJcjs.TABLE_SQL);
+    await sql.query(_chunk7NMQFTDJcjs.PUSH_SUBSCRIPTION_TABLE_SQL);
+    await sql.query(_chunk7NMQFTDJcjs.LLM_CREDENTIALS_TABLE_SQL);
+    for (const migration of _chunk7NMQFTDJcjs.MIGRATIONS) {
       await sql.query(migration.sql);
     }
     const indexResults = [];
-    for (const index of _chunkDCKCAGFVcjs.INDEXES) {
+    for (const index of _chunk7NMQFTDJcjs.INDEXES) {
       try {
         await sql.query(index.sql);
         indexResults.push({
@@ -54,11 +80,11 @@ var NeonAdapter = class {
         `Critical index creation failed (${failedNames}). Please remove duplicate UUID rows and run initSchema again.`
       );
     }
-    const tableCheck = await sql.query(_chunkDCKCAGFVcjs.VERIFY_TABLE_SQL);
+    const tableCheck = await sql.query(_chunk7NMQFTDJcjs.VERIFY_TABLE_SQL);
     if (tableCheck.length === 0) {
       throw new Error("Table creation verification failed");
     }
-    const columns = await sql.query(_chunkDCKCAGFVcjs.COLUMNS_SQL);
+    const columns = await sql.query(_chunk7NMQFTDJcjs.COLUMNS_SQL);
     return {
       columnsCreated: columns.length,
       indexesCreated: indexResults.filter((r) => r.status === "success").length,
@@ -72,6 +98,8 @@ var NeonAdapter = class {
   async dropSchema() {
     const sql = this._getSql();
     await sql.query("DROP TABLE IF EXISTS scheduled_messages CASCADE");
+    await sql.query("DROP TABLE IF EXISTS push_subscriptions CASCADE");
+    await sql.query("DROP TABLE IF EXISTS llm_credentials CASCADE");
   }
   async createTask(params) {
     const sql = this._getSql();
@@ -84,10 +112,15 @@ var NeonAdapter = class {
     );
     return rows[0] || null;
   }
+  // 建新任务 + 删掉被顶替的旧任务，一条语句一起成败（SQL 与语义见 pg-shared.js）。
+  async createTaskSuperseding(params, supersedesUuid) {
+    const sql = this._getSql();
+    return _chunkTKDISKCFcjs.createTaskSuperseding.call(void 0, (text, args) => sql.query(text, args), params, supersedesUuid);
+  }
   async getTaskByUuid(uuid, userId) {
     const sql = this._getSql();
     const rows = await sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
+      `SELECT ${_chunk7NMQFTDJcjs.TASK_DETAIL_COLUMNS}
        FROM scheduled_messages
        WHERE uuid = $1 AND user_id = $2 AND status = 'pending'
        LIMIT 1`,
@@ -98,7 +131,7 @@ var NeonAdapter = class {
   async getTaskByUuidOnly(uuid) {
     const sql = this._getSql();
     const rows = await sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
+      `SELECT ${_chunk7NMQFTDJcjs.TASK_DELIVERY_COLUMNS}
        FROM scheduled_messages
        WHERE uuid = $1 AND status = 'pending'
        LIMIT 1`,
@@ -106,12 +139,30 @@ var NeonAdapter = class {
     );
     return rows[0] || null;
   }
+  /**
+   * 这条 uuid 现在是什么状态——不限用户，也不限状态（上面那个只看 pending
+   * 行）。`runTask` 用它把「这条已经跑完了」和「压根没这条」分开回报。
+   *
+   * @param {string} uuid
+   * @returns {Promise<{ status: string }|null>}
+   */
+  async getTaskStatusByUuidOnly(uuid) {
+    const sql = this._getSql();
+    const rows = await sql.query(
+      `SELECT status FROM scheduled_messages WHERE uuid = $1 LIMIT 1`,
+      [uuid]
+    );
+    return rows[0] ? { status: rows[0].status } : null;
+  }
   async updateTaskById(taskId, updates) {
     const sql = this._getSql();
     const sets = [];
     const values = [];
     let idx = 1;
     for (const [key, value] of Object.entries(updates)) {
+      if (!_chunk7NMQFTDJcjs.UPDATABLE_COLUMNS.has(key)) {
+        throw new Error(`[amsg-server neon] rejected unknown update column: ${key}`);
+      }
       sets.push(`${key} = $${idx}`);
       values.push(value);
       idx++;
@@ -124,6 +175,15 @@ var NeonAdapter = class {
     );
     return rows[0] || null;
   }
+  /**
+   * 按 uuid 改一条 pending 任务（PUT /update-message、fire hook 的 renewTask）。
+   *
+   * 改排期（extraFields 里带 next_send_at）时多一道租约门：这条任务正被一次投递
+   * 占着的话不改，返回 null。投递收尾会按自己领取时看到的排期推进下一次（一次性
+   * 任务干脆标成已发送），这期间写进去的新时刻随后就被盖掉，接口却已经回了成功
+   * ——用户以为改期生效了，实际什么都没留下。正文这类字段不受这道门约束：它们
+   * 只影响以后的触发，收尾那边本来就不会覆盖（见 run-tick 的收尾守卫）。
+   */
   async updateTaskByUuid(uuid, userId, encryptedPayload, extraFields) {
     const sql = this._getSql();
     const sets = ["encrypted_payload = $1", "updated_at = NOW()"];
@@ -131,15 +191,19 @@ var NeonAdapter = class {
     let idx = 2;
     if (extraFields) {
       for (const [key, value] of Object.entries(extraFields)) {
+        if (!_chunk7NMQFTDJcjs.UPDATABLE_COLUMNS.has(key)) {
+          throw new Error(`[amsg-server neon] rejected unknown update column: ${key}`);
+        }
         sets.push(`${key} = $${idx}`);
         values.push(value);
         idx++;
       }
     }
     values.push(uuid, userId);
+    const leaseGate = extraFields && Object.prototype.hasOwnProperty.call(extraFields, "next_send_at") ? " AND (lease_until IS NULL OR lease_until <= NOW())" : "";
     const rows = await sql.query(
       `UPDATE scheduled_messages SET ${sets.join(", ")}
-       WHERE uuid = $${idx} AND user_id = $${idx + 1} AND status = 'pending'
+       WHERE uuid = $${idx} AND user_id = $${idx + 1} AND status = 'pending'${leaseGate}
        RETURNING uuid, updated_at`,
       values
     );
@@ -161,53 +225,26 @@ var NeonAdapter = class {
   async getPendingTasks(limit = 50) {
     const sql = this._getSql();
     return sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
+      `SELECT ${_chunk7NMQFTDJcjs.TASK_DELIVERY_COLUMNS}
        FROM scheduled_messages
        WHERE status = 'pending' AND next_send_at <= NOW()
          AND (lease_until IS NULL OR lease_until <= NOW())
+         AND (retry_after IS NULL OR retry_after <= NOW())
        ORDER BY next_send_at ASC
        LIMIT $1`,
       [limit]
     );
   }
-  /**
-   * 领取一条到点的任务：在 lease_until 上写下「这条归我管到什么时候」，
-   * 本次投递期间别的 tick 领不走它。
-   *
-   * 租约写在自己的列上，next_send_at 全程不动——那一列是用户设的触发时刻，
-   * 任务列表要读它、循环任务推进下一次也要拿它当基准。
-   *
-   * 两个 tick 抢同一行时只有一个改得动，另一个拿不到 RETURNING 行，据此跳
-   * 过。WHERE 里的两个条件各管一件事：
-   *   - lease_until 为空或已过期：没人正在跑这条。领了任务的 tick 中途没了
-   *     也不会把行焊死，租约到期后自然可以被接手。
-   *   - next_send_at 等于读这行时看到的值：读出来之后用户又改了排期的话，
-   *     这一跳就不该再按旧时刻发。
-   *
-   * 不加一个 'sending' 状态来表达「正在跑」：status 上有 CHECK 约束，加值
-   * 要改表。
-   *
-   * 比 next_send_at 时两边都截到毫秒：列是 timestamptz（微秒精度），驱动读
-   * 出来是 JS Date（毫秒精度），原值送回去可能因为亚毫秒差对不上。
-   *
-   * @param {number} taskId
-   * @param {string|Date} expectedNextSendAt - 读这行时拿到的 next_send_at 原值
-   * @param {string|Date} leaseUntil - 租期末尾
-   * @returns {Promise<boolean>} true = 领到了；false = 别人正拿着租约、排期被改过、或行已不是 pending
-   */
-  async claimTask(taskId, expectedNextSendAt, leaseUntil) {
+  // 领取一条到点的任务。SQL 与并发语义在 pg-shared.js（pg / neon 共用一份，
+  // 语义说明也在那里）。
+  async claimTask(taskId, expectedNextSendAt, leaseUntil, serializeGroup = null) {
     const sql = this._getSql();
-    const rows = await sql.query(
-      `UPDATE scheduled_messages
-          SET lease_until = $1, updated_at = NOW()
-        WHERE id = $2 AND status = 'pending'
-          AND date_trunc('milliseconds', next_send_at)
-            = date_trunc('milliseconds', $3::timestamptz)
-          AND (lease_until IS NULL OR lease_until <= NOW())
-       RETURNING id`,
-      [leaseUntil, taskId, expectedNextSendAt]
-    );
-    return rows.length > 0;
+    return _chunkTKDISKCFcjs.claimTask.call(void 0, (text, params) => sql.query(text, params), taskId, expectedNextSendAt, leaseUntil, serializeGroup);
+  }
+  // 投递期间的租约续期（run-tick 心跳；语义见 pg-shared.js）。
+  async renewTaskLease(taskId, leaseUntil) {
+    const sql = this._getSql();
+    return _chunkTKDISKCFcjs.renewTaskLease.call(void 0, (text, params) => sql.query(text, params), taskId, leaseUntil);
   }
   async listTasks(userId, opts = {}) {
     const sql = this._getSql();
@@ -228,7 +265,7 @@ var NeonAdapter = class {
     const total = parseInt(countRows[0].count, 10);
     const taskParams = [...params, limit, offset];
     const tasks = await sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, created_at, updated_at
+      `SELECT ${_chunk7NMQFTDJcjs.TASK_DETAIL_COLUMNS}
        FROM scheduled_messages
        WHERE ${where}
        ORDER BY next_send_at ASC
@@ -257,6 +294,41 @@ var NeonAdapter = class {
     );
     return rows.length > 0 ? rows[0].status : null;
   }
+  // 状态 + 失败摘要（GET /message 对已失败的行透出原因；语义见 pg-shared.js）。
+  async getTaskStatusInfo(uuid, userId) {
+    const sql = this._getSql();
+    return _chunkTKDISKCFcjs.getTaskStatusInfo.call(void 0, (text, params) => sql.query(text, params), uuid, userId);
+  }
+  // ── push_subscriptions（实现见 pg-shared.js，pg / neon 共用一份）─────────
+  async getPushSubscription(userId) {
+    const sql = this._getSql();
+    return _chunkTKDISKCFcjs.getPushSubscription.call(void 0, (text, params) => sql.query(text, params), userId);
+  }
+  async upsertPushSubscription(userId, encryptedSubscription, updatedAt) {
+    const sql = this._getSql();
+    return _chunkTKDISKCFcjs.upsertPushSubscription.call(void 0, (text, params) => sql.query(text, params), userId, encryptedSubscription, updatedAt);
+  }
+  async deletePushSubscription(userId) {
+    const sql = this._getSql();
+    return _chunkTKDISKCFcjs.deletePushSubscription.call(void 0, (text, params) => sql.query(text, params), userId);
+  }
+  // ── llm_credentials（实现见 pg-shared.js，pg / neon 共用一份）───────────
+  async upsertLlmCredentials(userId, entries) {
+    const sql = this._getSql();
+    return _chunkTKDISKCFcjs.upsertLlmCredentials.call(void 0, (text, params) => sql.query(text, params), userId, entries, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  async getLlmCredentials(userId, credIds) {
+    const sql = this._getSql();
+    return _chunkTKDISKCFcjs.getLlmCredentials.call(void 0, (text, params) => sql.query(text, params), userId, credIds);
+  }
+  async listLlmCredentials(userId) {
+    const sql = this._getSql();
+    return _chunkTKDISKCFcjs.listLlmCredentials.call(void 0, (text, params) => sql.query(text, params), userId);
+  }
+  async deleteLlmCredentials(userId, credIds = null) {
+    const sql = this._getSql();
+    return _chunkTKDISKCFcjs.deleteLlmCredentials.call(void 0, (text, params) => sql.query(text, params), userId, credIds);
+  }
 };