@njuptlzf/agent-chat-server 0.4.0 → 0.4.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/authz.d.ts CHANGED
@@ -1,6 +1,6 @@
1
1
  import type { DatabaseSync } from "node:sqlite";
2
2
  import { type Model } from "casbin";
3
- import type { MembershipStore } from "./stores.ts";
3
+ import type { MembershipStore, QuotaCaps } from "./stores.ts";
4
4
  /**
5
5
  * 权限内核。
6
6
  *
@@ -56,13 +56,16 @@ export interface LimitsConfig {
56
56
  dailyTokenQuota?: number;
57
57
  memberDailyTokenQuota?: number;
58
58
  memberMonthlyTokenPool?: number;
59
+ /**
60
+ * 单次 run 的 token 上界(T3 严格 token 上限)。reserve 时按它占位,让在飞
61
+ * run 参与 tokenCap 判定;<=0/缺省 = 不启用,行为与 W3 完全一致。
62
+ * 产品级可按 `limits.personas.<id>` 逐人格覆盖。
63
+ */
64
+ perRunTokenCap?: number;
59
65
  /** 按人格(账本产品)覆盖;缺省继承产品级。 */
60
66
  personas?: Record<string, LimitsConfig>;
61
67
  }
62
- export declare function capsForRoles(roles: string[], limits: LimitsConfig): {
63
- runCap?: number;
64
- tokenCap?: number;
65
- };
68
+ export declare function capsForRoles(roles: string[], limits: LimitsConfig): QuotaCaps;
66
69
  /** 某人格的生效上限 = 产品级 + `limits.personas.<id>` 覆盖(逐字段)。 */
67
70
  export declare function limitsForPersona(limits: LimitsConfig, persona: string): LimitsConfig;
68
71
  /**
@@ -70,10 +73,7 @@ export declare function limitsForPersona(limits: LimitsConfig, persona: string):
70
73
  * `isMember` 必须是「这个人格的账本」是否在期(admin 恒真)——
71
74
  * 否则买了 A 人格会解锁 B 人格的次数。
72
75
  */
73
- export declare function capsForPersona(limits: LimitsConfig, persona: string, isMember: boolean): {
74
- runCap?: number;
75
- tokenCap?: number;
76
- };
76
+ export declare function capsForPersona(limits: LimitsConfig, persona: string, isMember: boolean): QuotaCaps;
77
77
  /**
78
78
  * 结算拆账(唯一算式):池先冲,冲不下的走余额。
79
79
  * 已知边界:部分覆盖时 toolCalls 服务费按全额算(computeSpendCents 的第二项不随
package/dist/authz.js CHANGED
@@ -94,7 +94,12 @@ export function capsForRoles(roles, limits) {
94
94
  const member = roles.includes("member") || roles.includes("admin");
95
95
  const runCap = member ? limits.memberDailyRuns : limits.freeDailyRuns;
96
96
  const tokenCap = member ? (limits.memberDailyTokenQuota ?? limits.dailyTokenQuota) : limits.dailyTokenQuota;
97
- return { runCap: runCap && runCap > 0 ? runCap : undefined, tokenCap };
97
+ return {
98
+ runCap: runCap && runCap > 0 ? runCap : undefined,
99
+ tokenCap,
100
+ // T3:单次 run 上界随人格生效;<=0 视为不启用(ledger 侧钳制)。
101
+ ...(limits.perRunTokenCap !== undefined && limits.perRunTokenCap > 0 ? { perRunTokenCap: limits.perRunTokenCap } : {}),
102
+ };
98
103
  }
99
104
  /** 某人格的生效上限 = 产品级 + `limits.personas.<id>` 覆盖(逐字段)。 */
100
105
  export function limitsForPersona(limits, persona) {
package/dist/ledger.d.ts CHANGED
@@ -17,10 +17,10 @@
17
17
  * 崩溃安全:预留带 `expires_at`,读路径一律只认未过期的预留。
18
18
  * 进程崩了不会永久占着额度——不需要「启动时清理孤儿」这种容易漏的逻辑。
19
19
  *
20
- * **明确的能力边界**:跑的次数(run 位)在并发下是精确的;**token 上限做不到精确**,
21
- * 因为一次 run 会花多少 token 事前不可知。reserve 只能保证「已达上限就不再开新 run」,
22
- * 在飞的那几个仍可能把它顶过去。要精确,得先有「单次 run 的 token 上限」这一配置
23
- * (见架构稿 §6.1 待办 T3)。
20
+ * **能力边界**:跑的次数(run 位)在并发下恒精确。token 总量的精确性取决于是否配置
21
+ * `caps.perRunTokenCap`(T3):配了 ⇒ reserve 按上界占位、在飞 run 计入总量判定,
22
+ * `used + Σ在飞上界 <= tokenCap` 恒成立(正常范围内);没配 ⇒ 预留 token 恒 0,
23
+ * 退化为 W3 现状(只数已结算,在飞 run 可能把当日总量顶过去)。配置缺省零行为变化。
24
24
  */
25
25
  import { type QuotaCaps } from "./stores.ts";
26
26
  /** 一次预留的句柄。`operationId` 由调用方生成(一请求一个),是幂等键。 */
package/dist/ledger.js CHANGED
@@ -17,10 +17,10 @@
17
17
  * 崩溃安全:预留带 `expires_at`,读路径一律只认未过期的预留。
18
18
  * 进程崩了不会永久占着额度——不需要「启动时清理孤儿」这种容易漏的逻辑。
19
19
  *
20
- * **明确的能力边界**:跑的次数(run 位)在并发下是精确的;**token 上限做不到精确**,
21
- * 因为一次 run 会花多少 token 事前不可知。reserve 只能保证「已达上限就不再开新 run」,
22
- * 在飞的那几个仍可能把它顶过去。要精确,得先有「单次 run 的 token 上限」这一配置
23
- * (见架构稿 §6.1 待办 T3)。
20
+ * **能力边界**:跑的次数(run 位)在并发下恒精确。token 总量的精确性取决于是否配置
21
+ * `caps.perRunTokenCap`(T3):配了 ⇒ reserve 按上界占位、在飞 run 计入总量判定,
22
+ * `used + Σ在飞上界 <= tokenCap` 恒成立(正常范围内);没配 ⇒ 预留 token 恒 0,
23
+ * 退化为 W3 现状(只数已结算,在飞 run 可能把当日总量顶过去)。配置缺省零行为变化。
24
24
  */
25
25
  import { quotaBlockedReason } from "./stores.js";
26
26
  /** 预留默认存活时间:1 小时。 */
@@ -66,8 +66,20 @@ export class MemoryLedger {
66
66
  }
67
67
  }
68
68
  const tokenCap = input.caps?.tokenCap ?? this.dailyTokens;
69
- if (tokenCap !== undefined && (this.used.get(key) ?? 0) >= tokenCap) {
70
- return { ok: false, reason: quotaBlockedReason("tokens", { runCap, tokenCap }) };
69
+ let reserveTokens = 0;
70
+ if (tokenCap !== undefined) {
71
+ const used = this.used.get(key) ?? 0;
72
+ // T3:在飞预留的 token 上界参与判定(W3 这里只数已结算的 used)。
73
+ const reserved = [...this.rows.values()]
74
+ .filter((r) => r.day === day && r.state === "reserved" && r.expiresAt > now)
75
+ .reduce((a, r) => a + r.tokens, 0);
76
+ if (used + reserved >= tokenCap) {
77
+ return { ok: false, reason: quotaBlockedReason("tokens", { runCap, tokenCap }) };
78
+ }
79
+ // 钳制:上界不超过当日剩余量,保证 "used + reserved <= tokenCap" 不变量。
80
+ const cap = input.caps?.perRunTokenCap;
81
+ if (cap !== undefined && cap > 0)
82
+ reserveTokens = Math.min(cap, tokenCap - used - reserved);
71
83
  }
72
84
  const expiresAt = now + (input.ttlMs ?? RESERVATION_TTL_MS);
73
85
  this.rows.set(input.operationId, {
@@ -76,6 +88,7 @@ export class MemoryLedger {
76
88
  day,
77
89
  state: "reserved",
78
90
  expiresAt,
91
+ tokens: reserveTokens,
79
92
  });
80
93
  return { ok: true, reservation: { operationId: input.operationId, expiresAt } };
81
94
  }
@@ -86,6 +99,8 @@ export class MemoryLedger {
86
99
  if (!row || row.state !== "reserved")
87
100
  return "already";
88
101
  row.state = "settled";
102
+ // 多退少补:把占位的上界改写为实际消耗(未用部分释放给后续 run)。
103
+ row.tokens = input.tokens;
89
104
  const key = MemoryLedger.key(input.userId, input.persona, MemoryLedger.day(this.now()));
90
105
  if (input.tokens > 0)
91
106
  this.used.set(key, (this.used.get(key) ?? 0) + input.tokens);
@@ -532,10 +532,11 @@ export class SqliteLedger {
532
532
  }
533
533
  }
534
534
  const tokenCap = input.caps?.tokenCap ?? this.dailyTokens;
535
+ let reserveTokens = 0;
535
536
  if (tokenCap !== undefined) {
536
537
  const used = this.tokensUsed(input.userId, input.persona, day);
537
- // 在飞预留的 tokens 目前恒为 0(一次 run 事前不可知)。保留这个求和,
538
- // 是为了将来有了「单次 run 的 token 上限」时能直接生效(§6.1 待办 T3)。
538
+ // T3:在飞预留的 token 上界已不再是恒 0——配了 perRunTokenCap 的 run 会按上界占位,
539
+ // 这里把它们计入总量判定,让 "已结算 + 在飞上界 <= tokenCap" 在并发下成立。
539
540
  const reserved = this.db
540
541
  .prepare(`SELECT COALESCE(SUM(tokens), 0) AS n FROM quota_reservations
541
542
  WHERE user_id = ? AND persona = ? AND day = ? AND state = 'reserved' AND expires_at > ?`)
@@ -544,12 +545,16 @@ export class SqliteLedger {
544
545
  this.db.exec("ROLLBACK");
545
546
  return { ok: false, reason: quotaBlockedReason("tokens", { runCap, tokenCap }) };
546
547
  }
548
+ // 钳制:上界不超过当日剩余量,保证不变量 I-T3-1;未配置则写 0(W3 现状)。
549
+ const cap = input.caps?.perRunTokenCap;
550
+ if (cap !== undefined && cap > 0)
551
+ reserveTokens = Math.min(cap, tokenCap - used - reserved.n);
547
552
  }
548
553
  const expiresAt = nowMs + (input.ttlMs ?? RESERVATION_TTL_MS);
549
554
  this.db
550
555
  .prepare(`INSERT INTO quota_reservations (operation_id, user_id, persona, day, tokens, state, created_at, expires_at)
551
- VALUES (?, ?, ?, ?, 0, 'reserved', ?, ?)`)
552
- .run(input.operationId, input.userId, input.persona, day, nowMs, expiresAt);
556
+ VALUES (?, ?, ?, ?, ?, 'reserved', ?, ?)`)
557
+ .run(input.operationId, input.userId, input.persona, day, reserveTokens, nowMs, expiresAt);
553
558
  this.db.exec("COMMIT");
554
559
  return { ok: true, reservation: { operationId: input.operationId, expiresAt } };
555
560
  }
package/dist/stores.d.ts CHANGED
@@ -53,6 +53,11 @@ export declare class MemoryHistoryStore implements HistoryStore {
53
53
  export interface QuotaCaps {
54
54
  runCap?: number;
55
55
  tokenCap?: number;
56
+ /**
57
+ * 单次 run 的 token 上界(T3):reserve 时写入预留的 tokens,让在飞 run 参与
58
+ * 当日总量判定。<=0/缺省 = 不启用(预留写 0,W3 现状)。
59
+ */
60
+ perRunTokenCap?: number;
56
61
  }
57
62
  /** 万位读法:5000000 → 「500 万」(撞闸文案与权益卡共用,别在 UI 里二次造轮子)。 */
58
63
  export declare function fmtTokensWan(n: number): string;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@njuptlzf/agent-chat-server",
3
- "version": "0.4.0",
3
+ "version": "0.4.1",
4
4
  "description": "agentChat platform kernel: sessions, authz, billing, audit, model/MCP/persona config planes, and the product-directory loader.",
5
5
  "type": "module",
6
6
  "license": "Apache-2.0",
@@ -20,7 +20,7 @@ import { createRequire } from "node:module";
20
20
  import { spawnSync } from "node:child_process";
21
21
  import process from "node:process";
22
22
 
23
- const CLI_VERSION = "0.4.0";
23
+ const CLI_VERSION = "0.4.1";
24
24
  const MIN_SERVER = "0.2.0";
25
25
  const PKG = {
26
26
  protocol: "@njuptlzf/agent-chat-protocol",
package/src/authz.ts CHANGED
@@ -1,6 +1,6 @@
1
1
  import type { DatabaseSync } from "node:sqlite";
2
2
  import { Assertion, newEnforcer, newModelFromString, type Enforcer, type Model } from "casbin";
3
- import type { MembershipStore } from "./stores.ts";
3
+ import type { MembershipStore, QuotaCaps } from "./stores.ts";
4
4
 
5
5
  /**
6
6
  * 权限内核。
@@ -133,15 +133,26 @@ export interface LimitsConfig {
133
133
  dailyTokenQuota?: number;
134
134
  memberDailyTokenQuota?: number;
135
135
  memberMonthlyTokenPool?: number;
136
+ /**
137
+ * 单次 run 的 token 上界(T3 严格 token 上限)。reserve 时按它占位,让在飞
138
+ * run 参与 tokenCap 判定;<=0/缺省 = 不启用,行为与 W3 完全一致。
139
+ * 产品级可按 `limits.personas.<id>` 逐人格覆盖。
140
+ */
141
+ perRunTokenCap?: number;
136
142
  /** 按人格(账本产品)覆盖;缺省继承产品级。 */
137
143
  personas?: Record<string, LimitsConfig>;
138
144
  }
139
145
 
140
- export function capsForRoles(roles: string[], limits: LimitsConfig): { runCap?: number; tokenCap?: number } {
146
+ export function capsForRoles(roles: string[], limits: LimitsConfig): QuotaCaps {
141
147
  const member = roles.includes("member") || roles.includes("admin");
142
148
  const runCap = member ? limits.memberDailyRuns : limits.freeDailyRuns;
143
149
  const tokenCap = member ? (limits.memberDailyTokenQuota ?? limits.dailyTokenQuota) : limits.dailyTokenQuota;
144
- return { runCap: runCap && runCap > 0 ? runCap : undefined, tokenCap };
150
+ return {
151
+ runCap: runCap && runCap > 0 ? runCap : undefined,
152
+ tokenCap,
153
+ // T3:单次 run 上界随人格生效;<=0 视为不启用(ledger 侧钳制)。
154
+ ...(limits.perRunTokenCap !== undefined && limits.perRunTokenCap > 0 ? { perRunTokenCap: limits.perRunTokenCap } : {}),
155
+ };
145
156
  }
146
157
 
147
158
  /** 某人格的生效上限 = 产品级 + `limits.personas.<id>` 覆盖(逐字段)。 */
@@ -154,11 +165,7 @@ export function limitsForPersona(limits: LimitsConfig, persona: string): LimitsC
154
165
  * `isMember` 必须是「这个人格的账本」是否在期(admin 恒真)——
155
166
  * 否则买了 A 人格会解锁 B 人格的次数。
156
167
  */
157
- export function capsForPersona(
158
- limits: LimitsConfig,
159
- persona: string,
160
- isMember: boolean,
161
- ): { runCap?: number; tokenCap?: number } {
168
+ export function capsForPersona(limits: LimitsConfig, persona: string, isMember: boolean): QuotaCaps {
162
169
  return capsForRoles(isMember ? ["member"] : ["user"], limitsForPersona(limits, persona));
163
170
  }
164
171
 
package/src/ledger.ts CHANGED
@@ -17,10 +17,10 @@
17
17
  * 崩溃安全:预留带 `expires_at`,读路径一律只认未过期的预留。
18
18
  * 进程崩了不会永久占着额度——不需要「启动时清理孤儿」这种容易漏的逻辑。
19
19
  *
20
- * **明确的能力边界**:跑的次数(run 位)在并发下是精确的;**token 上限做不到精确**,
21
- * 因为一次 run 会花多少 token 事前不可知。reserve 只能保证「已达上限就不再开新 run」,
22
- * 在飞的那几个仍可能把它顶过去。要精确,得先有「单次 run 的 token 上限」这一配置
23
- * (见架构稿 §6.1 待办 T3)。
20
+ * **能力边界**:跑的次数(run 位)在并发下恒精确。token 总量的精确性取决于是否配置
21
+ * `caps.perRunTokenCap`(T3):配了 ⇒ reserve 按上界占位、在飞 run 计入总量判定,
22
+ * `used + Σ在飞上界 <= tokenCap` 恒成立(正常范围内);没配 ⇒ 预留 token 恒 0,
23
+ * 退化为 W3 现状(只数已结算,在飞 run 可能把当日总量顶过去)。配置缺省零行为变化。
24
24
  */
25
25
  import { quotaBlockedReason, type QuotaCaps } from "./stores.ts";
26
26
 
@@ -74,7 +74,15 @@ export const RESERVATION_TTL_MS = 60 * 60 * 1000;
74
74
  export class MemoryLedger implements Ledger {
75
75
  private readonly rows = new Map<
76
76
  string,
77
- { userId: string; persona: string; day: string; state: "reserved" | "settled" | "released"; expiresAt: number }
77
+ {
78
+ userId: string;
79
+ persona: string;
80
+ day: string;
81
+ state: "reserved" | "settled" | "released";
82
+ expiresAt: number;
83
+ /** 预留的 token 上界(T3);settle 时回填实际值。W3 恒 0。 */
84
+ tokens: number;
85
+ }
78
86
  >();
79
87
  private readonly used = new Map<string, number>();
80
88
  private readonly runs = new Map<string, number>();
@@ -120,8 +128,19 @@ export class MemoryLedger implements Ledger {
120
128
  }
121
129
 
122
130
  const tokenCap = input.caps?.tokenCap ?? this.dailyTokens;
123
- if (tokenCap !== undefined && (this.used.get(key) ?? 0) >= tokenCap) {
124
- return { ok: false, reason: quotaBlockedReason("tokens", { runCap, tokenCap }) };
131
+ let reserveTokens = 0;
132
+ if (tokenCap !== undefined) {
133
+ const used = this.used.get(key) ?? 0;
134
+ // T3:在飞预留的 token 上界参与判定(W3 这里只数已结算的 used)。
135
+ const reserved = [...this.rows.values()]
136
+ .filter((r) => r.day === day && r.state === "reserved" && r.expiresAt > now)
137
+ .reduce((a, r) => a + r.tokens, 0);
138
+ if (used + reserved >= tokenCap) {
139
+ return { ok: false, reason: quotaBlockedReason("tokens", { runCap, tokenCap }) };
140
+ }
141
+ // 钳制:上界不超过当日剩余量,保证 "used + reserved <= tokenCap" 不变量。
142
+ const cap = input.caps?.perRunTokenCap;
143
+ if (cap !== undefined && cap > 0) reserveTokens = Math.min(cap, tokenCap - used - reserved);
125
144
  }
126
145
 
127
146
  const expiresAt = now + (input.ttlMs ?? RESERVATION_TTL_MS);
@@ -131,6 +150,7 @@ export class MemoryLedger implements Ledger {
131
150
  day,
132
151
  state: "reserved",
133
152
  expiresAt,
153
+ tokens: reserveTokens,
134
154
  });
135
155
  return { ok: true, reservation: { operationId: input.operationId, expiresAt } };
136
156
  }
@@ -141,6 +161,8 @@ export class MemoryLedger implements Ledger {
141
161
  // 否则「settle 一个不存在的 operationId」就成了绕开额度的后门。
142
162
  if (!row || row.state !== "reserved") return "already";
143
163
  row.state = "settled";
164
+ // 多退少补:把占位的上界改写为实际消耗(未用部分释放给后续 run)。
165
+ row.tokens = input.tokens;
144
166
  const key = MemoryLedger.key(input.userId, input.persona, MemoryLedger.day(this.now()));
145
167
  if (input.tokens > 0) this.used.set(key, (this.used.get(key) ?? 0) + input.tokens);
146
168
  this.runs.set(key, (this.runs.get(key) ?? 0) + 1);
@@ -594,10 +594,11 @@ export class SqliteLedger implements Ledger {
594
594
  }
595
595
 
596
596
  const tokenCap = input.caps?.tokenCap ?? this.dailyTokens;
597
+ let reserveTokens = 0;
597
598
  if (tokenCap !== undefined) {
598
599
  const used = this.tokensUsed(input.userId, input.persona, day);
599
- // 在飞预留的 tokens 目前恒为 0(一次 run 事前不可知)。保留这个求和,
600
- // 是为了将来有了「单次 run 的 token 上限」时能直接生效(§6.1 待办 T3)。
600
+ // T3:在飞预留的 token 上界已不再是恒 0——配了 perRunTokenCap 的 run 会按上界占位,
601
+ // 这里把它们计入总量判定,让 "已结算 + 在飞上界 <= tokenCap" 在并发下成立。
601
602
  const reserved = this.db
602
603
  .prepare(
603
604
  `SELECT COALESCE(SUM(tokens), 0) AS n FROM quota_reservations
@@ -608,15 +609,18 @@ export class SqliteLedger implements Ledger {
608
609
  this.db.exec("ROLLBACK");
609
610
  return { ok: false, reason: quotaBlockedReason("tokens", { runCap, tokenCap }) };
610
611
  }
612
+ // 钳制:上界不超过当日剩余量,保证不变量 I-T3-1;未配置则写 0(W3 现状)。
613
+ const cap = input.caps?.perRunTokenCap;
614
+ if (cap !== undefined && cap > 0) reserveTokens = Math.min(cap, tokenCap - used - reserved.n);
611
615
  }
612
616
 
613
617
  const expiresAt = nowMs + (input.ttlMs ?? RESERVATION_TTL_MS);
614
618
  this.db
615
619
  .prepare(
616
620
  `INSERT INTO quota_reservations (operation_id, user_id, persona, day, tokens, state, created_at, expires_at)
617
- VALUES (?, ?, ?, ?, 0, 'reserved', ?, ?)`,
621
+ VALUES (?, ?, ?, ?, ?, 'reserved', ?, ?)`,
618
622
  )
619
- .run(input.operationId, input.userId, input.persona, day, nowMs, expiresAt);
623
+ .run(input.operationId, input.userId, input.persona, day, reserveTokens, nowMs, expiresAt);
620
624
  this.db.exec("COMMIT");
621
625
  return { ok: true, reservation: { operationId: input.operationId, expiresAt } };
622
626
  } catch (err) {
package/src/stores.ts CHANGED
@@ -173,6 +173,11 @@ export class MemoryHistoryStore implements HistoryStore {
173
173
  export interface QuotaCaps {
174
174
  runCap?: number;
175
175
  tokenCap?: number;
176
+ /**
177
+ * 单次 run 的 token 上界(T3):reserve 时写入预留的 tokens,让在飞 run 参与
178
+ * 当日总量判定。<=0/缺省 = 不启用(预留写 0,W3 现状)。
179
+ */
180
+ perRunTokenCap?: number;
176
181
  }
177
182
 
178
183
  /** 万位读法:5000000 → 「500 万」(撞闸文案与权益卡共用,别在 UI 里二次造轮子)。 */