costhawk 1.0.0

package/costcanary/app/api/optimizer/preview/route.ts

@@ -0,0 +1,147 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@clerk/nextjs/server'
+import { prisma } from '@/lib/prisma'
+
+// Force dynamic rendering for this route
+export const dynamic = 'force-dynamic'
+
+/**
+ * GET /api/optimizer/preview
+ * 
+ * Returns projected monthly savings based on recent usage patterns
+ */
+export async function GET(_request: NextRequest) {
+  try {
+    const { userId, orgId } = await auth()
+    
+    if (!userId) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+    
+    const effectiveOrgId = orgId || userId
+    
+    // Get last 30 days of usage
+    const thirtyDaysAgo = new Date()
+    thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30)
+    
+    // Get usage patterns
+    const usageLogs = await prisma.usageLog.findMany({
+      where: {
+        userId: { in: await getOrgUserIds(effectiveOrgId) },
+        timestamp: { gte: thirtyDaysAgo }
+      },
+      select: {
+        provider: true,
+        model: true,
+        inputTokens: true,
+        outputTokens: true,
+        cost: true
+      }
+    })
+    
+    if (usageLogs.length === 0) {
+      return NextResponse.json({
+        estimatedMonthlySavings: 0,
+        techniques: [],
+        message: 'Not enough usage data to calculate savings'
+      })
+    }
+    
+    // Calculate potential savings
+    let totalSavings = 0
+    const techniques = []
+    
+    // 1. Model optimization (e.g., GPT-4 -> GPT-3.5 for simple tasks)
+    const gpt4Usage = usageLogs.filter((l: any) => l.model === 'gpt-4')
+    if (gpt4Usage.length > 0) {
+      const potentialSavings = gpt4Usage.reduce((sum: any, log: any) => {
+        // Estimate 30% could use GPT-3.5 instead
+        const gpt35Cost = (log.inputTokens * 0.0015 + log.outputTokens * 0.002) / 1000
+        const savings = Number(log.cost) - gpt35Cost
+        return sum + (savings * 0.3) // 30% of calls
+      }, 0)
+      
+      if (potentialSavings > 0) {
+        totalSavings += potentialSavings
+        techniques.push({
+          name: 'Smart Model Selection',
+          description: 'Use GPT-3.5 for simpler queries',
+          estimatedSavings: potentialSavings,
+          percentage: 65 // 65% cost reduction for those calls
+        })
+      }
+    }
+    
+    // 2. Caching for repeated queries
+    const totalCost = usageLogs.reduce((sum: any, log: any) => sum + Number(log.cost), 0)
+    const cachingSavings = totalCost * 0.15 // Estimate 15% cache hit rate
+    if (cachingSavings > 0) {
+      totalSavings += cachingSavings
+      techniques.push({
+        name: 'Response Caching',
+        description: 'Cache frequently repeated queries',
+        estimatedSavings: cachingSavings,
+        percentage: 15
+      })
+    }
+    
+    // 3. Token optimization
+    const avgInputTokens = usageLogs.reduce((sum: any, log: any) => sum + log.inputTokens, 0) / usageLogs.length
+    if (avgInputTokens > 500) {
+      const tokenSavings = totalCost * 0.10 // 10% reduction through better prompts
+      totalSavings += tokenSavings
+      techniques.push({
+        name: 'Prompt Optimization',
+        description: 'Reduce prompt size without losing quality',
+        estimatedSavings: tokenSavings,
+        percentage: 10
+      })
+    }
+    
+    // 4. Batching opportunities
+    const providers = new Set(usageLogs.map((l: any) => l.provider))
+    if (providers.has('OPENAI')) {
+      const batchingSavings = totalCost * 0.05 // 5% from batching
+      totalSavings += batchingSavings
+      techniques.push({
+        name: 'Request Batching',
+        description: 'Batch multiple requests when possible',
+        estimatedSavings: batchingSavings,
+        percentage: 5
+      })
+    }
+    
+    // Project to monthly
+    const daysInPeriod = Math.min(30, Math.floor((Date.now() - thirtyDaysAgo.getTime()) / (1000 * 60 * 60 * 24)))
+    const monthlyMultiplier = 30 / daysInPeriod
+    const estimatedMonthlySavings = totalSavings * monthlyMultiplier
+    
+    return NextResponse.json({
+      estimatedMonthlySavings,
+      currentMonthlyCost: totalCost * monthlyMultiplier,
+      techniques: techniques.sort((a: any, b: any) => b.estimatedSavings - a.estimatedSavings),
+      optimizationPotential: (totalSavings / totalCost) * 100,
+      dataPoints: usageLogs.length,
+      message: `Based on ${usageLogs.length} API calls over ${daysInPeriod} days`
+    })
+  } catch (error) {
+    console.error('Optimizer preview error:', error)
+    return NextResponse.json(
+      { error: 'Failed to calculate optimization preview' },
+      { status: 500 }
+    )
+  }
+}
+
+async function getOrgUserIds(orgId: string): Promise<string[]> {
+  const users = await prisma.wrappedKey.findMany({
+    where: { orgId },
+    select: { userId: true },
+    distinct: ['userId']
+  })
+  
+  return users.map((u: any) => u.userId)
+}

package/costcanary/app/api/optimizer/route.ts

@@ -0,0 +1,118 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@clerk/nextjs/server'
+import { prisma } from '@/lib/prisma'
+import { createAuditLog } from '@/lib/audit'
+
+/**
+ * POST /api/optimizer
+ * 
+ * Enable or disable optimizer mode for the organization
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const { userId, orgId } = await auth()
+    
+    if (!userId) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+    
+    const { action } = await request.json()
+    
+    if (!['enable', 'disable'].includes(action)) {
+      return NextResponse.json(
+        { error: 'Invalid action. Use "enable" or "disable"' },
+        { status: 400 }
+      )
+    }
+    
+    const effectiveOrgId = orgId || userId
+    const enabled = action === 'enable'
+    
+    // Store optimizer setting (in production, this would be in a settings table)
+    // For now, we'll use user metadata
+    const user = await prisma.user.findUnique({
+      where: { id: userId }
+    })
+    
+    if (!user) {
+      return NextResponse.json(
+        { error: 'User not found' },
+        { status: 404 }
+      )
+    }
+    
+    // Update user settings (you might want to create a separate Settings model)
+    // For MVP, we'll use a simple flag
+    await prisma.user.update({
+      where: { id: userId },
+      data: {
+        // Store in a JSON field or create a Settings model
+        // For now, using the tier field as a placeholder
+        // In production, create a proper Settings model
+        updatedAt: new Date()
+      }
+    })
+    
+    // Audit log
+    await createAuditLog({
+      userId,
+      action: enabled ? 'CREATE' : 'DELETE',
+      entityType: 'OptimizerMode',
+      entityId: effectiveOrgId,
+      newValue: { enabled, timestamp: new Date() }
+    })
+    
+    return NextResponse.json({
+      enabled,
+      message: enabled 
+        ? 'Optimizer mode enabled. AI will now optimize your API calls for cost savings.'
+        : 'Optimizer mode disabled. API calls will pass through without modifications.',
+      timestamp: new Date()
+    })
+  } catch (error) {
+    console.error('Optimizer toggle error:', error)
+    return NextResponse.json(
+      { error: 'Failed to toggle optimizer mode' },
+      { status: 500 }
+    )
+  }
+}
+
+/**
+ * GET /api/optimizer
+ * 
+ * Get current optimizer status
+ */
+export async function GET(_request: NextRequest) {
+  try {
+    const { userId } = await auth()
+    
+    if (!userId) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+    
+    // In production, fetch from settings table
+    // For MVP, we'll return a default
+    const enabled = false // Default to disabled
+    
+    return NextResponse.json({
+      enabled,
+      mode: enabled ? 'optimize' : 'track',
+      description: enabled 
+        ? 'Optimizer is actively reducing costs'
+        : 'Tracking costs without modifications'
+    })
+  } catch (error) {
+    console.error('Get optimizer status error:', error)
+    return NextResponse.json(
+      { error: 'Failed to get optimizer status' },
+      { status: 500 }
+    )
+  }
+}

package/costcanary/app/api/pricing/models/route.ts

@@ -0,0 +1,102 @@
+import { NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { auth } from '@clerk/nextjs/server';
+
+export async function GET() {
+  try {
+    // Check authentication
+    const { userId } = await auth();
+    if (!userId) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    // Fetch all pricing models directly from PricingModelPrice table
+    // Order by createdAt DESC so we get the most recent first for deduplication
+    const allModels = await prisma.pricingModelPrice.findMany({
+      orderBy: [
+        { provider: 'asc' },
+        { canonicalModel: 'asc' },
+        { createdAt: 'desc' }
+      ]
+    });
+
+    // Transform and DEDUPLICATE - keep only first occurrence (most recent) per provider+model
+    const providerModels: Record<string, Array<{
+      id: string;
+      name: string;
+      displayName: string;
+      inputPricePerK: number;
+      outputPricePerK: number;
+    }>> = {};
+
+    const seenModels = new Set<string>();
+
+    for (const model of allModels) {
+      const provider = model.provider.toLowerCase();
+      const uniqueKey = `${provider}:${model.canonicalModel}`;
+
+      // Skip duplicates
+      if (seenModels.has(uniqueKey)) {
+        continue;
+      }
+      seenModels.add(uniqueKey);
+
+      if (!providerModels[provider]) {
+        providerModels[provider] = [];
+      }
+
+      // Create a display name that shows the price
+      const displayName = `${model.canonicalModel} ($${Number(model.unitInputPer1k).toFixed(4)}/$${Number(model.unitOutputPer1k).toFixed(4)} per 1K)`;
+
+      providerModels[provider].push({
+        id: model.canonicalModel,
+        name: model.canonicalModel,
+        displayName: displayName,
+        inputPricePerK: Number(model.unitInputPer1k),
+        outputPricePerK: Number(model.unitOutputPer1k)
+      });
+    }
+
+    // Create the provider list with proper formatting
+    const providers = [
+      {
+        id: "openai",
+        name: "OpenAI",
+        icon: "🤖",
+        models: providerModels['openai'] || []
+      },
+      {
+        id: "anthropic",
+        name: "Anthropic",
+        icon: "🧠",
+        models: providerModels['anthropic'] || []
+      },
+      {
+        id: "google",
+        name: "Google",
+        icon: "🔷",
+        models: providerModels['google'] || []
+      }
+    ];
+
+    return NextResponse.json({
+      success: true,
+      providers,
+      // Also return a flat model pricing map for easy lookup
+      modelPricing: Object.values(providerModels).flat().reduce((acc, model) => {
+        acc[model.id] = {
+          input: model.inputPricePerK,
+          output: model.outputPricePerK
+        };
+        return acc;
+      }, {} as Record<string, { input: number; output: number }>)
+    });
+
+  } catch (error) {
+    console.error('Failed to fetch pricing models:', error);
+    return NextResponse.json(
+      { error: 'Failed to fetch pricing models' },
+      { status: 500 }
+    );
+  }
+}