ai-agent-router 0.1.0

package/src/server/gateway-server.ts

@@ -0,0 +1,306 @@
+/**
+ * Standalone Gateway Server
+ * This server only provides API gateway functionality for external clients
+ * It does NOT include the Web UI
+ */
+
+import http from 'http';
+import { getDatabase, closeDatabase } from '../db/database';
+import { handleGatewayRequest } from './gateway';
+import { getConfig } from '../db/queries';
+import type { GatewayRequest, GatewayResponse } from './providers/types';
+
+interface GatewayServerOptions {
+  port: number;
+  hostname?: string;
+  apiKey?: string;
+}
+
+export class GatewayServer {
+  private server: http.Server | null = null;
+  private port: number;
+  private hostname: string;
+  private apiKey: string | null;
+
+  constructor(options: GatewayServerOptions) {
+    this.port = options.port;
+    this.hostname = options.hostname || 'localhost';
+    this.apiKey = options.apiKey || null;
+  }
+
+  /**
+   * Validate API key if configured
+   */
+  private validateApiKey(authHeader: string | null): boolean {
+    if (!this.apiKey) {
+      return true; // No API key configured, allow all requests
+    }
+
+    if (!authHeader) {
+      return false;
+    }
+
+    // Support both "Bearer <key>" and direct key
+    const key = authHeader.startsWith('Bearer ')
+      ? authHeader.substring(7)
+      : authHeader;
+
+    return key === this.apiKey;
+  }
+
+  /**
+   * Parse request body
+   */
+  private async parseBody(req: http.IncomingMessage): Promise<any> {
+    return new Promise((resolve, reject) => {
+      let body = '';
+      req.on('data', (chunk) => {
+        body += chunk.toString();
+      });
+      req.on('end', () => {
+        if (!body) {
+          resolve(null);
+          return;
+        }
+        try {
+          resolve(JSON.parse(body));
+        } catch {
+          resolve(body);
+        }
+      });
+      req.on('error', reject);
+    });
+  }
+
+  /**
+   * Handle gateway request
+   */
+  private async handleRequest(
+    req: http.IncomingMessage,
+    res: http.ServerResponse
+  ): Promise<void> {
+    const startTime = Date.now();
+    const requestId = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    
+    console.log(`[Gateway Server ${requestId}] Incoming request:`, {
+      method: req.method,
+      url: req.url,
+      headers: {
+        'content-type': req.headers['content-type'],
+        'authorization': req.headers['authorization'] ? '***' : undefined,
+      },
+    });
+
+    // CORS headers
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+
+    // Handle preflight
+    if (req.method === 'OPTIONS') {
+      console.log(`[Gateway Server ${requestId}] Handling OPTIONS preflight`);
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+
+    try {
+      // Validate API key if configured
+      const authHeader = req.headers.authorization || req.headers['x-api-key'] as string || null;
+      if (!this.validateApiKey(authHeader)) {
+        console.log(`[Gateway Server ${requestId}] API key validation failed`);
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: { message: 'Invalid or missing API key' } }));
+        return;
+      }
+
+      // Parse URL
+      const url = new URL(req.url || '/', `http://${this.hostname}:${this.port}`);
+      const pathname = url.pathname;
+      console.log(`[Gateway Server ${requestId}] Parsed URL:`, {
+        pathname,
+        searchParams: Object.fromEntries(url.searchParams.entries()),
+      });
+
+      // Parse body first to get model ID
+      let body: any = null;
+      if (req.method !== 'GET' && req.method !== 'HEAD') {
+        body = await this.parseBody(req);
+        console.log(`[Gateway Server ${requestId}] Parsed body:`, body ? JSON.stringify(body).substring(0, 200) : 'null');
+      }
+
+      // Get model ID from query, body, or URL path
+      // Priority: query param > body > path segment
+      let modelId = url.searchParams.get('model') || 
+                   url.searchParams.get('model_id') ||
+                   null;
+
+      // Get provider name (optional, for disambiguating models with same model_id)
+      const providerName = url.searchParams.get('provider') || null;
+
+      console.log(`[Gateway Server ${requestId}] Model ID from query:`, modelId);
+      console.log(`[Gateway Server ${requestId}] Provider from query:`, providerName);
+
+      // Try to get from body if not in query
+      if (!modelId && body) {
+        modelId = body.model || body.model_id || null;
+        console.log(`[Gateway Server ${requestId}] Model ID from body:`, modelId);
+      }
+      // Also get provider from body if not in query
+      const bodyProvider = body?.provider || null;
+      if (bodyProvider) {
+        console.log(`[Gateway Server ${requestId}] Provider from body:`, bodyProvider);
+      }
+
+      // Try to get from URL path (e.g., /v1/models/{model_id}/...)
+      if (!modelId && pathname) {
+        const pathMatch = pathname.match(/\/(?:v1|api\/gateway)\/models\/([^\/]+)/);
+        if (pathMatch) {
+          modelId = pathMatch[1];
+          console.log(`[Gateway Server ${requestId}] Model ID from path:`, modelId);
+        }
+      }
+
+      if (!modelId) {
+        console.log(`[Gateway Server ${requestId}] Error: Model ID not found`);
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ 
+          error: { 
+            message: 'Model ID not specified. Please provide model ID in query parameter (?model=xxx), request body, or URL path.' 
+          } 
+        }));
+        return;
+      }
+
+      console.log(`[Gateway Server ${requestId}] Processing request for model:`, modelId, 'provider:', providerName || bodyProvider || 'not specified');
+
+      // Build gateway request
+      const gatewayRequest: GatewayRequest = {
+        method: req.method || 'GET',
+        path: pathname,
+        headers: req.headers as Record<string, string>,
+        query: Object.fromEntries(url.searchParams.entries()),
+        body: body,
+      };
+
+      // Handle the request (pass provider name if specified)
+      const finalProviderName = providerName || bodyProvider;
+      console.log(`[Gateway Server ${requestId}] Calling handleGatewayRequest with model:`, modelId, 'provider:', finalProviderName || 'undefined');
+      
+      const response = await handleGatewayRequest(modelId, gatewayRequest, finalProviderName || undefined);
+
+      console.log(`[Gateway Server ${requestId}] Response received:`, {
+        status: response.status,
+        bodyType: typeof response.body,
+        bodyPreview: typeof response.body === 'string' 
+          ? response.body.substring(0, 200) 
+          : JSON.stringify(response.body).substring(0, 200),
+      });
+
+      // Send response
+      // If body is already a string, send it directly; otherwise stringify it
+      let responseBody: string;
+      if (response.body === null || response.body === undefined) {
+        responseBody = '';
+      } else if (typeof response.body === 'string') {
+        responseBody = response.body;
+      } else {
+        responseBody = JSON.stringify(response.body);
+      }
+      
+      const duration = Date.now() - startTime;
+      console.log(`[Gateway Server ${requestId}] Sending response (${duration}ms):`, {
+        status: response.status,
+        bodyLength: responseBody.length,
+      });
+      
+      res.writeHead(response.status, response.headers);
+      res.end(responseBody);
+    } catch (error: any) {
+      const duration = Date.now() - startTime;
+      console.error(`[Gateway Server ${requestId}] Error (${duration}ms):`, {
+        message: error.message,
+        stack: error.stack,
+      });
+      
+      if (!res.headersSent) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          error: {
+            message: error.message || 'Internal server error',
+            type: 'gateway_error',
+          },
+        }));
+      }
+    }
+  }
+
+  /**
+   * Start the gateway server
+   */
+  async start(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      // Initialize database
+      try {
+        getDatabase();
+      } catch (error: any) {
+        reject(new Error(`Failed to initialize database: ${error.message}`));
+        return;
+      }
+
+      this.server = http.createServer((req, res) => {
+        console.log(`[Gateway Server] New connection from ${req.socket.remoteAddress}:${req.socket.remotePort}`);
+        this.handleRequest(req, res).catch((error) => {
+          console.error('[Gateway Server] Unhandled request error:', error);
+          if (!res.headersSent) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: { message: 'Internal server error' } }));
+          }
+        });
+      });
+
+      this.server.listen(this.port, this.hostname, () => {
+        console.log(`✓ Gateway server ready on http://${this.hostname}:${this.port}`);
+        console.log(`  API Gateway: http://${this.hostname}:${this.port}/api/gateway`);
+        if (this.apiKey) {
+          console.log(`  API Key authentication: Enabled`);
+        }
+        resolve();
+      });
+
+      this.server.on('error', (error: any) => {
+        if (error.code === 'EADDRINUSE') {
+          reject(new Error(`Port ${this.port} is already in use`));
+        } else {
+          reject(error);
+        }
+      });
+
+      // Graceful shutdown
+      process.on('SIGTERM', () => {
+        this.stop();
+      });
+
+      process.on('SIGINT', () => {
+        this.stop();
+      });
+    });
+  }
+
+  /**
+   * Stop the gateway server
+   */
+  async stop(): Promise<void> {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => {
+          console.log('Gateway server closed');
+          closeDatabase();
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+}

package/src/server/gateway.ts

@@ -0,0 +1,163 @@
+import { getAllProviders } from '@/db/queries';
+import { getProviderAdapter } from './providers';
+import { logRequest } from './logger';
+import type { GatewayRequest, GatewayResponse } from './providers/types';
+
+export async function handleGatewayRequest(
+  modelId: string,
+  request: GatewayRequest,
+  providerName?: string
+): Promise<GatewayResponse> {
+  const startTime = Date.now();
+  const requestId = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  
+  console.log(`[Gateway ${requestId}] handleGatewayRequest called:`, {
+    modelId,
+    providerName: providerName || 'not specified',
+    method: request.method,
+    path: request.path,
+  });
+
+  try {
+    // Provider name is required for gateway requests
+    if (!providerName) {
+      console.log(`[Gateway ${requestId}] Provider name not specified`);
+      return {
+        status: 400,
+        headers: { 'Content-Type': 'application/json' },
+        body: { 
+          error: { 
+            message: 'Provider name is required. Please specify provider parameter.',
+            type: 'missing_provider',
+          } 
+        },
+      };
+    }
+
+    // Find the provider by name
+    const providers = getAllProviders();
+    const provider = providers.find(p => p.name.toLowerCase() === providerName.toLowerCase());
+    
+    if (!provider) {
+      console.log(`[Gateway ${requestId}] Provider not found:`, providerName);
+      const availableProviders = providers.map(p => p.name).join(', ');
+      return {
+        status: 404,
+        headers: { 'Content-Type': 'application/json' },
+        body: { 
+          error: { 
+            message: `Provider "${providerName}" not found. Available providers: ${availableProviders || 'none'}`,
+            type: 'provider_not_found',
+          } 
+        },
+      };
+    }
+
+    console.log(`[Gateway ${requestId}] Provider found:`, {
+      id: provider.id,
+      name: provider.name,
+      protocol: provider.protocol,
+      base_url: provider.base_url,
+      hasApiKey: !!provider.api_key,
+    });
+
+    // Create a model object with the user-provided model_id and the provider configuration
+    // The model_id comes from the user request, not from the database
+    const model = {
+      id: 0, // Not used for gateway requests
+      provider_id: provider.id,
+      name: modelId, // Use model_id as name for logging
+      model_id: modelId, // User-provided model ID
+      enabled: true, // Always enabled for gateway requests
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      provider: {
+        id: provider.id,
+        name: provider.name,
+        protocol: provider.protocol,
+        base_url: provider.base_url,
+        api_key: provider.api_key,
+      },
+    };
+
+    // Get provider adapter
+    const adapter = getProviderAdapter(provider.protocol);
+
+    // Forward the request using provider's config and user's model_id
+    console.log(`[Gateway ${requestId}] Forwarding request with:`, {
+      provider: provider.name,
+      protocol: provider.protocol,
+      modelId: modelId,
+    });
+    
+    const response = await adapter.forwardRequest(model as any, request);
+
+    // Log the request (use NULL model_id for gateway requests)
+    const responseTimeMs = Date.now() - startTime;
+    try {
+      await logRequest(
+        {
+          modelId: null as any, // NULL for gateway requests (no model in database)
+          method: request.method,
+          path: request.path,
+          headers: request.headers,
+          query: request.query,
+          body: request.body,
+        },
+        {
+          status: response.status,
+          headers: response.headers,
+          body: response.body,
+          responseTimeMs,
+        }
+      );
+      console.log(`[Gateway ${requestId}] Request logged successfully`);
+    } catch (logError: any) {
+      // Log error but don't fail the request
+      console.error(`[Gateway ${requestId}] Failed to log request:`, logError.message);
+    }
+
+    return response;
+  } catch (error: any) {
+    const responseTimeMs = Date.now() - startTime;
+    console.error(`[Gateway ${requestId}] Error:`, {
+      message: error.message,
+      stack: error.stack,
+    });
+    
+    const errorResponse: GatewayResponse = {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+      body: {
+        error: {
+          message: error.message || 'Internal server error',
+          type: 'gateway_error',
+        },
+      },
+    };
+
+    // Try to log error request (use NULL model_id)
+    try {
+      await logRequest(
+        {
+          modelId: null as any, // NULL for gateway requests
+          method: request.method,
+          path: request.path,
+          headers: request.headers,
+          query: request.query,
+          body: request.body,
+        },
+        {
+          status: errorResponse.status,
+          headers: errorResponse.headers,
+          body: errorResponse.body,
+          responseTimeMs,
+        }
+      );
+    } catch (logError: any) {
+      console.error(`[Gateway ${requestId}] Failed to log error request:`, logError.message);
+    }
+
+    return errorResponse;
+  }
+}

package/src/server/logger.ts

@@ -0,0 +1,96 @@
+import { createRequestLog } from '@/db/queries';
+import { maskApiKey, maskToken } from './crypto';
+
+export interface LogRequest {
+  modelId: number | null; // Allow null for gateway requests
+  method: string;
+  path: string;
+  headers: Record<string, string>;
+  query: Record<string, string>;
+  body: any;
+}
+
+export interface LogResponse {
+  status: number;
+  headers: Record<string, string>;
+  body: any;
+  responseTimeMs: number;
+}
+
+export async function logRequest(
+  request: LogRequest,
+  response: LogResponse
+): Promise<void> {
+  try {
+    // Mask sensitive information
+    const maskedHeaders = maskSensitiveHeaders(request.headers);
+    const maskedBody = maskSensitiveData(request.body);
+
+    await createRequestLog({
+      model_id: request.modelId,
+      request_method: request.method,
+      request_path: request.path,
+      request_headers: JSON.stringify(maskedHeaders),
+      request_query: JSON.stringify(request.query),
+      request_body: JSON.stringify(maskedBody),
+      response_status: response.status,
+      response_body: JSON.stringify(response.body),
+      response_time_ms: response.responseTimeMs,
+    });
+  } catch (error) {
+    console.error('Failed to log request:', error);
+    // Don't throw - logging failure shouldn't break the request
+  }
+}
+
+function maskSensitiveHeaders(headers: Record<string, string>): Record<string, string> {
+  const masked = { ...headers };
+  
+  // Mask API keys
+  if (masked['authorization']) {
+    const auth = masked['authorization'];
+    if (auth.startsWith('Bearer ')) {
+      masked['authorization'] = `Bearer ${maskToken(auth.substring(7))}`;
+    } else {
+      masked['authorization'] = maskToken(auth);
+    }
+  }
+  
+  if (masked['x-api-key']) {
+    masked['x-api-key'] = maskApiKey(masked['x-api-key']);
+  }
+  
+  if (masked['api-key']) {
+    masked['api-key'] = maskApiKey(masked['api-key']);
+  }
+  
+  return masked;
+}
+
+function maskSensitiveData(data: any): any {
+  if (!data || typeof data !== 'object') {
+    return data;
+  }
+  
+  if (Array.isArray(data)) {
+    return data.map(maskSensitiveData);
+  }
+  
+  const masked: any = {};
+  for (const [key, value] of Object.entries(data)) {
+    const lowerKey = key.toLowerCase();
+    if (lowerKey.includes('api') && lowerKey.includes('key')) {
+      masked[key] = maskApiKey(String(value));
+    } else if (lowerKey.includes('token')) {
+      masked[key] = maskToken(String(value));
+    } else if (lowerKey === 'authorization') {
+      masked[key] = maskToken(String(value));
+    } else if (typeof value === 'object' && value !== null) {
+      masked[key] = maskSensitiveData(value);
+    } else {
+      masked[key] = value;
+    }
+  }
+  
+  return masked;
+}

package/src/server/providers/anthropic.ts

@@ -0,0 +1,121 @@
+import type { ProviderAdapter, GatewayRequest, GatewayResponse } from './types';
+import type { Model, Provider } from '@/db/schema';
+import { decryptApiKey } from '@/server/crypto';
+
+export class AnthropicAdapter implements ProviderAdapter {
+  async forwardRequest(
+    model: Model & { provider: Provider },
+    request: GatewayRequest
+  ): Promise<GatewayResponse> {
+    console.log('[Anthropic Adapter] Starting forwardRequest:', {
+      modelId: model.model_id,
+      modelName: model.name,
+      providerName: model.provider.name,
+      providerBaseUrl: model.provider.base_url,
+      hasEncryptedApiKey: !!model.provider.api_key,
+      encryptedApiKeyLength: model.provider.api_key?.length || 0,
+    });
+    
+    let apiKey: string;
+    try {
+      apiKey = decryptApiKey(model.provider.api_key);
+      console.log('[Anthropic Adapter] API key decrypted successfully, length:', apiKey.length);
+    } catch (error: any) {
+      console.error('[Anthropic Adapter] Failed to decrypt API key:', error.message);
+      return {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+        body: { error: { message: 'Failed to decrypt API key', type: 'decryption_error' } },
+      };
+    }
+    
+    let baseUrl = model.provider.base_url || 'https://api.anthropic.com/v1';
+    
+    // Normalize baseUrl
+    baseUrl = baseUrl.trim().replace(/\/+$/, ''); // Remove trailing slashes
+    
+    // Build the target URL
+    let targetPath = request.path;
+    
+    // If path is root or empty, default to messages endpoint
+    if (!targetPath || targetPath === '/' || targetPath === '') {
+      targetPath = 'messages';
+    } else if (targetPath.startsWith('/v1/')) {
+      targetPath = targetPath.substring(4);
+    } else if (targetPath.startsWith('/')) {
+      targetPath = targetPath.substring(1);
+    }
+    
+    // Ensure baseUrl ends with /v1
+    if (!baseUrl.endsWith('/v1')) {
+      baseUrl = baseUrl + '/v1';
+    }
+    
+    const url = `${baseUrl}/${targetPath}`;
+    
+    console.log('[Anthropic Adapter] Forwarding request:', {
+      baseUrl: model.provider.base_url,
+      normalizedBaseUrl: baseUrl,
+      originalPath: request.path,
+      targetPath,
+      url,
+      method: request.method,
+      hasApiKey: !!apiKey,
+      apiKeyPrefix: apiKey ? apiKey.substring(0, 10) + '...' : 'none',
+    });
+
+    // Prepare headers
+    const headers: Record<string, string> = {
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+      'Content-Type': 'application/json',
+      ...request.headers,
+    };
+    delete headers['host'];
+    delete headers['connection'];
+    delete headers['authorization'];
+
+    console.log('[Anthropic Adapter] Request headers:', {
+      'Content-Type': headers['Content-Type'],
+      'x-api-key': headers['x-api-key'] ? '***' : 'none',
+      'anthropic-version': headers['anthropic-version'],
+    });
+
+    // Make the request
+    const response = await fetch(url, {
+      method: request.method,
+      headers,
+      body: request.method !== 'GET' && request.method !== 'HEAD' ? JSON.stringify(request.body) : undefined,
+    });
+    
+    console.log('[Anthropic Adapter] Response status:', response.status, response.statusText);
+
+    const responseBody = await response.text();
+    console.log('[Anthropic Adapter] Response body preview:', responseBody.substring(0, 200));
+    
+    let parsedBody: any;
+    try {
+      parsedBody = JSON.parse(responseBody);
+    } catch {
+      parsedBody = responseBody;
+      console.log('[Anthropic Adapter] Response body is not JSON, returning as string');
+    }
+
+    return {
+      status: response.status,
+      headers: Object.fromEntries(response.headers.entries()),
+      body: parsedBody,
+    };
+  }
+
+  async listModels(provider: Provider): Promise<Array<{ id: string; name: string }>> {
+    // Anthropic doesn't have a public models endpoint
+    // Return common models
+    return [
+      { id: 'claude-3-5-sonnet-20241022', name: 'Claude 3.5 Sonnet' },
+      { id: 'claude-3-opus-20240229', name: 'Claude 3 Opus' },
+      { id: 'claude-3-sonnet-20240229', name: 'Claude 3 Sonnet' },
+      { id: 'claude-3-haiku-20240307', name: 'Claude 3 Haiku' },
+    ];
+  }
+}