fix(github): resolve billing data caching and API call issues

**Problem:**
1. GitHub Copilot billing data not appearing in model picker
2. URLSession was returning cached responses without billing fields
3. API calls attempted before authentication configured

**Root Cause:**
URLSession cached earlier API responses (potentially from before
authentication was available). When refreshing model list, the cached
response was returned instead of making a fresh authenticated request.

**Solution:**
1. Disable URLSession caching for GitHub models API:
   - Added .reloadIgnoringLocalAndRemoteCacheData cache policy
   - Ensures fresh API calls with current authentication

2. Guard against unauthenticated API calls:
   - Added hasGitHubCopilotAuthentication() check
   - Skip capabilities fetch if no token/API key configured
   - Prevents caching of error responses

3. Code quality improvements:
   - Cleaned up verbose debug logging
   - Fixed misleading log messages about billing availability
   - Improved code comments

**Files Changed:**
- Sources/APIFramework/Providers.swift: Cache policy + auth check
- Sources/APIFramework/EndpointManager.swift: hasGitHubCopilotAuthentication()
- Sources/APIFramework/ModelListManager.swift: Guard API calls

**Testing:**
✅ Billing data displays correctly (claude-opus-4.5: 3x, opus-41: 10x)
✅ No API calls when not authenticated
✅ Build passes with no errors
✅ End-to-end flow verified

**Impact:**
- Model picker now shows cost multipliers for all GitHub Copilot models
- Prevents unnecessary API errors during startup
- More reliable billing data caching

Author: fewtarius

Sources/APIFramework/EndpointManager.swift

@@ -102,6 +102,16 @@ public class EndpointManager: ObservableObject {
         return try await githubProvider.fetchModelCapabilities()
     }
 
+    /// Check if GitHub Copilot provider has authentication configured
+    /// Returns true if device flow token or manual API key is available
+    public func hasGitHubCopilotAuthentication() async -> Bool {
+        guard let githubProvider = providers.values.first(where: { $0.config.providerType == .githubCopilot }) as? GitHubCopilotProvider else {
+            return false
+        }
+        
+        return await githubProvider.hasAuthentication()
+    }
+    
     /// Clear the GitHub Copilot capabilities cache to force a fresh fetch
     public func clearGitHubCopilotCapabilitiesCache() async throws {
         guard let githubProvider = providers.values.first(where: { $0.config.providerType == .githubCopilot }) as? GitHubCopilotProvider else {

Sources/APIFramework/ModelListManager.swift

@@ -128,14 +128,18 @@ public class ModelListManager: ObservableObject {
         isLoading = true
 
         do {
-            // Fetch GitHub Copilot model capabilities (including billing) BEFORE loading models
-            // FORCE fresh fetch to ensure billing data is populated (not from capabilities cache)
+            // Fetch GitHub Copilot model capabilities (including billing) if provider is configured
+            // Only attempt if there's a token or API key available to avoid unnecessary failed API calls
             do {
-                // Clear the static capabilities cache to force a fresh API call with billing data
-                // This is needed because the cache check happens before billing data is populated
-                _ = try await endpointManager.clearGitHubCopilotCapabilitiesCache()
-                _ = try await endpointManager.getGitHubCopilotModelCapabilities()
-                logger.debug("Fetched GitHub Copilot capabilities with billing info")
+                // Check if GitHub Copilot provider has authentication available
+                if await endpointManager.hasGitHubCopilotAuthentication() {
+                    // Clear the static capabilities cache to force a fresh API call with billing data
+                    _ = try await endpointManager.clearGitHubCopilotCapabilitiesCache()
+                    _ = try await endpointManager.getGitHubCopilotModelCapabilities()
+                    logger.debug("Fetched GitHub Copilot capabilities with billing info")
+                } else {
+                    logger.debug("Skipping GitHub Copilot capabilities fetch - no authentication configured")
+                }
             } catch {
                 logger.warning("Failed to fetch GitHub capabilities: \(error)")
             }

Sources/APIFramework/Providers.swift

@@ -715,25 +715,37 @@ public class GitHubCopilotProvider: AIProvider, ObservableObject {
     }
 
     /// Get API key - tries Copilot token first, falls back to config API key
-    /// This allows both device flow (with billing data) and manual API key (without billing data)
+    /// Both device flow tokens (via CopilotTokenStore) and manual API keys support billing data
     private func getAPIKey() async throws -> String {
-        // Try Copilot token first (preferred - has billing data)
+        // Try Copilot token first (from device flow - preferred)
         do {
             let token = try await CopilotTokenStore.shared.getCopilotToken()
-            logger.debug("Using Copilot token from device flow (has billing data)")
+            logger.debug("Using GitHub token from device flow")
             return token
         } catch {
-            logger.debug("Copilot token unavailable: \(error.localizedDescription)")
+            logger.debug("Device flow token unavailable: \(error.localizedDescription)")
         }
 
-        // Fall back to manual API key (no billing data, but still works)
+        // Fall back to manual API key
         guard let apiKey = config.apiKey else {
-            throw ProviderError.authenticationFailed("GitHub Copilot API key not configured. Please sign in with GitHub or provide an API key.")
+            throw ProviderError.authenticationFailed("GitHub Copilot API key not configured. Please sign in with GitHub or provide an API key in Preferences.")
         }
 
-        logger.debug("Using manual API key (billing data not available)")
+        logger.debug("Using manually configured API key")
         return apiKey
     }
+    
+    /// Check if authentication is available (device flow token or manual API key)
+    /// Used to avoid unnecessary API calls when not authenticated
+    public func hasAuthentication() async -> Bool {
+        // Check device flow token
+        if let _ = try? await CopilotTokenStore.shared.getCopilotToken() {
+            return true
+        }
+        
+        // Check manual API key
+        return config.apiKey != nil
+    }
 
     /// Fetch model capabilities from GitHub Copilot /models API Returns dictionary of modelId -> max_input_tokens (context size) **Why needed**: GitHub Copilot doesn't include model capabilities in main API responses.
     public func fetchModelCapabilities() async throws -> [String: Int] {
@@ -758,6 +770,8 @@ public class GitHubCopilotProvider: AIProvider, ObservableObject {
 
         var urlRequest = URLRequest(url: url)
         urlRequest.httpMethod = "GET"
+        urlRequest.cachePolicy = .reloadIgnoringLocalAndRemoteCacheData  // Disable caching
+        urlRequest.setValue("*/*", forHTTPHeaderField: "Accept")
         urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
         urlRequest.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
 
@@ -776,6 +790,13 @@ public class GitHubCopilotProvider: AIProvider, ObservableObject {
         do {
             let (data, response) = try await URLSession.shared.data(for: urlRequest)
 
+            #if DEBUG
+            /// Save raw response to file for debugging (debug builds only)
+            let debugPath = FileManager.default.homeDirectoryForCurrentUser
+                .appendingPathComponent("Library/Caches/sam/debug_github_models_response.json")
+            try? data.write(to: debugPath)
+            #endif
+
             guard let httpResponse = response as? HTTPURLResponse else {
                 throw ProviderError.networkError("Invalid response type")
             }