@zq-silk/yui 0.2.0 → 0.4.2

package/dist/controller/runtimeEventProcessor.js

@@ -0,0 +1,248 @@
+/** Folds immutable Hook facts one at a time before acknowledging them. */
+export class FileRuntimeEventProcessor {
+    inbox;
+    observer;
+    options;
+    constructor(inbox, observer, options = {}) {
+        this.inbox = inbox;
+        this.observer = observer;
+        this.options = options;
+    }
+    drain(now) {
+        const acknowledgedEventIds = [];
+        const deferred = [];
+        const failed = [];
+        let events;
+        try {
+            events = this.inbox.list();
+        }
+        catch (error) {
+            return { acknowledgedEventIds, deferred, failed: [{ error }] };
+        }
+        for (const event of events) {
+            try {
+                if (event.type === "native-turn-completed") {
+                    const outcome = this.applyCodex(event, now);
+                    if (outcome === "deferred") {
+                        deferred.push(event);
+                        continue;
+                    }
+                }
+                else if (event.type === "claude-stop-failure") {
+                    this.applyClaudeStopFailure(event, now);
+                }
+                else if (event.type === "native-session-lifecycle") {
+                    const outcome = this.applySessionLifecycle(event, now);
+                    if (outcome === "deferred") {
+                        deferred.push(event);
+                        continue;
+                    }
+                }
+                else if (event.type === "native-turn-progress") {
+                    const outcome = this.applyProviderTurnProgress(event, now);
+                    if (outcome === "deferred") {
+                        deferred.push(event);
+                        continue;
+                    }
+                }
+                else {
+                    const outcome = this.applyPromptAccepted(event, now);
+                    if (outcome === "deferred") {
+                        deferred.push(event);
+                        continue;
+                    }
+                }
+                this.acknowledge(event.id, acknowledgedEventIds);
+            }
+            catch (error) {
+                failed.push({ eventId: event.id, error });
+            }
+        }
+        return { acknowledgedEventIds, deferred, failed };
+    }
+    applySessionLifecycle(event, now) {
+        const task = this.observer.getTask(event.taskId);
+        if (task === null || task.status !== "active")
+            return "obsolete";
+        if (this.observer.observeProviderSessionLifecycle === undefined)
+            return "obsolete";
+        const outcome = this.observer.observeProviderSessionLifecycle({
+            eventId: event.id,
+            taskId: event.taskId,
+            roleName: event.roleName,
+            agentId: event.agentId,
+            adapterId: event.adapterId,
+            launchId: event.launchId,
+            nativeSessionId: event.nativeSessionId,
+            ...(event.runId === undefined ? {} : { runId: event.runId }),
+            ...(event.sessionSource === undefined ? {} : { sessionSource: event.sessionSource })
+        }, now);
+        if (outcome === "applied") {
+            this.options.onTaskRuntimeApplied?.({
+                taskId: event.taskId,
+                roleName: event.roleName
+            });
+        }
+        return outcome === "deferred" ? "deferred" : outcome;
+    }
+    applyPromptAccepted(event, now) {
+        const task = this.observer.getTask(event.taskId);
+        if (task === null || task.status !== "active")
+            return "obsolete";
+        if (this.observer.observeProviderPromptAccepted === undefined)
+            return "obsolete";
+        const outcome = this.observer.observeProviderPromptAccepted({
+            eventId: event.id,
+            taskId: event.taskId,
+            roleName: event.roleName,
+            agentId: event.agentId,
+            adapterId: event.adapterId,
+            launchId: event.launchId,
+            nativeSessionId: event.nativeSessionId,
+            runId: event.runId,
+            receiptId: event.receiptId
+        }, now);
+        if (outcome === "applied") {
+            this.options.onTaskRuntimeApplied?.({
+                taskId: event.taskId,
+                roleName: event.roleName
+            });
+        }
+        return outcome === "deferred" ? "deferred" : outcome;
+    }
+    applyProviderTurnProgress(event, now) {
+        const task = this.observer.getTask(event.taskId);
+        if (task === null || task.status !== "active")
+            return "obsolete";
+        if (this.observer.observeProviderTurnProgress === undefined)
+            return "obsolete";
+        const outcome = this.observer.observeProviderTurnProgress({
+            eventId: event.id,
+            receivedAt: event.receivedAt,
+            taskId: event.taskId,
+            roleName: event.roleName,
+            agentId: event.agentId,
+            adapterId: event.adapterId,
+            launchId: event.launchId,
+            nativeSessionId: event.nativeSessionId,
+            runId: event.runId,
+            progressId: event.progressId,
+            ...(event.sequence === undefined ? {} : { sequence: event.sequence })
+        }, now);
+        return outcome === "deferred" ? "deferred" : "applied";
+    }
+    applyCodex(event, now) {
+        if (event.scope === "task") {
+            const task = this.observer.getTask(event.taskId);
+            const input = {
+                eventId: event.id,
+                taskId: event.taskId,
+                roleName: event.roleName,
+                agentId: event.agentId,
+                adapterId: event.adapterId,
+                ...(event.launchId === undefined ? {} : { launchId: event.launchId }),
+                nativeSessionId: event.nativeSessionId,
+                turnId: event.turnId,
+                ...(event.runId === undefined ? {} : { runId: event.runId }),
+                summary: event.summary
+            };
+            if (task === null)
+                return "obsolete";
+            if (task.status !== "active") {
+                this.recordObsolete(event, task.status === "archived" ? "task-archived" : "task-retired", now);
+                return "obsolete";
+            }
+            const disposition = this.observer.classifyRuntimeTurnCompleted?.(input) ?? "apply";
+            if (disposition === "deferred")
+                return disposition;
+            if (disposition === "obsolete") {
+                this.recordObsolete(event, "identity-mismatch-or-terminal", now);
+                return disposition;
+            }
+            const observed = this.observer.observeRuntimeTurnCompleted(input, now);
+            if (isObsoleteRuntimeTurnObservation(observed)) {
+                this.recordObsolete(event, "runtime-cleanup-or-stopped-session", now);
+                return "obsolete";
+            }
+            this.options.onTaskRuntimeApplied?.({
+                taskId: event.taskId,
+                roleName: event.roleName
+            });
+            return "applied";
+        }
+        const input = {
+            eventId: event.id,
+            roleName: event.roleName,
+            agentId: event.agentId,
+            adapterId: event.adapterId,
+            ...(event.launchId === undefined ? {} : { launchId: event.launchId }),
+            nativeSessionId: event.nativeSessionId,
+            turnId: event.turnId,
+            ...(event.title === undefined ? {} : { title: event.title }),
+            summary: event.summary
+        };
+        if (this.observer.classifyGlobalRuntimeTurnCompleted?.(input) !== "obsolete") {
+            this.observer.observeGlobalRuntimeTurnCompleted(input, now);
+            return "applied";
+        }
+        return "obsolete";
+    }
+    applyClaudeStopFailure(event, now) {
+        const task = this.observer.getTask(event.taskId);
+        if (task === null)
+            return;
+        const input = {
+            eventId: event.id,
+            type: event.type,
+            taskId: event.taskId,
+            roleName: event.roleName,
+            agentId: event.agentId,
+            adapterId: event.adapterId,
+            launchId: event.launchId,
+            nativeSessionId: event.nativeSessionId,
+            runId: event.runId,
+            error: event.error,
+            ...(event.errorDetails === undefined ? {} : { errorDetails: event.errorDetails }),
+            ...(event.lastAssistantMessage === undefined
+                ? {}
+                : { lastAssistantMessage: event.lastAssistantMessage })
+        };
+        if (task.status !== "active"
+            || this.observer.classifyClaudeStopFailureEvent?.(input) === "obsolete") {
+            this.recordObsolete(event, task.status === "archived"
+                ? "task-archived"
+                : task.status !== "active"
+                    ? "task-retired"
+                    : "identity-mismatch-or-terminal", now);
+            return;
+        }
+        if (this.observer.observeClaudeStopFailureEvent === undefined) {
+            throw new Error("Claude StopFailure observer is unavailable.");
+        }
+        this.observer.observeClaudeStopFailureEvent(input, now);
+    }
+    recordObsolete(event, reason, now) {
+        if (event.scope !== "task" || event.taskId === undefined)
+            return;
+        this.observer.observeObsoleteRuntimeEvent?.({
+            eventId: event.id,
+            eventType: event.type,
+            taskId: event.taskId,
+            roleName: event.roleName,
+            agentId: event.agentId,
+            ...(event.runId === undefined ? {} : { runId: event.runId }),
+            ...(event.launchId === undefined ? {} : { launchId: event.launchId }),
+            nativeSessionId: event.nativeSessionId,
+            reason
+        }, now);
+    }
+    acknowledge(id, acknowledged) {
+        this.inbox.acknowledge(id);
+        acknowledged.push(id);
+    }
+}
+function isObsoleteRuntimeTurnObservation(value) {
+    return typeof value === "object"
+        && value !== null
+        && value.disposition === "obsolete";
+}