Re-implement math chat plugin in Swift

Author: intitni

Core/Sources/ChatPlugin/AskChatGPT.swift

@@ -2,7 +2,11 @@ import Foundation
 import OpenAIService
 
 /// Quickly ask a question to ChatGPT.
-func askChatGPT(systemPrompt: String, question: String) async throws -> String? {
-    let service = ChatGPTService(systemPrompt: systemPrompt)
+public func askChatGPT(
+    systemPrompt: String,
+    question: String,
+    temperature: Double? = nil
+) async throws -> String? {
+    let service = ChatGPTService(systemPrompt: systemPrompt, temperature: temperature)
     return try await service.sendAndWait(content: question)
 }

Core/Sources/ChatPlugin/Translate.swift

@@ -0,0 +1,34 @@
+import Foundation
+import Preferences
+
+@MainActor
+var translationCache = [String: String]()
+
+public func translate(text: String, cache: Bool = true) async -> String {
+    let language = UserDefaults.shared.value(for: \.chatGPTLanguage)
+    if language.isEmpty { return text }
+
+    let key = "\(language)-\(text)"
+    if cache, let cached = await translationCache[key] {
+        return cached
+    }
+
+    if let translated = try? await askChatGPT(
+        systemPrompt: """
+        You are a translator. Your job is to translate the message into \(language). The reply should only contain the translated content.
+        User: ###${{some text}}###
+        Assistant: ${{translated text}}
+        """,
+        question: "###\(text)###"
+    ) {
+        if cache {
+            let storeTask = Task { @MainActor in
+                translationCache[key] = translated
+            }
+            _ = await storeTask.result
+        }
+        return translated
+    }
+    return text
+}
+

Core/Sources/ChatPlugins/MathChatPlugin/MathChatPlugin.swift

@@ -22,7 +22,9 @@ public actor MathChatPlugin: ChatPlugin {
         delegate?.pluginDidStartResponding(self)
 
         let id = "\(Self.command)-\(UUID().uuidString)"
-        var reply = ChatMessage(id: id, role: .assistant, content: "Calculating...")
+        async let translatedCalculating = translate(text: "Calculating...")
+        async let translatedAnswer = translate(text: "Answer:")
+        var reply = ChatMessage(id: id, role: .assistant, content: await translatedCalculating)
 
         await chatGPTService.mutateHistory { history in
             history.append(.init(role: .user, content: originalMessage, summary: content))
@@ -31,11 +33,12 @@ public actor MathChatPlugin: ChatPlugin {
 
         do {
             let result = try await solveMathProblem(content)
+            let formattedResult = "\(await translatedAnswer) \(result)"
             await chatGPTService.mutateHistory { history in
                 if history.last?.id == id {
                     history.removeLast()
                 }
-                reply.content = result
+                reply.content = formattedResult
                 history.append(reply)
             }
         } catch {

Core/Sources/ChatPlugins/MathChatPlugin/SolveMathProblem.swift

@@ -1,36 +1,100 @@
+import ChatPlugin
 import Foundation
 import LangChain
-import PythonHelper
-import PythonKit
-
-func solveMathProblem(_ problem: String) async throws -> String {
-//    #if DEBUG
-//    let verbose = true
-//    #else
-//    let verbose = false
-//    #endif
-//
-//    struct E: Error, LocalizedError {
-//        var errorDescription: String? {
-//            "Failed to parse answer."
-//        }
-//    }
-//
-//    let task = Task {
-//        try runPython {
-//            let langchain = try Python.attemptImportOnPythonThread("langchain")
-//            let LLMMathChain = langchain.LLMMathChain
-//            let llm = try LangChainChatModel.DynamicChatOpenAI(temperature: 0)
-//            let llmMath = LLMMathChain.from_llm(llm, verbose: verbose)
-//            let result = try llmMath.run.throwing.dynamicallyCall(withArguments: problem)
-//            let answer = String(result)
-//            if let answer { return answer }
-//
-//            throw E()
-//        }
-//    }
-//    
-//    return try await task.value
-    return "N/A"
+import Logger
+import OpenAIService
+
+let systemPrompt = """
+Translate a math problem into a expression that can be executed using Python's numexpr library.
+Use the output of running this code to answer the question.
+
+Question: ${{Question with math problem.}}
+```text
+${{single line mathematical expression that solves the problem}}
+```
+...numexpr.evaluate(text)...
+```output
+${{Output of running the code}}
+```
+Answer: ${{Answer}}
+
+Begin.
+
+Question: What is 37593 * 67?
+```text
+37593 * 67
+```
+...numexpr.evaluate("37593 * 67")...
+```output
+2518731
+```
+Answer: 2518731
+
+Question: 37593^(1/5)
+```text
+37593**(1/5)
+```
+...numexpr.evaluate("37593**(1/5)")...
+```output
+8.222831614237718
+```
+Answer: 8.222831614237718
+"""
+
+/// Extract the math problem with ChatGPT, and pass it to python to get the result.
+///
+/// [llm_math in
+/// LangChain](https://github.com/hwchase17/langchain/blob/master/langchain/chains/llm_math/base.py)
+///
+/// The logic is basically the same as the LLMMathChain provided in LangChain.
+func solveMathProblem(_ question: String) async throws -> String {
+    guard let reply = try await askChatGPT(
+        systemPrompt: systemPrompt,
+        question: "Question: \(question)",
+        temperature: 0
+    ) else { return "No answer." }
+
+    // parse inside text code block
+    let codeBlockRegex = try NSRegularExpression(pattern: "```text\n(.*?)\n```", options: [])
+    let codeBlockMatches = codeBlockRegex.matches(
+        in: reply,
+        options: [],
+        range: NSRange(reply.startIndex..<reply.endIndex, in: reply)
+    )
+    if let firstMatch = codeBlockMatches.first, let textRange = Range(
+        firstMatch.range(at: 1),
+        in: reply
+    ) {
+        let text = reply[textRange]
+        let expression = String(text)
+        let task = Task { try evaluateWithPython(expression) }
+        if let answer = try await task.value {
+            return answer
+        }
+    }
+
+    // parse after Answer:
+    let answerRegex = try NSRegularExpression(pattern: "Answer: (.*)", options: [])
+    let answerMatches = answerRegex.matches(
+        in: reply,
+        options: [],
+        range: NSRange(reply.startIndex..<reply.endIndex, in: reply)
+    )
+    if let firstMatch = answerMatches.first, let answerRange = Range(
+        firstMatch.range(at: 1),
+        in: reply
+    ) {
+        let answer = reply[answerRange]
+        return String(answer)
+    }
+
+    return reply
+}
+
+func evaluateWithPython(_ expression: String) throws -> String? {
+    let mathExpression = NSExpression(format: expression)
+    let value = mathExpression.expressionValue(with: nil, context: nil)
+    Logger.service.debug(String(describing: value))
+    return (value as? Int).flatMap(String.init)
 }
 

Core/Sources/GitHubCopilotService/GitHubCopilotService.swift

@@ -127,7 +127,7 @@ public class GitHubCopilotBaseService {
                 }()
             }
             let localServer = CopilotLocalProcessServer(executionParameters: executionParams)
-            
+
             localServer.logMessages = UserDefaults.shared.value(for: \.gitHubCopilotVerboseLog)
             localServer.notificationHandler = { _, respond in
                 respond(.timeout)
@@ -162,9 +162,9 @@ public class GitHubCopilotBaseService {
 
             return (server, localServer)
         }()
-        
+
         self.server = server
-        self.localProcessServer = localServer
+        localProcessServer = localServer
     }
 
     public static func createFoldersIfNeeded() throws -> (
@@ -242,6 +242,12 @@ public final class GitHubCopilotAuthService: GitHubCopilotBaseService,
     }
 }
 
+@globalActor public enum GitHubCopilotSuggestionActor {
+    public actor TheActor {}
+    public static let shared = TheActor()
+}
+
+@GitHubCopilotSuggestionActor
 public final class GitHubCopilotSuggestionService: GitHubCopilotBaseService,
     GitHubCopilotSuggestionServiceType
 {
@@ -313,7 +319,7 @@ public final class GitHubCopilotSuggestionService: GitHubCopilotBaseService,
 
         return try await task.value
     }
-    
+
     public func cancelRequest() async {
         await localProcessServer?.cancelOngoingTasks()
     }
@@ -380,7 +386,7 @@ public final class GitHubCopilotSuggestionService: GitHubCopilotBaseService,
 //        Logger.service.debug("Close \(uri)")
         try await server.sendNotification(.didCloseTextDocument(.init(uri: uri)))
     }
-    
+
     public func terminate() async {
         // automatically handled
     }