@astralyn/pi 1.4.9 → 1.4.10

package/dist/core/agent-session.js

@@ -43,6 +43,7 @@ import { applyToolModifiers, DEFAULT_TOOL_NAMES, } from "./settings-manager.js";
 import { BUILTIN_PATH_PREFIX, createSyntheticSourceInfo, isSyntheticPath } from "./source-info.js";
 import { buildSystemPrompt, buildSystemPromptSections, diffSystemPromptSections, normalizeBuildSystemPromptOptions, } from "./system-prompt.js";
 import { TaskSession } from "./tasks/session.js";
+import { TASKS_TOOL_NAME } from "./tasks/types.js";
 import { createAllToolDefinitions } from "./tools/index.js";
 import { createLocalBashOperations } from "./tools/shell-operations.js";
 import { createToolDefinitionFromAgentTool } from "./tools/tool-definition-wrapper.js";
@@ -113,6 +114,10 @@ export class AgentSession {
         this._isBeforeSettle = false;
         this._abortDuringBeforeSettle = false;
         this._isEmittingAgentSettled = false;
+        /** Last observed quiescence; a transition into true emits `session_quiescent` once. */
+        this._quiescent = true;
+        this._quiescenceDisposed = false;
+        this._quiescenceWaiters = new Set();
         this._deferredSettledActions = [];
         this._baseToolDefinitions = new Map();
         /**
@@ -250,6 +255,7 @@ export class AgentSession {
                 // turn, so it still waits for the queues to drain.
                 return this.isStreaming || (this.pendingMessageCount === 0 && !this.agent.hasQueuedMessages());
             },
+            managementActive: () => this.getActiveToolNames().includes(TASKS_TOOL_NAME),
             deliver: (message, waitForPersistence) => {
                 if (this.isStreaming) {
                     this.agent.steer(message);
@@ -263,6 +269,7 @@ export class AgentSession {
             onEntry: (entry) => this._emit({ type: "entry_appended", entry }),
             onError: (event, error) => this._extensionRunner?.emitError({ extensionPath: "<background>", event, error }),
         });
+        this._tasksHost.subscribe(() => this._updateQuiescence());
         this._scopedModels = config.scopedModels ?? [];
         this._resourceLoader = config.resourceLoader;
         this._customTools = config.customTools ?? [];
@@ -316,6 +323,13 @@ export class AgentSession {
     retryTaskNotifications() {
         this._tasksHost.delivery.retry();
     }
+    /**
+     * Tell the session a background task's completion reached its consumer outside automatic
+     * delivery, such as a direct SDK waiter that read the result. It stops waiting to notify the model.
+     */
+    acknowledgeTaskDelivery(taskId) {
+        this._tasksHost.acknowledgeDelivery(taskId);
+    }
     /**
      * Run a lifecycle operation with delivery paused across its asynchronous gaps.
      * Lifecycle methods are thin shells over upstream bodies so those keep upstream's shape.
@@ -770,6 +784,82 @@ export class AgentSession {
         for (const l of this._eventListeners) {
             l(event);
         }
+        // Compaction runs outside agent runs, so its start is what leaves quiescence.
+        if (event.type === "compaction_start")
+            this._updateQuiescence();
+    }
+    /**
+     * Whether nothing more will happen without new input. Queued user input only matters during a
+     * run; left in the queue while idle it waits for the next prompt, and it also blocks automatic
+     * delivery, so completions that cannot start a turn do not count.
+     */
+    _computeQuiescent() {
+        if (this._isAgentRunActive ||
+            this._isEmittingAgentSettled ||
+            this._deferredSettledActions.length > 0 ||
+            this._pendingCustomMessages.length > 0 ||
+            this.isCompacting ||
+            this.isRetrying) {
+            return false;
+        }
+        if (this._tasksHost.runningBackground().length > 0)
+            return false;
+        const inputBlocksDelivery = this.pendingMessageCount > 0 || this.agent.hasQueuedMessages();
+        return !(this.model !== undefined && !inputBlocksDelivery && this._tasksHost.delivery.hasDeliverableWork());
+    }
+    /** Whether the session is quiescent now. See {@link AgentSessionEvent} `session_quiescent`. */
+    get isQuiescent() {
+        return !this._quiescenceDisposed && this._computeQuiescent();
+    }
+    _updateQuiescence() {
+        if (this._quiescenceDisposed)
+            return;
+        const quiescent = this._computeQuiescent();
+        const entered = quiescent && !this._quiescent;
+        this._quiescent = quiescent;
+        if (!quiescent)
+            return;
+        if (entered)
+            this._emit({ type: "session_quiescent" });
+        // A listener may have started new work.
+        if (!this._quiescent)
+            return;
+        for (const waiter of [...this._quiescenceWaiters])
+            waiter.resolve();
+    }
+    /**
+     * Resolve once the session is quiescent: no run, compaction, retry or branch summary, no
+     * unsettled background task, and no background completion still to be delivered (a failed
+     * delivery does not count: it retries only on the next input). Unlike {@link waitForIdle} this
+     * also waits for the turns that background completions start. Rejects when `signal` aborts or
+     * the session is disposed.
+     */
+    waitForQuiescence(signal) {
+        if (this._quiescenceDisposed)
+            return Promise.reject(new Error("The session was disposed"));
+        if (signal?.aborted)
+            return Promise.reject(signal.reason);
+        if (this._computeQuiescent())
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                resolve: () => {
+                    cleanup();
+                    resolve();
+                },
+                reject: (reason) => {
+                    cleanup();
+                    reject(reason);
+                },
+            };
+            const onAbort = () => waiter.reject(signal?.reason);
+            const cleanup = () => {
+                this._quiescenceWaiters.delete(waiter);
+                signal?.removeEventListener("abort", onAbort);
+            };
+            this._quiescenceWaiters.add(waiter);
+            signal?.addEventListener("abort", onAbort, { once: true });
+        });
     }
     _emitQueueUpdate() {
         this._emit({
@@ -792,6 +882,7 @@ export class AgentSession {
         return this._idleWaitPromise;
     }
     _resolveIdleWaitIfIdle() {
+        this._updateQuiescence();
         if (!this.isIdle || !this._resolveIdleWait) {
             return;
         }
@@ -1057,7 +1148,11 @@ export class AgentSession {
      * Call this when completely done with the session.
      */
     dispose() {
+        this._quiescenceDisposed = true;
+        const waiters = [...this._quiescenceWaiters];
         this._tasksHost.dispose();
+        for (const waiter of waiters)
+            waiter.reject(new Error("The session was disposed"));
         try {
             this.abortRetry();
             this.abortCompaction();
@@ -1267,6 +1362,7 @@ export class AgentSession {
         }
         this._hiddenDeclarations = hidden;
         this.agent.state.tools = declared;
+        this._tasksHost.toolsChanged();
         return declared;
     }
     /** Whether compaction or branch summarization is currently running */
@@ -1480,6 +1576,7 @@ export class AgentSession {
     async _startRun(trigger, onStarted) {
         this._isAgentRunActive = true;
         this._agentRunAbortRequested = false;
+        this._updateQuiescence();
         let messages;
         try {
             messages = await this._prepareRun(trigger);
@@ -3112,8 +3209,7 @@ export class AgentSession {
     async _reloadBody(options) {
         const oldRunner = this._extensionRunner;
         const previousFlagValues = oldRunner.getFlagValues();
-        this.tasks.close();
-        await Promise.all([this.tasks.shutdown(), this.abort()]);
+        await Promise.all([this._tasksHost.shutdown(), this.abort()]);
         await emitSessionShutdownEvent(oldRunner, { type: "session_shutdown", reason: "reload" });
         oldRunner.invalidate();
         const getDefaultTools = () => this._usesDefaultTools
@@ -3415,6 +3511,7 @@ export class AgentSession {
         const resumeBackground = this.pauseTaskNotifications();
         // Set up abort controller for summarization
         this._branchSummaryAbortController = new AbortController();
+        this._updateQuiescence();
         try {
             let extensionSummary;
             let fromExtension = false;