Support embedding with GitHub Copilot

Author: intitni

Core/Sources/HostApp/AccountSettings/EmbeddingModelManagement/EmbeddingModelEdit.swift

@@ -50,6 +50,7 @@ struct EmbeddingModelEdit {
         case openAI
         case azureOpenAI
         case ollama
+        case gitHubCopilot
         case openAICompatible
         case mistralOpenAICompatible
         case voyageAIOpenAICompatible
@@ -64,6 +65,8 @@ struct EmbeddingModelEdit {
                 self = .ollama
             case .openAICompatible:
                 self = .openAICompatible
+            case .gitHubCopilot:
+                self = .gitHubCopilot
             }
         }
     }
@@ -189,6 +192,8 @@ struct EmbeddingModelEdit {
                     state.format = .ollama
                 case .openAICompatible:
                     state.format = .openAICompatible
+                case .gitHubCopilot:
+                    state.format = .gitHubCopilot
                 case .mistralOpenAICompatible:
                     state.format = .openAICompatible
                     state.baseURLSelection.baseURL = "https://api.mistral.ai"

Core/Sources/HostApp/AccountSettings/EmbeddingModelManagement/EmbeddingModelEditView.swift

@@ -24,6 +24,8 @@ struct EmbeddingModelEditView: View {
                             OpenAICompatibleForm(store: store)
                         case .ollama:
                             OllamaForm(store: store)
+                        case .gitHubCopilot:
+                            GitHubCopilotForm(store: store)
                         }
                     }
                     .padding()
@@ -103,6 +105,8 @@ struct EmbeddingModelEditView: View {
                                 Text("Mistral (OpenAI Compatible)")
                             case .voyageAIOpenAICompatible:
                                 Text("Voyage (OpenAI Compatible)")
+                            case .gitHubCopilot:
+                                Text("GitHub Copilot")
                             }
                         }
                     },
@@ -383,6 +387,53 @@ struct EmbeddingModelEditView: View {
             }
         }
     }
+
+    struct GitHubCopilotForm: View {
+        @Perception.Bindable var store: StoreOf<EmbeddingModelEdit>
+        @State var isEditingCustomHeader = false
+
+        var body: some View {
+            WithPerceptionTracking {
+                TextField("Model Name", text: $store.modelName)
+                    .overlay(alignment: .trailing) {
+                        Picker(
+                            "",
+                            selection: $store.modelName,
+                            content: {
+                                if OpenAIEmbeddingModel(rawValue: store.modelName) == nil {
+                                    Text("Custom Model").tag(store.modelName)
+                                }
+                                ForEach(OpenAIEmbeddingModel.allCases, id: \.self) { model in
+                                    Text(model.rawValue).tag(model.rawValue)
+                                }
+                            }
+                        )
+                        .frame(width: 20)
+                    }
+
+                MaxTokensTextField(store: store)
+                DimensionsTextField(store: store)
+
+                Button("Custom Headers") {
+                    isEditingCustomHeader.toggle()
+                }
+
+                VStack(alignment: .leading, spacing: 8) {
+                    Text(Image(systemName: "exclamationmark.triangle.fill")) + Text(
+                        " Please login in the GitHub Copilot settings to use the model."
+                    )
+
+                    Text(Image(systemName: "exclamationmark.triangle.fill")) + Text(
+                        " This will call the APIs directly, which may not be allowed by GitHub. But it's used in other popular apps like Zed."
+                    )
+                }
+                .dynamicHeightTextInFormWorkaround()
+                .padding(.vertical)
+            }.sheet(isPresented: $isEditingCustomHeader) {
+                CustomHeaderSettingsView(headers: $store.customHeaders)
+            }
+        }
+    }
 }
 
 class EmbeddingModelManagementView_Editing_Previews: PreviewProvider {

Core/Sources/HostApp/AccountSettings/EmbeddingModelManagement/EmbeddingModelManagement.swift

@@ -11,6 +11,7 @@ extension EmbeddingModel: ManageableAIModel {
         case .azureOpenAI: return "Azure OpenAI"
         case .openAICompatible: return "OpenAI Compatible"
         case .ollama: return "Ollama"
+        case .gitHubCopilot: return "GitHub Copilot"
         }
     }
 

Tool/Sources/AIModel/EmbeddingModel.swift

@@ -21,6 +21,7 @@ public struct EmbeddingModel: Codable, Equatable, Identifiable {
         case azureOpenAI
         case openAICompatible
         case ollama
+        case gitHubCopilot
     }
 
     public struct Info: Codable, Equatable {
@@ -92,6 +93,8 @@ public struct EmbeddingModel: Codable, Equatable, Identifiable {
             let baseURL = info.baseURL
             if baseURL.isEmpty { return "http://localhost:11434/api/embeddings" }
             return "\(baseURL)/api/embeddings"
+        case .gitHubCopilot:
+            return "https://api.githubcopilot.com/embeddings"
         }
     }
 }

Tool/Sources/OpenAIService/APIs/GitHubCopilotEmbeddingService.swift

@@ -0,0 +1,72 @@
+import AIModel
+import AsyncAlgorithms
+import ChatBasic
+import Foundation
+import GitHubCopilotService
+import Logger
+import Preferences
+
+/// Looks like it's used in many other popular repositories so maybe it's safe.
+actor GitHubCopilotEmbeddingService: EmbeddingAPI {
+    let chatModel: EmbeddingModel
+
+    init(model: EmbeddingModel) {
+        var model = model
+        model.format = .openAICompatible
+        chatModel = model
+    }
+
+    func embed(text: String) async throws -> EmbeddingResponse {
+        let service = try await buildService()
+        return try await service.embed(text: text)
+    }
+
+    func embed(texts: [String]) async throws -> EmbeddingResponse {
+        let service = try await buildService()
+        return try await service.embed(texts: texts)
+    }
+
+    func embed(tokens: [[Int]]) async throws -> EmbeddingResponse {
+        let service = try await buildService()
+        return try await service.embed(tokens: tokens)
+    }
+
+    private func buildService() async throws -> OpenAIEmbeddingService {
+        let token = try await GitHubCopilotExtension.fetchToken()
+
+        return OpenAIEmbeddingService(
+            apiKey: token.token,
+            model: chatModel,
+            endpoint: token.endpoints.api + "/embeddings"
+        ) { request in
+
+//            POST /chat/completions HTTP/2
+//            :authority: api.individual.githubcopilot.com
+//            authorization: Bearer *
+//            x-request-id: *
+//            openai-organization: github-copilot
+//            vscode-sessionid: *
+//            vscode-machineid: *
+//            editor-version: vscode/1.89.1
+//            editor-plugin-version: Copilot for Xcode/0.35.5
+//            copilot-language-server-version: 1.236.0
+//            x-github-api-version: 2023-07-07
+//            openai-intent: conversation-panel
+//            content-type: application/json
+//            user-agent: GithubCopilot/1.236.0
+//            content-length: 9061
+//            accept: */*
+//            accept-encoding: gzip,deflate,br
+
+            request.setValue(
+                "Copilot for Xcode/\(Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "unknown")",
+                forHTTPHeaderField: "Editor-Version"
+            )
+            request.setValue("Bearer \(token.token)", forHTTPHeaderField: "Authorization")
+            request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+            request.setValue("vscode-chat", forHTTPHeaderField: "Copilot-Integration-Id")
+            request.setValue("2023-07-07", forHTTPHeaderField: "X-Github-Api-Version")
+        }
+    }
+}
+

Tool/Sources/OpenAIService/APIs/OpenAIEmbeddingService.swift

@@ -16,6 +16,7 @@ struct OpenAIEmbeddingService: EmbeddingAPI {
     let apiKey: String
     let model: EmbeddingModel
     let endpoint: String
+    var requestModifier: ((inout URLRequest) -> Void)? = nil
 
     public func embed(text: String) async throws -> EmbeddingResponse {
         return try await embed(texts: [text])
@@ -42,6 +43,7 @@ struct OpenAIEmbeddingService: EmbeddingAPI {
         Self.setupAppInformation(&request)
         Self.setupAPIKey(&request, model: model, apiKey: apiKey)
         await Self.setupExtraHeaderFields(&request, model: model, apiKey: apiKey)
+        requestModifier?(&request)
 
         let (result, response) = try await URLSession.shared.data(for: request)
         guard let response = response as? HTTPURLResponse else {
@@ -82,6 +84,7 @@ struct OpenAIEmbeddingService: EmbeddingAPI {
         Self.setupAppInformation(&request)
         Self.setupAPIKey(&request, model: model, apiKey: apiKey)
         await Self.setupExtraHeaderFields(&request, model: model, apiKey: apiKey)
+        requestModifier?(&request)
 
         let (result, response) = try await URLSession.shared.data(for: request)
         guard let response = response as? HTTPURLResponse else {
@@ -136,6 +139,8 @@ struct OpenAIEmbeddingService: EmbeddingAPI {
                 request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
             case .azureOpenAI:
                 request.setValue(apiKey, forHTTPHeaderField: "api-key")
+            case .gitHubCopilot:
+                break
             case .ollama:
                 assertionFailure("Unsupported")
             }

Tool/Sources/OpenAIService/EmbeddingService.swift

@@ -27,6 +27,10 @@ public struct EmbeddingService {
                 model: model,
                 endpoint: configuration.endpoint
             ).embed(text: text)
+        case .gitHubCopilot:
+            embeddingResponse = try await GitHubCopilotEmbeddingService(
+                model: model
+            ).embed(text: text)
         }
 
         #if DEBUG
@@ -59,6 +63,10 @@ public struct EmbeddingService {
                 model: model,
                 endpoint: configuration.endpoint
             ).embed(texts: text)
+        case .gitHubCopilot:
+            embeddingResponse = try await GitHubCopilotEmbeddingService(
+                model: model
+            ).embed(texts: text)
         }
 
         #if DEBUG
@@ -91,6 +99,10 @@ public struct EmbeddingService {
                 model: model,
                 endpoint: configuration.endpoint
             ).embed(tokens: tokens)
+        case .gitHubCopilot:
+            embeddingResponse = try await GitHubCopilotEmbeddingService(
+                model: model
+            ).embed(tokens: tokens)
         }
 
         #if DEBUG