@quantumai/quantum-cli-core
Version:
Quantum CLI Core - Multi-LLM Collaboration System
166 lines • 6.54 kB
JavaScript
/**
* @license
* Copyright 2025 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
import { OpenAIProvider } from './providers/openai-provider.js';
import { GeminiProvider } from './providers/gemini-provider.js';
import { GeminiClient } from '../core/client.js';
import { DualModelEngine } from './dual-engine.js';
import { UncertaintyLevel, } from './types.js';
import { isCollaborationEnabled } from './feature-flags.js';
/**
* Main collaboration engine that orchestrates multi-LLM interactions
*/
export class CollaborationEngine {
config;
dualEngine;
primaryProvider;
secondaryProvider;
constructor(config) {
this.config = config;
// Initialize providers asynchronously
this.initializeProviders().catch((error) => {
console.warn('Failed to initialize collaboration providers:', error);
});
}
async initializeProviders() {
const collaborationConfig = this.config.getCollaborationConfig();
if (!collaborationConfig?.enabled || !isCollaborationEnabled()) {
return;
}
try {
// Get providers from configuration
const providers = collaborationConfig.providers || [];
const enabledProviders = providers.filter((p) => p.enabled);
if (enabledProviders.length < 2) {
console.warn('Need at least 2 enabled providers for collaboration');
return;
}
// Use first two enabled providers for now
const primaryConfig = enabledProviders[0];
const secondaryConfig = enabledProviders[1];
// Initialize providers based on type
if (primaryConfig.type === 'gemini') {
// For Gemini, we need to create a GeminiClient instance
const geminiClient = new GeminiClient(this.config);
this.primaryProvider = new GeminiProvider(primaryConfig, geminiClient);
}
else if (primaryConfig.type === 'openai') {
this.primaryProvider = new OpenAIProvider(primaryConfig);
}
if (secondaryConfig.type === 'openai') {
this.secondaryProvider = new OpenAIProvider(secondaryConfig);
}
else if (secondaryConfig.type === 'gemini') {
// For Gemini, we need to create a GeminiClient instance
const geminiClient = new GeminiClient(this.config);
this.secondaryProvider = new GeminiProvider(secondaryConfig, geminiClient);
}
if (this.primaryProvider && this.secondaryProvider) {
// Convert CollaborationConfig to DualEngineConfig
const dualEngineConfig = {
autoVerifyThreshold: collaborationConfig.autoVerifyThreshold,
maxCostPerQuery: collaborationConfig.maxCostPerQuery,
uncertaintyThreshold: collaborationConfig.minConfidenceScore,
alignmentThreshold: collaborationConfig.consensusThreshold,
enableSynthesis: true,
};
this.dualEngine = new DualModelEngine(this.primaryProvider, this.secondaryProvider, dualEngineConfig, collaborationConfig);
}
}
catch (error) {
console.warn('Failed to initialize collaboration providers:', error);
}
}
async generateWithVerification(prompt, context) {
if (!this.dualEngine) {
return this.getFallbackResponse(prompt);
}
try {
return await this.dualEngine.generateWithVerification(prompt, context, {
verify: true,
});
}
catch (error) {
console.warn('Collaboration failed, falling back to single model:', error);
return this.getFallbackResponse(prompt);
}
}
async compareResponses(prompt, context) {
if (!this.dualEngine) {
return this.getFallbackResponse(prompt);
}
try {
return await this.dualEngine.generateWithVerification(prompt, context, {
compare: true,
});
}
catch (error) {
console.warn('Response comparison failed:', error);
return this.getFallbackResponse(prompt);
}
}
async *streamWithVerification(prompt, context) {
if (!this.dualEngine) {
yield 'Streaming not available in collaboration mode...';
return this.getFallbackResponse(prompt);
}
try {
// For now, use non-streaming approach
// TODO: Implement actual streaming in DualModelEngine
yield 'Generating with verification...';
const result = await this.dualEngine.generateWithVerification(prompt, context);
yield result.content;
return result;
}
catch (error) {
yield `Error: ${error}`;
return this.getFallbackResponse(prompt);
}
}
shouldUseCollaboration(query) {
const collaborationConfig = this.config.getCollaborationConfig();
if (!collaborationConfig?.enabled || !isCollaborationEnabled()) {
return false;
}
// Check for keywords that might benefit from verification
const keywords = [
'security',
'production',
'critical',
'database',
'authentication',
];
return keywords.some((keyword) => query.toLowerCase().includes(keyword));
}
async generate(query, options) {
if (options?.compare) {
return this.compareResponses(query);
}
else if (options?.verify) {
return this.generateWithVerification(query);
}
else {
// Default to verification if enabled
return this.generateWithVerification(query);
}
}
getFallbackResponse(prompt) {
const placeholderText = `Fallback response for: ${prompt}`;
return {
content: placeholderText,
primaryResponse: placeholderText,
verified: false,
confidence: 0.5,
uncertaintyLevel: UncertaintyLevel.MEDIUM,
uncertaintyReasons: ['Collaboration not available'],
metadata: {
duration: 0,
modelsUsed: ['fallback'],
fallback: true,
},
};
}
}
//# sourceMappingURL=collaboration-engine.js.map