claude-gemini-multimodal-bridge
Version:
Enterprise-grade AI integration bridge connecting Claude Code, Gemini CLI, and Google AI Studio with intelligent routing and advanced multimodal processing capabilities
535 lines (534 loc) • 20.2 kB
JavaScript
import { z } from 'zod';
export const LayerTypeSchema = z.enum(['claude', 'gemini', 'aistudio', 'workflow', 'tool', 'orchestrator']);
export const TargetLayerSchema = z.enum(['gemini', 'aistudio', 'adaptive']);
export const ExecutionModeSchema = z.enum(['sequential', 'parallel', 'adaptive']);
export const QualityLevelSchema = z.enum(['fast', 'balanced', 'quality']);
export const WorkflowTypeSchema = z.enum(['analysis', 'conversion', 'extraction', 'generation']);
export const FileTypeSchema = z.enum([
'image', 'audio', 'pdf', 'document', 'text', 'video'
]);
export const FileReferenceSchema = z.object({
path: z.string(),
type: FileTypeSchema,
size: z.number().optional(),
encoding: z.string().optional(),
content: z.string().optional(),
});
export const ProcessingOptionsSchema = z.object({
layer_priority: z.enum(['claude', 'gemini', 'aistudio', 'adaptive']).optional(),
execution_mode: z.enum(['sequential', 'parallel', 'adaptive']).optional(),
output_format: z.string().optional(),
quality_level: z.enum(['fast', 'balanced', 'quality']).optional(),
temperature: z.number().min(0).max(2).optional(),
max_tokens: z.number().positive().optional(),
timeout: z.number().positive().optional(),
use_cache: z.boolean().optional(),
depth: z.enum(['shallow', 'medium', 'deep']).optional(),
extractMetadata: z.boolean().optional(),
structured: z.boolean().optional(),
requiresGrounding: z.boolean().optional(),
parallelProcessing: z.boolean().optional(),
batchMode: z.boolean().optional(),
detailed: z.boolean().optional(),
extractionType: z.string().optional(),
outputFormat: z.string().optional(),
preserveQuality: z.boolean().optional(),
});
export const MultimodalProcessArgsSchema = z.object({
prompt: z.string().min(1),
workingDirectory: z.string().optional(),
files: z.array(FileReferenceSchema),
workflow: z.enum(['analysis', 'conversion', 'extraction', 'generation']),
options: ProcessingOptionsSchema.optional(),
});
export const DocumentAnalysisArgsSchema = z.object({
documents: z.array(z.string().min(1)),
workingDirectory: z.string().optional(),
analysis_type: z.enum(['summary', 'comparison', 'extraction', 'translation']),
output_requirements: z.string().optional(),
options: ProcessingOptionsSchema.optional(),
analysisType: z.enum(['summary', 'comparison', 'extraction', 'translation']).optional(),
extractImages: z.boolean().optional(),
extractStructuredData: z.boolean().optional(),
requiresGrounding: z.boolean().optional(),
depth: z.enum(['shallow', 'medium', 'deep']).optional(),
summaryLength: z.string().optional(),
dataTypes: z.array(z.string()).optional(),
comparisonType: z.string().optional(),
});
export const DocumentAnalysisResultSchema = z.object({
success: z.boolean(),
analysis_type: z.enum(['summary', 'comparison', 'extraction', 'translation']),
content: z.string(),
documents_processed: z.array(z.string()),
processing_time: z.number(),
insights: z.array(z.string()).optional(),
metadata: z.object({
total_duration: z.number(),
tokens_used: z.number().optional(),
cost: z.number().optional(),
quality_score: z.number().optional(),
}),
error: z.string().optional(),
});
export const WorkflowStepSchema = z.object({
id: z.string(),
layer: z.enum(['claude', 'gemini', 'aistudio']),
action: z.string(),
input: z.record(z.any()),
dependsOn: z.array(z.string()).optional(),
timeout: z.number().optional(),
retries: z.number().optional(),
});
export const ExecutionPlanSchema = z.object({
steps: z.array(WorkflowStepSchema),
dependencies: z.record(z.array(z.string())).optional(),
fallbackStrategies: z.record(z.object({
replace: z.string(),
with: WorkflowStepSchema,
})).optional(),
timeout: z.number().optional(),
});
export const WorkflowDefinitionArgsSchema = z.object({
workflow_definition: ExecutionPlanSchema,
input_data: z.record(z.any()),
execution_mode: z.enum(['sequential', 'parallel', 'adaptive']).optional(),
options: ProcessingOptionsSchema.optional(),
});
export const LayerResultSchema = z.object({
success: z.boolean(),
data: z.any().optional(),
error: z.string().optional(),
metadata: z.object({
layer: z.enum(['claude', 'gemini', 'aistudio']),
duration: z.number(),
tokens_used: z.number().optional(),
cost: z.number().optional(),
model: z.string().optional(),
fast_mode: z.boolean().optional(),
optimization: z.string().optional(),
retry_attempt: z.number().optional(),
}),
});
export const WorkflowResultSchema = z.object({
success: z.boolean(),
results: z.union([z.record(LayerResultSchema), z.array(LayerResultSchema)]),
summary: z.string().optional(),
metadata: z.object({
total_duration: z.number(),
steps_completed: z.number(),
steps_failed: z.number(),
total_cost: z.number().optional(),
workflow: z.string().optional(),
execution_mode: z.string().optional(),
layers_used: z.array(z.string()).optional(),
optimization: z.string().optional(),
}),
});
export const ConfigSchema = z.object({
gemini: z.object({
api_key: z.string(),
model: z.string().default('gemini-2.5-pro'),
timeout: z.number().default(60000),
max_tokens: z.number().default(16384),
temperature: z.number().default(0.2),
}),
claude: z.object({
code_path: z.string().default('/usr/local/bin/claude'),
timeout: z.number().default(300000),
}),
aistudio: z.object({
enabled: z.boolean().default(true),
max_files: z.number().default(10),
max_file_size: z.number().default(100),
}),
cache: z.object({
enabled: z.boolean().default(true),
ttl: z.number().default(3600),
}),
logging: z.object({
level: z.enum(['error', 'warn', 'info', 'debug']).default('info'),
file: z.string().optional(),
}),
});
export class CGMBError extends Error {
code;
layer;
details;
constructor(message, code, layer, details) {
super(message);
this.code = code;
this.layer = layer;
this.details = details;
this.name = 'CGMBError';
}
}
export class LayerError extends CGMBError {
constructor(message, layer, details) {
super(message, 'LAYER_ERROR', layer, details);
this.name = 'LayerError';
}
}
export class WorkflowError extends CGMBError {
constructor(message, details) {
super(message, 'WORKFLOW_ERROR', undefined, details);
this.name = 'WorkflowError';
}
}
export const ImageAnalysisTypeSchema = z.enum(['detailed', 'technical', 'extract_text']);
export const ImageAnalysisResultSchema = z.object({
type: ImageAnalysisTypeSchema,
description: z.string(),
extracted_text: z.string().optional(),
technical_details: z.record(z.any()).optional(),
confidence: z.number().min(0).max(1).optional(),
});
export const MultimodalResultSchema = z.object({
content: z.string(),
success: z.boolean(),
files_processed: z.array(z.string()),
processing_time: z.number(),
workflow_used: WorkflowTypeSchema,
layers_involved: z.array(LayerTypeSchema),
metadata: z.object({
total_duration: z.number(),
quality_level: QualityLevelSchema.optional(),
tokens_used: z.number().optional(),
cost: z.number().optional(),
}),
error: z.string().optional(),
});
export const GroundingContextSchema = z.object({
files: z.array(z.string()).optional(),
useSearch: z.boolean().default(false),
searchQuery: z.string().optional(),
context: z.string().optional(),
});
export const GroundedResultSchema = z.object({
content: z.string(),
sources: z.array(z.string()).optional(),
grounded: z.boolean(),
search_used: z.boolean(),
});
export const WorkloadAnalysisSchema = z.object({
requiresComplexReasoning: z.boolean(),
requiresMultimodalProcessing: z.boolean(),
requiresGrounding: z.boolean(),
estimatedComplexity: z.enum(['low', 'medium', 'high']),
recommendedLayer: z.enum(['claude', 'gemini', 'aistudio']),
confidence: z.number().min(0).max(1),
});
export const ReasoningTaskSchema = z.object({
prompt: z.string(),
context: z.string().optional(),
depth: z.enum(['shallow', 'medium', 'deep']).optional(),
domain: z.string().optional(),
});
export const ReasoningResultSchema = z.object({
reasoning: z.string(),
conclusion: z.string(),
confidence: z.number().min(0).max(1),
steps: z.array(z.string()).optional(),
});
export const LayerRequirementsSchema = z.object({
format: z.string(),
requirements: z.array(z.string()),
capabilities: z.array(z.string()),
example: z.record(z.any()),
limitations: z.array(z.string()).optional()
});
export const FormattedLayerDataSchema = z.object({
geminiFormat: z.object({
stdin: z.string(),
args: z.array(z.string())
}).optional(),
aistudioFormat: z.object({
apiData: z.record(z.any()),
files: z.array(z.string())
}).optional()
});
export const EnhancedCGMBRequestSchema = z.object({
prompt: z.string(),
workingDirectory: z.string().optional(),
targetLayer: TargetLayerSchema.optional(),
preformatted: z.boolean().optional(),
formattedData: FormattedLayerDataSchema.optional(),
files: z.array(FileReferenceSchema).optional(),
options: ProcessingOptionsSchema.optional()
});
export const GenerationTypeSchema = z.enum(['image', 'video', 'audio', 'music']);
export const ImageGenOptionsSchema = z.object({
width: z.number().min(64).max(4096).optional(),
height: z.number().min(64).max(4096).optional(),
aspectRatio: z.enum(['1:1', '16:9', '9:16', '4:3', '3:4']).optional(),
style: z.enum(['photorealistic', 'artistic', 'cartoon', 'sketch', 'abstract']).optional(),
quality: z.enum(['draft', 'standard', 'high', 'ultra']).optional(),
model: z.enum(['imagen-3', 'imagen-2']).default('imagen-3'),
seed: z.number().optional(),
guidance: z.number().min(1).max(20).optional(),
steps: z.number().min(10).max(100).optional(),
numberOfImages: z.number().min(1).max(4).optional(),
personGeneration: z.enum(['ALLOW', 'BLOCK']).optional(),
});
export const VideoGenOptionsSchema = z.object({
width: z.number().min(256).max(2048).optional(),
height: z.number().min(256).max(2048).optional(),
duration: z.number().min(1).max(30).optional(),
fps: z.enum(['24', '30', '60']).default('30'),
quality: z.enum(['draft', 'standard', 'high']).optional(),
model: z.enum(['veo-2', 'video-generation']).default('veo-2'),
motion: z.enum(['static', 'slow', 'medium', 'fast']).optional(),
seed: z.number().optional(),
});
export const AudioGenOptionsSchema = z.object({
voice: z.enum(['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer', 'Kore', 'Puck']).optional(),
language: z.string().optional(),
speed: z.number().min(0.25).max(4).optional(),
format: z.enum(['mp3', 'wav', 'flac']).default('mp3'),
quality: z.enum(['standard', 'hd']).optional(),
model: z.enum(['text-to-speech', 'voice-synthesis']).default('text-to-speech'),
});
export const MediaGenResultSchema = z.object({
success: z.boolean(),
generationType: GenerationTypeSchema,
outputPath: z.string(),
originalPrompt: z.string(),
metadata: z.object({
duration: z.number(),
fileSize: z.number(),
format: z.string(),
dimensions: z.object({
width: z.number(),
height: z.number(),
}).optional(),
model: z.string(),
settings: z.record(z.any()),
cost: z.number().optional(),
voice: z.string().optional(),
responseText: z.string().optional(),
translation: z.object({
detectedLanguage: z.string(),
languageName: z.string(),
originalPrompt: z.string().optional(),
translatedPrompt: z.string().optional(),
wasTranslated: z.boolean(),
}).optional(),
}),
media: z.object({
type: z.enum(['image', 'audio', 'video']),
data: z.string().optional(),
metadata: z.record(z.any()).optional(),
}).optional(),
downloadUrl: z.string().optional(),
error: z.string().optional(),
});
export const AudioAnalysisResultSchema = z.object({
transcription: z.string(),
language: z.string().optional(),
confidence: z.number().min(0).max(1).optional(),
sentiment: z.enum(['positive', 'negative', 'neutral']).optional(),
emotions: z.array(z.string()).optional(),
speakers: z.array(z.object({
id: z.string(),
confidence: z.number(),
segments: z.array(z.object({
start: z.number(),
end: z.number(),
text: z.string(),
})),
})).optional(),
metadata: z.object({
duration: z.number(),
sampleRate: z.number().optional(),
channels: z.number().optional(),
format: z.string(),
}),
});
export const MediaGenerationArgsSchema = z.object({
prompt: z.string().min(1),
type: GenerationTypeSchema,
options: z.record(z.any()).optional(),
outputPath: z.string().optional(),
downloadAfterGeneration: z.boolean().default(true),
});
export const AuthStatusSchema = z.object({
isAuthenticated: z.boolean(),
method: z.enum(['oauth', 'api_key', 'session']),
expiresAt: z.date().optional(),
userInfo: z.object({
email: z.string().optional(),
quotaRemaining: z.number().optional(),
planType: z.string().optional(),
}).optional(),
});
export const AuthResultSchema = z.object({
success: z.boolean(),
status: AuthStatusSchema,
error: z.string().optional(),
requiresAction: z.boolean().default(false),
actionInstructions: z.string().optional(),
});
export const VerificationResultSchema = z.object({
overall: z.boolean(),
services: z.record(AuthResultSchema),
recommendations: z.array(z.string()),
});
export var AuthErrorCode;
(function (AuthErrorCode) {
AuthErrorCode["NOT_AUTHENTICATED"] = "NOT_AUTHENTICATED";
AuthErrorCode["AUTH_EXPIRED"] = "AUTH_EXPIRED";
AuthErrorCode["INVALID_CREDENTIALS"] = "INVALID_CREDENTIALS";
AuthErrorCode["QUOTA_EXCEEDED"] = "QUOTA_EXCEEDED";
AuthErrorCode["AUTH_METHOD_NOT_SUPPORTED"] = "AUTH_METHOD_NOT_SUPPORTED";
AuthErrorCode["OAUTH_FLOW_FAILED"] = "OAUTH_FLOW_FAILED";
AuthErrorCode["API_KEY_INVALID"] = "API_KEY_INVALID";
AuthErrorCode["AUTH_SETUP_REQUIRED"] = "AUTH_SETUP_REQUIRED";
})(AuthErrorCode || (AuthErrorCode = {}));
export class AuthenticationError extends LayerError {
constructor(message, layer, code, authContext) {
super(message, layer, {
authError: true,
code,
authContext
});
this.name = 'AuthenticationError';
}
}
export const SetupResultSchema = z.object({
success: z.boolean(),
servicesConfigured: z.array(z.string()),
errors: z.array(z.string()),
nextSteps: z.array(z.string()).optional(),
});
export const SystemCapabilitiesSchema = z.object({
claudeCode: z.boolean(),
geminiCLI: z.boolean(),
aiStudio: z.boolean(),
lastChecked: z.date(),
});
export const RequestAnalysisSchema = z.object({
canEnhance: z.boolean(),
requiredCapabilities: z.array(z.enum(['claude', 'gemini', 'aistudio'])),
fallbackToOriginal: z.boolean(),
enhancementType: z.enum(['multimodal', 'grounding', 'reasoning', 'passthrough']),
confidence: z.number().min(0).max(1),
priority: z.enum(['low', 'medium', 'high']).optional(),
estimatedComplexity: z.enum(['simple', 'moderate', 'complex']).optional(),
});
export const EnhancementPlanSchema = z.object({
enhance: z.boolean(),
type: z.enum(['multimodal', 'grounding', 'reasoning', 'passthrough']),
layers: z.array(z.enum(['claude', 'gemini', 'aistudio'])),
confidence: z.number().min(0).max(1),
fallbackStrategy: z.object({
enabled: z.boolean(),
fallbackTo: z.array(z.enum(['claude', 'gemini', 'aistudio'])),
}).optional(),
estimatedDuration: z.number().optional(),
});
export const ClaudeRequestSchema = z.object({
args: z.array(z.string()),
originalCommand: z.string(),
workingDirectory: z.string().optional(),
environment: z.record(z.string()).optional(),
timestamp: z.date().default(() => new Date()),
});
export const ClaudeResponseSchema = z.object({
success: z.boolean(),
output: z.string().optional(),
error: z.string().optional(),
exitCode: z.number().optional(),
enhanced: z.boolean().default(false),
metadata: z.object({
executionTime: z.number(),
enhancementUsed: z.string().optional(),
layersInvolved: z.array(z.string()).optional(),
cost: z.number().optional(),
}).optional(),
});
export const AvailableCapabilitiesSchema = z.object({
claudeCode: z.object({
available: z.boolean(),
version: z.string().optional(),
authenticated: z.boolean(),
path: z.string().optional(),
}),
geminiCLI: z.object({
available: z.boolean(),
version: z.string().optional(),
authenticated: z.boolean(),
path: z.string().optional(),
}),
aiStudio: z.object({
available: z.boolean(),
authenticated: z.boolean(),
mcpServerAvailable: z.boolean(),
}),
lastChecked: z.date(),
});
export const MultimodalFileSchema = z.object({
path: z.string(),
type: FileTypeSchema,
size: z.number().optional(),
encoding: z.string().optional(),
content: z.string().optional(),
name: z.string().optional(),
metadata: z.record(z.any()).optional(),
});
export const MultimodalProcessResultSchema = z.object({
success: z.boolean(),
content: z.string(),
files_processed: z.array(z.string()),
processing_time: z.number(),
workflow_used: WorkflowTypeSchema,
layers_involved: z.array(LayerTypeSchema),
metadata: z.object({
total_duration: z.number(),
tokens_used: z.number().optional(),
cost: z.number().optional(),
quality_level: QualityLevelSchema.optional(),
}),
error: z.string().optional(),
});
export const WorkflowDefinitionSchema = z.object({
id: z.string(),
name: z.string().optional(),
description: z.string().optional(),
steps: z.array(WorkflowStepSchema),
dependencies: z.record(z.array(z.string())).optional(),
fallbackStrategies: z.record(z.object({
replace: z.string(),
with: WorkflowStepSchema,
})).optional(),
timeout: z.number().optional(),
phases: z.array(z.array(z.string())).optional(),
parallel: z.boolean().optional(),
continueOnError: z.boolean().optional(),
});
export const WorkflowExecutionPlanSchema = z.object({
id: z.string(),
workflow: WorkflowDefinitionSchema,
input_data: z.record(z.any()),
execution_mode: ExecutionModeSchema,
estimated_duration: z.number().optional(),
estimated_cost: z.number().optional(),
priority: z.enum(['low', 'medium', 'high']).optional(),
created_at: z.date().default(() => new Date()),
});
export const ResourceEstimateSchema = z.object({
estimated_duration: z.number(),
estimated_cost: z.number().optional(),
estimated_tokens: z.number().optional(),
complexity_score: z.number().min(0).max(10),
recommended_execution_mode: ExecutionModeSchema,
required_capabilities: z.array(z.enum(['claude', 'gemini', 'aistudio'])),
});
export const AI_MODELS = {
IMAGE_GENERATION: 'gemini-2.0-flash-preview-image-generation',
AUDIO_GENERATION: 'gemini-2.5-flash-preview-tts',
GEMINI_FLASH: 'gemini-2.0-flash',
GEMINI_FLASH_EXP: 'gemini-2.0-flash-exp',
GEMINI_FLASH_2_5: 'gemini-2.5-flash',
DOCUMENT_PROCESSING: 'gemini-2.5-flash',
MULTIMODAL_DEFAULT: 'gemini-2.0-flash-exp'
};