@astralyn/pi 1.1.0 → 1.3.0

package/dist/core/agent-session.js

@@ -140,6 +140,10 @@ export class AgentSession {
         this._handleAgentEvent = async (event) => {
             if (event.type === "message_start")
                 this._tasksHost.delivery.messageStarted(event.message);
+            // An abort requested while the run was starting, e.g. during before_agent_start, stops it
+            // here. agent_start is awaited before the first request.
+            if (event.type === "agent_start" && this._agentRunAbortRequested)
+                this.agent.abort();
             // Record the calls a tool made through ctx.executeTool() and their usage on its result message.
             if (this._nestedToolCalls) {
                 if (event.type === "message_start" && event.message.role === "toolResult") {
@@ -249,8 +253,9 @@ export class AgentSession {
                     this.agent.steer(message);
                     return waitForPersistence();
                 }
-                // Completion turns skip before_agent_start, but consume nextTurn context.
-                return this._runAgentPrompt([message, ...this._pendingNextTurnMessages]);
+                // An idle delivery starts its own custom-message run, which consumes the
+                // pending nextTurn context in _prepareRun.
+                return this._startRun({ messageType: "custom", message });
             },
             onEntry: (entry) => this._emit({ type: "entry_appended", entry }),
             onError: (event, error) => this._extensionRunner?.emitError({ extensionPath: "<background>", event, error }),
@@ -290,8 +295,8 @@ export class AgentSession {
             activeToolNames: this._initialActiveToolNames,
             includeAllExtensionTools: true,
         });
-        if (this._initialActiveToolNames === undefined)
-            this._restoreToolsFromTranscript();
+        if (this._usesDefaultTools)
+            this._restoreToolsFromTranscript(this._defaultToolModifiers);
     }
     get tasks() {
         return this._tasksHost.service;
@@ -1130,6 +1135,7 @@ export class AgentSession {
             exposure: this._getToolExposure(definition.name),
             ...(definition.namespace ? { namespace: definition.namespace } : {}),
             ...(definition.annotations ? { annotations: { ...definition.annotations } } : {}),
+            ...(definition.reachesTools ? { reachesTools: definition.reachesTools } : {}),
             sourceInfo,
         }));
     }
@@ -1410,28 +1416,51 @@ export class AgentSession {
      * Restore the active tool loadout declared by the session transcript, if it declares one.
      * Tools reachable only from other tools are never declared, but they do not depend on the active
      * set, so the transcript's declarations are the whole loadout.
+     * @param modifiers `+name`/`-name` entries applied to the restored loadout.
      */
-    _restoreToolsFromTranscript() {
+    _restoreToolsFromTranscript(modifiers = []) {
         this._pendingToolNames.clear();
         const current = getCurrentSystemMessage(this.sessionManager.buildSessionContext().messages);
         if (!current)
             return;
-        const names = (current.toolsAdded ?? []).map((tool) => tool.name);
+        const names = applyToolModifiers((current.toolsAdded ?? []).map((tool) => tool.name), modifiers);
         this._pendingToolNames = new Set(names.filter((name) => this._isAllowedTool(name)));
         this._setActiveTools(names);
     }
     // =========================================================================
     // Prompting
     // =========================================================================
-    async _runAgentPrompt(messages) {
+    /**
+     * Start a run from a user or custom message. The session counts as busy from here on, so
+     * messages sent while before_agent_start handlers run are queued into this run instead of
+     * starting another, and an abort requested meanwhile aborts the run as soon as it exists.
+     * @param onStarted Called once the run's messages are prepared, before the first request.
+     */
+    async _startRun(trigger, onStarted) {
+        this._isAgentRunActive = true;
         this._agentRunAbortRequested = false;
+        let messages;
+        try {
+            messages = await this._prepareRun(trigger);
+        }
+        catch (error) {
+            this._isAgentRunActive = false;
+            this._flushPendingBashMessages();
+            this._flushPendingCustomMessages();
+            this._resolveIdleWaitIfIdle();
+            throw error;
+        }
+        // Messages held while the run was starting go before its starting messages, as they would
+        // have while idle. No run exists yet, so they cannot split a tool call from its result.
+        this._flushPendingBashMessages();
+        this._flushPendingCustomMessages();
+        onStarted?.();
         // Compaction before the prompt may have scheduled a retry; the new prompt replaces it.
         this._failedResponse = undefined;
         this._recordSelection();
         // The run records the loadout in the transcript; restored tools that did not register by now
         // are dropped, so a tool that never registers does not stay pending.
         this._pendingToolNames.clear();
-        this._isAgentRunActive = true;
         try {
             await this.agent.prompt(messages);
             while (!this._agentRunAbortRequested) {
@@ -1458,6 +1487,64 @@ export class AgentSession {
             await this._emitAgentSettled();
         }
     }
+    /**
+     * Prepare a run and return its starting messages: compact first when needed, emit
+     * before_agent_start, apply the run's prompt options and tool loadout, and build the starting
+     * message followed by pending nextTurn messages (consumed here) and handler messages, with a
+     * system patch first when the prompt changed.
+     */
+    async _prepareRun(trigger) {
+        // Check if we need to compact before sending (catches aborted responses).
+        // The starting message is sent below, so do not call agent.continue() here.
+        const lastAssistant = this._findLastAssistantMessage();
+        if (lastAssistant) {
+            await this._checkCompaction(lastAssistant, false);
+        }
+        const selectedToolsBefore = this._baseSystemPromptOptions.selectedTools;
+        const result = await this._extensionRunner.emitBeforeAgentStart(trigger, this._baseSystemPromptOptions);
+        // Handlers may edit event.systemPromptOptions.selectedTools or call setActiveTools(),
+        // which updates the live loadout instead. An explicit edit wins; otherwise the live
+        // loadout is authoritative, so a setActiveTools() call is not undone here.
+        const handlerEditedTools = result.systemPromptOptions.selectedTools.length !== selectedToolsBefore.length ||
+            result.systemPromptOptions.selectedTools.some((name, index) => name !== selectedToolsBefore[index]);
+        if (!handlerEditedTools)
+            result.systemPromptOptions.selectedTools = this.getActiveToolNames();
+        const messages = [];
+        if (trigger.messageType === "custom") {
+            messages.push(trigger.message);
+        }
+        else {
+            // Normalize images after before_agent_start so extension-driven model selection
+            // determines the resize profile used for the request and history.
+            const normalized = await this._normalizePromptImages(trigger.images);
+            const text = normalized.hints.length > 0 ? `${trigger.prompt}\n\n${normalized.hints.join("\n")}` : trigger.prompt;
+            messages.push({
+                role: "user",
+                content: [{ type: "text", text }, ...normalized.images],
+                timestamp: Date.now(),
+            });
+        }
+        // Inject any pending "nextTurn" messages as context alongside the starting message. Each
+        // stays queued until _messagePersisted confirms its persistence, so a run that fails
+        // before persisting it carries it into the next attempt.
+        messages.push(...this._pendingNextTurnMessages);
+        for (const msg of result.messages) {
+            messages.push({
+                role: "custom",
+                customType: msg.customType,
+                // Untyped extensions can pass null/missing content; normalize at ingestion.
+                content: msg.content ?? [],
+                display: msg.display,
+                details: msg.details,
+                timestamp: Date.now(),
+            });
+        }
+        const updateMessage = this._preparePromptAndToolLoadout(result.systemPromptOptions);
+        this._runSystemPromptOptions = result.systemPromptOptions;
+        if (updateMessage)
+            messages.unshift(updateMessage);
+        return messages;
+    }
     async _handlePostAgentRun() {
         const message = this._lastAssistantMessage;
         const toolResults = this._lastAssistantToolResults;
@@ -1637,9 +1724,6 @@ export class AgentSession {
             preflightResult?.("queued");
             return;
         }
-        // Flush any pending bash and custom messages before the new prompt
-        this._flushPendingBashMessages();
-        this._flushPendingCustomMessages();
         // Validate model
         if (!this.model) {
             throw new Error(formatNoModelSelectedMessage());
@@ -1655,55 +1739,7 @@ export class AgentSession {
             }
             throw new Error(formatNoApiKeyFoundMessage(this.model.provider));
         }
-        // Check if we need to compact before sending (catches aborted responses).
-        // The user's new prompt is sent below, so do not call agent.continue() here.
-        const lastAssistant = this._findLastAssistantMessage();
-        if (lastAssistant) {
-            await this._checkCompaction(lastAssistant, false);
-        }
-        // Emit before_agent_start before normalizing images so extension-driven model
-        // selection determines the resize profile used for the request and history.
-        const selectedToolsBefore = this._baseSystemPromptOptions.selectedTools;
-        const result = await this._extensionRunner.emitBeforeAgentStart(expandedText, currentImages, this._baseSystemPromptOptions);
-        // Handlers may edit event.systemPromptOptions.selectedTools or call setActiveTools(),
-        // which updates the live loadout instead. An explicit edit wins; otherwise the live
-        // loadout is authoritative, so a setActiveTools() call is not undone here.
-        const handlerEditedTools = result.systemPromptOptions.selectedTools.length !== selectedToolsBefore.length ||
-            result.systemPromptOptions.selectedTools.some((name, index) => name !== selectedToolsBefore[index]);
-        if (!handlerEditedTools)
-            result.systemPromptOptions.selectedTools = this.getActiveToolNames();
-        const normalized = await this._normalizePromptImages(currentImages);
-        const userText = normalized.hints.length > 0 ? `${expandedText}\n\n${normalized.hints.join("\n")}` : expandedText;
-        // Build messages only after hooks and image normalization have completed.
-        const messages = [];
-        const userContent = [{ type: "text", text: userText }];
-        userContent.push(...normalized.images);
-        messages.push({
-            role: "user",
-            content: userContent,
-            timestamp: Date.now(),
-        });
-        // Inject any pending "nextTurn" messages as context alongside the user message
-        for (const msg of this._pendingNextTurnMessages) {
-            messages.push(msg);
-        }
-        for (const msg of result.messages) {
-            messages.push({
-                role: "custom",
-                customType: msg.customType,
-                // Untyped extensions can pass null/missing content; normalize at ingestion.
-                content: msg.content ?? [],
-                display: msg.display,
-                details: msg.details,
-                timestamp: Date.now(),
-            });
-        }
-        const updateMessage = this._preparePromptAndToolLoadout(result.systemPromptOptions);
-        this._runSystemPromptOptions = result.systemPromptOptions;
-        if (updateMessage)
-            messages.unshift(updateMessage);
-        preflightResult?.("started");
-        await this._runAgentPrompt(messages);
+        await this._startRun({ messageType: "user", prompt: expandedText, images: currentImages }, () => preflightResult?.("started"));
     }
     /**
      * Try to execute an extension command. Returns true if command was found and executed.
@@ -1877,10 +1913,10 @@ export class AgentSession {
         }
         else if (options?.triggerTurn) {
             if (this._isEmittingAgentSettled) {
-                this._deferredSettledActions.push(async () => await this._runAgentPrompt(appMessage));
+                this._deferredSettledActions.push(async () => await this.sendCustomMessage(message, options));
                 return;
             }
-            await this._runAgentPrompt(appMessage);
+            await this._startRun({ messageType: "custom", message: appMessage });
         }
         else if (this.isStreaming) {
             // Appending now would put the message between an assistant tool call and its