hoi4-agent-tools 3.0.9 → 3.2.0

package/dist/hoi4_agent_tools/mcp/tools/technology.js

@@ -1,83 +1,22 @@
+import { registerLegacyTaskTools } from '../server/legacy-task-tools.js';
 import { z } from 'zod/v4';
-import { publicArtifactLink } from '../../core/artifacts.js';
-import { compareCodeUnits, hashCanonical } from '../../core/canonical.js';
-import { IdleCacheLifetime } from '../../core/idle-cache-lifetime.js';
-import { emptyServiceResult } from '../../core/result.js';
-import { workspaceIdSchema } from '../../schemas/common.js';
-import { technologyDefectClassSchema, technologyDirectionSchema, technologyGraphReferenceSchema, technologyIdSchema, technologyImpactSchema, technologyProposedSourceSchema, technologyRenderViewSchema, technologyUnlockKindSchema, } from '../../schemas/technology.js';
-import { TechnologyTreeViewer, technologyDiagnostics, } from '../../technology/service.js';
+import { helperExpansionRequestSchema, helperExpansionSummarySchema, } from '../../schemas/helper-expansion.js';
+import { technologyAnalysisModeSchema, technologyCompareRequestSchema, technologyGraphReferenceSchema, technologyImpactSchema, technologyInspectRequestSchema, technologyProposedSourceSchema, technologyRenderRequestSchema, technologyRenderViewSchema, validateTechnologyCompareRequest, validateTechnologyInspectRequest, } from '../../schemas/technology.js';
 import { compactValidatedInputSchema } from '../server/context-schemas.js';
 import { nonNegativeIntegerSchema, sha256Schema } from '../server/output-schemas.js';
-import { progressReporter } from '../server/progress.js';
-import { errorResult, setInlineFilesScanned, strictOperationResultSchema, toolResult, } from '../server/result.js';
-import { resolveServerWorkspaceId } from '../server/base-tools.js';
-const technologyMode = z.enum([
-    'scan',
-    'folders',
-    'trace',
-    'explain',
-    'unlocks',
-    'bonus_coverage',
-    'lint',
-    'impact',
-]);
-const inspectInput = z
+import { strictOperationResultSchema } from '../server/result.js';
+const inspectInputSchema = z
     .object({
-    workspaceId: workspaceIdSchema,
-    mode: technologyMode,
-    folderId: technologyIdSchema.optional(),
-    technologyId: technologyIdSchema.optional(),
-    categoryId: technologyIdSchema.optional(),
-    targetKind: technologyUnlockKindSchema.optional(),
-    targetId: technologyIdSchema.optional(),
-    direction: technologyDirectionSchema.optional(),
-    maxDepth: z.number().int().min(1).max(256).optional(),
-    maxNodes: z.number().int().min(1).max(25_000).optional(),
-    includeSubTechnologies: z.boolean().optional(),
-    classifications: z.array(technologyDefectClassSchema).max(4).optional(),
-    codes: z.array(z.string().min(1).max(256)).max(100).optional(),
+    ...technologyInspectRequestSchema.shape,
+    helperExpansion: compactValidatedInputSchema(helperExpansionRequestSchema, 'Bounded helper paths; opaque continuationUri resumes the same source and roots. See docs/technology.md.').optional(),
     impact: compactValidatedInputSchema(technologyImpactSchema, 'Rename or removal subject.').optional(),
-    refresh: z.boolean().optional(),
 })
     .strict()
-    .superRefine((value, context) => {
-    if ((value.mode === 'trace' || value.mode === 'explain') && value.technologyId === undefined)
-        context.addIssue({
-            code: 'custom',
-            path: ['technologyId'],
-            message: `${value.mode} requires technologyId`,
-        });
-    if (value.mode === 'impact' && value.impact === undefined)
-        context.addIssue({
-            code: 'custom',
-            path: ['impact'],
-            message: 'Impact mode requires impact',
-        });
-});
-const renderInput = z
+    .superRefine(validateTechnologyInspectRequest);
+const renderInputSchema = z.object({ ...technologyRenderRequestSchema.shape }).strict();
+const compareInputSchema = z
     .object({
-    workspaceId: workspaceIdSchema,
-    view: technologyRenderViewSchema.exclude(['comparison']),
-    folderId: technologyIdSchema.optional(),
-    technologyId: technologyIdSchema.optional(),
-    categoryId: technologyIdSchema.optional(),
-    targetId: technologyIdSchema.optional(),
-    maxNodes: z.number().int().min(1).max(2_000).optional(),
-    includeHtml: z.boolean().optional(),
-    refresh: z.boolean().optional(),
-})
-    .strict()
-    .superRefine((value, context) => {
-    if (value.view === 'folder' && value.folderId === undefined)
-        context.addIssue({
-            code: 'custom',
-            path: ['folderId'],
-            message: 'Folder view requires folderId',
-        });
-});
-const compareInput = z
-    .object({
-    workspaceId: workspaceIdSchema,
+    ...technologyCompareRequestSchema.shape,
     before: compactValidatedInputSchema(technologyGraphReferenceSchema, 'Revision or graph resource.').optional(),
     after: compactValidatedInputSchema(technologyGraphReferenceSchema, 'Revision or graph resource.').optional(),
     proposedSources: z
@@ -85,19 +24,9 @@ const compareInput = z
         .min(1)
         .max(128)
         .optional(),
-    render: z.boolean().optional(),
-    maxRenderNodes: z.number().int().min(1).max(2_000).optional(),
-    refresh: z.boolean().optional(),
 })
     .strict()
-    .superRefine((value, context) => {
-    if (value.after !== undefined && value.proposedSources !== undefined)
-        context.addIssue({
-            code: 'custom',
-            path: ['after'],
-            message: 'after conflicts with proposedSources',
-        });
-});
+    .superRefine(validateTechnologyCompareRequest);
 const countsSchema = z
     .object({
     technologies: nonNegativeIntegerSchema,
@@ -112,15 +41,16 @@ const countsSchema = z
     artifacts: nonNegativeIntegerSchema,
 })
     .strict();
-const analysisOutput = strictOperationResultSchema(z
+const analysisOutputSchema = strictOperationResultSchema(z
     .object({
-    mode: technologyMode,
+    mode: technologyAnalysisModeSchema,
     revision: sha256Schema,
     graphHash: sha256Schema,
     counts: countsSchema,
+    helperExpansion: helperExpansionSummarySchema.optional(),
 })
     .strict());
-const renderOutput = strictOperationResultSchema(z
+const renderOutputSchema = strictOperationResultSchema(z
     .object({
     view: technologyRenderViewSchema,
     revision: sha256Schema,
@@ -139,7 +69,7 @@ const renderOutput = strictOperationResultSchema(z
     sourceAccurate: z.boolean(),
 })
     .strict());
-const compareOutput = strictOperationResultSchema(z
+const compareOutputSchema = strictOperationResultSchema(z
     .object({
     beforeRevision: sha256Schema,
     afterRevision: sha256Schema,
@@ -155,232 +85,38 @@ const compareOutput = strictOperationResultSchema(z
         .optional(),
 })
     .strict());
-const readOnly = {
+const readOnlyTechnologyTool = {
     readOnlyHint: true,
     destructiveHint: false,
     idempotentHint: true,
     openWorldHint: false,
 };
-function graphHash(graph) {
-    return hashCanonical({
-        schemaVersion: graph.schemaVersion,
-        analysisMode: graph.analysisMode ?? 'full',
-        workspaceIdentity: graph.workspaceIdentity,
-        revision: graph.revision,
-        statistics: graph.statistics,
-        sourceHashes: graph.sourceHashes,
-    });
-}
-function counts(graph, artifacts) {
-    return {
-        technologies: graph.statistics.technologyCount,
-        legacyDoctrines: graph.statistics.legacyDoctrineCount,
-        folders: graph.statistics.folderCount,
-        placements: graph.statistics.placementCount,
-        edges: graph.edges.length,
-        unlocks: graph.statistics.unlockCount,
-        references: graph.statistics.externalReferenceCount,
-        issues: graph.statistics.issueCount,
-        unresolved: graph.statistics.unresolvedCount,
-        artifacts,
-    };
-}
-function validation(graph) {
-    const blocking = technologyDiagnostics(graph).filter(({ severity }) => severity === 'error' || severity === 'blocker').length;
-    return {
-        passed: graph.complete && blocking === 0,
-        checks: [
-            {
-                id: 'technology-analysis',
-                passed: graph.complete && blocking === 0,
-                message: graph.complete
-                    ? `${blocking} blocking technology diagnostics; full evidence is linked`
-                    : graph.analysisMode === 'focused'
-                        ? 'Helper projections were deferred for this large workspace; direct evidence is linked'
-                        : `${graph.skippedSourceCount} source(s) were skipped; full evidence is linked`,
-            },
-        ],
-    };
-}
-function analysisRequest(input, workspaceId, context, signal) {
-    const impact = input.impact === undefined
-        ? undefined
-        : {
-            kind: input.impact.kind,
-            id: input.impact.id,
-            operation: input.impact.operation,
-            ...(input.impact.replacementId === undefined
-                ? {}
-                : { replacementId: input.impact.replacementId }),
-        };
-    const values = {
-        folderId: input.folderId,
-        technologyId: input.technologyId,
-        categoryId: input.categoryId,
-        targetKind: input.targetKind,
-        targetId: input.targetId,
-        direction: input.direction,
-        maxDepth: input.maxDepth,
-        maxNodes: input.maxNodes,
-        includeSubTechnologies: input.includeSubTechnologies,
-        classifications: input.classifications,
-        codes: input.codes,
-        impact,
-        refresh: input.refresh,
-    };
-    const compact = Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined));
-    return {
-        workspaceId,
-        mode: input.mode,
-        ...compact,
-        ...(context.principal === undefined ? {} : { principal: context.principal }),
-        signal,
-    };
-}
-export function registerTechnologyTools(server, engine, context) {
-    const viewer = new TechnologyTreeViewer(engine);
-    const cacheLifetime = new IdleCacheLifetime(() => viewer.clearCaches());
-    server.registerTool('hoi4.tech_inspect', {
+export const technologyTaskTools = [
+    {
+        name: 'hoi4.tech_inspect',
         title: 'Inspect technology trees',
         description: 'Scan, discover folders, trace, explain, inspect unlocks or bonuses, lint, and assess impact.',
-        inputSchema: inspectInput,
-        outputSchema: analysisOutput,
-        annotations: readOnly,
-    }, async (input, extra) => {
-        const workspaceId = await resolveServerWorkspaceId(engine, context, input.workspaceId, extra.signal);
-        const releaseCaches = cacheLifetime.begin();
-        try {
-            const progress = progressReporter(extra);
-            await progress.report(0, 2, 'Analyzing technologies');
-            const output = await viewer.analyze(analysisRequest(input, workspaceId, context, progress.signal));
-            const result = emptyServiceResult(workspaceId, {
-                mode: input.mode,
-                revision: output.graph.revision,
-                graphHash: graphHash(output.graph),
-                counts: counts(output.graph, output.artifacts.length),
-            });
-            result.code = output.graph.complete ? 'TECH_INSPECTED' : 'TECH_INSPECTED_PARTIAL';
-            setInlineFilesScanned(result, output.graph.filesScanned);
-            result.artifacts = output.artifacts.map(publicArtifactLink);
-            result.validation = validation(output.graph);
-            await progress.report(2, 2, 'Technology analysis complete');
-            return toolResult(result);
-        }
-        catch (error) {
-            return errorResult(error, workspaceId);
-        }
-        finally {
-            releaseCaches();
-        }
-    });
-    server.registerTool('hoi4.tech_render', {
+        inputSchema: inspectInputSchema,
+        outputSchema: analysisOutputSchema,
+        annotations: readOnlyTechnologyTool,
+    },
+    {
+        name: 'hoi4.tech_render',
         title: 'Render technology trees',
         description: 'Render source-linked JSON, SVG, PNG, and optional HTML technology views.',
-        inputSchema: renderInput,
-        outputSchema: renderOutput,
-        annotations: readOnly,
-    }, async (input, extra) => {
-        const workspaceId = await resolveServerWorkspaceId(engine, context, input.workspaceId, extra.signal);
-        const releaseCaches = cacheLifetime.begin();
-        try {
-            const progress = progressReporter(extra);
-            const request = {
-                workspaceId,
-                view: input.view,
-                ...(input.folderId === undefined ? {} : { folderId: input.folderId }),
-                ...(input.technologyId === undefined ? {} : { technologyId: input.technologyId }),
-                ...(input.categoryId === undefined ? {} : { categoryId: input.categoryId }),
-                ...(input.targetId === undefined ? {} : { targetId: input.targetId }),
-                ...(input.maxNodes === undefined ? {} : { maxNodes: input.maxNodes }),
-                ...(input.includeHtml === undefined ? {} : { includeHtml: input.includeHtml }),
-                ...(input.refresh === undefined ? {} : { refresh: input.refresh }),
-                ...(context.principal === undefined ? {} : { principal: context.principal }),
-                signal: progress.signal,
-            };
-            const output = await viewer.renderAndStore(request);
-            const result = emptyServiceResult(workspaceId, {
-                view: output.render.view,
-                revision: output.graph.revision,
-                graphHash: graphHash(output.graph),
-                hashes: output.render.hashes,
-                selectedNodes: output.render.selectedIds.length,
-                omittedNodes: output.render.omittedNodeCount,
-                focusedRenders: output.focused.length,
-                sourceAccurate: output.render.sourceAccurate,
-            });
-            result.code = output.graph.complete ? 'TECH_RENDERED' : 'TECH_RENDERED_PARTIAL';
-            setInlineFilesScanned(result, output.graph.filesScanned);
-            result.artifacts = output.artifacts.map(publicArtifactLink);
-            result.validation = validation(output.graph);
-            return toolResult(result);
-        }
-        catch (error) {
-            return errorResult(error, workspaceId);
-        }
-        finally {
-            releaseCaches();
-        }
-    });
-    server.registerTool('hoi4.tech_compare', {
+        inputSchema: renderInputSchema,
+        outputSchema: renderOutputSchema,
+        annotations: readOnlyTechnologyTool,
+    },
+    {
+        name: 'hoi4.tech_compare',
         title: 'Compare technology trees',
         description: 'Compare cached, resource-backed, current, or proposed source graphs without writes.',
-        inputSchema: compareInput,
-        outputSchema: compareOutput,
-        annotations: readOnly,
-    }, async (input, extra) => {
-        const workspaceId = await resolveServerWorkspaceId(engine, context, input.workspaceId, extra.signal);
-        const releaseCaches = cacheLifetime.begin();
-        try {
-            const progress = progressReporter(extra);
-            const request = {
-                workspaceId,
-                ...(input.before === undefined
-                    ? {}
-                    : { before: input.before }),
-                ...(input.after === undefined
-                    ? {}
-                    : { after: input.after }),
-                ...(input.proposedSources === undefined
-                    ? {}
-                    : {
-                        proposedSources: input.proposedSources,
-                    }),
-                ...(input.render === undefined ? {} : { render: input.render }),
-                ...(input.maxRenderNodes === undefined ? {} : { maxRenderNodes: input.maxRenderNodes }),
-                ...(input.refresh === undefined ? {} : { refresh: input.refresh }),
-                ...(context.principal === undefined ? {} : { principal: context.principal }),
-                signal: progress.signal,
-            };
-            const output = await viewer.compareAndStore(request);
-            const comparison = output.comparison;
-            const result = emptyServiceResult(workspaceId, {
-                beforeRevision: comparison.beforeRevision,
-                afterRevision: comparison.afterRevision,
-                added: comparison.technologies.added.length,
-                removed: comparison.technologies.removed.length,
-                renamed: comparison.technologies.renamed.length,
-                moved: comparison.technologies.moved.length,
-                regressions: comparison.regressions.length,
-                artifacts: output.artifacts.length,
-                ...(output.render === undefined ? {} : { renderHashes: output.render.hashes }),
-            });
-            result.code =
-                output.before.complete && output.after.complete
-                    ? 'TECH_COMPARED'
-                    : 'TECH_COMPARED_PARTIAL';
-            setInlineFilesScanned(result, [...new Set([...output.before.filesScanned, ...output.after.filesScanned])].sort(compareCodeUnits));
-            result.artifacts = output.artifacts.map(publicArtifactLink);
-            result.validation = {
-                passed: validation(output.before).passed && validation(output.after).passed,
-                checks: [...validation(output.before).checks, ...validation(output.after).checks],
-            };
-            return toolResult(result);
-        }
-        catch (error) {
-            return errorResult(error, workspaceId);
-        }
-        finally {
-            releaseCaches();
-        }
-    });
+        inputSchema: compareInputSchema,
+        outputSchema: compareOutputSchema,
+        annotations: readOnlyTechnologyTool,
+    },
+];
+export function registerTechnologyTools(server) {
+    registerLegacyTaskTools(server, technologyTaskTools);
 }

package/dist/hoi4_agent_tools/mcp/transports/http.js

@@ -2,6 +2,8 @@ import { randomUUID } from 'node:crypto';
 import { isIP } from 'node:net';
 import { TextDecoder } from 'node:util';
 import express, {} from 'express';
+import { toNodeHandler, toWebRequest } from '@modelcontextprotocol/node';
+import { createMcpHandler, isLegacyRequest } from '@modelcontextprotocol/server';
 import { hostHeaderValidation } from '@modelcontextprotocol/sdk/server/middleware/hostHeaderValidation.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest, SUPPORTED_PROTOCOL_VERSIONS, } from '@modelcontextprotocol/sdk/types.js';
@@ -9,6 +11,7 @@ import { HTTP_MAX_AGGREGATE_BODY_BYTES } from '../../core/configuration.js';
 import { canonicalJson } from '../../core/canonical.js';
 import { authenticate, bearerChallenge, HttpAuthError, protectedResourceMetadata, validateHttpDeployment, } from '../security/auth.js';
 import { BoundedEventStore, SharedEventStoreBudget } from './event-store.js';
+import { createModernOperationServer } from '../server/create-modern-operations.js';
 import { FinalProtocolTransport } from './protocol-gate.js';
 const WRITE_SCOPED_TOOLS = new Set(['hoi4.focus_rewrite', 'hoi4.gui_rewrite', 'hoi4.map_rewrite']);
 const MCP_ALLOWED_METHODS = 'GET, POST, DELETE';
@@ -18,6 +21,8 @@ const SINGLETON_SECURITY_HEADERS = new Set([
     'content-type',
     'host',
     'last-event-id',
+    'mcp-method',
+    'mcp-name',
     'mcp-protocol-version',
     'mcp-session-id',
     'origin',
@@ -211,7 +216,8 @@ function rejectAmbiguousSecurityHeaders(request, response, next) {
     const counts = new Map();
     for (let index = 0; index < request.rawHeaders.length; index += 2) {
         const name = request.rawHeaders[index]?.toLowerCase();
-        if (name !== undefined && SINGLETON_SECURITY_HEADERS.has(name)) {
+        if (name !== undefined &&
+            (SINGLETON_SECURITY_HEADERS.has(name) || name.startsWith('mcp-param-'))) {
             counts.set(name, (counts.get(name) ?? 0) + 1);
         }
     }
@@ -437,6 +443,51 @@ export async function startHttpServer(engine, configuration, serverFactory) {
             sendAuthError(response, configuration, authError);
         }
     };
+    const routeModernRequest = async (request, response) => {
+        // Preserve the legacy adapter's response contract for every claim-less request, including
+        // malformed JSON-RPC bodies. Explicit modern claims alone enter the SDK's strict ladder.
+        const body = request.body;
+        const params = isRecord(body) && isRecord(body.params) ? body.params : undefined;
+        const metadata = params !== undefined && isRecord(params._meta) ? params._meta : undefined;
+        const modernClaim = (isRecord(body) && body.method === 'server/discover') ||
+            request.headers['mcp-protocol-version'] === '2026-07-28' ||
+            request.headers['mcp-method'] !== undefined ||
+            request.headers['mcp-name'] !== undefined ||
+            Object.keys(request.headers).some((name) => name.startsWith('mcp-param-')) ||
+            (metadata !== undefined &&
+                Object.keys(metadata).some((name) => name.startsWith('io.modelcontextprotocol/')));
+        if (!modernClaim)
+            return false;
+        // An explicit malformed modern claim belongs to modern validation, never to a legacy session.
+        // The Node SDK helper concatenates Host and req.url. A validated absolute-form target
+        // must therefore be changed to origin-form only while this SDK adapter consumes it.
+        const originalUrl = request.url;
+        if (!originalUrl.startsWith('/')) {
+            const target = new URL(originalUrl);
+            request.url = `${target.pathname}${target.search}`;
+        }
+        try {
+            const probe = await toWebRequest(request, request.body);
+            if (await isLegacyRequest(probe, request.body))
+                return false;
+            const principal = request.authPrincipal;
+            if (principal === undefined) {
+                jsonRpcError(response, 401, 'Authentication context is missing');
+                return true;
+            }
+            // The only principal and scopes given to the modern core come from the authenticated
+            // middleware. No request envelope or caller-authored metadata can substitute for them.
+            const modern = createMcpHandler(() => createModernOperationServer(engine, {
+                principal: principal.principal,
+                scopes: [...principal.scopes],
+            }), { legacy: 'reject', responseMode: 'auto' });
+            await toNodeHandler(modern)(request, response, request.body);
+            return true;
+        }
+        finally {
+            request.url = originalUrl;
+        }
+    };
     app.all('/mcp', async (request, response, next) => {
         if (['GET', 'POST', 'DELETE'].includes(request.method)) {
             next();
@@ -575,6 +626,8 @@ export async function startHttpServer(engine, configuration, serverFactory) {
     };
     app.post('/mcp', authenticateMiddleware, async (request, response) => {
         try {
+            if (await routeModernRequest(request, response))
+                return;
             const sessionId = sessionHeader(request);
             if (rejectInvalidProtocolHeader(request, response, sessionId !== undefined))
                 return;
@@ -696,6 +749,8 @@ export async function startHttpServer(engine, configuration, serverFactory) {
         }
     });
     app.get('/mcp', authenticateMiddleware, async (request, response) => {
+        if (await routeModernRequest(request, response))
+            return;
         if (rejectInvalidProtocolHeader(request, response, true))
             return;
         const session = await findSession(request, response);
@@ -740,6 +795,8 @@ export async function startHttpServer(engine, configuration, serverFactory) {
         await session.transport.handleRequest(request, response);
     });
     app.delete('/mcp', authenticateMiddleware, async (request, response) => {
+        if (await routeModernRequest(request, response))
+            return;
         if (rejectInvalidProtocolHeader(request, response, true))
             return;
         const session = await findSession(request, response);

package/dist/hoi4_agent_tools/mcp/transports/modern-task-routing.js

@@ -0,0 +1,109 @@
+import { isJSONRPCRequest, isJSONRPCNotification, PROTOCOL_VERSION_META_KEY, Server, } from '@modelcontextprotocol/server';
+import { CancelledNotificationSchema } from '@modelcontextprotocol/core';
+import { secureId } from '../../core/canonical.js';
+export const MODERN_TASK_ROUTES = new Map([
+    ['tasks/get', 'io.github.klimPaskov/hoi4-agent-tools.internal/tasks/get'],
+    ['tasks/update', 'io.github.klimPaskov/hoi4-agent-tools.internal/tasks/update'],
+    ['tasks/cancel', 'io.github.klimPaskov/hoi4-agent-tools.internal/tasks/cancel'],
+]);
+const privateMethods = new Set(MODERN_TASK_ROUTES.values());
+/**
+ * SDK 2.0.0 issue #2598: historical tasks/get and tasks/cancel are rejected by
+ * its core-method era gate before registered extension handlers can run.
+ * Rewrite only these extension method names at the public Transport seam.
+ * The SDK still validates the envelope and pins the era; HTTP/auth metadata,
+ * request IDs, cancellation, params, and every other method remain untouched.
+ */
+// eslint-disable-next-line @typescript-eslint/no-deprecated -- Public advanced Server API is needed to decorate its transport; McpServer cannot inject one.
+export class ModernTaskRoutingServer extends Server {
+    async connect(transport) {
+        // SDK 2.0.0's cancellation handler ignores falsy IDs (0 and ''). Give only those
+        // active requests private truthy IDs internally and preserve their exact wire IDs.
+        const requestAliases = new Map();
+        const responseAliases = new Map();
+        const releaseAlias = (alias) => {
+            const original = responseAliases.get(alias);
+            if (original !== undefined)
+                requestAliases.delete(original);
+            responseAliases.delete(alias);
+        };
+        const routed = {
+            get sessionId() {
+                return transport.sessionId;
+            },
+            ...(transport.hasPerRequestStream === undefined
+                ? {}
+                : { hasPerRequestStream: transport.hasPerRequestStream }),
+            start: async () => {
+                transport.onclose = () => {
+                    requestAliases.clear();
+                    responseAliases.clear();
+                    routed.onclose?.();
+                };
+                transport.onerror = (error) => routed.onerror?.(error);
+                transport.onmessage = (message, extra) => {
+                    if (isJSONRPCRequest(message) && privateMethods.has(message.method)) {
+                        void transport
+                            .send({
+                            jsonrpc: '2.0',
+                            id: message.id,
+                            error: { code: -32601, message: 'Method not found' },
+                        })
+                            .catch((error) => routed.onerror?.(error instanceof Error ? error : new Error('Response could not be sent')));
+                        return;
+                    }
+                    const alias = isJSONRPCRequest(message) &&
+                        message.params?._meta?.[PROTOCOL_VERSION_META_KEY] === '2026-07-28'
+                        ? MODERN_TASK_ROUTES.get(message.method)
+                        : undefined;
+                    let inbound = alias === undefined ? message : { ...message, method: alias };
+                    if (isJSONRPCRequest(inbound) && (inbound.id === 0 || inbound.id === '')) {
+                        if (requestAliases.has(inbound.id)) {
+                            void transport
+                                .send({
+                                jsonrpc: '2.0',
+                                id: inbound.id,
+                                error: { code: -32600, message: 'Request ID is already active' },
+                            })
+                                .catch((error) => routed.onerror?.(error instanceof Error ? error : new Error('Response could not be sent')));
+                            return;
+                        }
+                        const requestAlias = secureId('mcp_request');
+                        requestAliases.set(inbound.id, requestAlias);
+                        responseAliases.set(requestAlias, inbound.id);
+                        inbound = { ...inbound, id: requestAlias };
+                    }
+                    else if (isJSONRPCNotification(inbound) &&
+                        inbound.method === 'notifications/cancelled' &&
+                        CancelledNotificationSchema.safeParse(inbound).success) {
+                        const original = inbound.params?.requestId;
+                        const requestAlias = original === 0 || original === '' ? requestAliases.get(original) : undefined;
+                        if (requestAlias !== undefined) {
+                            inbound = { ...inbound, params: { ...inbound.params, requestId: requestAlias } };
+                            releaseAlias(requestAlias);
+                        }
+                    }
+                    routed.onmessage?.(inbound, extra);
+                };
+                await transport.start();
+            },
+            send: (message, options) => {
+                const original = 'id' in message && typeof message.id === 'string'
+                    ? responseAliases.get(message.id)
+                    : undefined;
+                const related = typeof options?.relatedRequestId === 'string'
+                    ? responseAliases.get(options.relatedRequestId)
+                    : undefined;
+                const outbound = original === undefined ? message : { ...message, id: original };
+                if (original !== undefined && 'id' in message && typeof message.id === 'string')
+                    releaseAlias(message.id);
+                return transport.send(outbound, related === undefined ? options : { ...options, relatedRequestId: related });
+            },
+            close: () => transport.close(),
+            setProtocolVersion: (version) => transport.setProtocolVersion?.(version),
+            setSupportedProtocolVersions: (versions) => transport.setSupportedProtocolVersions?.(versions),
+        };
+        // eslint-disable-next-line @typescript-eslint/no-deprecated -- Connect the public advanced Server API after wrapping the transport.
+        await super.connect(routed);
+    }
+}