route-claudecode
Version:
Advanced routing and transformation system for Claude Code outputs to multiple AI providers
399 lines • 15 kB
JavaScript
"use strict";
/**
* 动态模型配置系统集成示例
* 展示如何将模型发现系统集成到路由器和提供商中
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.DynamicModelIntegration = void 0;
exports.createIntegratedRouterConfig = createIntegratedRouterConfig;
exports.createDynamicModelIntegration = createDynamicModelIntegration;
exports.exampleUsage = exampleUsage;
const dynamic_model_config_manager_1 = require("@/utils/dynamic-model-config-manager");
const logger_1 = require("@/utils/logger");
/**
* 动态模型配置系统集成类
*/
class DynamicModelIntegration {
config;
modelManager;
isInitialized = false;
constructor(config) {
this.config = config;
if (config.modelDiscovery.enabled) {
this.initializeModelManager();
}
}
/**
* 初始化模型管理器
*/
initializeModelManager() {
this.modelManager = (0, dynamic_model_config_manager_1.createDynamicModelConfigManager)({
...dynamic_model_config_manager_1.DEFAULT_MODEL_CONFIG_MANAGER_CONFIG,
autoDiscovery: this.config.modelDiscovery.autoUpdateRouting,
discoveryInterval: this.config.modelDiscovery.discoveryInterval,
maxModelsPerProvider: this.config.modelDiscovery.maxModelsPerProvider
});
// 设置模型更新监听器
this.modelManager.addModelUpdateListener(this.handleModelUpdate.bind(this));
logger_1.logger.info('Dynamic model configuration system initialized', {
enabled: this.config.modelDiscovery.enabled,
autoUpdateRouting: this.config.modelDiscovery.autoUpdateRouting,
discoveryInterval: this.config.modelDiscovery.discoveryInterval
}, 'dynamic-model-integration');
}
/**
* 初始化系统集成
*/
async initialize() {
if (!this.modelManager) {
logger_1.logger.warn('Model discovery is disabled, skipping initialization', {}, 'dynamic-model-integration');
return;
}
logger_1.logger.info('Initializing dynamic model configuration system', {}, 'dynamic-model-integration');
try {
// 注册所有提供商
for (const [providerId, providerConfig] of Object.entries(this.config.providers)) {
await this.registerProvider(providerId, providerConfig);
}
// 启动自动发现
if (this.config.modelDiscovery.autoUpdateRouting) {
this.modelManager.startAutoDiscovery();
logger_1.logger.info('Auto discovery started', {
interval: this.config.modelDiscovery.discoveryInterval + ' minutes'
}, 'dynamic-model-integration');
}
this.isInitialized = true;
logger_1.logger.info('Dynamic model configuration system initialized successfully', {}, 'dynamic-model-integration');
}
catch (error) {
logger_1.logger.error('Failed to initialize dynamic model configuration system', error, 'dynamic-model-integration');
throw error;
}
}
/**
* 注册提供商
*/
async registerProvider(providerId, providerConfig) {
if (!this.modelManager)
return;
logger_1.logger.debug('Registering provider for model discovery', { providerId }, 'dynamic-model-integration');
try {
await this.modelManager.registerProvider(providerId, providerConfig);
// 立即执行一次模型发现
if (this.config.modelDiscovery.autoUpdateRouting) {
await this.modelManager.discoverProviderModels(providerId);
}
}
catch (error) {
logger_1.logger.warn('Failed to register provider for model discovery', {
providerId,
error: error instanceof Error ? error.message : String(error)
}, 'dynamic-model-integration');
// 不抛出错误，允许系统继续运行
}
}
/**
* 处理模型更新事件
*/
handleModelUpdate(event) {
const { providerId, type, modelId, timestamp, details } = event;
logger_1.logger.info('Model configuration update received', {
providerId,
type,
modelId,
timestamp: new Date(timestamp).toISOString()
}, 'dynamic-model-integration');
// 根据事件类型执行不同的操作
switch (type) {
case 'model_added':
this.handleModelAdded(providerId, modelId, details);
break;
case 'model_removed':
this.handleModelRemoved(providerId, modelId);
break;
case 'model_became_available':
this.handleModelBecameAvailable(providerId, modelId, details);
break;
case 'model_became_unavailable':
this.handleModelBecameUnavailable(providerId, modelId, details);
break;
}
}
/**
* 处理模型添加
*/
handleModelAdded(providerId, modelId, details) {
logger_1.logger.info('New model discovered', {
providerId,
modelId,
result: details.result
}, 'dynamic-model-integration');
// 这里可以更新路由配置，将新模型添加到路由表中
// 例如：this.updateRoutingConfig(providerId, modelId);
// 也可以发送通知给监控系统
// this.notifyMonitoringSystem('model_added', { providerId, modelId });
}
/**
* 处理模型移除
*/
handleModelRemoved(providerId, modelId) {
logger_1.logger.warn('Model removed from availability list', {
providerId,
modelId
}, 'dynamic-model-integration');
// 这里可以从路由配置中移除模型
// 例如：this.removeFromRoutingConfig(providerId, modelId);
// 也可以发送通知给监控系统
// this.notifyMonitoringSystem('model_removed', { providerId, modelId });
}
/**
* 处理模型变为可用
*/
handleModelBecameAvailable(providerId, modelId, details) {
logger_1.logger.info('Model became available', {
providerId,
modelId,
responseTime: details.result.responseTime
}, 'dynamic-model-integration');
// 这里可以重新启用模型在路由配置中
// 例如：this.enableModelInRoutingConfig(providerId, modelId);
// 也可以发送恢复通知给监控系统
// this.notifyMonitoringSystem('model_restored', { providerId, modelId });
}
/**
* 处理模型变为不可用
*/
handleModelBecameUnavailable(providerId, modelId, details) {
logger_1.logger.warn('Model became unavailable', {
providerId,
modelId,
error: details.result.error,
statusCode: details.result.statusCode
}, 'dynamic-model-integration');
// 这里可以暂时禁用模型在路由配置中
// 例如：this.disableModelInRoutingConfig(providerId, modelId);
// 也可以发送故障通知给监控系统
// this.notifyMonitoringSystem('model_failed', { providerId, modelId });
}
/**
* 获取可用模型列表
*/
getAvailableModels(category) {
if (!this.modelManager || !this.isInitialized) {
return [];
}
const availableModels = this.modelManager.getAvailableModels(category);
return availableModels.map(model => ({
providerId: 'unknown', // 需要从模型配置中获取providerId
modelId: model.id,
responseTime: model.responseTime,
category: model.category,
priority: model.priority
}));
}
/**
* 获取系统状态
*/
getStatus() {
if (!this.modelManager) {
return {
isInitialized: false,
isAutoDiscoveryRunning: false,
registeredProviders: [],
totalModels: 0,
availableModels: 0,
lastUpdateTime: 0
};
}
const managerStatus = this.modelManager.getStatus();
return {
isInitialized: this.isInitialized,
isAutoDiscoveryRunning: managerStatus.isAutoDiscoveryRunning,
registeredProviders: managerStatus.registeredProviders,
totalModels: managerStatus.totalModels,
availableModels: managerStatus.availableModels,
lastUpdateTime: managerStatus.lastUpdateTime
};
}
/**
* 手动触发模型发现
*/
async triggerModelDiscovery(providerId) {
if (!this.modelManager || !this.isInitialized) {
throw new Error('Dynamic model configuration system is not initialized');
}
if (providerId) {
// 发现特定提供商的模型
return await this.modelManager.discoverProviderModels(providerId);
}
else {
// 发现所有提供商的模型
const results = {};
for (const providerId of Object.keys(this.config.providers)) {
try {
results[providerId] = await this.modelManager.discoverProviderModels(providerId);
}
catch (error) {
logger_1.logger.error('Failed to discover models for provider', {
providerId,
error: error instanceof Error ? error.message : String(error)
}, 'dynamic-model-integration');
results[providerId] = {
error: error.message,
totalModels: 0,
availableModels: [],
unavailableModels: []
};
}
}
return results;
}
}
/**
* 测试模型可用性
*/
async testModelAvailability(providerId, modelId) {
if (!this.modelManager || !this.isInitialized) {
throw new Error('Dynamic model configuration system is not initialized');
}
return await this.modelManager.testModelAvailability(providerId, modelId);
}
/**
* 停止系统集成
*/
shutdown() {
if (this.modelManager) {
this.modelManager.stopAutoDiscovery();
logger_1.logger.info('Dynamic model configuration system shutdown completed', {}, 'dynamic-model-integration');
}
}
/**
* 更新路由配置的示例方法
*/
updateRoutingConfig(providerId, modelId) {
// 这里可以实现动态更新路由配置的逻辑
// 例如：更新routing配置中的模型列表
// 注意：这需要线程安全地更新路由器配置
logger_1.logger.info('Updating routing configuration for new model', {
providerId,
modelId
}, 'dynamic-model-integration');
// 示例：将新模型添加到default类别的路由配置中
// this.config.routing.default.models.push({
// provider: providerId,
// model: modelId,
// weight: 1
// });
}
}
exports.DynamicModelIntegration = DynamicModelIntegration;
/**
* 创建集成动态模型配置系统的路由器配置
*/
function createIntegratedRouterConfig(baseConfig, modelDiscoveryConfig = {}) {
const discoveryConfig = {
enabled: true,
autoUpdateRouting: true,
discoveryInterval: 30, // 30分钟
maxModelsPerProvider: 10,
modelFallbackEnabled: true,
...modelDiscoveryConfig
};
return {
...baseConfig,
modelDiscovery: discoveryConfig
};
}
/**
* 工厂函数创建动态模型配置系统集成
*/
function createDynamicModelIntegration(config) {
return new DynamicModelIntegration(config);
}
/**
* 示例使用代码
*/
async function exampleUsage() {
// 1. 创建基础路由器配置
const baseConfig = {
server: {
port: 3000,
host: 'localhost'
},
providers: {
'openai-provider': {
type: 'openai',
endpoint: 'https://api.openai.com/v1/chat/completions',
authentication: {
type: 'bearer',
credentials: {
apiKey: process.env.OPENAI_API_KEY || 'your-api-key'
}
},
settings: {}
},
'anthropic-provider': {
type: 'anthropic',
endpoint: 'https://api.anthropic.com/v1/messages',
authentication: {
type: 'bearer',
credentials: {
apiKey: process.env.ANTHROPIC_API_KEY || 'your-api-key'
}
},
settings: {}
}
},
routing: {
default: {
provider: 'openai-provider',
model: 'gpt-4'
}
},
debug: {
enabled: true,
logLevel: 'info',
traceRequests: false,
saveRequests: false,
logDir: './logs'
},
hooks: []
};
// 2. 创建集成动态模型配置系统的配置
const integratedConfig = createIntegratedRouterConfig(baseConfig, {
enabled: true,
autoUpdateRouting: true,
discoveryInterval: 15, // 15分钟进行一次发现
maxModelsPerProvider: 5, // 最多每个提供商5个模型
modelFallbackEnabled: true
});
// 3. 创建系统集成实例
const integration = createDynamicModelIntegration(integratedConfig);
try {
// 4. 初始化系统
await integration.initialize();
// 5. 获取系统状态
const status = integration.getStatus();
console.log('System Status:', status);
// 6. 获取可用模型
const availableModels = integration.getAvailableModels();
console.log('Available Models:', availableModels);
// 7. 手动触发模型发现
const discoveryResults = await integration.triggerModelDiscovery();
console.log('Discovery Results:', discoveryResults);
// 8. 测试特定模型可用性
if (availableModels.length > 0) {
const firstModel = availableModels[0];
const isAvailable = await integration.testModelAvailability(firstModel.providerId, firstModel.modelId);
console.log(`Model ${firstModel.modelId} availability:`, isAvailable);
}
}
catch (error) {
console.error('Example usage failed:', error);
}
finally {
// 9. 关闭系统
integration.shutdown();
}
}
//# sourceMappingURL=dynamic-model-integration-example.js.map