hoi4-agent-tools 3.0.9 → 3.2.0

package/dist/hoi4_agent_tools/mcp/resources/register.js

@@ -1,153 +1,7 @@
 import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { canonicalJson } from '../../core/canonical.js';
-import { ServiceError } from '../../core/result.js';
-const artifactResourceLimit = 1_048_576;
-const artifactChunkMetadataKey = 'io.github.klimpaskov/hoi4-agent-tools.artifact-byte-range';
-const fatalUtf8Decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
-const artifactResourceMetadata = {
-    title: 'HOI4 review artifact',
-    description: 'Complete plans, diagnostics, layouts, previews, event graphs, routes, state and scope reports, comparisons, and diffs. Reads accept zero-based byte offset and positive byte length query selectors; each response reports its exact byte range and continuation URI in _meta.',
-    _meta: {
-        [artifactChunkMetadataKey]: {
-            version: 1,
-            unit: 'byte',
-            maxChunkSize: artifactResourceLimit,
-            selectors: {
-                offset: { type: 'integer', minimum: 0, default: 0 },
-                length: {
-                    type: 'integer',
-                    minimum: 1,
-                    maximum: artifactResourceLimit,
-                    default: artifactResourceLimit,
-                },
-                metadata: { type: 'string', enum: ['manifest'], optional: true },
-            },
-        },
-    },
-};
-function assertResourceSelectors(uri, allowed) {
-    if (uri.hash !== '' || uri.username !== '' || uri.password !== '' || uri.port !== '') {
-        throw new ServiceError('RESOURCE_URI_INVALID', 'Resource URI is not canonical');
-    }
-    const allowedNames = new Set(allowed);
-    const seen = new Set();
-    for (const name of uri.searchParams.keys()) {
-        if (!allowedNames.has(name)) {
-            throw new ServiceError('RESOURCE_SELECTOR_INVALID', 'Resource selector is not supported');
-        }
-        if (seen.has(name)) {
-            throw new ServiceError('RESOURCE_SELECTOR_INVALID', 'Resource selectors may not be repeated');
-        }
-        seen.add(name);
-    }
-}
-function contentArtifactUri(uri) {
-    const contentUri = new URL(uri);
-    contentUri.search = '';
-    contentUri.hash = '';
-    return contentUri.href;
-}
-function exactUtf8Text(bytes) {
-    try {
-        const text = fatalUtf8Decoder.decode(bytes);
-        return Buffer.from(text, 'utf8').equals(bytes) ? text : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function artifactRangeParameter(uri, name, fallback, minimum, maximum = Number.MAX_SAFE_INTEGER) {
-    const raw = uri.searchParams.get(name);
-    if (raw === null)
-        return fallback;
-    if (!/^\d+$/u.test(raw)) {
-        throw new ServiceError('ARTIFACT_RANGE_INVALID', 'Artifact byte range is invalid');
-    }
-    const value = Number(raw);
-    if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
-        throw new ServiceError('ARTIFACT_RANGE_INVALID', 'Artifact byte range is invalid');
-    }
-    return value;
-}
-function artifactChunkMetadata(uri, metadata, totalSize, offset, returnedLength, requestedLength) {
-    const endExclusive = offset + returnedLength;
-    let continuationUri = null;
-    if (endExclusive < totalSize) {
-        const continuation = new URL(contentArtifactUri(uri));
-        continuation.searchParams.set('offset', String(endExclusive));
-        continuation.searchParams.set('length', String(requestedLength));
-        if (metadata !== null)
-            continuation.searchParams.set('metadata', metadata);
-        continuationUri = continuation.href;
-    }
-    return {
-        [artifactChunkMetadataKey]: {
-            version: 1,
-            unit: 'byte',
-            totalSize,
-            returnedRange: { offset, length: returnedLength, endExclusive },
-            complete: offset === 0 && returnedLength === totalSize,
-            continuationUri,
-        },
-    };
-}
+import { artifactResourceDefinition, readArtifactResource } from '../../core/artifact-resource.js';
+/** SDK-v1 registration only; ownership and byte-range behavior live in the shared core. */
 export function registerMcpResources(server, engine, context) {
-    server.registerResource('artifact', new ResourceTemplate('hoi4-agent://workspace/{workspaceId}/artifact/{sha256}/{provenanceHash}/{name}', { list: undefined }), artifactResourceMetadata, async (uri, { workspaceId }, extra) => {
-        extra.signal.throwIfAborted();
-        assertResourceSelectors(uri, ['offset', 'length', 'metadata']);
-        const workspace = engine.resolver.get(String(workspaceId), context.principal);
-        const offset = artifactRangeParameter(uri, 'offset', 0, 0);
-        const length = artifactRangeParameter(uri, 'length', artifactResourceLimit, 1, artifactResourceLimit);
-        const metadata = uri.searchParams.get('metadata');
-        if (metadata !== null && metadata !== 'manifest') {
-            throw new ServiceError('ARTIFACT_METADATA_INVALID', 'Artifact metadata selector is invalid');
-        }
-        if (metadata === 'manifest') {
-            const described = await engine.artifacts.describe(workspace, contentArtifactUri(uri), extra.signal);
-            const { path: artifactPath, ...publicManifest } = described;
-            void artifactPath;
-            const manifestBytes = Buffer.from(`${canonicalJson(publicManifest)}\n`, 'utf8');
-            const start = Math.min(offset, manifestBytes.length);
-            const selected = manifestBytes.subarray(start, Math.min(manifestBytes.length, start + length));
-            const complete = start === 0 && selected.length === manifestBytes.length;
-            const _meta = artifactChunkMetadata(uri, metadata, manifestBytes.length, start, selected.length, length);
-            return {
-                contents: [
-                    complete
-                        ? {
-                            uri: uri.href,
-                            mimeType: 'application/json',
-                            text: selected.toString('utf8'),
-                            _meta,
-                        }
-                        : {
-                            uri: uri.href,
-                            mimeType: 'application/json',
-                            blob: selected.toString('base64'),
-                            _meta,
-                        },
-                ],
-            };
-        }
-        const artifact = await engine.artifacts.read(workspace, contentArtifactUri(uri), { offset, length }, extra.signal);
-        const textual = artifact.mimeType.startsWith('text/') ||
-            artifact.mimeType === 'application/json' ||
-            artifact.mimeType === 'image/svg+xml';
-        const start = Math.min(offset, artifact.totalSize);
-        const complete = start === 0 && artifact.bytes.length === artifact.totalSize;
-        const text = textual && complete ? exactUtf8Text(artifact.bytes) : undefined;
-        const _meta = artifactChunkMetadata(uri, metadata, artifact.totalSize, start, artifact.bytes.length, length);
-        return {
-            contents: [
-                text !== undefined
-                    ? { uri: uri.href, mimeType: artifact.mimeType, text, _meta }
-                    : {
-                        uri: uri.href,
-                        mimeType: artifact.mimeType,
-                        blob: artifact.bytes.toString('base64'),
-                        _meta,
-                    },
-            ],
-        };
-    });
+    const { name, uriTemplate, ...metadata } = artifactResourceDefinition;
+    server.registerResource(name, new ResourceTemplate(uriTemplate, { list: undefined }), metadata, (uri, _variables, extra) => readArtifactResource(engine, uri.href, context, extra.signal));
 }

package/dist/hoi4_agent_tools/mcp/server/base-tools.js

@@ -1,219 +1,3 @@
-import { boundedSourceHashEvidence, publicArtifactLink } from '../../core/artifacts.js';
-import { lstat } from 'node:fs/promises';
-import { canonicalJson } from '../../core/canonical.js';
-import { exactChangedFilePatterns, focusDomainScanPatterns, } from '../../core/domain-scan-patterns.js';
-import { ServiceError } from '../../core/result.js';
-import { parseClausewitz } from '../../core/source/index.js';
-import { TRANSACTION_MAX_DIAGNOSTICS } from '../../core/transaction-limits.js';
-import { importContinuousFocusPalettes, importFocusTrees, layoutFocusTreeAsync, lintContinuousFocusPalette, lintFocusTree, } from '../../focus/index.js';
-import { ScriptedGuiStudio } from '../../gui/index.js';
-import { AgentNudger, attributeMapValidationDiagnostics } from '../../map/index.js';
-import { PACKAGE_VERSION } from '../../version.js';
-export async function resolveServerWorkspaceId(engine, context, workspaceId, signal) {
-    if (workspaceId === 'current' && context.resolveCurrentWorkspaceId !== undefined) {
-        return context.resolveCurrentWorkspaceId(signal);
-    }
-    return engine.resolver.resolveWorkspaceId(workspaceId, context.principal);
-}
-export async function resolveServerWorkspaceForSource(engine, context, workspaceId, relativePath, signal) {
-    const resolvedWorkspaceId = await resolveServerWorkspaceId(engine, context, workspaceId, signal);
-    if (workspaceId !== 'current' || relativePath === undefined)
-        return resolvedWorkspaceId;
-    try {
-        const resolved = await engine.resolver.resolvePath(resolvedWorkspaceId, relativePath, 'read', ['mod'], context.principal);
-        signal?.throwIfAborted();
-        if ((await lstat(resolved.path)).isFile())
-            return resolvedWorkspaceId;
-    }
-    catch (error) {
-        if (error.name === 'AbortError')
-            throw error;
-    }
-    return ((await engine.resolver.resolveUniqueModSourceWorkspaceId(relativePath, context.principal, signal)) ?? resolvedWorkspaceId);
-}
-export function requireServerScope(context, scope) {
-    if (context.scopes !== undefined && !context.scopes.includes(scope)) {
-        throw new ServiceError('AUTH_SCOPE_REQUIRED', `This operation requires the ${scope} scope`, {
-            requiredScope: scope,
-        });
-    }
-}
-function sourcePathComparisonKey(value) {
-    const normalized = value.replaceAll('\\', '/');
-    return process.platform === 'win32' ? normalized.toLocaleLowerCase('en-US') : normalized;
-}
-function focusReferences(engineSnapshot) {
-    const active = (kind) => engineSnapshot.index
-        .findAll(kind)
-        .filter(({ overridden }) => !overridden)
-        .map(({ id }) => id);
-    return {
-        decision: active('decision'),
-        decision_category: active('decision_category'),
-        event: active('event'),
-        idea: active('idea'),
-        leader: active('leader'),
-        formable: active('formable'),
-        helper: active('scripted_effect'),
-    };
-}
-export async function postValidateTransaction(engine, transaction, principal, signal) {
-    engine.invalidate(transaction.workspaceId);
-    const workspace = engine.resolver.get(transaction.workspaceId, principal);
-    const focusTransaction = transaction.operationKind === 'focus-plan-changes' ||
-        transaction.operationKind === 'continuous-focus-plan-changes';
-    const snapshot = await engine.scan(transaction.workspaceId, {
-        patterns: focusTransaction
-            ? focusDomainScanPatterns(workspace)
-            : exactChangedFilePatterns(transaction.files.map(({ relativePath }) => relativePath)),
-    }, principal, signal);
-    const changed = new Set(transaction.files.map(({ relativePath }) => sourcePathComparisonKey(relativePath)));
-    const diagnostics = snapshot.diagnostics.filter(({ location }) => {
-        if (location === undefined)
-            return false;
-        const sourcePath = sourcePathComparisonKey(location.path);
-        return [...changed].some((relativePath) => sourcePath.endsWith(`:${relativePath}`));
-    });
-    const checks = [];
-    if (transaction.operationKind === 'focus-plan-changes') {
-        const catalog = focusReferences(snapshot);
-        for (const file of snapshot.files.filter(({ shadowedBy, relativePath }) => shadowedBy === undefined &&
-            relativePath.toLowerCase().endsWith('.txt') &&
-            changed.has(sourcePathComparisonKey(relativePath)))) {
-            const document = parseClausewitz(file.bytes, file.displayPath);
-            const imported = importFocusTrees(document, { references: catalog });
-            diagnostics.push(...imported.diagnostics);
-            for (const plan of imported.plans) {
-                const layout = await layoutFocusTreeAsync(plan, signal === undefined ? {} : { signal });
-                diagnostics.push(...lintFocusTree(plan, {
-                    index: snapshot.index,
-                    references: catalog,
-                    layout,
-                }));
-            }
-        }
-        const passed = !diagnostics.some(({ severity }) => severity === 'error' || severity === 'blocker');
-        checks.push({
-            id: 'post-write-focus',
-            passed,
-            message: passed
-                ? 'The focus result re-imported, laid out, and linted successfully'
-                : 'The focus result failed post-write import or lint',
-        });
-    }
-    else if (transaction.operationKind === 'continuous-focus-plan-changes') {
-        for (const file of snapshot.files.filter(({ shadowedBy, relativePath }) => shadowedBy === undefined &&
-            relativePath.toLowerCase().endsWith('.txt') &&
-            changed.has(sourcePathComparisonKey(relativePath)))) {
-            const imported = importContinuousFocusPalettes(parseClausewitz(file.bytes, file.displayPath));
-            diagnostics.push(...imported.diagnostics);
-            for (const plan of imported.continuousFocusPalettes) {
-                diagnostics.push(...lintContinuousFocusPalette(plan));
-            }
-        }
-        const passed = !diagnostics.some(({ severity }) => severity === 'error' || severity === 'blocker');
-        checks.push({
-            id: 'post-write-continuous-focus',
-            passed,
-            message: passed
-                ? 'The continuous focus result re-imported and linted successfully'
-                : 'The continuous focus result failed post-write import or lint',
-        });
-    }
-    else if (transaction.operationKind === 'gui-source-change' ||
-        transaction.operationKind === 'gui-helper-compilation') {
-        const studio = new ScriptedGuiStudio(engine);
-        const scanned = await studio.scan(transaction.workspaceId, principal, signal);
-        diagnostics.push(...scanned.graph.diagnostics);
-        const passed = !scanned.graph.diagnostics.some(({ severity }) => severity === 'error' || severity === 'blocker');
-        checks.push({
-            id: 'post-write-gui-graph',
-            passed,
-            message: passed
-                ? 'The GUI graph rebuilt successfully'
-                : 'The GUI graph has blocking diagnostics',
-        });
-    }
-    else if (transaction.operationKind === 'agent-nudger-map-changes') {
-        const nudger = new AgentNudger(engine);
-        const validated = await nudger.validate(transaction.workspaceId, principal, signal);
-        const mapDiagnostics = attributeMapValidationDiagnostics({
-            diagnostics: [...diagnostics, ...validated.validation.diagnostics],
-            operations: transaction.operations,
-            changes: transaction.files,
-        });
-        diagnostics.length = 0;
-        diagnostics.push(...mapDiagnostics);
-        checks.push(...validated.validation.checks);
-        checks.push({
-            id: 'post-write-map',
-            passed: validated.validation.passed,
-            message: validated.validation.passed
-                ? 'The map result rescanned and validated successfully'
-                : 'The map result failed post-write validation',
-        });
-    }
-    const passed = !diagnostics.some(({ severity }) => severity === 'error' || severity === 'blocker');
-    checks.unshift({
-        id: 'post-write-shared-index',
-        passed,
-        message: passed
-            ? 'Changed files reparsed and reindexed successfully'
-            : 'Changed files have blocking post-write diagnostics',
-    });
-    const availableDiagnostics = Math.max(0, TRANSACTION_MAX_DIAGNOSTICS - transaction.diagnostics.length);
-    if (diagnostics.length > availableDiagnostics) {
-        const workspace = engine.resolver.get(transaction.workspaceId, principal);
-        const sourceEvidence = boundedSourceHashEvidence(Object.fromEntries(transaction.files.flatMap(({ relativePath, afterSha256 }) => afterSha256 === null ? [] : [[relativePath, afterSha256]])));
-        const artifact = await engine.artifacts.putChunked(workspace, `${transaction.operationKind}.post-validation.json`, 'application/json', `${canonicalJson({
-            schemaVersion: 1,
-            operationKind: transaction.operationKind,
-            diagnosticCount: diagnostics.length,
-            checks,
-            diagnostics,
-        })}\n`, {
-            kind: 'rewrite-post-validation',
-            toolVersion: PACKAGE_VERSION,
-            schemaVersion: 'rewrite-post-validation.v1',
-            sourceHashes: sourceEvidence.sourceHashes,
-            metadata: { sourceHashInventory: sourceEvidence.inventory },
-        }, 'Complete diagnostics from post-write validation', signal);
-        const retainedLimit = Math.max(0, availableDiagnostics - 1);
-        const hard = diagnostics.filter(({ severity }) => severity === 'error' || severity === 'blocker');
-        const retainedHard = hard.slice(0, retainedLimit);
-        const retainedSoft = diagnostics
-            .filter(({ severity }) => severity !== 'error' && severity !== 'blocker')
-            .slice(0, retainedLimit - retainedHard.length);
-        const omittedHard = hard.length - retainedHard.length;
-        const artifactLink = publicArtifactLink(artifact);
-        checks.push({
-            id: 'post-write-diagnostics-artifact',
-            passed: omittedHard === 0,
-            message: `Complete post-write diagnostics are stored at ${artifactLink.uri}`,
-        });
-        return {
-            diagnostics: availableDiagnostics === 0
-                ? []
-                : [
-                    ...retainedHard,
-                    ...retainedSoft,
-                    {
-                        code: 'POST_VALIDATION_DIAGNOSTICS_IN_ARTIFACT',
-                        severity: omittedHard > 0 ? 'blocker' : 'warning',
-                        category: 'validation',
-                        message: `Complete post-write validation contains ${diagnostics.length} diagnostics and is stored as an artifact`,
-                        details: {
-                            total: diagnostics.length,
-                            returned: availableDiagnostics,
-                            omitted: diagnostics.length - retainedLimit,
-                            omittedHard,
-                            artifact: artifactLink,
-                        },
-                    },
-                ],
-            checks,
-            artifacts: [artifactLink],
-        };
-    }
-    return { diagnostics, checks, artifacts: [] };
-}
+/** Compatibility names for the protocol-independent execution authorization boundary. */
+export { requireOperationScope as requireServerScope, resolveOperationWorkspaceForSource as resolveServerWorkspaceForSource, resolveOperationWorkspaceId as resolveServerWorkspaceId, } from '../../core/operation-context.js';
+export { postValidateTransaction } from '../../core/domain-validation.js';

package/dist/hoi4_agent_tools/mcp/server/create-modern-operations.js

@@ -0,0 +1,188 @@
+import { fileURLToPath } from 'node:url';
+import { CallToolResultSchema, ClientCapabilitiesSchema, ListToolsResultSchema, } from '@modelcontextprotocol/core';
+import { CLIENT_CAPABILITIES_META_KEY, inputRequired, ProtocolError, ProtocolErrorCode, } from '@modelcontextprotocol/server';
+import { z } from 'zod/v4';
+import { isJobControlTool, JobControlService } from '../../core/job-controls.js';
+import { OperationTaskService } from '../../core/operation-tasks.js';
+import { errorResult } from '../../core/operation-result.js';
+import { PACKAGE_NAME, PACKAGE_VERSION } from '../../version.js';
+import { MODERN_TASK_ROUTES, ModernTaskRoutingServer } from '../transports/modern-task-routing.js';
+import { registerModernResources } from '../resources/register-modern.js';
+import { registerModernPrompts } from '../prompts/register-modern.js';
+import { jobControlTools } from '../tools/job.js';
+import { ModernTaskAdapter, TASKS_EXTENSION } from './modern-tasks.js';
+import { SERVER_INSTRUCTIONS } from './instructions.js';
+import { modernProgressReporter, withProgressHeartbeat } from './progress.js';
+import { taskToolCatalog } from './task-tool-catalog.js';
+const rootsResponseSchema = z
+    .object({
+    roots: z
+        .array(z.object({ uri: z.string().max(8192), name: z.string().optional() }).loose())
+        .max(256),
+})
+    .loose();
+const metadataParamsSchema = z.record(z.string(), z.unknown());
+const workspaceRootsKey = 'hoi4-workspace-roots';
+function clientCapabilities(envelope) {
+    // SDK 2.0.0 publishes RequestMetaEnvelope as {}, although it retains these keys at runtime.
+    const parsed = z
+        .object({ [CLIENT_CAPABILITIES_META_KEY]: ClientCapabilitiesSchema })
+        .loose()
+        .safeParse(envelope);
+    return parsed.success ? parsed.data[CLIENT_CAPABILITIES_META_KEY] : undefined;
+}
+/**
+ * Modern operation/task factory, shared by the connection and HTTP serving entries.
+ * The stdio entry explicitly opts into the two private ChaosX tools when configured.
+ * HTTP remains mod-independent and never enables that private extension.
+ */
+export function createModernOperationServer(engine, context = {}, tasks = new OperationTaskService(engine), options = {}) {
+    const adapter = new ModernTaskAdapter(tasks);
+    const controls = new JobControlService(engine);
+    const privateOperations = options.createPrivateTools?.(engine, context);
+    const definitions = [
+        ...taskToolCatalog,
+        ...jobControlTools,
+        ...(privateOperations === undefined
+            ? []
+            : [privateOperations.visual.definition, privateOperations.country.definition]),
+    ];
+    const server = new ModernTaskRoutingServer({ name: PACKAGE_NAME, version: PACKAGE_VERSION }, {
+        capabilities: {
+            tools: {},
+            resources: {},
+            prompts: {},
+            extensions: { [TASKS_EXTENSION]: {} },
+        },
+        instructions: SERVER_INSTRUCTIONS,
+    });
+    registerModernResources(server, engine, context);
+    registerModernPrompts(server);
+    server.setRequestHandler('tools/list', () => ListToolsResultSchema.parse({
+        tools: definitions.map(({ name, inputSchema, outputSchema, ...metadata }) => ({
+            ...metadata,
+            name,
+            inputSchema: {
+                ...z.toJSONSchema(inputSchema, { target: 'draft-7', io: 'input' }),
+                type: 'object',
+            },
+            ...(outputSchema === undefined
+                ? {}
+                : {
+                    outputSchema: {
+                        ...z.toJSONSchema(outputSchema, { target: 'draft-7', io: 'input' }),
+                        type: 'object',
+                    },
+                }),
+        })),
+    }));
+    server.setRequestHandler('tools/call', async (request, extra) => {
+        const definition = definitions.find(({ name }) => name === request.params.name);
+        if (definition === undefined)
+            throw new ProtocolError(ProtocolErrorCode.InvalidParams, 'Unknown tool');
+        const input = definition.inputSchema.safeParse(request.params.arguments ?? {});
+        if (!input.success)
+            throw new ProtocolError(ProtocolErrorCode.InvalidParams, 'Invalid tool arguments');
+        const capabilities = clientCapabilities(extra.mcpReq.envelope);
+        const arguments_ = z.record(z.string(), z.json()).parse(input.data);
+        let operationContext = context;
+        if ((arguments_.workspaceId === undefined || arguments_.workspaceId === 'current') &&
+            capabilities?.roots !== undefined &&
+            context.resolveCurrentWorkspaceId === undefined) {
+            const response = extra.mcpReq.inputResponses?.[workspaceRootsKey];
+            if (response === undefined)
+                return inputRequired({ inputRequests: { [workspaceRootsKey]: inputRequired.listRoots() } });
+            const roots = rootsResponseSchema.safeParse(response);
+            if (!roots.success)
+                throw new ProtocolError(ProtocolErrorCode.InvalidParams, 'Invalid workspace roots response');
+            const paths = roots.data.roots.flatMap(({ uri }) => {
+                try {
+                    return new URL(uri).protocol === 'file:' ? [fileURLToPath(uri)] : [];
+                }
+                catch {
+                    return [];
+                }
+            });
+            operationContext = {
+                ...context,
+                resolveCurrentWorkspaceId: async () => engine.resolver.resolveClientWorkspaceId(paths, context.principal),
+            };
+        }
+        try {
+            if (privateOperations !== undefined) {
+                const operations = operationContext === context || options.createPrivateTools === undefined
+                    ? privateOperations
+                    : options.createPrivateTools(engine, operationContext);
+                const progress = modernProgressReporter(extra);
+                if (definition.name === operations.visual.definition.name) {
+                    const result = await operations.visual.call(operations.visual.definition.inputSchema.parse(arguments_), progress);
+                    if (result.isError !== true)
+                        operations.visual.definition.outputSchema.parse(result.structuredContent);
+                    return CallToolResultSchema.parse({
+                        ...result,
+                        resultType: 'complete',
+                        ttlMs: 0,
+                        cacheScope: 'private',
+                    });
+                }
+                if (definition.name === operations.country.definition.name) {
+                    const result = await operations.country.call(operations.country.definition.inputSchema.parse(arguments_), progress);
+                    if (result.isError !== true)
+                        operations.country.definition.outputSchema.parse(result.structuredContent);
+                    return CallToolResultSchema.parse({
+                        ...result,
+                        resultType: 'complete',
+                        ttlMs: 0,
+                        cacheScope: 'private',
+                    });
+                }
+            }
+            if (isJobControlTool(definition.name)) {
+                const result = await controls.call(definition.name, arguments_, operationContext, extra.mcpReq.signal);
+                const completed = CallToolResultSchema.parse({
+                    ...result,
+                    resultType: 'complete',
+                    ttlMs: 0,
+                    cacheScope: 'private',
+                });
+                if (definition.outputSchema !== undefined)
+                    definition.outputSchema.parse(completed.structuredContent);
+                return completed;
+            }
+            const progress = modernProgressReporter(extra);
+            const result = await withProgressHeartbeat(async () => {
+                const completed = await adapter.call({ name: definition.name, arguments: arguments_ }, capabilities, operationContext, {
+                    requestId: extra.mcpReq.id,
+                    signal: extra.mcpReq.signal,
+                    ...(extra.sessionId === undefined ? {} : { sessionId: extra.sessionId }),
+                });
+                // A native task response ends this request, not the durable operation.
+                // Subsequent state and progress come from authenticated tasks/get polling.
+                if (completed.resultType !== 'task') {
+                    await progress.report(2, 3, 'Retrieving persistent operation result');
+                    await progress.report(3, 3, 'Persistent operation complete');
+                }
+                return completed;
+            }, progress);
+            return CallToolResultSchema.parse({ content: [], ...result });
+        }
+        catch (error) {
+            if (error instanceof ProtocolError || extra.mcpReq.signal.aborted)
+                throw error;
+            return errorResult(error, typeof arguments_.workspaceId === 'string' ? arguments_.workspaceId : 'current');
+        }
+    });
+    for (const [method, alias] of MODERN_TASK_ROUTES) {
+        server.setRequestHandler(alias, { params: metadataParamsSchema }, async (params, extra) => {
+            if (extra.http?.req !== undefined &&
+                (extra.http.req.headers.get('mcp-method') !== method ||
+                    extra.http.req.headers.get('mcp-name') !== params.taskId))
+                throw new ProtocolError(ProtocolErrorCode.InvalidParams, 'Task routing headers do not match the request');
+            const { _meta: _metadata, ...payload } = params;
+            if (method === 'tasks/update')
+                payload.inputResponses = extra.mcpReq.inputResponses ?? payload.inputResponses;
+            return adapter.handle(method, payload, clientCapabilities(extra.mcpReq.envelope), context, extra.mcpReq.signal);
+        });
+    }
+    return server;
+}

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

@@ -5,22 +5,32 @@ import { registerFocusTools } from '../tools/focus.js';
 import { registerGuiTools } from '../tools/gui.js';
 import { registerMapTools } from '../tools/map.js';
 import { registerEventTools } from '../tools/event.js';
+import { registerAnalysisTools } from '../tools/analysis.js';
 import { registerTechnologyTools } from '../tools/technology.js';
 import { registerProbabilityTools } from '../tools/probability.js';
+import { registerJobTools } from '../tools/job.js';
 import { registerMcpResources } from '../resources/register.js';
 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.';
+import { PersistentJobTaskStore } from './job-task-store.js';
+import { SERVER_INSTRUCTIONS } from './instructions.js';
+export { SERVER_INSTRUCTIONS } from './instructions.js';
 export function createMcpServer(engine, context = {}) {
+    let serverContext = context;
+    const taskStore = new PersistentJobTaskStore(engine, () => serverContext);
     const server = new McpServer({
         name: PACKAGE_NAME,
         version: PACKAGE_VERSION,
         websiteUrl: 'https://github.com/klimPaskov/hoi4-agent-tools',
     }, {
-        capabilities: { logging: {} },
+        capabilities: {
+            logging: {},
+            tasks: { list: {}, cancel: {}, requests: { tools: { call: {} } } },
+        },
         instructions: SERVER_INSTRUCTIONS,
+        taskStore,
     });
     installRequestLifecycle(server, engine);
-    const serverContext = {
+    serverContext = {
         ...context,
         resolveCurrentWorkspaceId: async (signal) => {
             const capabilities = server.server.getClientCapabilities();
@@ -43,9 +53,11 @@ export function createMcpServer(engine, context = {}) {
     registerFocusTools(server, engine, serverContext);
     registerGuiTools(server, engine, serverContext);
     registerMapTools(server, engine, serverContext);
-    registerEventTools(server, engine, serverContext);
-    registerTechnologyTools(server, engine, serverContext);
-    registerProbabilityTools(server, engine, serverContext);
+    registerEventTools(server);
+    registerAnalysisTools(server);
+    registerTechnologyTools(server);
+    registerProbabilityTools(server);
+    registerJobTools(server, engine, serverContext);
     registerMcpResources(server, engine, serverContext);
     return server;
 }

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

@@ -0,0 +1,2 @@
+/** Shared agent-facing guidance for both MCP protocol generations. */
+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 cross-system source review with hoi4.impact_inspect and decision or mission scenarios with hoi4.decision_inspect. Impact and decision 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. Long operations support negotiated MCP tasks; native background rewrites require a stable requestKey. Large evidence is linked as resources.';