@mxf-dev/core 1.0.0

package/dist/config/ConfigManager.js

@@ -0,0 +1,814 @@
+/**
+ * Copyright 2024 Brad Anderson
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @author Brad Anderson <BradA1878@pm.me>
+ * @repository https://github.com/mxf-dev/mxf
+ * @documentation https://mxf-dev.github.io/mxf/
+ */
+/**
+ * SDK Configuration Framework
+ *
+ * Provides a comprehensive configuration system for feature toggles and LLM selection.
+ * Enables dynamic configuration of agent behaviors and capabilities.
+ */
+import { Observable, from } from 'rxjs';
+import { Logger } from '../utils/Logger.js';
+import { EventBus } from '../events/EventBus.js';
+import { createBaseEventPayload } from '../schemas/EventPayloadSchema.js';
+/**
+ * Default SDK configuration
+ */
+const DEFAULT_CONFIG = {
+    version: '1.0.0',
+    llmModels: [
+        {
+            id: 'claude-3-opus-20240229',
+            name: 'Claude 3 Opus',
+            providerType: 'anthropic',
+            version: '1.0',
+            contextWindow: 200000,
+            defaultParameters: {
+                temperature: 0.7,
+                maxTokens: 4096
+            },
+            features: ['MCP', 'tool_use', 'binary_protocol']
+        },
+        {
+            id: 'gpt-4-turbo',
+            name: 'GPT-4 Turbo',
+            providerType: 'openai',
+            version: '1.0',
+            contextWindow: 128000,
+            defaultParameters: {
+                temperature: 0.7,
+                maxTokens: 4096
+            },
+            features: ['tool_use', 'binary_protocol']
+        }
+    ],
+    defaultLlmModel: 'claude-3-opus-20240229',
+    features: {
+        'binary_protocol': {
+            key: 'binary_protocol',
+            name: 'Model Excahnge Protocol (MXP)',
+            description: 'Uses binary message format for efficient agent communication',
+            enabled: true,
+            defaultValue: true
+        },
+        'control_loop': {
+            key: 'control_loop',
+            name: 'Control Loop',
+            description: 'Enables structured decision-making within agents',
+            enabled: true,
+            defaultValue: true
+        },
+        'memory_system': {
+            key: 'memory_system',
+            name: 'Memory System',
+            description: 'Provides persistent storage at agent, channel, and shared levels',
+            enabled: true,
+            defaultValue: true
+        },
+        'self_reflection': {
+            key: 'self_reflection',
+            name: 'Self Reflection',
+            description: 'Enhances decision quality through feedback loops with reinforcement learning',
+            enabled: true,
+            defaultValue: true,
+            requires: ['memory_system']
+        },
+        'agent_specialization': {
+            key: 'agent_specialization',
+            name: 'Agent Specialization',
+            description: 'Defines agent capabilities and expertise',
+            enabled: true,
+            defaultValue: true
+        },
+        'channel_context': {
+            key: 'channel_context',
+            name: 'Channel Context',
+            description: 'Provides semantic framework for agent interactions',
+            enabled: true,
+            defaultValue: true
+        },
+        'mcp_integration': {
+            key: 'mcp_integration',
+            name: 'MCP Integration',
+            description: 'Integrates with Anthropic MCP for LLM-to-tool interactions',
+            enabled: true,
+            defaultValue: true
+        },
+        'reinforcement_learning': {
+            key: 'reinforcement_learning',
+            name: 'Reinforcement Learning',
+            description: 'Server-side neural network integration using Brain.js',
+            enabled: false,
+            defaultValue: false,
+            requires: ['self_reflection'],
+            parameters: {
+                learningRate: 0.01,
+                networkType: 'feedforward',
+                hiddenLayers: [8, 8]
+            }
+        },
+        'transitional_intelligence': {
+            key: 'transitional_intelligence',
+            name: 'Transitional Intelligence',
+            description: 'Augments core control loop with specialized LLMs',
+            enabled: false,
+            defaultValue: false,
+            requires: ['control_loop']
+        },
+        'tool_selection_optimization': {
+            key: 'tool_selection_optimization',
+            name: 'Tool Selection Optimization',
+            description: 'Intelligently pre-filters tools to optimize context usage',
+            enabled: false,
+            defaultValue: false
+        }
+    },
+    parameters: {
+        agentConnectTimeout: 30000,
+        messageRetryCount: 3,
+        messageRetryDelay: 1000,
+        logLevel: 'info'
+    },
+    agentTypes: {
+        supportedRoles: ['consumer', 'provider', 'admin'],
+        defaultRole: 'consumer',
+        supportedServiceTypes: [
+            'assistant', // General assistant agents
+            'specialist', // Domain-specific expert agents
+            'coordinator', // Multi-agent coordination
+            'memory', // Memory management agents
+            'tool_provider', // Tool execution providers
+            'data_processor', // Data processing specialists
+            'workflow_manager', // Workflow orchestration
+            'monitoring', // System monitoring agents
+            'integration' // External system integration
+        ],
+        supportedSpecializations: [
+            // General specializations
+            'general_assistant',
+            'task_coordinator',
+            'workflow_optimizer',
+            // Technical specializations
+            'code_assistant',
+            'data_analyst',
+            'system_monitor',
+            'integration_specialist',
+            // Domain-specific specializations
+            'research',
+            'analysis',
+            'communication',
+            'documentation',
+            // Advanced specializations
+            'pattern_recognition',
+            'performance_optimization',
+            'error_recovery',
+            'multi_agent_coordination'
+        ],
+        capabilityMapping: {
+            'assistant': ['conversation', 'task_execution', 'tool_use'],
+            'specialist': ['domain_expertise', 'advanced_reasoning', 'specialized_tools'],
+            'coordinator': ['multi_agent_communication', 'task_delegation', 'workflow_management'],
+            'memory': ['data_storage', 'pattern_recognition', 'context_management'],
+            'tool_provider': ['tool_execution', 'external_integration', 'resource_management'],
+            'data_processor': ['data_analysis', 'transformation', 'aggregation'],
+            'workflow_manager': ['process_orchestration', 'dependency_management', 'scheduling'],
+            'monitoring': ['system_observation', 'performance_tracking', 'alerting'],
+            'integration': ['external_api_access', 'protocol_translation', 'data_synchronization']
+        },
+        rolePermissions: {
+            'consumer': ['read_channel', 'send_message', 'use_tools'],
+            'provider': ['read_channel', 'send_message', 'use_tools', 'provide_tools', 'coordinate_agents'],
+            'admin': ['read_channel', 'send_message', 'use_tools', 'provide_tools', 'coordinate_agents', 'manage_channel', 'system_admin']
+        }
+    },
+    channelSystemLlm: {
+        enabled: true,
+        operationOverrides: {}
+    },
+    environment: {
+        name: 'development'
+    }
+};
+/**
+ * Configuration event types
+ */
+export const ConfigEvents = {
+    /**
+     * Config updated event
+     */
+    CONFIG_UPDATED: 'config:updated',
+    /**
+     * Feature state changed event
+     */
+    FEATURE_STATE_CHANGED: 'config:feature_state_changed',
+    /**
+     * LLM model changed event
+     */
+    LLM_MODEL_CHANGED: 'config:llm_model_changed',
+    /**
+     * Channel SystemLLM state changed event
+     */
+    CHANNEL_SYSTEM_LLM_CHANGED: 'config:channel_system_llm_changed',
+};
+/**
+ * Configuration manager implementation
+ */
+export class ConfigManager {
+    // Current configuration
+    config;
+    // Logger instance for ConfigManager
+    logger;
+    // Singleton instance
+    static instance;
+    /**
+     * Get the singleton instance
+     */
+    static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    /**
+     * Private constructor to prevent direct instantiation
+     * Use ConfigManager.getInstance() instead
+     */
+    constructor() {
+        // Initialize with default configuration
+        this.config = {
+            ...DEFAULT_CONFIG,
+            channelSystemLlmById: new Map()
+        };
+        // Initialize logger with proper component name
+        this.logger = new Logger('info', 'ConfigManager', 'client');
+    }
+    /**
+     * Get the current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Get the configuration as an observable
+     */
+    getConfigObservable() {
+        // Create an Observable that subscribes to the EventBus config update event
+        return new Observable(observer => {
+            // Immediately emit the current configuration
+            observer.next({ ...this.config });
+            // Set up event listener for future updates
+            const handler = (event) => {
+                observer.next({ ...event.config });
+            };
+            // Subscribe to the event
+            EventBus.client.on(ConfigEvents.CONFIG_UPDATED, handler);
+            // Return cleanup function
+            return () => {
+                // Remove the event listener when Observable is unsubscribed
+                EventBus.client.off(ConfigEvents.CONFIG_UPDATED, handler);
+            };
+        });
+    }
+    /**
+     * Load configuration from a file
+     * @param filePath - Path to configuration file
+     */
+    loadConfigFromFile(filePath) {
+        // In a browser environment, we would use fetch
+        // In Node.js, we would use fs.readFile
+        // This is a simplified implementation that assumes we're in a Node.js environment
+        try {
+            // Note: In a real implementation, this would be asynchronous
+            // For now, we'll just return the current config
+            this.logger.warn(`loadConfigFromFile not fully implemented. File path: ${filePath}`);
+            return from(Promise.resolve(this.config));
+        }
+        catch (error) {
+            this.logger.error(`Failed to load configuration from file: ${error}`);
+            return from(Promise.resolve(this.config));
+        }
+    }
+    /**
+     * Load configuration from an object
+     * @param config - Configuration object
+     */
+    loadConfig(config) {
+        // Merge with default configuration
+        this.config = this.mergeConfigs(DEFAULT_CONFIG, config);
+        // Validate configuration
+        this.validateConfig();
+        // Emit configuration update event
+        this.emitConfigUpdated(['all']);
+        return from(Promise.resolve(this.config));
+    }
+    /**
+     * Update configuration
+     * @param updates - Configuration updates
+     */
+    updateConfig(updates) {
+        // Capture updated properties for the event
+        const updatedProps = Object.keys(updates);
+        // Merge with current configuration
+        this.config = this.mergeConfigs(this.config, updates);
+        // Validate configuration
+        this.validateConfig();
+        // Emit configuration update event
+        this.emitConfigUpdated(updatedProps);
+        return from(Promise.resolve(this.config));
+    }
+    /**
+     * Check if a feature is enabled
+     * @param featureKey - Feature key
+     */
+    isFeatureEnabled(featureKey) {
+        const feature = this.config.features[featureKey];
+        if (!feature) {
+            // Feature not found
+            return false;
+        }
+        if (feature.requires) {
+            // Check if required features are enabled
+            for (const requiredFeature of feature.requires) {
+                if (!this.isFeatureEnabled(requiredFeature)) {
+                    // Required feature is not enabled
+                    return false;
+                }
+            }
+        }
+        return feature.enabled;
+    }
+    /**
+     * Get feature toggle by key
+     * @param featureKey - Feature key
+     */
+    getFeature(featureKey) {
+        const feature = this.config.features[featureKey];
+        if (!feature) {
+            return null;
+        }
+        return { ...feature };
+    }
+    /**
+     * Enable a feature
+     * @param featureKey - Feature key
+     */
+    enableFeature(featureKey) {
+        const feature = this.config.features[featureKey];
+        if (!feature) {
+            return from(Promise.resolve(false));
+        }
+        if (feature.enabled) {
+            return from(Promise.resolve(true));
+        }
+        // Enable feature
+        feature.enabled = true;
+        // Track affected features for the event
+        const affectedFeatures = [];
+        // Check if dependencies need to be enabled
+        if (feature.requires) {
+            for (const requiredFeature of feature.requires) {
+                if (!this.isFeatureEnabled(requiredFeature)) {
+                    this.enableFeature(requiredFeature);
+                    affectedFeatures.push(requiredFeature);
+                }
+            }
+        }
+        // Emit feature state change event
+        this.emitFeatureStateChanged(featureKey, true, affectedFeatures);
+        // Also emit general config update
+        this.emitConfigUpdated(['features']);
+        return from(Promise.resolve(true));
+    }
+    /**
+     * Disable a feature
+     * @param featureKey - Feature key
+     */
+    disableFeature(featureKey) {
+        const feature = this.config.features[featureKey];
+        if (!feature) {
+            return from(Promise.resolve(false));
+        }
+        // Disable feature
+        feature.enabled = false;
+        // Track affected features for the event
+        const affectedFeatures = [];
+        // Check if other features depend on this one
+        for (const [key, otherFeature] of Object.entries(this.config.features)) {
+            if (otherFeature.requires && otherFeature.requires.includes(featureKey) && otherFeature.enabled) {
+                // Disable dependent feature
+                this.disableFeature(key);
+                affectedFeatures.push(key);
+            }
+        }
+        // Emit feature state change event
+        this.emitFeatureStateChanged(featureKey, false, affectedFeatures);
+        // Also emit general config update
+        this.emitConfigUpdated(['features']);
+        return from(Promise.resolve(true));
+    }
+    /**
+     * Get LLM model configuration
+     * @param modelId - Model ID (optional, returns default if not specified)
+     */
+    getLlmModel(modelId) {
+        const id = modelId || this.config.defaultLlmModel;
+        const model = this.config.llmModels.find(m => m.id === id);
+        if (!model) {
+            return null;
+        }
+        return { ...model };
+    }
+    /**
+     * Set default LLM model
+     * @param modelId - Model ID
+     */
+    setDefaultLlmModel(modelId) {
+        const model = this.getLlmModel(modelId);
+        if (!model) {
+            return from(Promise.resolve(false));
+        }
+        const previousModelId = this.config.defaultLlmModel;
+        // Update default model
+        this.config.defaultLlmModel = modelId;
+        // Emit LLM model change event
+        this.emitLlmModelChanged(previousModelId, modelId);
+        // Also emit general config update
+        this.emitConfigUpdated(['defaultLlmModel']);
+        return from(Promise.resolve(true));
+    }
+    /**
+     * Get parameter value
+     * @param key - Parameter key
+     * @param defaultValue - Default value if parameter not found
+     */
+    getParameter(key, defaultValue) {
+        const value = this.config.parameters[key];
+        if (value === undefined) {
+            return defaultValue;
+        }
+        return value;
+    }
+    /**
+     * Set parameter value
+     * @param key - Parameter key
+     * @param value - Parameter value
+     */
+    setParameter(key, value) {
+        // Set parameter
+        this.config.parameters[key] = value;
+        // Emit configuration update event
+        this.emitConfigUpdated(['parameters']);
+        return from(Promise.resolve(true));
+    }
+    /**
+     * Get supported agent roles
+     */
+    getSupportedAgentRoles() {
+        return this.config.agentTypes.supportedRoles;
+    }
+    /**
+     * Get default agent role
+     */
+    getDefaultAgentRole() {
+        return this.config.agentTypes.defaultRole;
+    }
+    /**
+     * Get supported service types
+     */
+    getSupportedServiceTypes() {
+        return this.config.agentTypes.supportedServiceTypes;
+    }
+    /**
+     * Get supported agent specializations
+     */
+    getSupportedSpecializations() {
+        return this.config.agentTypes.supportedSpecializations;
+    }
+    /**
+     * Get agent capabilities for a service type
+     * @param serviceType - Service type
+     */
+    getAgentCapabilities(serviceType) {
+        return this.config.agentTypes.capabilityMapping[serviceType] || [];
+    }
+    /**
+     * Get role permissions
+     * @param role - Agent role
+     */
+    getRolePermissions(role) {
+        return this.config.agentTypes.rolePermissions[role] || [];
+    }
+    /**
+     * Validate agent configuration
+     * @param role - Agent role
+     * @param serviceTypes - Service types
+     * @param specialization - Agent specialization
+     */
+    validateAgentConfig(role, serviceTypes, specialization) {
+        // Check if role is supported
+        if (!this.config.agentTypes.supportedRoles.includes(role)) {
+            return false;
+        }
+        // Check if service types are supported
+        for (const serviceType of serviceTypes) {
+            if (!this.config.agentTypes.supportedServiceTypes.includes(serviceType)) {
+                return false;
+            }
+        }
+        // Check if specialization is supported (if provided)
+        if (specialization && !this.config.agentTypes.supportedSpecializations.includes(specialization)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Get recommended capabilities for agent configuration
+     * @param serviceTypes - Service types
+     * @param specialization - Agent specialization
+     */
+    getRecommendedCapabilities(serviceTypes, specialization) {
+        const recommendedCapabilities = [];
+        // Get capabilities for each service type
+        for (const serviceType of serviceTypes) {
+            recommendedCapabilities.push(...this.getAgentCapabilities(serviceType));
+        }
+        // If specialization is provided, add its capabilities
+        if (specialization) {
+            // For now, assume specialization capabilities are the same as service type capabilities
+            // In the future, we can add more complex logic to determine specialization capabilities
+            recommendedCapabilities.push(...this.getAgentCapabilities(specialization));
+        }
+        return recommendedCapabilities;
+    }
+    /**
+     * Check if SystemLLM is enabled for the channel
+     * @param channelId - Optional channel ID to check (if not provided, checks global)
+     * @param operationType - Optional specific operation to check
+     */
+    isChannelSystemLlmEnabled(channelId, operationType) {
+        // If channelId provided, check channel-specific config first
+        if (channelId && this.config.channelSystemLlmById) {
+            const channelConfig = this.config.channelSystemLlmById.get(channelId);
+            if (channelConfig) {
+                // Channel has specific config, use it
+                if (!channelConfig.enabled) {
+                    return false;
+                }
+                // Check operation-specific override for this channel
+                if (operationType && channelConfig.operationOverrides) {
+                    const opValue = channelConfig.operationOverrides[operationType];
+                    return opValue ?? true;
+                }
+                return true;
+            }
+        }
+        // Fall back to global channel setting
+        if (!this.config.channelSystemLlm.enabled) {
+            return false;
+        }
+        // If no operation type specified, return global setting
+        if (!operationType) {
+            return true;
+        }
+        // Check for global operation-specific override
+        const overrides = this.config.channelSystemLlm.operationOverrides;
+        if (overrides && operationType in overrides) {
+            return overrides[operationType] ?? true;
+        }
+        // Default to global setting
+        return true;
+    }
+    /**
+     * Get channel SystemLLM configuration
+     */
+    getChannelSystemLlmConfig() {
+        return { ...this.config.channelSystemLlm };
+    }
+    /**
+     * Set channel SystemLLM enabled state
+     * @param enabled - Whether to enable SystemLLM
+     * @param channelId - Optional channel ID (if not provided, sets global)
+     * @param reason - Optional reason for the change
+     */
+    setChannelSystemLlmEnabled(enabled, channelId, reason) {
+        if (channelId) {
+            // Set channel-specific configuration
+            if (!this.config.channelSystemLlmById) {
+                this.config.channelSystemLlmById = new Map();
+            }
+            const existingConfig = this.config.channelSystemLlmById.get(channelId) || {};
+            this.config.channelSystemLlmById.set(channelId, {
+                ...existingConfig,
+                enabled,
+                disabledReason: enabled ? undefined : reason
+            });
+        }
+        else {
+            // Update global configuration
+            this.config.channelSystemLlm.enabled = enabled;
+            if (reason) {
+                this.config.channelSystemLlm.disabledReason = enabled ? undefined : reason;
+            }
+        }
+        // Emit channel SystemLLM change event
+        this.emitChannelSystemLlmChanged(enabled, reason, undefined, channelId);
+        // Also emit general config update
+        this.emitConfigUpdated(['channelSystemLlm']);
+        return from(Promise.resolve(true));
+    }
+    /**
+     * Set channel SystemLLM operation override
+     * @param operation - Operation name
+     * @param enabled - Whether to enable for this operation
+     * @param channelId - Optional channel ID (if not provided, sets global)
+     */
+    setChannelSystemLlmOperationOverride(operation, enabled, channelId) {
+        if (channelId) {
+            // Set channel-specific operation override
+            if (!this.config.channelSystemLlmById) {
+                this.config.channelSystemLlmById = new Map();
+            }
+            const existingConfig = this.config.channelSystemLlmById.get(channelId) || { enabled: true };
+            if (!existingConfig.operationOverrides) {
+                existingConfig.operationOverrides = {};
+            }
+            existingConfig.operationOverrides[operation] = enabled;
+            this.config.channelSystemLlmById.set(channelId, existingConfig);
+            // Emit with channel-specific overrides
+            this.emitChannelSystemLlmChanged(existingConfig.enabled, undefined, existingConfig.operationOverrides, channelId);
+        }
+        else {
+            // Set global operation override
+            if (!this.config.channelSystemLlm.operationOverrides) {
+                this.config.channelSystemLlm.operationOverrides = {};
+            }
+            this.config.channelSystemLlm.operationOverrides[operation] = enabled;
+            // Emit with global overrides
+            this.emitChannelSystemLlmChanged(this.config.channelSystemLlm.enabled, undefined, this.config.channelSystemLlm.operationOverrides, undefined);
+        }
+        // Also emit general config update
+        this.emitConfigUpdated(['channelSystemLlm']);
+        return from(Promise.resolve(true));
+    }
+    /**
+     * Merge configurations
+     * @param baseConfig - Base configuration
+     * @param overrides - Configuration overrides
+     * @private
+     */
+    mergeConfigs(baseConfig, overrides) {
+        const merged = { ...baseConfig };
+        // Merge top-level properties
+        for (const [key, value] of Object.entries(overrides)) {
+            if (key === 'features' || key === 'parameters') {
+                // Skip these for now, will handle separately
+                continue;
+            }
+            if (key === 'llmModels' && Array.isArray(value)) {
+                // Replace LLM models
+                merged.llmModels = [...value];
+                continue;
+            }
+            // @ts-ignore: Dynamic property assignment
+            merged[key] = value;
+        }
+        // Merge features
+        if (overrides.features) {
+            for (const [key, feature] of Object.entries(overrides.features)) {
+                merged.features[key] = {
+                    ...merged.features[key],
+                    ...feature
+                };
+            }
+        }
+        // Merge parameters
+        if (overrides.parameters) {
+            merged.parameters = {
+                ...merged.parameters,
+                ...overrides.parameters
+            };
+        }
+        return merged;
+    }
+    /**
+     * Validate configuration
+     * @private
+     */
+    validateConfig() {
+        // Check if default LLM model exists
+        const defaultModel = this.config.llmModels.find(m => m.id === this.config.defaultLlmModel);
+        if (!defaultModel) {
+            this.logger.warn(`Default LLM model '${this.config.defaultLlmModel}' not found. Using first available model.`);
+            if (this.config.llmModels.length > 0) {
+                this.config.defaultLlmModel = this.config.llmModels[0].id;
+            }
+        }
+        // Validate feature dependencies
+        for (const [key, feature] of Object.entries(this.config.features)) {
+            if (feature.enabled && feature.requires) {
+                for (const requiredFeature of feature.requires) {
+                    if (!this.config.features[requiredFeature]) {
+                        this.logger.warn(`Feature '${key}' requires '${requiredFeature}', but required feature not found.`);
+                        feature.enabled = false;
+                        break;
+                    }
+                    if (!this.config.features[requiredFeature].enabled) {
+                        this.logger.warn(`Feature '${key}' requires '${requiredFeature}', but required feature is disabled.`);
+                        feature.enabled = false;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Emit configuration updated event
+     * @param updatedProps - Updated properties
+     * @private
+     */
+    emitConfigUpdated(updatedProps) {
+        const data = {
+            config: { ...this.config },
+            updatedProps,
+        };
+        const payload = createBaseEventPayload(ConfigEvents.CONFIG_UPDATED, 'sdk_system_agent', // Placeholder agentId
+        'config_channel', // Placeholder channelId
+        data);
+        EventBus.client.emit(ConfigEvents.CONFIG_UPDATED, payload);
+    }
+    /**
+     * Emit feature state changed event
+     * @param featureKey - Feature key
+     * @param enabled - New state
+     * @param affectedFeatures - Affected dependent features
+     * @private
+     */
+    emitFeatureStateChanged(featureKey, enabled, affectedFeatures) {
+        const data = {
+            featureKey,
+            enabled,
+            affectedFeatures,
+        };
+        const payload = createBaseEventPayload(ConfigEvents.FEATURE_STATE_CHANGED, 'sdk_system_agent', // Placeholder agentId
+        'config_channel', // Placeholder channelId
+        data);
+        EventBus.client.emit(ConfigEvents.FEATURE_STATE_CHANGED, payload);
+    }
+    /**
+     * Emit LLM model changed event
+     * @param previousModelId - Previous model ID
+     * @param newModelId - New model ID
+     * @private
+     */
+    emitLlmModelChanged(previousModelId, newModelId) {
+        const data = {
+            previousModelId,
+            newModelId,
+        };
+        const payload = createBaseEventPayload(ConfigEvents.LLM_MODEL_CHANGED, 'sdk_system_agent', // Placeholder agentId
+        'config_channel', // Placeholder channelId
+        data);
+        EventBus.client.emit(ConfigEvents.LLM_MODEL_CHANGED, payload);
+    }
+    /**
+     * Emit channel SystemLLM changed event
+     * @param enabled - Whether SystemLLM is enabled
+     * @param reason - Optional reason for the change
+     * @param operationOverrides - Optional operation-specific overrides
+     * @param channelId - Optional channel ID for channel-specific changes
+     * @private
+     */
+    emitChannelSystemLlmChanged(enabled, reason, operationOverrides, channelId) {
+        const data = {
+            enabled,
+            reason,
+            operationOverrides,
+            channelId,
+            timestamp: Date.now()
+        };
+        const payload = createBaseEventPayload(ConfigEvents.CHANNEL_SYSTEM_LLM_CHANGED, 'sdk_system_agent', // Placeholder agentId
+        channelId || 'config_channel', // Use actual channelId or placeholder
+        data, { source: 'ConfigManager' });
+        // Emit to client bus - will propagate to server via shared eventSubject
+        EventBus.client.emit(ConfigEvents.CHANNEL_SYSTEM_LLM_CHANGED, payload);
+        // Also emit to server bus to ensure propagation
+        EventBus.server.emit(ConfigEvents.CHANNEL_SYSTEM_LLM_CHANGED, payload);
+    }
+}
+//# sourceMappingURL=ConfigManager.js.map