Skip to content

Claude Code. Any Model. The most powerful AI coding agent now speaks every language.

13.4 KB
Raw Blame
import Foundation

// MARK: - API Response Types

/// Health check response from bridge
struct HealthResponse: Codable {
    let status: String
    let version: String
    let uptime: Double
}

/// Proxy status response
struct ProxyStatus: Codable {
    let running: Bool
    let port: Int?
    let proxyPort: Int?  // HTTPS proxy port (separate from HTTP API port)
    let detectedApps: [DetectedApp]
    let totalRequests: Int
    let activeConnections: Int
    let uptime: Double
    let version: String
}

/// Proxy enable response (includes proxy port)
struct ProxyEnableResponse: Codable {
    let success: Bool
    let proxyPort: Int?
    let message: String?
}

/// Detected application info
struct DetectedApp: Codable, Identifiable {
    let name: String
    let confidence: Double
    let userAgent: String
    let lastSeen: String
    let requestCount: Int

    var id: String { name }
}

/// Routing configuration
struct RoutingConfig: Codable {
    let enabled: Bool
    let modelMap: [String: String]
}

/// Debug state response from /debug/state endpoint
struct DebugState: Codable {
    let config: BridgeConfig?
    let routingConfig: RoutingConfig
    let proxyEnabled: Bool
    let connectHandlerExists: Bool
}

/// Log entry
struct LogEntry: Codable, Identifiable {
    let timestamp: String
    let app: String
    let confidence: Double
    let requestedModel: String
    let targetModel: String
    let status: Int
    let latency: Int
    let inputTokens: Int
    let outputTokens: Int
    let cost: Double

    var id: String { timestamp }
}

/// Log response
struct LogResponse: Codable {
    let logs: [LogEntry]
    let total: Int
    let hasMore: Bool
    let nextOffset: Int?
}

/// Raw traffic entry for all intercepted requests
struct RawTrafficEntry: Codable, Identifiable {
    let timestamp: String
    let method: String
    let host: String
    let path: String
    let userAgent: String
    let origin: String?
    let contentType: String?
    let contentLength: Int?
    let detectedApp: String
    let confidence: Double

    var id: String { timestamp + path }
}

/// Traffic response
struct TrafficResponse: Codable {
    let traffic: [RawTrafficEntry]
    let total: Int
}

/// Generic API response
struct ApiResponse: Codable {
    let success: Bool
    let error: String?
}

/// Debug mode response
struct DebugResponse: Codable {
    let success: Bool
    let data: DebugData?
    let error: String?

    struct DebugData: Codable {
        let enabled: Bool
        let logPath: String?
        let logDir: String?
    }
}

// MARK: - Configuration Types

/// Bridge configuration
struct BridgeConfig: Codable {
    var defaultModel: String?
    var apps: [String: AppModelMapping]
    var enabled: Bool
}

/// Per-app model mapping
struct AppModelMapping: Codable {
    var modelMap: [String: String]
    var enabled: Bool
    var notes: String?
}

/// API keys for enabling proxy
struct ApiKeys: Codable {
    var openrouter: String?
    var openai: String?
    var gemini: String?
    var anthropic: String?
    var minimax: String?
    var kimi: String?
    var glm: String?
}

/// Options for starting the bridge proxy
struct BridgeStartOptions: Codable {
    let apiKeys: ApiKeys
    var port: Int?
}

// MARK: - Model Constants

/// Known Claude model names for mapping
enum ClaudeModel: String, CaseIterable {
    case opus = "claude-3-opus-20240229"
    case sonnet = "claude-3-sonnet-20240229"
    case haiku = "claude-3-haiku-20240307"
    case opus4 = "claude-sonnet-4-20250514"  // Claude 4 naming

    var displayName: String {
        switch self {
        case .opus: return "Claude 3 Opus"
        case .sonnet: return "Claude 3 Sonnet"
        case .haiku: return "Claude 3 Haiku"
        case .opus4: return "Claude 4 Sonnet"
        }
    }
}

/// Common target models for mapping
enum TargetModel: String, CaseIterable, Identifiable {
    // Passthrough (no routing)
    case passthrough = "internal"

    // Direct API models
    case minimaxM2 = "mm/minimax-m2.1"
    case glm47 = "z-ai/glm-4.7"
    case gemini3Pro = "g/gemini-3-pro-preview"
    case gpt53Codex = "oai/gpt-5.3-codex"
    case grokCodeFast = "x-ai/grok-code-fast-1"

    var id: String { rawValue }

    var displayName: String {
        switch self {
        case .passthrough: return "Passthrough (Claude)"
        case .minimaxM2: return "MiniMax M2.1"
        case .glm47: return "GLM-4.7"
        case .gemini3Pro: return "Gemini 3 Pro"
        case .gpt53Codex: return "GPT-5.3 Codex"
        case .grokCodeFast: return "Grok Code Fast"
        }
    }
}

// MARK: - Profile Types

/// Model slots that can be remapped in a profile
struct ProfileSlots: Codable, Equatable {
    var opus: String
    var sonnet: String
    var haiku: String
    var subagent: String

    /// Create default passthrough slots (identity mapping)
    static var passthrough: ProfileSlots {
        ProfileSlots(
            opus: "claude-opus-4-6-20260201",
            sonnet: "claude-sonnet-4-5-20250929",
            haiku: "claude-3-haiku-20240307",
            subagent: "claude-sonnet-4-5-20250929"
        )
    }

    /// Create cost-optimized slots
    static var costSaver: ProfileSlots {
        ProfileSlots(
            opus: "g/gemini-3-pro-preview",
            sonnet: "mm/minimax-m2.1",
            haiku: "mm/minimax-m2.1",
            subagent: "mm/minimax-m2.1"
        )
    }

    /// Create performance-optimized slots
    static var performance: ProfileSlots {
        ProfileSlots(
            opus: "openai/gpt-4o",
            sonnet: "g/gemini-2.0-flash-exp",
            haiku: "g/gemini-2.0-flash-exp",
            subagent: "g/gemini-2.0-flash-exp"
        )
    }

    /// Create balanced slots
    static var balanced: ProfileSlots {
        ProfileSlots(
            opus: "openai/gpt-4o",
            sonnet: "g/gemini-2.0-flash-exp",
            haiku: "openai/gpt-4o-mini",
            subagent: "openai/gpt-4o-mini"
        )
    }
}

/// A model profile defining how Claude models are remapped
struct ModelProfile: Codable, Identifiable, Equatable {
    let id: UUID
    var name: String
    var description: String?
    let isPreset: Bool
    var slots: ProfileSlots
    let createdAt: Date
    var modifiedAt: Date

    init(
        id: UUID = UUID(),
        name: String,
        description: String? = nil,
        isPreset: Bool = false,
        slots: ProfileSlots,
        createdAt: Date = Date(),
        modifiedAt: Date = Date()
    ) {
        self.id = id
        self.name = name
        self.description = description
        self.isPreset = isPreset
        self.slots = slots
        self.createdAt = createdAt
        self.modifiedAt = modifiedAt
    }

    /// Create a preset profile
    static func preset(
        name: String,
        description: String,
        slots: ProfileSlots
    ) -> ModelProfile {
        ModelProfile(
            name: name,
            description: description,
            isPreset: true,
            slots: slots
        )
    }

    /// Create a custom profile
    static func custom(
        name: String,
        description: String? = nil,
        slots: ProfileSlots
    ) -> ModelProfile {
        ModelProfile(
            name: name,
            description: description,
            isPreset: false,
            slots: slots
        )
    }
}

extension ModelProfile {
    // Fixed UUIDs for preset profiles to ensure selection persistence
    private static let passthroughId = UUID(uuidString: "00000000-0000-0000-0000-000000000001")!
    private static let costSaverId = UUID(uuidString: "00000000-0000-0000-0000-000000000002")!
    private static let performanceId = UUID(uuidString: "00000000-0000-0000-0000-000000000003")!
    private static let balancedId = UUID(uuidString: "00000000-0000-0000-0000-000000000004")!

    /// Default preset profiles
    static let presets: [ModelProfile] = [
        ModelProfile(
            id: passthroughId,
            name: "Passthrough",
            description: "Use original Claude models (no remapping)",
            isPreset: true,
            slots: .passthrough
        ),
        ModelProfile(
            id: costSaverId,
            name: "Cost Saver",
            description: "Route to cheaper models",
            isPreset: true,
            slots: .costSaver
        ),
        ModelProfile(
            id: performanceId,
            name: "Performance",
            description: "Route to fastest models",
            isPreset: true,
            slots: .performance
        ),
        ModelProfile(
            id: balancedId,
            name: "Balanced",
            description: "Mixed performance and cost",
            isPreset: true,
            slots: .balanced
        )
    ]
}

// MARK: - Statistics Types

/// A recorded request statistic
struct RequestStat: Codable, Identifiable {
    let id: UUID
    let timestamp: Date
    let sourceModel: String  // e.g., "claude-opus-4-6"
    let targetModel: String  // e.g., "g/gemini-3-pro-preview" or "internal"
    let inputTokens: Int
    let outputTokens: Int
    let durationMs: Int
    let success: Bool

    init(
        id: UUID = UUID(),
        timestamp: Date = Date(),
        sourceModel: String,
        targetModel: String,
        inputTokens: Int,
        outputTokens: Int,
        durationMs: Int,
        success: Bool
    ) {
        self.id = id
        self.timestamp = timestamp
        self.sourceModel = sourceModel
        self.targetModel = targetModel
        self.inputTokens = inputTokens
        self.outputTokens = outputTokens
        self.durationMs = durationMs
        self.success = success
    }
}

/// Manages request statistics with SQLite persistence
@MainActor
class StatsManager: ObservableObject {
    @Published var recentRequests: [RequestStat] = []
    @Published var todayStats: (requests: Int, inputTokens: Int, outputTokens: Int, cost: Double) = (0, 0, 0, 0)
    @Published var periodStats: (requests: Int, inputTokens: Int, outputTokens: Int, cost: Double) = (0, 0, 0, 0)
    @Published var selectedPeriod: StatsPeriod = .thirtyDays

    private let db = StatsDatabase.shared

    enum StatsPeriod: String, CaseIterable {
        case sevenDays = "7 Days"
        case thirtyDays = "30 Days"
        case ninetyDays = "90 Days"
        case allTime = "All Time"

        var days: Int? {
            switch self {
            case .sevenDays: return 7
            case .thirtyDays: return 30
            case .ninetyDays: return 90
            case .allTime: return nil
            }
        }
    }

    init() {
        refreshStats()
    }

    // MARK: - Computed Properties

    /// Recent activity (last 10 requests)
    var recentActivity: [RequestStat] {
        Array(recentRequests.prefix(10))
    }

    /// Requests today (convenience accessor)
    var requestsToday: Int {
        todayStats.requests
    }

    /// Total input tokens for selected period
    var totalInputTokens: Int {
        periodStats.inputTokens
    }

    /// Total output tokens for selected period
    var totalOutputTokens: Int {
        periodStats.outputTokens
    }

    /// Total tokens for selected period
    var totalTokens: Int {
        periodStats.inputTokens + periodStats.outputTokens
    }

    /// Total cost for selected period
    var totalCost: Double {
        periodStats.cost
    }

    // MARK: - Recording

    /// Record a new request stat
    func recordRequest(_ stat: RequestStat, appName: String? = nil, cost: Double = 0) {
        // Save to SQLite
        db.recordRequest(stat, appName: appName, cost: cost)

        // Refresh UI
        refreshStats()
    }

    /// Record a request from log entry
    func recordFromLogEntry(_ entry: LogEntry) {
        let stat = RequestStat(
            timestamp: parseTimestamp(entry.timestamp),
            sourceModel: entry.requestedModel,
            targetModel: entry.targetModel,
            inputTokens: entry.inputTokens,
            outputTokens: entry.outputTokens,
            durationMs: entry.latency,
            success: entry.status >= 200 && entry.status < 300
        )
        recordRequest(stat, appName: entry.app, cost: entry.cost)
    }

    // MARK: - Data Refresh

    /// Refresh all stats from database
    func refreshStats() {
        // Load recent requests
        recentRequests = db.getRecentRequests(limit: 100)

        // Load today's stats
        todayStats = db.getTodayStats()

        // Load period stats based on selection
        if let days = selectedPeriod.days {
            periodStats = db.getStatsForLastDays(days)
        } else {
            periodStats = db.getAllTimeStats()
        }
    }

    /// Change the selected time period
    func setPeriod(_ period: StatsPeriod) {
        selectedPeriod = period
        refreshStats()
    }

    /// Get model usage breakdown
    func getModelUsage() -> [(model: String, count: Int, tokens: Int)] {
        db.getModelUsage(days: selectedPeriod.days)
    }

    // MARK: - Maintenance

    /// Clear all statistics
    func clearStats() {
        db.clearAllStats()
        refreshStats()
    }

    /// Get database size
    func getDatabaseSize() -> String {
        let bytes = db.getDatabaseSize()
        let formatter = ByteCountFormatter()
        formatter.countStyle = .file
        return formatter.string(fromByteCount: bytes)
    }

    // MARK: - Helpers

    private func parseTimestamp(_ timestamp: String) -> Date {
        let formatter = ISO8601DateFormatter()
        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
        return formatter.date(from: timestamp) ?? Date()
    }
}