@subimpact/e 0.99.12 → 0.100.0

package/dist/core/agent-session.js

@@ -133,12 +133,6 @@ export class AgentSession {
     _cwd;
     _extensionRunnerRef;
     _initialActiveToolNames;
-    /**
-     * Tools of the restored or reloaded loadout that are not registered yet. They are activated when
-     * they are registered, and dropped when `setActiveToolsByName()` deactivates a tool or the next
-     * agent run starts.
-     */
-    _pendingToolNames = new Set();
     _usesDefaultTools;
     _allowedToolNames;
     _excludedToolNames;
@@ -157,8 +151,6 @@ export class AgentSession {
     _toolRegistry = new Map();
     /** Created on the first `ctx.executeTool()` call. */
     _nestedToolCalls;
-    /** Declared tools whose declarations requests leave out, from `prepareLoadout` hooks. */
-    _hiddenDeclarations = new Set();
     _toolDefinitions = new Map();
     _toolPromptSnippets = new Map();
     _toolPromptGuidelines = new Map();
@@ -192,14 +184,13 @@ export class AgentSession {
         this._installAgentNextTurnRefresh();
         this._installAgentRequestProjection();
         this._installAgentBoundaryHooks();
-        this._installHiddenDeclarationsProjection();
         this._installAgentForcedPromptProjection();
         this._buildRuntime({
             activeToolNames: this._initialActiveToolNames,
             includeAllExtensionTools: true,
         });
         if (this._initialActiveToolNames === undefined)
-            this._restoreToolsFromTranscript();
+            this._restoreActiveTools();
     }
     get modelRuntime() {
         return this._modelRuntime;
@@ -535,7 +526,7 @@ export class AgentSession {
                 toolSnippets: { ...this._baseSystemPromptOptions.toolSnippets, ...runOptions.toolSnippets },
                 toolGuidelines: { ...this._baseSystemPromptOptions.toolGuidelines, ...runOptions.toolGuidelines },
             });
-            const updateMessage = this._preparePromptAndToolLoadout(options, nextContext.messages);
+            const updateMessage = this._preparePromptUpdate(options, nextContext.messages);
             // Keep session.systemPrompt and ctx.getSystemPrompt() in step with what the provider sees.
             this._runSystemPromptOptions = options;
             return {
@@ -1063,7 +1054,6 @@ export class AgentSession {
             description: definition.description,
             parameters: definition.parameters,
             promptGuidelines: definition.promptGuidelines,
-            exposure: this._getToolExposure(definition.name),
             ...(definition.namespace ? { namespace: definition.namespace } : {}),
             ...(definition.annotations ? { annotations: { ...definition.annotations } } : {}),
             sourceInfo,
@@ -1079,82 +1069,29 @@ export class AgentSession {
      * Changes take effect on the next agent turn.
      */
     setActiveToolsByName(toolNames) {
-        const previous = this.getActiveToolNames();
         this._setActiveTools(toolNames);
-        // A loadout that deactivates a tool replaces the restored one, whose pending tools are dropped.
-        const active = new Set(this.getActiveToolNames());
-        if (previous.some((name) => !active.has(name)))
-            this._pendingToolNames.clear();
     }
     _setActiveTools(toolNames) {
-        const tools = this._applyToolLoadout(toolNames);
-        for (const tool of tools)
-            this._pendingToolNames.delete(tool.name);
+        const tools = [];
+        for (const name of [...new Set(toolNames)]) {
+            const tool = this._toolRegistry.get(name);
+            if (tool)
+                tools.push(tool);
+        }
+        this.agent.state.tools = tools;
         this._rebuildSystemPrompt(tools.map((tool) => tool.name));
     }
     _isAllowedTool(name) {
         return (!this._allowedToolNames || this._allowedToolNames.has(name)) && !this._excludedToolNames?.has(name);
     }
-    _getToolExposure(name) {
-        return this._toolDefinitions.get(name)?.definition.exposure ?? "direct";
-    }
-    /** Tools callable through `ctx.executeTool()`: the active `direct` tools. */
+    /** Tools callable through `ctx.executeTool()`: the active registered tools. */
     _getCallableTools(active = new Set(this.getActiveToolNames())) {
-        return [...this._toolRegistry.values()].filter((tool) => this._getToolExposure(tool.name) === "direct" && active.has(tool.name));
+        return [...this._toolRegistry.values()].filter((tool) => active.has(tool.name));
     }
     /**
-     * Set the agent's tools for the given active tool names and return them. The active tools are
-     * the registered, non-hidden ones; they are declared to the model. Active tools with a
-     * `prepareLoadout` hook can change the declared descriptions and hide declarations from
-     * requests (see {@link _installHiddenDeclarationsProjection}).
+     * Set the agent's tools for the given active tool names. The active tools are the registered
+     * ones; they are the tools the model sees, full list, every request.
      */
-    _applyToolLoadout(toolNames) {
-        const tools = [...new Set(toolNames)].flatMap((name) => {
-            const tool = this._toolRegistry.get(name);
-            return tool && this._getToolExposure(name) !== "hidden" ? [tool] : [];
-        });
-        const hooks = tools.flatMap((tool) => {
-            const entry = this._toolDefinitions.get(tool.name);
-            return entry?.definition.prepareLoadout ? [entry] : [];
-        });
-        const hidden = new Set();
-        let declared = tools;
-        if (hooks.length > 0) {
-            const loadout = {
-                declared: tools,
-                callable: this._getCallableTools(new Set(tools.map((tool) => tool.name))),
-                registered: [...this._toolRegistry.values()],
-                getExposure: (name) => this._getToolExposure(name),
-                getNamespace: (name) => this._toolDefinitions.get(name)?.definition.namespace,
-            };
-            const descriptions = new Map();
-            for (const { definition, sourceInfo } of hooks) {
-                try {
-                    const changes = definition.prepareLoadout?.(loadout);
-                    for (const [name, description] of Object.entries(changes?.descriptions ?? {})) {
-                        descriptions.set(name, description);
-                    }
-                    for (const name of changes?.hiddenDeclarations ?? [])
-                        hidden.add(name);
-                }
-                catch (error) {
-                    this._extensionRunner.emitError({
-                        extensionPath: sourceInfo.path,
-                        event: "prepare_loadout",
-                        error: error instanceof Error ? error.message : String(error),
-                        stack: error instanceof Error ? error.stack : undefined,
-                    });
-                }
-            }
-            declared = tools.map((tool) => {
-                const description = descriptions.get(tool.name);
-                return description === undefined ? tool : { ...tool, description };
-            });
-        }
-        this._hiddenDeclarations = hidden;
-        this.agent.state.tools = declared;
-        return declared;
-    }
     /** Whether compaction or branch summarization is currently running */
     get isCompacting() {
         return (this._autoCompactionAbortController !== undefined ||
@@ -1224,8 +1161,7 @@ export class AgentSession {
         const toolSnippets = {};
         for (const name of this._toolRegistry.keys()) {
             const snippet = this._toolPromptSnippets.get(name);
-            // Tools without a snippet are not listed. Hidden tools are only callable through another tool.
-            if (snippet && !this._hiddenDeclarations.has(name))
+            if (snippet)
                 toolSnippets[name] = snippet;
         }
         const loaderSystemPrompt = this._resourceLoader.getSystemPrompt();
@@ -1245,19 +1181,17 @@ export class AgentSession {
         });
     }
     /**
-     * Apply a prompt and tool loadout for the next request. Sets the executable tools and
-     * returns a system message patching the prompt sections the model currently has (replayed
-     * from `messages`), or undefined when the prompt is unchanged. Tool changes are declared by
-     * the agent loop before the request.
+     * Set the executable tools for the next request and returns a system message patching the
+     * prompt sections the model currently has (replayed from `messages`), or undefined when the
+     * prompt is unchanged. Tool changes are declared by the agent loop before the request.
      *
      * A forced prompt does not affect the transcript: the structured sections are still diffed
      * and persisted, and the forced text is projected onto the request by
      * {@link _installAgentForcedPromptProjection}.
      */
-    _preparePromptAndToolLoadout(options, messages = this.agent.state.messages) {
-        options.selectedTools = this._applyToolLoadout(options.selectedTools).map((tool) => tool.name);
-        // The tool list must match the declarations the request carries, so hidden tools are not listed.
-        options.toolSnippets = Object.fromEntries(Object.entries(options.toolSnippets).filter(([name]) => !this._hiddenDeclarations.has(name)));
+    _preparePromptUpdate(options, messages = this.agent.state.messages) {
+        this._setActiveTools(options.selectedTools);
+        options.selectedTools = this.agent.state.tools.map((tool) => tool.name);
         const sections = diffSystemPromptSections(getCurrentSystemMessage(messages)?.sections ?? {}, buildSystemPromptSections(options));
         return sections ? { role: "system", content: "", sections, timestamp: Date.now() } : undefined;
     }
@@ -1268,35 +1202,8 @@ export class AgentSession {
      * head of the request; a mid-conversation system message would leave the original prompt
      * in place. The forced text is a rendering of the current prompt, so the transcript keeps
      * its structured sections and the request is projected instead: the system messages
-     * collapse into one head holding the forced text and the current tools. Runs after the
-     * `context` extension handlers.
-     */
-    /**
-     * Remove the declarations that `prepareLoadout` hooks hide from every request. The whole
-     * transcript is filtered with the current set, so the projected declarations stay consistent
-     * across requests and only change when the loadout does.
+     * collapse into one head holding the forced text. Runs after the `context` extension handlers.
      */
-    _installHiddenDeclarationsProjection() {
-        const previousTransformContext = this.agent.transformContext;
-        this.agent.transformContext = async (messages, signal) => {
-            const transformed = previousTransformContext ? await previousTransformContext(messages, signal) : messages;
-            const hidden = this._hiddenDeclarations;
-            if (hidden.size === 0)
-                return transformed;
-            return transformed.map((message) => {
-                if (message.role !== "system" || (!message.toolsAdded && !message.toolsRemoved))
-                    return message;
-                const { toolsAdded, toolsRemoved, ...rest } = message;
-                const added = toolsAdded?.filter((tool) => !hidden.has(tool.name)) ?? [];
-                const removed = toolsRemoved?.filter((tool) => !hidden.has(tool.name)) ?? [];
-                return {
-                    ...rest,
-                    ...(added.length > 0 ? { toolsAdded: added } : {}),
-                    ...(removed.length > 0 ? { toolsRemoved: removed } : {}),
-                };
-            });
-        };
-    }
     _installAgentForcedPromptProjection() {
         const previousTransformContext = this.agent.transformContext;
         this.agent.transformContext = async (messages, signal) => {
@@ -1308,25 +1215,23 @@ export class AgentSession {
             const head = {
                 role: "system",
                 content: forced,
-                ...(current?.toolsAdded ? { toolsAdded: current.toolsAdded } : {}),
+                ...(current?.tools ? { tools: current.tools } : {}),
                 timestamp: current?.timestamp ?? Date.now(),
             };
             return [head, ...transformed.filter((message) => message.role !== "system")];
         };
     }
     /**
-     * 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.
+     * Restore the active tools declared by the session transcript, if it declares one. Tools that
+     * register later are activated when they register; the transcript's snapshot only names the
+     * active set.
      */
-    _restoreToolsFromTranscript() {
-        this._pendingToolNames.clear();
+    _restoreActiveTools() {
         const current = getCurrentSystemMessage(this.sessionManager.buildSessionContext().messages);
         if (!current)
             return;
-        const names = (current.toolsAdded ?? []).map((tool) => tool.name);
-        this._pendingToolNames = new Set(names.filter((name) => this._isAllowedTool(name)));
-        this._setActiveTools(names);
+        const names = current.tools?.map((tool) => tool.name) ?? [];
+        this._setActiveTools(names.filter((name) => this._isAllowedTool(name)));
     }
     // =========================================================================
     // Prompting
@@ -1336,9 +1241,6 @@ export class AgentSession {
         // 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);
@@ -1577,7 +1479,7 @@ export class AgentSession {
                 timestamp: Date.now(),
             });
         }
-        const updateMessage = this._preparePromptAndToolLoadout(result.systemPromptOptions);
+        const updateMessage = this._preparePromptUpdate(result.systemPromptOptions);
         this._runSystemPromptOptions = result.systemPromptOptions;
         if (updateMessage)
             messages.unshift(updateMessage);
@@ -2759,8 +2661,8 @@ export class AgentSession {
         });
     }
     _refreshToolRegistry(options) {
-        // Tools that were already activated on registration. A tool whose exposure changes to
-        // `direct` or `model-only` (for example from `hidden`) is activated like a new tool.
+        // Tools that were already activated on registration. A tool whose defaultActive changes to
+        // active (for example from false) is activated like a new tool.
         const previousActivatedOnRegistration = new Set([...this._toolRegistry.keys()].filter((name) => this._isActivatedOnRegistration(name)));
         const previousActiveToolNames = this.getActiveToolNames();
         const allowedToolNames = this._allowedToolNames;
@@ -2819,9 +2721,8 @@ export class AgentSession {
         if (allowedToolNames) {
             for (const toolName of this._toolRegistry.keys()) {
                 // Naming a tool activates it even when it is not active by default.
-                if (allowedToolNames.has(toolName) && this._isDeclarable(toolName)) {
+                if (allowedToolNames.has(toolName))
                     nextActiveToolNames.push(toolName);
-                }
             }
         }
         else if (options?.includeAllExtensionTools) {
@@ -2837,18 +2738,11 @@ export class AgentSession {
                 }
             }
         }
-        // Pending tools that are registered now become active.
-        nextActiveToolNames.push(...this._pendingToolNames);
         this._setActiveTools([...new Set(nextActiveToolNames)]);
     }
-    /** Whether activating the tool declares it to the model. */
-    _isDeclarable(name) {
-        const exposure = this._getToolExposure(name);
-        return exposure === "direct" || exposure === "model-only";
-    }
-    /** Whether registering the tool activates it, which declares it to the model. */
+    /** Whether registering the tool activates it. */
     _isActivatedOnRegistration(name) {
-        return this._isDeclarable(name) && this._toolDefinitions.get(name)?.definition.defaultActive !== false;
+        return this._toolDefinitions.get(name)?.definition.defaultActive !== false;
     }
     _buildRuntime(options) {
         const autoResizeImages = this.settingsManager.getImageAutoResize();
@@ -2900,11 +2794,9 @@ export class AgentSession {
         const addedDefaultTools = this._usesDefaultTools
             ? (this.settingsManager.getDefaultTools() ?? DEFAULT_TOOL_NAMES).filter((name) => !previousDefaultTools.has(name))
             : [];
-        // Tools the new extensions register later are pending until then.
-        for (const name of this.getActiveToolNames())
-            this._pendingToolNames.add(name);
+        const activeToolNames = [...this.getActiveToolNames(), ...addedDefaultTools];
         this._buildRuntime({
-            activeToolNames: [...this.getActiveToolNames(), ...addedDefaultTools],
+            activeToolNames,
             flagValues: previousFlagValues,
             includeAllExtensionTools: true,
         });
@@ -3290,7 +3182,7 @@ export class AgentSession {
             }
             // Update finalized context from the canonical session projection.
             this._refreshFinalizedContext();
-            this._restoreToolsFromTranscript();
+            this._restoreActiveTools();
             // Emit session_tree event
             await this._extensionRunner.emit({
                 type: "session_tree",