@myagentroam/agent 0.11.34 → 0.11.35

package/dist/subagent/session-controller.js

@@ -4,295 +4,8 @@ import { randomUUID } from 'node:crypto';
 import { AgentError, describeAgentError } from '../error.js';
 import { SUBAGENT_LIMITS } from './limits.js';
 import { parseAgentWaitTargets, SubagentWaitCoordinator, waitForAgentGroup } from './wait.js';
+import { SubagentTask, observeAgentEvent } from './task.js';
 const RECENT_TERMINAL_RESOURCE_LIMIT = 16;
-/** Owns the mutable state and transitions of one child task. */
-class SubagentTask {
-    state;
-    get detailsEvicted() {
-        return this.state.detailsEvicted;
-    }
-    get restorable() {
-        return this.state.restorable;
-    }
-    get permissionStop() {
-        return this.state.permissionStop;
-    }
-    get agentId() {
-        return this.state.agentId;
-    }
-    get description() {
-        return this.state.description;
-    }
-    get role() {
-        return this.state.role;
-    }
-    get ownerInstanceId() {
-        return this.state.ownerInstanceId;
-    }
-    get extensionId() {
-        return this.state.extensionId;
-    }
-    get status() {
-        return this.state.status;
-    }
-    get modelId() {
-        return this.state.modelId;
-    }
-    get modelName() {
-        return this.state.modelName;
-    }
-    get reasoningEffort() {
-        return this.state.reasoningEffort;
-    }
-    get latestMessage() {
-        return this.state.latestMessage;
-    }
-    get latestActivity() {
-        return this.state.latestActivity;
-    }
-    get messageRevision() {
-        return this.state.messageRevision;
-    }
-    get observedMessageRevision() {
-        return this.state.observedMessageRevision;
-    }
-    get latestMessageActivityRevision() {
-        return this.state.latestMessageActivityRevision;
-    }
-    get summary() {
-        return this.state.summary;
-    }
-    get changedFiles() {
-        return this.state.changedFiles;
-    }
-    get verification() {
-        return this.state.verification;
-    }
-    get evidence() {
-        return this.state.evidence;
-    }
-    get errorCode() {
-        return this.state.errorCode;
-    }
-    get errorMessage() {
-        return this.state.errorMessage;
-    }
-    get terminalPending() {
-        return this.state.terminalPending;
-    }
-    get observedTerminalRevision() {
-        return this.state.observedTerminalRevision;
-    }
-    get terminalRevision() {
-        return this.state.terminalRevision;
-    }
-    get resourceRevision() {
-        return this.state.resourceRevision;
-    }
-    get turn() {
-        return this.state.turn;
-    }
-    get controlTail() {
-        return this.state.controlTail;
-    }
-    get receipt() {
-        return this.state.receipt;
-    }
-    constructor(state) {
-        this.state = state;
-    }
-    acknowledgeMessage(revision) {
-        this.state.observedMessageRevision = Math.max(this.state.observedMessageRevision, revision);
-    }
-    acknowledgeTerminal(revision) {
-        this.state.observedTerminalRevision = Math.max(this.state.observedTerminalRevision, revision);
-    }
-    selectModel(model) {
-        this.state.modelId = model.id;
-        this.state.modelName = model.name;
-        if (model.reasoningEffort !== undefined)
-            this.state.reasoningEffort = model.reasoningEffort;
-    }
-    setReceipt(receipt) {
-        this.state.receipt = receipt;
-    }
-    updateDelivery(receipt, status) {
-        if (status !== 'applied' && receipt.deliveryStatus !== 'accepted')
-            return false;
-        receipt.deliveryStatus = status;
-        return true;
-    }
-    requestCancel(expected) {
-        const turn = this.state.turn;
-        if (turn !== expected)
-            return;
-        if (turn.handle)
-            turn.handle.cancel();
-        else
-            turn.cancelRequested = true;
-    }
-    attachHandle(expected, handle) {
-        const turn = this.state.turn;
-        if (turn !== expected)
-            return;
-        turn.handle = handle;
-    }
-    cancelPending(expected) {
-        const turn = this.state.turn;
-        if (turn === expected && turn.cancelRequested)
-            turn.handle.cancel();
-    }
-    takePendingMessages(expected) {
-        const turn = this.state.turn;
-        return turn === expected ? turn.pendingMessages.splice(0) : [];
-    }
-    settleHandleReady(expected) {
-        if (this.state.turn === expected)
-            this.state.turn.resolveHandleReady();
-    }
-    settleCompletion(expected) {
-        if (this.state.turn === expected)
-            this.state.turn.resolve();
-    }
-    appendMessage(message) {
-        this.state.turn.pendingMessages.push(message);
-    }
-    control(operation) {
-        const result = (this.state.controlTail ?? Promise.resolve()).then(operation);
-        const tail = result.then(() => undefined, () => undefined);
-        this.state.controlTail = tail;
-        void tail.then(() => {
-            if (this.state.controlTail === tail)
-                delete this.state.controlTail;
-        });
-        return result;
-    }
-    cancelQueued(publish) {
-        this.state.status = 'cancelled';
-        if (publish)
-            this.state.terminalPending = true;
-    }
-    queueTurn(input, onComplete) {
-        let resolve;
-        let resolveHandleReady;
-        const completion = new Promise((done) => (resolve = done));
-        const handleReady = new Promise((done) => (resolveHandleReady = done));
-        const turn = {
-            ...input,
-            handleReady,
-            completion,
-            resolve: () => {
-                onComplete();
-                resolve();
-            },
-            resolveHandleReady
-        };
-        this.state.status = 'queued';
-        this.state.restorable = false;
-        delete this.state.summary;
-        delete this.state.permissionStop;
-        delete this.state.errorCode;
-        delete this.state.errorMessage;
-        this.state.changedFiles = [];
-        this.state.verification = [];
-        this.state.evidence = [];
-        this.state.terminalPending = false;
-        this.state.turn = turn;
-        return turn;
-    }
-    markRunning() {
-        this.state.status = 'running';
-    }
-    clearTurn(expected) {
-        if (expected === undefined || this.state.turn === expected)
-            delete this.state.turn;
-    }
-    observeEvent(event, revision) {
-        if (!observeAgentEvent(this.state, event))
-            return false;
-        this.state.messageRevision++;
-        this.state.latestMessageActivityRevision = revision;
-        return true;
-    }
-    complete(result, terminal, persisted, previousActivity, previousRevision) {
-        if (result.status === 'completed') {
-            this.state.status = 'completed';
-            this.state.summary = result.finalAnswer;
-            if (result.permissionStop)
-                this.state.permissionStop = result.permissionStop;
-            else
-                delete this.state.permissionStop;
-        }
-        else if (result.status === 'cancelled')
-            this.state.status = 'cancelled';
-        else {
-            this.state.status = 'failed';
-            this.state.errorCode = result.errorCode ?? 'MAR_AGENT_SUBAGENT_FAILED';
-            this.state.errorMessage = result.errorMessage ?? 'Subagent execution failed.';
-        }
-        this.state.restorable =
-            persisted &&
-                terminal === this.state.status &&
-                (previousActivity === undefined || this.state.latestActivity !== previousActivity) &&
-                (this.state.latestMessage === undefined || this.state.messageRevision > previousRevision) &&
-                (this.state.status !== 'completed' ||
-                    (this.state.latestMessage?.phase === 'final_answer' &&
-                        this.state.summary === this.state.latestMessage.text));
-        this.state.terminalPending = true;
-    }
-    fail(error) {
-        const diagnostic = describeAgentError(error, 'MAR_AGENT_SUBAGENT_FAILED');
-        this.state.status = 'failed';
-        this.state.restorable = false;
-        this.state.errorCode = diagnostic.code;
-        this.state.errorMessage = diagnostic.message;
-        this.state.terminalPending = true;
-    }
-    touch(revision, terminal = false) {
-        this.state.resourceRevision = revision;
-        if (terminal)
-            this.state.terminalRevision = revision;
-    }
-    terminalPublished(revision) {
-        if (this.state.terminalRevision === revision)
-            this.state.terminalPending = false;
-    }
-    evictDetails() {
-        for (const key of DETAIL_FIELDS)
-            delete this.state[key];
-        this.state.changedFiles = [];
-        this.state.verification = [];
-        this.state.evidence = [];
-        this.state.detailsEvicted = true;
-    }
-    restoreDetails(restored) {
-        for (const key of DETAIL_FIELDS) {
-            if (key in restored)
-                Object.assign(this.state, { [key]: restored[key] });
-            else
-                delete this.state[key];
-        }
-        delete this.state.detailsEvicted;
-    }
-    copyWaitState() {
-        return {
-            ...this.state,
-            changedFiles: [...this.state.changedFiles],
-            verification: [...this.state.verification],
-            evidence: this.state.evidence.map((item) => ({ ...item }))
-        };
-    }
-}
-const DETAIL_FIELDS = [
-    'latestMessage',
-    'latestActivity',
-    'summary',
-    'changedFiles',
-    'verification',
-    'evidence',
-    'permissionStop',
-    'errorMessage'
-];
 export class SubagentSessionController {
     parentSessionId;
     rootSessionId;
@@ -872,20 +585,24 @@ export class SubagentSessionController {
                 options.signal?.throwIfAborted();
                 // Resolve before cancelling so an unavailable model does not stop valid work.
                 const selected = resolveExistingModel(execution, state);
-                if (options.delivery === 'replace')
-                    await this.#cancelState(state);
-                this.#requireExecution();
-                options.signal?.throwIfAborted();
                 const turnId = state.turn?.turnId ?? randomUUID();
                 const receipt = { messageId: randomUUID(), turnId, deliveryStatus: 'accepted' };
                 const mutableReceipt = receipt;
-                const delivery = this.#createDelivery(state, execution, mutableReceipt, options.signal);
+                const { delivery, waitSignal } = this.#createDelivery(state, execution, mutableReceipt, options.signal);
                 try {
+                    const sendSignal = options.signal === undefined
+                        ? waitSignal
+                        : AbortSignal.any([waitSignal, options.signal]);
+                    sendSignal.throwIfAborted();
+                    if (options.delivery === 'replace')
+                        await waitForPromise(this.#cancelState(state), sendSignal);
+                    this.#requireExecution();
+                    sendSignal.throwIfAborted();
+                    if (state.turn && state.status !== 'running' && state.status !== 'queued') {
+                        await waitForPromise(state.turn.completion, sendSignal);
+                    }
                     if (state.status === 'running' && state.turn) {
                         const turn = state.turn;
-                        const sendSignal = delivery.signal && options.signal
-                            ? AbortSignal.any([delivery.signal, options.signal])
-                            : (delivery.signal ?? options.signal);
                         if (!turn.handle)
                             await waitForPromise(turn.handleReady, sendSignal);
                         this.#requireExecution();
@@ -949,10 +666,9 @@ export class SubagentSessionController {
             this.#touchResource(state, true);
             this.#closeReceipt(state);
             await this.#publishTerminal(state);
-            state.settleHandleReady(turn);
-            state.settleCompletion(turn);
+            state.settleQueuedTurn(turn);
             this.#notifyCompletion(state);
-            state.clearTurn(turn);
+            state.releaseTurn(turn);
             this.#drain();
         }
         else if (state.status === 'running' && state.turn) {
@@ -991,12 +707,11 @@ export class SubagentSessionController {
             state.cancelQueued(false);
             this.#closeReceipt(state);
             if (turn) {
-                state.settleHandleReady(turn);
-                state.settleCompletion(turn);
+                state.settleQueuedTurn(turn);
             }
             this.#notifyCompletion(state);
             if (turn)
-                state.clearTurn(turn);
+                state.releaseTurn(turn);
         }
         for (const state of this.#agents.values()) {
             if (state.status !== 'running' || !state.turn)
@@ -1048,96 +763,43 @@ export class SubagentSessionController {
         while (!this.#disposed && this.#running < this.limits.maxConcurrent && this.#queue.length > 0) {
             const state = this.#queue.shift();
             const turn = state.turn;
-            if (!turn || state.status !== 'queued')
+            if (!turn || !state.markRunning(turn))
                 continue;
-            state.markRunning();
             this.#touchResource(state);
             this.#running++;
             void this.#startAndConsumeTurn(state, turn);
         }
     }
     async #startAndConsumeTurn(state, turn) {
-        try {
-            const handle = await turn.start({
-                turnId: turn.turnId,
-                ...(turn.delivery === undefined ? {} : { delivery: turn.delivery }),
-                ...(turn.origin === undefined ? {} : { origin: turn.origin }),
-                sessionId: state.agentId,
-                prompt: turn.prompt,
-                modelId: state.modelId,
-                reasoningEffort: state.reasoningEffort,
-                role: state.role,
-                initialMailbox: state.takePendingMessages(turn)
-            });
-            state.attachHandle(turn, handle);
-        }
-        catch (error) {
-            state.settleHandleReady(turn);
-            await this.#failTurn(state, turn, error);
-            return;
-        }
-        state.cancelPending(turn);
-        state.settleHandleReady(turn);
-        await this.#consumeTurn(state, turn);
-    }
-    async #consumeTurn(state, turn) {
-        const previousActivity = state.latestActivity;
-        const previousMessageRevision = state.messageRevision;
-        let terminal;
-        try {
-            const consume = (async () => {
-                for await (const event of turn.handle) {
-                    if (event.type === 'execution.completed')
-                        terminal = 'completed';
-                    else if (event.type === 'execution.failed')
-                        terminal = 'failed';
-                    else if (event.type === 'execution.cancelled')
-                        terminal = 'cancelled';
-                    if (!state.observeEvent(event, this.#activityRevision + 1))
-                        continue;
-                    this.#activityRevision++;
-                    this.#touchResource(state);
-                    this.#notifyActivity({ state, kind: 'message' });
-                }
-            })();
-            const [resultOutcome, consumeOutcome] = await Promise.allSettled([
-                Promise.resolve().then(() => turn.handle.result()),
-                consume
-            ]);
-            if (resultOutcome.status === 'rejected')
-                throw resultOutcome.reason;
-            if (consumeOutcome.status === 'rejected')
-                throw consumeOutcome.reason;
-            const result = resultOutcome.value;
-            state.complete(result, terminal, turn.handle.persistedEvents === true, previousActivity, previousMessageRevision);
+        const outcome = await state.runTurn(turn, () => this.#activityRevision + 1, () => {
+            this.#activityRevision++;
+            this.#touchResource(state);
+            this.#notifyActivity({ state, kind: 'message' });
+        }, () => {
             this.#touchResource(state, true);
             this.#closeReceipt(state);
+        });
+        if (outcome === 'opening-failed') {
+            this.#running--;
+            state.settleTurn(turn);
+            state.releaseTurn(turn);
+            this.#notifyCompletion(state);
             await this.#publishTerminal(state);
+            this.#drain();
+            return;
         }
-        catch (error) {
-            this.#setFailure(state, error);
-            this.#closeReceipt(state);
+        try {
             await this.#publishTerminal(state);
         }
         finally {
             this.#closeReceipt(state);
             this.#running--;
-            state.settleCompletion(turn);
+            state.settleTurn(turn);
             this.#notifyCompletion(state);
-            state.clearTurn(turn);
+            state.releaseTurn(turn);
             this.#drain();
         }
     }
-    async #failTurn(state, turn, error) {
-        this.#setFailure(state, error);
-        this.#closeReceipt(state);
-        this.#running--;
-        state.settleCompletion(turn);
-        state.clearTurn(turn);
-        this.#notifyCompletion(state);
-        await this.#publishTerminal(state);
-        this.#drain();
-    }
     #setFailure(state, error) {
         state.fail(error);
         this.#touchResource(state, true);
@@ -1255,7 +917,7 @@ export class SubagentSessionController {
         sourceSignal?.addEventListener('abort', abort, { once: true });
         if (sourceSignal?.aborted)
             abort();
-        return delivery;
+        return { delivery, waitSignal: controller.signal };
     }
     #closeReceipt(state) {
         for (const pending of this.#pendingDeliveries)
@@ -1601,88 +1263,11 @@ function restoreAgentState(session) {
     }
     return state;
 }
-function observeAgentEvent(state, event) {
-    if (event.type === 'message.completed') {
-        state.latestMessage = latestMessageFromEvent(event);
-        state.latestActivity = {
-            kind: 'message',
-            timestamp: event.timestamp,
-            phase: event.phase
-        };
-        return true;
-    }
-    if (event.type === 'tool.started') {
-        state.latestActivity = {
-            kind: 'tool',
-            timestamp: event.timestamp,
-            toolName: event.toolName,
-            status: 'started'
-        };
-        return false;
-    }
-    if (event.type === 'tool.failed') {
-        state.latestActivity = {
-            kind: 'tool',
-            timestamp: event.timestamp,
-            toolName: event.toolName,
-            status: 'failed'
-        };
-        return false;
-    }
-    if (event.type !== 'tool.completed')
-        return false;
-    state.latestActivity = {
-        kind: 'tool',
-        timestamp: event.timestamp,
-        toolName: event.toolName,
-        status: 'completed'
-    };
-    if (event.toolName === 'apply_patch' && isRecord(event.data)) {
-        const data = event.data;
-        const files = Array.isArray(data.files) ? data.files : [];
-        for (const file of files) {
-            if (!isRecord(file))
-                continue;
-            for (const path of [file.path, file.targetPath])
-                if (typeof path === 'string' && path.length > 0 && !state.changedFiles.includes(path))
-                    state.changedFiles.push(path);
-        }
-    }
-    else if (event.toolName === 'read' && isRecord(event.data)) {
-        const data = event.data;
-        const results = Array.isArray(data.results) ? data.results : [];
-        for (const result of results) {
-            if (!isRecord(result) || typeof result.path !== 'string' || result.error !== undefined)
-                continue;
-            const evidence = {
-                path: result.path,
-                ...(isPositiveInteger(result.startLine) ? { startLine: result.startLine } : {}),
-                ...(isPositiveInteger(result.endLine) ? { endLine: result.endLine } : {})
-            };
-            if (!state.evidence.some((item) => JSON.stringify(item) === JSON.stringify(evidence)))
-                state.evidence.push(evidence);
-        }
-    }
-    else if (event.toolName === 'exec')
-        state.verification.push(event.summary);
-    return false;
-}
 function eventType(record) {
     return record && isRecord(record.payload) && typeof record.payload.type === 'string'
         ? record.payload.type
         : undefined;
 }
-function latestMessageFromEvent(event) {
-    const text = event.text;
-    return {
-        itemId: event.itemId,
-        turnId: event.turnId ?? '',
-        phase: event.phase,
-        text,
-        timestamp: event.timestamp,
-        truncated: text !== event.text
-    };
-}
 function isReasoningEffort(value) {
     return (value === 'low' ||
         value === 'medium' ||
@@ -1694,9 +1279,6 @@ function isReasoningEffort(value) {
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
-function isPositiveInteger(value) {
-    return typeof value === 'number' && Number.isInteger(value) && value >= 1;
-}
 function truncateUtf8(value, maximumBytes) {
     const bytes = Buffer.from(value);
     if (bytes.length <= maximumBytes)