route-claudecode
Version:
Advanced routing and transformation system for Claude Code outputs to multiple AI providers
252 lines • 9.81 kB
JavaScript
;
/**
* Transformation Manager
* Central hub for managing message format transformations
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.transformationManager = exports.TransformationManager = void 0;
exports.transformOpenAIToAnthropic = transformOpenAIToAnthropic;
exports.transformAnthropicToOpenAI = transformAnthropicToOpenAI;
exports.transformOpenAIResponseToAnthropic = transformOpenAIResponseToAnthropic;
exports.transformAnthropicResponseToOpenAI = transformAnthropicResponseToOpenAI;
const openai_1 = require("./openai");
const anthropic_1 = require("./anthropic");
const codewhisperer_1 = require("./codewhisperer");
const streaming_1 = require("./streaming");
const logger_1 = require("@/utils/logger");
class TransformationManager {
transformers = new Map();
constructor() {
this.initializeTransformers();
}
/**
* Initialize all available transformers
*/
initializeTransformers() {
const openaiTransformer = (0, openai_1.createOpenAITransformer)();
const anthropicTransformer = (0, anthropic_1.createAnthropicTransformer)();
const codewhispererTransformer = (0, codewhisperer_1.createCodeWhispererTransformer)();
this.transformers.set('openai', openaiTransformer);
this.transformers.set('anthropic', anthropicTransformer);
this.transformers.set('codewhisperer', codewhispererTransformer);
// Use console.log instead of logger during initialization to avoid port dependency
console.log('Transformation manager initialized with transformers:', Array.from(this.transformers.keys()));
}
/**
* Get transformer by name
*/
getTransformer(name) {
return this.transformers.get(name);
}
/**
* Transform request between formats
*/
transformRequest(request, context, requestId) {
try {
logger_1.logger.debug('Transforming request', {
source: context.sourceProvider,
target: context.targetProvider,
requestId
});
// If source and target are the same, return as-is
if (context.sourceProvider === context.targetProvider) {
return request;
}
// Convert to unified format first
let unifiedRequest;
if (context.sourceProvider === 'unified') {
unifiedRequest = request;
}
else {
const sourceTransformer = this.transformers.get(context.sourceProvider);
if (!sourceTransformer) {
throw new Error(`Source transformer not found: ${context.sourceProvider}`);
}
unifiedRequest = sourceTransformer.transformRequestToUnified(request);
}
// Convert from unified to target format
if (context.targetProvider === 'unified') {
return unifiedRequest;
}
const targetTransformer = this.transformers.get(context.targetProvider);
if (!targetTransformer) {
throw new Error(`Target transformer not found: ${context.targetProvider}`);
}
const transformedRequest = targetTransformer.transformRequestFromUnified(unifiedRequest);
logger_1.logger.debug('Request transformation completed', {
source: context.sourceProvider,
target: context.targetProvider,
requestId
});
return transformedRequest;
}
catch (error) {
logger_1.logger.error('Request transformation failed', error, requestId);
throw error;
}
}
/**
* Transform response between formats
*/
transformResponse(response, context, requestId) {
try {
logger_1.logger.debug('Transforming response', {
source: context.sourceProvider,
target: context.targetProvider,
requestId
});
// If source and target are the same, return as-is
if (context.sourceProvider === context.targetProvider) {
return response;
}
// Convert to unified format first
let unifiedResponse;
if (context.sourceProvider === 'unified') {
unifiedResponse = response;
}
else {
const sourceTransformer = this.transformers.get(context.sourceProvider);
if (!sourceTransformer) {
throw new Error(`Source transformer not found: ${context.sourceProvider}`);
}
unifiedResponse = sourceTransformer.transformResponseToUnified(response);
}
// Convert from unified to target format
if (context.targetProvider === 'unified') {
return unifiedResponse;
}
const targetTransformer = this.transformers.get(context.targetProvider);
if (!targetTransformer) {
throw new Error(`Target transformer not found: ${context.targetProvider}`);
}
const transformedResponse = targetTransformer.transformResponseFromUnified(unifiedResponse);
logger_1.logger.debug('Response transformation completed', {
source: context.sourceProvider,
target: context.targetProvider,
requestId
});
return transformedResponse;
}
catch (error) {
logger_1.logger.error('Response transformation failed', error, requestId);
throw error;
}
}
/**
* Create streaming transformer
*/
createStreamingTransformer(options) {
const sourceTransformer = this.transformers.get(options.sourceFormat);
const targetTransformer = this.transformers.get(options.targetFormat);
if (!sourceTransformer) {
throw new Error(`Source transformer not found: ${options.sourceFormat}`);
}
if (!targetTransformer) {
throw new Error(`Target transformer not found: ${options.targetFormat}`);
}
return (0, streaming_1.createStreamingTransformer)(sourceTransformer, targetTransformer, options);
}
/**
* Transform streaming response
*/
async *transformStream(stream, options) {
const streamingTransformer = this.createStreamingTransformer(options);
if (options.sourceFormat === 'openai' && options.targetFormat === 'anthropic') {
yield* streamingTransformer.transformOpenAIToAnthropic(stream);
}
else if (options.sourceFormat === 'anthropic' && options.targetFormat === 'openai') {
yield* streamingTransformer.transformAnthropicToOpenAI(stream);
}
else {
throw new Error(`Unsupported streaming transformation: ${options.sourceFormat} -> ${options.targetFormat}`);
}
}
/**
* Detect request format
*/
detectRequestFormat(request) {
// Check for Anthropic-specific fields
if (Array.isArray(request.system) ||
(request.tools && request.tools.some((t) => t.input_schema))) {
return 'anthropic';
}
// Check for OpenAI-specific fields
if (request.tools && request.tools.some((t) => t.function)) {
return 'openai';
}
// Default heuristics
if (request.messages && Array.isArray(request.messages)) {
const hasToolRole = request.messages.some((m) => m.role === 'tool');
const hasToolCalls = request.messages.some((m) => m.tool_calls);
if (hasToolRole || hasToolCalls) {
return 'openai';
}
}
return 'unknown';
}
/**
* Get available transformers
*/
getAvailableTransformers() {
return Array.from(this.transformers.keys());
}
/**
* Register custom transformer
*/
registerTransformer(name, transformer) {
this.transformers.set(name, transformer);
logger_1.logger.info(`Registered custom transformer: ${name}`);
}
/**
* Get transformation statistics
*/
getStats() {
return {
availableTransformers: this.getAvailableTransformers(),
totalTransformers: this.transformers.size
};
}
}
exports.TransformationManager = TransformationManager;
// Global transformation manager instance
exports.transformationManager = new TransformationManager();
/**
* Utility functions for common transformations
*/
/**
* Transform OpenAI request to Anthropic format
*/
function transformOpenAIToAnthropic(request, requestId) {
return exports.transformationManager.transformRequest(request, {
sourceProvider: 'openai',
targetProvider: 'anthropic'
}, requestId);
}
/**
* Transform Anthropic request to OpenAI format
*/
function transformAnthropicToOpenAI(request, requestId) {
return exports.transformationManager.transformRequest(request, {
sourceProvider: 'anthropic',
targetProvider: 'openai'
}, requestId);
}
/**
* Transform OpenAI response to Anthropic format
*/
function transformOpenAIResponseToAnthropic(response, requestId) {
return exports.transformationManager.transformResponse(response, {
sourceProvider: 'openai',
targetProvider: 'anthropic'
}, requestId);
}
/**
* Transform Anthropic response to OpenAI format
*/
function transformAnthropicResponseToOpenAI(response, requestId) {
return exports.transformationManager.transformResponse(response, {
sourceProvider: 'anthropic',
targetProvider: 'openai'
}, requestId);
}
//# sourceMappingURL=manager.js.map