langmart-gateway-type3 3.0.40 → 3.0.42

package/dist/gateway-server.js

@@ -16,25 +16,13 @@ const local_vault_1 = require("./local-vault");
 const gateway_config_1 = require("./gateway-config");
 const headless_session_1 = require("./headless-session");
 const gateway_mode_1 = require("./gateway-mode");
-/**
- * Type 3 Gateway Server
- * Seller-managed gateway deployed on seller's infrastructure
- *
- * Key Differences from Type 2:
- * - Uses local vault for provider credentials (NOT central database)
- * - Seller manages their own API keys
- * - More privacy and control for sellers
- *
- * Similarities to Type 2:
- * - Same WebSocket communication protocol with Type 1
- * - Same request/response format
- * - Same registration and heartbeat mechanisms
- */
 class Type3GatewayServer extends events_1.EventEmitter {
     constructor(config) {
         super();
         this.wss = null;
-        this.marketplaceWs = null;
+        this.registryWs = null; // Primary connection (backward compat)
+        // Multi-connect: Map of server connections (serverId -> connection)
+        this.serverConnections = new Map();
         this.activeRequests = new Map();
         this.healthCheckInterval = null;
         // Version loaded dynamically - works from both source and dist folders
@@ -66,8 +54,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
         this.isShuttingDown = false;
         this.headlessSessionManager = null; // For remote automation sessions
         this.port = config.port;
-        this.marketplaceUrl = config.marketplaceUrl || 'wss://control.marketplace.ai';
-        this.marketplaceApiUrl = config.marketplaceUrl?.replace('wss://', 'https://').replace('control.', 'api.') || 'https://api.marketplace.ai';
+        this.registryUrl = config.registryUrl || 'wss://control.registry.ai';
+        this.registryApiUrl = config.registryUrl?.replace('wss://', 'https://').replace('control.', 'api.') || 'https://api.registry.ai';
         // Set gateway mode (defaults to FULL for backward compatibility)
         this.gatewayMode = config.mode ?? gateway_mode_1.GatewayMode.FULL;
         this.enableRemoteLLMSession = config.enableRemoteLLMSession ?? true;
@@ -142,8 +130,9 @@ class Type3GatewayServer extends events_1.EventEmitter {
         console.log(`[${this.nodeId}] Starting Type 3 Gateway Server on port ${this.port}`);
         // 1. Start management REST API server for CLI
         await this.startManagementServer();
-        // 2. Connect to marketplace control plane (primary function)
-        await this.connectToMarketplace();
+        // 2. Connect to all inference servers (Multi-Connect architecture)
+        // This discovers all Type 0/Type 1 servers and connects to each
+        await this.connectToAllServers();
         // 3. Load credentials from local vault (only if LLM routing is enabled)
         if (this.enableLLMRouting) {
             await this.loadCredentials();
@@ -155,11 +144,234 @@ class Type3GatewayServer extends events_1.EventEmitter {
         }
         // 5. Start health monitoring
         this.startHealthMonitoring();
-        // 6. Register with marketplace (includes tool discovery)
+        // 6. Register with registry (includes tool discovery)
         await this.registerGateway();
         console.log(`[${this.nodeId}] Type 3 Gateway ready and registered`);
         console.log(`[${this.nodeId}] Management API: http://localhost:${this.port}`);
     }
+    /**
+     * Discover all available inference servers from the registry
+     * This enables Type 3 Multi-Connect architecture
+     */
+    async discoverInferenceServers() {
+        try {
+            // Convert WebSocket URL to HTTP for API call
+            const httpUrl = this.registryUrl
+                .replace('ws://', 'http://')
+                .replace('wss://', 'https://');
+            const discoveryUrl = `${httpUrl}/api/public/inference-servers`;
+            console.log(`[${this.nodeId}] Discovering inference servers from ${discoveryUrl}...`);
+            const response = await axios_1.default.get(discoveryUrl, {
+                timeout: 5000,
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`
+                }
+            });
+            if (response.data?.success && Array.isArray(response.data.servers)) {
+                const servers = response.data.servers;
+                console.log(`[${this.nodeId}] Discovered ${servers.length} inference servers:`);
+                servers.forEach(s => {
+                    console.log(`[${this.nodeId}]   - ${s.name} (${s.serverType}:${s.port}) ${s.isActive ? '[ACTIVE]' : ''}`);
+                });
+                return servers;
+            }
+            console.log(`[${this.nodeId}] No servers discovered, falling back to single connection`);
+            return [];
+        }
+        catch (error) {
+            console.log(`[${this.nodeId}] Server discovery failed: ${error.message}, using single connection`);
+            return [];
+        }
+    }
+    /**
+     * Connect to all discovered inference servers (Multi-Connect)
+     */
+    async connectToAllServers() {
+        const servers = await this.discoverInferenceServers();
+        if (servers.length === 0) {
+            // Fallback to single connection using registryUrl
+            console.log(`[${this.nodeId}] No servers discovered, using single connection to ${this.registryUrl}`);
+            await this.connectToRegistry();
+            return;
+        }
+        // Connect to ALL servers in parallel
+        console.log(`[${this.nodeId}] Connecting to ${servers.length} inference servers...`);
+        const connectionPromises = servers.map(async (server) => {
+            try {
+                await this.connectToServer(server);
+            }
+            catch (error) {
+                console.error(`[${this.nodeId}] Failed to connect to ${server.name}: ${error.message}`);
+            }
+        });
+        await Promise.allSettled(connectionPromises);
+        // Check how many connections succeeded
+        const connectedCount = Array.from(this.serverConnections.values())
+            .filter(c => c.ws?.readyState === ws_1.default.OPEN).length;
+        console.log(`[${this.nodeId}] Connected to ${connectedCount}/${servers.length} inference servers`);
+        // If no connections succeeded, try the primary registryUrl
+        if (connectedCount === 0) {
+            console.log(`[${this.nodeId}] No multi-connect succeeded, falling back to ${this.registryUrl}`);
+            await this.connectToRegistry();
+        }
+    }
+    /**
+     * Connect to a specific inference server
+     */
+    async connectToServer(server) {
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            console.log(`[${this.nodeId}] Connecting to ${server.name} at ${server.websocketUrl}...`);
+            const ws = new ws_1.default(server.websocketUrl, {
+                headers: {
+                    'X-Gateway-Type': '3',
+                    'X-Instance-ID': this.instanceId,
+                    'X-Node-ID': this.nodeId,
+                    'X-Version': this.currentVersion
+                }
+            });
+            // Preserve reconnect attempts from existing connection (for proper backoff)
+            const existingConnection = this.serverConnections.get(server.id);
+            const reconnectAttempts = existingConnection?.reconnectAttempts || 0;
+            const reconnectInterval = existingConnection?.reconnectInterval || null;
+            // Track this connection (preserving reconnect state)
+            const connection = {
+                serverId: server.id,
+                serverType: server.serverType,
+                port: server.port,
+                ws: ws,
+                isAuthenticated: false,
+                reconnectAttempts: reconnectAttempts,
+                reconnectInterval: reconnectInterval
+            };
+            this.serverConnections.set(server.id, connection);
+            ws.on('open', () => {
+                console.log(`[${this.nodeId}] ✅ Connected to ${server.name} (${server.serverType}:${server.port})`);
+                // Reset reconnect state on successful connection
+                connection.reconnectAttempts = 0;
+                if (connection.reconnectInterval) {
+                    clearTimeout(connection.reconnectInterval);
+                    connection.reconnectInterval = null;
+                }
+                // Set as primary if this is the active server or first connection
+                if (server.isActive || !this.registryWs) {
+                    this.registryWs = ws;
+                }
+                if (!settled) {
+                    settled = true;
+                    resolve();
+                }
+            });
+            ws.on('message', (data) => {
+                this.handleRegistryMessage(data.toString(), server.id);
+            });
+            ws.on('error', (error) => {
+                console.error(`[${this.nodeId}] ❌ Connection error to ${server.name}:`, error.message);
+                if (!settled) {
+                    settled = true;
+                    reject(error);
+                }
+            });
+            ws.on('close', (code, reason) => {
+                const reasonStr = reason ? (Buffer.isBuffer(reason) ? reason.toString() : String(reason)) : 'unknown';
+                console.log(`[${this.nodeId}] 🔌 Disconnected from ${server.name} (code: ${code}, reason: ${reasonStr})`);
+                connection.isAuthenticated = false;
+                // Handle reconnection for this specific server
+                this.handleServerDisconnection(server);
+            });
+        });
+    }
+    /**
+     * Handle disconnection from a specific server and schedule reconnection
+     */
+    handleServerDisconnection(server) {
+        const connection = this.serverConnections.get(server.id);
+        if (!connection || this.isShuttingDown)
+            return;
+        // Clear existing reconnect interval
+        if (connection.reconnectInterval) {
+            clearTimeout(connection.reconnectInterval);
+        }
+        connection.reconnectAttempts++;
+        const delay = Math.min(this.reconnectDelay * connection.reconnectAttempts, 60000);
+        console.log(`[${this.nodeId}] Scheduling reconnection to ${server.name} in ${delay / 1000}s (attempt ${connection.reconnectAttempts})`);
+        connection.reconnectInterval = setTimeout(async () => {
+            try {
+                await this.connectToServer(server);
+                await this.registerWithServer(server.id);
+                // Note: reconnectAttempts is reset in the 'open' handler of connectToServer
+            }
+            catch (error) {
+                console.error(`[${this.nodeId}] Reconnection to ${server.name} failed:`, error.message);
+                this.handleServerDisconnection(server);
+            }
+        }, delay);
+    }
+    /**
+     * Register gateway with a specific server
+     */
+    async registerWithServer(serverId) {
+        const connection = this.serverConnections.get(serverId);
+        if (!connection?.ws || connection.ws.readyState !== ws_1.default.OPEN) {
+            return;
+        }
+        // Use same registration message format
+        const registrationMessage = await this.buildRegistrationMessage();
+        connection.ws.send(JSON.stringify(registrationMessage));
+    }
+    /**
+     * Register gateway with all connected servers
+     */
+    async registerWithAllServers() {
+        const registrationMessage = await this.buildRegistrationMessage();
+        for (const [serverId, connection] of this.serverConnections) {
+            if (connection.ws?.readyState === ws_1.default.OPEN) {
+                console.log(`[${this.nodeId}] Registering with server ${serverId}...`);
+                connection.ws.send(JSON.stringify(registrationMessage));
+            }
+        }
+    }
+    /**
+     * Build registration message (extracted for reuse)
+     */
+    async buildRegistrationMessage() {
+        const os = require('os');
+        // Detect run mode and container environment
+        const isContainer = this.detectContainerEnvironment();
+        const runMode = this.detectRunMode();
+        const dockerImage = process.env.DOCKER_IMAGE_NAME || null;
+        // Discover available MCP tools
+        let availableTools = [];
+        if (this.enableRemoteLLMSession && this.headlessSessionManager) {
+            availableTools = this.headlessSessionManager.discoverAvailableTools?.() || [];
+        }
+        return {
+            type: 'gateway_register',
+            gateway_type: 3,
+            gateway_id: this.gatewayId,
+            instance_id: this.instanceId,
+            node_id: this.nodeId,
+            version: this.currentVersion,
+            api_key: this.apiKey,
+            capabilities: {
+                maxConcurrent: 10,
+                supportsStreaming: true,
+                supportsFunctions: true,
+                supportedModels: this.vault.listAccessPoints().map((ap) => ap.model_id),
+                availableTools: availableTools
+            },
+            system_info: {
+                osPlatform: os.platform(),
+                osRelease: os.release(),
+                nodeVersion: process.version,
+                arch: os.arch(),
+                hostname: os.hostname(),
+                isContainer: isContainer,
+                runMode: runMode,
+                dockerImage: dockerImage
+            }
+        };
+    }
     /**
      * Initialize the headless session manager for remote automation
      */
@@ -167,7 +379,7 @@ class Type3GatewayServer extends events_1.EventEmitter {
         this.headlessSessionManager = new headless_session_1.HeadlessSessionManager({
             gatewayId: this.instanceId,
             vault: this.vault,
-            marketplaceUrl: this.marketplaceUrl,
+            registryUrl: this.registryUrl,
             apiKey: this.apiKey
         });
         // Listen for session events
@@ -201,8 +413,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
                 node_id: this.nodeId,
                 uptime_ms: uptime,
                 uptime_human: this.formatUptime(uptime),
-                marketplace_connected: this.marketplaceWs?.readyState === ws_1.default.OPEN,
-                marketplace_authenticated: this.isAuthenticated,
+                registry_connected: this.registryWs?.readyState === ws_1.default.OPEN,
+                registry_authenticated: this.isAuthenticated,
                 mode: {
                     value: this.gatewayMode,
                     name: modeNames[this.gatewayMode],
@@ -336,16 +548,16 @@ class Type3GatewayServer extends events_1.EventEmitter {
                         code: 'vault_error'
                     });
                 }
-                // Query marketplace for connection details
-                const marketplaceUrl = this.marketplaceUrl.replace('ws://', 'http://').replace('wss://', 'https://');
-                const connectionResponse = await axios_1.default.get(`${marketplaceUrl}/api/connections`, {
+                // Query registry for connection details
+                const registryUrl = this.registryUrl.replace('ws://', 'http://').replace('wss://', 'https://');
+                const connectionResponse = await axios_1.default.get(`${registryUrl}/api/connections`, {
                     headers: { 'Authorization': `Bearer ${this.apiKey}` },
                     timeout: 5000
                 });
                 const connection = connectionResponse.data.connections?.find((c) => c.id === connectionId);
                 if (!connection) {
                     return res.status(404).json({
-                        error: 'Connection not found in marketplace',
+                        error: 'Connection not found in registry',
                         code: 'connection_not_found'
                     });
                 }
@@ -470,7 +682,7 @@ class Type3GatewayServer extends events_1.EventEmitter {
                 // Automatically trigger reconnection after response is sent
                 setTimeout(async () => {
                     console.log(`[${this.nodeId}] Auto-reconnecting with new API key...`);
-                    await this.connectToMarketplace();
+                    await this.connectToRegistry();
                     await this.registerGateway();
                 }, 500);
             }
@@ -479,17 +691,17 @@ class Type3GatewayServer extends events_1.EventEmitter {
                 res.status(500).json({ error: error.message });
             }
         });
-        // POST /reconnect - Reconnect to marketplace
+        // POST /reconnect - Reconnect to registry
         this.managementApp.post('/reconnect', async (req, res) => {
             try {
                 console.log(`[${this.nodeId}] Reconnect requested via management API`);
                 res.json({
                     status: 'reconnecting',
-                    message: 'Disconnecting and reconnecting to marketplace'
+                    message: 'Disconnecting and reconnecting to registry'
                 });
                 // Reconnect after sending response
                 setTimeout(async () => {
-                    await this.connectToMarketplace();
+                    await this.connectToRegistry();
                     await this.registerGateway();
                 }, 500);
             }
@@ -503,7 +715,7 @@ class Type3GatewayServer extends events_1.EventEmitter {
             res.json({
                 status: 'healthy',
                 timestamp: new Date().toISOString(),
-                connected: this.marketplaceWs?.readyState === ws_1.default.OPEN,
+                connected: this.registryWs?.readyState === ws_1.default.OPEN,
                 authenticated: this.isAuthenticated,
                 current_user: this.currentUser ? {
                     user_id: this.currentUser.id,
@@ -546,9 +758,9 @@ class Type3GatewayServer extends events_1.EventEmitter {
         return `${seconds}s`;
     }
     /**
-     * Connect to marketplace control plane
+     * Connect to registry control plane
      */
-    async connectToMarketplace() {
+    async connectToRegistry() {
         return new Promise((resolve, reject) => {
             // Track if this promise has been settled to prevent double resolve/reject
             let settled = false;
@@ -556,15 +768,15 @@ class Type3GatewayServer extends events_1.EventEmitter {
                 clearTimeout(this.reconnectInterval);
                 this.reconnectInterval = null;
             }
-            if (this.marketplaceWs) {
-                this.marketplaceWs.removeAllListeners();
-                if (this.marketplaceWs.readyState === ws_1.default.OPEN) {
-                    this.marketplaceWs.close();
+            if (this.registryWs) {
+                this.registryWs.removeAllListeners();
+                if (this.registryWs.readyState === ws_1.default.OPEN) {
+                    this.registryWs.close();
                 }
-                this.marketplaceWs = null;
+                this.registryWs = null;
             }
-            console.log(`[${this.nodeId}] Connecting to marketplace at ${this.marketplaceUrl}...`);
-            this.marketplaceWs = new ws_1.default(this.marketplaceUrl, {
+            console.log(`[${this.nodeId}] Connecting to registry at ${this.registryUrl}...`);
+            this.registryWs = new ws_1.default(this.registryUrl, {
                 headers: {
                     'X-Gateway-Type': '3',
                     'X-Instance-ID': this.instanceId,
@@ -572,31 +784,35 @@ class Type3GatewayServer extends events_1.EventEmitter {
                     'X-Version': this.currentVersion
                 }
             });
-            this.marketplaceWs.on('open', () => {
-                console.log(`[${this.nodeId}] ✅ Connected to marketplace control plane`);
+            this.registryWs.on('open', () => {
+                console.log(`[${this.nodeId}] ✅ Connected to registry control plane`);
                 this.isAuthenticated = false;
                 if (!settled) {
                     settled = true;
                     resolve();
                 }
             });
-            this.marketplaceWs.on('message', (data) => {
-                this.handleMarketplaceMessage(data.toString());
+            this.registryWs.on('message', (data) => {
+                this.handleRegistryMessage(data.toString());
             });
-            this.marketplaceWs.on('error', (error) => {
-                console.error(`[${this.nodeId}] ❌ Marketplace connection error:`, error.message);
+            this.registryWs.on('error', (error) => {
+                console.error(`[${this.nodeId}] ❌ Registry connection error:`, error.message);
                 this.emit('error', error);
                 // Only reject on initial connection attempt (before promise is settled)
                 if (!settled) {
                     settled = true;
                     reject(error);
                 }
+                // For errors after connection, trigger reconnection
+                // (close event should also fire, but just in case)
             });
-            this.marketplaceWs.on('close', (code, reason) => {
-                console.log(`[${this.nodeId}] 🔌 Disconnected from marketplace (code: ${code}, reason: ${reason})`);
+            this.registryWs.on('close', (code, reason) => {
+                // reason can be Buffer or string depending on ws version - handle both
+                const reasonStr = reason ? (Buffer.isBuffer(reason) ? reason.toString() : String(reason)) : 'unknown';
+                console.log(`[${this.nodeId}] 🔌 Disconnected from registry (code: ${code}, reason: ${reasonStr})`);
                 this.isAuthenticated = false;
                 this.currentUser = null; // Clear user info on disconnect
-                this.handleMarketplaceDisconnection();
+                this.handleRegistryDisconnection();
             });
         });
     }
@@ -627,7 +843,7 @@ class Type3GatewayServer extends events_1.EventEmitter {
         }
     }
     /**
-     * Register gateway with marketplace
+     * Register gateway with registry
      * Includes tool discovery for remote automation sessions (if enabled)
      */
     async registerGateway() {
@@ -692,14 +908,29 @@ class Type3GatewayServer extends events_1.EventEmitter {
         if (this.enableLLMRouting) {
             console.log(`[${this.nodeId}] Registering with ${connections.length} connections for LLM routing`);
         }
-        if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-            this.marketplaceWs.send(JSON.stringify(registration));
+        // Multi-connect: Register with ALL connected servers
+        if (this.serverConnections.size > 0) {
+            let registeredCount = 0;
+            for (const [serverId, connection] of this.serverConnections) {
+                if (connection.ws?.readyState === ws_1.default.OPEN) {
+                    console.log(`[${this.nodeId}] Registering with server ${connection.serverType}:${connection.port}...`);
+                    connection.ws.send(JSON.stringify(registration));
+                    registeredCount++;
+                }
+            }
+            console.log(`[${this.nodeId}] Registered with ${registeredCount}/${this.serverConnections.size} inference servers`);
+        }
+        else if (this.registryWs?.readyState === ws_1.default.OPEN) {
+            // Fallback: Single connection mode
+            this.registryWs.send(JSON.stringify(registration));
         }
     }
     /**
-     * Handle messages from marketplace control plane
+     * Handle messages from registry control plane
+     * @param data - Message data as string
+     * @param serverId - Optional server ID for multi-connect tracking
      */
-    async handleMarketplaceMessage(data) {
+    async handleRegistryMessage(data, serverId) {
         try {
             const message = JSON.parse(data);
             // Gateway Type 1 sends both 'event' and 'type' properties for compatibility
@@ -743,8 +974,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
                     console.log(`[${this.nodeId}] Scheduling reconnection with new gateway ID in 2 seconds...`);
                     setTimeout(async () => {
                         try {
-                            console.log(`[${this.nodeId}] Reconnecting to marketplace with fresh identity...`);
-                            await this.connectToMarketplace();
+                            console.log(`[${this.nodeId}] Reconnecting to registry with fresh identity...`);
+                            await this.connectToRegistry();
                             await this.registerGateway();
                             console.log(`[${this.nodeId}] ✅ Successfully reconnected with new gateway ID`);
                         }
@@ -757,8 +988,15 @@ class Type3GatewayServer extends events_1.EventEmitter {
                 case 'auth_confirmed':
                     // Gateway Type 1 sends auth_confirmed after successful authentication
                     // It also includes the server-assigned gateway_id and gateway_name
-                    console.log(`[${this.nodeId}] Authentication confirmed by Gateway Type 1`);
+                    console.log(`[${this.nodeId}] Authentication confirmed by Gateway Type 1${serverId ? ` (server: ${serverId})` : ''}`);
                     this.isAuthenticated = true;
+                    // Update connection-specific auth status for multi-connect
+                    if (serverId) {
+                        const connection = this.serverConnections.get(serverId);
+                        if (connection) {
+                            connection.isAuthenticated = true;
+                        }
+                    }
                     // IMPORTANT: Store server-assigned gateway_id for future reconnections
                     // NOTE: gateway_name is NOT stored locally - it's managed server-side only
                     const serverGatewayId = message.gatewayId || message.gateway_id;
@@ -802,7 +1040,7 @@ class Type3GatewayServer extends events_1.EventEmitter {
                         this.sendErrorResponse(message.request_id, 'llm_routing_disabled', 'This gateway is not configured for LLM routing');
                         break;
                     }
-                    await this.handleHttpRequest(message);
+                    await this.handleHttpRequest(message, serverId);
                     break;
                 // ============= REMOTE SESSION EVENTS =============
                 case 'session_start':
@@ -848,15 +1086,15 @@ class Type3GatewayServer extends events_1.EventEmitter {
                     await this.handleUpdateAvailable(message);
                     break;
                 case 'update_now':
-                    // Mandatory update command from marketplace
+                    // Mandatory update command from registry
                     await this.handleUpdateNow(message);
                     break;
                 default:
-                    console.log(`[${this.nodeId}] Unknown marketplace event: ${eventType}`);
+                    console.log(`[${this.nodeId}] Unknown registry event: ${eventType}`);
             }
         }
         catch (error) {
-            console.error(`[${this.nodeId}] Marketplace message error:`, error);
+            console.error(`[${this.nodeId}] Registry message error:`, error);
         }
     }
     /**
@@ -883,6 +1121,7 @@ class Type3GatewayServer extends events_1.EventEmitter {
             console.log(`[Type3-${this.nodeId}] Step 2: Extracted parameters:`, {
                 provider,
                 endpoint,
+                endpointUrl: endpointUrl || 'NOT PROVIDED',
                 model,
                 hasMessages: !!messages,
                 messageCount: messages?.length || 0,
@@ -950,7 +1189,7 @@ class Type3GatewayServer extends events_1.EventEmitter {
             }
             if (!stream) {
                 console.log(`[Type3-${this.nodeId}] Step 7: Received response from provider`);
-                if (this.marketplaceWs && this.marketplaceWs.readyState === ws_1.default.OPEN) {
+                if (this.registryWs && this.registryWs.readyState === ws_1.default.OPEN) {
                     const responseMessage = {
                         event: 'inference_response',
                         request_id: requestId,
@@ -961,7 +1200,7 @@ class Type3GatewayServer extends events_1.EventEmitter {
                             node_id: this.nodeId
                         }
                     };
-                    this.marketplaceWs.send(JSON.stringify(responseMessage));
+                    this.registryWs.send(JSON.stringify(responseMessage));
                     console.log(`[Type3-${this.nodeId}] Step 8: Response sent successfully`);
                 }
             }
@@ -974,8 +1213,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
         }
         catch (error) {
             console.error(`[Type3-${this.nodeId}] ERROR in request ${requestId}:`, error.message);
-            if (this.marketplaceWs && this.marketplaceWs.readyState === ws_1.default.OPEN) {
-                this.marketplaceWs.send(JSON.stringify({
+            if (this.registryWs && this.registryWs.readyState === ws_1.default.OPEN) {
+                this.registryWs.send(JSON.stringify({
                     event: 'inference_error',
                     request_id: requestId,
                     error: {
@@ -1077,8 +1316,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
                     if (line.startsWith('data: ')) {
                         const data = line.substring(6);
                         if (data === '[DONE]') {
-                            if (this.marketplaceWs && this.marketplaceWs.readyState === ws_1.default.OPEN) {
-                                this.marketplaceWs.send(JSON.stringify({
+                            if (this.registryWs && this.registryWs.readyState === ws_1.default.OPEN) {
+                                this.registryWs.send(JSON.stringify({
                                     event: 'stream_end',
                                     request_id: requestId,
                                     timestamp: new Date().toISOString()
@@ -1088,8 +1327,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
                         else {
                             try {
                                 const parsed = JSON.parse(data);
-                                if (this.marketplaceWs && this.marketplaceWs.readyState === ws_1.default.OPEN) {
-                                    this.marketplaceWs.send(JSON.stringify({
+                                if (this.registryWs && this.registryWs.readyState === ws_1.default.OPEN) {
+                                    this.registryWs.send(JSON.stringify({
                                         event: 'stream_chunk',
                                         request_id: requestId,
                                         data: parsed,
@@ -1107,8 +1346,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
             return new Promise((resolve, reject) => {
                 response.data.on('end', () => {
                     console.log(`[${this.nodeId}] Streaming completed for request ${requestId}`);
-                    if (this.marketplaceWs && this.marketplaceWs.readyState === ws_1.default.OPEN) {
-                        this.marketplaceWs.send(JSON.stringify({
+                    if (this.registryWs && this.registryWs.readyState === ws_1.default.OPEN) {
+                        this.registryWs.send(JSON.stringify({
                             event: 'stream_complete',
                             request_id: requestId,
                             stream_completed: true,
@@ -1119,8 +1358,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
                 });
                 response.data.on('error', (error) => {
                     console.error(`[${this.nodeId}] Stream error for request ${requestId}:`, error);
-                    if (this.marketplaceWs && this.marketplaceWs.readyState === ws_1.default.OPEN) {
-                        this.marketplaceWs.send(JSON.stringify({
+                    if (this.registryWs && this.registryWs.readyState === ws_1.default.OPEN) {
+                        this.registryWs.send(JSON.stringify({
                             event: 'stream_error',
                             request_id: requestId,
                             error: {
@@ -1190,10 +1429,10 @@ class Type3GatewayServer extends events_1.EventEmitter {
      *   body: { ... } (optional)
      * }
      */
-    async handleHttpRequest(message) {
+    async handleHttpRequest(message, sourceServerId) {
         const requestId = message.requestId || (0, uuid_1.v4)();
         const { connection_id, method, url, headers = {}, body } = message;
-        console.log(`[${this.nodeId}] Forwarding HTTP ${method} request to: ${url}`);
+        console.log(`[${this.nodeId}] Forwarding HTTP ${method} request to: ${url}${sourceServerId ? ` (from server: ${sourceServerId})` : ''}`);
         try {
             // Get API key from local vault if connection_id provided
             let requestHeaders = { ...headers };
@@ -1228,7 +1467,7 @@ class Type3GatewayServer extends events_1.EventEmitter {
             catch {
                 responseData = responseText;
             }
-            // Send RAW HTTP response back to Type 1
+            // Send RAW HTTP response back to the server that sent the request
             const wsResponse = {
                 event: 'http_response',
                 requestId: requestId,
@@ -1238,34 +1477,67 @@ class Type3GatewayServer extends events_1.EventEmitter {
                 body: responseData, // RAW response body
                 timestamp: new Date().toISOString()
             };
-            if (this.marketplaceWs && this.marketplaceWs.readyState === ws_1.default.OPEN) {
-                this.marketplaceWs.send(JSON.stringify(wsResponse));
-                console.log(`[${this.nodeId}] Sent HTTP response (${response.status}) to Type 1`);
+            if (this.sendToServer(sourceServerId, wsResponse)) {
+                console.log(`[${this.nodeId}] Sent HTTP response (${response.status}) to server${sourceServerId ? ` ${sourceServerId}` : ''}`);
+            }
+            else {
+                console.error(`[${this.nodeId}] Failed to send HTTP response - no connection available`);
             }
         }
         catch (error) {
             console.error(`[${this.nodeId}] HTTP forwarding error:`, error.message);
-            if (this.marketplaceWs && this.marketplaceWs.readyState === ws_1.default.OPEN) {
-                this.marketplaceWs.send(JSON.stringify({
-                    event: 'http_response',
-                    requestId: requestId,
-                    success: false,
-                    error: error.message,
-                    timestamp: new Date().toISOString()
-                }));
-            }
+            this.sendToServer(sourceServerId, {
+                event: 'http_response',
+                requestId: requestId,
+                success: false,
+                error: error.message,
+                timestamp: new Date().toISOString()
+            });
+        }
+    }
+    /**
+     * Send message to a specific server connection
+     * Falls back to registryWs if serverId not found or not connected
+     * @param serverId - The server ID to send to
+     * @param message - The message object to send
+     * @returns true if message was sent, false otherwise
+     */
+    sendToServer(serverId, message) {
+        // Try to find the specific server connection
+        if (serverId) {
+            const connection = this.serverConnections.get(serverId);
+            if (connection?.ws?.readyState === ws_1.default.OPEN) {
+                connection.ws.send(JSON.stringify(message));
+                return true;
+            }
+        }
+        // Fallback to registryWs (backward compatibility)
+        if (this.registryWs && this.registryWs.readyState === ws_1.default.OPEN) {
+            this.registryWs.send(JSON.stringify(message));
+            return true;
         }
+        return false;
     }
     /**
-     * Send health status to marketplace
+     * Send health status to all connected servers (multi-connect)
      */
     sendHealthStatus() {
-        if (this.marketplaceWs && this.marketplaceWs.readyState === ws_1.default.OPEN) {
-            const heartbeat = {
-                type: 'heartbeat',
-                timestamp: new Date().toISOString()
-            };
-            this.marketplaceWs.send(JSON.stringify(heartbeat));
+        const heartbeat = {
+            type: 'heartbeat',
+            timestamp: new Date().toISOString()
+        };
+        const heartbeatStr = JSON.stringify(heartbeat);
+        // Send to all connected servers (multi-connect)
+        let sentCount = 0;
+        for (const [serverId, connection] of this.serverConnections) {
+            if (connection.ws?.readyState === ws_1.default.OPEN) {
+                connection.ws.send(heartbeatStr);
+                sentCount++;
+            }
+        }
+        // Fallback to registryWs if no server connections (legacy mode)
+        if (sentCount === 0 && this.registryWs && this.registryWs.readyState === ws_1.default.OPEN) {
+            this.registryWs.send(heartbeatStr);
         }
         const status = {
             event: 'health_status',
@@ -1284,8 +1556,18 @@ class Type3GatewayServer extends events_1.EventEmitter {
             },
             timestamp: new Date().toISOString()
         };
-        if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-            this.marketplaceWs.send(JSON.stringify(status));
+        const statusStr = JSON.stringify(status);
+        // Send health status to all connected servers (multi-connect)
+        let statusSentCount = 0;
+        for (const [, connection] of this.serverConnections) {
+            if (connection.ws?.readyState === ws_1.default.OPEN) {
+                connection.ws.send(statusStr);
+                statusSentCount++;
+            }
+        }
+        // Fallback to registryWs if no server connections (legacy mode)
+        if (statusSentCount === 0 && this.registryWs?.readyState === ws_1.default.OPEN) {
+            this.registryWs.send(statusStr);
         }
         this.metrics.lastHealthCheck = new Date();
     }
@@ -1318,8 +1600,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
             },
             timestamp: new Date().toISOString()
         };
-        if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-            this.marketplaceWs.send(JSON.stringify(rateLimits));
+        if (this.registryWs?.readyState === ws_1.default.OPEN) {
+            this.registryWs.send(JSON.stringify(rateLimits));
         }
     }
     /**
@@ -1329,25 +1611,25 @@ class Type3GatewayServer extends events_1.EventEmitter {
     startHealthMonitoring() {
         this.healthCheckInterval = setInterval(() => {
             // Only send health status if connected
-            if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
+            if (this.registryWs?.readyState === ws_1.default.OPEN) {
                 this.sendHealthStatus();
             }
             else if (!this.reconnectInterval && !this.isShuttingDown) {
                 // Connection lost and no reconnection scheduled - trigger reconnection
-                console.warn(`[${this.nodeId}] Health check: Lost connection to marketplace, triggering reconnection...`);
+                console.warn(`[${this.nodeId}] Health check: Lost connection to registry, triggering reconnection...`);
                 // Reset reconnect attempts for health-check triggered reconnection
                 // This ensures we start fresh when health check detects a problem
                 this.reconnectAttempts = 0;
-                this.handleMarketplaceDisconnection();
+                this.handleRegistryDisconnection();
             }
         }, 30000);
     }
     /**
-     * Handle marketplace disconnection with robust retry logic
+     * Handle registry disconnection with robust retry logic
      * This method schedules reconnection attempts with exponential backoff
      * and ensures registerGateway() is always called after successful reconnection
      */
-    handleMarketplaceDisconnection() {
+    handleRegistryDisconnection() {
         if (this.isShuttingDown) {
             console.log(`[${this.nodeId}] Shutdown in progress, skipping reconnection`);
             return;
@@ -1372,9 +1654,9 @@ class Type3GatewayServer extends events_1.EventEmitter {
             this.reconnectInterval = null; // Clear so we can schedule next attempt if needed
             console.log(`[${this.nodeId}] 🔄 Attempting to reconnect (attempt ${this.reconnectAttempts})...`);
             try {
-                await this.connectToMarketplace();
+                await this.connectToRegistry();
                 // Check if connection was successful
-                if (this.marketplaceWs && this.marketplaceWs.readyState === ws_1.default.OPEN) {
+                if (this.registryWs && this.registryWs.readyState === ws_1.default.OPEN) {
                     console.log(`[${this.nodeId}] ✅ Reconnected successfully!`);
                     console.log(`[${this.nodeId}] 📝 Re-registering after reconnection...`);
                     try {
@@ -1386,18 +1668,18 @@ class Type3GatewayServer extends events_1.EventEmitter {
                     catch (regError) {
                         console.error(`[${this.nodeId}] ❌ Registration failed after reconnect:`, regError.message);
                         // Schedule another attempt since registration failed
-                        this.handleMarketplaceDisconnection();
+                        this.handleRegistryDisconnection();
                     }
                 }
                 else {
-                    console.warn(`[${this.nodeId}] ⚠️ WebSocket not open after connectToMarketplace, scheduling retry...`);
-                    this.handleMarketplaceDisconnection();
+                    console.warn(`[${this.nodeId}] ⚠️ WebSocket not open after connectToRegistry, scheduling retry...`);
+                    this.handleRegistryDisconnection();
                 }
             }
             catch (error) {
                 console.error(`[${this.nodeId}] ❌ Reconnection attempt failed:`, error.message);
                 // Schedule another reconnection attempt
-                this.handleMarketplaceDisconnection();
+                this.handleRegistryDisconnection();
             }
         }, delay);
     }
@@ -1636,6 +1918,7 @@ class Type3GatewayServer extends events_1.EventEmitter {
     async handleSessionStart(message) {
         const requestId = message.requestId || message.request_id;
         console.log(`[${this.nodeId}] Received session_start request: ${requestId}`);
+        console.log(`[${this.nodeId}] session_start received includeEnvironmentInfo: ${message.includeEnvironmentInfo}, systemPrompt defined: ${message.systemPrompt !== undefined}, systemPrompt length: ${message.systemPrompt?.length || 0}`);
         if (!this.headlessSessionManager) {
             this.sendSessionError(requestId, 'Headless session manager not initialized');
             return;
@@ -1647,6 +1930,7 @@ class Type3GatewayServer extends events_1.EventEmitter {
                 organizationId: message.organizationId,
                 templateId: message.templateId,
                 systemPrompt: message.systemPrompt,
+                includeEnvironmentInfo: message.includeEnvironmentInfo !== false, // Default to true
                 initialMessage: message.initialMessage,
                 modelId: message.modelId,
                 connectionId: message.connectionId,
@@ -1659,8 +1943,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
             // Send acknowledgment to Type 1
             // NOTE: The initialMessage is the assistant's greeting, already added to session history
             // We do NOT call processSessionMessageInternal because the greeting doesn't need an LLM response
-            if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-                this.marketplaceWs.send(JSON.stringify({
+            if (this.registryWs?.readyState === ws_1.default.OPEN) {
+                this.registryWs.send(JSON.stringify({
                     event: 'session_started',
                     requestId,
                     sessionId: session.sessionId,
@@ -1699,13 +1983,17 @@ class Type3GatewayServer extends events_1.EventEmitter {
         if (needsRestore && sessionRestore) {
             const reason = !existingSession ? 'not found in memory' : `in ${existingSession.status} state`;
             console.log(`[${this.nodeId}] Session ${sessionId} ${reason}, auto-restoring from Type 1 data`);
+            console.log(`[${this.nodeId}] Session restore data - systemPrompt: ${sessionRestore.systemPrompt ? 'provided' : 'not provided'}, includeEnvironmentInfo: ${sessionRestore.includeEnvironmentInfo}`);
             try {
                 await this.headlessSessionManager.restoreSession(sessionId, {
                     userId: sessionRestore.userId,
                     organizationId: sessionRestore.organizationId,
                     sessionType: sessionRestore.sessionType,
                     modelId: modelId,
-                    messages: sessionRestore.messages || []
+                    messages: sessionRestore.messages || [],
+                    // Pass system prompt configuration from session metadata for proper restore
+                    systemPrompt: sessionRestore.systemPrompt,
+                    includeEnvironmentInfo: sessionRestore.includeEnvironmentInfo
                 });
                 console.log(`[${this.nodeId}] Session ${sessionId} restored/reactivated successfully`);
             }
@@ -1725,8 +2013,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
         try {
             // Stream handler to send chunks to Type 1
             const onChunk = (chunk) => {
-                if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-                    this.marketplaceWs.send(JSON.stringify({
+                if (this.registryWs?.readyState === ws_1.default.OPEN) {
+                    this.registryWs.send(JSON.stringify({
                         event: 'session_chunk',
                         requestId,
                         sessionId,
@@ -1738,18 +2026,26 @@ class Type3GatewayServer extends events_1.EventEmitter {
             const response = await this.headlessSessionManager.processMessage(sessionId, userMessage, onChunk, modelId // Pass per-message model ID
             );
             // Send final response to Type 1
-            if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-                this.marketplaceWs.send(JSON.stringify({
+            if (this.registryWs?.readyState === ws_1.default.OPEN) {
+                this.registryWs.send(JSON.stringify({
                     event: 'session_response',
                     requestId,
                     sessionId,
                     status: response.status,
-                    message: response.message,
-                    toolResults: response.toolResults,
                     isComplete: response.isComplete,
                     error: response.error,
-                    requestIds: response.requestIds, // LLM request IDs for request log linking
-                    usage: response.usage, // Token usage for display
+                    // New structured fields for Type 1
+                    assistant_message: response.assistant_message,
+                    tool_calls: response.tool_calls,
+                    tools_available: response.tools_available,
+                    tools_enabled: response.tools_enabled,
+                    llm_iterations: response.llm_iterations,
+                    request_log_ids: response.request_log_ids,
+                    usage: response.usage,
+                    // Legacy fields for backward compatibility
+                    message: response.message,
+                    toolResults: response.toolResults,
+                    requestIds: response.requestIds || response.request_log_ids,
                     timestamp: new Date().toISOString()
                 }));
             }
@@ -1771,8 +2067,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
             return;
         }
         const success = await this.headlessSessionManager.cancelSession(sessionId);
-        if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-            this.marketplaceWs.send(JSON.stringify({
+        if (this.registryWs?.readyState === ws_1.default.OPEN) {
+            this.registryWs.send(JSON.stringify({
                 event: 'session_cancelled',
                 requestId,
                 sessionId,
@@ -1788,8 +2084,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
         const requestId = message.requestId || message.request_id;
         console.log(`[${this.nodeId}] Received get_tools request`);
         const tools = this.headlessSessionManager?.getAvailableTools() || [];
-        if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-            this.marketplaceWs.send(JSON.stringify({
+        if (this.registryWs?.readyState === ws_1.default.OPEN) {
+            this.registryWs.send(JSON.stringify({
                 event: 'tools_response',
                 requestId,
                 gatewayId: this.instanceId,
@@ -1802,8 +2098,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
      * Send session error to Type 1
      */
     sendSessionError(requestId, error, sessionId) {
-        if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-            this.marketplaceWs.send(JSON.stringify({
+        if (this.registryWs?.readyState === ws_1.default.OPEN) {
+            this.registryWs.send(JSON.stringify({
                 event: 'session_error',
                 requestId,
                 sessionId,
@@ -1816,8 +2112,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
      * Send inference error response to Type 1
      */
     sendErrorResponse(requestId, code, message) {
-        if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-            this.marketplaceWs.send(JSON.stringify({
+        if (this.registryWs?.readyState === ws_1.default.OPEN) {
+            this.registryWs.send(JSON.stringify({
                 event: 'inference_error',
                 request_id: requestId,
                 error: {
@@ -2021,8 +2317,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
             });
             console.log(`[${this.nodeId}] Script execution completed: ${result.success ? 'success' : 'failed'} (exit code: ${result.exit_code})`);
             // Send result back to Type 1
-            if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-                this.marketplaceWs.send(JSON.stringify({
+            if (this.registryWs?.readyState === ws_1.default.OPEN) {
+                this.registryWs.send(JSON.stringify({
                     event: 'script_result',
                     requestId,
                     success: true,
@@ -2046,8 +2342,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
      * Send script execution error to Type 1
      */
     sendScriptError(requestId, code, message) {
-        if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-            this.marketplaceWs.send(JSON.stringify({
+        if (this.registryWs?.readyState === ws_1.default.OPEN) {
+            this.registryWs.send(JSON.stringify({
                 event: 'script_result',
                 requestId,
                 success: false,
@@ -2079,8 +2375,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
             // autoUpdate defaults to true if not explicitly set to false
             const shouldAutoUpdate = mandatory || (autoUpdate !== false);
             // Send acknowledgment to Type 1
-            if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-                this.marketplaceWs.send(JSON.stringify({
+            if (this.registryWs?.readyState === ws_1.default.OPEN) {
+                this.registryWs.send(JSON.stringify({
                     event: 'update_acknowledged',
                     gatewayId: this.instanceId,
                     currentVersion: this.currentVersion,
@@ -2115,8 +2411,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
         console.log(`[${this.nodeId}] 🚨 Immediate update requested: v${version}`);
         console.log(`[${this.nodeId}] Reason: ${reason || 'No reason provided'}`);
         // Acknowledge the update command
-        if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-            this.marketplaceWs.send(JSON.stringify({
+        if (this.registryWs?.readyState === ws_1.default.OPEN) {
+            this.registryWs.send(JSON.stringify({
                 event: 'update_starting',
                 gatewayId: this.instanceId,
                 currentVersion: this.currentVersion,
@@ -2227,8 +2523,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
         if (resolvedTargetVersion && this.currentVersion === resolvedTargetVersion) {
             console.log(`[${this.nodeId}] ✅ Already at version v${this.currentVersion}, skipping update`);
             // Notify Type 1 that no update is needed
-            if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-                this.marketplaceWs.send(JSON.stringify({
+            if (this.registryWs?.readyState === ws_1.default.OPEN) {
+                this.registryWs.send(JSON.stringify({
                     event: 'already_up_to_date',
                     gatewayId: this.instanceId,
                     currentVersion: this.currentVersion,
@@ -2270,8 +2566,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
             }
             console.log(`[${this.nodeId}] ✓ Package installed successfully`);
             // Step 2: Notify Type 1 of successful install
-            if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-                this.marketplaceWs.send(JSON.stringify({
+            if (this.registryWs?.readyState === ws_1.default.OPEN) {
+                this.registryWs.send(JSON.stringify({
                     event: 'update_installed',
                     gatewayId: this.instanceId,
                     previousVersion: this.currentVersion,
@@ -2283,8 +2579,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
             // Step 3: Graceful restart
             console.log(`[${this.nodeId}] Step 2: Initiating graceful restart...`);
             // Close WebSocket cleanly
-            if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-                this.marketplaceWs.send(JSON.stringify({
+            if (this.registryWs?.readyState === ws_1.default.OPEN) {
+                this.registryWs.send(JSON.stringify({
                     event: 'gateway_restarting',
                     gatewayId: this.instanceId,
                     reason: 'update',
@@ -2333,8 +2629,8 @@ class Type3GatewayServer extends events_1.EventEmitter {
             console.error(`[${this.nodeId}] ❌ Update failed:`, error.message);
             this.isUpdating = false;
             // Notify Type 1 of failure
-            if (this.marketplaceWs?.readyState === ws_1.default.OPEN) {
-                this.marketplaceWs.send(JSON.stringify({
+            if (this.registryWs?.readyState === ws_1.default.OPEN) {
+                this.registryWs.send(JSON.stringify({
                     event: 'update_failed',
                     gatewayId: this.instanceId,
                     currentVersion: this.currentVersion,
@@ -2384,9 +2680,9 @@ class Type3GatewayServer extends events_1.EventEmitter {
             console.log(`[${this.nodeId}] Waiting for ${this.activeRequests.size} active requests...`);
             await new Promise(resolve => setTimeout(resolve, 1000));
         }
-        // Close marketplace WebSocket
-        if (this.marketplaceWs) {
-            this.marketplaceWs.close();
+        // Close registry WebSocket
+        if (this.registryWs) {
+            this.registryWs.close();
         }
         // Close management API server
         if (this.managementServer) {
@@ -2407,7 +2703,7 @@ exports.Type3GatewayServer = Type3GatewayServer;
 if (require.main === module) {
     const gateway = new Type3GatewayServer({
         port: parseInt(process.env.GATEWAY_PORT || '8083'),
-        marketplaceUrl: process.env.MARKETPLACE_URL,
+        registryUrl: process.env.REGISTRY_URL,
         instanceId: process.env.INSTANCE_ID,
         apiKey: process.env.GATEWAY_API_KEY,
         vaultPath: process.env.VAULT_PATH,