@asm-agent/coding-agent 0.8.8 → 0.9.0

package/dist/core/agent-session.js

@@ -8,9 +8,8 @@ import { clampThinkingLevel, cleanupSessionResources, getSupportedThinkingLevels
 import { theme } from "../modes/interactive/theme/theme.js";
 import { stripFrontmatter } from "../utils/frontmatter.js";
 import { sleep } from "../utils/sleep.js";
-import { AGENT_MESSAGE_CUSTOM_TYPE, AGENT_MESSAGE_RECEIVED_PREVIEW_LABEL, AGENT_MESSAGE_SKILL_NAME, assertAgentSessionNameAvailable, assertDirectAgentMessageTarget, createAgentMessageHostHandlers, formatAgentSessionNameUnavailable, isAgentSessionMessage, normalizeAgentSessionMessage, parseAgentSessionMessagePromptId, startsAgentRun, } from "./agent-messages.js";
+import { AGENT_MESSAGE_CUSTOM_TYPE, AGENT_MESSAGE_RECEIVED_PREVIEW_LABEL, AGENT_MESSAGE_SKILL_NAME, assertAgentMessageQueueCapacity, assertAgentSessionNameAvailable, assertDirectAgentMessageTarget, createAgentMessageHostHandlers, DEFAULT_AGENT_MESSAGE_MAX_PENDING_PER_SESSION, formatAgentSessionNameUnavailable, isAgentSessionMessage, isAgentSessionMessagePrompt, normalizeAgentSessionMessage, parseAgentSessionMessagePromptId, startsAgentRun, } from "./agent-messages.js";
 import { AGENT_OBSERVE_SKILL_NAME, createAgentObserveHostHandlers, normalizeObserveLimit, normalizeObserveMaxChars, ORCHESTRATION_HEARTBEAT_SKILL_NAME, } from "./agent-observe.js";
-import { flushAgentTraceUpload } from "./agent-traces.js";
 import { addLoginGuidanceToAuthError, formatAuthenticationFailedMessage, formatNoApiKeyFoundMessage, formatNoModelSelectedMessage, isLikelyAuthenticationError, } from "./auth-guidance.js";
 import { addAutonomousContinuation, addAutonomousUsage, autonomousStatus, createAutonomousRuntimeState, nextAutonomousContinuation, refreshAutonomousQualityGates, setAutonomousEnabled, } from "./autonomous.js";
 import { executeBashWithOperations } from "./bash-executor.js";
@@ -37,6 +36,7 @@ import { parseRefineCommandOptions, parseSessionSlashCommand, parseSlashCommand,
 import { createSyntheticSourceInfo } from "./source-info.js";
 import { buildSystemPrompt } from "./system-prompt.js";
 import { THINKING_LEVELS } from "./thinking-levels.js";
+import { acpMcpToolNames, createAcpMcpToolDefinitions } from "./tools/acp-mcp.js";
 import { createLocalBashOperations } from "./tools/bash.js";
 import { createAllToolDefinitions } from "./tools/index.js";
 import { IpythonKernelProvisioner } from "./tools/ipython.js";
@@ -341,11 +341,12 @@ export class AgentSession {
     _retryPromise = undefined;
     _retryResolve = undefined;
     _retryAuthFailureSources = [];
+    _agentMessageClearEpoch = 0;
     _agentMessageOutcomes = new Map();
     _lateIpythonSentAgentMessages = new Map();
     /** Outcome disclosures whose session-file append failed; retained for context rebuilds. */
     _unpersistedOutcomes = [];
-    _bashAbortController = undefined;
+    _bashAbortControllers = new Set();
     _userBashRunning = false;
     _userBashAbortRequested = false;
     _pendingBashMessages = [];
@@ -357,6 +358,7 @@ export class AgentSession {
     _modelSelectEmitContext = new AsyncLocalStorage();
     _resourceLoader;
     _customTools;
+    _acpMcpTools = [];
     _baseToolDefinitions = new Map();
     _cwd;
     _agentDir;
@@ -554,6 +556,10 @@ export class AgentSession {
                 throw new Error("MCP is unavailable in this session");
             return;
         }
+        if (servers.length > 0 && !this._ipythonKernelProvisioner) {
+            throw new Error("ACP MCP servers require the built-in cpython tool");
+        }
+        this._assertAcpMcpToolNamesAvailable(acpMcpToolNames(servers));
         if (!this._mcpManager.replaceAcpServers(servers, ownerId))
             return;
         this._rebuildRuntimeForAcpMcpServers();
@@ -562,8 +568,12 @@ export class AgentSession {
         if (!this._mcpManager?.canReleaseAcpServers(ownerId))
             return;
         if (this._mcpManager.replaceAcpServers([], ownerId)) {
-            // Host MCP handlers read this manager dynamically, so credentials disappear
-            // before the kernel-side transport is closed.
+            const removedToolNames = new Set(this._acpMcpTools.map((tool) => tool.name));
+            const activeToolNames = this.getActiveToolNames().filter((name) => !removedToolNames.has(name));
+            for (const name of removedToolNames)
+                this._allowedToolNames?.delete(name);
+            this._acpMcpTools = [];
+            this._refreshToolRegistry({ activeToolNames, includeAllExtensionTools: true });
             this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames());
             this.agent.state.systemPrompt = this._baseSystemPrompt;
         }
@@ -602,9 +612,26 @@ export class AgentSession {
             inputPause.release();
         }
     }
+    _assertAcpMcpToolNamesAvailable(names) {
+        const occupiedNames = new Set([
+            ...this._baseToolDefinitions.keys(),
+            ...this._customTools.map((tool) => tool.name),
+            ...this._extensionRunner.getAllRegisteredTools().map((tool) => tool.definition.name),
+        ]);
+        for (const name of names) {
+            if (occupiedNames.has(name)) {
+                throw new Error(`ACP MCP tool name conflicts with an existing tool: ${name}`);
+            }
+        }
+    }
     _rebuildRuntimeForAcpMcpServers() {
+        const previousToolNames = new Set(this._acpMcpTools.map((tool) => tool.name));
+        const nextToolNames = acpMcpToolNames(this._mcpManager?.getAcpServers() ?? []);
+        this._assertAcpMcpToolNamesAvailable(nextToolNames);
+        const activeToolNames = this.getActiveToolNames().filter((name) => !previousToolNames.has(name));
+        activeToolNames.push(...nextToolNames);
         this._buildRuntime({
-            activeToolNames: this.getActiveToolNames(),
+            activeToolNames,
             includeAllExtensionTools: true,
         });
         this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames());
@@ -2027,7 +2054,6 @@ export class AgentSession {
                 if (instructions !== undefined && typeof instructions !== "string") {
                     throw new Error("compact.run instructions must be a string when provided");
                 }
-                // "status" is reserved by the host-request reply protocol; don't use it as a key.
                 if (!this.isStreaming) {
                     return {
                         scheduled: false,
@@ -2981,7 +3007,7 @@ export class AgentSession {
         }
     }
     async _disposeAsyncOnce() {
-        // Flush kernels/traces for both still-running and retained children; the sync
+        // Flush kernels for both still-running and retained children; the sync
         // dispose() below only tears them down synchronously.
         for (const run of [...this._activeRlmChildRuns.values()]) {
             const childSession = run.session;
@@ -3305,7 +3331,7 @@ export class AgentSession {
             rlmDepth: this._rlmDepth,
             rlmParentAgent: this._rlmParentAgent,
             harnessState: this._loadMergedHarnessState(),
-            genericMcpServers: this._mcpManager?.getEnabledGenericServers(),
+            genericMcpServers: this._mcpManager?.getEnabledPersistentGenericServers(),
         };
         return buildSystemPrompt(this._baseSystemPromptOptions);
     }
@@ -3466,6 +3492,22 @@ export class AgentSession {
     }
     async acceptAgentMessagePrompt(text, options) {
         const customMessage = options?.customMessage && isAgentSessionMessage(options.customMessage) ? options.customMessage : undefined;
+        const clearEpoch = this._agentMessageClearEpoch;
+        const admissionCommitted = () => {
+            options?.admissionCommitted?.();
+            if (clearEpoch !== this._agentMessageClearEpoch) {
+                throw new Error("Agent message was cleared before admission");
+            }
+        };
+        if (this._sessionInputPumpSuspended &&
+            this._isBusyForSessionInput("preflight") &&
+            options?.queueIfBusy === true &&
+            options.streamingBehavior) {
+            admissionCommitted();
+            const queued = await this.queueAgentMessagePrompt(text, options.streamingBehavior, customMessage);
+            options.preflightResult?.(queued, queued);
+            return;
+        }
         await this._prompt(text, {
             ...options,
             resumeIfIdle: false,
@@ -3475,6 +3517,7 @@ export class AgentSession {
             returnAfterAccepted: true,
             agentMessageId: options?.agentMessageId ?? customMessage?.details.id ?? parseAgentSessionMessagePromptId(text),
             customMessage,
+            admissionCommitted,
         });
         if (customMessage?.details.fromRelationship === "parent")
             this._repliedToParentSinceTask = false;
@@ -3737,6 +3780,11 @@ export class AgentSession {
                     expandPromptTemplates,
                 });
                 const normalized = normalizationResult instanceof Promise ? await normalizationResult : normalizationResult;
+                // Async input handlers ran between the admission check above and
+                // admission itself; re-check so content invalidated during that
+                // await (e.g. a cron job cancelled or updated) is not admitted.
+                if (normalizationResult instanceof Promise)
+                    options?.admissionCommitted?.();
                 if (normalized.kind === "extensionCommand") {
                     commitFence?.release();
                     reportPreflight(true);
@@ -4300,6 +4348,11 @@ export class AgentSession {
         if (this._sessionInputAdmissionPauses.size > 0) {
             throw new Error("Cannot admit a session action while session input admission is paused.");
         }
+        if (options.restore !== true &&
+            action.payload.kind === "turn" &&
+            isAgentSessionMessage(primaryDeliveryRecord(action).message)) {
+            assertAgentMessageQueueCapacity(this._actionStore.unfinishedActions().length, DEFAULT_AGENT_MESSAGE_MAX_PENDING_PER_SESSION);
+        }
         const coalescedOwner = options.restore ? undefined : this._coalescedFollowUpOwner(action);
         if (coalescedOwner) {
             if (action.agentMessageId !== coalescedOwner.agentMessageId) {
@@ -4998,6 +5051,10 @@ export class AgentSession {
                 action.payload.prepared = undefined;
         }
     }
+    clearQueuedAgentMessages() {
+        this._agentMessageClearEpoch++;
+        return this.clearQueuedUserMessagesMatching(isAgentSessionMessagePrompt);
+    }
     clearQueuedUserMessagesMatching(predicate) {
         const ownedActions = this._actionStore.ownedActions();
         const dispatchedTurnCount = ownedActions.filter((action) => action.payload.kind === "turn" &&
@@ -7201,14 +7258,16 @@ export class AgentSession {
         const previousActiveToolNames = this.getActiveToolNames();
         const allowedToolNames = this._allowedToolNames;
         const registeredTools = this._extensionRunner.getAllRegisteredTools();
+        const sdkToolEntry = (definition) => ({
+            definition,
+            sourceInfo: createSyntheticSourceInfo(`<sdk:${definition.name}>`, {
+                source: "sdk",
+            }),
+        });
         const allCustomTools = [
             ...registeredTools,
-            ...this._customTools.map((definition) => ({
-                definition,
-                sourceInfo: createSyntheticSourceInfo(`<sdk:${definition.name}>`, {
-                    source: "sdk",
-                }),
-            })),
+            ...this._customTools.map(sdkToolEntry),
+            ...this._acpMcpTools.map(sdkToolEntry),
         ];
         const isAllowedTool = (name) => !allowedToolNames || allowedToolNames.has(name);
         const allowedCustomTools = allCustomTools.filter((tool) => isAllowedTool(tool.definition.name));
@@ -7338,6 +7397,20 @@ export class AgentSession {
         }
         this._bindExtensionCore(this._extensionRunner);
         this._applyExtensionBindings(this._extensionRunner);
+        const previousAcpMcpToolNames = new Set(this._acpMcpTools.map((tool) => tool.name));
+        const acpServers = this._mcpManager?.getAcpServers() ?? [];
+        if (acpServers.length > 0 && !this._ipythonKernelProvisioner) {
+            throw new Error("ACP MCP servers require the built-in cpython tool");
+        }
+        const acpMcpTools = this._ipythonKernelProvisioner
+            ? createAcpMcpToolDefinitions(acpServers, this._ipythonKernelProvisioner)
+            : [];
+        this._assertAcpMcpToolNamesAvailable(acpMcpTools.map((tool) => tool.name));
+        for (const name of previousAcpMcpToolNames)
+            this._allowedToolNames?.delete(name);
+        for (const tool of acpMcpTools)
+            this._allowedToolNames?.add(tool.name);
+        this._acpMcpTools = acpMcpTools;
         const defaultActiveToolNames = this._baseToolsOverride ? Object.keys(this._baseToolsOverride) : ["ipython"];
         const baseActiveToolNames = [...(options.activeToolNames ?? defaultActiveToolNames)];
         if (this._goalState.status === "active" && this._includeGoals) {
@@ -8651,7 +8724,6 @@ export class AgentSession {
                         const text = compactRlmText(readAssistantText(assistant));
                         if (text)
                             answerPreview = text;
-                        void flushAgentTraceUpload(child.sessionManager).catch(() => undefined);
                         emitChildUpdate();
                     }
                     else if (event.type === "message_start" || event.type === "message_update") {
@@ -9088,14 +9160,16 @@ export class AgentSession {
      * @param options.operations Custom BashOperations for remote execution
      */
     async executeBash(command, onChunk, options) {
-        this._bashAbortController = new AbortController();
+        // Each invocation owns its controller so abortBash reaches every in-flight command.
+        const abortController = new AbortController();
+        this._bashAbortControllers.add(abortController);
         const prefix = this.settingsManager.getShellCommandPrefix();
         const shellPath = this.settingsManager.getShellPath();
         const resolvedCommand = prefix ? `${prefix}\n${command}` : command;
         try {
             const result = await executeBashWithOperations(resolvedCommand, this.sessionManager.getCwd(), options?.operations ?? createLocalBashOperations({ shellPath }), {
                 onChunk,
-                signal: this._bashAbortController.signal,
+                signal: abortController.signal,
             });
             if (!options?.transient) {
                 this.recordBashResult(command, result, options);
@@ -9103,7 +9177,8 @@ export class AgentSession {
             return result;
         }
         finally {
-            this._bashAbortController = undefined;
+            this._bashAbortControllers.delete(abortController);
+            this._notifySessionInputCheckpointChange();
         }
     }
     /**
@@ -9247,13 +9322,16 @@ export class AgentSession {
     abortBash() {
         // A user bash command may not have spawned yet (extension dispatch in
         // progress); flag the request so runUserBash cancels before executing.
-        if (this._userBashRunning && this._bashAbortController === undefined) {
+        // runUserBash clears the flag at each start, so a stale flag is harmless.
+        if (this._userBashRunning) {
             this._userBashAbortRequested = true;
         }
-        this._bashAbortController?.abort();
+        for (const controller of this._bashAbortControllers) {
+            controller.abort();
+        }
     }
     get isBashRunning() {
-        return this._bashAbortController !== undefined || this._userBashRunning;
+        return this._bashAbortControllers.size > 0 || this._userBashRunning;
     }
     /** Whether there are pending bash messages waiting to be flushed */
     get hasPendingBashMessages() {