hoi4-agent-tools 3.0.7 → 3.0.8

package/CHANGELOG.md

@@ -4,6 +4,20 @@
 
 No unreleased changes.
 
+## 3.0.8 - 2026-09-05
+
+- Queue simultaneous tool calls fairly across HTTP sessions and coordinate expensive operations across local task processes sharing private server state.
+- Rotate across every waiting session and canonicalize configured storage aliases, including Windows short-name paths, before acquiring shared execution capacity.
+- Keep every tool call responsive with strictly increasing MCP progress notifications during execution and queue waits; allow cancellation and discovery while tool capacity is occupied.
+- Separate HTTP request admission and body-byte reservations from expensive execution capacity, replacing the two-request ceiling with defaults suitable for parallel agents.
+- Keep active HTTP sessions alive, yield during shared source indexing, and serialize backpressured stdio output without leaking listeners or leaving sends pending after a disconnect.
+- Share cached GUI source graphs across sessions using the same engine instead of retaining a separate graph per client.
+- Reverify artifacts after metadata changes caused by concurrent publication-link cleanup, avoiding false hash collisions while still rejecting altered bytes.
+- Serialize artifact admission, publication, and failed-batch cleanup across processes so one writer cannot remove evidence committed by another.
+- Add concurrent production workflows spanning focus, GUI, map, event, technology, and probability tools over both transports, including shared artifacts, session expiry, cancelled queue entries, and abandoned process recovery.
+- Qualify each map layer separately from semantic and pixel diffs so failures and deadlines identify the affected operation rather than an aggregate rendering loop.
+- Update `fast-uri` and `qs` to patched releases identified by the dependency audit.
+
 ## 3.0.7 - 2026-09-01
 
 - Reclaim detached parser, graph, and render memory after the idle cache window so parallel coding-agent tasks do not retain large V8 heaps and trigger `Transport closed` through host memory exhaustion. Idle cleanup is coordinated across every MCP domain and never compacts during an active tool call.

package/dist/hoi4_agent_tools/core/artifacts.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { z } from 'zod/v4';
 import { canonicalJson, compareCodeUnits, sha256Bytes } from './canonical.js';
 import { ServiceError } from './result.js';
+import { SharedRequestCapacity } from './shared-request-capacity.js';
 import { containedGeneratedPath, isPortablePathSegment } from './workspace.js';
 const sha256Schema = z.string().regex(/^[a-f0-9]{64}$/u);
 const artifactProvenanceSchema = z
@@ -329,7 +330,9 @@ async function withArtifactQueue(root, action, signal) {
     artifactQueues.set(root, tail);
     try {
         await waitForArtifactTurn(previous, signal);
-        return await action();
+        // Admission, publication, and rollback must be one critical section across
+        // processes too: another writer may reuse the same immutable address.
+        return await new SharedRequestCapacity(root, 1).run(signal ?? new AbortController().signal, action);
     }
     finally {
         release();
@@ -607,6 +610,23 @@ async function publishExclusiveFile(target, bytes, signal) {
     }
 }
 async function readVerifiedArtifactRange(filePath, expectedSha256, range, verifiedIdentity, signal) {
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            return await readArtifactRangeOnce(filePath, expectedSha256, range, attempt === 0 ? verifiedIdentity : undefined, signal);
+        }
+        catch (error) {
+            if (attempt >= 2 ||
+                !(error instanceof ServiceError) ||
+                error.code !== 'ARTIFACT_READ_INCOMPLETE')
+                throw error;
+            // Removing the temporary hard link after atomic publication changes ctime
+            // without changing content. Retry from a fresh handle and hash all bytes;
+            // never reuse cached verification after an identity change.
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+    }
+}
+async function readArtifactRangeOnce(filePath, expectedSha256, range, verifiedIdentity, signal) {
     signal?.throwIfAborted();
     if (range !== undefined &&
         (!Number.isSafeInteger(range.offset) ||

package/dist/hoi4_agent_tools/core/configuration.js

@@ -3,7 +3,8 @@ import path from 'node:path';
 import { z } from 'zod/v4';
 import { CONFIG_VERSION } from '../version.js';
 import { ServiceError } from './result.js';
-export const HTTP_MAX_SAFE_CONCURRENT_REQUESTS = 2;
+export const HTTP_MAX_SAFE_CONCURRENT_REQUESTS = 1024;
+export const HTTP_DEFAULT_CONCURRENT_REQUESTS = 128;
 export const HTTP_MAX_BODY_BYTES = 67_108_864;
 export const HTTP_MAX_AGGREGATE_BODY_BYTES = 134_217_728;
 export const HTTP_DEFAULT_SESSION_EVENT_BYTES = 2_097_152;
@@ -132,6 +133,8 @@ export const serverConfigurationSchema = z
     })
         .optional(),
     scanMaxFiles: z.number().int().min(1).max(1_000_000).default(DEFAULT_SCAN_MAX_FILES),
+    maxConcurrentTools: z.number().int().min(1).max(32).default(2),
+    maxSharedTools: z.number().int().min(1).max(128).default(4),
     scanMaxBytes: z
         .number()
         .int()
@@ -193,18 +196,18 @@ export const serverConfigurationSchema = z
         headersTimeoutMs: z.number().int().min(1_000).max(120_000).default(10_000),
         requestTimeoutMs: z.number().int().min(1_000).max(300_000).default(30_000),
         keepAliveTimeoutMs: z.number().int().min(1_000).max(120_000).default(5_000),
-        maxConnections: z.number().int().min(1).max(100_000).default(64),
+        maxConnections: z.number().int().min(1).max(100_000).default(512),
         maxRequestsPerSocket: z.number().int().min(1).max(100_000).default(100),
         maxConcurrentRequests: z
             .number()
             .int()
             .min(1)
             .max(HTTP_MAX_SAFE_CONCURRENT_REQUESTS)
-            .default(HTTP_MAX_SAFE_CONCURRENT_REQUESTS),
+            .default(HTTP_DEFAULT_CONCURRENT_REQUESTS),
         maxSessions: z.number().int().min(1).max(10_000).default(128),
         maxSessionsPerPrincipal: z.number().int().min(1).max(10_000).default(32),
-        maxEventStreams: z.number().int().min(1).max(10_000).default(32),
-        maxEventStreamsPerPrincipal: z.number().int().min(1).max(10_000).default(4),
+        maxEventStreams: z.number().int().min(1).max(10_000).default(128),
+        maxEventStreamsPerPrincipal: z.number().int().min(1).max(10_000).default(32),
         maxSessionEventBytes: z
             .number()
             .int()
@@ -212,7 +215,7 @@ export const serverConfigurationSchema = z
             .max(67_108_864)
             .default(HTTP_DEFAULT_SESSION_EVENT_BYTES),
         maxEventStoreBytes: z.number().int().min(65_536).max(268_435_456).default(16_777_216),
-        requestsPerMinute: z.number().int().min(1).max(100_000).default(120),
+        requestsPerMinute: z.number().int().min(1).max(100_000).default(6_000),
         sessionTtlSeconds: z.number().int().min(60).max(86_400).default(3600),
     })
         .strict()
@@ -274,16 +277,16 @@ export const serverConfigurationSchema = z
         headersTimeoutMs: 10_000,
         requestTimeoutMs: 30_000,
         keepAliveTimeoutMs: 5_000,
-        maxConnections: 64,
+        maxConnections: 512,
         maxRequestsPerSocket: 100,
-        maxConcurrentRequests: HTTP_MAX_SAFE_CONCURRENT_REQUESTS,
+        maxConcurrentRequests: HTTP_DEFAULT_CONCURRENT_REQUESTS,
         maxSessions: 128,
         maxSessionsPerPrincipal: 32,
-        maxEventStreams: 32,
-        maxEventStreamsPerPrincipal: 4,
+        maxEventStreams: 128,
+        maxEventStreamsPerPrincipal: 32,
         maxSessionEventBytes: HTTP_DEFAULT_SESSION_EVENT_BYTES,
         maxEventStoreBytes: 16_777_216,
-        requestsPerMinute: 120,
+        requestsPerMinute: 6_000,
         sessionTtlSeconds: 3600,
     }),
 })
@@ -332,23 +335,6 @@ export const serverConfigurationSchema = z
             message: 'HTTP keep-alive timeout must be shorter than the header timeout',
         });
     }
-    const concurrentScanBytes = value.scanMaxBytes * value.http.maxConcurrentRequests;
-    if (!Number.isSafeInteger(concurrentScanBytes) || concurrentScanBytes > 536_870_912) {
-        context.addIssue({
-            code: 'custom',
-            path: ['scanMaxBytes'],
-            message: 'Scan-byte ceiling multiplied by HTTP concurrency must not exceed 512 MiB',
-        });
-    }
-    const concurrentBodyBytes = value.http.maxBodyBytes * value.http.maxConcurrentRequests;
-    if (!Number.isSafeInteger(concurrentBodyBytes) ||
-        concurrentBodyBytes > HTTP_MAX_AGGREGATE_BODY_BYTES) {
-        context.addIssue({
-            code: 'custom',
-            path: ['http', 'maxBodyBytes'],
-            message: 'HTTP body-byte ceiling multiplied by concurrency must not exceed 128 MiB',
-        });
-    }
 });
 export async function loadConfiguration(filePath) {
     const absolute = path.resolve(filePath);

package/dist/hoi4_agent_tools/core/engine.js

@@ -3,6 +3,8 @@ import { SymbolIndex } from './index.js';
 import { WorkspaceScanner } from './scanner.js';
 import { ArtifactStore } from './artifacts.js';
 import { TransactionManager } from './transactions.js';
+import { RequestScheduler } from './request-scheduler.js';
+import { SharedRequestCapacity } from './shared-request-capacity.js';
 const RECOVERY_TTL_SECONDS = 3_600;
 const RECOVERY_MAX_BYTES = 536_870_912;
 const RECOVERY_MAX_RECORDS = 128;
@@ -74,6 +76,8 @@ function defaultPatterns(workspace) {
 }
 export class CoreEngine {
     resolver;
+    requests;
+    sharedRequests;
     scanner;
     artifacts;
     transactions;
@@ -84,6 +88,8 @@ export class CoreEngine {
     #activeScanAdmissions = new Set();
     constructor(resolver, services = {}) {
         this.resolver = resolver;
+        this.requests = new RequestScheduler(resolver.config().maxConcurrentTools);
+        this.sharedRequests = new SharedRequestCapacity(resolver.serverState()?.root, resolver.config().maxSharedTools);
         this.scanner =
             services.scanner ??
                 new WorkspaceScanner(resolver.config().scanMaxFiles, resolver.config().scanMaxBytes, resolver.config().scanMaxFileBytes);
@@ -159,7 +165,7 @@ export class CoreEngine {
                     const cached = this.#scanCache.get(cacheKey);
                     if (cached !== undefined)
                         return cached;
-                    const index = SymbolIndex.build(files);
+                    const index = await SymbolIndex.buildAsync(files, controller.signal);
                     const snapshot = {
                         workspaceId,
                         revision,

package/dist/hoi4_agent_tools/core/index.js

@@ -284,6 +284,31 @@ export class SymbolIndex {
         index.finalize();
         return index;
     }
+    /** Yield between source files so protocol cancellation and progress remain responsive. */
+    static async buildAsync(files, signal) {
+        signal?.throwIfAborted();
+        const index = new SymbolIndex();
+        const definitionSelection = selectedDefinitionFiles(files);
+        for (const displayPath of definitionSelection.selected)
+            index.#definitionFiles.add(displayPath);
+        for (const skipped of definitionSelection.skipped) {
+            index.recordSkippedSource(skipped.file, skipped.diagnostics);
+        }
+        let yieldedAt = performance.now();
+        for (const file of [...files].sort((a, b) => a.loadOrder - b.loadOrder || compareCodeUnits(a.displayPath, b.displayPath))) {
+            signal?.throwIfAborted();
+            index.files.set(file.displayPath, file);
+            index.indexFile(file);
+            if (performance.now() - yieldedAt >= 20) {
+                await new Promise((resolve) => setImmediate(resolve));
+                signal?.throwIfAborted();
+                yieldedAt = performance.now();
+            }
+        }
+        index.finalize();
+        signal?.throwIfAborted();
+        return index;
+    }
     get complete() {
         return this.#complete;
     }

package/dist/hoi4_agent_tools/core/request-scheduler.js

@@ -0,0 +1,79 @@
+import { ServiceError } from './result.js';
+/** Shares execution capacity across all sessions using an engine, with fair, cancellable waits. */
+export class RequestScheduler {
+    capacity;
+    maxPending;
+    maxPendingBytes;
+    active = 0;
+    pendingBytes = 0;
+    pending = [];
+    lastOwner;
+    constructor(capacity = 2, maxPending = 1024, maxPendingBytes = 134_217_728) {
+        this.capacity = capacity;
+        this.maxPending = maxPending;
+        this.maxPendingBytes = maxPendingBytes;
+        if (!Number.isSafeInteger(capacity) || capacity < 1) {
+            throw new RangeError('Execution capacity must be a positive integer');
+        }
+    }
+    async run(owner, bytes, signal, action) {
+        signal.throwIfAborted();
+        await new Promise((resolve, reject) => {
+            if (this.pending.length >= this.maxPending ||
+                bytes > this.maxPendingBytes - this.pendingBytes) {
+                reject(new ServiceError('REQUEST_QUEUE_FULL', 'The server request queue is full; retry after current work completes'));
+                return;
+            }
+            const entry = {
+                owner,
+                bytes,
+                start: () => {
+                    signal.removeEventListener('abort', entry.cancel);
+                    this.active += 1;
+                    this.lastOwner = owner;
+                    resolve();
+                },
+                cancel: () => {
+                    const index = this.pending.indexOf(entry);
+                    if (index < 0)
+                        return;
+                    this.pending.splice(index, 1);
+                    this.pendingBytes -= bytes;
+                    signal.removeEventListener('abort', entry.cancel);
+                    reject(signal.reason instanceof Error
+                        ? signal.reason
+                        : new DOMException('Request cancelled', 'AbortError'));
+                    this.drain();
+                },
+            };
+            signal.addEventListener('abort', entry.cancel, { once: true });
+            this.pending.push(entry);
+            this.pendingBytes += bytes;
+            this.drain();
+        });
+        try {
+            signal.throwIfAborted();
+            return await action();
+        }
+        finally {
+            this.active -= 1;
+            this.drain();
+        }
+    }
+    drain() {
+        while (this.active < this.capacity && this.pending.length > 0) {
+            const other = this.pending.findIndex(({ owner }) => owner !== this.lastOwner);
+            const entry = this.pending.splice(Math.max(0, other), 1)[0];
+            // Move this session's remaining work behind every other waiting session.
+            // Merely avoiding the last owner can alternate two busy sessions forever.
+            const sameOwner = [];
+            const otherOwners = [];
+            for (const pending of this.pending) {
+                (pending.owner === entry.owner ? sameOwner : otherOwners).push(pending);
+            }
+            this.pending.splice(0, this.pending.length, ...otherOwners, ...sameOwner);
+            this.pendingBytes -= entry.bytes;
+            entry.start();
+        }
+    }
+}

package/dist/hoi4_agent_tools/core/shared-request-capacity.js

@@ -0,0 +1,108 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readdir, rmdir, stat, unlink, writeFile } from 'node:fs/promises';
+import { hostname } from 'node:os';
+import { setTimeout as delay } from 'node:timers/promises';
+import { sha256Bytes } from './canonical.js';
+import { canonicalPath, containedGeneratedPath } from './workspace.js';
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== 'ESRCH';
+    }
+}
+/** Bounds heavy work across task processes sharing the same private server state. */
+export class SharedRequestCapacity {
+    stateRoot;
+    capacity;
+    constructor(stateRoot, capacity = 4) {
+        this.stateRoot = stateRoot;
+        this.capacity = capacity;
+    }
+    async run(signal, action) {
+        signal.throwIfAborted();
+        if (this.stateRoot === undefined)
+            return action();
+        const root = await containedGeneratedPath(await canonicalPath(this.stateRoot, signal), 'request-capacity', sha256Bytes(hostname().toLowerCase()).slice(0, 16));
+        await mkdir(root, { recursive: true });
+        const lease = `${process.pid}-${randomUUID()}.lease`;
+        for (;;) {
+            signal.throwIfAborted();
+            for (let index = 0; index < this.capacity; index += 1) {
+                let slot;
+                try {
+                    slot = await containedGeneratedPath(root, String(index));
+                }
+                catch (error) {
+                    // Another process can finish a slot while canonical containment is checked.
+                    if (error.code === 'ENOENT')
+                        continue;
+                    throw error;
+                }
+                try {
+                    await mkdir(slot);
+                }
+                catch (error) {
+                    if (error.code !== 'EEXIST')
+                        throw error;
+                    await this.reap(slot);
+                    continue;
+                }
+                let owner;
+                try {
+                    owner = await containedGeneratedPath(slot, lease);
+                    await writeFile(owner, '', { flag: 'wx', mode: 0o600 });
+                }
+                catch (error) {
+                    // A competing stale-owner cleanup can remove an empty slot before our
+                    // owner file is published. No work starts until the owner exists.
+                    if (error.code === 'ENOENT')
+                        continue;
+                    await rmdir(slot).catch(() => undefined);
+                    throw error;
+                }
+                try {
+                    signal.throwIfAborted();
+                    return await action();
+                }
+                finally {
+                    await unlink(owner);
+                    await rmdir(slot).catch((error) => {
+                        const code = error.code;
+                        if (code !== 'ENOENT' && code !== 'ENOTEMPTY')
+                            throw error;
+                    });
+                }
+            }
+            await delay(100, undefined, { signal });
+        }
+    }
+    async reap(slot) {
+        try {
+            const owners = await readdir(slot);
+            if (owners.length === 0) {
+                if (Date.now() - (await stat(slot)).mtimeMs < 30_000)
+                    return;
+            }
+            else {
+                for (const name of owners) {
+                    const match = /^([1-9][0-9]*)-[0-9a-f-]{36}\.lease$/u.exec(name);
+                    if (match === null || processAlive(Number(match[1])))
+                        return;
+                    // Unique owner names prevent a concurrent reaper from deleting a new lease.
+                    await unlink(await containedGeneratedPath(slot, name)).catch((error) => {
+                        if (error.code !== 'ENOENT')
+                            throw error;
+                    });
+                }
+            }
+            await rmdir(slot);
+        }
+        catch (error) {
+            if (!['ENOENT', 'ENOTEMPTY', 'EEXIST'].includes(error.code ?? ''))
+                throw error;
+        }
+    }
+}

package/dist/hoi4_agent_tools/gui/studio.js

@@ -672,13 +672,14 @@ export function guiArtifactProvenance(graph, kind, primaryScene, scenarioScenes
         },
     };
 }
+const sharedGuiGraphs = new WeakMap();
 export class ScriptedGuiStudio {
     engine;
     resolver;
     transactions;
     scanner;
     artifacts;
-    #graphCache = new Map();
+    #graphCache;
     constructor(engineOrResolver, transactions, scanner = new WorkspaceScanner(), artifacts = new ArtifactStore()) {
         this.engine =
             engineOrResolver instanceof CoreEngine
@@ -689,6 +690,8 @@ export class ScriptedGuiStudio {
                     ...(transactions === undefined ? {} : { transactions }),
                 });
         this.resolver = this.engine.resolver;
+        this.#graphCache = sharedGuiGraphs.get(this.engine) ?? new Map();
+        sharedGuiGraphs.set(this.engine, this.#graphCache);
         this.transactions = this.engine.transactions;
         this.scanner = this.engine.scanner;
         this.artifacts = this.engine.artifacts;

package/dist/hoi4_agent_tools/mcp/server/create.js

@@ -8,7 +8,8 @@ import { registerEventTools } from '../tools/event.js';
 import { registerTechnologyTools } from '../tools/technology.js';
 import { registerProbabilityTools } from '../tools/probability.js';
 import { registerMcpResources } from '../resources/register.js';
-export const SERVER_INSTRUCTIONS = 'Use focus tools for focus trees, GUI tools for interfaces, and map tools for map data. Start unfamiliar event chains with hoi4.event_inspect. Event tools are read-only. Start technology and doctrine work with hoi4.tech_inspect. Technology tools are read-only. Start weighted AI, MTTH, random, and declared-pool analysis with hoi4.probability_inspect. Probability tools are read-only. Long GUI calls emit periodic progress heartbeats when the client requests progress. Large evidence is linked as resources.';
+import { installRequestLifecycle } from './request-lifecycle.js';
+export const SERVER_INSTRUCTIONS = 'Use focus tools for focus trees, GUI tools for interfaces, and map tools for map data. Start unfamiliar event chains with hoi4.event_inspect. Event tools are read-only. Start technology and doctrine work with hoi4.tech_inspect. Technology tools are read-only. Start weighted AI, MTTH, random, and declared-pool analysis with hoi4.probability_inspect. Probability tools are read-only. Concurrent calls queue automatically and emit periodic progress when the client requests it. Large evidence is linked as resources.';
 export function createMcpServer(engine, context = {}) {
     const server = new McpServer({
         name: PACKAGE_NAME,
@@ -18,6 +19,7 @@ export function createMcpServer(engine, context = {}) {
         capabilities: { logging: {} },
         instructions: SERVER_INSTRUCTIONS,
     });
+    installRequestLifecycle(server, engine);
     const serverContext = {
         ...context,
         resolveCurrentWorkspaceId: async (signal) => {

package/dist/hoi4_agent_tools/mcp/server/progress.js

@@ -3,11 +3,16 @@
  * common MCP clients, while still keeping notification traffic negligible for ordinary calls.
  */
 export const PROGRESS_HEARTBEAT_INTERVAL_MS = 10_000;
+const reporters = new WeakMap();
+const heartbeatOwners = new WeakSet();
 export function progressReporter(extra) {
+    const existing = reporters.get(extra);
+    if (existing !== undefined)
+        return existing;
     let latest = Number.NEGATIVE_INFINITY;
     let latestTotal = 1;
-    let latestMessage = '';
-    return {
+    let latestMessage = 'Waiting for server execution capacity';
+    const reporter = {
         signal: extra.signal,
         async report(progress, total, message) {
             extra.signal.throwIfAborted();
@@ -20,27 +25,38 @@ export function progressReporter(extra) {
             if (normalized <= latest)
                 return;
             latest = normalized;
-            await extra.sendNotification({
+            await extra
+                .sendNotification({
                 method: 'notifications/progress',
                 params: { progressToken, progress: normalized, total, message },
-            });
+            })
+                .catch(() => undefined);
         },
         async pulse(message = latestMessage) {
             extra.signal.throwIfAborted();
             const progressToken = extra._meta?.progressToken;
             if (progressToken === undefined)
                 return;
-            await extra.sendNotification({
+            // Use the next representably larger value rather than repeating a value, which
+            // violates MCP progress ordering. These pulses do not invent completed work.
+            latest = Number.isFinite(latest)
+                ? latest + Math.max(1, Math.abs(latest)) * Number.EPSILON * 2
+                : 0;
+            await extra
+                .sendNotification({
                 method: 'notifications/progress',
                 params: {
                     progressToken,
-                    progress: Number.isFinite(latest) ? latest : 0,
-                    total: latestTotal,
+                    progress: latest,
+                    ...(latest <= latestTotal ? { total: latestTotal } : {}),
                     message,
                 },
-            });
+            })
+                .catch(() => undefined);
         },
     };
+    reporters.set(extra, reporter);
+    return reporter;
 }
 /**
  * Keep an MCP request alive while a domain service is in a long, opaque asynchronous stage.
@@ -52,6 +68,10 @@ export async function withProgressHeartbeat(operation, reporter, message, interv
         throw new RangeError('Progress heartbeat interval must be a positive finite number');
     }
     reporter.signal.throwIfAborted();
+    if (heartbeatOwners.has(reporter)) {
+        return typeof operation === 'function' ? operation() : operation;
+    }
+    heartbeatOwners.add(reporter);
     let active = true;
     let inFlight = false;
     const tick = () => {
@@ -76,5 +96,6 @@ export async function withProgressHeartbeat(operation, reporter, message, interv
     finally {
         active = false;
         clearInterval(timer);
+        heartbeatOwners.delete(reporter);
     }
 }

package/dist/hoi4_agent_tools/mcp/server/request-lifecycle.js

@@ -0,0 +1,14 @@
+import { progressReporter, withProgressHeartbeat } from './progress.js';
+/** Wrap the public SDK handler registration so optional tools receive the same lifecycle. */
+export function installRequestLifecycle(server, engine) {
+    const register = server.server.setRequestHandler.bind(server.server);
+    const owner = {};
+    server.server.setRequestHandler = (schema, handler) => {
+        register(schema, (request, extra) => {
+            if (request.method !== 'tools/call')
+                return handler(request, extra);
+            const progress = progressReporter(extra);
+            return withProgressHeartbeat(() => engine.requests.run(owner, Buffer.byteLength(JSON.stringify(request)), extra.signal, () => engine.sharedRequests.run(extra.signal, async () => handler(request, extra))), progress);
+        });
+    };
+}

package/dist/hoi4_agent_tools/mcp/transports/bounded-stdio.js

@@ -49,6 +49,9 @@ export class BoundedStdioServerTransport {
     frameBytes = 0;
     started = false;
     closed = false;
+    writing = false;
+    queuedBytes = 0;
+    writes = [];
     constructor(options = {}) {
         this.input = options.stdin ?? process.stdin;
         this.output = options.stdout ?? process.stdout;
@@ -149,8 +152,13 @@ export class BoundedStdioServerTransport {
         this.input.off('error', this.handleInputError);
         this.input.off('end', this.handleInputEnd);
         this.input.off('close', this.handleInputClose);
-        this.output.off('error', this.handleOutputError);
+        if (!this.writing)
+            this.output.off('error', this.handleOutputError);
         this.output.off('close', this.handleOutputClose);
+        const error = new Error('Stdio transport is closed');
+        for (const write of this.writes.splice(0))
+            write.reject(error);
+        this.queuedBytes = 0;
         if (destroyInput)
             this.input.destroy();
         else if (this.input.listenerCount('data') === 0)
@@ -179,22 +187,44 @@ export class BoundedStdioServerTransport {
     send(message) {
         if (this.closed)
             return Promise.reject(new Error('Stdio transport is closed'));
+        const data = serializeMessage(message);
+        const bytes = Buffer.byteLength(data);
+        if (bytes > 134_217_728 - this.queuedBytes) {
+            return Promise.reject(new Error('Stdio output queue is full'));
+        }
         return new Promise((resolve, reject) => {
-            const onError = (error) => {
-                this.output.off('error', onError);
-                reject(error);
-            };
-            this.output.once('error', onError);
-            const written = this.output.write(serializeMessage(message));
-            if (written) {
-                this.output.off('error', onError);
-                resolve();
+            this.queuedBytes += bytes;
+            this.writes.push({ data, bytes, resolve, reject });
+            this.flushWrites();
+        });
+    }
+    flushWrites() {
+        if (this.writing || this.closed)
+            return;
+        const write = this.writes[0];
+        if (write === undefined)
+            return;
+        this.writing = true;
+        this.output.write(write.data, (error) => {
+            this.writing = false;
+            if (this.closed) {
+                // A stream error is emitted after its write callback. Keep the listener through
+                // that turn so closing an output with buffered writes cannot crash the process.
+                setImmediate(() => this.output.off('error', this.handleOutputError));
+                return;
+            }
+            this.writes.shift();
+            this.queuedBytes -= write.bytes;
+            if (error != null) {
+                write.reject(error);
+                this.writing = true;
+                this.finish(true);
+                this.writing = false;
+                setImmediate(() => this.output.off('error', this.handleOutputError));
             }
             else {
-                this.output.once('drain', () => {
-                    this.output.off('error', onError);
-                    resolve();
-                });
+                write.resolve();
+                this.flushWrites();
             }
         });
     }