@sema-agent/core 1.424.0 → 1.425.0

package/dist/core/auto-compaction.d.ts

@@ -67,6 +67,10 @@ export interface MaybeCompactOptions {
         maxCharsPerFile?: number;
         recentlyReadFiles?: () => string[];
     };
+    onApplied?: (attachedComplete: ReadonlyArray<{
+        path: string;
+        content: string;
+    }>) => void;
     overheadTokens?: number;
     summaryProvider?: (input: {
         messagesToSummarize: AgentMessage[];

package/dist/core/auto-compaction.js

@@ -315,6 +315,7 @@ export async function maybeCompact(opts) {
     const persistStartAt = summaryEndAt ?? Date.now();
     let summaryWithAttachments = summary;
     const attachedFiles = [];
+    const attachedComplete = [];
     const att = opts.workingFileAttachments;
     const recentlyRead = att?.recentlyReadFiles?.() ?? [];
     const candidateFiles = recentlyRead.length > 0 ? recentlyRead : (details?.modifiedFilesByRecency ?? details?.modifiedFiles);
@@ -343,6 +344,8 @@ export async function maybeCompact(opts) {
             remaining -= clipped.length;
             blocks.push(`<working-file path="${path}">\n${clipped}\n</working-file>`);
             attachedFiles.push({ path, chars: Math.min(content.length, cap), truncated: wasClipped });
+            if (!wasClipped)
+                attachedComplete.push({ path, content });
         }
         if (blocks.length > 0) {
             summaryWithAttachments +=
@@ -365,6 +368,11 @@ export async function maybeCompact(opts) {
         promptEpoch: restatedEpoch,
         ...(restatedListings !== undefined ? { announcedListings: restatedListings } : {}),
     }, false);
+    try {
+        opts.onApplied?.(attachedComplete);
+    }
+    catch {
+    }
     if (ca !== undefined) {
         try {
             ca.apply(restatedEpoch.artifactDigest);

package/dist/core/mcp.d.ts

@@ -64,6 +64,9 @@ export declare function truncateMcpErrorText(s: string): string;
 export declare const MCP_TOOL_TIMEOUT_DEFAULT_MS = 100000000;
 export declare function mcpToolTimeoutMs(): number;
 export declare function mcpToolTotalTimeoutMs(perCallMs: number): number;
+export declare const MCP_IDLE_TIMEOUT_STDIO_DEFAULT_MS: number;
+export declare const MCP_IDLE_TIMEOUT_HTTP_DEFAULT_MS: number;
+export declare function mcpIdleTimeoutMs(kind: "stdio" | "http"): number;
 export declare function normalizeMcpName(name: string): string;
 export declare function clampNameSegment(seg: string, max?: number): string;
 export declare const MCP_IMAGE_MAX_BASE64: number;
@@ -130,6 +133,18 @@ interface McpContentItem {
     };
 }
 export declare function mapContent(content: Array<McpContentItem>, serverName?: string, imageResizer?: McpImageResizer): Promise<Array<TextContent | ImageContent>>;
+export type McpSchemaNormalizeResult = {
+    outcome: "unchanged";
+} | {
+    outcome: "normalized";
+    schema: Record<string, unknown>;
+    note: string;
+    combinators: string[];
+} | {
+    outcome: "drop";
+    reason: string;
+};
+export declare function normalizeMcpToolSchema(schema: unknown): McpSchemaNormalizeResult;
 export declare function mcpToolSchemaProblem(schema: unknown): string | undefined;
 export declare function materializeMcpTools(specs: McpServerSpec[], principal?: string, onElicit?: OnElicit, imageResizer?: McpImageResizer): Promise<MaterializedMcp>;
 export {};

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 = [];

package/dist/core/runner/prepare-task.d.ts

@@ -194,6 +194,10 @@ export interface Prepared {
     promptOverheadTokens: number;
     readTaskFile?: (path: string) => Promise<string | null>;
     recentlyReadFiles?: () => string[];
+    onCompactionApplied?: (attachedComplete: ReadonlyArray<{
+        path: string;
+        content: string;
+    }>) => void;
     lspDiagnostics?: {
         registry: import("../lsp-diagnostics.js").LspDiagnosticsRegistry;
         nudge: (rawPath: string) => void;

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

@@ -55,7 +55,7 @@ import { hasBackgroundShell, sweepBackgroundShells } from "../background-shell.j
 import { createTaskOutputTool, createTaskStopTool, defaultTaskRegistry } from "../task-registry.js";
 import { createMonitorTool } from "../../tools/monitor.js";
 import { createWorktreeTools } from "../../tools/worktree.js";
-import { bashReversibilityProbe, createHandsToolkit, seedReadFileStateFromContext, HAND_TOOL_EFFECTS, pdfModelCapabilitiesOf } from "../../tools/fs/index.js";
+import { applyCompactionToReadFileState, bashReversibilityProbe, createHandsToolkit, seedReadFileStateFromContext, HAND_TOOL_EFFECTS, pdfModelCapabilitiesOf } from "../../tools/fs/index.js";
 import { decodeTextBytes } from "../../tools/fs/encoding.js";
 import { ASK_USER_QUESTION_TOOL_NAME, createAskUserQuestionTool } from "../ask-question.js";
 import { createSchedulerTools } from "../../tools/scheduler-tools.js";
@@ -3286,9 +3286,13 @@ export async function prepareTask(spec, deps, sessions, resume, _memorySelector,
             : undefined;
         const recentlyReadFiles = handsEnabled && readFileStateForCheckpoint
             ? () => [...readFileStateForCheckpoint.entries()]
+                .filter(([, v]) => v.seededFromContext !== true)
                 .sort((a, b) => (b[1].lastReadAt ?? 0) - (a[1].lastReadAt ?? 0))
                 .map(([path]) => path)
             : undefined;
+        const onCompactionApplied = handsEnabled && readFileStateForCheckpoint
+            ? (attachedComplete) => applyCompactionToReadFileState(readFileStateForCheckpoint, attachedComplete)
+            : undefined;
         const detectExternalChanges = handsEnabled && readFileStateForCheckpoint
             ? async (maxFiles) => {
                 const candidates = [...readFileStateForCheckpoint.entries()]
@@ -3371,7 +3375,7 @@ export async function prepareTask(spec, deps, sessions, resume, _memorySelector,
             : undefined;
         overheadState.promptChars = systemPrompt.length;
         const preparedHolder = {};
-        const buildPrepared = () => ({ harness, session, sessionId, taskRootPath, model, thinking, compModel, mcp: mcp, blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, nestedStats, cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), denyNarrowingPolicy, ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), releaseSignal, cacheBreakDetector, cacheFingerprint, promptManifest, epochDeclaredSections, activeTools, ownedEnv, suspendRef, reviewRef, reviewRequestRef, suspendLoopRef, suspendForResource, ...(callCapRef ? { callCapRef } : {}), ...(cutKills ? { cutKills } : {}), ...(callCapRef ? { callIssuedAtRef } : {}), suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, promptOverheadTokens, readTaskFile, recentlyReadFiles, compactionReuseRef, trimPressureRef, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit } } : {}), planModeRef, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, listBackgroundTasks, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
+        const buildPrepared = () => ({ harness, session, sessionId, taskRootPath, model, thinking, compModel, mcp: mcp, blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, nestedStats, cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), denyNarrowingPolicy, ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), releaseSignal, cacheBreakDetector, cacheFingerprint, promptManifest, epochDeclaredSections, activeTools, ownedEnv, suspendRef, reviewRef, reviewRequestRef, suspendLoopRef, suspendForResource, ...(callCapRef ? { callCapRef } : {}), ...(cutKills ? { cutKills } : {}), ...(callCapRef ? { callIssuedAtRef } : {}), suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, promptOverheadTokens, readTaskFile, recentlyReadFiles, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit } } : {}), planModeRef, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, listBackgroundTasks, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
         const prepared = buildPrepared();
         preparedHolder.current = prepared;
         return prepared;

package/dist/core/runner/runtask.js

@@ -1826,6 +1826,7 @@ export class Runner {
                                     ...(typeof spec.compaction?.attachWorkingFiles === "object" ? spec.compaction.attachWorkingFiles : undefined),
                                 }
                                 : undefined,
+                            ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
                             ...this.seamCCompactionOptions(prepared),
                             ...windowSafetyOptions(prepared.harness.getModel()),
                             ...this.compactionHookOptions(spec, prepared.sessionId, "forced"),
@@ -2259,6 +2260,7 @@ export class Runner {
                             ...(typeof spec.compaction?.attachWorkingFiles === "object" ? spec.compaction.attachWorkingFiles : undefined),
                         }
                         : undefined,
+                    ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
                     ...this.seamCCompactionOptions(prepared),
                     ...windowSafetyOptions(event.model),
                     ...this.compactionHookOptions(spec, prepared.sessionId, trimPressure ? "forced" : forceManual ? "manual" : "auto"),
@@ -3540,6 +3542,7 @@ export class Runner {
                             ...(typeof spec.compaction?.attachWorkingFiles === "object" ? spec.compaction.attachWorkingFiles : undefined),
                         }
                         : undefined,
+                    ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
                     ...this.seamCCompactionOptions(prepared),
                     ...this.compactionHookOptions(spec, prepared.sessionId, "auto"),
                 });

package/dist/tools/fs/index.d.ts

@@ -10,6 +10,10 @@ export type ReadImageDownsamplerOption = ImageDownsampler | false | undefined;
 export declare function msTimeoutToSec(timeoutMs: number | undefined): number;
 export declare function seededFileUnchangedReminder(filePath: string): string;
 export declare function seedReadFileStateFromContext(state: ReadFileState, key: string, content: string): void;
+export declare function applyCompactionToReadFileState(state: ReadFileState, attachedComplete: ReadonlyArray<{
+    path: string;
+    content: string;
+}>): void;
 export interface CwdRef {
     current: string;
 }

package/dist/tools/fs/index.js

@@ -73,6 +73,17 @@ export function seededFileUnchangedReminder(filePath) {
 export function seedReadFileStateFromContext(state, key, content) {
     state.set(key, { hash: sha256(content), totalLines: countLines(content), truncated: false, lastReadAt: Date.now(), seededFromContext: true });
 }
+export function applyCompactionToReadFileState(state, attachedComplete) {
+    for (const [k, v] of [...state]) {
+        if (v.seededFromContext !== true)
+            state.delete(k);
+    }
+    for (const f of attachedComplete) {
+        const totalLines = countLines(f.content);
+        const displayLines = f.content.length === 0 ? 0 : f.content.split("\n").length;
+        state.set(f.path, { hash: sha256(f.content), totalLines, truncated: false, view: { start: 1, end: displayLines }, lastReadAt: Date.now() });
+    }
+}
 async function enoentMessage(env, key, cwd, signal) {
     let msg = `File does not exist. Note: your current working directory is ${cwd}.`;
     const sep = Math.max(key.lastIndexOf("/"), key.lastIndexOf("\\"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "1.424.0",
+  "version": "1.425.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",