@sema-agent/core 1.423.0 → 1.425.0

package/dist/core/mcp.js

@@ -96,6 +96,43 @@ export function mcpToolTimeoutMs() {
 export function mcpToolTotalTimeoutMs(perCallMs) {
     return parseEnvMs("MCP_TOOL_TIMEOUT_TOTAL") ?? perCallMs;
 }
+export const MCP_IDLE_TIMEOUT_STDIO_DEFAULT_MS = 30 * 60_000;
+export const MCP_IDLE_TIMEOUT_HTTP_DEFAULT_MS = 5 * 60_000;
+export function mcpIdleTimeoutMs(kind) {
+    return kind === "stdio"
+        ? (parseEnvMs("MCP_IDLE_TIMEOUT_STDIO") ?? MCP_IDLE_TIMEOUT_STDIO_DEFAULT_MS)
+        : (parseEnvMs("MCP_IDLE_TIMEOUT_HTTP") ?? MCP_IDLE_TIMEOUT_HTTP_DEFAULT_MS);
+}
+function idleKindOf(spec) {
+    return spec.transport.kind === "stdio" ? "stdio" : "http";
+}
+const IDLE_WATCHDOG_ABORT_REASON = Symbol("mcp-idle-watchdog-abort");
+function armMcpIdleWatchdog(health, idleMs, outerSignal) {
+    const idleController = new AbortController();
+    let timer;
+    const rearm = () => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        const armedAt = Date.now();
+        timer = setTimeout(() => {
+            if (health.pendingElicitations > 0 || health.lastElicitationClosedAt > armedAt) {
+                rearm();
+                return;
+            }
+            idleController.abort(IDLE_WATCHDOG_ABORT_REASON);
+        }, idleMs);
+    };
+    rearm();
+    return {
+        combinedSignal: outerSignal !== undefined ? AbortSignal.any([outerSignal, idleController.signal]) : idleController.signal,
+        idleSignal: idleController.signal,
+        rearm,
+        dispose: () => {
+            if (timer !== undefined)
+                clearTimeout(timer);
+        },
+    };
+}
 function mcpStartupTimeoutMs() {
     return parseEnvMs("MCP_TIMEOUT");
 }
@@ -110,6 +147,16 @@ function writeEffectWarning(writeEffect) {
         : "";
 }
 function rethrowHonestMcpError(err, ctx) {
+    if (ctx.idle?.signal.reason === IDLE_WATCHDOG_ABORT_REASON) {
+        const serverLabel = inlineUntrusted(ctx.server);
+        const e = new Error(`${ctx.what} on MCP server "${serverLabel}" received no response for ${ctx.idle.idleMs}ms (idle watchdog — ` +
+            `distinct from the ${ctx.timeoutMs}ms total ceiling above). The server may still be alive but is not ` +
+            `responding; the client stopped waiting.${writeEffectWarning(ctx.writeEffect)} (Set MCP_IDLE_TIMEOUT_STDIO ` +
+            `/ MCP_IDLE_TIMEOUT_HTTP (ms) to change this bound.)`, { cause: err });
+        e.errorKind = "timeout";
+        e.details = { timedOut: true, timeoutMs: ctx.idle.idleMs, idleTimeout: true, server: ctx.server };
+        throw e;
+    }
     if (ctx.signal?.aborted)
         throw err;
     const serverLabel = inlineUntrusted(ctx.server);
@@ -117,7 +164,7 @@ function rethrowHonestMcpError(err, ctx) {
         const data = err.data;
         const totalMs = typeof data?.maxTotalTimeout === "number" ? data.maxTotalTimeout : undefined;
         const e = new Error(totalMs !== undefined
-            ? `${ctx.what} on MCP server "${serverLabel}" exceeded its total time ceiling of ${totalMs}ms (the call stayed alive — e.g. via progress notifications — but ran past the total wall-clock budget). The client stopped waiting, but the server may still be executing the request — the outcome is unknown.${writeEffectWarning(ctx.writeEffect)} (Set the MCP_TOOL_TIMEOUT_TOTAL environment variable (ms) to change this ceiling; MCP_TOOL_TIMEOUT only tunes the idle timeout, currently ${ctx.timeoutMs}ms.)`
+            ? `${ctx.what} on MCP server "${serverLabel}" exceeded its total time ceiling of ${totalMs}ms (the call stayed alive — e.g. via progress notifications — but ran past the total wall-clock budget). The client stopped waiting, but the server may still be executing the request — the outcome is unknown.${writeEffectWarning(ctx.writeEffect)} (Set the MCP_TOOL_TIMEOUT_TOTAL environment variable (ms) to change this ceiling; MCP_TOOL_TIMEOUT only tunes the per-call timer, currently ${ctx.timeoutMs}ms.)`
             : `${ctx.what} on MCP server "${serverLabel}" timed out after ${ctx.timeoutMs}ms. The client stopped waiting, but the server may still be executing the request — the outcome is unknown.${writeEffectWarning(ctx.writeEffect)} (Set the MCP_TOOL_TIMEOUT environment variable (ms) to change this limit.)`, { cause: err });
         e.errorKind = "timeout";
         e.details =
@@ -419,6 +466,112 @@ export async function mapContent(content, serverName, imageResizer) {
     }
     return out;
 }
+const MCP_SCHEMA_COMBINATOR_KEYS = ["anyOf", "oneOf", "allOf"];
+const MCP_SCHEMA_PROP_NAME_RE = /^[a-zA-Z0-9_.-]{1,64}$/;
+const MCP_SCHEMA_CARRY_KEYS = ["$defs", "definitions", "$schema", "additionalProperties", "description", "title"];
+function isPlainSchemaObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function resolveLocalSchemaRef(fragment, root) {
+    const ref = fragment.$ref;
+    if (typeof ref !== "string")
+        return fragment;
+    const m = /^#\/(\$defs|definitions)\/([^/]+)$/.exec(ref);
+    if (m === null)
+        return fragment;
+    const bucket = root[m[1]];
+    if (!isPlainSchemaObject(bucket))
+        return fragment;
+    const resolved = bucket[m[2]];
+    return isPlainSchemaObject(resolved) ? resolved : fragment;
+}
+function summarizeSchemaBranch(branch) {
+    if (!isPlainSchemaObject(branch))
+        return null;
+    const required = branch.required;
+    if (Array.isArray(required) && required.length > 0 && required.every((n) => typeof n === "string")) {
+        return required.join(", ");
+    }
+    const properties = branch.properties;
+    if (isPlainSchemaObject(properties)) {
+        const names = Object.keys(properties);
+        if (names.length > 0)
+            return names.join(", ");
+    }
+    return null;
+}
+function buildSchemaFlattenNote(combinators, schema, hasAnyOfOrOneOf) {
+    if (!hasAnyOfOrOneOf) {
+        return "Input constraint: all listed parameters apply together (flattened from a JSON Schema allOf).";
+    }
+    const key = combinators.includes("oneOf") ? "oneOf" : "anyOf";
+    const branches = schema[key];
+    const summaries = Array.isArray(branches)
+        ? [...new Set(branches.map((b) => summarizeSchemaBranch(isPlainSchemaObject(b) ? resolveLocalSchemaRef(b, schema) : b)).filter((s) => s !== null))]
+        : [];
+    const verb = key === "oneOf" ? "Provide parameters for exactly one of" : "Provide parameters for at least one of";
+    if (summaries.length === 0)
+        return `Input constraint: ${verb} the documented parameter groups (flattened from a JSON Schema ${key}).`;
+    return `Input constraint: ${verb}: ${summaries.map((s) => `(${s})`).join(" or ")}.`;
+}
+export function normalizeMcpToolSchema(schema) {
+    if (!isPlainSchemaObject(schema))
+        return { outcome: "unchanged" };
+    const combinatorsPresent = MCP_SCHEMA_COMBINATOR_KEYS.filter((k) => k in schema);
+    if (combinatorsPresent.length === 0)
+        return { outcome: "unchanged" };
+    try {
+        const properties = Object.create(null);
+        const collectProps = (propsObj) => {
+            if (!isPlainSchemaObject(propsObj))
+                return;
+            for (const [name, propSchema] of Object.entries(propsObj)) {
+                if (MCP_SCHEMA_PROP_NAME_RE.test(name) && !(name in properties) && isPlainSchemaObject(propSchema)) {
+                    properties[name] = propSchema;
+                }
+            }
+        };
+        collectProps(schema.properties);
+        for (const key of combinatorsPresent) {
+            const branches = schema[key];
+            if (!Array.isArray(branches)) {
+                return { outcome: "drop", reason: `input schema has top-level ${key} that is not an array` };
+            }
+            for (const branch of branches) {
+                if (isPlainSchemaObject(branch))
+                    collectProps(resolveLocalSchemaRef(branch, schema).properties);
+            }
+        }
+        const required = new Set();
+        const collectRequired = (reqArr) => {
+            if (!Array.isArray(reqArr))
+                return;
+            for (const name of reqArr) {
+                if (typeof name === "string" && name in properties)
+                    required.add(name);
+            }
+        };
+        collectRequired(schema.required);
+        const allOfBranches = schema.allOf;
+        if (Array.isArray(allOfBranches)) {
+            for (const branch of allOfBranches) {
+                if (isPlainSchemaObject(branch))
+                    collectRequired(resolveLocalSchemaRef(branch, schema).required);
+            }
+        }
+        const hasAnyOfOrOneOf = combinatorsPresent.includes("anyOf") || combinatorsPresent.includes("oneOf");
+        const flattened = { type: "object", properties, required: [...required] };
+        for (const key of MCP_SCHEMA_CARRY_KEYS) {
+            if (key in schema)
+                flattened[key] = schema[key];
+        }
+        const note = buildSchemaFlattenNote(combinatorsPresent, schema, hasAnyOfOrOneOf);
+        return { outcome: "normalized", schema: flattened, note, combinators: combinatorsPresent };
+    }
+    catch {
+        return { outcome: "drop", reason: `input schema uses top-level ${combinatorsPresent.join("/")} and could not be normalized` };
+    }
+}
 export function mcpToolSchemaProblem(schema) {
     if (schema === undefined)
         return undefined;
@@ -512,7 +665,8 @@ export async function materializeMcpTools(specs, principal, onElicit, imageResiz
                     continue;
                 }
                 try {
-                    const listed = await h.client.listTools(undefined, undefined);
+                    const listed = await listToolsLenient(h.client);
+                    cacheMcpToolMetadata(h.client, listed.tools);
                     const { serverTools, serverAxes, dropped } = intakeListedTools(listed, h.spec, h.client, h.health, imageResizer);
                     const newNames = serverTools.map((t) => t.name);
                     const added = newNames.filter((n) => !h.toolNames.includes(n));
@@ -600,14 +754,14 @@ function resourceLine(r) {
 function serverNames(servers) {
     return servers.map((r) => r.server).join(", ") || "(none)";
 }
-async function readDirViaExtension(rs, uri, signal, timeoutMs) {
+async function readDirViaExtension(rs, uri, signal, timeoutMs, watchdog) {
     const resources = [];
     let cursor;
     let pages = 0;
     do {
         let page;
         try {
-            page = await rs.client.request({ method: "resources/directory/read", params: { uri, ...(cursor !== undefined ? { cursor } : {}) } }, ListResourcesResultSchema, { signal, timeout: timeoutMs });
+            page = await rs.client.request({ method: "resources/directory/read", params: { uri, ...(cursor !== undefined ? { cursor } : {}) } }, ListResourcesResultSchema, { signal: watchdog.combinedSignal, timeout: timeoutMs });
         }
         catch (err) {
             if (err instanceof McpError && err.code === ErrorCode.InvalidParams) {
@@ -622,6 +776,7 @@ async function readDirViaExtension(rs, uri, signal, timeoutMs) {
             }
             throw err;
         }
+        watchdog.rearm();
         resources.push(...page.resources);
         cursor = page.nextCursor;
         pages++;
@@ -689,8 +844,10 @@ function buildResourceTools(resourceServers) {
                         sections.push(`[${rs.server}] Error: server disconnected — its resources are unavailable.`);
                         continue;
                     }
+                    const idleMs = mcpIdleTimeoutMs(rs.transportKind);
+                    const watchdog = armMcpIdleWatchdog(rs.health, idleMs, signal);
                     try {
-                        const res = await rs.client.listResources(undefined, { signal, timeout: mcpToolTimeoutMs() });
+                        const res = await rs.client.listResources(undefined, { signal: watchdog.combinedSignal, timeout: mcpToolTimeoutMs() });
                         all.push(...res.resources.map((r) => ({ server: rs.server, ...r })));
                         const lines = res.resources.map((r) => resourceLine(r));
                         sections.push(`[${rs.server}]\n${lines.length ? lines.join("\n") : "(no resources)"}`);
@@ -698,10 +855,17 @@ function buildResourceTools(resourceServers) {
                     catch (err) {
                         if (signal?.aborted)
                             throw err;
-                        const msg = err instanceof Error ? err.message : String(err);
+                        const msg = watchdog.idleSignal.reason === IDLE_WATCHDOG_ABORT_REASON
+                            ? `received no response for ${idleMs}ms (idle watchdog; set MCP_IDLE_TIMEOUT_STDIO / MCP_IDLE_TIMEOUT_HTTP to change this bound)`
+                            : err instanceof Error
+                                ? err.message
+                                : String(err);
                         errors.push({ server: rs.server, error: msg });
                         sections.push(`[${rs.server}] Error: could not list resources: ${inlineUntrusted(msg)}`);
                     }
+                    finally {
+                        watchdog.dispose();
+                    }
                 }
                 const body = sections.join("\n\n");
                 return {
@@ -739,9 +903,17 @@ function buildResourceTools(resourceServers) {
                 if (rs.health.dead)
                     throwDeadServer(server, what);
                 const timeoutMs = mcpToolTimeoutMs();
-                const res = await rs.client
-                    .readResource({ uri }, { signal, timeout: timeoutMs })
-                    .catch((err) => rethrowHonestMcpError(err, { server, what, timeoutMs, writeEffect: false, signal, attributeServer: true }));
+                const idleMs = mcpIdleTimeoutMs(rs.transportKind);
+                const watchdog = armMcpIdleWatchdog(rs.health, idleMs, signal);
+                let res;
+                try {
+                    res = await rs.client
+                        .readResource({ uri }, { signal: watchdog.combinedSignal, timeout: timeoutMs })
+                        .catch((err) => rethrowHonestMcpError(err, { server, what, timeoutMs, writeEffect: false, signal, attributeServer: true, idle: { signal: watchdog.idleSignal, idleMs } }));
+                }
+                finally {
+                    watchdog.dispose();
+                }
                 const text = (await Promise.all((res.contents ?? []).map(async (c) => {
                     if ("text" in c && typeof c.text === "string")
                         return c.text;
@@ -783,48 +955,103 @@ function buildResourceTools(resourceServers) {
                 if (rs.health.dead)
                     throwDeadServer(server, what);
                 const timeoutMs = mcpToolTimeoutMs();
-                const ext = rs.client.getServerCapabilities()?.extensions?.[MCP_SKILLS_EXTENSION];
-                if (ext?.directoryRead === true) {
-                    const r = await readDirViaExtension(rs, uri, signal, timeoutMs).catch((err) => rethrowHonestMcpError(err, { server, what, timeoutMs, writeEffect: false, signal, attributeServer: true }));
-                    if (r.kind === "not_directory") {
-                        return {
-                            content: [{ type: "text", text: `Not a directory resource: ${inlineUntrusted(uri)}. If it is a file resource, use ${READ_MCP_RESOURCE} instead.` }],
-                            details: { resources: [] },
-                            terminate: false,
-                        };
+                const idleMs = mcpIdleTimeoutMs(rs.transportKind);
+                const watchdog = armMcpIdleWatchdog(rs.health, idleMs, signal);
+                try {
+                    const ext = rs.client.getServerCapabilities()?.extensions?.[MCP_SKILLS_EXTENSION];
+                    if (ext?.directoryRead === true) {
+                        const r = await readDirViaExtension(rs, uri, signal, timeoutMs, watchdog).catch((err) => rethrowHonestMcpError(err, { server, what, timeoutMs, writeEffect: false, signal, attributeServer: true, idle: { signal: watchdog.idleSignal, idleMs } }));
+                        if (r.kind === "not_directory") {
+                            return {
+                                content: [{ type: "text", text: `Not a directory resource: ${inlineUntrusted(uri)}. If it is a file resource, use ${READ_MCP_RESOURCE} instead.` }],
+                                details: { resources: [] },
+                                terminate: false,
+                            };
+                        }
+                        if (r.kind === "ok")
+                            return renderDirChildren(server, uri, r.resources, { truncated: r.truncated, incomplete: r.incomplete, cursorInvalid: r.cursorInvalid });
+                        watchdog.rearm();
                     }
-                    if (r.kind === "ok")
-                        return renderDirChildren(server, uri, r.resources, { truncated: r.truncated, incomplete: r.incomplete, cursorInvalid: r.cursorInvalid });
+                    const res = await rs.client
+                        .listResources(undefined, { signal: watchdog.combinedSignal, timeout: timeoutMs })
+                        .catch((err) => rethrowHonestMcpError(err, { server, what, timeoutMs, writeEffect: false, signal, attributeServer: true, idle: { signal: watchdog.idleSignal, idleMs } }));
+                    const children = res.resources.filter((r) => typeof r.uri === "string" && r.uri !== uri && r.uri.startsWith(uri));
+                    return renderDirChildren(server, uri, children);
+                }
+                finally {
+                    watchdog.dispose();
                 }
-                const res = await rs.client
-                    .listResources(undefined, { signal, timeout: timeoutMs })
-                    .catch((err) => rethrowHonestMcpError(err, { server, what, timeoutMs, writeEffect: false, signal, attributeServer: true }));
-                const children = res.resources.filter((r) => typeof r.uri === "string" && r.uri !== uri && r.uri.startsWith(uri));
-                return renderDirChildren(server, uri, children);
             },
         });
         axes.push({ name: READ_MCP_RESOURCE_DIR, effect: "read" });
     }
     return { tools, axes };
 }
+function cacheMcpToolMetadata(client, tools) {
+    const withCache = client;
+    if (typeof withCache.cacheToolMetadata !== "function")
+        return;
+    try {
+        withCache.cacheToolMetadata(tools);
+    }
+    catch {
+    }
+}
+const LenientListToolsResultSchema = {
+    safeParse(data) {
+        if (typeof data !== "object" || data === null)
+            return { success: false, error: new Error("tools/list result is not an object") };
+        const rawTools = data.tools;
+        if (!Array.isArray(rawTools))
+            return { success: false, error: new Error("tools/list result.tools is not an array") };
+        const tools = [];
+        for (const raw of rawTools) {
+            if (typeof raw !== "object" || raw === null || typeof raw.name !== "string") {
+                return { success: false, error: new Error("a tools/list entry is missing a string name") };
+            }
+            const t = raw;
+            tools.push({
+                name: t.name,
+                ...(typeof t.description === "string" ? { description: t.description } : {}),
+                inputSchema: t.inputSchema,
+                ...(t.annotations !== undefined ? { annotations: t.annotations } : {}),
+                ...(t._meta !== undefined ? { _meta: t._meta } : {}),
+                ...(t.outputSchema !== undefined ? { outputSchema: t.outputSchema } : {}),
+                ...(t.execution !== undefined ? { execution: t.execution } : {}),
+            });
+        }
+        const nextCursor = data.nextCursor;
+        return { success: true, data: { tools, ...(typeof nextCursor === "string" ? { nextCursor } : {}) } };
+    },
+};
+async function listToolsLenient(client, options) {
+    return client.request({ method: "tools/list", params: {} }, LenientListToolsResultSchema, options);
+}
 async function connectServer(spec, principal, onElicit, imageResizer) {
     const elicitOn = spec.elicitation === true && onElicit !== undefined;
+    const health = { dead: false, pendingElicitations: 0, lastElicitationClosedAt: 0 };
     const client = new Client({ name: `sema-core/${spec.name}`, version: "0.1.0" }, { capabilities: elicitOn ? { elicitation: { form: {} } } : {} });
     if (elicitOn) {
         client.setRequestHandler(ElicitRequestSchema, async (request, extra) => {
-            const p = request.params;
-            const req = {
-                server: spec.name,
-                message: typeof p.message === "string" ? p.message : "",
-                ...(p.requestedSchema !== undefined ? { requestedSchema: p.requestedSchema } : {}),
-                ...(principal !== undefined ? { principal } : {}),
-            };
-            const answer = await onElicit(req, extra?.signal);
-            return answer.action === "accept" ? { action: "accept", content: answer.content ?? {} } : { action: answer.action };
+            health.pendingElicitations++;
+            try {
+                const p = request.params;
+                const req = {
+                    server: spec.name,
+                    message: typeof p.message === "string" ? p.message : "",
+                    ...(p.requestedSchema !== undefined ? { requestedSchema: p.requestedSchema } : {}),
+                    ...(principal !== undefined ? { principal } : {}),
+                };
+                const answer = await onElicit(req, extra?.signal);
+                return answer.action === "accept" ? { action: "accept", content: answer.content ?? {} } : { action: answer.action };
+            }
+            finally {
+                health.pendingElicitations--;
+                health.lastElicitationClosedAt = Date.now();
+            }
         });
     }
     const transport = buildTransport(spec, principal);
-    const health = { dead: false };
     const announce = {};
     const startupMs = mcpStartupTimeoutMs();
     const startupOpts = startupMs !== undefined ? { timeout: startupMs } : undefined;
@@ -834,7 +1061,8 @@ async function connectServer(spec, principal, onElicit, imageResizer) {
             health.dead = true;
             announce.fn?.();
         };
-        const listed = await client.listTools(undefined, startupOpts);
+        const listed = await listToolsLenient(client, startupOpts);
+        cacheMcpToolMetadata(client, listed.tools);
         const { serverTools, serverAxes, dropped } = intakeListedTools(listed, spec, client, health, imageResizer);
         const caps = client.getServerCapabilities();
         const resourceInfo = caps?.resources
@@ -860,7 +1088,7 @@ async function connectServer(spec, principal, onElicit, imageResizer) {
             axes: serverAxes,
             dropped,
             ...(instructions ? { instructions } : {}),
-            ...(resourceInfo && (resourceInfo.listAllowed || resourceInfo.readAllowed) ? { resourceServer: { server: spec.name, client, health, ...resourceInfo } } : {}),
+            ...(resourceInfo && (resourceInfo.listAllowed || resourceInfo.readAllowed) ? { resourceServer: { server: spec.name, client, health, transportKind: idleKindOf(spec), ...resourceInfo } } : {}),
         };
     }
     catch (err) {
@@ -876,7 +1104,18 @@ function intakeListedTools(listed, spec, client, health, imageResizer) {
         if (spec.allowTools && !spec.allowTools.includes(t.name)) {
             continue;
         }
-        const schemaProblem = mcpToolSchemaProblem(t.inputSchema);
+        const normalized = normalizeMcpToolSchema(t.inputSchema);
+        let effectiveInputSchema = t.inputSchema;
+        let effectiveDescription = t.description;
+        if (normalized.outcome === "drop") {
+            dropped.push({ tool: inlineUntrusted(t.name), reason: inlineUntrusted(normalized.reason, 240) });
+            continue;
+        }
+        if (normalized.outcome === "normalized") {
+            effectiveInputSchema = normalized.schema;
+            effectiveDescription = normalized.note + (t.description ? `\n\n${t.description}` : "");
+        }
+        const schemaProblem = mcpToolSchemaProblem(effectiveInputSchema);
         if (schemaProblem !== undefined) {
             dropped.push({ tool: inlineUntrusted(t.name), reason: inlineUntrusted(schemaProblem, 240) });
             continue;
@@ -898,24 +1137,32 @@ function intakeListedTools(listed, spec, client, health, imageResizer) {
         const mcpMaxResultSizeChars = resolveMcpDeclaredResultSize(t._meta);
         serverTools.push({
             name: namespacedName,
-            description: t.description ?? `MCP tool ${remoteName} from ${spec.name}`,
+            description: effectiveDescription ?? `MCP tool ${remoteName} from ${spec.name}`,
             label: `${spec.name}:${remoteName}`,
-            parameters: (t.inputSchema ?? { type: "object" }),
+            parameters: (effectiveInputSchema ?? { type: "object" }),
             ...(mcpMaxResultSizeChars !== undefined ? { mcpMaxResultSizeChars } : {}),
             execute: async (_toolCallId, params, signal) => {
                 const what = `The call to tool ${inlineUntrusted(remoteName)}`;
                 if (health.dead)
                     throwDeadServer(spec.name, what);
                 const timeoutMs = mcpToolTimeoutMs();
-                const res = await client
-                    .callTool({ name: remoteName, arguments: (params ?? {}) }, undefined, {
-                    signal,
-                    timeout: timeoutMs,
-                    resetTimeoutOnProgress: true,
-                    onprogress: () => { },
-                    maxTotalTimeout: mcpToolTotalTimeoutMs(timeoutMs),
-                })
-                    .catch((err) => rethrowHonestMcpError(err, { server: spec.name, what, timeoutMs, writeEffect, signal }));
+                const idleMs = mcpIdleTimeoutMs(idleKindOf(spec));
+                const watchdog = armMcpIdleWatchdog(health, idleMs, signal);
+                let res;
+                try {
+                    res = await client
+                        .callTool({ name: remoteName, arguments: (params ?? {}) }, undefined, {
+                        signal: watchdog.combinedSignal,
+                        timeout: timeoutMs,
+                        resetTimeoutOnProgress: true,
+                        onprogress: () => watchdog.rearm(),
+                        maxTotalTimeout: mcpToolTotalTimeoutMs(timeoutMs),
+                    })
+                        .catch((err) => rethrowHonestMcpError(err, { server: spec.name, what, timeoutMs, writeEffect, signal, idle: { signal: watchdog.idleSignal, idleMs } }));
+                }
+                finally {
+                    watchdog.dispose();
+                }
                 const mapped = await mapContent(res.content, spec.name, imageResizer);
                 if (res.isError === true) {
                     const parts = [];
@@ -955,4 +1202,3 @@ function asServerWarning(spec, err) {
     warning.code = "mcp.server_unavailable";
     return warning;
 }
-//# sourceMappingURL=mcp.js.map

package/dist/core/media-byte-cap.d.ts

@@ -10,4 +10,3 @@ export declare function capAggregateMediaBytes(messages: AgentMessage[], opts: {
     limitBytes: number;
     onStripped?: (info: MediaStripInfo) => void;
 }): AgentMessage[];
-//# sourceMappingURL=media-byte-cap.d.ts.map

package/dist/core/media-byte-cap.js

@@ -48,4 +48,3 @@ export function capAggregateMediaBytes(messages, opts) {
         opts.onStripped?.({ totalBytes: total, limitBytes, removedCount, removedBytes });
     return out;
 }
-//# sourceMappingURL=media-byte-cap.js.map

package/dist/core/memory-engine/data-plane.d.ts

@@ -57,4 +57,3 @@ export interface InboundEntryFinding {
 export declare function screenInboundEntries(entries: readonly MemoryEntry[], opts?: {
     perFileBytes?: number;
 }): InboundEntryFinding[];
-//# sourceMappingURL=data-plane.d.ts.map

package/dist/core/memory-engine/data-plane.js

@@ -195,4 +195,3 @@ function revOf(text, id) {
     const parsed = parseEntryFile(text);
     return computeEntryRev({ id, frontmatter: parsed.frontmatter, body: parsed.body });
 }
-//# sourceMappingURL=data-plane.js.map

package/dist/core/memory-engine/dual-root.d.ts

@@ -13,4 +13,3 @@ export declare function needsDualRoots(planes: ScopePlanes): boolean;
 export declare function parsedProjectPlane(planes: ScopePlanes, writeScope: string | null): ParsedScopeKey[];
 export declare function mergeInjections(project: MemoryInjection | undefined, personal: MemoryInjection | undefined): MemoryInjection;
 export declare function mergeHarvestReports(a: HarvestReport, b: HarvestReport): HarvestReport;
-//# sourceMappingURL=dual-root.d.ts.map

package/dist/core/memory-engine/dual-root.js

@@ -72,4 +72,3 @@ export function mergeHarvestReports(a, b) {
         merged.quarantineFailures = qf;
     return merged;
 }
-//# sourceMappingURL=dual-root.js.map

package/dist/core/memory-engine/engine.d.ts

@@ -64,4 +64,3 @@ export declare class MemoryEngine {
 }
 export declare function renderAnnouncements(queue: readonly MemoryAnnouncement[], folded: number): string;
 export declare function truncateIndex(text: string): string;
-//# sourceMappingURL=engine.d.ts.map

package/dist/core/memory-engine/engine.js

@@ -839,4 +839,3 @@ function chmodSafe(path, mode) {
 function needsCompletion(parsed, fm) {
     return !parsed.hadFrontmatter || parsed.frontmatter.name !== fm.name || parsed.frontmatter.description !== fm.description;
 }
-//# sourceMappingURL=engine.js.map

package/dist/core/memory-engine/file-backend.d.ts

@@ -52,4 +52,3 @@ export declare class FileMemoryEngineBackend implements MemoryBackend {
     private readCursors;
 }
 export { scopeDirName };
-//# sourceMappingURL=file-backend.d.ts.map

package/dist/core/memory-engine/file-backend.js

@@ -782,4 +782,3 @@ function readSafe(path) {
     }
 }
 export { scopeDirName };
-//# sourceMappingURL=file-backend.js.map

package/dist/core/memory-engine/frontmatter.d.ts

@@ -10,4 +10,3 @@ export declare function parseEntryFile(text: string): ParsedEntryFile;
 export declare function serializeEntryFile(entry: Pick<MemoryEntry, "id" | "frontmatter" | "body">): string;
 export declare function computeEntryRev(entry: Pick<MemoryEntry, "id" | "frontmatter" | "body">): string;
 export declare function entryFromFile(text: string, id: string, slug: string, scope: string): MemoryEntry;
-//# sourceMappingURL=frontmatter.d.ts.map

package/dist/core/memory-engine/frontmatter.js

@@ -177,4 +177,3 @@ export function entryFromFile(text, id, slug, scope) {
     entry.rev = computeEntryRev(entry);
     return entry;
 }
-//# sourceMappingURL=frontmatter.js.map

package/dist/core/memory-engine/index.d.ts

@@ -10,4 +10,3 @@ export { migrateScope, type MigrateScopeReport } from "./migrate.js";
 export { materializeEntriesToFiles, harvestFilesToPatches, projectionsToWriteBack, screenInboundEntries, REMOTE_HARVEST_PER_FILE_BYTES, REMOTE_MASS_DELETION_FUSE_RATIO, type RemoteMemoryFile, type RemoteMemoryBaseline, type RemoteMaterialization, type RemoteHarvestResult, type InboundEntryFinding, } from "./data-plane.js";
 export { reconcileMemoryEntries, nextSyncBaseline, mergeRecallHits, type MemorySyncCursor, type MemorySyncConflict, type MemorySyncPlan, type RecallSource, } from "./sync.js";
 export { syncMemoryScope, type MemorySyncTransport, type MemorySyncRequestBody, type MemorySyncResponseBody, type MemorySyncClientConflict, type SyncMemoryScopeOptions, type MemorySyncClientResult, } from "./sync-client.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/core/memory-engine/index.js

@@ -9,4 +9,3 @@ export { migrateScope } from "./migrate.js";
 export { materializeEntriesToFiles, harvestFilesToPatches, projectionsToWriteBack, screenInboundEntries, REMOTE_HARVEST_PER_FILE_BYTES, REMOTE_MASS_DELETION_FUSE_RATIO, } from "./data-plane.js";
 export { reconcileMemoryEntries, nextSyncBaseline, mergeRecallHits, } from "./sync.js";
 export { syncMemoryScope, } from "./sync-client.js";
-//# sourceMappingURL=index.js.map

package/dist/core/memory-engine/layout.d.ts

@@ -41,4 +41,3 @@ export declare function scanFuseCount(controlDir: string, key: string): number;
 export declare function clearScanFuse(controlDir: string, keys: Iterable<string>): void;
 export declare function atomicWriteFileSync(path: string, data: string): void;
 export {};
-//# sourceMappingURL=layout.d.ts.map

package/dist/core/memory-engine/layout.js

@@ -456,4 +456,3 @@ export function atomicWriteFileSync(path, data) {
         throw err;
     }
 }
-//# sourceMappingURL=layout.js.map

package/dist/core/memory-engine/memory-backend-contract.d.ts

@@ -7,4 +7,3 @@ export interface MemoryBackendContractHooks {
 }
 export declare function memoryBackendContract(hooks: MemoryBackendContractHooks): Promise<void>;
 export declare function assertMemoryBackendSearchEquivalence(a: MemoryBackend, b: MemoryBackend): Promise<void>;
-//# sourceMappingURL=memory-backend-contract.d.ts.map

package/dist/core/memory-engine/memory-backend-contract.js

@@ -311,4 +311,3 @@ export async function assertMemoryBackendSearchEquivalence(a, b) {
         assert.deepStrictEqual(pa, pb, `search("${q}") diverged between backends`);
     }
 }
-//# sourceMappingURL=memory-backend-contract.js.map

package/dist/core/memory-engine/migrate.d.ts

@@ -5,4 +5,3 @@ export interface MigrateScopeReport {
     cursorMoved: boolean;
 }
 export declare function migrateScope(backend: MemoryBackend, fromScope: string, toScope: string): Promise<MigrateScopeReport>;
-//# sourceMappingURL=migrate.d.ts.map

package/dist/core/memory-engine/migrate.js

@@ -20,4 +20,3 @@ export async function migrateScope(backend, fromScope, toScope) {
     }
     return { moved: report.applied.length, conflicts: report.conflicts, cursorMoved };
 }
-//# sourceMappingURL=migrate.js.map

package/dist/core/memory-engine/scan.d.ts

@@ -5,4 +5,3 @@ export declare function scanMemoryWrite(text: string, opts?: {
     maxBytes?: number;
 }): ScanFinding[];
 export declare function scanRemediation(code: ScanFinding["code"]): string;
-//# sourceMappingURL=scan.d.ts.map

package/dist/core/memory-engine/scan.js

@@ -46,4 +46,3 @@ export function scanRemediation(code) {
             return "Split the content into smaller topic files, or trim it.";
     }
 }
-//# sourceMappingURL=scan.js.map

package/dist/core/memory-engine/scope-contract.d.ts

@@ -41,4 +41,3 @@ export declare function resolveProjectId(rootDir: string): {
     projectId: string;
     markerDir: string;
 } | null;
-//# sourceMappingURL=scope-contract.d.ts.map

package/dist/core/memory-engine/scope-contract.js

@@ -202,4 +202,3 @@ export function resolveProjectId(rootDir) {
         return null;
     return { projectId: parsed.projectId, markerDir: projectRoot };
 }
-//# sourceMappingURL=scope-contract.js.map

package/dist/core/memory-engine/sync-client.d.ts

@@ -63,4 +63,3 @@ export interface MemorySyncClientResult {
     warnings?: string[];
 }
 export declare function syncMemoryScope(opts: SyncMemoryScopeOptions): Promise<MemorySyncClientResult>;
-//# sourceMappingURL=sync-client.d.ts.map