plugin-agent-orchestrator 1.1.3 → 1.1.4
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/client/index.js +1 -1
- package/dist/client-v2/214.b063f33ba044a808.js +10 -0
- package/dist/client-v2/253.59577b40d9875be0.js +10 -0
- package/dist/client-v2/264.7ed8bee71fa5935c.js +10 -0
- package/dist/client-v2/{41.ba6e080cc0488143.js → 41.3deb9e57a0f64fc4.js} +1 -1
- package/dist/client-v2/418.58fa350f5496efd3.js +10 -0
- package/dist/client-v2/{53.7c29c28043e9112d.js → 53.9a10455323390f14.js} +1 -1
- package/dist/client-v2/619.0a2144aaffefe018.js +10 -0
- package/dist/client-v2/{70.bda9518881c05360.js → 70.ffff2997c10fd4b0.js} +1 -1
- package/dist/client-v2/{794.9bbb8d3a61b2bdf2.js → 794.a67a2614405ba627.js} +1 -1
- package/dist/client-v2/925.e5925bf21ed68e7a.js +10 -0
- package/dist/client-v2/{993.82778b6fd6db3cb1.js → 993.b0688fdc5ccb000a.js} +1 -1
- package/dist/client-v2/index.js +1 -1
- package/dist/externalVersion.js +8 -6
- package/dist/locale/en-US.json +48 -28
- package/dist/locale/vi-VN.json +48 -28
- package/dist/locale/zh-CN.json +48 -28
- package/dist/server/collections/agent-execution-spans.js +47 -0
- package/dist/server/collections/agent-harness-profile-versions.js +56 -0
- package/dist/server/collections/agent-harness-profiles.js +12 -0
- package/dist/server/collections/agent-loop-action-approvals.js +68 -0
- package/dist/server/collections/agent-loop-artifacts.js +55 -0
- package/dist/server/collections/agent-loop-circuit-states.js +53 -0
- package/dist/server/collections/agent-loop-control-settings.js +51 -0
- package/dist/server/collections/agent-loop-events.js +27 -0
- package/dist/server/collections/agent-loop-path-locks.js +57 -0
- package/dist/server/collections/agent-loop-patterns.js +72 -0
- package/dist/server/collections/agent-loop-runs.js +163 -2
- package/dist/server/collections/agent-loop-steps.js +69 -0
- package/dist/server/collections/agent-loop-usage-buckets.js +52 -0
- package/dist/server/collections/agent-loop-worktrees.js +55 -0
- package/dist/server/migrations/{20260427000000-change-packages-to-text.js → 20260427000002-change-packages-to-text.js} +2 -0
- package/dist/server/migrations/20260429000000-add-llm-fields.js +3 -2
- package/dist/server/migrations/{20260429000000-fix-inputargs-json-to-text.js → 20260429000001-fix-inputargs-json-to-text.js} +14 -6
- package/dist/server/migrations/20260503000000-add-orchestrator-trace-fields.js +2 -1
- package/dist/server/migrations/20260524000000-add-agent-loop-fields-to-skill-executions.js +2 -1
- package/dist/server/migrations/20260803010000-backfill-loop-control-plane-data.js +262 -0
- package/dist/server/plugin.js +52 -150
- package/dist/server/resources/agent-loop-approval.js +83 -0
- package/dist/server/resources/agent-loop-artifact.js +86 -0
- package/dist/server/resources/agent-loop-events-stream.js +130 -0
- package/dist/server/resources/agent-loop.js +181 -139
- package/dist/server/resources/resource-helpers.js +63 -0
- package/dist/server/resources/tracing.js +121 -107
- package/dist/server/services/DurableCircuitBreakerService.js +229 -0
- package/dist/server/services/HarnessCompiler.js +142 -0
- package/dist/server/services/HarnessProfileService.js +168 -0
- package/dist/server/services/HarnessSchema.js +167 -0
- package/dist/server/services/LoopBudgetService.js +269 -0
- package/dist/server/services/LoopControlService.js +139 -0
- package/dist/server/services/LoopPatternSchema.js +180 -0
- package/dist/server/services/LoopPatternService.js +132 -0
- package/dist/server/services/LoopRunRepository.js +205 -0
- package/dist/server/services/LoopRunStateMachine.js +389 -0
- package/dist/server/services/LoopSchedulerService.js +193 -0
- package/dist/server/services/LoopTriggerService.js +128 -0
- package/dist/server/services/LoopWorkerService.js +461 -0
- package/dist/server/services/PathLockService.js +288 -0
- package/dist/server/services/PluginAiRuntimeAdapter.js +215 -0
- package/dist/server/services/VerificationSchema.js +59 -0
- package/dist/server/services/VerificationService.js +169 -0
- package/dist/server/skill-hub/actions/git-import.js +13 -7
- package/dist/server/skill-hub/services/RegistrySkillSnapshotService.js +1 -5
- package/dist/server/utils/ensure-indexes.js +111 -0
- package/dist/server/utils/loop-pattern-context.js +56 -0
- package/package.json +1 -1
- package/src/client/OrchestratorSettings.tsx +44 -0
- package/src/client-v2/components/AgentRunsTab.tsx +576 -494
- package/src/client-v2/components/HarnessProfilesTab.tsx +13 -8
- package/src/client-v2/components/MemoryInspectorTab.tsx +19 -3
- package/src/client-v2/components/TracingTab.tsx +515 -432
- package/src/client-v2/hooks/useApiRequest.ts +141 -121
- package/src/client-v2/skill-hub/components/SkillMetrics.tsx +8 -6
- package/src/locale/en-US.json +52 -28
- package/src/locale/vi-VN.json +52 -28
- package/src/locale/zh-CN.json +52 -28
- package/src/server/__tests__/circuit-breaker.test.ts +225 -146
- package/src/server/__tests__/harness-compiler.test.ts +131 -0
- package/src/server/__tests__/harness-profile-service.test.ts +116 -0
- package/src/server/__tests__/harness-tool-plan.test.ts +148 -0
- package/src/server/__tests__/loop-budget-service.test.ts +255 -0
- package/src/server/__tests__/loop-control-plane-backfill.test.ts +266 -0
- package/src/server/__tests__/loop-pattern-schema.test.ts +56 -0
- package/src/server/__tests__/loop-pattern-service.test.ts +148 -0
- package/src/server/__tests__/loop-run-state-machine.test.ts +90 -0
- package/src/server/__tests__/loop-worker-claim.test.ts +341 -0
- package/src/server/__tests__/loop-worker-execution.test.ts +236 -0
- package/src/server/__tests__/path-lock-service.test.ts +254 -0
- package/src/server/__tests__/smoke.test.ts +62 -21
- package/src/server/collections/agent-execution-spans.ts +47 -0
- package/src/server/collections/agent-harness-profile-versions.ts +26 -0
- package/src/server/collections/agent-harness-profiles.ts +12 -0
- package/src/server/collections/agent-loop-action-approvals.ts +38 -0
- package/src/server/collections/agent-loop-artifacts.ts +25 -0
- package/src/server/collections/agent-loop-circuit-states.ts +23 -0
- package/src/server/collections/agent-loop-control-settings.ts +21 -0
- package/src/server/collections/agent-loop-events.ts +27 -0
- package/src/server/collections/agent-loop-path-locks.ts +27 -0
- package/src/server/collections/agent-loop-patterns.ts +42 -0
- package/src/server/collections/agent-loop-runs.ts +163 -2
- package/src/server/collections/agent-loop-steps.ts +69 -0
- package/src/server/collections/agent-loop-usage-buckets.ts +22 -0
- package/src/server/collections/agent-loop-worktrees.ts +25 -0
- package/src/server/migrations/{20260427000000-change-packages-to-text.ts → 20260427000002-change-packages-to-text.ts} +3 -0
- package/src/server/migrations/20260429000000-add-llm-fields.ts +3 -2
- package/src/server/migrations/{20260429000000-fix-inputargs-json-to-text.ts → 20260429000001-fix-inputargs-json-to-text.ts} +13 -6
- package/src/server/migrations/20260503000000-add-orchestrator-trace-fields.ts +2 -1
- package/src/server/migrations/20260524000000-add-agent-loop-fields-to-skill-executions.ts +2 -1
- package/src/server/migrations/20260803010000-backfill-loop-control-plane-data.ts +293 -0
- package/src/server/plugin.ts +53 -167
- package/src/server/resources/agent-loop-approval.ts +52 -0
- package/src/server/resources/agent-loop-artifact.ts +56 -0
- package/src/server/resources/agent-loop-events-stream.ts +105 -0
- package/src/server/resources/agent-loop.ts +202 -143
- package/src/server/resources/agent-monitor.ts +482 -482
- package/src/server/resources/resource-helpers.ts +33 -0
- package/src/server/resources/tracing.ts +145 -137
- package/src/server/services/DurableCircuitBreakerService.ts +239 -0
- package/src/server/services/HarnessCompiler.ts +133 -0
- package/src/server/services/HarnessProfileService.ts +157 -0
- package/src/server/services/HarnessSchema.ts +163 -0
- package/src/server/services/LoopBudgetService.ts +275 -0
- package/src/server/services/LoopControlService.ts +124 -0
- package/src/server/services/LoopPatternSchema.ts +167 -0
- package/src/server/services/LoopPatternService.ts +143 -0
- package/src/server/services/LoopRunRepository.ts +237 -0
- package/src/server/services/LoopRunStateMachine.ts +432 -0
- package/src/server/services/LoopSchedulerService.ts +199 -0
- package/src/server/services/LoopTriggerService.ts +115 -0
- package/src/server/services/LoopWorkerService.ts +522 -0
- package/src/server/services/PathLockService.ts +321 -0
- package/src/server/services/PluginAiRuntimeAdapter.ts +315 -0
- package/src/server/services/VerificationSchema.ts +31 -0
- package/src/server/services/VerificationService.ts +185 -0
- package/src/server/skill-hub/actions/__tests__/git-import.test.ts +15 -1
- package/src/server/skill-hub/actions/git-import.ts +9 -3
- package/src/server/skill-hub/services/RegistrySkillSnapshotService.ts +1 -5
- package/src/server/skill-hub/services/__tests__/RegistrySkillSnapshotService.test.ts +1 -3
- package/src/server/utils/ensure-indexes.ts +96 -0
- package/src/server/utils/logging.ts +0 -1
- package/src/server/utils/loop-pattern-context.ts +20 -0
- package/dist/client-v2/214.79650a549273f163.js +0 -10
- package/dist/client-v2/253.9f0537713cee9e6c.js +0 -10
- package/dist/client-v2/264.718a107e43fc163c.js +0 -10
- package/dist/client-v2/418.ce8f5b2b8a229d1d.js +0 -10
- package/dist/client-v2/619.bd3c5698b40705c3.js +0 -10
- package/dist/client-v2/925.f5370de8f6632d65.js +0 -10
- package/dist/server/services/AgentHarness.js +0 -81
- package/dist/server/services/AgentLoopController.js +0 -1023
- package/dist/server/services/AgentLoopRepository.js +0 -192
- package/dist/server/services/AgentLoopService.js +0 -142
- package/dist/server/services/AgentPlanValidator.js +0 -99
- package/dist/server/services/AgentPlannerService.js +0 -99
- package/dist/server/services/CircuitBreaker.js +0 -125
- package/dist/server/services/ContextAggregator.js +0 -201
- package/dist/server/services/PlanningPromptService.js +0 -95
- package/dist/server/tools/agent-loop.js +0 -373
- package/dist/server/tools/orchestrator-plan.js +0 -254
- package/src/server/__tests__/agent-loop-controller.test.ts +0 -375
- package/src/server/__tests__/context-aggregator.test.ts +0 -222
- package/src/server/__tests__/parallel-execution.test.ts +0 -318
- package/src/server/__tests__/planning-prompt-service.test.ts +0 -23
- package/src/server/services/AgentHarness.ts +0 -67
- package/src/server/services/AgentLoopController.ts +0 -1263
- package/src/server/services/AgentLoopRepository.ts +0 -178
- package/src/server/services/AgentLoopService.ts +0 -177
- package/src/server/services/AgentPlanValidator.ts +0 -73
- package/src/server/services/AgentPlannerService.ts +0 -80
- package/src/server/services/CircuitBreaker.ts +0 -126
- package/src/server/services/ContextAggregator.ts +0 -239
- package/src/server/services/PlanningPromptService.ts +0 -72
- package/src/server/tools/agent-loop.ts +0 -360
- package/src/server/tools/orchestrator-plan.ts +0 -255
|
@@ -0,0 +1,432 @@
|
|
|
1
|
+
import { randomUUID } from 'node:crypto';
|
|
2
|
+
import type { Database, Model, Transaction } from '@nocobase/database';
|
|
3
|
+
import { LoopControlService } from './LoopControlService';
|
|
4
|
+
import { loopPatternPolicySchema } from './LoopPatternSchema';
|
|
5
|
+
import { getRunEventBus } from './RunEventBus';
|
|
6
|
+
import { isPassingVerification } from './VerificationSchema';
|
|
7
|
+
|
|
8
|
+
export const loopRunStatuses = [
|
|
9
|
+
'queued',
|
|
10
|
+
'preparing',
|
|
11
|
+
'waiting_lock',
|
|
12
|
+
'running',
|
|
13
|
+
'waiting_approval',
|
|
14
|
+
'verifying',
|
|
15
|
+
'waiting_human',
|
|
16
|
+
'paused',
|
|
17
|
+
'blocked',
|
|
18
|
+
'succeeded',
|
|
19
|
+
'failed',
|
|
20
|
+
'canceled',
|
|
21
|
+
] as const;
|
|
22
|
+
|
|
23
|
+
export type LoopRunStatus = (typeof loopRunStatuses)[number];
|
|
24
|
+
|
|
25
|
+
const transitions: Record<LoopRunStatus, ReadonlySet<LoopRunStatus>> = {
|
|
26
|
+
queued: new Set(['preparing', 'paused', 'blocked', 'canceled']),
|
|
27
|
+
preparing: new Set(['queued', 'waiting_lock', 'running', 'paused', 'blocked', 'failed', 'canceled']),
|
|
28
|
+
waiting_lock: new Set(['preparing', 'paused', 'blocked', 'canceled']),
|
|
29
|
+
running: new Set(['queued', 'waiting_approval', 'verifying', 'paused', 'blocked', 'failed', 'canceled']),
|
|
30
|
+
waiting_approval: new Set(['running', 'waiting_human', 'paused', 'blocked', 'failed', 'canceled']),
|
|
31
|
+
verifying: new Set(['running', 'waiting_human', 'paused', 'blocked', 'succeeded', 'failed', 'canceled']),
|
|
32
|
+
waiting_human: new Set(['running', 'succeeded', 'failed', 'canceled']),
|
|
33
|
+
paused: new Set(['queued', 'preparing', 'running', 'waiting_approval', 'verifying', 'blocked', 'canceled']),
|
|
34
|
+
blocked: new Set(['queued', 'waiting_human', 'failed', 'canceled']),
|
|
35
|
+
succeeded: new Set(),
|
|
36
|
+
failed: new Set(['queued']),
|
|
37
|
+
canceled: new Set(),
|
|
38
|
+
};
|
|
39
|
+
|
|
40
|
+
export type TransitionInput = {
|
|
41
|
+
from: LoopRunStatus;
|
|
42
|
+
to: LoopRunStatus;
|
|
43
|
+
runtimeVersion?: string;
|
|
44
|
+
verifierEvidence?: unknown;
|
|
45
|
+
humanAccepted?: boolean;
|
|
46
|
+
};
|
|
47
|
+
|
|
48
|
+
export function assertRunTransition(input: TransitionInput) {
|
|
49
|
+
if (input.runtimeVersion && input.runtimeVersion !== 'control-plane-v2') {
|
|
50
|
+
throw new Error('Historical plan-era runs are read-only.');
|
|
51
|
+
}
|
|
52
|
+
if (input.from === input.to) {
|
|
53
|
+
throw new Error(`Run is already ${input.to}.`);
|
|
54
|
+
}
|
|
55
|
+
if (!transitions[input.from].has(input.to)) {
|
|
56
|
+
throw new Error(`Illegal run transition: ${input.from} -> ${input.to}.`);
|
|
57
|
+
}
|
|
58
|
+
if (input.to === 'succeeded') {
|
|
59
|
+
if (!isPassingVerification(input.verifierEvidence)) {
|
|
60
|
+
throw new Error('A run cannot succeed without a structured passing verifier verdict.');
|
|
61
|
+
}
|
|
62
|
+
if (input.from === 'waiting_human' && input.humanAccepted !== true) {
|
|
63
|
+
throw new Error('Human acceptance is required to finish a run waiting for human review.');
|
|
64
|
+
}
|
|
65
|
+
}
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
function read(record: Model | Record<string, unknown>, key: string) {
|
|
69
|
+
const model = record as Model & { get?: (name: string) => unknown };
|
|
70
|
+
return typeof model.get === 'function' ? model.get(key) : (record as Record<string, unknown>)[key];
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
function asStatus(value: unknown): LoopRunStatus {
|
|
74
|
+
if (typeof value === 'string' && (loopRunStatuses as readonly string[]).includes(value)) {
|
|
75
|
+
return value as LoopRunStatus;
|
|
76
|
+
}
|
|
77
|
+
throw new Error(`Unknown Loop Control Plane run status: ${String(value)}.`);
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
const activeExecutionStatuses: LoopRunStatus[] = ['preparing', 'running', 'verifying'];
|
|
81
|
+
const claimableStatuses: LoopRunStatus[] = ['queued', 'waiting_lock'];
|
|
82
|
+
|
|
83
|
+
function asDate(value: unknown): Date | null {
|
|
84
|
+
if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value;
|
|
85
|
+
if (typeof value === 'string' || typeof value === 'number') {
|
|
86
|
+
const parsed = new Date(value);
|
|
87
|
+
return Number.isNaN(parsed.getTime()) ? null : parsed;
|
|
88
|
+
}
|
|
89
|
+
return null;
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
function leaseIsExpired(record: Model | Record<string, unknown>, now: Date) {
|
|
93
|
+
const lockedUntil = asDate(read(record, 'lockedUntil'));
|
|
94
|
+
return !lockedUntil || lockedUntil.getTime() <= now.getTime();
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
function leaseOwner(record: Model | Record<string, unknown>) {
|
|
98
|
+
const owner = read(record, 'lockedBy');
|
|
99
|
+
return typeof owner === 'string' && owner.trim() ? owner : null;
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
// Only a run someone actually claimed can lose its lease. An active run with no owner still
|
|
103
|
+
// occupies a concurrency slot: requeueing it would dispatch work that may already be running.
|
|
104
|
+
function leaseIsReclaimable(record: Model | Record<string, unknown>, now: Date) {
|
|
105
|
+
return leaseOwner(record) !== null && leaseIsExpired(record, now);
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
function asPositiveInteger(value: unknown, label: string) {
|
|
109
|
+
const parsed = Number(value);
|
|
110
|
+
if (!Number.isSafeInteger(parsed) || parsed <= 0) throw new Error(`${label} is invalid.`);
|
|
111
|
+
return parsed;
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
function asPlain(record: Model | Record<string, unknown>) {
|
|
115
|
+
return typeof (record as Model).toJSON === 'function'
|
|
116
|
+
? ((record as Model).toJSON() as Record<string, unknown>)
|
|
117
|
+
: structuredClone(record as Record<string, unknown>);
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
export type ClaimedLoopRun = {
|
|
121
|
+
run: Record<string, unknown>;
|
|
122
|
+
leaseToken: string;
|
|
123
|
+
leaseUntil: Date;
|
|
124
|
+
};
|
|
125
|
+
|
|
126
|
+
export class LoopRunStateMachine {
|
|
127
|
+
private readonly control: LoopControlService;
|
|
128
|
+
|
|
129
|
+
constructor(private readonly database: Database) {
|
|
130
|
+
this.control = new LoopControlService(database);
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
async claimNext(workerId: string, leaseMs: number): Promise<ClaimedLoopRun | null> {
|
|
134
|
+
const normalizedWorkerId = workerId.trim();
|
|
135
|
+
if (!normalizedWorkerId) throw new Error('Worker identity is required.');
|
|
136
|
+
if (!Number.isSafeInteger(leaseMs) || leaseMs < 5_000) throw new Error('Worker lease must be at least 5000ms.');
|
|
137
|
+
|
|
138
|
+
const committed = await this.database.sequelize.transaction(async (transaction) => {
|
|
139
|
+
const control = await this.control.getForUpdate(transaction);
|
|
140
|
+
if (control.state !== 'running')
|
|
141
|
+
return { claimed: null, blockedEvents: [] as Array<{ runId: number; event: unknown }> };
|
|
142
|
+
|
|
143
|
+
const runs = this.database.getRepository('agentLoopRuns');
|
|
144
|
+
const now = new Date();
|
|
145
|
+
const reclaimedEvents: Array<{ runId: number; event: unknown }> = [];
|
|
146
|
+
|
|
147
|
+
// A worker that crashed mid-run leaves an active status behind with a lease that
|
|
148
|
+
// eventually expires. Those runs must be returned to the queue before concurrency is
|
|
149
|
+
// measured, otherwise each crash permanently consumes a slot.
|
|
150
|
+
const staleActive = await runs.find({
|
|
151
|
+
filter: { runtimeVersion: 'control-plane-v2', status: { $in: activeExecutionStatuses } },
|
|
152
|
+
transaction,
|
|
153
|
+
lock: transaction.LOCK.UPDATE,
|
|
154
|
+
});
|
|
155
|
+
for (const candidate of staleActive) {
|
|
156
|
+
if (!leaseIsReclaimable(candidate, now)) continue;
|
|
157
|
+
const runId = asPositiveInteger(read(candidate, 'id'), 'Run identifier');
|
|
158
|
+
const from = asStatus(read(candidate, 'status'));
|
|
159
|
+
assertRunTransition({
|
|
160
|
+
from,
|
|
161
|
+
to: 'queued',
|
|
162
|
+
runtimeVersion: String(read(candidate, 'runtimeVersion') || ''),
|
|
163
|
+
});
|
|
164
|
+
await runs.update({
|
|
165
|
+
filterByTk: runId,
|
|
166
|
+
values: { status: 'queued', lockedBy: null, lockedUntil: null },
|
|
167
|
+
transaction,
|
|
168
|
+
});
|
|
169
|
+
const event = await this.createEvent(
|
|
170
|
+
{
|
|
171
|
+
runId,
|
|
172
|
+
type: 'run_lease_expired',
|
|
173
|
+
title: 'Worker lease expired',
|
|
174
|
+
content: `Run returned to the queue after its ${from} worker lease expired.`,
|
|
175
|
+
status: 'queued',
|
|
176
|
+
payload: { from, previousOwner: read(candidate, 'lockedBy') ?? null },
|
|
177
|
+
actorType: 'system',
|
|
178
|
+
actorIdentity: normalizedWorkerId,
|
|
179
|
+
correlationKey: `lease-expired:${runId}:${String(read(candidate, 'lockedBy') || '')}`,
|
|
180
|
+
createdAt: now,
|
|
181
|
+
},
|
|
182
|
+
transaction,
|
|
183
|
+
);
|
|
184
|
+
reclaimedEvents.push({ runId, event });
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
const activeGlobal = await this.countActive(runs, {}, transaction, now);
|
|
188
|
+
if (activeGlobal >= control.globalMaxConcurrency) {
|
|
189
|
+
return { claimed: null, blockedEvents: reclaimedEvents };
|
|
190
|
+
}
|
|
191
|
+
|
|
192
|
+
const candidates = await runs.find({
|
|
193
|
+
filter: { runtimeVersion: 'control-plane-v2', status: { $in: claimableStatuses } },
|
|
194
|
+
sort: ['createdAt', 'id'],
|
|
195
|
+
limit: 100,
|
|
196
|
+
transaction,
|
|
197
|
+
lock: transaction.LOCK.UPDATE,
|
|
198
|
+
});
|
|
199
|
+
const blockedEvents: Array<{ runId: number; event: unknown }> = [...reclaimedEvents];
|
|
200
|
+
|
|
201
|
+
for (const candidate of candidates) {
|
|
202
|
+
const runId = asPositiveInteger(read(candidate, 'id'), 'Run identifier');
|
|
203
|
+
const patternId = Number(read(candidate, 'patternId'));
|
|
204
|
+
const pattern =
|
|
205
|
+
Number.isSafeInteger(patternId) && patternId > 0
|
|
206
|
+
? await this.database.getRepository('agentLoopPatterns').findOne({
|
|
207
|
+
filterByTk: patternId,
|
|
208
|
+
transaction,
|
|
209
|
+
lock: transaction.LOCK.UPDATE,
|
|
210
|
+
})
|
|
211
|
+
: null;
|
|
212
|
+
let blockedReason = '';
|
|
213
|
+
if (!Number.isSafeInteger(patternId) || patternId <= 0) blockedReason = 'Run has no valid pattern snapshot.';
|
|
214
|
+
else if (!pattern) blockedReason = 'Loop pattern was deleted.';
|
|
215
|
+
else if (read(pattern, 'enabled') !== true) blockedReason = 'Loop pattern is disabled.';
|
|
216
|
+
|
|
217
|
+
const parsedPolicy = loopPatternPolicySchema.safeParse(read(candidate, 'policySnapshot'));
|
|
218
|
+
if (!blockedReason && !parsedPolicy.success) blockedReason = 'Run policy snapshot is invalid.';
|
|
219
|
+
if (blockedReason) {
|
|
220
|
+
assertRunTransition({
|
|
221
|
+
from: asStatus(read(candidate, 'status')),
|
|
222
|
+
to: 'blocked',
|
|
223
|
+
runtimeVersion: String(read(candidate, 'runtimeVersion') || ''),
|
|
224
|
+
});
|
|
225
|
+
await runs.update({
|
|
226
|
+
filterByTk: runId,
|
|
227
|
+
values: { status: 'blocked', blockedReason, lockedBy: null, lockedUntil: null },
|
|
228
|
+
transaction,
|
|
229
|
+
});
|
|
230
|
+
const event = await this.createEvent(
|
|
231
|
+
{
|
|
232
|
+
runId,
|
|
233
|
+
type: 'run_blocked',
|
|
234
|
+
title: 'Run blocked',
|
|
235
|
+
content: blockedReason,
|
|
236
|
+
status: 'blocked',
|
|
237
|
+
payload: { reason: blockedReason },
|
|
238
|
+
actorType: 'worker',
|
|
239
|
+
actorIdentity: normalizedWorkerId,
|
|
240
|
+
correlationKey: `claim-blocked:${runId}`,
|
|
241
|
+
createdAt: now,
|
|
242
|
+
},
|
|
243
|
+
transaction,
|
|
244
|
+
);
|
|
245
|
+
blockedEvents.push({ runId, event });
|
|
246
|
+
continue;
|
|
247
|
+
}
|
|
248
|
+
|
|
249
|
+
const activePattern = await this.countActive(runs, { patternId }, transaction, now);
|
|
250
|
+
if (activePattern >= parsedPolicy.data.maxConcurrency) continue;
|
|
251
|
+
|
|
252
|
+
const leaseToken = `${normalizedWorkerId}:${randomUUID()}`;
|
|
253
|
+
const leaseUntil = new Date(now.getTime() + leaseMs);
|
|
254
|
+
assertRunTransition({
|
|
255
|
+
from: asStatus(read(candidate, 'status')),
|
|
256
|
+
to: 'preparing',
|
|
257
|
+
runtimeVersion: String(read(candidate, 'runtimeVersion') || ''),
|
|
258
|
+
});
|
|
259
|
+
await runs.update({
|
|
260
|
+
filterByTk: runId,
|
|
261
|
+
values: { status: 'preparing', blockedReason: null, lockedBy: leaseToken, lockedUntil: leaseUntil },
|
|
262
|
+
transaction,
|
|
263
|
+
});
|
|
264
|
+
const event = await this.createEvent(
|
|
265
|
+
{
|
|
266
|
+
runId,
|
|
267
|
+
type: 'run_claimed',
|
|
268
|
+
title: 'Run claimed',
|
|
269
|
+
content: `Run claimed by worker ${normalizedWorkerId}.`,
|
|
270
|
+
status: 'preparing',
|
|
271
|
+
payload: { workerId: normalizedWorkerId, leaseUntil: leaseUntil.toISOString() },
|
|
272
|
+
actorType: 'worker',
|
|
273
|
+
actorIdentity: normalizedWorkerId,
|
|
274
|
+
correlationKey: `claim:${leaseToken}`,
|
|
275
|
+
createdAt: now,
|
|
276
|
+
},
|
|
277
|
+
transaction,
|
|
278
|
+
);
|
|
279
|
+
return {
|
|
280
|
+
claimed: {
|
|
281
|
+
run: { ...asPlain(candidate), status: 'preparing', lockedBy: leaseToken, lockedUntil: leaseUntil },
|
|
282
|
+
leaseToken,
|
|
283
|
+
leaseUntil,
|
|
284
|
+
runId,
|
|
285
|
+
event,
|
|
286
|
+
},
|
|
287
|
+
blockedEvents,
|
|
288
|
+
};
|
|
289
|
+
}
|
|
290
|
+
return { claimed: null, blockedEvents };
|
|
291
|
+
});
|
|
292
|
+
|
|
293
|
+
for (const blocked of committed.blockedEvents) getRunEventBus().emit(blocked.runId, blocked.event);
|
|
294
|
+
if (!committed.claimed) return null;
|
|
295
|
+
getRunEventBus().emit(committed.claimed.runId, committed.claimed.event);
|
|
296
|
+
return {
|
|
297
|
+
run: committed.claimed.run,
|
|
298
|
+
leaseToken: committed.claimed.leaseToken,
|
|
299
|
+
leaseUntil: committed.claimed.leaseUntil,
|
|
300
|
+
};
|
|
301
|
+
}
|
|
302
|
+
|
|
303
|
+
async renewLease(runId: number, leaseToken: string, leaseMs: number) {
|
|
304
|
+
if (!leaseToken.trim()) throw new Error('Worker lease token is required.');
|
|
305
|
+
if (!Number.isSafeInteger(leaseMs) || leaseMs < 5_000) throw new Error('Worker lease must be at least 5000ms.');
|
|
306
|
+
return this.database.sequelize.transaction(async (transaction) => {
|
|
307
|
+
const runs = this.database.getRepository('agentLoopRuns');
|
|
308
|
+
const run = await runs.findOne({ filterByTk: runId, transaction, lock: transaction.LOCK.UPDATE });
|
|
309
|
+
if (!run || read(run, 'lockedBy') !== leaseToken)
|
|
310
|
+
throw new Error('Worker lease is no longer owned by this worker.');
|
|
311
|
+
if (String(read(run, 'runtimeVersion')) !== 'control-plane-v2')
|
|
312
|
+
throw new Error('Historical plan-era runs are read-only.');
|
|
313
|
+
if (!activeExecutionStatuses.includes(asStatus(read(run, 'status')))) {
|
|
314
|
+
throw new Error('Only actively executing runs can renew a worker lease.');
|
|
315
|
+
}
|
|
316
|
+
const leaseUntil = new Date(Date.now() + leaseMs);
|
|
317
|
+
await runs.update({ filterByTk: runId, values: { lockedUntil: leaseUntil }, transaction });
|
|
318
|
+
return leaseUntil;
|
|
319
|
+
});
|
|
320
|
+
}
|
|
321
|
+
|
|
322
|
+
async releaseLease(runId: number, leaseToken: string) {
|
|
323
|
+
if (!leaseToken.trim()) throw new Error('Worker lease token is required.');
|
|
324
|
+
return this.database.sequelize.transaction(async (transaction) => {
|
|
325
|
+
const runs = this.database.getRepository('agentLoopRuns');
|
|
326
|
+
const run = await runs.findOne({ filterByTk: runId, transaction, lock: transaction.LOCK.UPDATE });
|
|
327
|
+
if (!run) return false;
|
|
328
|
+
if (read(run, 'lockedBy') !== leaseToken) throw new Error('Worker lease is no longer owned by this worker.');
|
|
329
|
+
await runs.update({ filterByTk: runId, values: { lockedBy: null, lockedUntil: null }, transaction });
|
|
330
|
+
return true;
|
|
331
|
+
});
|
|
332
|
+
}
|
|
333
|
+
|
|
334
|
+
async transition(input: {
|
|
335
|
+
runId: number;
|
|
336
|
+
to: LoopRunStatus;
|
|
337
|
+
actorType: string;
|
|
338
|
+
actorIdentity: string;
|
|
339
|
+
eventType?: string;
|
|
340
|
+
title?: string;
|
|
341
|
+
content?: string;
|
|
342
|
+
correlationKey?: string;
|
|
343
|
+
leaseToken?: string;
|
|
344
|
+
values?: Record<string, unknown>;
|
|
345
|
+
humanAccepted?: boolean;
|
|
346
|
+
}) {
|
|
347
|
+
const committed = await this.database.sequelize.transaction(async (transaction) => {
|
|
348
|
+
const runs = this.database.getRepository('agentLoopRuns');
|
|
349
|
+
const run = await runs.findOne({
|
|
350
|
+
filterByTk: input.runId,
|
|
351
|
+
transaction,
|
|
352
|
+
lock: transaction.LOCK.UPDATE,
|
|
353
|
+
});
|
|
354
|
+
if (!run) throw new Error(`Agent loop run ${input.runId} was not found.`);
|
|
355
|
+
|
|
356
|
+
if (input.actorType === 'worker') {
|
|
357
|
+
if (!input.leaseToken?.trim() || read(run, 'lockedBy') !== input.leaseToken) {
|
|
358
|
+
throw new Error('Worker lease is no longer owned by this worker.');
|
|
359
|
+
}
|
|
360
|
+
if (leaseIsExpired(run, new Date())) throw new Error('Worker lease has expired.');
|
|
361
|
+
}
|
|
362
|
+
|
|
363
|
+
const from = asStatus(read(run, 'status'));
|
|
364
|
+
|
|
365
|
+
// The transition table permits `paused -> running/verifying` because that is how a human
|
|
366
|
+
// resumes a run. A worker must not use those edges: a run paused or canceled mid-invocation
|
|
367
|
+
// would otherwise be carried forward by the worker that was already executing it, and the
|
|
368
|
+
// pause would only take effect on the next claim.
|
|
369
|
+
if (input.actorType === 'worker' && !activeExecutionStatuses.includes(from)) {
|
|
370
|
+
throw new Error(`A worker cannot transition a run that is ${from}.`);
|
|
371
|
+
}
|
|
372
|
+
|
|
373
|
+
const verifierEvidence = input.values?.verifierEvidence ?? read(run, 'verifierEvidence');
|
|
374
|
+
assertRunTransition({
|
|
375
|
+
from,
|
|
376
|
+
to: input.to,
|
|
377
|
+
runtimeVersion: String(read(run, 'runtimeVersion') || ''),
|
|
378
|
+
verifierEvidence,
|
|
379
|
+
humanAccepted: input.humanAccepted,
|
|
380
|
+
});
|
|
381
|
+
|
|
382
|
+
const now = new Date();
|
|
383
|
+
await runs.update({
|
|
384
|
+
filterByTk: input.runId,
|
|
385
|
+
values: {
|
|
386
|
+
...(input.values || {}),
|
|
387
|
+
status: input.to,
|
|
388
|
+
...(input.to === 'running' && !read(run, 'startedAt') ? { startedAt: now } : {}),
|
|
389
|
+
...(['succeeded', 'failed', 'canceled'].includes(input.to) ? { endedAt: now } : {}),
|
|
390
|
+
},
|
|
391
|
+
transaction,
|
|
392
|
+
});
|
|
393
|
+
const event = await this.createEvent(
|
|
394
|
+
{
|
|
395
|
+
runId: input.runId,
|
|
396
|
+
type: input.eventType || 'run_status_changed',
|
|
397
|
+
title: input.title || `Run ${input.to}`,
|
|
398
|
+
content: input.content || `${from} -> ${input.to}`,
|
|
399
|
+
status: input.to,
|
|
400
|
+
payload: { from, to: input.to },
|
|
401
|
+
actorType: input.actorType,
|
|
402
|
+
actorIdentity: input.actorIdentity,
|
|
403
|
+
correlationKey: input.correlationKey,
|
|
404
|
+
createdAt: now,
|
|
405
|
+
},
|
|
406
|
+
transaction,
|
|
407
|
+
);
|
|
408
|
+
return { from, to: input.to, event };
|
|
409
|
+
});
|
|
410
|
+
|
|
411
|
+
getRunEventBus().emit(input.runId, committed.event);
|
|
412
|
+
return committed;
|
|
413
|
+
}
|
|
414
|
+
|
|
415
|
+
private async countActive(
|
|
416
|
+
runs: ReturnType<Database['getRepository']>,
|
|
417
|
+
filter: Record<string, unknown>,
|
|
418
|
+
transaction: Transaction,
|
|
419
|
+
now: Date,
|
|
420
|
+
) {
|
|
421
|
+
const rows = await runs.find({
|
|
422
|
+
filter: { ...filter, runtimeVersion: 'control-plane-v2', status: { $in: activeExecutionStatuses } },
|
|
423
|
+
transaction,
|
|
424
|
+
});
|
|
425
|
+
return rows.filter((row) => !leaseIsReclaimable(row, now)).length;
|
|
426
|
+
}
|
|
427
|
+
|
|
428
|
+
private async createEvent(values: Record<string, unknown>, transaction: Transaction) {
|
|
429
|
+
const record = await this.database.getRepository('agentLoopEvents').create({ values, transaction });
|
|
430
|
+
return typeof record.toJSON === 'function' ? record.toJSON() : record;
|
|
431
|
+
}
|
|
432
|
+
}
|
|
@@ -0,0 +1,199 @@
|
|
|
1
|
+
import type { Database, Model, Transaction } from '@nocobase/database';
|
|
2
|
+
import type { Application, Plugin } from '@nocobase/server';
|
|
3
|
+
import type { LoopPattern } from './LoopPatternSchema';
|
|
4
|
+
import { LoopPatternService } from './LoopPatternService';
|
|
5
|
+
import { LoopTriggerService } from './LoopTriggerService';
|
|
6
|
+
|
|
7
|
+
type ManagedCronJob = ReturnType<Application['cronJobManager']['addJob']>;
|
|
8
|
+
|
|
9
|
+
type ScheduledPattern = {
|
|
10
|
+
job: ManagedCronJob;
|
|
11
|
+
signature: string;
|
|
12
|
+
};
|
|
13
|
+
|
|
14
|
+
type TransactionOptions = {
|
|
15
|
+
transaction?: Transaction;
|
|
16
|
+
};
|
|
17
|
+
|
|
18
|
+
export type LoopSchedulerSyncMessage = {
|
|
19
|
+
type: 'loop-pattern-schedule-changed';
|
|
20
|
+
patternId: number;
|
|
21
|
+
};
|
|
22
|
+
|
|
23
|
+
function read(record: Model | Record<string, unknown>, key: string) {
|
|
24
|
+
const model = record as Model & { get?: (name: string) => unknown };
|
|
25
|
+
return typeof model.get === 'function' ? model.get(key) : (record as Record<string, unknown>)[key];
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
function positiveInteger(value: unknown) {
|
|
29
|
+
const parsed = Number(value);
|
|
30
|
+
return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
function isLockAcquireError(error: unknown) {
|
|
34
|
+
return error instanceof Error && error.constructor.name === 'LockAcquireError';
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
function tickDate(pattern: LoopPattern, now: Date) {
|
|
38
|
+
const fields = pattern.cronExpression?.split(/\s+/).filter(Boolean).length || 5;
|
|
39
|
+
const interval = fields === 6 ? 1_000 : 60_000;
|
|
40
|
+
return new Date(Math.floor(now.getTime() / interval) * interval);
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
export class LoopSchedulerService {
|
|
44
|
+
private readonly scheduled = new Map<number, ScheduledPattern>();
|
|
45
|
+
private started = false;
|
|
46
|
+
private installed = false;
|
|
47
|
+
|
|
48
|
+
constructor(
|
|
49
|
+
private readonly plugin: Plugin,
|
|
50
|
+
private readonly patterns: LoopPatternService,
|
|
51
|
+
private readonly triggers: LoopTriggerService,
|
|
52
|
+
) {}
|
|
53
|
+
|
|
54
|
+
install() {
|
|
55
|
+
if (this.installed) return;
|
|
56
|
+
this.installed = true;
|
|
57
|
+
this.plugin.db.on('agentLoopPatterns.afterCreate', this.onPatternChanged);
|
|
58
|
+
this.plugin.db.on('agentLoopPatterns.afterUpdate', this.onPatternChanged);
|
|
59
|
+
this.plugin.db.on('agentLoopPatterns.afterDestroy', this.onPatternChanged);
|
|
60
|
+
this.plugin.app.on('afterStart', this.start);
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
async dispose() {
|
|
64
|
+
if (!this.installed) return;
|
|
65
|
+
this.installed = false;
|
|
66
|
+
this.plugin.db.off('agentLoopPatterns.afterCreate', this.onPatternChanged);
|
|
67
|
+
this.plugin.db.off('agentLoopPatterns.afterUpdate', this.onPatternChanged);
|
|
68
|
+
this.plugin.db.off('agentLoopPatterns.afterDestroy', this.onPatternChanged);
|
|
69
|
+
this.plugin.app.off('afterStart', this.start);
|
|
70
|
+
this.stop();
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
readonly start = async () => {
|
|
74
|
+
if (this.started) return;
|
|
75
|
+
this.started = true;
|
|
76
|
+
await this.resyncAll();
|
|
77
|
+
};
|
|
78
|
+
|
|
79
|
+
stop() {
|
|
80
|
+
this.started = false;
|
|
81
|
+
for (const { job } of this.scheduled.values()) this.plugin.app.cronJobManager.removeJob(job);
|
|
82
|
+
this.scheduled.clear();
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
async handleSyncMessage(message: unknown) {
|
|
86
|
+
if (!message || typeof message !== 'object') return;
|
|
87
|
+
const value = message as Partial<LoopSchedulerSyncMessage>;
|
|
88
|
+
if (value.type !== 'loop-pattern-schedule-changed') return;
|
|
89
|
+
const patternId = positiveInteger(value.patternId);
|
|
90
|
+
if (!patternId) return;
|
|
91
|
+
await this.resyncPattern(patternId);
|
|
92
|
+
}
|
|
93
|
+
|
|
94
|
+
async resyncAll() {
|
|
95
|
+
if (!this.started) return;
|
|
96
|
+
const records = await this.plugin.db.getRepository('agentLoopPatterns').find({ fields: ['id'] });
|
|
97
|
+
const patternIds = new Set<number>();
|
|
98
|
+
for (const record of records) {
|
|
99
|
+
const patternId = positiveInteger(read(record, 'id'));
|
|
100
|
+
if (!patternId) continue;
|
|
101
|
+
patternIds.add(patternId);
|
|
102
|
+
await this.resyncPattern(patternId);
|
|
103
|
+
}
|
|
104
|
+
for (const patternId of this.scheduled.keys()) {
|
|
105
|
+
if (!patternIds.has(patternId)) this.remove(patternId);
|
|
106
|
+
}
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
async resyncPattern(patternId: number) {
|
|
110
|
+
if (!this.started) return;
|
|
111
|
+
const record = await this.plugin.db.getRepository('agentLoopPatterns').findOne({ filterByTk: patternId });
|
|
112
|
+
if (!record || read(record, 'enabled') !== true || read(record, 'triggerType') !== 'cron') {
|
|
113
|
+
this.remove(patternId);
|
|
114
|
+
return;
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
try {
|
|
118
|
+
const { pattern } = await this.patterns.get(patternId);
|
|
119
|
+
const signature = JSON.stringify([pattern.cronExpression, pattern.timezone]);
|
|
120
|
+
if (this.scheduled.get(patternId)?.signature === signature) return;
|
|
121
|
+
this.remove(patternId);
|
|
122
|
+
const job = this.plugin.app.cronJobManager.addJob({
|
|
123
|
+
cronTime: pattern.cronExpression as string,
|
|
124
|
+
timeZone: pattern.timezone as string,
|
|
125
|
+
onTick: () => this.onTick(patternId, pattern).catch((error) => this.logTickError(patternId, error)),
|
|
126
|
+
});
|
|
127
|
+
this.scheduled.set(patternId, { job, signature });
|
|
128
|
+
if (this.plugin.app.cronJobManager.started) job.start();
|
|
129
|
+
this.plugin.app.logger.info(`[AgentOrchestrator] Scheduled loop pattern ${pattern.key}.`, {
|
|
130
|
+
patternId,
|
|
131
|
+
cronExpression: pattern.cronExpression,
|
|
132
|
+
timezone: pattern.timezone,
|
|
133
|
+
});
|
|
134
|
+
} catch (error) {
|
|
135
|
+
this.remove(patternId);
|
|
136
|
+
this.plugin.app.logger.error(`[AgentOrchestrator] Loop pattern ${patternId} could not be scheduled.`, { error });
|
|
137
|
+
}
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
private readonly onPatternChanged = async (record: Model, options: TransactionOptions = {}) => {
|
|
141
|
+
const patternId = positiveInteger(read(record, 'id'));
|
|
142
|
+
if (!patternId) return;
|
|
143
|
+
const apply = async () => {
|
|
144
|
+
await this.resyncPattern(patternId);
|
|
145
|
+
await this.plugin.sendSyncMessage({ type: 'loop-pattern-schedule-changed', patternId });
|
|
146
|
+
};
|
|
147
|
+
if (options.transaction) {
|
|
148
|
+
// afterCommit does not await its callback, so a rejection here would be
|
|
149
|
+
// an unhandled promise. Catch and log so a failed resync/broadcast does
|
|
150
|
+
// not silently drop the schedule change.
|
|
151
|
+
options.transaction.afterCommit(() =>
|
|
152
|
+
apply().catch((error) =>
|
|
153
|
+
this.plugin.app.logger.error(
|
|
154
|
+
`[AgentOrchestrator] Failed to apply schedule change for loop pattern ${patternId} after commit.`,
|
|
155
|
+
{ error },
|
|
156
|
+
),
|
|
157
|
+
),
|
|
158
|
+
);
|
|
159
|
+
return;
|
|
160
|
+
}
|
|
161
|
+
await apply();
|
|
162
|
+
};
|
|
163
|
+
|
|
164
|
+
private async onTick(patternId: number, pattern: LoopPattern) {
|
|
165
|
+
const scheduledAt = tickDate(pattern, new Date());
|
|
166
|
+
const triggerKey = `cron:${pattern.key}:${scheduledAt.toISOString()}`;
|
|
167
|
+
let lock;
|
|
168
|
+
try {
|
|
169
|
+
lock = await this.plugin.app.lockManager.tryAcquire(
|
|
170
|
+
`agent-loop:schedule:${this.plugin.app.name}:${patternId}:${triggerKey}`,
|
|
171
|
+
);
|
|
172
|
+
} catch (error) {
|
|
173
|
+
if (isLockAcquireError(error)) return;
|
|
174
|
+
throw error;
|
|
175
|
+
}
|
|
176
|
+
|
|
177
|
+
await lock.runExclusive(async () => {
|
|
178
|
+
await this.triggers.enqueue({
|
|
179
|
+
patternId,
|
|
180
|
+
triggerType: 'cron',
|
|
181
|
+
triggerKey,
|
|
182
|
+
triggerPayload: { scheduledAt: scheduledAt.toISOString(), timezone: pattern.timezone },
|
|
183
|
+
});
|
|
184
|
+
}, 60_000);
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
private remove(patternId: number) {
|
|
188
|
+
const existing = this.scheduled.get(patternId);
|
|
189
|
+
if (!existing) return;
|
|
190
|
+
this.plugin.app.cronJobManager.removeJob(existing.job);
|
|
191
|
+
this.scheduled.delete(patternId);
|
|
192
|
+
}
|
|
193
|
+
|
|
194
|
+
private logTickError(patternId: number, error: unknown) {
|
|
195
|
+
this.plugin.app.logger.error(`[AgentOrchestrator] Scheduled loop pattern ${patternId} failed to enqueue.`, {
|
|
196
|
+
error,
|
|
197
|
+
});
|
|
198
|
+
}
|
|
199
|
+
}
|