@1mcp/agent 0.37.0 → 0.38.0

package/build/sdk/legacy/transport/restartableStdioTransport.js

@@ -0,0 +1,192 @@
+import logger, { debugIf } from '../../../logger/logger.js';
+import { StdioClientTransport } from '../../../sdk/legacy/client/stdio.js';
+/**
+ * Wrapper around StdioClientTransport that provides automatic restart functionality
+ * Implements Transport interface and adds OAuth provider support
+ */
+export class RestartableStdioTransport {
+    serverParams;
+    restartConfig;
+    managedStderr;
+    _currentTransport = null;
+    _restartCount = 0;
+    _isStarting = false;
+    _isClosing = false;
+    _restartTimer = null;
+    // Extended properties for AuthProviderTransport compatibility
+    timeout;
+    tags;
+    oauthProvider;
+    // Event handlers
+    onclose;
+    onerror;
+    onmessage;
+    constructor(serverParams, restartConfig, managedStderr) {
+        this.serverParams = serverParams;
+        this.restartConfig = restartConfig;
+        this.managedStderr = managedStderr;
+        debugIf(() => ({
+            message: `Creating RestartableStdioTransport for command: ${serverParams.command}`,
+            meta: { command: serverParams.command },
+        }));
+    }
+    /**
+     * Creates a new underlying transport instance
+     */
+    createTransport() {
+        const transport = new StdioClientTransport(this.serverParams);
+        this.managedStderr?.attach(transport.stderr);
+        // Forward event handlers
+        transport.onclose = () => this.handleTransportClose();
+        transport.onerror = (error) => this.handleTransportError(error);
+        transport.onmessage = (message) => this.handleTransportMessage(message);
+        return transport;
+    }
+    /**
+     * Handles transport close events
+     */
+    handleTransportClose() {
+        if (this._isClosing) {
+            // Expected close, forward the event
+            this.onclose?.();
+            return;
+        }
+        // Unexpected close, attempt restart if configured
+        if (this.restartConfig.restartOnExit) {
+            this.attemptRestart();
+        }
+        else {
+            // No restart configured, forward close event
+            this.onclose?.();
+        }
+    }
+    /**
+     * Handles transport error events
+     */
+    handleTransportError(error) {
+        logger.error(`Transport error: ${error.message}`);
+        this.onerror?.(error);
+    }
+    /**
+     * Handles transport message events
+     */
+    handleTransportMessage(message) {
+        this.onmessage?.(message);
+    }
+    /**
+     * Attempts to restart the transport
+     */
+    attemptRestart() {
+        if (this._isClosing) {
+            return; // Don't restart if we're intentionally closing
+        }
+        const maxRestarts = this.restartConfig.maxRestarts;
+        if (maxRestarts !== undefined && this._restartCount >= maxRestarts) {
+            logger.error(`Max restart limit reached (${maxRestarts}), stopping transport`);
+            this.onerror?.(new Error(`Transport failed after ${maxRestarts} restart attempts`));
+            return;
+        }
+        this._restartCount++;
+        const restartDelay = this.restartConfig.restartDelay ?? 1000;
+        logger.info(`Attempting transport restart ${this._restartCount} in ${restartDelay}ms...`);
+        this._restartTimer = setTimeout(async () => {
+            this._restartTimer = null;
+            try {
+                await this.restartTransport();
+                logger.info(`Transport restarted successfully (attempt ${this._restartCount})`);
+            }
+            catch (error) {
+                logger.error(`Transport restart failed: ${error}`);
+                this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+            }
+        }, restartDelay);
+    }
+    /**
+     * Restarts the underlying transport
+     */
+    async restartTransport() {
+        if (this._isStarting || this._isClosing) {
+            return;
+        }
+        this._isStarting = true;
+        try {
+            // Close old transport if it exists
+            if (this._currentTransport) {
+                await this._currentTransport.close();
+            }
+            // Create and start new transport
+            this._currentTransport = this.createTransport();
+            await this._currentTransport.start();
+        }
+        finally {
+            this._isStarting = false;
+        }
+    }
+    /**
+     * Starts the transport
+     */
+    async start() {
+        if (this._currentTransport) {
+            throw new Error('RestartableStdioTransport already started!');
+        }
+        this._isStarting = true;
+        this._restartCount = 0;
+        try {
+            this._currentTransport = this.createTransport();
+            await this._currentTransport.start();
+            debugIf('RestartableStdioTransport started successfully');
+        }
+        finally {
+            this._isStarting = false;
+        }
+    }
+    /**
+     * Gets the stderr stream from the current transport
+     */
+    get stderr() {
+        return this._currentTransport?.stderr ?? null;
+    }
+    /**
+     * Gets the process PID from the current transport
+     */
+    get pid() {
+        return this._currentTransport?.pid ?? null;
+    }
+    /**
+     * Sends a message through the current transport
+     */
+    async send(message) {
+        if (!this._currentTransport) {
+            throw new Error('Transport not started');
+        }
+        return this._currentTransport.send(message);
+    }
+    /**
+     * Closes the transport and prevents restart
+     */
+    async close() {
+        this._isClosing = true;
+        // Clear any pending restart timer
+        if (this._restartTimer) {
+            clearTimeout(this._restartTimer);
+            this._restartTimer = null;
+        }
+        // Close current transport if it exists
+        if (this._currentTransport) {
+            await this._currentTransport.close();
+            this._currentTransport = null;
+        }
+        await this.managedStderr?.close();
+        debugIf('RestartableStdioTransport closed');
+    }
+    /**
+     * Gets restart statistics
+     */
+    getRestartStats() {
+        return {
+            restartCount: this._restartCount,
+            isRestarting: this._isStarting,
+        };
+    }
+}
+//# sourceMappingURL=restartableStdioTransport.js.map

package/build/sdk/legacy/transport/restartableStdioTransport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"restartableStdioTransport.js","sourceRoot":"","sources":["../../../../src/sdk/legacy/transport/restartableStdioTransport.ts"],"names":[],"mappings":"AAEA,OAAO,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAyB,MAAM,iCAAiC,CAAC;AAsB9F;;;GAGG;AACH,MAAM,OAAO,yBAAyB;IAkBjB;IACA;IACA;IAnBX,iBAAiB,GAAgC,IAAI,CAAC;IACtD,aAAa,GAAG,CAAC,CAAC;IAClB,WAAW,GAAG,KAAK,CAAC;IACpB,UAAU,GAAG,KAAK,CAAC;IACnB,aAAa,GAAyC,IAAI,CAAC;IAEnE,8DAA8D;IACvD,OAAO,CAAU;IACjB,IAAI,CAAY;IAChB,aAAa,CAAW;IAE/B,iBAAiB;IACV,OAAO,CAAc;IACrB,OAAO,CAA0B;IACjC,SAAS,CAAqC;IAErD,YACmB,YAAmC,EACnC,aAAyC,EACzC,aAAkC;QAFlC,iBAAY,GAAZ,YAAY,CAAuB;QACnC,kBAAa,GAAb,aAAa,CAA4B;QACzC,kBAAa,GAAb,aAAa,CAAqB;QAEnD,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;YACb,OAAO,EAAE,mDAAmD,YAAY,CAAC,OAAO,EAAE;YAClF,IAAI,EAAE,EAAE,OAAO,EAAE,YAAY,CAAC,OAAO,EAAE;SACxC,CAAC,CAAC,CAAC;IACN,CAAC;IAED;;OAEG;IACK,eAAe;QACrB,MAAM,SAAS,GAAG,IAAI,oBAAoB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC9D,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAE7C,yBAAyB;QACzB,SAAS,CAAC,OAAO,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC;QACtD,SAAS,CAAC,OAAO,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;QAChE,SAAS,CAAC,SAAS,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC;QAExE,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;OAEG;IACK,oBAAoB;QAC1B,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,oCAAoC;YACpC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;YACjB,OAAO;QACT,CAAC;QAED,kDAAkD;QAClD,IAAI,IAAI,CAAC,aAAa,CAAC,aAAa,EAAE,CAAC;YACrC,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,CAAC;aAAM,CAAC;YACN,6CAA6C;YAC7C,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;QACnB,CAAC;IACH,CAAC;IAED;;OAEG;IACK,oBAAoB,CAAC,KAAY;QACvC,MAAM,CAAC,KAAK,CAAC,oBAAoB,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QAClD,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;IAED;;OAEG;IACK,sBAAsB,CAAC,OAAuB;QACpD,IAAI,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,CAAC;IAC5B,CAAC;IAED;;OAEG;IACK,cAAc;QACpB,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,OAAO,CAAC,+CAA+C;QACzD,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC;QACnD,IAAI,WAAW,KAAK,SAAS,IAAI,IAAI,CAAC,aAAa,IAAI,WAAW,EAAE,CAAC;YACnE,MAAM,CAAC,KAAK,CAAC,8BAA8B,WAAW,uBAAuB,CAAC,CAAC;YAC/E,IAAI,CAAC,OAAO,EAAE,CAAC,IAAI,KAAK,CAAC,0BAA0B,WAAW,mBAAmB,CAAC,CAAC,CAAC;YACpF,OAAO;QACT,CAAC;QAED,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,MAAM,YAAY,GAAG,IAAI,CAAC,aAAa,CAAC,YAAY,IAAI,IAAI,CAAC;QAE7D,MAAM,CAAC,IAAI,CAAC,gCAAgC,IAAI,CAAC,aAAa,OAAO,YAAY,OAAO,CAAC,CAAC;QAE1F,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,KAAK,IAAI,EAAE;YACzC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;YAC1B,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBAC9B,MAAM,CAAC,IAAI,CAAC,6CAA6C,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;YAClF,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,KAAK,CAAC,6BAA6B,KAAK,EAAE,CAAC,CAAC;gBACnD,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAC5E,CAAC;QACH,CAAC,EAAE,YAAY,CAAC,CAAC;IACnB,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,gBAAgB;QAC5B,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACxC,OAAO;QACT,CAAC;QAED,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QAExB,IAAI,CAAC;YACH,mCAAmC;YACnC,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAC3B,MAAM,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC;YACvC,CAAC;YAED,iCAAiC;YACjC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;YAChD,MAAM,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC;QACvC,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QAC3B,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAK;QACT,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;QAChE,CAAC;QAED,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;QAEvB,IAAI,CAAC;YACH,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;YAChD,MAAM,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC;YACrC,OAAO,CAAC,gDAAgD,CAAC,CAAC;QAC5D,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QAC3B,CAAC;IACH,CAAC;IAED;;OAEG;IACH,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,iBAAiB,EAAE,MAAM,IAAI,IAAI,CAAC;IAChD,CAAC;IAED;;OAEG;IACH,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,iBAAiB,EAAE,GAAG,IAAI,IAAI,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,IAAI,CAAC,OAAuB;QAChC,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAC3C,CAAC;QAED,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAK;QACT,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QAEvB,kCAAkC;QAClC,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACjC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC5B,CAAC;QAED,uCAAuC;QACvC,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC3B,MAAM,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC;YACrC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAChC,CAAC;QAED,MAAM,IAAI,CAAC,aAAa,EAAE,KAAK,EAAE,CAAC;QAElC,OAAO,CAAC,kCAAkC,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACH,eAAe;QACb,OAAO;YACL,YAAY,EAAE,IAAI,CAAC,aAAa;YAChC,YAAY,EAAE,IAAI,CAAC,WAAW;SAC/B,CAAC;IACJ,CAAC;CACF"}

package/build/sdk/legacy/transport/stdioProxyTransport.d.ts

@@ -0,0 +1,92 @@
+import type { TemplateContextProof } from '../../../core/context/templateContextTrust.js';
+import type { ContextData } from '../../../types/context.js';
+/**
+ * STDIO Proxy Transport Options
+ */
+export interface StdioProxyTransportOptions {
+    serverUrl: string;
+    bearerToken?: string;
+    preset?: string;
+    filter?: string;
+    tags?: string[];
+    timeout?: number;
+    context?: ContextData;
+    contextProof?: TemplateContextProof;
+    createContextProof?: (context: ContextData) => Promise<TemplateContextProof | undefined>;
+}
+/**
+ * STDIO Proxy Transport
+ *
+ * Provides a STDIO interface that proxies all requests to a running 1MCP HTTP server.
+ * Acts as a bridge between STDIO-only MCP clients and the centralized HTTP server.
+ *
+ * This implementation uses pure transport-to-transport forwarding without the Client layer,
+ * to avoid conflicts with MCP protocol message handling.
+ */
+export declare class StdioProxyTransport {
+    private options;
+    private stdioTransport;
+    private httpTransport;
+    private isConnected;
+    private httpStarted;
+    private stdioStarted;
+    private closePromise?;
+    private context;
+    private clientInfo;
+    private initializeIntercepted;
+    private serverUrl;
+    private downstreamPin?;
+    private legacyInitializeRequestId?;
+    constructor(options: StdioProxyTransportOptions);
+    /**
+     * Start the proxy transport
+     */
+    start(): Promise<void>;
+    /**
+     * Set up HTTP transport message handlers
+     * Extracted to allow re-setup after transport recreation
+     */
+    private setupHttpTransportMessageHandlers;
+    /**
+     * Set up bidirectional message forwarding between STDIO and HTTP
+     */
+    private setupMessageForwarding;
+    private classifyDownstreamFrame;
+    private observeUpstreamFrame;
+    private isProtocolFailure;
+    private failProtocolFrame;
+    /**
+     * Build User-Agent string with optional client info
+     */
+    private buildUserAgent;
+    /**
+     * Create a custom fetch function that dynamically injects User-Agent header
+     *
+     * This ensures the HTTP server sees updated client info for all requests after
+     * the initialize message is processed. The custom fetch wraps the global fetch
+     * and merges the current User-Agent (which includes client info if available)
+     * with the request headers.
+     *
+     * Why custom fetch instead of requestInit?
+     * - The SDK's StreamableHTTPClientTransport uses _fetch directly for all requests
+     * - Updating requestInit after transport creation doesn't affect existing connections
+     * - Custom fetch allows dynamic header injection without recreating the transport
+     * - Avoids "Transport closed" errors from mid-session transport recreation
+     *
+     * @returns A fetch function that injects the current User-Agent header
+     */
+    private createDynamicHeaderFetch;
+    /**
+     * Type guard to check if a JSON-RPC message is a request
+     */
+    private isRequest;
+    /**
+     * Add context metadata to message using _meta field
+     */
+    private addContextMeta;
+    /**
+     * Close the proxy transport
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=stdioProxyTransport.d.ts.map

package/build/sdk/legacy/transport/stdioProxyTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdioProxyTransport.d.ts","sourceRoot":"","sources":["../../../../src/sdk/legacy/transport/stdioProxyTransport.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAWtF,OAAO,KAAK,EAAc,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGrE;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,YAAY,CAAC,EAAE,oBAAoB,CAAC;IACpC,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CAAC;CAC1F;AASD;;;;;;;;GAQG;AACH,qBAAa,mBAAmB;IAclB,OAAO,CAAC,OAAO;IAb3B,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,aAAa,CAAgC;IACrD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,YAAY,CAAC,CAAgB;IACrC,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,qBAAqB,CAAS;IACtC,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,aAAa,CAAC,CAAiB;IACvC,OAAO,CAAC,yBAAyB,CAAC,CAAkB;gBAEhC,OAAO,EAAE,0BAA0B;IAgDvD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAyB5B;;;OAGG;IACH,OAAO,CAAC,iCAAiC;IAyBzC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAoD9B,OAAO,CAAC,uBAAuB;IAyC/B,OAAO,CAAC,oBAAoB;IAoB5B,OAAO,CAAC,iBAAiB;YAMX,iBAAiB;IAkB/B;;OAEG;IACH,OAAO,CAAC,cAAc;IAUtB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,wBAAwB;IAwBhC;;OAEG;IACH,OAAO,CAAC,SAAS;IAOjB;;OAEG;YACW,cAAc;IAqC5B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CA0B7B"}

package/build/sdk/legacy/transport/stdioProxyTransport.js

@@ -0,0 +1,388 @@
+import { PROTOCOL_VERSION_META_KEY, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
+import { buildCliContext, generateStreamableSessionId } from '../../../commands/shared/cliContext.js';
+import { MCP_SERVER_VERSION } from '../../../constants/mcp.js';
+import { classifyProtocolEra, createGatewayFailure, } from '../../../gateway/contracts/index.js';
+import logger from '../../../logger/logger.js';
+import { toProtocolJSONRPCMessage } from '../../../sdk/contracts/index.js';
+import { StdioServerTransport } from '../../../sdk/legacy/server/stdio.js';
+import { ClientInfoExtractor } from '../../../utils/client/clientInfoExtractor.js';
+/**
+ * Generate a secure mcp-session-id for the proxy with the correct prefix
+ */
+function generateMcpSessionId() {
+    return generateStreamableSessionId();
+}
+/**
+ * STDIO Proxy Transport
+ *
+ * Provides a STDIO interface that proxies all requests to a running 1MCP HTTP server.
+ * Acts as a bridge between STDIO-only MCP clients and the centralized HTTP server.
+ *
+ * This implementation uses pure transport-to-transport forwarding without the Client layer,
+ * to avoid conflicts with MCP protocol message handling.
+ */
+export class StdioProxyTransport {
+    options;
+    stdioTransport;
+    httpTransport;
+    isConnected = false;
+    httpStarted = false;
+    stdioStarted = false;
+    closePromise;
+    context;
+    clientInfo = null;
+    initializeIntercepted = false;
+    serverUrl;
+    downstreamPin;
+    legacyInitializeRequestId;
+    constructor(options) {
+        this.options = options;
+        // Reset any previous state
+        ClientInfoExtractor.reset();
+        this.context =
+            this.options.context ||
+                buildCliContext({
+                    cwd: process.cwd(),
+                    projectRoot: process.cwd(),
+                    transportType: 'stdio-proxy',
+                    version: MCP_SERVER_VERSION,
+                    sessionId: generateMcpSessionId(),
+                });
+        logger.info('🔍 Detected proxy context', {
+            projectPath: this.context.project.path,
+            projectName: this.context.project.name,
+            sessionId: this.context.sessionId,
+        });
+        // Create STDIO server transport (for client communication)
+        this.stdioTransport = new StdioServerTransport();
+        // Prepare the server URL (no query parameters needed - using context headers)
+        this.serverUrl = new URL(this.options.serverUrl);
+        // Apply priority: preset > filter > tags (only one will be added)
+        if (this.options.preset) {
+            this.serverUrl.searchParams.set('preset', this.options.preset);
+        }
+        else if (this.options.filter) {
+            this.serverUrl.searchParams.set('filter', this.options.filter);
+        }
+        else if (this.options.tags && this.options.tags.length > 0) {
+            this.serverUrl.searchParams.set('tags', this.options.tags.join(','));
+        }
+        logger.info('📡 Proxy connecting with _meta field approach', {
+            url: this.serverUrl.toString(),
+            contextProvided: true,
+        });
+        // Create HTTP transport with custom fetch that dynamically injects User-Agent
+        // Note: sessionId is passed as a parameter, SDK will handle adding it to headers
+        this.httpTransport = new StreamableHTTPClientTransport(this.serverUrl, {
+            fetch: this.createDynamicHeaderFetch(),
+            sessionId: this.context.sessionId,
+        });
+    }
+    /**
+     * Start the proxy transport
+     */
+    async start() {
+        try {
+            // CRITICAL: Set up message forwarding BEFORE starting transports
+            // This ensures handlers are ready when messages start flowing
+            this.setupMessageForwarding();
+            // Start HTTP transport connection
+            this.httpStarted = true;
+            await this.httpTransport.start();
+            logger.info('Connected to 1MCP HTTP server');
+            // Start STDIO transport
+            this.stdioStarted = true;
+            await this.stdioTransport.start();
+            this.isConnected = true;
+            logger.info('STDIO proxy started successfully');
+        }
+        catch (error) {
+            logger.error(`Failed to start STDIO proxy: ${error}`);
+            await this.close();
+            throw error;
+        }
+    }
+    /**
+     * Set up HTTP transport message handlers
+     * Extracted to allow re-setup after transport recreation
+     */
+    setupHttpTransportMessageHandlers() {
+        // Forward messages from HTTP server to STDIO client
+        this.httpTransport.onmessage = async (message) => {
+            try {
+                this.observeUpstreamFrame(message);
+                // Forward to STDIO client
+                await this.stdioTransport.send(message);
+            }
+            catch (error) {
+                logger.error(`Error forwarding HTTP message to STDIO: ${error}`);
+                if (this.isProtocolFailure(error))
+                    await this.failProtocolFrame(message, error);
+            }
+        };
+        // Handle errors from HTTP transport
+        this.httpTransport.onerror = (error) => {
+            logger.error(`HTTP transport error: ${error.message}`);
+        };
+        // Handle HTTP transport close
+        this.httpTransport.onclose = async () => {
+            logger.warn('HTTP server connection closed');
+            await this.close();
+        };
+    }
+    /**
+     * Set up bidirectional message forwarding between STDIO and HTTP
+     */
+    setupMessageForwarding() {
+        // Forward messages from STDIO client to HTTP server
+        this.stdioTransport.onmessage = async (message) => {
+            try {
+                this.classifyDownstreamFrame(message);
+                // Check for initialize request to extract client info
+                if (!this.initializeIntercepted) {
+                    const clientInfo = ClientInfoExtractor.extractFromInitializeRequest(toProtocolJSONRPCMessage(message));
+                    if (clientInfo) {
+                        this.clientInfo = clientInfo;
+                        this.initializeIntercepted = true;
+                        logger.info('🔍 Extracted client info from initialize request', {
+                            clientName: clientInfo.name,
+                            clientVersion: clientInfo.version,
+                            clientTitle: clientInfo.title,
+                        });
+                        // Client info is now available - custom fetch will dynamically inject
+                        // the updated User-Agent header for all subsequent HTTP requests
+                        logger.info('✅ Client info extracted - User-Agent will be updated for all requests', {
+                            userAgent: this.buildUserAgent(),
+                        });
+                    }
+                }
+                // Add context metadata to message _meta field
+                const enhancedMessage = await this.addContextMeta(message);
+                // Forward to HTTP server
+                await this.httpTransport.send(enhancedMessage);
+            }
+            catch (error) {
+                logger.error(`Error forwarding STDIO message to HTTP: ${error}`);
+                if (this.isProtocolFailure(error))
+                    await this.failProtocolFrame(message, error);
+            }
+        };
+        // Set up HTTP transport message handlers
+        this.setupHttpTransportMessageHandlers();
+        // Handle errors from STDIO transport
+        this.stdioTransport.onerror = (error) => {
+            logger.error(`STDIO transport error: ${error.message}`);
+        };
+        // Handle STDIO transport close
+        this.stdioTransport.onclose = async () => {
+            logger.info('STDIO transport closed');
+            await this.close();
+        };
+    }
+    classifyDownstreamFrame(message) {
+        if (!('method' in message))
+            return;
+        const params = message.params;
+        const record = typeof params === 'object' && params !== null ? params : undefined;
+        const meta = record && typeof record._meta === 'object' && record._meta !== null
+            ? record._meta
+            : undefined;
+        const modernRevision = meta?.[PROTOCOL_VERSION_META_KEY];
+        let evidence;
+        if (message.method === 'initialize') {
+            evidence = { syntax: 'legacy', revision: record?.protocolVersion };
+            this.legacyInitializeRequestId = 'id' in message ? message.id : undefined;
+        }
+        else if (modernRevision !== undefined) {
+            evidence = { syntax: 'modern', revision: modernRevision };
+        }
+        else if (this.downstreamPin?.era === 'legacy') {
+            return;
+        }
+        else {
+            throw createGatewayFailure({
+                kind: 'protocol',
+                code: 'proxy_protocol_evidence_missing',
+                message: 'The proxy request does not contain valid protocol era evidence',
+            });
+        }
+        const classified = classifyProtocolEra(evidence);
+        if (!classified.ok)
+            throw classified.failure;
+        if (this.downstreamPin &&
+            (this.downstreamPin.era !== classified.value.era || this.downstreamPin.revision !== classified.value.revision)) {
+            throw createGatewayFailure({
+                kind: 'protocol',
+                code: 'proxy_protocol_era_conflict',
+                message: 'The proxy downstream protocol era is already pinned',
+            });
+        }
+        this.downstreamPin ??= classified.value;
+    }
+    observeUpstreamFrame(message) {
+        if (this.downstreamPin?.era !== 'legacy' || !('id' in message) || message.id !== this.legacyInitializeRequestId) {
+            return;
+        }
+        if (!('result' in message))
+            return;
+        const result = message.result;
+        const revision = typeof result === 'object' && result !== null ? result.protocolVersion : undefined;
+        const classified = classifyProtocolEra({ syntax: 'legacy', revision });
+        if (!classified.ok) {
+            throw createGatewayFailure({
+                kind: 'protocol',
+                code: 'proxy_legacy_revision_mismatch',
+                message: 'The proxy upstream selected an unsupported legacy protocol revision',
+            });
+        }
+        this.downstreamPin = classified.value;
+        this.httpTransport.setProtocolVersion(classified.value.revision);
+    }
+    isProtocolFailure(error) {
+        if (typeof error !== 'object' || error === null)
+            return false;
+        const candidate = error;
+        return candidate.kind === 'protocol' && typeof candidate.code === 'string';
+    }
+    async failProtocolFrame(message, failure) {
+        const id = 'id' in message && (typeof message.id === 'string' || typeof message.id === 'number') ? message.id : null;
+        try {
+            await this.stdioTransport.send({
+                jsonrpc: '2.0',
+                id,
+                error: {
+                    code: -32_600,
+                    message: 'Proxy protocol negotiation failed',
+                    data: { code: failure.code },
+                },
+            });
+        }
+        finally {
+            await this.close();
+        }
+    }
+    /**
+     * Build User-Agent string with optional client info
+     */
+    buildUserAgent() {
+        const base = `1MCP-Proxy/${MCP_SERVER_VERSION}`;
+        if (this.clientInfo) {
+            const { name, version, title } = this.clientInfo;
+            const clientString = title ? `${name}/${version} (${title})` : `${name}/${version}`;
+            return `${base} ${clientString}`;
+        }
+        return base;
+    }
+    /**
+     * Create a custom fetch function that dynamically injects User-Agent header
+     *
+     * This ensures the HTTP server sees updated client info for all requests after
+     * the initialize message is processed. The custom fetch wraps the global fetch
+     * and merges the current User-Agent (which includes client info if available)
+     * with the request headers.
+     *
+     * Why custom fetch instead of requestInit?
+     * - The SDK's StreamableHTTPClientTransport uses _fetch directly for all requests
+     * - Updating requestInit after transport creation doesn't affect existing connections
+     * - Custom fetch allows dynamic header injection without recreating the transport
+     * - Avoids "Transport closed" errors from mid-session transport recreation
+     *
+     * @returns A fetch function that injects the current User-Agent header
+     */
+    createDynamicHeaderFetch() {
+        return async (input, init) => {
+            // Build current User-Agent (includes client info if available)
+            const currentUserAgent = this.buildUserAgent();
+            // Merge headers: preserve existing headers, add/update User-Agent
+            const headers = new Headers(init?.headers);
+            headers.set('User-Agent', currentUserAgent);
+            if (this.options.bearerToken) {
+                headers.set('Authorization', `Bearer ${this.options.bearerToken}`);
+            }
+            // Create new init with updated headers
+            const updatedInit = {
+                ...init,
+                headers,
+                redirect: 'error',
+            };
+            // Call global fetch with updated headers
+            return fetch(input, updatedInit);
+        };
+    }
+    /**
+     * Type guard to check if a JSON-RPC message is a request
+     */
+    isRequest(message) {
+        return 'method' in message;
+    }
+    /**
+     * Add context metadata to message using _meta field
+     */
+    async addContextMeta(message) {
+        // Create context with client info if available
+        const contextWithClient = {
+            ...this.context,
+            ...(this.clientInfo && {
+                transport: {
+                    type: 'stdio-proxy',
+                    connectionTimestamp: new Date().toISOString(),
+                    client: this.clientInfo,
+                },
+            }),
+        };
+        const contextProof = this.options.createContextProof
+            ? await this.options.createContextProof(contextWithClient)
+            : this.options.contextProof;
+        // Only add _meta to messages that are requests (have params)
+        if (this.isRequest(message) && message.params !== undefined) {
+            const params = message.params;
+            // Return a new message object with _meta field
+            return {
+                ...message,
+                params: {
+                    ...params,
+                    _meta: {
+                        ...(params._meta || {}), // Preserve existing _meta
+                        context: contextWithClient, // Add our context data
+                        ...(contextProof ? { contextProof } : {}),
+                    },
+                },
+            };
+        }
+        // Return original message for responses or requests without params
+        return message;
+    }
+    /**
+     * Close the proxy transport
+     */
+    async close() {
+        if (this.closePromise)
+            return this.closePromise;
+        if (!this.httpStarted && !this.stdioStarted && !this.isConnected)
+            return;
+        this.isConnected = false;
+        this.closePromise = (async () => {
+            this.httpTransport.onmessage = undefined;
+            this.httpTransport.onerror = undefined;
+            this.httpTransport.onclose = undefined;
+            this.stdioTransport.onmessage = undefined;
+            this.stdioTransport.onerror = undefined;
+            this.stdioTransport.onclose = undefined;
+            const closers = [];
+            if (this.httpStarted)
+                closers.push(this.httpTransport.close());
+            if (this.stdioStarted)
+                closers.push(this.stdioTransport.close());
+            this.httpStarted = false;
+            this.stdioStarted = false;
+            const outcomes = await Promise.allSettled(closers);
+            for (const outcome of outcomes) {
+                if (outcome.status === 'rejected')
+                    logger.error(`Error closing STDIO proxy: ${outcome.reason}`);
+            }
+            logger.info('STDIO proxy closed');
+        })();
+        return this.closePromise;
+    }
+}
+//# sourceMappingURL=stdioProxyTransport.js.map