agentic-qe 3.3.5 → 3.4.1

package/v3/dist/mcp/http-server.js

@@ -0,0 +1,833 @@
+/**
+ * Agentic QE v3 - HTTP Server
+ * Express server for AG-UI SSE/WebSocket, A2A discovery, and A2UI surfaces
+ *
+ * This server runs alongside the stdio MCP server to provide:
+ * - AG-UI Protocol: SSE streaming at /agent/stream (default, unidirectional)
+ * - AG-UI Protocol: WebSocket streaming at /agent/ws (bidirectional, <100ms latency)
+ * - A2A Protocol: Agent discovery at /.well-known/agent.json
+ * - A2A Protocol: Task submission at /a2a/tasks
+ *
+ * @module mcp/http-server
+ */
+import { createServer } from 'http';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+// AG-UI imports
+import { createEventAdapter, } from '../adapters/ag-ui/index.js';
+// A2A imports
+import { createDiscoveryService, getDiscoveryRouteDefinitions, } from '../adapters/a2a/discovery/index.js';
+import { createTaskManager, createTaskStore, } from '../adapters/a2a/tasks/index.js';
+// Push Notifications imports
+import { createWebhookService, createSubscriptionStore, } from '../adapters/a2a/notifications/index.js';
+import { createAgentCardGenerator, } from '../adapters/index.js';
+// SSE Transport
+import { createSSETransport, } from './transport/sse/index.js';
+// WebSocket Transport
+import { createWebSocketTransport, } from './transport/websocket/index.js';
+import { AGUIEventType } from './transport/sse/types.js';
+// Memory for CRDT
+import { getUnifiedMemory } from '../kernel/unified-memory.js';
+class SimpleRouter {
+    routes = [];
+    add(method, path, handler) {
+        // Convert Express-style path params to regex
+        const paramNames = [];
+        const patternStr = path.replace(/:([^/]+)/g, (_, name) => {
+            paramNames.push(name);
+            return '([^/]+)';
+        });
+        const pattern = new RegExp(`^${patternStr}$`);
+        this.routes.push({ method: method.toUpperCase(), pattern, paramNames, handler });
+    }
+    match(method, path) {
+        for (const route of this.routes) {
+            if (route.method !== method.toUpperCase() && route.method !== 'ALL') {
+                continue;
+            }
+            const match = path.match(route.pattern);
+            if (match) {
+                const params = {};
+                route.paramNames.forEach((name, i) => {
+                    params[name] = match[i + 1];
+                });
+                return { handler: route.handler, params };
+            }
+        }
+        return null;
+    }
+}
+// ============================================================================
+// HTTP Server Implementation
+// ============================================================================
+class HTTPServerImpl {
+    eventAdapter;
+    discoveryService;
+    taskManager;
+    taskStore;
+    sseTransport;
+    webSocketTransport;
+    enableWebSocket;
+    router;
+    agentMarkdownDir;
+    skipAgentCardLoading;
+    skipCRDTInit;
+    server = null;
+    running = false;
+    agentCardsLoaded = false;
+    enableCors;
+    // OAuth 2.0 (ADR-054)
+    jwtVerifier;
+    enableOAuth;
+    authMiddleware;
+    // Push Notifications (ADR-054)
+    webhookService;
+    subscriptionStore;
+    enablePushNotifications;
+    // Hot Reload (ADR-054)
+    hotReloadService;
+    healthChecker;
+    enableHotReload;
+    constructor(config = {}) {
+        // Initialize components with defaults
+        this.eventAdapter = config.eventAdapter ?? createEventAdapter();
+        this.enableCors = config.enableCors ?? true;
+        this.skipAgentCardLoading = config.skipAgentCardLoading ?? false;
+        this.skipCRDTInit = config.skipCRDTInit ?? false;
+        this.enableWebSocket = config.enableWebSocket ?? true;
+        // Resolve agent markdown directory
+        const currentDir = dirname(fileURLToPath(import.meta.url));
+        this.agentMarkdownDir = config.agentMarkdownDir ?? join(currentDir, '../../assets/agents/v3');
+        // Initialize task store and manager
+        this.taskStore = createTaskStore();
+        this.taskManager = config.taskManager ?? createTaskManager({
+            storeConfig: {},
+        });
+        // Initialize agent card generator and discovery service
+        const baseUrl = 'http://localhost:' + (process.env.AQE_HTTP_PORT || '3000');
+        const agentCardGenerator = config.agentCardGenerator ?? createAgentCardGenerator({
+            baseUrl,
+        });
+        this.discoveryService = config.discoveryService ?? createDiscoveryService({
+            generator: agentCardGenerator,
+            baseUrl,
+        });
+        // Initialize SSE transport (default, unidirectional)
+        this.sseTransport = config.sseTransport ?? createSSETransport();
+        // CRITICAL: Wire the SSE agent handler to process requests
+        this.sseTransport.setAgentHandler(this.handleAgentRequest.bind(this));
+        // Initialize WebSocket transport (optional, bidirectional <100ms latency)
+        if (this.enableWebSocket) {
+            this.webSocketTransport = config.webSocketTransport ?? createWebSocketTransport(config.webSocketConfig);
+            // Wire the WebSocket agent handler (same handler as SSE)
+            this.webSocketTransport.setAgentHandler(this.handleAgentRequest.bind(this));
+        }
+        else {
+            this.webSocketTransport = null;
+        }
+        // ========================================
+        // OAuth 2.0 Initialization (ADR-054)
+        // ========================================
+        this.jwtVerifier = config.jwtVerifier;
+        this.enableOAuth = config.enableOAuth ?? false;
+        if (this.jwtVerifier && this.enableOAuth) {
+            // Create auth middleware that returns true if auth passes
+            this.authMiddleware = async (req, res) => {
+                const authHeader = req.headers.authorization;
+                if (!authHeader?.startsWith('Bearer ')) {
+                    res.setHeader('WWW-Authenticate', 'Bearer');
+                    this.sendError(res, 401, 'Authentication required');
+                    return false;
+                }
+                const token = authHeader.substring(7);
+                try {
+                    const claims = await this.jwtVerifier.verify(token);
+                    req.user = claims;
+                    return true;
+                }
+                catch {
+                    res.setHeader('WWW-Authenticate', 'Bearer error="invalid_token"');
+                    this.sendError(res, 401, 'Invalid or expired token');
+                    return false;
+                }
+            };
+        }
+        // ========================================
+        // Push Notifications Initialization (ADR-054)
+        // ========================================
+        this.subscriptionStore = config.subscriptionStore ?? createSubscriptionStore();
+        this.webhookService = config.webhookService ?? createWebhookService();
+        this.enablePushNotifications = config.enablePushNotifications ?? true;
+        // Wire task events to webhook notifications
+        if (this.enablePushNotifications && this.webhookService) {
+            this.taskManager.on('stateChange', (event) => {
+                this.webhookService.notifyStateChange(event.taskId, event.newStatus, event.previousStatus).catch((err) => console.error('[AQE] Webhook delivery failed:', err));
+            });
+            this.taskManager.on('artifactAdded', (event) => {
+                this.webhookService.notifyArtifactCreated(event.taskId, {
+                    id: event.artifact.id ?? 'unknown',
+                    name: event.artifact.name ?? 'artifact',
+                }).catch((err) => console.error('[AQE] Artifact webhook delivery failed:', err));
+            });
+        }
+        // ========================================
+        // Hot Reload Initialization (ADR-054)
+        // ========================================
+        this.enableHotReload = config.enableHotReload ?? false;
+        this.healthChecker = config.healthChecker;
+        this.hotReloadService = config.hotReloadService;
+        // Setup router
+        this.router = new SimpleRouter();
+        this.setupRoutes();
+    }
+    // ============================================================================
+    // SSE Agent Handler - THE CRITICAL INTEGRATION POINT
+    // ============================================================================
+    /**
+     * Handle AG-UI agent requests via SSE
+     * This is the main integration point between AG-UI protocol and A2A task system
+     */
+    async handleAgentRequest(request, emit, signal) {
+        // Extract message content from request
+        const messageContent = request.messages?.map(m => m.content).join('\n') || '';
+        if (!messageContent) {
+            emit({
+                type: AGUIEventType.RUN_ERROR,
+                runId: request.runId || 'unknown',
+                message: 'No message content provided',
+                code: 'INVALID_REQUEST',
+            });
+            return;
+        }
+        // Create A2A task from AG-UI request
+        const task = this.taskManager.createTask({
+            role: 'user',
+            parts: [{ type: 'text', text: messageContent }],
+        }, { contextId: request.threadId });
+        // Emit STEP_STARTED for task creation
+        emit({
+            type: AGUIEventType.STEP_STARTED,
+            stepId: task.id,
+            name: 'Task Processing',
+            runId: request.runId,
+        });
+        // Subscribe to task events and forward to SSE
+        const taskEventHandler = (event) => {
+            if (event.taskId !== task.id || signal.aborted)
+                return;
+            // Emit appropriate AG-UI events based on task state changes
+            if (event.newStatus === 'working') {
+                emit({
+                    type: AGUIEventType.TEXT_MESSAGE_START,
+                    messageId: `msg-${task.id}`,
+                    role: 'assistant',
+                });
+            }
+            else if (event.newStatus === 'completed') {
+                emit({
+                    type: AGUIEventType.TEXT_MESSAGE_CONTENT,
+                    messageId: `msg-${task.id}`,
+                    delta: 'Task completed successfully',
+                });
+                emit({
+                    type: AGUIEventType.TEXT_MESSAGE_END,
+                    messageId: `msg-${task.id}`,
+                });
+                emit({
+                    type: AGUIEventType.STEP_FINISHED,
+                    stepId: task.id,
+                    result: event.task,
+                });
+            }
+            else if (event.newStatus === 'failed') {
+                emit({
+                    type: AGUIEventType.STEP_FINISHED,
+                    stepId: task.id,
+                    result: { error: 'Task failed' },
+                });
+            }
+        };
+        const artifactHandler = (event) => {
+            if (event.taskId !== task.id || signal.aborted)
+                return;
+            // Emit artifact as text message content
+            const textParts = event.artifact?.parts?.filter(p => p.type === 'text') || [];
+            for (const part of textParts) {
+                if (part.text) {
+                    emit({
+                        type: AGUIEventType.TEXT_MESSAGE_CONTENT,
+                        messageId: `msg-${task.id}`,
+                        delta: part.text,
+                    });
+                }
+            }
+        };
+        this.taskManager.on('stateChange', taskEventHandler);
+        this.taskManager.on('artifactAdded', artifactHandler);
+        // Handle abort signal
+        signal.addEventListener('abort', () => {
+            this.taskManager.off('stateChange', taskEventHandler);
+            this.taskManager.off('artifactAdded', artifactHandler);
+            try {
+                this.taskManager.cancelTask(task.id);
+            }
+            catch {
+                // Task may already be in terminal state
+            }
+        });
+        // Start task processing
+        try {
+            this.taskManager.startTask(task.id);
+            // Simulate task completion for now (in production, this would delegate to actual handlers)
+            // TODO: Wire to actual MCP tool handlers
+            await new Promise(resolve => setTimeout(resolve, 100));
+            if (!signal.aborted) {
+                this.taskManager.completeTask(task.id, [
+                    this.taskManager.createTextArtifact(`result-${task.id}`, 'Result', `Processed: ${messageContent}`),
+                ]);
+            }
+        }
+        catch (error) {
+            if (!signal.aborted) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                this.taskManager.failTask(task.id, {
+                    code: 'PROCESSING_ERROR',
+                    message: errorMessage,
+                });
+            }
+        }
+        finally {
+            // Cleanup listeners
+            this.taskManager.off('stateChange', taskEventHandler);
+            this.taskManager.off('artifactAdded', artifactHandler);
+        }
+    }
+    // ============================================================================
+    // Route Setup
+    // ============================================================================
+    setupRoutes() {
+        // Get discovery route definitions
+        const discoveryRoutes = getDiscoveryRouteDefinitions({
+            discoveryService: this.discoveryService,
+        });
+        // Register discovery routes
+        for (const route of discoveryRoutes) {
+            const handler = this.createHandlerFromDefinition(route);
+            this.router.add(route.method, route.path, handler);
+        }
+        // A2A Task routes
+        this.router.add('POST', '/a2a/tasks', this.handleTaskSubmit.bind(this));
+        this.router.add('GET', '/a2a/tasks/:taskId', this.handleTaskGet.bind(this));
+        this.router.add('POST', '/a2a/tasks/:taskId/cancel', this.handleTaskCancel.bind(this));
+        this.router.add('GET', '/a2a/tasks/:taskId/subscribe', this.handleTaskSubscribe.bind(this));
+        this.router.add('GET', '/a2a/tasks', this.handleTaskList.bind(this));
+        // Push Notification routes (ADR-054)
+        if (this.enablePushNotifications) {
+            this.router.add('POST', '/a2a/tasks/:taskId/pushNotification', this.handlePushNotificationSet.bind(this));
+            this.router.add('GET', '/a2a/tasks/:taskId/pushNotification', this.handlePushNotificationGet.bind(this));
+            this.router.add('DELETE', '/a2a/tasks/:taskId/pushNotification', this.handlePushNotificationDelete.bind(this));
+        }
+        // AG-UI SSE streaming endpoint
+        this.router.add('POST', '/agent/stream', this.handleAgentStream.bind(this));
+        this.router.add('OPTIONS', '/agent/stream', this.handleCorsPreFlight.bind(this));
+        // Health check
+        this.router.add('GET', '/health', this.handleHealth.bind(this));
+    }
+    createHandlerFromDefinition(route) {
+        return async (req, res) => {
+            // Create Express-compatible request/response wrappers
+            const httpReq = this.wrapRequest(req);
+            const httpRes = this.wrapResponse(res);
+            // Execute all handlers in sequence
+            for (const handler of route.handlers) {
+                await handler(httpReq, httpRes);
+                if (res.writableEnded)
+                    break;
+            }
+        };
+    }
+    // ============================================================================
+    // Request/Response Wrappers
+    // ============================================================================
+    wrapRequest(req) {
+        const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+        const query = {};
+        url.searchParams.forEach((value, key) => {
+            const existing = query[key];
+            if (existing) {
+                if (Array.isArray(existing)) {
+                    existing.push(value);
+                }
+                else {
+                    query[key] = [existing, value];
+                }
+            }
+            else {
+                query[key] = value;
+            }
+        });
+        return {
+            params: req.params || {},
+            query,
+            headers: req.headers,
+            header: (name) => {
+                const value = req.headers[name.toLowerCase()];
+                return Array.isArray(value) ? value[0] : value;
+            },
+        };
+    }
+    wrapResponse(res) {
+        return {
+            status: (code) => {
+                res.statusCode = code;
+                return this.wrapResponse(res);
+            },
+            json: (body) => {
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify(body));
+            },
+            setHeader: (name, value) => {
+                res.setHeader(name, value);
+            },
+            end: () => {
+                res.end();
+            },
+        };
+    }
+    // ============================================================================
+    // Task Handlers
+    // ============================================================================
+    async handleTaskSubmit(req, res) {
+        try {
+            const body = await this.parseBody(req);
+            const { message, contextId } = body;
+            if (!message) {
+                this.sendError(res, 400, 'Missing required field: message');
+                return;
+            }
+            // TaskManager.createTask expects (A2AMessage, CreateTaskOptions?)
+            const task = this.taskManager.createTask(message, { contextId });
+            this.setCorsHeaders(res);
+            res.setHeader('Content-Type', 'application/json');
+            res.statusCode = 201;
+            res.end(JSON.stringify({ task }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to submit task';
+            this.sendError(res, 500, message);
+        }
+    }
+    async handleTaskGet(req, res) {
+        try {
+            const taskId = req.params?.taskId;
+            if (!taskId) {
+                this.sendError(res, 400, 'Missing task ID');
+                return;
+            }
+            const task = await this.taskStore.get(taskId);
+            if (!task) {
+                this.sendError(res, 404, 'Task not found');
+                return;
+            }
+            this.setCorsHeaders(res);
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ task }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to get task';
+            this.sendError(res, 500, message);
+        }
+    }
+    async handleTaskCancel(req, res) {
+        try {
+            const taskId = req.params?.taskId;
+            if (!taskId) {
+                this.sendError(res, 400, 'Missing task ID');
+                return;
+            }
+            await this.taskManager.cancelTask(taskId);
+            this.setCorsHeaders(res);
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ success: true }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to cancel task';
+            this.sendError(res, 500, message);
+        }
+    }
+    async handleTaskSubscribe(req, res) {
+        const taskId = req.params?.taskId;
+        if (!taskId) {
+            this.sendError(res, 400, 'Missing task ID');
+            return;
+        }
+        const task = await this.taskStore.get(taskId);
+        if (!task) {
+            this.sendError(res, 404, 'Task not found');
+            return;
+        }
+        // Set SSE headers
+        this.setCorsHeaders(res);
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.setHeader('X-Accel-Buffering', 'no');
+        res.flushHeaders();
+        // Send initial state
+        res.write(`data: ${JSON.stringify({ type: 'task_state', task })}\n\n`);
+        // Subscribe to task events using EventEmitter
+        const onStateChange = (event) => {
+            const e = event;
+            if (e.taskId === taskId && !res.writableEnded) {
+                res.write(`data: ${JSON.stringify(event)}\n\n`);
+            }
+        };
+        const onArtifact = (event) => {
+            const e = event;
+            if (e.taskId === taskId && !res.writableEnded) {
+                res.write(`data: ${JSON.stringify(event)}\n\n`);
+            }
+        };
+        this.taskManager.on('stateChange', onStateChange);
+        this.taskManager.on('artifactAdded', onArtifact);
+        // Handle client disconnect
+        req.on('close', () => {
+            this.taskManager.off('stateChange', onStateChange);
+            this.taskManager.off('artifactAdded', onArtifact);
+        });
+    }
+    async handleTaskList(req, res) {
+        try {
+            const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+            const status = url.searchParams.get('status') || undefined;
+            const limit = parseInt(url.searchParams.get('limit') || '50', 10);
+            const result = await this.taskStore.query({ status: status, limit });
+            this.setCorsHeaders(res);
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify(result));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to list tasks';
+            this.sendError(res, 500, message);
+        }
+    }
+    // ============================================================================
+    // Push Notification Handlers (ADR-054)
+    // ============================================================================
+    async handlePushNotificationSet(req, res) {
+        try {
+            const taskId = req.params?.taskId;
+            if (!taskId) {
+                this.sendError(res, 400, 'Missing task ID');
+                return;
+            }
+            const body = await this.parseBody(req);
+            const { url, token, events } = body;
+            if (!url) {
+                this.sendError(res, 400, 'Missing required field: url');
+                return;
+            }
+            // Validate URL
+            try {
+                new URL(url);
+            }
+            catch {
+                this.sendError(res, 400, 'Invalid webhook URL');
+                return;
+            }
+            // Create subscription
+            if (this.subscriptionStore) {
+                const webhookEvents = events || ['task.completed', 'task.failed'];
+                this.subscriptionStore.create(taskId, {
+                    url,
+                    secret: token || '',
+                    events: webhookEvents,
+                    timeout: 30000,
+                    maxRetries: 5,
+                });
+            }
+            this.setCorsHeaders(res);
+            res.setHeader('Content-Type', 'application/json');
+            res.statusCode = 200;
+            res.end(JSON.stringify({ success: true }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to set push notification';
+            this.sendError(res, 500, message);
+        }
+    }
+    async handlePushNotificationGet(req, res) {
+        try {
+            const taskId = req.params?.taskId;
+            if (!taskId) {
+                this.sendError(res, 400, 'Missing task ID');
+                return;
+            }
+            const subscriptions = this.subscriptionStore?.listByTask(taskId) || [];
+            if (subscriptions.length === 0) {
+                this.sendError(res, 404, 'No push notification configured for this task');
+                return;
+            }
+            const subscription = subscriptions[0];
+            this.setCorsHeaders(res);
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({
+                url: subscription.webhookConfig.url,
+                events: subscription.webhookConfig.events,
+            }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to get push notification';
+            this.sendError(res, 500, message);
+        }
+    }
+    async handlePushNotificationDelete(req, res) {
+        try {
+            const taskId = req.params?.taskId;
+            if (!taskId) {
+                this.sendError(res, 400, 'Missing task ID');
+                return;
+            }
+            // Remove all subscriptions for this task
+            const subscriptions = this.subscriptionStore?.listByTask(taskId) || [];
+            for (const sub of subscriptions) {
+                this.subscriptionStore?.delete(sub.id);
+            }
+            this.setCorsHeaders(res);
+            res.statusCode = 204;
+            res.end();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to delete push notification';
+            this.sendError(res, 500, message);
+        }
+    }
+    // ============================================================================
+    // AG-UI Handler
+    // ============================================================================
+    async handleAgentStream(req, res) {
+        // Delegate to SSE transport (which now has the handler wired)
+        await this.sseTransport.handleRequest(req, res);
+    }
+    // ============================================================================
+    // Utility Handlers
+    // ============================================================================
+    handleCorsPreFlight(_req, res) {
+        this.setCorsHeaders(res);
+        res.statusCode = 204;
+        res.end();
+    }
+    handleHealth(_req, res) {
+        this.setCorsHeaders(res);
+        res.setHeader('Content-Type', 'application/json');
+        res.end(JSON.stringify({
+            status: 'ok',
+            version: '3.0.0',
+            protocols: ['ag-ui', 'a2a', 'a2ui'],
+            agentCardsLoaded: this.agentCardsLoaded,
+            agentCount: this.discoveryService.getAgentCount(),
+            timestamp: new Date().toISOString(),
+        }));
+    }
+    // ============================================================================
+    // Helpers
+    // ============================================================================
+    async parseBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            let size = 0;
+            const maxSize = 1024 * 1024; // 1MB
+            req.on('data', (chunk) => {
+                size += chunk.length;
+                if (size > maxSize) {
+                    reject(new Error('Request body too large'));
+                    return;
+                }
+                chunks.push(chunk);
+            });
+            req.on('end', () => {
+                try {
+                    const body = Buffer.concat(chunks).toString('utf-8');
+                    if (!body) {
+                        resolve({});
+                        return;
+                    }
+                    resolve(JSON.parse(body));
+                }
+                catch (error) {
+                    reject(new Error('Invalid JSON in request body'));
+                }
+            });
+            req.on('error', reject);
+        });
+    }
+    setCorsHeaders(res) {
+        if (this.enableCors) {
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+            res.setHeader('Access-Control-Max-Age', '86400');
+        }
+    }
+    sendError(res, code, message) {
+        this.setCorsHeaders(res);
+        res.setHeader('Content-Type', 'application/json');
+        res.statusCode = code;
+        res.end(JSON.stringify({ error: { code, message } }));
+    }
+    // ============================================================================
+    // Server Lifecycle
+    // ============================================================================
+    async start(port) {
+        if (this.running) {
+            throw new Error('Server already running');
+        }
+        // CRITICAL: Initialize CRDT for distributed state
+        if (!this.skipCRDTInit) {
+            try {
+                const memory = getUnifiedMemory();
+                if (!memory.isCRDTInitialized()) {
+                    memory.initializeCRDT(`aqe-http-${process.pid}-${Date.now()}`);
+                    console.error('[AQE] CRDT store initialized');
+                }
+            }
+            catch (error) {
+                console.error('[AQE] WARNING: Failed to initialize CRDT:', error);
+                // Non-fatal, continue without CRDT
+            }
+        }
+        // CRITICAL: Load agent cards before accepting connections
+        if (!this.skipAgentCardLoading) {
+            try {
+                await this.discoveryService.loadCards(this.agentMarkdownDir);
+                this.agentCardsLoaded = true;
+                console.error(`[AQE] Loaded ${this.discoveryService.getAgentCount()} agent cards`);
+            }
+            catch (error) {
+                console.error('[AQE] WARNING: Failed to load agent cards:', error);
+                // Non-fatal, discovery will return empty results
+            }
+        }
+        return new Promise(async (resolve, reject) => {
+            this.server = createServer((req, res) => {
+                this.handleHttpRequest(req, res).catch((error) => {
+                    console.error('[HTTP] Request error:', error);
+                    this.sendError(res, 500, 'Internal server error');
+                });
+            });
+            this.server.on('error', (error) => {
+                reject(error);
+            });
+            // Attach WebSocket transport for bidirectional streaming
+            if (this.webSocketTransport && this.enableWebSocket) {
+                try {
+                    await this.webSocketTransport.attach(this.server, '/agent/ws');
+                    console.error('[AQE] WebSocket transport attached at /agent/ws');
+                }
+                catch (error) {
+                    console.error('[AQE] WARNING: Failed to attach WebSocket transport:', error);
+                    // Non-fatal, SSE is still available as fallback
+                }
+            }
+            // Start hot reload watcher if enabled (ADR-054)
+            if (this.enableHotReload && this.hotReloadService) {
+                this.hotReloadService.start().then(() => {
+                    console.error('[AQE] Hot reload enabled for agent cards');
+                }).catch(err => {
+                    console.error('[AQE] WARNING: Failed to start hot reload:', err);
+                });
+            }
+            this.server.listen(port, () => {
+                this.running = true;
+                console.error(`[AQE] HTTP server started on port ${port}`);
+                console.error(`[AQE] Endpoints ready:`);
+                console.error(`[AQE]   GET  /.well-known/agent.json - Platform discovery (${this.discoveryService.getAgentCount()} agents)`);
+                console.error(`[AQE]   POST /agent/stream          - AG-UI SSE streaming (default)`);
+                if (this.webSocketTransport) {
+                    console.error(`[AQE]   WS   /agent/ws              - AG-UI WebSocket streaming (<100ms latency)`);
+                }
+                console.error(`[AQE]   POST /a2a/tasks             - A2A task submission`);
+                if (this.enablePushNotifications) {
+                    console.error(`[AQE]   POST /a2a/tasks/:id/pushNotification - Push notification subscription`);
+                }
+                if (this.enableOAuth) {
+                    console.error(`[AQE]   OAuth 2.0 protection enabled`);
+                }
+                if (this.enableHotReload) {
+                    console.error(`[AQE]   Hot reload enabled for agent cards`);
+                }
+                console.error(`[AQE]   GET  /health                - Health check`);
+                resolve();
+            });
+        });
+    }
+    async handleHttpRequest(req, res) {
+        const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+        const path = url.pathname;
+        const method = req.method || 'GET';
+        // Try to match route
+        const match = this.router.match(method, path);
+        if (match) {
+            // Attach params to request
+            req.params = match.params;
+            await match.handler(req, res);
+        }
+        else {
+            // 404 Not Found
+            this.sendError(res, 404, 'Not found');
+        }
+    }
+    async stop() {
+        if (!this.running || !this.server) {
+            return;
+        }
+        return new Promise((resolve) => {
+            this.server.close(() => {
+                this.running = false;
+                this.server = null;
+                console.error('[AQE] HTTP server stopped');
+                resolve();
+            });
+            // Close SSE transport
+            this.sseTransport.dispose();
+            // Close WebSocket transport
+            if (this.webSocketTransport) {
+                this.webSocketTransport.dispose();
+            }
+        });
+    }
+    // ============================================================================
+    // Accessors
+    // ============================================================================
+    getEventAdapter() {
+        return this.eventAdapter;
+    }
+    getDiscoveryService() {
+        return this.discoveryService;
+    }
+    getTaskManager() {
+        return this.taskManager;
+    }
+    getServer() {
+        return this.server;
+    }
+    getWebSocketTransport() {
+        return this.webSocketTransport;
+    }
+    isRunning() {
+        return this.running;
+    }
+    hasLoadedAgentCards() {
+        return this.agentCardsLoaded;
+    }
+    isWebSocketEnabled() {
+        return this.enableWebSocket && this.webSocketTransport !== null;
+    }
+}
+// ============================================================================
+// Factory Function
+// ============================================================================
+export function createHTTPServer(config) {
+    return new HTTPServerImpl(config);
+}
+//# sourceMappingURL=http-server.js.map