costhawk 1.0.0

package/costcanary/app/api/proxy/anthropic/route.ts

@@ -0,0 +1,539 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@clerk/nextjs/server';
+import { prisma } from '@/lib/prisma';
+import { checkUsageLimit, incrementUsage } from '@/lib/usage-limits';
+import { logAuditEvent } from '@/lib/audit-events';
+import { decrypt } from '@/lib/encryption';
+import { resolveWrappedKey, validateKeyPolicy } from '@/lib/wrapped-keys';
+import { headers } from 'next/headers';
+import { Provider } from '@prisma/client';
+import { resolveCanonicalModel } from '@/lib/model-alias';
+import { getActivePrice, computeCost, getFallbackPrice } from '@/lib/pricing';
+import { parseSSEStream } from '@/lib/sse-parser';
+import { estimateAnthropicTokens, estimateCompletionTokens } from '@/lib/tokens';
+
+// Force Node.js runtime and disable static optimization
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+export const revalidate = 0;
+
+// CORS headers for public API access
+function getCorsHeaders() {
+  return {
+    'Access-Control-Allow-Origin': process.env.NEXT_PUBLIC_APP_ORIGIN || '*',
+    'Access-Control-Allow-Methods': 'GET,POST,OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type,Authorization',
+  };
+}
+
+// Handle preflight requests
+export async function OPTIONS() {
+  return new NextResponse(null, { 
+    status: 204, 
+    headers: getCorsHeaders()
+  });
+}
+
+// Simple GET for health checks
+export async function GET() {
+  return NextResponse.json(
+    { ok: true, service: 'anthropic-proxy', timestamp: new Date().toISOString() },
+    { headers: getCorsHeaders() }
+  );
+}
+
+// This is the Anthropic API proxy that handles wrapped keys and enforces usage limits
+export async function POST(req: NextRequest) {
+  const requestId = Math.random().toString(36).substring(7);
+  
+  // Critical debug logging for production issues
+  // DEBUG: console.log(`[proxy-anthropic-${requestId}] Request received:`, {
+  //   url: req.url,
+  //   method: req.method,
+  //   hasAuth: !!req.headers.get('authorization'),
+  //   authPrefix: req.headers.get('authorization')?.substring(0, 15),
+  // });
+  
+  try {
+    // Parse body once at the beginning
+    const body = await req.json();
+    
+    // Check if this is a wrapped key request
+    const authHeader = req.headers.get('authorization');
+    let isWrappedKey = false;
+    let wrappedKeyId: string | null = null;
+    let resolvedKey: Awaited<ReturnType<typeof resolveWrappedKey>> = null;
+    
+    if (authHeader?.startsWith('Bearer ch_sk_')) {
+      // This is a wrapped key
+      isWrappedKey = true;
+      wrappedKeyId = authHeader.substring(7); // Remove "Bearer "
+      
+      // DEBUG: console.log(`[proxy-anthropic-${requestId}] Wrapped key detected:`, {
+      //   wrappedKeyId: wrappedKeyId.substring(0, 20) + '...',
+      //   fullKeyLength: wrappedKeyId.length,
+      // });
+      
+      try {
+        // Resolve the wrapped key
+        resolvedKey = await resolveWrappedKey(wrappedKeyId);
+        
+        if (!resolvedKey) {
+          // DEBUG: console.error(`[proxy-anthropic-${requestId}] Wrapped key not found:`, wrappedKeyId);
+          return NextResponse.json(
+            { error: 'Invalid or expired wrapped key' },
+            { status: 401 }
+          );
+        }
+        
+        // Verify it's an Anthropic key
+        if (resolvedKey.provider !== 'ANTHROPIC') {
+          return NextResponse.json(
+            { error: `This wrapped key is for ${resolvedKey.provider}, not Anthropic` },
+            { status: 400 }
+          );
+        }
+        
+        // DEBUG: console.log(`[proxy-anthropic-${requestId}] Wrapped key resolved:`, {
+        //   userId: resolvedKey.userId,
+        //   orgId: resolvedKey.orgId,
+        //   provider: resolvedKey.provider,
+        //   hasPolicy: !!resolvedKey.policy,
+        // });
+        
+      } catch (keyError) {
+        // DEBUG: console.error(`[proxy-anthropic-${requestId}] Wrapped key resolution error:`, keyError);
+        return NextResponse.json(
+          { error: 'Failed to resolve wrapped key', details: keyError instanceof Error ? keyError.message : 'Unknown error' },
+          { status: 500 }
+        );
+      }
+      
+      try {
+        // Validate policy
+        const headersList = await headers();
+        const ipAddress = headersList.get('x-forwarded-for')?.split(',')[0] || 
+                         headersList.get('x-real-ip') || undefined;
+        
+        const policyValidation = await validateKeyPolicy(resolvedKey.policy, {
+          model: body.model,
+          orgId: resolvedKey.orgId,
+          ipAddress
+        });
+        
+        if (!policyValidation.allowed) {
+          return NextResponse.json(
+            { error: policyValidation.reason || 'Request blocked by policy' },
+            { status: 403 }
+          );
+        }
+        
+      } catch (policyError) {
+        return NextResponse.json(
+          { error: 'Policy validation failed', details: policyError instanceof Error ? policyError.message : 'Unknown error' },
+          { status: 500 }
+        );
+      }
+    }
+    
+    // 1. Authenticate user (for non-wrapped key requests)
+    let user;
+    if (isWrappedKey && resolvedKey) {
+      user = await prisma.user.findUnique({
+        where: { id: resolvedKey.userId }
+      });
+    } else {
+      const { userId: clerkId } = await auth();
+      if (!clerkId) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+      }
+      
+      user = await prisma.user.findUnique({
+        where: { clerkId }
+      });
+    }
+
+    if (!user) {
+      return NextResponse.json({ error: 'User not found' }, { status: 404 });
+    }
+
+    // 3. CHECK USAGE LIMITS (CRITICAL!)
+    const usageCheck = await checkUsageLimit(user.id);
+    
+    if (!usageCheck.allowed) {
+      // Log the rejection
+      await logAuditEvent({
+        userId: user.id,
+        action: 'api_call_rejected',
+        details: {
+          reason: 'usage_limit_exceeded',
+          currentUsage: usageCheck.currentUsage,
+          limit: usageCheck.limit,
+          tier: usageCheck.tier,
+        },
+      });
+
+      // Return 402 Payment Required
+      return NextResponse.json(
+        {
+          error: 'Usage limit exceeded',
+          message: usageCheck.message,
+          upgradeUrl: usageCheck.upgradeUrl,
+          usage: {
+            current: usageCheck.currentUsage,
+            limit: usageCheck.limit,
+            tier: usageCheck.tier,
+          },
+        },
+        { status: 402 } // Payment Required
+      );
+    }
+
+    // 4. Get API key
+    let decryptedKey: string;
+    let apiKeyId: string | undefined;
+    
+    if (isWrappedKey && resolvedKey) {
+      // Use the wrapped key's real API key
+      decryptedKey = resolvedKey.realKey;
+      // No apiKeyId for wrapped keys
+    } else {
+      // Use regular API key - need to fetch it
+      const apiKey = await prisma.apiKey.findFirst({
+        where: {
+          userId: user.id,
+          provider: 'ANTHROPIC',
+          isActive: true
+        }
+      });
+      
+      if (!apiKey) {
+        return NextResponse.json(
+          { error: 'No Anthropic API key configured. Please add one in settings.' },
+          { status: 400 }
+        );
+      }
+      
+      apiKeyId = apiKey.id;
+      decryptedKey = decrypt(apiKey.encryptedKey);
+    }
+
+    // 5. Forward request to Anthropic
+    const startTime = Date.now();
+
+    const anthropicResponse = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': decryptedKey,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify(body),
+      // @ts-expect-error Node 18 streaming support
+      duplex: 'half',
+    });
+
+    const contentType = anthropicResponse.headers.get('content-type') || '';
+    const latency = Date.now() - startTime;
+    
+    // Check if this is a streaming response (SSE)
+    const isStreaming = contentType.toLowerCase().includes('text/event-stream');
+    
+    if (isStreaming) {
+      // For streaming responses, use the new SSE parser
+      // DEBUG: console.log(`[proxy-anthropic-${requestId}] Streaming response detected, parsing with tee`);
+      
+      if (anthropicResponse.ok && anthropicResponse.body) {
+        // Parse SSE stream to extract usage
+        const { clientStream, parsePromise } = await parseSSEStream(
+          anthropicResponse.body,
+          'ANTHROPIC'
+        );
+        
+        // Create response with client stream
+        const response = new Response(clientStream, {
+          status: anthropicResponse.status,
+          headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache, no-transform',
+            'X-Accel-Buffering': 'no',
+            ...getCorsHeaders(),
+          },
+        });
+        
+        // Process usage data asynchronously
+        parsePromise.then(async (parseResult) => {
+          await incrementUsage(user.id);
+          
+          // Resolve canonical model
+          const canonicalModel = await resolveCanonicalModel(
+            Provider.ANTHROPIC,
+            body.model,
+            parseResult.model
+          );
+          
+          // Get pricing and compute cost
+          let cost = 0;
+          let costIn = 0;
+          let costOut = 0;
+          let estimated = false;
+          let pricingVersionId: string | undefined;
+          
+          if (canonicalModel) {
+            const price = await getActivePrice(Provider.ANTHROPIC, canonicalModel) ||
+                         getFallbackPrice(Provider.ANTHROPIC, canonicalModel);
+            
+            if (price) {
+              pricingVersionId = price.versionId !== 'fallback' ? price.versionId : undefined;
+              
+              if (parseResult.usage) {
+                const breakdown = computeCost(parseResult.usage, price);
+                cost = breakdown.total;
+                costIn = breakdown.costIn;
+                costOut = breakdown.costOut;
+              } else if (parseResult.completionText) {
+                // Estimate if no usage provided
+                const inputTokens = estimateAnthropicTokens(body.messages || []).inputTokens;
+                const completionTokens = estimateCompletionTokens(parseResult.completionText);
+                const breakdown = computeCost(
+                  { input: inputTokens, output: completionTokens },
+                  price
+                );
+                cost = breakdown.total;
+                costIn = breakdown.costIn;
+                costOut = breakdown.costOut;
+                estimated = true;
+              }
+            }
+          }
+          
+          // Log usage
+          await prisma.usageLog.create({
+            data: {
+              userId: user.id,
+              apiKeyId: apiKeyId,
+              wrappedKeyId: isWrappedKey && resolvedKey ? resolvedKey.wrappedKey.id : undefined,
+              provider: Provider.ANTHROPIC,
+              model: body.model || 'unknown',
+              responseModel: parseResult.model,
+              canonicalModel,
+              pricingVersionId,
+              endpoint: '/v1/messages',
+              inputTokens: (typeof parseResult.usage?.input_tokens === 'number' ? parseResult.usage.input_tokens : 
+                           typeof parseResult.usage?.input === 'number' ? parseResult.usage.input : 0),
+              outputTokens: (typeof parseResult.usage?.output_tokens === 'number' ? parseResult.usage.output_tokens : 
+                            typeof parseResult.usage?.output === 'number' ? parseResult.usage.output : 0),
+              totalTokens: ((typeof parseResult.usage?.input_tokens === 'number' ? parseResult.usage.input_tokens : 0) +
+                           (typeof parseResult.usage?.output_tokens === 'number' ? parseResult.usage.output_tokens : 0)),
+              cost,
+              costInputUsd: costIn,
+              costOutputUsd: costOut,
+              latency,
+              statusCode: anthropicResponse.status,
+              metadata: { streaming: true, estimated },
+              estimated,
+            },
+          });
+        }).catch(async error => {
+          // DEBUG: console.error(`[proxy-anthropic-${requestId}] SSE parse error:`, error);
+          // Still log usage but mark as failed parsing
+          try {
+            await incrementUsage(user.id);
+            await prisma.usageLog.create({
+              data: {
+                userId: user.id,
+                apiKeyId: apiKeyId,
+                wrappedKeyId: isWrappedKey && resolvedKey ? resolvedKey.wrappedKey.id : undefined,
+                provider: Provider.ANTHROPIC,
+                model: body.model || 'unknown',
+                endpoint: '/v1/messages',
+                inputTokens: 0,
+                outputTokens: 0,
+                totalTokens: 0,
+                cost: 0,
+                latency,
+                statusCode: anthropicResponse.status,
+                metadata: { streaming: true, parseError: true },
+                error: error instanceof Error ? error.message : 'SSE parse failed',
+              },
+            });
+          } catch (logError) {
+            // DEBUG: console.error(`[proxy-anthropic-${requestId}] Failed to log parse error:`, logError);
+          }
+        });
+        
+        return response;
+      } else {
+        // Non-OK response, pass through
+        return new Response(anthropicResponse.body, {
+          status: anthropicResponse.status,
+          headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache, no-transform',
+            'X-Accel-Buffering': 'no',
+            ...getCorsHeaders(),
+          },
+        });
+      }
+    }
+    
+    // For non-streaming responses, parse JSON
+    let responseData;
+    try {
+      const responseText = await anthropicResponse.text();
+      responseData = JSON.parse(responseText);
+    } catch (parseError) {
+      // DEBUG: console.error(`[proxy-anthropic-${requestId}] Failed to parse response:`, parseError);
+      // Return the raw response if we can't parse it
+      return new Response(anthropicResponse.body, {
+        status: anthropicResponse.status,
+        headers: {
+          ...Object.fromEntries(anthropicResponse.headers.entries()),
+          ...getCorsHeaders(),
+        },
+      });
+    }
+
+    // Variables for cost tracking (declared outside for header access)
+    let cost = 0;
+    let costIn = 0;
+    let costOut = 0;
+    let estimated = false;
+
+    // 6. Track usage (AFTER successful call)
+    if (anthropicResponse.ok) {
+      await incrementUsage(user.id);
+
+      // Extract model from response
+      const responseModel = responseData.model;
+      
+      // Resolve canonical model
+      const canonicalModel = await resolveCanonicalModel(
+        Provider.ANTHROPIC,
+        body.model,
+        responseModel
+      );
+      
+      // Get pricing and compute cost
+      const usage = responseData.usage || {};
+      let pricingVersionId: string | undefined;
+      
+      if (canonicalModel) {
+        const price = await getActivePrice(Provider.ANTHROPIC, canonicalModel) ||
+                     getFallbackPrice(Provider.ANTHROPIC, canonicalModel);
+        
+        if (price) {
+          pricingVersionId = price.versionId !== 'fallback' ? price.versionId : undefined;
+          
+          if (usage.input_tokens || usage.output_tokens) {
+            const breakdown = computeCost({
+              input: usage.input_tokens,
+              output: usage.output_tokens
+            }, price);
+            cost = breakdown.total;
+            costIn = breakdown.costIn;
+            costOut = breakdown.costOut;
+          } else {
+            // Estimate tokens if not provided
+            const inputTokens = estimateAnthropicTokens(body.messages || []).inputTokens;
+            const completionText = responseData.content?.[0]?.text;
+            const completionTokens = completionText ? 
+              estimateCompletionTokens(completionText) : 0;
+            const breakdown = computeCost(
+              { input: inputTokens, output: completionTokens },
+              price
+            );
+            cost = breakdown.total;
+            costIn = breakdown.costIn;
+            costOut = breakdown.costOut;
+            estimated = true;
+          }
+        }
+      }
+      
+      // Log usage details
+      await prisma.usageLog.create({
+        data: {
+          userId: user.id,
+          apiKeyId: apiKeyId,
+          wrappedKeyId: isWrappedKey && resolvedKey ? resolvedKey.wrappedKey.id : undefined,
+          provider: Provider.ANTHROPIC,
+          model: body.model || 'unknown',
+          responseModel,
+          canonicalModel,
+          pricingVersionId,
+          endpoint: '/v1/messages',
+          inputTokens: usage.input_tokens || 0,
+          outputTokens: usage.output_tokens || 0,
+          totalTokens: (usage.input_tokens || 0) + (usage.output_tokens || 0),
+          cost,
+          costInputUsd: costIn,
+          costOutputUsd: costOut,
+          latency,
+          statusCode: anthropicResponse.status,
+          estimated,
+        },
+      });
+
+      // Update last used timestamp
+      if (apiKeyId) {
+        await prisma.apiKey.update({
+          where: { id: apiKeyId },
+          data: { lastUsed: new Date() },
+        });
+      }
+    }
+
+    // 7. Add usage warning headers if needed
+    const responseHeaders: Record<string, string> = {
+      ...getCorsHeaders(),
+      'X-CH-Proxy': 'anthropic',
+      'X-CH-Request-Id': requestId,
+    };
+    
+    if (usageCheck.message) {
+      responseHeaders['X-Usage-Warning'] = usageCheck.message;
+      responseHeaders['X-Usage-Current'] = usageCheck.currentUsage.toString();
+      responseHeaders['X-Usage-Limit'] = usageCheck.limit?.toString() || 'unlimited';
+    }
+    
+    // Add usage and cost information to headers
+    if (anthropicResponse.ok && responseData.usage) {
+      const usage = responseData.usage;
+      responseHeaders['X-CH-Input-Tokens'] = (usage.input_tokens || 0).toString();
+      responseHeaders['X-CH-Output-Tokens'] = (usage.output_tokens || 0).toString();
+      responseHeaders['X-CH-Total-Tokens'] = ((usage.input_tokens || 0) + (usage.output_tokens || 0)).toString();
+      // Add cost information if it was calculated above
+      if (cost > 0 || costIn > 0 || costOut > 0) {
+        responseHeaders['X-CH-Cost-USD'] = cost.toFixed(6);
+        responseHeaders['X-CH-Cost-Input-USD'] = costIn.toFixed(6);
+        responseHeaders['X-CH-Cost-Output-USD'] = costOut.toFixed(6);
+        if (estimated) {
+          responseHeaders['X-CH-Cost-Estimated'] = 'true';
+        }
+      }
+    }
+
+    return NextResponse.json(responseData, { 
+      status: anthropicResponse.status,
+      headers: responseHeaders
+    });
+  } catch (error) {
+    // DEBUG: console.error(`[proxy-anthropic-${requestId}] Critical proxy error:`, error);
+    
+    // Provide more detailed error information in development
+    const isDevelopment = process.env.NODE_ENV === 'development';
+    
+    return NextResponse.json(
+      { 
+        error: 'Internal proxy error',
+        requestId,
+        ...(isDevelopment && { 
+          details: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined
+        })
+      },
+      { status: 500 }
+    );
+  }
+}