@sema-agent/core 1.397.0 → 1.399.0

package/dist/core/runner/prepare-task.js

@@ -9,6 +9,7 @@ import { buildAutoModePrompt, renderAutoModeAction, renderAutoModeWindow } from
 import { resolveModel, resolveTaskModel, roleModelIfSet } from "../roles.js";
 import { primaryActivityArg } from "../arg-summary.js";
 import { materializeMcpTools } from "../mcp.js";
+import { Type } from "typebox";
 import { brainToRuntime } from "../runtime.js";
 import { MemoryEngine } from "../memory-engine/engine.js";
 import { deriveControlPlaneDir, deriveProjectControlDir, deriveProjectMemoryDir, deriveRepoMemoryDir, drainMemoryAnnouncements, enqueueMemoryAnnouncement, lookupProjectIdHint, recordProjectIdHint, resolveMemoryEngineRoot } from "../memory-engine/layout.js";
@@ -933,7 +934,7 @@ export async function prepareTask(spec, deps, sessions, resume, _memorySelector,
         }
         mcp = spec.mcp?.length
             ? await materializeMcpTools(spec.mcp, spec.principal, deps.onElicit, deps.mcpImageResizer)
-            : { tools: [], toolAxes: [], warnings: [], serverInstructions: [], instructionsDelta: { pendingAdds: [], pendingRemovals: [] }, droppedTools: [], statuses: [], dispose: async () => { } };
+            : { tools: [], toolAxes: [], warnings: [], serverInstructions: [], instructionsDelta: { pendingAdds: [], pendingRemovals: [] }, droppedTools: [], statuses: [], refresh: async () => [], dispose: async () => { } };
         for (const w of mcp.warnings)
             deps.onError?.(w, { phase: "mcp", sessionId });
         for (const d of mcp.droppedTools) {
@@ -950,22 +951,83 @@ export async function prepareTask(spec, deps, sessions, resume, _memorySelector,
             }
         }
         tools.push(...mcp.tools.map((t) => mcpOffload(t)));
-        for (const axis of mcp.toolAxes) {
-            if (axis.irreversibility === "always") {
-                irreversibilityTier.set(axis.name, "always");
-                irreversibleTools.add(axis.name);
-            }
-            if (axis.egress) {
-                if (axis.effect !== undefined && axis.effect !== "write") {
-                    const e = new Error(`MCP tool "${axis.name}" resolves to egress:true with effect:"${axis.effect}" — an egress tool (external write) must have effect:"write". Clear egress (toolAxes egress:false) if it is a pure read, or set effect:"write".`);
-                    e.code = "config.egress_requires_write_effect";
-                    throw e;
+        const rebuildHarnessToolsRef = {};
+        if (spec.mcp?.length) {
+            tools.push({
+                name: "RefreshMcpTools",
+                label: "RefreshMcpTools",
+                description: "Refresh the tool list of connected MCP servers. Never dials or re-dials connections — it only re-reads the tool list over the existing connection. The refreshed tools are available immediately; you can call them on your next step. Use when a server's expected tool is missing, or the tool list looks stale after a connection recovered. Omit `server` to refresh every connected server.",
+                parameters: Type.Object({
+                    server: Type.Optional(Type.String({ description: "Name of a single MCP server to refresh; omit to refresh all connected servers." })),
+                }),
+                execute: async (_toolCallId, params) => {
+                    const serverArg = params?.server;
+                    const results = await mcp.refresh(typeof serverArg === "string" && serverArg.length > 0 ? serverArg : undefined);
+                    const lines = [];
+                    let changed = false;
+                    for (const r of results) {
+                        if (r.status !== "refreshed" || r.tools === undefined) {
+                            lines.push(`${r.server}: ${r.status}${r.error !== undefined ? ` (${r.error})` : ""}`);
+                            continue;
+                        }
+                        const excludedSet = new Set(toolFaceSnapshot.exclude ?? []);
+                        const pushable = r.tools.filter((t) => !excludedSet.has(t.name));
+                        const excludedNow = r.tools.filter((t) => excludedSet.has(t.name)).map((t) => t.name);
+                        try {
+                            foldMcpAxes((r.axes ?? []).filter((a) => !excludedSet.has(a.name)));
+                        }
+                        catch (foldErr) {
+                            lines.push(`${r.server}: failed (${foldErr instanceof Error ? foldErr.message : String(foldErr)})`);
+                            continue;
+                        }
+                        for (let i = tools.length - 1; i >= 0; i--) {
+                            const t = tools[i];
+                            if (t.name.startsWith(r.prefix)) {
+                                toolEffects.delete(t.name);
+                                tools.splice(i, 1);
+                            }
+                        }
+                        tools.push(...pushable.map((t) => mcpOffload(t)));
+                        changed = true;
+                        const detail = [];
+                        const shownAdded = r.added.filter((n) => !excludedSet.has(n));
+                        if (shownAdded.length > 0)
+                            detail.push(`added: ${shownAdded.join(", ")}`);
+                        if (r.removed.length > 0)
+                            detail.push(`removed: ${r.removed.join(", ")}`);
+                        if (excludedNow.length > 0)
+                            detail.push(`excluded by deployment config (not mounted): ${excludedNow.join(", ")}`);
+                        if ((r.dropped?.length ?? 0) > 0)
+                            detail.push(`dropped (invalid schema): ${r.dropped.map((d) => d.tool).join(", ")}`);
+                        lines.push(`${r.server}: refreshed — ${pushable.length} tool${pushable.length === 1 ? "" : "s"}${detail.length > 0 ? ` (${detail.join("; ")})` : ""}`);
+                    }
+                    if (changed)
+                        await rebuildHarnessToolsRef.current?.();
+                    const text = lines.length === 0 ? "No connected MCP servers to refresh." : lines.join("\n");
+                    return { content: [{ type: "text", text }], details: { results }, terminate: false };
+                },
+            });
+            toolEffects.set("RefreshMcpTools", "read");
+        }
+        const foldMcpAxes = (axes) => {
+            for (const axis of axes) {
+                if (axis.irreversibility === "always") {
+                    irreversibilityTier.set(axis.name, "always");
+                    irreversibleTools.add(axis.name);
+                }
+                if (axis.egress) {
+                    if (axis.effect !== undefined && axis.effect !== "write") {
+                        const e = new Error(`MCP tool "${axis.name}" resolves to egress:true with effect:"${axis.effect}" — an egress tool (external write) must have effect:"write". Clear egress (toolAxes egress:false) if it is a pure read, or set effect:"write".`);
+                        e.code = "config.egress_requires_write_effect";
+                        throw e;
+                    }
+                    egressTools.add(axis.name);
                 }
-                egressTools.add(axis.name);
+                if (!toolEffects.has(axis.name))
+                    toolEffects.set(axis.name, axis.effect ?? "write");
             }
-            if (!toolEffects.has(axis.name))
-                toolEffects.set(axis.name, axis.effect ?? "write");
-        }
+        };
+        foldMcpAxes(mcp.toolAxes);
         const callCapOn = spec.limits?.callCapByDeadline !== false;
         const callCapRef = spec.limits?.timeoutSec &&
             spec.limits.timeoutSec > 0 &&
@@ -1814,6 +1876,15 @@ export async function prepareTask(spec, deps, sessions, resume, _memorySelector,
         }
         const activeTools = new Set();
         const fpRef = {};
+        if (rebuildHarnessToolsRef.current === undefined) {
+            rebuildHarnessToolsRef.current = async () => {
+                const list = [...tools];
+                await harnessRef.current.setTools(list, list.map((t) => t.name));
+                if (fpRef.current)
+                    fpRef.current.tools = toolsToFingerprintInputs(list);
+                turnSnapshotRef.current?.refreshTools(toolsToFingerprintInputs(list));
+            };
+        }
         const turnSnapshotRef = {};
         let harnessTools = tools;
         let toolsDeltaRef;
@@ -1847,7 +1918,7 @@ export async function prepareTask(spec, deps, sessions, resume, _memorySelector,
             const deltaRef = toolsDeltaRef;
             const rematerialize = async (active) => {
                 const list = buildToolList(active);
-                await harnessRef.current.setTools(list);
+                await harnessRef.current.setTools(list, list.map((t) => t.name));
                 if (fpRef.current)
                     fpRef.current.tools = toolsToFingerprintInputs(list);
                 turnSnapshotRef.current?.refreshTools(toolsToFingerprintInputs(list));
@@ -1858,6 +1929,7 @@ export async function prepareTask(spec, deps, sessions, resume, _memorySelector,
                     }
                 }
             };
+            rebuildHarnessToolsRef.current = () => rematerialize(activeTools);
             toolSearch = makeToolSearchTool({
                 registry,
                 active: activeTools,