plugin-agent-orchestrator 1.1.6 → 1.1.7

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.
Files changed (69) hide show
  1. package/dist/client/index.js +1 -1
  2. package/dist/client-v2/index.js +1 -1
  3. package/dist/externalVersion.js +7 -7
  4. package/dist/server/collections/agent-loop-runs.js +6 -0
  5. package/dist/server/collections/skill-metrics.js +66 -0
  6. package/dist/server/plugin.js +91 -2
  7. package/dist/server/resources/agent-loop-events-stream.js +1 -0
  8. package/dist/server/resources/agent-loop.js +1 -1
  9. package/dist/server/services/DurableCircuitBreakerService.js +9 -12
  10. package/dist/server/services/ExecutionSpanService.js +8 -3
  11. package/dist/server/services/HarnessProfileService.js +23 -26
  12. package/dist/server/services/LoopBudgetService.js +36 -39
  13. package/dist/server/services/LoopControlService.js +8 -11
  14. package/dist/server/services/LoopPatternSchema.js +51 -17
  15. package/dist/server/services/LoopPatternService.js +31 -11
  16. package/dist/server/services/LoopRunRepository.js +2 -5
  17. package/dist/server/services/LoopRunStateMachine.js +31 -34
  18. package/dist/server/services/LoopSchedulerService.js +4 -7
  19. package/dist/server/services/LoopTriggerService.js +11 -6
  20. package/dist/server/services/LoopWorkerService.js +88 -22
  21. package/dist/server/services/PathLockService.js +19 -22
  22. package/dist/server/services/PluginAiRuntimeAdapter.js +51 -8
  23. package/dist/server/services/RunEventBus.js +14 -2
  24. package/dist/server/services/SkillAccessService.js +50 -1
  25. package/dist/server/services/TokenTracker.js +17 -1
  26. package/dist/server/services/ToolLoopDetectionService.js +14 -17
  27. package/dist/server/services/VerificationService.js +47 -16
  28. package/dist/server/services/harness-runtime-policy.js +7 -12
  29. package/dist/server/skill-hub/plugin.js +34 -27
  30. package/dist/server/utils/ha-lock.js +73 -0
  31. package/dist/server/utils/loop-pattern-context.js +42 -5
  32. package/dist/server/utils/record-utils.js +44 -0
  33. package/package.json +1 -1
  34. package/src/client/plugin.tsx +1 -1
  35. package/src/client-v2/plugin.tsx +14 -13
  36. package/src/server/__tests__/tool-loop-detection.test.ts +1 -0
  37. package/src/server/collections/agent-loop-runs.ts +7 -0
  38. package/src/server/collections/skill-metrics.ts +36 -0
  39. package/src/server/plugin.ts +117 -1
  40. package/src/server/resources/agent-loop-events-stream.ts +108 -105
  41. package/src/server/resources/agent-loop.ts +1 -1
  42. package/src/server/resources/tracing.ts +267 -266
  43. package/src/server/services/DurableCircuitBreakerService.ts +235 -239
  44. package/src/server/services/ExecutionSpanService.ts +37 -12
  45. package/src/server/services/HarnessProfileService.ts +1 -5
  46. package/src/server/services/LoopBudgetService.ts +271 -275
  47. package/src/server/services/LoopControlService.ts +120 -124
  48. package/src/server/services/LoopPatternSchema.ts +60 -14
  49. package/src/server/services/LoopPatternService.ts +171 -143
  50. package/src/server/services/LoopRunRepository.ts +1 -5
  51. package/src/server/services/LoopRunStateMachine.ts +1 -5
  52. package/src/server/services/LoopSchedulerService.ts +195 -199
  53. package/src/server/services/LoopTriggerService.ts +7 -5
  54. package/src/server/services/LoopWorkerService.ts +102 -12
  55. package/src/server/services/PathLockService.ts +317 -321
  56. package/src/server/services/PluginAiRuntimeAdapter.ts +59 -4
  57. package/src/server/services/RunEventBus.ts +13 -0
  58. package/src/server/services/SkillAccessService.ts +80 -5
  59. package/src/server/services/TokenTracker.ts +59 -7
  60. package/src/server/services/ToolLoopDetectionService.ts +8 -11
  61. package/src/server/services/VerificationSchema.ts +31 -31
  62. package/src/server/services/VerificationService.ts +60 -11
  63. package/src/server/services/harness-runtime-policy.ts +2 -9
  64. package/src/server/skill-hub/plugin.ts +36 -28
  65. package/src/server/types.ts +5 -39
  66. package/src/server/utils/ensure-indexes.ts +96 -96
  67. package/src/server/utils/ha-lock.ts +80 -0
  68. package/src/server/utils/loop-pattern-context.ts +84 -20
  69. package/src/server/utils/record-utils.ts +19 -0
@@ -1,275 +1,271 @@
1
- import type { Database, Model } from '@nocobase/database';
2
- import type { LoopPatternPolicy } from './LoopPatternSchema';
3
-
4
- export type UsageDelta = {
5
- invocations?: number;
6
- toolCalls?: number;
7
- delegations?: number;
8
- verifications?: number;
9
- inputTokens?: number;
10
- outputTokens?: number;
11
- totalTokens?: number;
12
- cost?: number;
13
- };
14
-
15
- type UsageTotals = Required<UsageDelta>;
16
-
17
- function read(record: Model | Record<string, unknown>, key: string) {
18
- const model = record as Model & { get?: (name: string) => unknown };
19
- return typeof model.get === 'function' ? model.get(key) : (record as Record<string, unknown>)[key];
20
- }
21
-
22
- function storedCount(value: unknown, label: string) {
23
- if (value === null || value === undefined) return 0;
24
- const parsed = Number(value);
25
- if (!Number.isSafeInteger(parsed) || parsed < 0) throw new Error(`${label} counter is invalid.`);
26
- return parsed;
27
- }
28
-
29
- function storedCost(value: unknown, label: string) {
30
- if (value === null || value === undefined) return 0;
31
- const parsed = Number(value);
32
- if (!Number.isFinite(parsed) || parsed < 0) throw new Error(`${label} counter is invalid.`);
33
- return parsed;
34
- }
35
-
36
- function deltaCount(value: unknown, label: string) {
37
- if (value === null || value === undefined) return 0;
38
- const parsed = Number(value);
39
- if (!Number.isSafeInteger(parsed) || parsed < 0)
40
- throw new Error(`${label} usage delta must be a nonnegative integer.`);
41
- return parsed;
42
- }
43
-
44
- function deltaCost(value: unknown) {
45
- if (value === null || value === undefined) return 0;
46
- const parsed = Number(value);
47
- if (!Number.isFinite(parsed) || parsed < 0) throw new Error('Cost usage delta must be a nonnegative finite number.');
48
- return parsed;
49
- }
50
-
51
- function normalizedDelta(delta: UsageDelta): UsageTotals {
52
- const result = {
53
- invocations: deltaCount(delta.invocations, 'Invocation'),
54
- toolCalls: deltaCount(delta.toolCalls, 'Tool call'),
55
- delegations: deltaCount(delta.delegations, 'Delegation'),
56
- verifications: deltaCount(delta.verifications, 'Verification'),
57
- inputTokens: deltaCount(delta.inputTokens, 'Input token'),
58
- outputTokens: deltaCount(delta.outputTokens, 'Output token'),
59
- totalTokens: deltaCount(delta.totalTokens, 'Total token'),
60
- cost: deltaCost(delta.cost),
61
- };
62
- result.totalTokens = Math.max(result.totalTokens, result.inputTokens + result.outputTokens);
63
- return result;
64
- }
65
-
66
- function storedLimit(value: unknown, label: string) {
67
- if (value === null || value === undefined) return null;
68
- const parsed = Number(value);
69
- if (!Number.isFinite(parsed) || parsed < 0) throw new Error(`${label} limit is invalid.`);
70
- return parsed;
71
- }
72
-
73
- function exceeds(current: number, delta: number, limit: number | null, label: string) {
74
- if (limit !== null && current + delta > limit) {
75
- throw new Error(`${label} budget exceeded: ${current} + ${delta} > ${limit}.`);
76
- }
77
- }
78
-
79
- function bucketDate(date: Date) {
80
- return date.toISOString().slice(0, 10);
81
- }
82
-
83
- type DistributedLock = {
84
- runExclusive<T>(key: string, operation: () => Promise<T>, ttl?: number): Promise<T>;
85
- };
86
-
87
- export class LoopBudgetService {
88
- constructor(
89
- private readonly database: Database,
90
- private readonly distributedLock: DistributedLock,
91
- ) {}
92
-
93
- async reserve(input: { runId: number; patternId: number; policy: LoopPatternPolicy; delta: UsageDelta; now?: Date }) {
94
- if (!Number.isSafeInteger(input.runId) || input.runId <= 0) throw new Error('A valid run identifier is required.');
95
- if (!Number.isSafeInteger(input.patternId) || input.patternId <= 0)
96
- throw new Error('A valid pattern identifier is required.');
97
- const delta = normalizedDelta(input.delta);
98
- const date = bucketDate(input.now || new Date());
99
- return this.distributedLock.runExclusive(
100
- `agent-loop:budget:global:${date}`,
101
- () => this.reserveInTransaction(input, delta, date),
102
- 30_000,
103
- );
104
- }
105
-
106
- private async reserveInTransaction(
107
- input: { runId: number; patternId: number; policy: LoopPatternPolicy; delta: UsageDelta },
108
- delta: UsageTotals,
109
- date: string,
110
- ) {
111
- return this.database.sequelize.transaction(async (transaction) => {
112
- const controls = this.database.getRepository('agentLoopControlSettings');
113
- const control = await controls.findOne({
114
- filter: { key: 'global' },
115
- transaction,
116
- lock: transaction.LOCK.UPDATE,
117
- });
118
- if (!control) throw new Error('Global Loop Control settings were not found.');
119
- if (String(read(control, 'state')) !== 'running') {
120
- throw new Error(String(read(control, 'reason') || 'Loop Control Plane is not running.'));
121
- }
122
-
123
- const runs = this.database.getRepository('agentLoopRuns');
124
- const run = await runs.findOne({
125
- filterByTk: input.runId,
126
- transaction,
127
- lock: transaction.LOCK.UPDATE,
128
- });
129
- if (!run) throw new Error(`Agent loop run ${input.runId} was not found.`);
130
- if (String(read(run, 'runtimeVersion')) !== 'control-plane-v2') {
131
- throw new Error('Historical plan-era runs cannot consume Loop Control Plane budgets.');
132
- }
133
- if (Number(read(run, 'patternId')) !== input.patternId) {
134
- throw new Error(`Agent loop run ${input.runId} does not belong to pattern ${input.patternId}.`);
135
- }
136
-
137
- const buckets = this.database.getRepository('agentLoopUsageBuckets');
138
- let bucket = await buckets.findOne({
139
- filter: { patternId: input.patternId, bucketDate: date },
140
- transaction,
141
- lock: transaction.LOCK.UPDATE,
142
- });
143
- if (!bucket) {
144
- bucket = await buckets.create({
145
- values: { patternId: input.patternId, bucketDate: date },
146
- transaction,
147
- });
148
- }
149
- const dailyBuckets = await buckets.find({
150
- filter: { bucketDate: date },
151
- transaction,
152
- lock: transaction.LOCK.UPDATE,
153
- });
154
-
155
- this.assertRunBudget(run, input.policy, delta);
156
- this.assertDailyBudget(bucket, input.policy, delta);
157
- this.assertGlobalDailyBudget(dailyBuckets, control, delta);
158
- await runs.update({
159
- filterByTk: input.runId,
160
- values: {
161
- invocationCount: storedCount(read(run, 'invocationCount'), 'Run invocation') + delta.invocations,
162
- toolCallCount: storedCount(read(run, 'toolCallCount'), 'Run tool call') + delta.toolCalls,
163
- delegationCount: storedCount(read(run, 'delegationCount'), 'Run delegation') + delta.delegations,
164
- verificationCount: storedCount(read(run, 'verificationCount'), 'Run verification') + delta.verifications,
165
- totalInputTokens: storedCount(read(run, 'totalInputTokens'), 'Run input token') + delta.inputTokens,
166
- totalOutputTokens: storedCount(read(run, 'totalOutputTokens'), 'Run output token') + delta.outputTokens,
167
- totalTokens: storedCount(read(run, 'totalTokens'), 'Run total token') + delta.totalTokens,
168
- totalCost: storedCost(read(run, 'totalCost'), 'Run cost') + delta.cost,
169
- },
170
- transaction,
171
- });
172
- await buckets.update({
173
- filterByTk: read(bucket, 'id'),
174
- values: {
175
- invocationCount: storedCount(read(bucket, 'invocationCount'), 'Daily invocation') + delta.invocations,
176
- toolCallCount: storedCount(read(bucket, 'toolCallCount'), 'Daily tool call') + delta.toolCalls,
177
- delegationCount: storedCount(read(bucket, 'delegationCount'), 'Daily delegation') + delta.delegations,
178
- inputTokens: storedCount(read(bucket, 'inputTokens'), 'Daily input token') + delta.inputTokens,
179
- outputTokens: storedCount(read(bucket, 'outputTokens'), 'Daily output token') + delta.outputTokens,
180
- totalTokens: storedCount(read(bucket, 'totalTokens'), 'Daily total token') + delta.totalTokens,
181
- totalCost: storedCost(read(bucket, 'totalCost'), 'Daily cost') + delta.cost,
182
- },
183
- transaction,
184
- });
185
- return { reserved: delta, bucketDate: date };
186
- });
187
- }
188
-
189
- private assertRunBudget(run: Model, policy: LoopPatternPolicy, delta: UsageTotals) {
190
- const limits = policy.perRun;
191
- exceeds(
192
- storedCount(read(run, 'invocationCount'), 'Run invocation'),
193
- delta.invocations,
194
- limits.maxInvocations,
195
- 'Per-run invocation',
196
- );
197
- exceeds(
198
- storedCount(read(run, 'toolCallCount'), 'Run tool call'),
199
- delta.toolCalls,
200
- limits.maxToolCalls,
201
- 'Per-run tool call',
202
- );
203
- exceeds(
204
- storedCount(read(run, 'delegationCount'), 'Run delegation'),
205
- delta.delegations,
206
- limits.maxDelegations,
207
- 'Per-run delegation',
208
- );
209
- exceeds(
210
- storedCount(read(run, 'verificationCount'), 'Run verification'),
211
- delta.verifications,
212
- limits.maxVerifications,
213
- 'Per-run verification',
214
- );
215
- exceeds(
216
- storedCount(read(run, 'totalTokens'), 'Run total token'),
217
- delta.totalTokens,
218
- limits.maxTokens,
219
- 'Per-run token',
220
- );
221
- exceeds(storedCost(read(run, 'totalCost'), 'Run cost'), delta.cost, limits.maxCost, 'Per-run cost');
222
- }
223
-
224
- private assertDailyBudget(bucket: Model, policy: LoopPatternPolicy, delta: UsageTotals) {
225
- const limits = policy.daily;
226
- exceeds(
227
- storedCount(read(bucket, 'invocationCount'), 'Daily invocation'),
228
- delta.invocations,
229
- limits.maxInvocations,
230
- 'Daily invocation',
231
- );
232
- exceeds(
233
- storedCount(read(bucket, 'toolCallCount'), 'Daily tool call'),
234
- delta.toolCalls,
235
- limits.maxToolCalls,
236
- 'Daily tool call',
237
- );
238
- exceeds(
239
- storedCount(read(bucket, 'delegationCount'), 'Daily delegation'),
240
- delta.delegations,
241
- limits.maxDelegations,
242
- 'Daily delegation',
243
- );
244
- exceeds(
245
- storedCount(read(bucket, 'totalTokens'), 'Daily total token'),
246
- delta.totalTokens,
247
- limits.maxTokens,
248
- 'Daily token',
249
- );
250
- exceeds(storedCost(read(bucket, 'totalCost'), 'Daily cost'), delta.cost, limits.maxCost, 'Daily cost');
251
- }
252
-
253
- private assertGlobalDailyBudget(buckets: Model[], control: Model, delta: UsageTotals) {
254
- const currentTokens = buckets.reduce(
255
- (total, bucket) => total + storedCount(read(bucket, 'totalTokens'), 'Daily total token'),
256
- 0,
257
- );
258
- const currentCost = buckets.reduce(
259
- (total, bucket) => total + storedCost(read(bucket, 'totalCost'), 'Daily cost'),
260
- 0,
261
- );
262
- exceeds(
263
- currentTokens,
264
- delta.totalTokens,
265
- storedLimit(read(control, 'dailyMaxTokens'), 'Global daily token'),
266
- 'Global daily token',
267
- );
268
- exceeds(
269
- currentCost,
270
- delta.cost,
271
- storedLimit(read(control, 'dailyMaxCost'), 'Global daily cost'),
272
- 'Global daily cost',
273
- );
274
- }
275
- }
1
+ import type { Database, Model } from '@nocobase/database';
2
+ import type { LoopPatternPolicy } from './LoopPatternSchema';
3
+ import { read } from '../utils/record-utils';
4
+
5
+ export type UsageDelta = {
6
+ invocations?: number;
7
+ toolCalls?: number;
8
+ delegations?: number;
9
+ verifications?: number;
10
+ inputTokens?: number;
11
+ outputTokens?: number;
12
+ totalTokens?: number;
13
+ cost?: number;
14
+ };
15
+
16
+ type UsageTotals = Required<UsageDelta>;
17
+
18
+ function storedCount(value: unknown, label: string) {
19
+ if (value === null || value === undefined) return 0;
20
+ const parsed = Number(value);
21
+ if (!Number.isSafeInteger(parsed) || parsed < 0) throw new Error(`${label} counter is invalid.`);
22
+ return parsed;
23
+ }
24
+
25
+ function storedCost(value: unknown, label: string) {
26
+ if (value === null || value === undefined) return 0;
27
+ const parsed = Number(value);
28
+ if (!Number.isFinite(parsed) || parsed < 0) throw new Error(`${label} counter is invalid.`);
29
+ return parsed;
30
+ }
31
+
32
+ function deltaCount(value: unknown, label: string) {
33
+ if (value === null || value === undefined) return 0;
34
+ const parsed = Number(value);
35
+ if (!Number.isSafeInteger(parsed) || parsed < 0)
36
+ throw new Error(`${label} usage delta must be a nonnegative integer.`);
37
+ return parsed;
38
+ }
39
+
40
+ function deltaCost(value: unknown) {
41
+ if (value === null || value === undefined) return 0;
42
+ const parsed = Number(value);
43
+ if (!Number.isFinite(parsed) || parsed < 0) throw new Error('Cost usage delta must be a nonnegative finite number.');
44
+ return parsed;
45
+ }
46
+
47
+ function normalizedDelta(delta: UsageDelta): UsageTotals {
48
+ const result = {
49
+ invocations: deltaCount(delta.invocations, 'Invocation'),
50
+ toolCalls: deltaCount(delta.toolCalls, 'Tool call'),
51
+ delegations: deltaCount(delta.delegations, 'Delegation'),
52
+ verifications: deltaCount(delta.verifications, 'Verification'),
53
+ inputTokens: deltaCount(delta.inputTokens, 'Input token'),
54
+ outputTokens: deltaCount(delta.outputTokens, 'Output token'),
55
+ totalTokens: deltaCount(delta.totalTokens, 'Total token'),
56
+ cost: deltaCost(delta.cost),
57
+ };
58
+ result.totalTokens = Math.max(result.totalTokens, result.inputTokens + result.outputTokens);
59
+ return result;
60
+ }
61
+
62
+ function storedLimit(value: unknown, label: string) {
63
+ if (value === null || value === undefined) return null;
64
+ const parsed = Number(value);
65
+ if (!Number.isFinite(parsed) || parsed < 0) throw new Error(`${label} limit is invalid.`);
66
+ return parsed;
67
+ }
68
+
69
+ function exceeds(current: number, delta: number, limit: number | null, label: string) {
70
+ if (limit !== null && current + delta > limit) {
71
+ throw new Error(`${label} budget exceeded: ${current} + ${delta} > ${limit}.`);
72
+ }
73
+ }
74
+
75
+ function bucketDate(date: Date) {
76
+ return date.toISOString().slice(0, 10);
77
+ }
78
+
79
+ type DistributedLock = {
80
+ runExclusive<T>(key: string, operation: () => Promise<T>, ttl?: number): Promise<T>;
81
+ };
82
+
83
+ export class LoopBudgetService {
84
+ constructor(
85
+ private readonly database: Database,
86
+ private readonly distributedLock: DistributedLock,
87
+ ) {}
88
+
89
+ async reserve(input: { runId: number; patternId: number; policy: LoopPatternPolicy; delta: UsageDelta; now?: Date }) {
90
+ if (!Number.isSafeInteger(input.runId) || input.runId <= 0) throw new Error('A valid run identifier is required.');
91
+ if (!Number.isSafeInteger(input.patternId) || input.patternId <= 0)
92
+ throw new Error('A valid pattern identifier is required.');
93
+ const delta = normalizedDelta(input.delta);
94
+ const date = bucketDate(input.now || new Date());
95
+ return this.distributedLock.runExclusive(
96
+ `agent-loop:budget:global:${date}`,
97
+ () => this.reserveInTransaction(input, delta, date),
98
+ 30_000,
99
+ );
100
+ }
101
+
102
+ private async reserveInTransaction(
103
+ input: { runId: number; patternId: number; policy: LoopPatternPolicy; delta: UsageDelta },
104
+ delta: UsageTotals,
105
+ date: string,
106
+ ) {
107
+ return this.database.sequelize.transaction(async (transaction) => {
108
+ const controls = this.database.getRepository('agentLoopControlSettings');
109
+ const control = await controls.findOne({
110
+ filter: { key: 'global' },
111
+ transaction,
112
+ lock: transaction.LOCK.UPDATE,
113
+ });
114
+ if (!control) throw new Error('Global Loop Control settings were not found.');
115
+ if (String(read(control, 'state')) !== 'running') {
116
+ throw new Error(String(read(control, 'reason') || 'Loop Control Plane is not running.'));
117
+ }
118
+
119
+ const runs = this.database.getRepository('agentLoopRuns');
120
+ const run = await runs.findOne({
121
+ filterByTk: input.runId,
122
+ transaction,
123
+ lock: transaction.LOCK.UPDATE,
124
+ });
125
+ if (!run) throw new Error(`Agent loop run ${input.runId} was not found.`);
126
+ if (String(read(run, 'runtimeVersion')) !== 'control-plane-v2') {
127
+ throw new Error('Historical plan-era runs cannot consume Loop Control Plane budgets.');
128
+ }
129
+ if (Number(read(run, 'patternId')) !== input.patternId) {
130
+ throw new Error(`Agent loop run ${input.runId} does not belong to pattern ${input.patternId}.`);
131
+ }
132
+
133
+ const buckets = this.database.getRepository('agentLoopUsageBuckets');
134
+ let bucket = await buckets.findOne({
135
+ filter: { patternId: input.patternId, bucketDate: date },
136
+ transaction,
137
+ lock: transaction.LOCK.UPDATE,
138
+ });
139
+ if (!bucket) {
140
+ bucket = await buckets.create({
141
+ values: { patternId: input.patternId, bucketDate: date },
142
+ transaction,
143
+ });
144
+ }
145
+ const dailyBuckets = await buckets.find({
146
+ filter: { bucketDate: date },
147
+ transaction,
148
+ lock: transaction.LOCK.UPDATE,
149
+ });
150
+
151
+ this.assertRunBudget(run, input.policy, delta);
152
+ this.assertDailyBudget(bucket, input.policy, delta);
153
+ this.assertGlobalDailyBudget(dailyBuckets, control, delta);
154
+ await runs.update({
155
+ filterByTk: input.runId,
156
+ values: {
157
+ invocationCount: storedCount(read(run, 'invocationCount'), 'Run invocation') + delta.invocations,
158
+ toolCallCount: storedCount(read(run, 'toolCallCount'), 'Run tool call') + delta.toolCalls,
159
+ delegationCount: storedCount(read(run, 'delegationCount'), 'Run delegation') + delta.delegations,
160
+ verificationCount: storedCount(read(run, 'verificationCount'), 'Run verification') + delta.verifications,
161
+ totalInputTokens: storedCount(read(run, 'totalInputTokens'), 'Run input token') + delta.inputTokens,
162
+ totalOutputTokens: storedCount(read(run, 'totalOutputTokens'), 'Run output token') + delta.outputTokens,
163
+ totalTokens: storedCount(read(run, 'totalTokens'), 'Run total token') + delta.totalTokens,
164
+ totalCost: storedCost(read(run, 'totalCost'), 'Run cost') + delta.cost,
165
+ },
166
+ transaction,
167
+ });
168
+ await buckets.update({
169
+ filterByTk: read(bucket, 'id'),
170
+ values: {
171
+ invocationCount: storedCount(read(bucket, 'invocationCount'), 'Daily invocation') + delta.invocations,
172
+ toolCallCount: storedCount(read(bucket, 'toolCallCount'), 'Daily tool call') + delta.toolCalls,
173
+ delegationCount: storedCount(read(bucket, 'delegationCount'), 'Daily delegation') + delta.delegations,
174
+ inputTokens: storedCount(read(bucket, 'inputTokens'), 'Daily input token') + delta.inputTokens,
175
+ outputTokens: storedCount(read(bucket, 'outputTokens'), 'Daily output token') + delta.outputTokens,
176
+ totalTokens: storedCount(read(bucket, 'totalTokens'), 'Daily total token') + delta.totalTokens,
177
+ totalCost: storedCost(read(bucket, 'totalCost'), 'Daily cost') + delta.cost,
178
+ },
179
+ transaction,
180
+ });
181
+ return { reserved: delta, bucketDate: date };
182
+ });
183
+ }
184
+
185
+ private assertRunBudget(run: Model, policy: LoopPatternPolicy, delta: UsageTotals) {
186
+ const limits = policy.perRun;
187
+ exceeds(
188
+ storedCount(read(run, 'invocationCount'), 'Run invocation'),
189
+ delta.invocations,
190
+ limits.maxInvocations,
191
+ 'Per-run invocation',
192
+ );
193
+ exceeds(
194
+ storedCount(read(run, 'toolCallCount'), 'Run tool call'),
195
+ delta.toolCalls,
196
+ limits.maxToolCalls,
197
+ 'Per-run tool call',
198
+ );
199
+ exceeds(
200
+ storedCount(read(run, 'delegationCount'), 'Run delegation'),
201
+ delta.delegations,
202
+ limits.maxDelegations,
203
+ 'Per-run delegation',
204
+ );
205
+ exceeds(
206
+ storedCount(read(run, 'verificationCount'), 'Run verification'),
207
+ delta.verifications,
208
+ limits.maxVerifications,
209
+ 'Per-run verification',
210
+ );
211
+ exceeds(
212
+ storedCount(read(run, 'totalTokens'), 'Run total token'),
213
+ delta.totalTokens,
214
+ limits.maxTokens,
215
+ 'Per-run token',
216
+ );
217
+ exceeds(storedCost(read(run, 'totalCost'), 'Run cost'), delta.cost, limits.maxCost, 'Per-run cost');
218
+ }
219
+
220
+ private assertDailyBudget(bucket: Model, policy: LoopPatternPolicy, delta: UsageTotals) {
221
+ const limits = policy.daily;
222
+ exceeds(
223
+ storedCount(read(bucket, 'invocationCount'), 'Daily invocation'),
224
+ delta.invocations,
225
+ limits.maxInvocations,
226
+ 'Daily invocation',
227
+ );
228
+ exceeds(
229
+ storedCount(read(bucket, 'toolCallCount'), 'Daily tool call'),
230
+ delta.toolCalls,
231
+ limits.maxToolCalls,
232
+ 'Daily tool call',
233
+ );
234
+ exceeds(
235
+ storedCount(read(bucket, 'delegationCount'), 'Daily delegation'),
236
+ delta.delegations,
237
+ limits.maxDelegations,
238
+ 'Daily delegation',
239
+ );
240
+ exceeds(
241
+ storedCount(read(bucket, 'totalTokens'), 'Daily total token'),
242
+ delta.totalTokens,
243
+ limits.maxTokens,
244
+ 'Daily token',
245
+ );
246
+ exceeds(storedCost(read(bucket, 'totalCost'), 'Daily cost'), delta.cost, limits.maxCost, 'Daily cost');
247
+ }
248
+
249
+ private assertGlobalDailyBudget(buckets: Model[], control: Model, delta: UsageTotals) {
250
+ const currentTokens = buckets.reduce(
251
+ (total, bucket) => total + storedCount(read(bucket, 'totalTokens'), 'Daily total token'),
252
+ 0,
253
+ );
254
+ const currentCost = buckets.reduce(
255
+ (total, bucket) => total + storedCost(read(bucket, 'totalCost'), 'Daily cost'),
256
+ 0,
257
+ );
258
+ exceeds(
259
+ currentTokens,
260
+ delta.totalTokens,
261
+ storedLimit(read(control, 'dailyMaxTokens'), 'Global daily token'),
262
+ 'Global daily token',
263
+ );
264
+ exceeds(
265
+ currentCost,
266
+ delta.cost,
267
+ storedLimit(read(control, 'dailyMaxCost'), 'Global daily cost'),
268
+ 'Global daily cost',
269
+ );
270
+ }
271
+ }