@zq-silk/yui 0.6.5 → 0.6.6

package/dist/controller/agentRuntimeObserver.js

@@ -1,6 +1,8 @@
 import { createHash } from "node:crypto";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
 import { createRuntimeObservation, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
+const DEFAULT_MAX_CONCURRENT_SAMPLES = 8;
+const MAX_CONCURRENT_SAMPLES = 64;
 /**
  * Controller-owned, provider-independent sampler. Drivers own source parsing;
  * this component owns active-Run discovery, cursor lifetime, canonical event
@@ -11,11 +13,13 @@ export class AgentRuntimeObserver {
     inbox;
     drivers;
     #states = new Map();
+    #maxConcurrentSamples;
     #sequence = 0;
-    constructor(store, inbox, drivers = builtinAgentDriverRegistry()) {
+    constructor(store, inbox, drivers = builtinAgentDriverRegistry(), options = {}) {
         this.store = store;
         this.inbox = inbox;
         this.drivers = drivers;
+        this.#maxConcurrentSamples = sampleConcurrency(options.maxConcurrentSamples);
     }
     async sample(now = new Date()) {
         const active = this.activeSources();
@@ -25,7 +29,9 @@ export class AgentRuntimeObserver {
                 this.#states.delete(key);
         }
         const dirty = new Set();
-        await Promise.all(active.map(async ({ key, fence, source, freshSession, persistedState }) => {
+        const sequenceBase = this.#sequence;
+        this.#sequence += active.length;
+        await forEachConcurrent(active, this.#maxConcurrentSamples, async ({ key, fence, source, freshSession, persistedState }, index) => {
             const existingState = this.#states.get(key);
             // Cursor state is intentionally process-local, but the latest canonical
             // usage/activity baseline is durable. Rehydrate it after Controller
@@ -49,7 +55,10 @@ export class AgentRuntimeObserver {
             }
             state.cursor = sample.cursor;
             const at = now.toISOString();
-            const sequence = this.#sequence++;
+            // Reserve sequence numbers in source-key order before sampling. Provider
+            // latency can change completion order without changing observation
+            // identity or the canonical sequence assigned to a source.
+            const sequence = sequenceBase + index;
             if (existingState === undefined && freshSession && state.usage === undefined) {
                 const zero = Object.freeze({ inputTokens: 0, outputTokens: 0 });
                 this.inbox.enqueueObservation(createRuntimeObservation({
@@ -114,28 +123,52 @@ export class AgentRuntimeObserver {
             if (sample.activityId !== undefined)
                 state.activityId = sample.activityId;
             this.#states.set(key, state);
-        }));
-        return Object.freeze([...dirty].sort());
+        });
+        return Object.freeze([...dirty].sort(numericCompare));
     }
     activeSources() {
         const result = [];
-        for (const task of this.store.listTasks()) {
-            if (task.status !== "active")
-                continue;
-            const observations = this.store.listEvents(task.id)
-                .map(runtimeObservationFromTaskEvent)
-                .filter((value) => value !== null);
+        const indexedTaskIds = this.store.listActiveTaskIds?.();
+        // FileTaskStore remains a development/compatibility fallback. The normal
+        // Controller store is SQLite and must discover only its indexed hot set.
+        const activeTasks = indexedTaskIds === undefined
+            ? this.store.listTasks().filter((task) => task.status === "active")
+            : [...new Set(indexedTaskIds)]
+                .sort(numericCompare)
+                .map((taskId) => this.store.getTask(taskId))
+                .filter((task) => (task !== null && task.status === "active"));
+        for (const task of activeTasks) {
+            // A Task still incurs one O(E) event projection. Group those observations
+            // by Run and sort each group once so every active Run can reuse the same
+            // ordered slice instead of repeatedly filtering/sorting all E events.
+            const observationsByRunId = new Map();
+            for (const event of this.store.listEvents(task.id)) {
+                const observation = runtimeObservationFromTaskEvent(event);
+                const runId = observation?.fence.runId;
+                if (observation === null || runId === undefined)
+                    continue;
+                const grouped = observationsByRunId.get(runId);
+                if (grouped === undefined) {
+                    observationsByRunId.set(runId, [observation]);
+                }
+                else {
+                    grouped.push(observation);
+                }
+            }
+            for (const observations of observationsByRunId.values()) {
+                observations.sort(compareObservations);
+            }
             for (const run of this.store.listAgentRuns(task.id)) {
                 if (run.status !== "active"
                     || this.store.getActiveAgentRun(task.id, run.roleName)?.id !== run.id)
                     continue;
+                const observations = observationsByRunId.get(run.id) ?? [];
                 const accepted = observations
                     .filter((observation) => observation.kind === "turn.accepted"
                     && observation.fence.runId === run.id
                     && observation.fence.roleName === run.roleName
                     && observation.fence.agentId === run.effective.agentId
                     && observation.payload.observerSource !== undefined)
-                    .sort(compareObservations)
                     .at(-1);
                 const source = accepted?.payload.observerSource;
                 if (accepted === undefined || source === undefined
@@ -150,19 +183,23 @@ export class AgentRuntimeObserver {
                 }
                 const fence = accepted.fence;
                 const exact = observations
-                    .filter((observation) => runtimeObservationFenceMatches(fence, observation.fence))
-                    .sort(compareObservations);
+                    .filter((observation) => runtimeObservationFenceMatches(fence, observation.fence));
                 const persistedUsage = exact.filter((observation) => (observation.kind === "activity.observed"
                     && observation.payload.usage !== undefined)).at(-1);
                 const persistedHealth = exact.filter((observation) => (observation.kind === "observer.health"
                     && observation.payload.sourceId === source.sourceId)).at(-1);
                 result.push(Object.freeze({
                     key: JSON.stringify([
+                        fence.taskId,
+                        fence.roleName,
+                        fence.runId,
+                        fence.agentId,
                         fence.driverId,
+                        fence.launchId,
                         fence.sessionGenerationId,
                         fence.nativeSessionId,
                         fence.nativeTurnId,
-                        fence.runId,
+                        fence.receiptId,
                         source.sourceId
                     ]),
                     fence,
@@ -187,8 +224,31 @@ export class AgentRuntimeObserver {
                 }));
             }
         }
-        return result;
+        return Object.freeze(result.sort((left, right) => numericCompare(left.key, right.key)));
+    }
+}
+async function forEachConcurrent(values, limit, visit) {
+    let nextIndex = 0;
+    const workers = Math.min(limit, values.length);
+    await Promise.all(Array.from({ length: workers }, async () => {
+        while (nextIndex < values.length) {
+            const index = nextIndex;
+            nextIndex += 1;
+            await visit(values[index], index);
+        }
+    }));
+}
+function sampleConcurrency(value) {
+    const resolved = value ?? DEFAULT_MAX_CONCURRENT_SAMPLES;
+    if (!Number.isSafeInteger(resolved)
+        || resolved < 1
+        || resolved > MAX_CONCURRENT_SAMPLES) {
+        throw new Error(`Agent runtime observer maxConcurrentSamples must be between 1 and ${MAX_CONCURRENT_SAMPLES}.`);
     }
+    return resolved;
+}
+function numericCompare(left, right) {
+    return left.localeCompare(right, undefined, { numeric: true });
 }
 function compareObservations(left, right) {
     return left.receivedAt.localeCompare(right.receivedAt)