Merge pull request #4 from SwiftedMind/develop

2.0.0 Release Merge

Author: SwiftedMind

Package.swift

@@ -5,7 +5,12 @@ import PackageDescription
 
 let package = Package(
     name: "GPTSwift",
-    platforms: [.iOS(.v13), .macOS(.v10_15)],
+    platforms: [
+        .iOS(.v13),
+        .macOS(.v10_15),
+        .watchOS(.v8),
+        .tvOS(.v15)
+    ],
     products: [
         .library(
             name: "GPTSwift",

README.md

@@ -1,18 +1,30 @@
-![GPTSwiftBanner](https://user-images.githubusercontent.com/7083109/222953457-ffaa5920-64c2-4b04-b6ad-e1341b89732c.png)
-
+<picture>
+  <source width="150px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/7083109/224795534-47eaf18c-2032-48a9-a453-3dba6fbd7699.png">
+  <img width="150px" alt="GPTSwift Logo. Light: 'Light Mode' Dark: 'Dark Mode'" src="https://user-images.githubusercontent.com/7083109/224795540-5a1938ed-b829-40d3-aa67-3a51fa5de904.png">
+</picture>
 
 # GPTSwift
 [![](https://img.shields.io/endpoint?url=https%3A%2F%2Fswiftpackageindex.com%2Fapi%2Fpackages%2FSwiftedMind%2FGPTSwift%2Fbadge%3Ftype%3Dswift-versions)](https://swiftpackageindex.com/SwiftedMind/GPTSwift)
 [![](https://img.shields.io/endpoint?url=https%3A%2F%2Fswiftpackageindex.com%2Fapi%2Fpackages%2FSwiftedMind%2FGPTSwift%2Fbadge%3Ftype%3Dplatforms)](https://swiftpackageindex.com/SwiftedMind/GPTSwift)
 
 
+[![](https://img.shields.io/endpoint?url=https%3A%2F%2Fswiftpackageindex.com%2Fapi%2Fpackages%2FSwiftedMind%2FGPTSwift%2Fbadge%3Ftype%3Dswift-versions)](https://swiftpackageindex.com/SwiftedMind/GPTSwift)
+[![](https://img.shields.io/endpoint?url=https%3A%2F%2Fswiftpackageindex.com%2Fapi%2Fpackages%2FSwiftedMind%2FGPTSwift%2Fbadge%3Ftype%3Dplatforms)](https://swiftpackageindex.com/SwiftedMind/GPTSwift)
+![GitHub](https://img.shields.io/github/license/SwiftedMind/GPTSwift)
+
 GPTSwift is a lightweight and convenient wrapper around the OpenAI API. It is completely written in Swift. Currently, only ChatGPT's API is supported.
 
 Using GPTSwift is easy:
 
 ```swift
-let gptSwift = GPTSwift(apiKey: "YOUR_API_KEY")
-try await gptSwift.askChatGPT("What is the answer to life, the universe and everything in it?")
+let gptSwift = ChatGPTSwift(apiKey: "YOUR_API_KEY")
+try await gptSwift.ask("What is the answer to life, the universe and everything in it?")
+
+// Stream the answers as they are generated
+var answer = ""
+for try await nextWord in try await gptSwift.streamedAnswer.ask("Tell me a story about birds") {
+    answer += nextWord
+}
 ```
 
 An example project can be found here: [GPTPlayground](https://github.com/SwiftedMind/GPTPlayground/tree/main)
@@ -29,17 +41,14 @@ An example project can be found here: [GPTPlayground](https://github.com/Swifted
 
 ### Requirements
 
-- iOS 13+
-- macOS 10.15+
-
-You will also need Swift 5.7 to compile the package.
+GPTSwift supports iOS 15+, macOS 12+, watchOS 8+ and tvOS 15+.
 
 ### Installation
 
 The package is installed through the Swift Package Manager. Simply add the following line to your `Package.swift` dependencies:
 
 ```swift
-.package(url: "https://github.com/SwiftedMind/GPTSwift", from: "1.0.0")
+.package(url: "https://github.com/SwiftedMind/GPTSwift", from: "2.0.0")
 ```
 
 Alternatively, if you want to add the package to an Xcode project, go to `File` > `Add Packages...` and enter the URL "https://github.com/SwiftedMind/GPTSwift" into the search field at the top. GPTSwift should appear in the list. Select it and click "Add Package" in the bottom right.
@@ -55,14 +64,14 @@ GPTSwift is just a lightweight wrapper around the API. Here are a few examples:
 import GPTSwift
 
 func askChatGPT() async throws {
-    let gptSwift = GPTSwift(apiKey: "YOUR_API_KEY")
+    let gptSwift = ChatGPTSwift(apiKey: "YOUR_API_KEY")
 
     // Basic query
-    let firstResponse = try await gptSwift.askChatGPT("What is the answer to life, the universe and everything in it?")
+    let firstResponse = try await gptSwift.ask("What is the answer to life, the universe and everything in it?")
     print(firstResponse.choices.map(\.message))
 
     // Send multiple messages
-    let secondResponse = try await gptSwift.askChatGPT(
+    let secondResponse = try await gptSwift.ask(
         messages: [
             ChatMessage(role: .system, content: "You are a dog."),
             ChatMessage(role: .user, content: "Do you actually like playing fetch?")
@@ -80,11 +89,32 @@ func askChatGPT() async throws {
     fullRequest.temperature = 0.8
     fullRequest.numberOfAnswers = 2
 
-    let thirdResponse = try await gptSwift.askChatGPT(request: fullRequest)
+    let thirdResponse = try await gptSwift.ask(with: fullRequest)
     print(thirdResponse.choices.map(\.message))
 }
 ```
 
+### Streaming answers
+
+All of the above methods have a variant that lets you stream GPT's answer word for word, right as they are generated. The stream is provided to you via an `AsyncThrowingStream`. All you have to do is add a `streamedAnswer` before the call to `ask()`. For example:
+
+```swift
+import GPTSwift
+
+// In your view model
+@Published var gptAnswer = ""
+
+func askChatGPT() async throws {
+    let gptSwift = ChatGPTSwift(apiKey: "YOUR_API_KEY")
+
+    // Basic query
+    gptAnswer = ""
+    for try await nextWord in try await gptSwift.streamedAnswer.ask("Tell me a story about birds") {
+        gptAnswer += nextWord
+    }
+}
+```
+
 For more information about the API, you can look at OpenAI's documentation:
 - [ChatGPT API Introduction](https://platform.openai.com/docs/guides/chat/chat-completions-beta)
 - [ChatGPT API documentation](https://platform.openai.com/docs/api-reference/chat/create)

Sources/GPTSwift/ChatGPT/ChatGPTSwift+StreamedAnswer.swift

@@ -0,0 +1,126 @@
+//
+//  Copyright © 2023 Dennis Müller and all collaborators
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+import Get
+
+extension ChatGPTSwift {
+    public class StreamedAnswer {
+        private let client: APIClient
+        private let apiKey: String
+
+        init(client: APIClient, apiKey: String) {
+            self.client = client
+            self.apiKey = apiKey
+        }
+
+        /// Ask ChatGPT a single prompt without any special configuration.
+        /// - Parameter userPrompt: The prompt to send
+        /// - Returns: The response.
+        @available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *)
+        public func ask(_ userPrompt: String) async throws -> AsyncThrowingStream<String, Swift.Error> {
+            let chatRequest = ChatRequest(messages: [.init(role: .user, content: userPrompt)], stream: true)
+            return try await ask(with: chatRequest)
+        }
+
+        /// Ask ChatGPT something by sending multiple messages without any special configuration.
+        /// - Parameter messages: The chat messages.
+        /// - Returns: The response.
+        @available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *)
+        public func ask(messages: [ChatMessage]) async throws -> AsyncThrowingStream<String, Swift.Error> {
+            let chatRequest = ChatRequest(messages: messages, stream: true)
+            return try await ask(with: chatRequest)
+        }
+
+        /// Ask ChatGPT something by providing a chat request object, giving you full control over the request's configuration.
+        /// - Parameter request: The request.
+        /// - Returns: The response.
+        @available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *)
+        public func ask(with chatRequest: ChatRequest) async throws -> AsyncThrowingStream<String, Swift.Error> {
+            let request = Request(path: API.v1ChatCompletion, method: .post, body: chatRequest)
+            var urlRequest = try await client.makeURLRequest(for: request)
+            addHeaders(to: &urlRequest)
+
+            let (result, response) = try await client.session.bytes(for: urlRequest)
+
+            guard let response = response as? HTTPURLResponse else {
+                throw Error.invalidResponse
+            }
+
+            guard (200...299).contains(response.statusCode) else {
+                throw Error.unacceptableStatusCode(code: response.statusCode, message: "")
+            }
+
+            return AsyncThrowingStream { continuation in
+                Task {
+                    do {
+                        for try await line in result.lines {
+                            if let chatResponse = line.asStreamedResponse {
+
+                                // Ignore lines where only the role is specified
+                                if chatResponse.choices.first?.delta.role != nil {
+                                    continue
+                                }
+
+                                if let message = chatResponse.choices.first?.delta.content {
+                                    continuation.yield(message)
+                                } else {
+                                    break
+                                }
+                            } else {
+                                break
+                            }
+                        }
+                    } catch {
+                        throw Error.networkError(error)
+                    }
+
+                    continuation.finish()
+                }
+            }
+        }
+
+        private func addHeaders(to request: inout URLRequest) {
+            request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+            request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        }
+    }
+}
+
+extension ChatGPTSwift.StreamedAnswer {
+    public enum Error: Swift.Error {
+        case invalidResponse
+        case unacceptableStatusCode(code: Int, message: String)
+        case networkError(Swift.Error)
+    }
+}
+
+private let decoder = JSONDecoder()
+private extension String {
+    var asStreamedResponse: ChatStreamedResponse? {
+        guard hasPrefix("data: "),
+              let data = dropFirst(6).data(using: .utf8) else {
+            return nil
+        }
+        return try! decoder.decode(ChatStreamedResponse.self, from: data)
+    }
+}

Sources/GPTSwift/GPTSwift.swift renamed to Sources/GPTSwift/ChatGPT/ChatGPTSwift.swift

@@ -23,14 +23,15 @@
 import Foundation
 import Get
 
-/// A simple wrapper around the API for OpenAI.
-///
-/// Currently only supporting ChatGPT's model.
-public class GPTSwift: APIClientDelegate {
+/// A simple wrapper around the API for OpenAI's ChatGPT.
+public class ChatGPTSwift: APIClientDelegate {
 
     private let client: APIClient
     private let apiClientRequestHandler: APIClientRequestHandler
 
+    /// A version of GPTSwift that streams all the answers.
+    public let streamedAnswer: StreamedAnswer
+
     /// A simple wrapper around the API for OpenAI.
     ///
     /// Currently only supporting ChatGPT's model.
@@ -40,12 +41,13 @@ public class GPTSwift: APIClientDelegate {
         self.client = APIClient(baseURL: URL(string: API.base)) { [apiClientRequestHandler] configuration in
             configuration.delegate = apiClientRequestHandler
         }
+        self.streamedAnswer = .init(client: client, apiKey: apiKey)
     }
 
     /// Ask ChatGPT a single prompt without any special configuration.
     /// - Parameter userPrompt: The prompt to send
     /// - Returns: The response.
-    public func askChatGPT(_ userPrompt: String) async throws -> ChatResponse {
+    public func ask(_ userPrompt: String) async throws -> ChatResponse {
         let request = Request<ChatResponse>(
             path: API.v1ChatCompletion,
             method: .post,
@@ -54,29 +56,30 @@ public class GPTSwift: APIClientDelegate {
             ])
         )
 
+
         return try await client.send(request).value
     }
 
-    /// Ask ChatGPT something by providing a chat request object, giving you full control over the request's configuration.
-    /// - Parameter request: The request.
+    /// Ask ChatGPT something by sending multiple messages without any special configuration.
+    /// - Parameter messages: The chat messages.
     /// - Returns: The response.
-    public func askChatGPT(request: ChatRequest) async throws -> ChatResponse {
+    public func ask(messages: [ChatMessage]) async throws -> ChatResponse {
         let request = Request<ChatResponse>(
             path: API.v1ChatCompletion,
             method: .post,
-            body: request
+            body: ChatRequest(messages: messages)
         )
         return try await client.send(request).value
     }
 
-    /// Ask ChatGPT something by sending multiple messages without any special configuration.
-    /// - Parameter messages: The chat messages.
+    /// Ask ChatGPT something by providing a chat request object, giving you full control over the request's configuration.
+    /// - Parameter request: The request.
     /// - Returns: The response.
-    public func askChatGPT(messages: [ChatMessage]) async throws -> ChatResponse {
+    public func ask(with request: ChatRequest) async throws -> ChatResponse {
         let request = Request<ChatResponse>(
             path: API.v1ChatCompletion,
             method: .post,
-            body: ChatRequest(messages: messages)
+            body: request
         )
         return try await client.send(request).value
     }

Sources/GPTSwift/Models/ChatMessage.swift renamed to Sources/GPTSwift/ChatGPT/Models/ChatMessage.swift

@@ -31,34 +31,14 @@ import Foundation
 public struct ChatMessage: Codable {
 
     /// The role of the message.
-    public var role: Role
+    public var role: ChatMessageRole
 
     /// The content of the message.
     public var content: String
 
     /// A message is a part of the chat conversation.
-    public init(role: Role, content: String) {
+    public init(role: ChatMessageRole, content: String) {
         self.role = role
         self.content = content
     }
 }
-
-extension ChatMessage {
-    
-    /// A role can be seen as the "owner", or "author" of a given message. You use this to allow GPT to differentiate between actual user prompts, behavior instructions (by you, the developer) and previous answers by GPT.
-    ///
-    /// For more information, see the [OpenAI documentation](https://platform.openai.com/docs/guides/chat/introduction).
-    public enum Role: String, Codable {
-
-        /// The user role is the used for the prompts made by the end-user.
-        case user
-
-        /// The system role is used to instruct GPT on how to behave and what to generate.
-        case system
-
-        /// The assistant role is usually meant to indicate that a message originates from a previous GPT answer.
-        ///
-        /// This is useful because it allows GPT to recall previous answers and know about the general context of the conversation.
-        case assistant
-    }
-}

Sources/GPTSwift/ChatGPT/Models/ChatMessageRole.swift

@@ -0,0 +1,25 @@
+//
+//  File.swift
+//  
+//
+//  Created by Dennis Müller on 05.03.23.
+//
+
+import Foundation
+
+/// A role can be seen as the "owner", or "author" of a given message. You use this to allow GPT to differentiate between actual user prompts, behavior instructions (by you, the developer) and previous answers by GPT.
+///
+/// For more information, see the [OpenAI documentation](https://platform.openai.com/docs/guides/chat/introduction).
+public enum ChatMessageRole: String, Codable {
+
+    /// The user role is the used for the prompts made by the end-user.
+    case user
+
+    /// The system role is used to instruct GPT on how to behave and what to generate.
+    case system
+
+    /// The assistant role is usually meant to indicate that a message originates from a previous GPT answer.
+    ///
+    /// This is useful because it allows GPT to recall previous answers and know about the general context of the conversation.
+    case assistant
+}