responses-proxy 0.1.0

package/dist/routing-engine.js

@@ -0,0 +1,377 @@
+import { fetchProviderUsage } from "./provider-usage.js";
+export class RoutingEngine {
+    providerRepository;
+    healthCheckCache;
+    healthCacheTtl;
+    constructor(providerRepository, healthCheckCache = new Map(), healthCacheTtl = 30000 // 30 seconds
+    ) {
+        this.providerRepository = providerRepository;
+        this.healthCheckCache = healthCheckCache;
+        this.healthCacheTtl = healthCacheTtl;
+    }
+    /**
+     * Select the best provider for a request using multi-tier routing
+     */
+    async selectProvider(combo, request) {
+        const startTime = Date.now();
+        let fallbackCount = 0;
+        let retryCount = 0;
+        // Get enabled tiers sorted by priority
+        const enabledTiers = combo.tiers
+            .filter(tier => tier.isEnabled)
+            .sort((a, b) => a.priority - b.priority);
+        if (enabledTiers.length === 0) {
+            return {
+                success: false,
+                error: 'No enabled tiers available',
+                selectionTime: Date.now() - startTime,
+                fallbackCount,
+                retryCount
+            };
+        }
+        // Try each tier in priority order
+        for (let tierIndex = 0; tierIndex < enabledTiers.length; tierIndex++) {
+            const tier = enabledTiers[tierIndex];
+            try {
+                // Get eligible providers for this tier
+                const eligibleProviders = await this.getEligibleProviders(tier, request);
+                if (eligibleProviders.length > 0) {
+                    // Select provider based on load balancing strategy
+                    const selectedProvider = await this.selectFromTier(eligibleProviders, combo.policies.loadBalancing, request);
+                    if (selectedProvider) {
+                        return {
+                            success: true,
+                            provider: selectedProvider.provider,
+                            tier: tier.name,
+                            selectionTime: Date.now() - startTime,
+                            eligibilityScore: selectedProvider.eligibilityScore,
+                            fallbackCount,
+                            retryCount
+                        };
+                    }
+                }
+                // If this isn't the last tier, wait for fallback delay
+                if (tierIndex < enabledTiers.length - 1) {
+                    fallbackCount++;
+                    if (tier.fallbackDelay > 0) {
+                        await new Promise(resolve => setTimeout(resolve, tier.fallbackDelay));
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Error selecting from tier ${tier.name}:`, error);
+                // Continue to next tier on error
+                fallbackCount++;
+            }
+        }
+        return {
+            success: false,
+            error: 'No eligible providers available in any tier',
+            selectionTime: Date.now() - startTime,
+            fallbackCount,
+            retryCount
+        };
+    }
+    /**
+     * Get eligible providers for a tier based on health and configuration
+     */
+    async getEligibleProviders(tier, request) {
+        const eligibleProviders = [];
+        for (const binding of tier.providers) {
+            if (!binding.isEnabled) {
+                continue;
+            }
+            try {
+                // Get provider from repository
+                const provider = this.providerRepository.getProvider(binding.providerId);
+                if (!provider) {
+                    console.warn(`Provider ${binding.providerId} not found`);
+                    continue;
+                }
+                // Get provider health
+                const health = await this.getProviderHealth(binding.providerId);
+                // Calculate eligibility score
+                const eligibilityScore = this.calculateEligibilityScore(provider, health, request, tier);
+                // Check if provider meets minimum eligibility threshold
+                const minThreshold = this.getMinEligibilityThreshold(tier, request);
+                if (eligibilityScore >= minThreshold) {
+                    eligibleProviders.push({
+                        binding,
+                        provider,
+                        health,
+                        eligibilityScore
+                    });
+                }
+            }
+            catch (error) {
+                console.error(`Error evaluating provider ${binding.providerId}:`, error);
+                // Skip this provider on error
+            }
+        }
+        return eligibleProviders;
+    }
+    /**
+     * Select a provider from eligible providers based on load balancing strategy
+     */
+    async selectFromTier(eligibleProviders, strategy, request) {
+        if (eligibleProviders.length === 0) {
+            return null;
+        }
+        if (eligibleProviders.length === 1) {
+            return eligibleProviders[0];
+        }
+        switch (strategy) {
+            case 'weighted':
+                return this.selectByWeight(eligibleProviders);
+            case 'health_based':
+                return this.selectByHealth(eligibleProviders);
+            case 'cost_optimized':
+                return this.selectByCost(eligibleProviders);
+            case 'round_robin':
+                return this.selectRoundRobin(eligibleProviders, request);
+            case 'least_connections':
+                return this.selectLeastConnections(eligibleProviders);
+            case 'random':
+                return this.selectRandom(eligibleProviders);
+            default:
+                // Default to weighted selection
+                return this.selectByWeight(eligibleProviders);
+        }
+    }
+    /**
+     * Calculate eligibility score for a provider (0-100)
+     */
+    calculateEligibilityScore(provider, health, request, tier) {
+        let score = 100;
+        // Response time factor (20% weight)
+        if (health.averageResponseTime > 5000) {
+            score -= 20;
+        }
+        else if (health.averageResponseTime > 2000) {
+            score -= 10;
+        }
+        else if (health.averageResponseTime > 1000) {
+            score -= 5;
+        }
+        // Error rate factor (30% weight)
+        if (health.errorRate > 0.1) {
+            score -= 30;
+        }
+        else if (health.errorRate > 0.05) {
+            score -= 15;
+        }
+        else if (health.errorRate > 0.02) {
+            score -= 8;
+        }
+        // Quota availability factor (25% weight)
+        if (health.quotaUsagePercent > 95) {
+            score -= 25;
+        }
+        else if (health.quotaUsagePercent > 80) {
+            score -= 10;
+        }
+        else if (health.quotaUsagePercent > 60) {
+            score -= 5;
+        }
+        // Account status factor (25% weight)
+        if (!health.hasValidAccounts) {
+            score -= 25;
+        }
+        else if (health.accountsNearExpiry) {
+            score -= 10;
+        }
+        // Health threshold check
+        if (tier.healthThreshold && tier.healthThreshold.length > 0) {
+            const providerHealthStatus = this.getProviderHealthStatus(health);
+            if (!tier.healthThreshold.includes(providerHealthStatus)) {
+                score -= 50; // Significant penalty for not meeting health threshold
+            }
+        }
+        // Priority boost for high priority requests
+        if (request.priority === 'high' && provider.capabilities.usageCheckEnabled) {
+            score += 5;
+        }
+        return Math.max(0, Math.min(100, score));
+    }
+    /**
+     * Get provider health status category
+     */
+    getProviderHealthStatus(health) {
+        if (!health.isHealthy || health.errorRate > 0.1 || health.averageResponseTime > 5000) {
+            return 'degraded';
+        }
+        if (health.quotaUsagePercent > 90) {
+            return 'rate_limited';
+        }
+        return 'healthy';
+    }
+    /**
+     * Get minimum eligibility threshold based on tier and request
+     */
+    getMinEligibilityThreshold(tier, request) {
+        // Higher tiers have higher standards
+        switch (tier.tier) {
+            case 'subscription':
+                return 70;
+            case 'cheap':
+                return 50;
+            case 'free':
+                return 30;
+            case 'custom':
+                return 40;
+            default:
+                return 50;
+        }
+    }
+    /**
+     * Get cached provider health or fetch fresh data
+     */
+    async getProviderHealth(providerId) {
+        const cached = this.healthCheckCache.get(providerId);
+        const now = Date.now();
+        if (cached && (now - cached.lastChecked) < this.healthCacheTtl) {
+            return cached;
+        }
+        // Fetch fresh health data
+        const health = await this.fetchProviderHealth(providerId);
+        this.healthCheckCache.set(providerId, health);
+        return health;
+    }
+    /**
+     * Fetch provider health from various sources
+     */
+    async fetchProviderHealth(providerId) {
+        const provider = this.providerRepository.getProvider(providerId);
+        if (!provider) {
+            throw new Error(`Provider ${providerId} not found`);
+        }
+        let quotaUsagePercent = 0;
+        let isHealthy = true;
+        let averageResponseTime = 1000; // Default 1s
+        let errorRate = 0;
+        // Check provider usage if enabled
+        if (provider.capabilities.usageCheckEnabled && provider.capabilities.usageCheckUrl) {
+            try {
+                const usage = await fetchProviderUsage({
+                    apiKey: provider.providerApiKeys[0],
+                    requestId: `route-health-${providerId}-${Date.now()}`,
+                    logger: {
+                        info: () => { },
+                        warn: () => { },
+                        error: () => { },
+                        debug: () => { },
+                        trace: () => { },
+                        fatal: () => { },
+                        silent: () => { },
+                    },
+                    timeoutMs: 5000,
+                    url: provider.capabilities.usageCheckUrl,
+                });
+                if (usage && usage.limit !== undefined && usage.used !== undefined) {
+                    quotaUsagePercent = (usage.used / usage.limit) * 100;
+                    isHealthy = quotaUsagePercent < 95;
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to check usage for provider ${providerId}:`, error);
+                // Assume degraded if we can't check usage
+                isHealthy = false;
+                errorRate = 0.1;
+            }
+        }
+        // Check account status based on auth mode
+        let hasValidAccounts = true;
+        let accountsNearExpiry = false;
+        if (provider.authMode === 'chatgpt_oauth') {
+            // TODO: Check ChatGPT OAuth account status
+            // For now, assume valid if provider has chatgptAccountId
+            hasValidAccounts = !!provider.chatgptAccountId;
+        }
+        else if (provider.authMode === 'kiro') {
+            // TODO: Check Kiro account status
+            // For now, assume valid
+            hasValidAccounts = true;
+        }
+        else if (provider.authMode === 'api_key') {
+            // Check if provider has API keys
+            hasValidAccounts = provider.providerApiKeys.length > 0;
+        }
+        return {
+            providerId,
+            isHealthy,
+            averageResponseTime,
+            errorRate,
+            quotaUsagePercent,
+            hasValidAccounts,
+            accountsNearExpiry,
+            lastChecked: Date.now()
+        };
+    }
+    // Load balancing strategy implementations
+    selectByWeight(providers) {
+        const totalWeight = providers.reduce((sum, p) => sum + p.binding.weight, 0);
+        const random = Math.random() * totalWeight;
+        let currentWeight = 0;
+        for (const provider of providers) {
+            currentWeight += provider.binding.weight;
+            if (random <= currentWeight) {
+                return provider;
+            }
+        }
+        return providers[0]; // Fallback
+    }
+    selectByHealth(providers) {
+        // Sort by eligibility score (highest first)
+        const sorted = [...providers].sort((a, b) => b.eligibilityScore - a.eligibilityScore);
+        return sorted[0];
+    }
+    selectByCost(providers) {
+        // For now, prefer providers in 'cheap' or 'free' tiers
+        // TODO: Implement actual cost calculation based on provider pricing
+        const cheapProviders = providers.filter(p => p.provider.name.toLowerCase().includes('free') ||
+            p.provider.name.toLowerCase().includes('cheap'));
+        if (cheapProviders.length > 0) {
+            return this.selectByHealth(cheapProviders);
+        }
+        return this.selectByHealth(providers);
+    }
+    selectRoundRobin(providers, request) {
+        // Simple round-robin based on request hash
+        const hash = this.hashString(request.route + (request.clientRoute || ''));
+        const index = hash % providers.length;
+        return providers[index];
+    }
+    selectLeastConnections(providers) {
+        // TODO: Implement actual connection tracking
+        // For now, fall back to health-based selection
+        return this.selectByHealth(providers);
+    }
+    selectRandom(providers) {
+        const index = Math.floor(Math.random() * providers.length);
+        return providers[index];
+    }
+    hashString(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return Math.abs(hash);
+    }
+    /**
+     * Clear health cache (useful for testing or forced refresh)
+     */
+    clearHealthCache() {
+        this.healthCheckCache.clear();
+    }
+    /**
+     * Get current health cache stats
+     */
+    getHealthCacheStats() {
+        return {
+            size: this.healthCheckCache.size,
+            entries: Array.from(this.healthCheckCache.keys())
+        };
+    }
+}

package/dist/routing-integration.js

@@ -0,0 +1,155 @@
+import { resolveProviderForRequest } from "./provider-routing.js";
+/**
+ * Enhanced provider resolution that uses routing combos when available,
+ * falling back to the original simple provider selection logic.
+ */
+export async function resolveProviderWithRouting(request, context) {
+    const { clientRoute, providers, providerHint, requestId, startedAt } = request;
+    const { routingComboRepository, routingEngine, healthService } = context;
+    // If explicit provider is requested, honor it directly (bypass routing combos)
+    if (providerHint.providerId || providerHint.providerName) {
+        const resolution = resolveProviderForRequest({
+            providers,
+            explicitProviderId: providerHint.providerId,
+            explicitProviderName: providerHint.providerName,
+        });
+        if ("error" in resolution) {
+            return { error: resolution.error };
+        }
+        return {
+            provider: resolution.provider,
+            matchReason: "explicit_provider",
+            selectionTime: Date.now() - startedAt
+        };
+    }
+    try {
+        // Check if client route has a routing combo assigned
+        const assignedComboId = await routingComboRepository.getClientRouteCombo(clientRoute);
+        if (assignedComboId) {
+            // Use routing combo for provider selection
+            const combo = await routingComboRepository.getComboById(assignedComboId);
+            if (combo && combo.isActive) {
+                const routingResult = await routingEngine.selectProvider(combo, {
+                    route: typeof request.headers["x-proxy-route"] === "string" ? request.headers["x-proxy-route"] : "",
+                    clientRoute,
+                    startTime: startedAt,
+                    priority: request.headers["x-priority"] === "high" ? "high" : "normal",
+                });
+                if (routingResult.success && routingResult.provider) {
+                    return {
+                        provider: routingResult.provider,
+                        matchReason: "routing_combo",
+                        routingComboId: combo.id,
+                        tierName: routingResult.tier,
+                        selectionTime: routingResult.selectionTime,
+                        fallbackCount: routingResult.fallbackCount
+                    };
+                }
+                // If routing combo failed, fall back to simple selection
+                console.warn(`Routing combo ${assignedComboId} failed for client route ${clientRoute}: ${routingResult.error}`);
+            }
+        }
+        // Check for default routing combo if no specific assignment
+        if (!assignedComboId) {
+            const defaultCombo = await routingComboRepository.getDefaultCombo();
+            if (defaultCombo && defaultCombo.isActive) {
+                const routingResult = await routingEngine.selectProvider(defaultCombo, {
+                    route: typeof request.headers["x-proxy-route"] === "string" ? request.headers["x-proxy-route"] : "",
+                    clientRoute,
+                    startTime: startedAt,
+                    priority: request.headers["x-priority"] === "high" ? "high" : "normal",
+                });
+                if (routingResult.success && routingResult.provider) {
+                    return {
+                        provider: routingResult.provider,
+                        matchReason: "routing_combo",
+                        routingComboId: defaultCombo.id,
+                        tierName: routingResult.tier,
+                        selectionTime: routingResult.selectionTime,
+                        fallbackCount: routingResult.fallbackCount
+                    };
+                }
+            }
+        }
+        // Fall back to original simple provider selection
+        const fallbackResolution = resolveProviderForRequest({
+            providers,
+            explicitProviderId: undefined,
+            explicitProviderName: undefined,
+        });
+        if ("error" in fallbackResolution) {
+            return { error: fallbackResolution.error };
+        }
+        return {
+            provider: fallbackResolution.provider,
+            matchReason: "fallback",
+            selectionTime: Date.now() - startedAt
+        };
+    }
+    catch (error) {
+        console.error(`Error in routing integration for client route ${clientRoute}:`, error);
+        // Fall back to original simple provider selection on any error
+        const fallbackResolution = resolveProviderForRequest({
+            providers,
+            explicitProviderId: undefined,
+            explicitProviderName: undefined,
+        });
+        if ("error" in fallbackResolution) {
+            return { error: fallbackResolution.error };
+        }
+        return {
+            provider: fallbackResolution.provider,
+            matchReason: "fallback",
+            selectionTime: Date.now() - startedAt
+        };
+    }
+}
+/**
+ * Record request result for health tracking
+ */
+export function recordRequestResult(context, providerId, responseTime, isError) {
+    try {
+        context.healthService.recordRequestResult(providerId, responseTime, isError);
+    }
+    catch (error) {
+        console.error(`Failed to record request result for provider ${providerId}:`, error);
+    }
+}
+/**
+ * Get routing combo assignment for a client route
+ */
+export async function getClientRouteCombo(context, clientRoute) {
+    try {
+        return await context.routingComboRepository.getClientRouteCombo(clientRoute);
+    }
+    catch (error) {
+        console.error(`Failed to get routing combo for client route ${clientRoute}:`, error);
+        return null;
+    }
+}
+/**
+ * Assign a routing combo to a client route
+ */
+export async function assignClientRouteCombo(context, clientRoute, comboId) {
+    try {
+        await context.routingComboRepository.assignClientRouteCombo(clientRoute, comboId);
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to assign routing combo ${comboId} to client route ${clientRoute}:`, error);
+        return false;
+    }
+}
+/**
+ * Remove routing combo assignment from a client route
+ */
+export async function unassignClientRouteCombo(context, clientRoute) {
+    try {
+        await context.routingComboRepository.unassignClientRouteCombo(clientRoute);
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to unassign routing combo from client route ${clientRoute}:`, error);
+        return false;
+    }
+}