@auxot/worker-cli 0.1.0

package/dist/policy-validator.js

@@ -0,0 +1,242 @@
+/**
+ * Policy Validation
+ *
+ * Validates worker capabilities against GPU key policy.
+ */
+/**
+ * Normalize model name for comparison
+ * Extracts base model name + version + variant (removes quantization, parameters, file patterns)
+ */
+function normalizeModelName(name) {
+    // Remove common quantization suffixes
+    let normalized = name
+        .replace(/-GGUF$/i, '')
+        .replace(/\.gguf$/i, '');
+    // Remove path components (keep only filename)
+    const parts = normalized.split('/');
+    if (parts.length > 1) {
+        normalized = parts[parts.length - 1];
+    }
+    // Remove multi-GGUF file patterns (e.g., "-00001-of-00003")
+    normalized = normalized.replace(/-\d{5}-of-\d{5}$/i, '');
+    // Extract version number (e.g., "3", "2.5", "4", "3.3")
+    let version = '';
+    const versionMatch = normalized.match(/^(Qwen|Llama|Ministral|Devstral|Gemma|DeepSeek|Granite|GPT-OSS)[-_]?(\d+(?:\.\d+)?)/i);
+    if (versionMatch) {
+        version = versionMatch[2];
+        normalized = normalized.replace(new RegExp(`^${versionMatch[1]}[-_]?${versionMatch[2]}`, 'i'), versionMatch[1]);
+    }
+    // Extract variant (composite or single)
+    let variant = '';
+    const compositePatterns = [
+        /-VL-Instruct$/i,
+        /-VL-Thinking$/i,
+        /-VL-Chat$/i,
+        /-VL-Coder$/i,
+        /-VL-Code$/i,
+    ];
+    for (const pattern of compositePatterns) {
+        const match = normalized.match(pattern);
+        if (match) {
+            variant = match[0].replace(/^-/i, '');
+            normalized = normalized.replace(pattern, '');
+            break;
+        }
+    }
+    if (!variant) {
+        const singlePatterns = [
+            /-Instruct$/i,
+            /-Thinking$/i,
+            /-Chat$/i,
+            /-Coder$/i,
+            /-Code$/i,
+            /-VL$/i,
+            /-Vision$/i,
+            /-Maverick$/i,
+            /-Scout$/i,
+            /-Reasoning$/i,
+        ];
+        for (const pattern of singlePatterns) {
+            const match = normalized.match(pattern);
+            if (match) {
+                variant = match[0].replace(/^-/i, '');
+                normalized = normalized.replace(pattern, '');
+                break;
+            }
+        }
+    }
+    // Remove quantization patterns (Q4_K_M, Q5_K_S, etc.)
+    normalized = normalized.replace(/[-_]Q\d+[_\w]*/i, '');
+    // Remove parameter counts (7B, 13B, 30B, etc.)
+    normalized = normalized.replace(/[-_](\d+(?:\.\d+)?[BMK])(?![0-9])/i, '');
+    // Remove expert counts (A22B, E2B, etc.)
+    normalized = normalized.replace(/[-_]([AE]\d+[BMK])/i, '');
+    normalized = normalized.replace(/[-_](\d+[AE])(?![0-9])/i, '');
+    // Remove trailing version numbers that are NOT part of the model name
+    normalized = normalized.replace(/[-_](\d{4,})$/i, ''); // Remove 4+ digit trailing numbers
+    // Normalize base name
+    const nameLower = normalized.toLowerCase();
+    let base = '';
+    if (nameLower.startsWith('qwen')) {
+        base = 'Qwen';
+    }
+    else if (nameLower.startsWith('llama') || nameLower.startsWith('meta-llama')) {
+        base = 'Llama';
+    }
+    else if (nameLower.startsWith('ministral') || nameLower.startsWith('devstral')) {
+        base = 'Ministral';
+    }
+    else if (nameLower.startsWith('gemma')) {
+        base = 'Gemma';
+    }
+    else if (nameLower.startsWith('deepseek')) {
+        base = 'DeepSeek';
+    }
+    else if (nameLower.startsWith('granite')) {
+        base = 'Granite';
+    }
+    else if (nameLower.startsWith('gpt-oss') || nameLower.startsWith('gptoss')) {
+        base = 'GPT-OSS';
+    }
+    else {
+        base = normalized.trim();
+    }
+    // Combine base + version + variant
+    let result = base;
+    if (version) {
+        result += ` ${version}`;
+    }
+    if (variant) {
+        result += `-${variant}`;
+    }
+    return result.trim();
+}
+/**
+ * Extract quantization from model name or capabilities
+ */
+function extractQuantization(capabilities) {
+    // Try to extract from model name
+    const model = capabilities.model || '';
+    // Check for quantization patterns
+    const quantPatterns = [
+        'Q3_K_S', 'Q4_K_S', 'Q5_K_S', 'Q6_K', 'Q8_0', 'Q8_K',
+        'F16', 'F32', 'BF16',
+    ];
+    for (const pattern of quantPatterns) {
+        if (model.includes(pattern)) {
+            return pattern;
+        }
+    }
+    return null;
+}
+/**
+ * Infer capabilities from model name
+ */
+function inferCapabilitiesFromModel(modelName) {
+    const name = modelName.toLowerCase();
+    const capabilities = [];
+    if (name.includes('vision') || name.includes('multimodal') || name.includes('vl-')) {
+        capabilities.push('vision');
+    }
+    if (name.includes('code') || name.includes('coder') || name.includes('starcoder')) {
+        capabilities.push('code');
+    }
+    if (name.includes('embed') || name.includes('embedding')) {
+        capabilities.push('embedding');
+    }
+    if (capabilities.length === 0) {
+        capabilities.push('chat');
+    }
+    return [...new Set(capabilities)];
+}
+/**
+ * Validate worker capabilities against policy
+ */
+/**
+ * Parse parameter count from string (e.g., "7B" -> 7e9, "30B" -> 30e9)
+ */
+function parseParameters(parameters) {
+    const match = parameters.match(/^(\d+(?:\.\d+)?)(B|M|K)$/i);
+    if (!match)
+        return 0;
+    const value = parseFloat(match[1]);
+    const unit = match[2].toUpperCase();
+    if (unit === 'B')
+        return value * 1e9;
+    if (unit === 'M')
+        return value * 1e6;
+    if (unit === 'K')
+        return value * 1e3;
+    return value;
+}
+export function validatePolicy(discoveredCapabilities, policy) {
+    const errors = [];
+    const warnings = []; // Declared but currently unused (reserved for future validation warnings)
+    // 0. Check model size limit for CPU mode (warning only - binary download already handles this)
+    // Note: This is just a warning since the policy comes from the server
+    // The actual binary selection (GPU vs CPU) happens in llama-binary.ts
+    // TODO: Add warnings here if needed in the future
+    // 1. Model name match (normalized comparison)
+    // Normalize both discovered and policy model names to base + version + variant
+    const discoveredNormalized = normalizeModelName(discoveredCapabilities.model || '');
+    const policyNormalized = normalizeModelName(policy.model_name);
+    if (discoveredNormalized !== policyNormalized) {
+        errors.push(`Model name mismatch: discovered "${discoveredCapabilities.model}" (normalized: "${discoveredNormalized}") ` +
+            `does not match policy "${policy.model_name}" (normalized: "${policyNormalized}")`);
+    }
+    // 2. Context size >= policy.context_size
+    const discoveredCtxSize = discoveredCapabilities.ctx_size || 0;
+    if (discoveredCtxSize < policy.context_size) {
+        errors.push(`Context size insufficient: discovered ${discoveredCtxSize} < required ${policy.context_size}`);
+    }
+    // 3. Quantization match (if specified in policy)
+    const discoveredQuant = extractQuantization(discoveredCapabilities);
+    if (discoveredQuant && discoveredQuant !== policy.quantization) {
+        errors.push(`Quantization mismatch: discovered "${discoveredQuant}" does not match policy "${policy.quantization}"`);
+    }
+    // 4. Capabilities match (worker must have all required capabilities)
+    const discoveredCaps = inferCapabilitiesFromModel(discoveredCapabilities.model || '');
+    const missingCaps = policy.capabilities.filter((requiredCap) => !discoveredCaps.includes(requiredCap));
+    if (missingCaps.length > 0) {
+        errors.push(`Missing required capabilities: ${missingCaps.join(', ')}. ` +
+            `Discovered: ${discoveredCaps.join(', ')}. ` +
+            `Required: ${policy.capabilities.join(', ')}`);
+    }
+    // 5. Parameters match (if specified in policy)
+    if (policy.parameters) {
+        const discoveredParams = discoveredCapabilities.parameters;
+        if (discoveredParams && discoveredParams !== policy.parameters) {
+            errors.push(`Parameters mismatch: discovered "${discoveredParams}" does not match policy "${policy.parameters}"`);
+        }
+    }
+    // 6. Family match (if specified in policy)
+    if (policy.family) {
+        // Infer family from model name or capabilities
+        // MoE models have:
+        // 1. "MoE" or "mixture-of-experts" in name
+        // 2. Expert notation like "A22B", "E22B" (e.g., "235B-A22B" = 235B total, 22B experts)
+        // 3. Multiple parameter counts separated by dashes (total-expert pattern)
+        const modelName = (discoveredCapabilities.model || '').toLowerCase();
+        // Check for explicit MoE indicators
+        const hasMoEKeyword = modelName.includes('moe') || modelName.includes('mixture-of-experts');
+        // Check for expert notation (A22B, E22B, etc.)
+        const hasExpertNotation = /[ae]\d+[bmk]/i.test(modelName);
+        // Check for total-expert parameter pattern (e.g., "235B-A22B", "70B-E2B")
+        const hasTotalExpertPattern = /\d+[bmk]-[ae]\d+[bmk]/i.test(modelName);
+        // Check for multiple large parameter counts separated by dashes
+        const paramPatterns = modelName.match(/\d+[bmk]/gi) || [];
+        const hasMultipleLargeParams = paramPatterns.length >= 2 &&
+            paramPatterns.some(p => /^(\d{2,}|[0-9]+0)[bmk]$/i.test(p)); // 2+ digits or ends in 0
+        const isMoE = hasMoEKeyword || hasExpertNotation || hasTotalExpertPattern || hasMultipleLargeParams;
+        const discoveredFamily = isMoE ? 'MoE' : 'Dense';
+        if (discoveredFamily !== policy.family) {
+            errors.push(`Family mismatch: discovered "${discoveredFamily}" does not match policy "${policy.family}". ` +
+                `Model name: "${discoveredCapabilities.model}"`);
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings: warnings.length > 0 ? warnings : undefined,
+    };
+}

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for worker CLI
+ */
+export {};

package/dist/websocket.js

@@ -0,0 +1,433 @@
+/**
+ * WebSocket Connection Manager
+ *
+ * Handles connection to Auxot WebSocket server with:
+ * - Hello handshake
+ * - Heartbeat keepalive
+ * - Job message handling
+ * - Automatic reconnection with exponential backoff
+ */
+import WebSocket from 'ws';
+import { logServerToClient, logClientToServer } from './debug.js';
+import { validatePolicy } from './policy-validator.js';
+const HEARTBEAT_INTERVAL = 5000; // 5 seconds
+const INITIAL_RETRY_DELAY = 1000; // 1 second
+const MAX_RETRY_DELAY = 60000; // 60 seconds
+const RETRY_MULTIPLIER = 2; // Exponential backoff multiplier
+export class WebSocketConnection {
+    ws = null;
+    heartbeatTimer = null;
+    reconnectTimer = null;
+    gpuKey;
+    capabilities;
+    onJobCallback = null;
+    onCancelCallback = null;
+    onPolicyCallback = null;
+    onConfigAckCallback = null;
+    wsUrl = '';
+    retryDelay = INITIAL_RETRY_DELAY;
+    isConnected = false;
+    shouldReconnect = true;
+    isReconnecting = false;
+    policy = null;
+    constructor(gpuKey, capabilities) {
+        this.gpuKey = gpuKey;
+        this.capabilities = capabilities;
+    }
+    /**
+     * Connect to WebSocket server and send hello message
+     */
+    async connect(wsUrl) {
+        this.wsUrl = wsUrl;
+        this.shouldReconnect = true;
+        return this.attemptConnection();
+    }
+    /**
+     * Attempt to establish WebSocket connection
+     */
+    async attemptConnection() {
+        return new Promise((resolve, reject) => {
+            if (!this.wsUrl) {
+                reject(new Error('No WebSocket URL configured'));
+                return;
+            }
+            // Only log if not already reconnecting (first attempt or successful reconnection)
+            if (!this.isReconnecting) {
+                console.log(`Connecting to ${this.wsUrl}...`);
+            }
+            try {
+                this.ws = new WebSocket(this.wsUrl);
+            }
+            catch (error) {
+                this.scheduleReconnect();
+                reject(error);
+                return;
+            }
+            // Set a connection timeout
+            const connectionTimeout = setTimeout(() => {
+                if (!this.isConnected) {
+                    this.ws?.close();
+                    this.scheduleReconnect();
+                    reject(new Error('Connection timeout'));
+                }
+            }, 10000);
+            this.ws.on('open', () => {
+                // Send hello message (server will assign GPU ID)
+                const helloMsg = {
+                    type: 'hello',
+                    gpu_key: this.gpuKey,
+                    capabilities: this.capabilities,
+                };
+                this.send(helloMsg);
+            });
+            this.ws.on('message', async (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    // Debug log (skip heartbeat_ack to reduce noise)
+                    if (message.type !== 'heartbeat_ack') {
+                        logServerToClient(message);
+                    }
+                    if (message.type === 'hello_ack') {
+                        clearTimeout(connectionTimeout);
+                        if (message.success) {
+                            // Store policy from server
+                            if (!message.policy) {
+                                const errorMsg = 'Server did not send policy in hello_ack';
+                                console.error(`✗ ${errorMsg}`);
+                                this.shouldReconnect = false;
+                                this.ws?.close();
+                                reject(new Error(errorMsg));
+                                return;
+                            }
+                            this.policy = message.policy;
+                            // If policy callback is registered, defer validation (will validate via config message after spawning llama.cpp)
+                            if (this.onPolicyCallback) {
+                                // Spawn llama.cpp and discover capabilities (validation will happen via config message)
+                                try {
+                                    await this.onPolicyCallback(message.policy);
+                                }
+                                catch (error) {
+                                    console.error('[Policy Callback] Error:', error);
+                                    this.shouldReconnect = false;
+                                    this.ws?.close();
+                                    reject(error);
+                                    return;
+                                }
+                                // Validation deferred - will happen via config message
+                                // Connection is established but validation happens later
+                                console.log('✓ Successfully authenticated with server');
+                                console.log(`  Policy: ${message.policy.model_name} (${message.policy.quantization})`);
+                                console.log('  Spawning llama.cpp process...');
+                                console.log('  (Capabilities validation will happen via config message)');
+                            }
+                            else {
+                                // No policy callback - validate immediately (legacy flow)
+                                const validation = await validatePolicy(this.capabilities, message.policy);
+                                // Log warnings if any
+                                if (validation.warnings && validation.warnings.length > 0) {
+                                    console.warn('⚠ Policy validation warnings:');
+                                    validation.warnings.forEach((warning) => {
+                                        console.warn(`  - ${warning}`);
+                                    });
+                                }
+                                if (!validation.valid) {
+                                    console.error('✗ Policy validation failed:');
+                                    console.error('  Expected:');
+                                    console.error(`    Model: ${message.policy.model_name}`);
+                                    console.error(`    Quantization: ${message.policy.quantization}`);
+                                    console.error(`    Context Size: ${message.policy.context_size}`);
+                                    console.error(`    Capabilities: ${message.policy.capabilities.join(', ')}`);
+                                    if (message.policy.parameters) {
+                                        console.error(`    Parameters: ${message.policy.parameters}`);
+                                    }
+                                    if (message.policy.family) {
+                                        console.error(`    Family: ${message.policy.family}`);
+                                    }
+                                    console.error('  Discovered:');
+                                    console.error(`    Model: ${this.capabilities.model}`);
+                                    console.error(`    Context Size: ${this.capabilities.ctx_size}`);
+                                    if (this.capabilities.parameters) {
+                                        console.error(`    Parameters: ${this.capabilities.parameters}`);
+                                    }
+                                    console.error('  Errors:');
+                                    validation.errors.forEach((error) => {
+                                        console.error(`    - ${error}`);
+                                    });
+                                    console.error('\nPlease configure your llama.cpp server to match the policy requirements.');
+                                    this.shouldReconnect = false;
+                                    this.ws?.close();
+                                    reject(new Error(`Policy validation failed: ${validation.errors.join('; ')}`));
+                                    return;
+                                }
+                                console.log('✓ Successfully authenticated with server');
+                                console.log(`  Policy: ${message.policy.model_name} (${message.policy.quantization})`);
+                                console.log('✓ Capabilities validated against policy');
+                            }
+                            this.isConnected = true;
+                            this.isReconnecting = false;
+                            this.retryDelay = INITIAL_RETRY_DELAY; // Reset retry delay on success
+                            this.startHeartbeat();
+                            resolve();
+                        }
+                        else {
+                            // Check if there's a reconnect_in_seconds field (duplicate connection)
+                            const errorMessage = message.error || 'Authentication failed';
+                            if (message.reconnect_in_seconds || message.reconnectInSeconds) {
+                                const reconnectIn = message.reconnect_in_seconds || message.reconnectInSeconds;
+                                console.error(`✗ Worker UUID already connected! Are you trying to connect the same worker ID twice?`);
+                                console.error(`   The existing connection's presence key expires in ${reconnectIn} seconds.`);
+                                console.error(`   Waiting ${reconnectIn} seconds and retrying automatically...`);
+                                // Close connection and schedule reconnect (do NOT reject - let retry handle it)
+                                this.ws?.close();
+                                // Wait for the specified time before reconnecting
+                                this.retryDelay = Math.max(reconnectIn * 1000, INITIAL_RETRY_DELAY);
+                                this.scheduleReconnect();
+                                // Resolve instead of reject - this allows the app to continue with auto-retry
+                                resolve();
+                            }
+                            else {
+                                // Authentication errors (invalid key, key not found, etc.) are fatal - stop retrying
+                                console.error('✗ Authentication failed:', errorMessage);
+                                console.error('   Fatal error: Stopping retry attempts. Please check your GPU key and try again.');
+                                // Stop retrying for authentication errors
+                                this.shouldReconnect = false;
+                                this.ws?.close();
+                                // Don't schedule reconnect - this is a fatal error
+                                reject(new Error(errorMessage));
+                            }
+                        }
+                    }
+                    else if (message.type === 'config_ack') {
+                        // Config acknowledged (validation happened on server)
+                        if (this.onConfigAckCallback) {
+                            this.onConfigAckCallback(message.success, message.error);
+                        }
+                        else {
+                            // Fallback: log and handle errors
+                            if (message.success) {
+                                console.log('✓ Capabilities validated by server');
+                            }
+                            else {
+                                console.error(`✗ Config validation failed: ${message.error}`);
+                                this.shouldReconnect = false;
+                                this.ws?.close();
+                            }
+                        }
+                    }
+                    else if (message.type === 'heartbeat_ack') {
+                        // Heartbeat acknowledged (silent)
+                    }
+                    else if (message.type === 'cancel') {
+                        // Cancel message
+                        console.log(`Received cancel request for job ${message.job_id}`);
+                        if (this.onCancelCallback) {
+                            this.onCancelCallback(message);
+                        }
+                        else {
+                            console.warn('No cancel callback registered!');
+                        }
+                    }
+                    else if (message.type === 'job') {
+                        // Job received
+                        console.log(`Received job ${message.job_id}`);
+                        if (this.onJobCallback) {
+                            this.onJobCallback(message).catch((err) => {
+                                console.error('Error processing job:', err);
+                                this.sendError(message.job_id, err.message);
+                            });
+                        }
+                        else {
+                            console.warn('No job callback registered!');
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error('Error parsing message:', error);
+                }
+            });
+            this.ws.on('error', (error) => {
+                clearTimeout(connectionTimeout);
+                // Silently handle connection errors during reconnection
+            });
+            this.ws.on('close', (code, reason) => {
+                clearTimeout(connectionTimeout);
+                this.isConnected = false;
+                this.stopHeartbeat();
+                if (this.shouldReconnect) {
+                    if (!this.isReconnecting) {
+                        console.log('WebSocket disconnected, will continue to retry...');
+                        this.isReconnecting = true;
+                    }
+                    this.scheduleReconnect();
+                }
+                else {
+                    console.log('WebSocket disconnected');
+                }
+            });
+        });
+    }
+    /**
+     * Schedule reconnection with exponential backoff
+     */
+    scheduleReconnect() {
+        if (this.reconnectTimer || !this.shouldReconnect) {
+            return;
+        }
+        this.reconnectTimer = setTimeout(async () => {
+            this.reconnectTimer = null;
+            try {
+                await this.attemptConnection();
+            }
+            catch (error) {
+                // Connection failed, exponential backoff will continue (silently)
+                this.retryDelay = Math.min(this.retryDelay * RETRY_MULTIPLIER, MAX_RETRY_DELAY);
+            }
+        }, this.retryDelay);
+    }
+    /**
+     * Start sending heartbeat messages
+     */
+    startHeartbeat() {
+        this.stopHeartbeat(); // Clear any existing timer
+        this.heartbeatTimer = setInterval(() => {
+            if (this.isConnected) {
+                const heartbeatMsg = {
+                    type: 'heartbeat',
+                    // Server identifies worker by WebSocket connection, not GPU ID
+                };
+                this.send(heartbeatMsg);
+            }
+        }, HEARTBEAT_INTERVAL);
+    }
+    /**
+     * Stop heartbeat timer
+     */
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    /**
+     * Send message to server
+     */
+    send(message) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            const jsonString = JSON.stringify(message);
+            // Debug log (skip heartbeats to reduce noise)
+            if (message.type !== 'heartbeat') {
+                logClientToServer(message);
+            }
+            this.ws.send(jsonString);
+        }
+    }
+    /**
+     * Send token to server
+     */
+    sendToken(jobId, token) {
+        this.send({
+            type: 'token',
+            job_id: jobId,
+            token,
+        });
+    }
+    /**
+     * Send completion to server with metadata
+     */
+    sendComplete(jobId, fullResponse, durationMs, inputTokens, outputTokens, toolCalls) {
+        this.send({
+            type: 'complete',
+            job_id: jobId,
+            full_response: fullResponse,
+            duration_ms: durationMs,
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            tool_calls: toolCalls,
+        });
+    }
+    /**
+     * Send error to server
+     */
+    sendError(jobId, error) {
+        this.send({
+            type: 'error',
+            job_id: jobId,
+            error,
+        });
+    }
+    /**
+     * Register callback for job messages
+     */
+    onJob(callback) {
+        this.onJobCallback = callback;
+    }
+    /**
+     * Register callback for cancel messages
+     */
+    onCancel(callback) {
+        this.onCancelCallback = callback;
+    }
+    /**
+     * Register callback for policy (called when policy is received in hello_ack)
+     * Used to spawn llama.cpp process before validation
+     */
+    onPolicy(callback) {
+        this.onPolicyCallback = callback;
+    }
+    /**
+     * Register callback for config_ack (called when server validates our config)
+     */
+    onConfigAck(callback) {
+        this.onConfigAckCallback = callback;
+    }
+    /**
+     * Update capabilities (called after spawning llama.cpp)
+     */
+    updateCapabilities(capabilities) {
+        this.capabilities = capabilities;
+    }
+    /**
+     * Send config message to server (called after discovering capabilities)
+     */
+    sendConfig(capabilities) {
+        this.send({
+            type: 'config',
+            capabilities,
+        });
+    }
+    /**
+     * Check if connected
+     */
+    get connected() {
+        return this.isConnected;
+    }
+    /**
+     * Get policy received from server
+     */
+    getPolicy() {
+        return this.policy;
+    }
+    /**
+     * Get current capabilities
+     */
+    getCapabilities() {
+        return this.capabilities;
+    }
+    /**
+     * Close connection
+     */
+    close() {
+        this.shouldReconnect = false;
+        this.stopHeartbeat();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.isConnected = false;
+        this.policy = null; // Clear policy on disconnect
+    }
+}