agentic-qe 2.7.4 → 2.8.0

package/dist/edge/browser/BrowserAgent.js

@@ -0,0 +1,743 @@
+"use strict";
+/**
+ * BrowserAgent - Browser-Compatible Base Agent for WASM Environments
+ *
+ * This is the browser-compatible version of BaseAgent that can run in:
+ * - Modern browsers (Chrome 87+, Firefox 89+, Safari 15+)
+ * - Web Workers
+ * - Service Workers
+ * - WASM-based environments
+ *
+ * Key differences from Node.js BaseAgent:
+ * - No EventEmitter inheritance (uses custom BrowserEventEmitter)
+ * - No Node.js crypto (uses Web Crypto API via shims)
+ * - No fs/path dependencies
+ * - IndexedDB for storage instead of SQLite
+ * - BroadcastChannel for cross-tab coordination
+ *
+ * Phase 0: @ruvector/edge integration
+ * Target bundle size contribution: <100KB
+ *
+ * @module edge/browser/BrowserAgent
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserAgentBase = exports.BrowserAgent = exports.BrowserAgentStatus = exports.BrowserAgentType = void 0;
+const browser_agent_types_1 = require("../types/browser-agent.types");
+const shims_1 = require("../wasm/shims");
+const index_1 = require("../index");
+// Re-export for convenience
+var browser_agent_types_2 = require("../types/browser-agent.types");
+Object.defineProperty(exports, "BrowserAgentType", { enumerable: true, get: function () { return browser_agent_types_2.BrowserAgentType; } });
+Object.defineProperty(exports, "BrowserAgentStatus", { enumerable: true, get: function () { return browser_agent_types_2.BrowserAgentStatus; } });
+// ============================================
+// Default Strategy Implementations
+// ============================================
+/**
+ * Default lifecycle strategy for browser agents
+ */
+class DefaultBrowserLifecycleStrategy {
+    constructor() {
+        this.status = browser_agent_types_1.BrowserAgentStatus.INITIALIZING;
+        this.statusListeners = new Map();
+    }
+    getStatus() {
+        return this.status;
+    }
+    async transitionTo(status, _reason) {
+        this.status = status;
+        const listeners = this.statusListeners.get(status);
+        if (listeners) {
+            listeners.forEach((resolve) => resolve());
+            this.statusListeners.delete(status);
+        }
+    }
+    async waitForStatus(status, timeout = 10000) {
+        if (this.status === status)
+            return;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`Agent did not reach status '${status}' within ${timeout}ms`));
+            }, timeout);
+            const listener = () => {
+                clearTimeout(timer);
+                resolve();
+            };
+            if (!this.statusListeners.has(status)) {
+                this.statusListeners.set(status, []);
+            }
+            this.statusListeners.get(status).push(listener);
+        });
+    }
+    async waitForReady(timeout = 10000) {
+        const status = this.getStatus();
+        if (status === browser_agent_types_1.BrowserAgentStatus.IDLE || status === browser_agent_types_1.BrowserAgentStatus.ACTIVE) {
+            return;
+        }
+        return this.waitForStatus(browser_agent_types_1.BrowserAgentStatus.IDLE, timeout);
+    }
+}
+/**
+ * Default memory strategy for browser agents
+ */
+class DefaultBrowserMemoryStrategy {
+    constructor(memoryStore, agentId) {
+        this.memoryStore = memoryStore;
+        this.agentId = agentId;
+    }
+    async store(key, value, options) {
+        const fullKey = `aqe/${this.agentId.type}/${key}`;
+        await this.memoryStore.store(fullKey, value, options?.ttl);
+    }
+    async retrieve(key) {
+        const fullKey = `aqe/${this.agentId.type}/${key}`;
+        return this.memoryStore.retrieve(fullKey);
+    }
+    async storeShared(agentType, key, value, options) {
+        const fullKey = `aqe/shared/${agentType}/${key}`;
+        await this.memoryStore.store(fullKey, value, options?.ttl);
+    }
+    async retrieveShared(agentType, key) {
+        const fullKey = `aqe/shared/${agentType}/${key}`;
+        return this.memoryStore.retrieve(fullKey);
+    }
+}
+/**
+ * Default coordination strategy for browser agents
+ */
+class DefaultBrowserCoordinationStrategy {
+    constructor(eventBus, agentId) {
+        this.eventBus = eventBus;
+        this.agentId = agentId;
+        this.crypto = (0, shims_1.createBrowserCrypto)();
+        // Initialize BroadcastChannel for cross-tab coordination
+        if (typeof BroadcastChannel !== 'undefined') {
+            try {
+                this.broadcastChannel = new BroadcastChannel('agentic-qe-coordination');
+                this.broadcastChannel.onmessage = (event) => {
+                    const message = event.data;
+                    if (message.target?.id !== this.agentId.id && message.source?.id !== this.agentId.id) {
+                        this.eventBus.emit(message.type, message);
+                    }
+                };
+            }
+            catch {
+                // BroadcastChannel not available
+            }
+        }
+    }
+    emitEvent(type, data) {
+        const event = {
+            id: (0, browser_agent_types_1.generateBrowserEventId)(this.crypto),
+            type,
+            source: this.agentId,
+            data,
+            timestamp: Date.now(),
+            priority: 'medium',
+            scope: 'global',
+        };
+        this.eventBus.emit(type, event);
+        this.broadcastChannel?.postMessage(event);
+    }
+    registerHandler(type, handler) {
+        this.eventBus.on(type, handler);
+    }
+    unregisterHandler(type, handler) {
+        this.eventBus.off(type, handler);
+    }
+    async broadcast(message) {
+        this.eventBus.emit('agent.message', message);
+        this.broadcastChannel?.postMessage(message);
+    }
+    destroy() {
+        this.broadcastChannel?.close();
+    }
+}
+// ============================================
+// Simple BrowserAgent (Legacy Compatibility)
+// ============================================
+/**
+ * Simple browser agent for basic WASM operations
+ * Use BrowserAgentBase for full BaseAgent compatibility
+ */
+class BrowserAgent {
+    constructor(config) {
+        this.config = {
+            maxMemoryMB: 50,
+            debug: false,
+            ...config
+        };
+        this.eventHandlers = new Set();
+        this.memory = config.memory ?? null;
+        this.state = {
+            status: 'idle',
+            lastActivity: Date.now(),
+            tasksCompleted: 0,
+            memoryUsage: {
+                usedBytes: 0,
+                maxBytes: (this.config.maxMemoryMB ?? 50) * 1024 * 1024,
+                vectorCount: 0,
+                indexSizeBytes: 0
+            },
+            capabilities: (0, index_1.getEdgeCapabilities)()
+        };
+    }
+    get id() {
+        return this.config.id;
+    }
+    get type() {
+        return this.config.type;
+    }
+    getState() {
+        return { ...this.state };
+    }
+    getCapabilities() {
+        return this.state.capabilities;
+    }
+    async start() {
+        if (this.state.status === 'running') {
+            this.log('Agent already running');
+            return;
+        }
+        this.log('Starting agent...');
+        if (!this.state.capabilities.hasWASM) {
+            throw new Error('WebAssembly not supported in this environment');
+        }
+        if (this.memory) {
+            await this.memory.initialize();
+            this.updateMemoryUsage();
+        }
+        this.state.status = 'running';
+        this.state.lastActivity = Date.now();
+        this.emit({ type: 'started', agentId: this.id });
+        this.log('Agent started successfully');
+    }
+    async stop() {
+        if (this.state.status !== 'running') {
+            this.log('Agent not running');
+            return;
+        }
+        this.log('Stopping agent...');
+        if (this.memory) {
+            await this.memory.close();
+        }
+        this.state.status = 'idle';
+        this.state.lastActivity = Date.now();
+        this.emit({ type: 'stopped', agentId: this.id });
+        this.log('Agent stopped');
+    }
+    async storeVector(key, vector, metadata) {
+        if (!this.memory) {
+            throw new Error('No memory adapter configured');
+        }
+        if (this.state.status !== 'running') {
+            throw new Error('Agent not running');
+        }
+        await this.memory.store(key, vector, metadata);
+        this.updateMemoryUsage();
+        this.state.lastActivity = Date.now();
+    }
+    async searchVectors(query, k = 10) {
+        if (!this.memory) {
+            throw new Error('No memory adapter configured');
+        }
+        if (this.state.status !== 'running') {
+            throw new Error('Agent not running');
+        }
+        const results = await this.memory.search(query, k);
+        this.state.lastActivity = Date.now();
+        return results;
+    }
+    on(handler) {
+        this.eventHandlers.add(handler);
+        return () => this.eventHandlers.delete(handler);
+    }
+    recordTaskCompletion(taskId, duration) {
+        this.state.tasksCompleted++;
+        this.state.lastActivity = Date.now();
+        this.emit({ type: 'task_completed', agentId: this.id, taskId, duration });
+    }
+    updateMemoryUsage() {
+        if (this.memory) {
+            this.state.memoryUsage = this.memory.getMemoryUsage();
+            this.emit({ type: 'memory_updated', agentId: this.id, usage: this.state.memoryUsage });
+        }
+    }
+    emit(event) {
+        this.eventHandlers.forEach((handler) => {
+            try {
+                handler(event);
+            }
+            catch (error) {
+                this.log(`Event handler error: ${error}`);
+            }
+        });
+    }
+    log(message) {
+        if (this.config.debug) {
+            console.log(`[BrowserAgent:${this.id}] ${message}`);
+        }
+    }
+}
+exports.BrowserAgent = BrowserAgent;
+// ============================================
+// Abstract BrowserAgentBase (Full BaseAgent Compatibility)
+// ============================================
+/**
+ * Abstract base class for browser-compatible QE agents
+ * Mirrors the interface of Node.js BaseAgent
+ *
+ * @example
+ * ```typescript
+ * class BrowserTestGeneratorAgent extends BrowserAgentBase {
+ *   protected async initializeComponents(): Promise<void> {
+ *     // Initialize test generation components
+ *   }
+ *
+ *   protected async performTask(task: BrowserTask): Promise<any> {
+ *     // Generate tests in browser
+ *   }
+ *
+ *   protected async loadKnowledge(): Promise<void> {
+ *     // Load cached patterns from IndexedDB
+ *   }
+ *
+ *   protected async cleanup(): Promise<void> {
+ *     // Cleanup resources
+ *   }
+ * }
+ * ```
+ */
+class BrowserAgentBase {
+    constructor(config) {
+        this.performanceMetrics = {
+            tasksCompleted: 0,
+            averageExecutionTime: 0,
+            errorCount: 0,
+            lastActivity: Date.now(),
+        };
+        this.statusChangeCallbacks = [];
+        this.crypto = (0, shims_1.createBrowserCrypto)();
+        this.logger = (0, shims_1.createBrowserLogger)();
+        this.agentId = config.id
+            ? { id: config.id, type: config.type, created: Date.now() }
+            : (0, browser_agent_types_1.generateBrowserAgentId)(config.type, this.crypto);
+        this.capabilities = new Map((config.capabilities || []).map((cap) => [cap.name, cap]));
+        this.context = config.context;
+        this.memoryStore = config.memoryStore;
+        this.eventBus = config.eventBus || (0, shims_1.createBrowserEventEmitter)();
+        this.llmConfig = config.llm;
+        this.strategies = {
+            lifecycle: config.lifecycleStrategy ?? new DefaultBrowserLifecycleStrategy(),
+            memory: config.memoryStrategy ?? new DefaultBrowserMemoryStrategy(this.memoryStore, this.agentId),
+            learning: config.learningStrategy,
+            coordination: config.coordinationStrategy ?? new DefaultBrowserCoordinationStrategy(this.eventBus, this.agentId),
+        };
+        this.setupEventHandlers();
+    }
+    // ============================================
+    // Public Interface
+    // ============================================
+    async initialize() {
+        if (this.initializationPromise) {
+            return this.initializationPromise;
+        }
+        const currentStatus = this.strategies.lifecycle.getStatus();
+        if (currentStatus === browser_agent_types_1.BrowserAgentStatus.ACTIVE || currentStatus === browser_agent_types_1.BrowserAgentStatus.IDLE) {
+            return;
+        }
+        this.initializationPromise = this.doInitialize();
+        try {
+            await this.initializationPromise;
+        }
+        finally {
+            this.initializationPromise = undefined;
+        }
+    }
+    async doInitialize() {
+        try {
+            await this.loadKnowledge();
+            const savedState = await this.memoryStore.retrieve(`state:${this.agentId.id}`);
+            if (savedState && typeof savedState === 'object') {
+                const state = savedState;
+                if (state.performanceMetrics) {
+                    this.performanceMetrics = { ...this.performanceMetrics, ...state.performanceMetrics };
+                }
+            }
+            await this.initializeLLMProvider();
+            await this.initializeComponents();
+            await this.strategies.lifecycle.transitionTo(browser_agent_types_1.BrowserAgentStatus.IDLE);
+            this.emitStatusChange(browser_agent_types_1.BrowserAgentStatus.IDLE);
+            this.strategies.coordination.emitEvent('agent.initialized', { agentId: this.agentId });
+            this.logger.info(`[${this.agentId.id}] Agent initialized successfully`);
+        }
+        catch (error) {
+            await this.strategies.lifecycle.transitionTo(browser_agent_types_1.BrowserAgentStatus.ERROR, `Initialization failed: ${error}`);
+            this.emitStatusChange(browser_agent_types_1.BrowserAgentStatus.ERROR);
+            throw new browser_agent_types_1.BrowserAgentError(`Agent initialization failed: ${error}`, 'INITIALIZATION_FAILED', true, error instanceof Error ? error : undefined);
+        }
+    }
+    async executeTask(assignment) {
+        const startTime = (0, shims_1.hrtime)();
+        try {
+            this.validateTaskAssignment(assignment);
+            this.currentTask = assignment;
+            await this.strategies.lifecycle.transitionTo(browser_agent_types_1.BrowserAgentStatus.ACTIVE);
+            this.emitStatusChange(browser_agent_types_1.BrowserAgentStatus.ACTIVE);
+            const preTaskData = { assignment };
+            await this.onPreTask(preTaskData);
+            const result = await this.performTask(assignment.task);
+            const duration = (0, shims_1.elapsed)(startTime);
+            const postTaskData = { assignment, result, duration };
+            await this.onPostTask(postTaskData);
+            this.updatePerformanceMetrics(startTime, true);
+            await this.memoryStore.store(`task-result:${assignment.id}`, result);
+            this.currentTask = undefined;
+            await this.strategies.lifecycle.transitionTo(browser_agent_types_1.BrowserAgentStatus.IDLE);
+            this.emitStatusChange(browser_agent_types_1.BrowserAgentStatus.IDLE);
+            return {
+                success: true,
+                data: result,
+                duration: (0, shims_1.elapsed)(startTime),
+                metadata: { taskId: assignment.id },
+            };
+        }
+        catch (error) {
+            this.updatePerformanceMetrics(startTime, false);
+            this.currentTask = undefined;
+            const taskErrorData = {
+                assignment,
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            };
+            await this.onTaskError(taskErrorData);
+            await this.strategies.lifecycle.transitionTo(browser_agent_types_1.BrowserAgentStatus.ERROR, `Task failed: ${error}`);
+            this.emitStatusChange(browser_agent_types_1.BrowserAgentStatus.ERROR);
+            throw new browser_agent_types_1.BrowserAgentError(`Task execution failed: ${error}`, 'TASK_FAILED', true, error instanceof Error ? error : undefined);
+        }
+    }
+    async terminate() {
+        try {
+            await this.strategies.lifecycle.transitionTo(browser_agent_types_1.BrowserAgentStatus.STOPPING);
+            this.emitStatusChange(browser_agent_types_1.BrowserAgentStatus.STOPPING);
+            await this.saveState();
+            await this.cleanup();
+            await this.cleanupLLM();
+            if (this.strategies.coordination instanceof DefaultBrowserCoordinationStrategy) {
+                this.strategies.coordination.destroy();
+            }
+            await this.strategies.lifecycle.transitionTo(browser_agent_types_1.BrowserAgentStatus.TERMINATED);
+            this.emitStatusChange(browser_agent_types_1.BrowserAgentStatus.TERMINATED);
+            this.strategies.coordination.emitEvent('agent.terminated', { agentId: this.agentId });
+            this.eventBus.removeAllListeners();
+            this.statusChangeCallbacks = [];
+            this.logger.info(`[${this.agentId.id}] Agent terminated successfully`);
+        }
+        catch (error) {
+            await this.strategies.lifecycle.transitionTo(browser_agent_types_1.BrowserAgentStatus.ERROR, `Termination failed: ${error}`);
+            throw error;
+        }
+    }
+    // ============================================
+    // Getters
+    // ============================================
+    getAgentId() {
+        return this.agentId;
+    }
+    getStatus() {
+        return {
+            agentId: this.agentId,
+            status: this.strategies.lifecycle.getStatus(),
+            currentTask: this.currentTask?.id,
+            capabilities: Array.from(this.capabilities.keys()),
+            performanceMetrics: { ...this.performanceMetrics },
+        };
+    }
+    hasCapability(name) {
+        return this.capabilities.has(name);
+    }
+    getCapability(name) {
+        return this.capabilities.get(name);
+    }
+    getCapabilities() {
+        return Array.from(this.capabilities.values());
+    }
+    getStrategies() {
+        return this.strategies;
+    }
+    // ============================================
+    // Event-Driven Coordination
+    // ============================================
+    async waitForStatus(status, timeout = 10000) {
+        if (this.strategies.lifecycle.waitForStatus) {
+            return this.strategies.lifecycle.waitForStatus(status, timeout);
+        }
+        return new Promise((resolve, reject) => {
+            if (this.strategies.lifecycle.getStatus() === status) {
+                return resolve();
+            }
+            const timer = setTimeout(() => {
+                reject(new Error(`Agent did not reach status '${status}' within ${timeout}ms`));
+            }, timeout);
+            const callback = (newStatus) => {
+                if (newStatus === status) {
+                    clearTimeout(timer);
+                    this.removeStatusChangeCallback(callback);
+                    resolve();
+                }
+            };
+            this.addStatusChangeCallback(callback);
+        });
+    }
+    async waitForReady(timeout = 10000) {
+        if (this.strategies.lifecycle.waitForReady) {
+            return this.strategies.lifecycle.waitForReady(timeout);
+        }
+        const status = this.strategies.lifecycle.getStatus();
+        if (status === browser_agent_types_1.BrowserAgentStatus.IDLE || status === browser_agent_types_1.BrowserAgentStatus.ACTIVE) {
+            return;
+        }
+        return this.waitForStatus(browser_agent_types_1.BrowserAgentStatus.IDLE, timeout);
+    }
+    addStatusChangeCallback(callback) {
+        this.statusChangeCallbacks.push(callback);
+    }
+    removeStatusChangeCallback(callback) {
+        const index = this.statusChangeCallbacks.indexOf(callback);
+        if (index !== -1) {
+            this.statusChangeCallbacks.splice(index, 1);
+        }
+    }
+    // ============================================
+    // LLM Integration
+    // ============================================
+    hasLLM() {
+        return this.llmProvider !== undefined;
+    }
+    getLLMProvider() {
+        return this.llmProvider;
+    }
+    async llmComplete(prompt, options) {
+        if (!this.llmProvider) {
+            throw new browser_agent_types_1.BrowserAgentError('LLM not available - initialize agent first', 'LLM_ERROR', false);
+        }
+        const completionOptions = {
+            model: options?.model || this.llmConfig?.defaultModel || 'default',
+            messages: [{ role: 'user', content: prompt }],
+            maxTokens: options?.maxTokens,
+            temperature: options?.temperature,
+            metadata: {
+                ...options?.metadata,
+                agentId: this.agentId.id,
+                agentType: this.agentId.type,
+            },
+        };
+        const response = await this.llmProvider.complete(completionOptions);
+        return response.content
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text)
+            .join('\n');
+    }
+    async llmEmbed(text) {
+        if (!this.llmProvider?.embed) {
+            throw new browser_agent_types_1.BrowserAgentError('Embeddings not supported by LLM provider', 'LLM_ERROR', false);
+        }
+        const response = await this.llmProvider.embed({ text });
+        return response.embedding || [];
+    }
+    // ============================================
+    // FleetManager Compatibility
+    // ============================================
+    async start() {
+        const status = this.strategies.lifecycle.getStatus();
+        if (status === browser_agent_types_1.BrowserAgentStatus.ACTIVE || status === browser_agent_types_1.BrowserAgentStatus.IDLE) {
+            return;
+        }
+        await this.initialize();
+    }
+    async stop() {
+        await this.terminate();
+    }
+    async assignTask(task) {
+        const assignment = {
+            id: (0, browser_agent_types_1.generateBrowserTaskId)(this.crypto),
+            task,
+            agentId: this.agentId.id,
+            assignedAt: Date.now(),
+            status: 'assigned',
+        };
+        await this.executeTask(assignment);
+    }
+    // ============================================
+    // Protected Methods
+    // ============================================
+    registerCapability(capability) {
+        this.capabilities.set(capability.name, capability);
+        this.strategies.coordination.emitEvent('capability.registered', {
+            agentId: this.agentId,
+            capability: capability.name,
+        });
+    }
+    registerCapabilities(capabilities) {
+        capabilities.forEach((cap) => this.registerCapability(cap));
+    }
+    emitEvent(type, data) {
+        this.strategies.coordination.emitEvent(type, data);
+    }
+    emitStatusChange(status) {
+        this.statusChangeCallbacks.forEach((callback) => {
+            try {
+                callback(status);
+            }
+            catch (error) {
+                this.logger.error(`Status change callback error:`, error);
+            }
+        });
+        this.strategies.coordination.emitEvent('agent.status-changed', {
+            agentId: this.agentId,
+            status,
+            timestamp: Date.now(),
+        });
+    }
+    async broadcastMessage(type, payload) {
+        const message = {
+            id: (0, browser_agent_types_1.generateBrowserMessageId)(this.crypto),
+            from: this.agentId,
+            to: { id: 'broadcast', type: browser_agent_types_1.BrowserAgentType.TEST_GENERATOR, created: Date.now() },
+            type: type,
+            payload,
+            timestamp: Date.now(),
+            priority: 'medium',
+        };
+        await this.strategies.coordination.broadcast(message);
+    }
+    async storeMemory(key, value, ttl) {
+        await this.strategies.memory.store(key, value, { ttl });
+    }
+    async retrieveMemory(key) {
+        return this.strategies.memory.retrieve(key);
+    }
+    async storeSharedMemory(key, value, ttl) {
+        await this.strategies.memory.storeShared(this.agentId.type, key, value, { ttl });
+    }
+    async retrieveSharedMemory(agentType, key) {
+        return this.strategies.memory.retrieveShared(agentType, key);
+    }
+    // ============================================
+    // Lifecycle Hooks
+    // ============================================
+    async onPreTask(data) {
+        this.taskStartTime = (0, shims_1.hrtime)();
+        if (this.strategies.lifecycle.onPreTask) {
+            await this.strategies.lifecycle.onPreTask(data);
+        }
+        this.emitEvent('hook.pre-task', { agentId: this.agentId, taskId: data.assignment.id });
+    }
+    async onPostTask(data) {
+        if (this.strategies.lifecycle.onPostTask) {
+            await this.strategies.lifecycle.onPostTask(data);
+        }
+        if (this.strategies.learning?.recordExecution) {
+            await this.strategies.learning.recordExecution({
+                task: data.assignment.task,
+                result: data.result,
+                success: true,
+                duration: data.duration,
+                metadata: { taskId: data.assignment.id },
+            });
+        }
+        this.emitEvent('hook.post-task', { agentId: this.agentId, taskId: data.assignment.id, duration: data.duration });
+    }
+    async onTaskError(data) {
+        const executionTime = this.taskStartTime ? (0, shims_1.elapsed)(this.taskStartTime) : 0;
+        await this.storeMemory(`error:${data.assignment.id}`, {
+            error: data.error,
+            stack: data.stack,
+            assignment: { id: data.assignment.id, taskType: data.assignment.task?.type ?? 'unknown' },
+            timestamp: Date.now(),
+            agentId: this.agentId.id,
+        });
+        if (this.strategies.lifecycle.onTaskError) {
+            await this.strategies.lifecycle.onTaskError(data);
+        }
+        if (this.strategies.learning?.recordExecution) {
+            await this.strategies.learning.recordExecution({
+                task: data.assignment.task,
+                error: data.error,
+                success: false,
+                duration: executionTime,
+                metadata: { taskId: data.assignment.id },
+            });
+        }
+        this.emitEvent('hook.task-error', { agentId: this.agentId, error: data.error });
+    }
+    // ============================================
+    // Private Helpers
+    // ============================================
+    async initializeLLMProvider() {
+        if (!this.llmConfig?.enabled || !this.llmConfig?.provider) {
+            return;
+        }
+        try {
+            this.llmProvider = this.llmConfig.provider;
+            await this.llmProvider.initialize();
+            this.logger.info(`[${this.agentId.id}] LLM provider initialized`);
+        }
+        catch (error) {
+            this.logger.warn(`[${this.agentId.id}] LLM initialization failed:`, error);
+        }
+    }
+    async cleanupLLM() {
+        if (this.llmProvider) {
+            try {
+                await this.llmProvider.shutdown();
+                this.logger.info(`[${this.agentId.id}] LLM provider shutdown complete`);
+            }
+            catch (error) {
+                this.logger.warn(`[${this.agentId.id}] LLM shutdown error:`, error);
+            }
+        }
+    }
+    setupEventHandlers() {
+        this.strategies.coordination.registerHandler('fleet.shutdown', async () => {
+            await this.terminate();
+        });
+        this.strategies.coordination.registerHandler('agent.ping', (event) => {
+            if (event.target?.id === this.agentId.id) {
+                this.emitEvent('agent.pong', { agentId: this.agentId });
+            }
+        });
+    }
+    validateTaskAssignment(assignment) {
+        if (!assignment?.task) {
+            throw new browser_agent_types_1.BrowserAgentError('Invalid task assignment', 'VALIDATION_ERROR', false);
+        }
+        const requiredCapabilities = assignment.task.requirements?.capabilities || [];
+        for (const cap of requiredCapabilities) {
+            if (!this.hasCapability(cap)) {
+                throw new browser_agent_types_1.BrowserAgentError(`Missing required capability: ${cap}`, 'VALIDATION_ERROR', false);
+            }
+        }
+    }
+    updatePerformanceMetrics(startTime, success) {
+        const duration = (0, shims_1.elapsed)(startTime);
+        if (success) {
+            this.performanceMetrics.tasksCompleted++;
+            this.performanceMetrics.averageExecutionTime =
+                (this.performanceMetrics.averageExecutionTime * (this.performanceMetrics.tasksCompleted - 1) + duration) /
+                    this.performanceMetrics.tasksCompleted;
+        }
+        else {
+            this.performanceMetrics.errorCount++;
+        }
+        this.performanceMetrics.lastActivity = Date.now();
+    }
+    async saveState() {
+        await this.memoryStore.store(`state:${this.agentId.id}`, {
+            performanceMetrics: this.performanceMetrics,
+            timestamp: Date.now(),
+        });
+    }
+}
+exports.BrowserAgentBase = BrowserAgentBase;
+exports.default = BrowserAgent;
+//# sourceMappingURL=BrowserAgent.js.map