@sayknow-cli/coding-agent 0.4.7 → 0.5.1

package/src/runtime/memory-guard.ts

@@ -0,0 +1,292 @@
+import type { Settings } from "../config/settings";
+import type {
+	MemoryGuardActionTarget,
+	MemoryGuardDecision,
+	MemoryGuardDomainSnapshot,
+	MemoryGuardPolicy,
+	MemoryGuardSchedulerState,
+} from "./memory-guard-contract";
+
+const BYTES_PER_MB = 1024 * 1024;
+const DEFAULT_CHECK_INTERVAL_MS = 30_000;
+
+type ScheduleOwner = { generation: number; token: number };
+type DeferredSchedule = { generation: number; deadline: number };
+type WorkOwner = { generation: number; source: "timer" | "external" };
+
+export interface MemoryGuardHostRegistration {
+	ownerId: string;
+	intervalMs: number;
+}
+
+export interface MemoryGuardHostOptions {
+	run: () => Promise<void>;
+	logDebug?: (message: string, meta?: Record<string, unknown>) => void;
+	schedulerNow?: () => number;
+}
+
+function normalizePositiveIntervalMs(intervalMs: number): number {
+	if (!Number.isFinite(intervalMs) || intervalMs <= 0) throw new Error("invalid_interval_ms");
+	return intervalMs;
+}
+
+function toRatio(percent: number): number {
+	return percent / 100;
+}
+
+function mbToBytes(value: number): number {
+	return Math.round(value * BYTES_PER_MB);
+}
+
+function sortTargets(left: MemoryGuardActionTarget, right: MemoryGuardActionTarget): number {
+	if (left.excessBytes !== right.excessBytes) return right.excessBytes - left.excessBytes;
+	if (left.kind !== right.kind) return left.kind === "host" ? -1 : 1;
+	if (left.kind === "worker" && right.kind === "worker") return left.workerId.localeCompare(right.workerId);
+	return 0;
+}
+
+export function resolveMemoryGuardPolicy(settings: Settings): MemoryGuardPolicy {
+	const configuredPolicyLimitMb = settings.get("memoryGuard.policyLimitMb");
+	return {
+		enabled: settings.get("memoryGuard.enabled"),
+		checkIntervalMs: settings.get("memoryGuard.checkIntervalMs"),
+		gcThresholdRatio: toRatio(settings.get("memoryGuard.gcThresholdPercent")),
+		restartThresholdRatio: toRatio(settings.get("memoryGuard.restartThresholdPercent")),
+		restartThresholdWindowMs: settings.get("memoryGuard.restartThresholdWindowMs"),
+		cooldownMs: settings.get("memoryGuard.cooldownMs"),
+		parentReserveBytes: mbToBytes(settings.get("memoryGuard.parentReserveMb")),
+		policyLimitBytes: configuredPolicyLimitMb > 0 ? mbToBytes(configuredPolicyLimitMb) : null,
+	};
+}
+
+export function chooseMemoryGuardAction(input: {
+	domain: MemoryGuardDomainSnapshot;
+	hostSupported: boolean;
+	workerSupported: (workerId: string) => boolean;
+}): MemoryGuardDecision {
+	const candidates: MemoryGuardActionTarget[] = [];
+	if (input.hostSupported && input.domain.hostExcessBytes > 0) {
+		candidates.push({ kind: "host", excessBytes: input.domain.hostExcessBytes });
+	}
+	for (const worker of input.domain.workers) {
+		if (!worker.accepted || worker.excessBytes <= 0 || !input.workerSupported(worker.workerId)) continue;
+		candidates.push({ kind: "worker", workerId: worker.workerId, excessBytes: worker.excessBytes });
+	}
+	if (candidates.length > 0) {
+		candidates.sort(sortTargets);
+		return { kind: "execute", target: candidates[0]! };
+	}
+	const unsupportedExcessExists =
+		input.domain.hostExcessBytes > 0 ||
+		input.domain.workers.some(worker => worker.accepted && worker.excessBytes > 0);
+	if (unsupportedExcessExists) return { kind: "noop", reason: "memory_guard_action_noop_unsupported" };
+	return { kind: "noop", reason: "memory_guard_action_noop_unmanaged_or_within_allowance" };
+}
+
+export function revalidateMemoryGuardAction(
+	previous: Extract<MemoryGuardDecision, { kind: "execute" }>,
+	revalidated: MemoryGuardDecision,
+): MemoryGuardDecision {
+	if (revalidated.kind !== "execute")
+		return { kind: "revalidated_out", reason: "memory_guard_action_revalidated_out" };
+	if (previous.target.kind !== revalidated.target.kind)
+		return { kind: "revalidated_out", reason: "memory_guard_action_revalidated_out" };
+	if (
+		previous.target.kind === "worker" &&
+		revalidated.target.kind === "worker" &&
+		previous.target.workerId !== revalidated.target.workerId
+	) {
+		return { kind: "revalidated_out", reason: "memory_guard_action_revalidated_out" };
+	}
+	return revalidated;
+}
+
+export class MemoryGuardHost {
+	#run: () => Promise<void>;
+	#logDebug: (message: string, meta?: Record<string, unknown>) => void;
+	#defaultSchedulerNow: () => number;
+	#schedulerNow: () => number;
+	#registrations = new Map<string, { intervalMs: number; nextDueMs: number }>();
+	#pendingTimer: NodeJS.Timeout | null = null;
+	#pendingDeadline: number | null = null;
+	#pendingOwner: ScheduleOwner | null = null;
+	#deferredSchedule: DeferredSchedule | null = null;
+	#inProgressOwner: WorkOwner | null = null;
+	#stopped = false;
+	#generation = 0;
+	#nextTimerToken = 0;
+
+	constructor(options: MemoryGuardHostOptions) {
+		this.#run = options.run;
+		this.#logDebug = options.logDebug ?? (() => undefined);
+		this.#defaultSchedulerNow = options.schedulerNow ?? (() => performance.now());
+		this.#schedulerNow = this.#defaultSchedulerNow;
+	}
+
+	register(registration: MemoryGuardHostRegistration): () => void {
+		const intervalMs = normalizePositiveIntervalMs(registration.intervalMs);
+		const now = this.#schedulerNow();
+		const existing = this.#registrations.get(registration.ownerId);
+		const isNewRegistration = !existing;
+		const nextDueMs = existing ? Math.min(existing.nextDueMs, now + intervalMs) : now + intervalMs;
+		this.#registrations.set(registration.ownerId, { intervalMs, nextDueMs });
+		this.#stopped = false;
+		if (isNewRegistration) {
+			const deadline = nextDueMs;
+			if (
+				this.#inProgressOwner?.generation === this.#generation &&
+				(this.#pendingDeadline === null || this.#pendingDeadline <= deadline)
+			) {
+				this.#deferSchedule(this.#generation, deadline);
+			} else {
+				this.#requestSchedule(deadline);
+			}
+		}
+		let unregistered = false;
+		return () => {
+			if (unregistered) return;
+			unregistered = true;
+			this.#registrations.delete(registration.ownerId);
+			if (this.#registrations.size === 0) this.#stop();
+		};
+	}
+
+	updateInterval(ownerId: string, intervalMs: number): void {
+		const existing = this.#registrations.get(ownerId);
+		if (!existing) return;
+		const normalized = normalizePositiveIntervalMs(intervalMs);
+		if (existing.intervalMs === normalized) return;
+		const now = this.#schedulerNow();
+		const nextDueMs = now + normalized;
+		this.#registrations.set(ownerId, { intervalMs: normalized, nextDueMs });
+		if (this.#inProgressOwner) return;
+		const nextDeadline = this.#nextDeadlineMs();
+		if (this.#pendingDeadline !== null && nextDeadline > this.#pendingDeadline) {
+			this.#clearPendingSchedule();
+		}
+		this.#requestSchedule(nextDeadline);
+	}
+
+	async runTick(generation = this.#generation, source: WorkOwner["source"] = "external"): Promise<void> {
+		if (this.#inProgressOwner || this.#registrations.size === 0) return;
+		const owner: WorkOwner = { generation, source };
+		this.#inProgressOwner = owner;
+		try {
+			await this.#run();
+		} catch (error) {
+			this.#logDebug("memory guard tick failed", { error: error instanceof Error ? error.message : String(error) });
+		} finally {
+			if (this.#inProgressOwner === owner) this.#inProgressOwner = null;
+			this.#advanceDueTimes();
+			this.#reconcileCurrentSchedule();
+		}
+	}
+
+	async runTimerCallbackForTest(owner: { generation: number; token: number }, deadline: number): Promise<void> {
+		await this.#handleTimerCallback(owner, deadline);
+	}
+
+	setSchedulerNowForTest(now: () => number): void {
+		this.#schedulerNow = now;
+	}
+
+	getStateForTest(): MemoryGuardSchedulerState {
+		return {
+			timerActive: this.#pendingTimer !== null,
+			registrationCount: this.#registrations.size,
+			inProgress: this.#inProgressOwner !== null,
+			generation: this.#generation,
+			pendingDeadline: this.#pendingDeadline,
+			pendingOwner: this.#pendingOwner ? { ...this.#pendingOwner } : null,
+			deferredDeadline: this.#deferredSchedule?.deadline ?? null,
+			deferredGeneration: this.#deferredSchedule?.generation ?? null,
+			activeGeneration: this.#inProgressOwner?.generation ?? null,
+		};
+	}
+
+	resetForTest(): void {
+		this.#stop();
+		this.#registrations.clear();
+		this.#inProgressOwner = null;
+		this.#deferredSchedule = null;
+		this.#nextTimerToken = 0;
+		this.#schedulerNow = this.#defaultSchedulerNow;
+	}
+
+	#nextDeadlineMs(): number {
+		let minDue = Number.POSITIVE_INFINITY;
+		for (const reg of this.#registrations.values()) {
+			minDue = Math.min(minDue, reg.nextDueMs);
+		}
+		return Number.isFinite(minDue) ? minDue : this.#schedulerNow() + DEFAULT_CHECK_INTERVAL_MS;
+	}
+
+	#advanceDueTimes(): void {
+		const now = this.#schedulerNow();
+		for (const reg of this.#registrations.values()) {
+			if (reg.nextDueMs <= now) {
+				reg.nextDueMs = now + reg.intervalMs;
+			}
+		}
+	}
+
+	#clearPendingSchedule(): void {
+		if (this.#pendingTimer) clearTimeout(this.#pendingTimer);
+		this.#pendingTimer = null;
+		this.#pendingDeadline = null;
+		this.#pendingOwner = null;
+	}
+
+	#requestSchedule(deadline: number): void {
+		if (this.#stopped || this.#registrations.size === 0) return;
+		if (this.#pendingDeadline !== null && this.#pendingDeadline <= deadline) return;
+		this.#clearPendingSchedule();
+		const owner = { generation: this.#generation, token: ++this.#nextTimerToken };
+		this.#pendingDeadline = deadline;
+		this.#pendingOwner = owner;
+		this.#pendingTimer = setTimeout(
+			() => {
+				void this.#handleTimerCallback(owner, deadline);
+			},
+			Math.max(0, deadline - this.#schedulerNow()),
+		);
+		this.#pendingTimer.unref?.();
+	}
+
+	#deferSchedule(generation: number, deadline: number): void {
+		if (generation !== this.#generation) return;
+		if (this.#deferredSchedule?.generation === generation) {
+			this.#deferredSchedule.deadline = Math.min(this.#deferredSchedule.deadline, deadline);
+			return;
+		}
+		this.#deferredSchedule = { generation, deadline };
+	}
+
+	async #handleTimerCallback(owner: ScheduleOwner, deadline: number): Promise<void> {
+		if (this.#pendingOwner?.generation !== owner.generation || this.#pendingOwner.token !== owner.token) return;
+		this.#pendingTimer = null;
+		this.#pendingDeadline = null;
+		this.#pendingOwner = null;
+		if (this.#inProgressOwner) {
+			this.#deferSchedule(owner.generation, deadline);
+			return;
+		}
+		await this.runTick(owner.generation, "timer");
+	}
+
+	#reconcileCurrentSchedule(): void {
+		if (this.#stopped || this.#registrations.size === 0 || this.#inProgressOwner) return;
+		const normalDeadline = this.#nextDeadlineMs();
+		const deferredDeadline =
+			this.#deferredSchedule?.generation === this.#generation ? this.#deferredSchedule.deadline : null;
+		if (deferredDeadline !== null) this.#deferredSchedule = null;
+		this.#requestSchedule(deferredDeadline === null ? normalDeadline : Math.min(deferredDeadline, normalDeadline));
+	}
+
+	#stop(): void {
+		this.#stopped = true;
+		this.#generation++;
+		this.#clearPendingSchedule();
+		this.#deferredSchedule = null;
+	}
+}

package/src/runtime/memory-limit.ts

@@ -0,0 +1,50 @@
+export interface EffectiveMemoryLimitInput {
+	hardCapBytes?: number | null;
+	policyLimitBytes?: number | null;
+}
+
+export interface EffectiveMemoryLimit {
+	hardCapBytes: number | null;
+	policyLimitBytes: number | null;
+	effectiveBytes: number | null;
+	source: "none" | "hard_cap" | "policy_limit" | "hard_cap_and_policy_limit";
+}
+
+function normalizePositiveByteCount(value: number | null | undefined): number | null {
+	return Number.isSafeInteger(value) && typeof value === "number" && value > 0 ? value : null;
+}
+
+export function resolveEffectiveMemoryLimit(input: EffectiveMemoryLimitInput): EffectiveMemoryLimit {
+	const hardCapBytes = normalizePositiveByteCount(input.hardCapBytes);
+	const policyLimitBytes = normalizePositiveByteCount(input.policyLimitBytes);
+	if (hardCapBytes !== null && policyLimitBytes !== null) {
+		return {
+			hardCapBytes,
+			policyLimitBytes,
+			effectiveBytes: Math.min(hardCapBytes, policyLimitBytes),
+			source: "hard_cap_and_policy_limit",
+		};
+	}
+	if (hardCapBytes !== null) {
+		return {
+			hardCapBytes,
+			policyLimitBytes: null,
+			effectiveBytes: hardCapBytes,
+			source: "hard_cap",
+		};
+	}
+	if (policyLimitBytes !== null) {
+		return {
+			hardCapBytes: null,
+			policyLimitBytes,
+			effectiveBytes: policyLimitBytes,
+			source: "policy_limit",
+		};
+	}
+	return {
+		hardCapBytes: null,
+		policyLimitBytes: null,
+		effectiveBytes: null,
+		source: "none",
+	};
+}

package/src/runtime-mcp/client.ts

@@ -15,15 +15,12 @@ import type {
 	MCPInitializeParams,
 	MCPInitializeResult,
 	MCPPrompt,
-	MCPPromptsListResult,
 	MCPRequestOptions,
 	MCPResource,
 	MCPResourceReadParams,
 	MCPResourceReadResult,
 	MCPResourceSubscribeParams,
-	MCPResourcesListResult,
 	MCPResourceTemplate,
-	MCPResourceTemplatesListResult,
 	MCPServerCapabilities,
 	MCPServerConfig,
 	MCPServerConnection,
@@ -43,6 +40,9 @@ const PROTOCOL_VERSION = "2025-03-26";
 /** Default connection timeout in ms */
 const CONNECTION_TIMEOUT_MS = 30_000;
 
+const MAX_PAGINATION_PAGES = 100,
+	MAX_PAGINATION_ITEMS = 10_000;
+
 /** Client info sent during initialization */
 const CLIENT_INFO = {
 	name: "skc-coding-agent",
@@ -109,6 +109,40 @@ function decodeToolsListResult(value: unknown): MCPToolsListResult {
 	return value.nextCursor === undefined ? { tools } : { tools, nextCursor: value.nextCursor };
 }
 
+async function collectPaginated<T>(
+	connection: MCPServerConnection,
+	options: MCPRequestOptions | undefined,
+	method: string,
+	itemKey: string,
+	items: T[],
+	decode?: (value: unknown) => unknown,
+): Promise<void> {
+	const seenCursors = new Set<string>();
+	const failure = (detail: string) => new MCPExpectedFailure(new Error(`MCP ${method} pagination ${detail}`));
+	let cursor: string | undefined;
+	for (let page = 1; page <= MAX_PAGINATION_PAGES; page++) {
+		const value = await connection.transport.request<unknown>(method, cursor ? { cursor } : {}, options);
+		const result = decode ? decode(value) : value;
+		if (
+			!isRecord(result) ||
+			!Array.isArray(result[itemKey]) ||
+			(result.nextCursor !== undefined && typeof result.nextCursor !== "string")
+		)
+			throw new MCPExpectedFailure();
+		const nextCursor = result.nextCursor as string | undefined;
+		if (nextCursor && seenCursors.has(nextCursor)) throw failure("repeated a cursor");
+		const pageItems = result[itemKey] as T[];
+		const itemCount = items.length + pageItems.length;
+		if (itemCount > MAX_PAGINATION_ITEMS || (itemCount === MAX_PAGINATION_ITEMS && nextCursor))
+			throw failure("did not complete within the 10000-item budget");
+		items.push(...pageItems);
+		if (!nextCursor) return;
+		if (page === MAX_PAGINATION_PAGES) throw failure("did not complete within the 100-page budget");
+		seenCursors.add(nextCursor);
+		cursor = nextCursor;
+	}
+}
+
 /**
  * Default handler for standard MCP server-to-client requests.
  * Handles `ping` and `roots/list`; rejects unknown methods with -32601.
@@ -292,18 +326,7 @@ export async function listTools(
 	}
 
 	const allTools: MCPToolDefinition[] = [];
-	let cursor: string | undefined;
-
-	do {
-		const params: Record<string, unknown> = {};
-		if (cursor) {
-			params.cursor = cursor;
-		}
-
-		const result = decodeToolsListResult(await connection.transport.request<unknown>("tools/list", params, options));
-		allTools.push(...result.tools);
-		cursor = result.nextCursor;
-	} while (cursor);
+	await collectPaginated(connection, options, "tools/list", "tools", allTools, decodeToolsListResult);
 
 	// Cache tools
 	connection.tools = allTools;
@@ -362,18 +385,7 @@ export async function listResources(
 	}
 
 	const allResources: MCPResource[] = [];
-	let cursor: string | undefined;
-
-	do {
-		const params: Record<string, unknown> = {};
-		if (cursor) {
-			params.cursor = cursor;
-		}
-
-		const result = await connection.transport.request<MCPResourcesListResult>("resources/list", params, options);
-		allResources.push(...result.resources);
-		cursor = result.nextCursor;
-	} while (cursor);
+	await collectPaginated(connection, options, "resources/list", "resources", allResources);
 
 	connection.resources = allResources;
 	return allResources;
@@ -395,22 +407,7 @@ export async function listResourceTemplates(
 	}
 
 	const allTemplates: MCPResourceTemplate[] = [];
-	let cursor: string | undefined;
-
-	do {
-		const params: Record<string, unknown> = {};
-		if (cursor) {
-			params.cursor = cursor;
-		}
-
-		const result = await connection.transport.request<MCPResourceTemplatesListResult>(
-			"resources/templates/list",
-			params,
-			options,
-		);
-		allTemplates.push(...result.resourceTemplates);
-		cursor = result.nextCursor;
-	} while (cursor);
+	await collectPaginated(connection, options, "resources/templates/list", "resourceTemplates", allTemplates);
 
 	connection.resourceTemplates = allTemplates;
 	return allTemplates;
@@ -514,18 +511,7 @@ export async function listPrompts(
 	}
 
 	const allPrompts: MCPPrompt[] = [];
-	let cursor: string | undefined;
-
-	do {
-		const params: Record<string, unknown> = {};
-		if (cursor) {
-			params.cursor = cursor;
-		}
-
-		const result = await connection.transport.request<MCPPromptsListResult>("prompts/list", params, options);
-		allPrompts.push(...result.prompts);
-		cursor = result.nextCursor;
-	} while (cursor);
+	await collectPaginated(connection, options, "prompts/list", "prompts", allPrompts);
 
 	connection.prompts = allPrompts;
 	return allPrompts;

package/src/runtime-mcp/content-limits.ts

@@ -0,0 +1,71 @@
+export const MCP_MAX_CONTENT_BYTES = 16 * 1024 * 1024;
+export const MCP_MAX_ERROR_BYTES = 16 * 1024;
+export const MCP_MAX_SSE_REQUEST_MESSAGES = 1024;
+export const MCP_MAX_SSE_BATCH_MESSAGES = 1024;
+export const MCP_HTTP_TIMEOUT_MS = 30_000;
+
+function ignoreCancellation(cancel: () => Promise<unknown>): void {
+	try {
+		void cancel().catch(() => {});
+	} catch {}
+}
+
+export function cancelMCPStream(stream: ReadableStream<Uint8Array> | null): void {
+	if (stream) ignoreCancellation(() => stream.cancel());
+}
+
+type ByteReader = Pick<ReadableStreamDefaultReader<Uint8Array>, "read">;
+
+async function readChunk(reader: ByteReader, signal?: AbortSignal) {
+	if (!signal) return reader.read();
+	signal.throwIfAborted();
+	const aborted = Promise.withResolvers<never>();
+	const onAbort = () => aborted.reject(signal.reason);
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		return await Promise.race([reader.read(), aborted.promise]);
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+	}
+}
+
+export async function readMCPResponseText(response: Response, limit: number, truncate = false, signal?: AbortSignal) {
+	const declared = response.headers.get("Content-Length");
+	if (!truncate && declared && /^\d+$/.test(declared) && Number(declared) > limit) {
+		cancelMCPStream(response.body);
+		throw new Error("MCP response exceeds size limit");
+	}
+	if (!response.body) return "";
+	const reader = response.body.getReader();
+	let buffer = new Uint8Array(Math.min(limit, 64 * 1024));
+	let total = 0;
+	try {
+		while (true) {
+			const { value, done } = await readChunk(reader, signal);
+			if (done) break;
+			if (value.length === 0) continue;
+			const remaining = limit - total;
+			if (value.length > remaining) {
+				if (truncate && remaining > 0) buffer.set(value.subarray(0, remaining), total);
+				ignoreCancellation(() => reader.cancel());
+				if (!truncate) throw new Error("MCP response exceeds size limit");
+				return `${new TextDecoder().decode(buffer)}\u2026`;
+			}
+			if (total + value.length > buffer.length) {
+				const grown = new Uint8Array(Math.min(limit, Math.max(total + value.length, buffer.length * 2)));
+				grown.set(buffer);
+				buffer = grown;
+			}
+			buffer.set(value, total);
+			total += value.length;
+		}
+		return new TextDecoder().decode(buffer.subarray(0, total));
+	} catch (error) {
+		ignoreCancellation(() => reader.cancel());
+		throw error;
+	} finally {
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+}

package/src/runtime-mcp/discoverable-tool-metadata.ts

@@ -7,10 +7,10 @@
  * the new symbols under the legacy names so existing call sites still compile.
  */
 export type {
+	DiscoverableTool as DiscoverableMCPTool,
 	DiscoverableToolSearchDocument as DiscoverableMCPSearchDocument,
 	DiscoverableToolSearchIndex as DiscoverableMCPSearchIndex,
 	DiscoverableToolSearchResult as DiscoverableMCPSearchResult,
-	DiscoverableTool as DiscoverableMCPTool,
 	DiscoverableToolServerSummary as DiscoverableMCPToolServerSummary,
 	DiscoverableToolSummary as DiscoverableMCPToolSummary,
 } from "../tool-discovery/tool-index";

package/src/runtime-mcp/json-rpc.ts

@@ -5,6 +5,8 @@
  * without maintaining persistent connections.
  */
 import { logger } from "@sayknow-cli/utils";
+import { cancelMCPStream, MCP_HTTP_TIMEOUT_MS, MCP_MAX_CONTENT_BYTES, readMCPResponseText } from "./content-limits";
+import { redactMCPDiagnosticValue, redactMCPEndpoint } from "./redaction";
 
 /** Parse SSE response format (lines starting with "data: ") */
 export function parseSSE(text: string): unknown {
@@ -25,6 +27,15 @@ export function parseSSE(text: string): unknown {
 	}
 }
 
+async function translateMCPTimeout<T>(operation: Promise<T>, signal: AbortSignal): Promise<T> {
+	try {
+		return await operation;
+	} catch (error) {
+		if (signal.aborted && error === signal.reason) throw new Error("MCP request timed out");
+		throw error;
+	}
+}
+
 /** JSON-RPC 2.0 response structure */
 export interface JsonRpcResponse<T = unknown> {
 	jsonrpc: "2.0";
@@ -57,26 +68,32 @@ export async function callMCP<T = unknown>(
 		params: params ?? {},
 	};
 
-	const response = await fetch(url, {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-			Accept: "application/json, text/event-stream",
-		},
-		body: JSON.stringify(body),
-	});
+	const signal = AbortSignal.timeout(MCP_HTTP_TIMEOUT_MS);
+	const response = await translateMCPTimeout(
+		fetch(url, {
+			method: "POST",
+			headers: { "Content-Type": "application/json", Accept: "application/json, text/event-stream" },
+			body: JSON.stringify(body),
+			signal,
+		}),
+		signal,
+	);
 
 	if (!response.ok) {
+		cancelMCPStream(response.body);
 		const errorMsg = `MCP request failed: ${response.status} ${response.statusText}`;
-		logger.error(errorMsg, { url, method, params });
+		logger.error(errorMsg, { url: redactMCPEndpoint(url), method, params: redactMCPDiagnosticValue(params) });
 		throw new Error(errorMsg);
 	}
 
-	const text = await response.text();
+	const text = await translateMCPTimeout(readMCPResponseText(response, MCP_MAX_CONTENT_BYTES, false, signal), signal);
 	const result = parseSSE(text) as JsonRpcResponse<T> | null;
 
 	if (!result) {
-		logger.error("Failed to parse MCP response", { url, method, responseText: text.slice(0, 500) });
+		logger.error("Failed to parse MCP response", {
+			url: redactMCPEndpoint(url),
+			method,
+		});
 		throw new Error("Failed to parse MCP response");
 	}