Merge pull request #5 from Compiler-Inc/add/simple-calls

feat: add simple calls

Author: AtharvaVaidya

Sources/CompilerSwiftAI/Auth/CompilerClient+Auth.swift

@@ -29,8 +29,9 @@ extension CompilerClient {
     }
 
     func authenticateWithServer(idToken: String, nonce: String? = nil) async throws -> String {
-        let lowercasedAppID = appID.uuidString.lowercased()
+        let lowercasedAppID = appID.lowercased()
         let endpoint = "\(baseURL)/v1/apps/\(lowercasedAppID)/end-users/apple"
+        
         guard let url = URL(string: endpoint) else {
             authLogger.error("Invalid URL: \(self.baseURL)")
             throw AuthError.invalidResponse

Sources/CompilerSwiftAI/Function Calling/AppStateProtocol.swift

@@ -0,0 +1,10 @@
+//
+//  File.swift
+//  CompilerSwiftAI
+//
+//  Created by Atharva Vaidya on 3/8/25.
+//
+
+import Foundation
+
+public protocol AppStateProtocol: Encodable & Sendable {}

Sources/CompilerSwiftAI/Function Calling/CompilerClient+Functions.swift

@@ -2,9 +2,9 @@
 
 import OSLog
 
-extension CompilerClient {
+public extension CompilerClient {
     // Request model
-    struct Request<State>: Encodable, Sendable where State: Encodable & Sendable {
+    internal struct Request<State>: Encodable, Sendable where State: Encodable & Sendable {
         let id: String
         let prompt: String
         let state: State
@@ -16,10 +16,13 @@ extension CompilerClient {
     ///   - state: Current state of your app (as defined by the developer, only needs to conform to Encodable and Sendable)
     ///   - token: Authorization token
     /// - Returns: An array of functions with Parameters that are both Decodable and Sendable
-    public func processFunction<State: Encodable & Sendable, Parameters: Decodable & Sendable>(_ prompt: String, for state: State, using _: String) async throws -> [Function<Parameters>] {
+    func processFunction<State: AppStateProtocol, FunctionType: Decodable & Sendable>(
+        prompt: String,
+        for state: State
+    ) async throws -> [FunctionType] {
         functionLogger.debug("Starting processFunction with prompt: \(prompt)")
 
-        let endpoint = "\(baseURL)/v1/function-call/\(appID.uuidString)"
+        let endpoint = "\(baseURL)/v1/function-call/\(appID)"
 
         guard let url = URL(string: endpoint) else {
             functionLogger.error("Invalid URL: \(self.baseURL)")
@@ -28,7 +31,7 @@ extension CompilerClient {
 
         functionLogger.debug("URL created: \(url)")
 
-        let request = Request(id: appID.uuidString, prompt: prompt, state: state)
+        let request = Request(id: appID, prompt: prompt, state: state)
 
         var urlRequest = URLRequest(url: url)
         urlRequest.httpMethod = "POST"
@@ -56,7 +59,7 @@ extension CompilerClient {
         functionLogger.debug("Response body: \(String(data: data, encoding: .utf8) ?? "nil")")
 
         do {
-            let functions = try JSONDecoder().decode([Function<Parameters>].self, from: data)
+            let functions = try JSONDecoder().decode([FunctionType].self, from: data)
             functionLogger.debug("Decoded response: \(functions)")
             return functions
         } catch {

Sources/CompilerSwiftAI/Function Calling/Function.swift

@@ -1,14 +1,25 @@
 //  Copyright © 2025 Compiler, Inc. All rights reserved.
 
 /// The Function struct hold's the function call being returned from Compiler with parameters defined by in the applcation
-public struct Function<Parameters>: Decodable, Sendable where Parameters: Decodable & Sendable {
+public struct Function<Parameters: Decodable & Sendable>: FunctionCallProtocol {
+    private enum CodingKeys: String, CodingKey {
+        case id = "function"
+        case parameters
+        case colloquialDescription = "colloquial_response"
+    }
+    
     /// Function name
-    public let name: String
+    public let id: String
+    
     /// Parameters are Decodable and Sendable and can be anything you need
     public let parameters: Parameters?
-
-    private enum CodingKeys: String, CodingKey {
-        case name = "function"
-        case parameters
+    
+    /// The description to show the user while this function is being executed.
+    public let colloquialDescription: String
+    
+    public init(id: String, parameters: Parameters?, colloquialDescription: String) {
+        self.id = id
+        self.parameters = parameters
+        self.colloquialDescription = colloquialDescription
     }
 }

Sources/CompilerSwiftAI/Function Calling/FunctionCallProtocol.swift

@@ -0,0 +1,21 @@
+//
+//  File.swift
+//  CompilerSwiftAI
+//
+//  Created by Atharva Vaidya on 3/8/25.
+//
+
+import Foundation
+
+public protocol FunctionCallProtocol: Decodable & Sendable {
+    associatedtype Parameters: Decodable & Sendable
+    
+    /// The identifier for this function
+    var id: String { get }
+    
+    /// All the parameters for this function type.
+    var parameters: Parameters { get }
+    
+    /// The description to show the user while this function is being executed.
+    var colloquialDescription: String { get }
+}

Sources/CompilerSwiftAI/Model Calling/ChatHistory.swift

@@ -3,104 +3,43 @@
 import Foundation
 
 /// A convenience type to help manage conversation history with LLMs
-@available(macOS 14.0, iOS 17.0, *)
-actor ChatHistory {
-    var _messages: [Message]
-    var messageID: UUID?
-
-    /// We'll store the active continuation if someone requests `messagesStream`.
-    var continuation: AsyncStream<[Message]>.Continuation?
-
-    var messages: [Message] {
-        // Return all messages except those that are *still* streaming
-        get async {
-            _messages.filter { $0.state == .complete }
-        }
-    }
-
-    /// A continuous stream of *all* messages, including .streaming states
-    var messagesStream: AsyncStream<[Message]> {
-        AsyncStream { continuation in
-            self.continuation = continuation
-            // Immediately yield whatever we have
-            continuation.yield(_messages)
-        }
-    }
-
-    init(systemPrompt: String) {
-        _messages = [Message(role: .system, content: systemPrompt)]
-    }
-
-    func notifyMessageUpdate() {
-        continuation?.yield(_messages)
+actor ChatHistory: ObservableObject {
+    @Published var messages: [Message] = []
+    
+    /// The current message that is being streamed.
+    private var messageId: String?
+    
+    func addSystemPrompt(_ content: String) {
+        messages.append(Message.systemMessage(content: content))
     }
 
     func addUserMessage(_ content: String) {
-        _messages.append(Message(role: .user, content: content))
-        notifyMessageUpdate()
-    }
-
-    func addAssistantMessage(_ content: String) {
-        _messages.append(Message(role: .assistant, content: content))
-        notifyMessageUpdate()
+        messages.append(Message.userMessage(content: content))
     }
 
     /// Start a new streaming response from the assistant
-    @discardableResult
-    func beginStreamingResponse() -> UUID {
-        let id = UUID()
-        let msg = Message(id: id, role: .assistant, content: "", state: .streaming(""))
-        _messages.append(msg)
-        messageID = id
-        notifyMessageUpdate()
-        return id
+    func beginStreamingResponse() {
+        let msg = Message.assistantMessage(content: "")
+        messages.append(msg)
+        messageId = msg.id
     }
 
     /// Update the partial text of the *current* streaming assistant message
     func updateStreamingMessage(_ partial: String) {
-        guard let id = messageID,
-              let idx = _messages.firstIndex(where: { $0.id == id })
-        else {
+        guard let id = messageId, let index = messages.firstIndex(where: { $0.id == id }) else {
             return
         }
-        let old = _messages[idx]
-        _messages[idx] = Message(
-            id: old.id,
-            role: old.role,
-            content: partial,
-            state: .streaming(partial)
+        
+        let streamingMessage = messages[index]
+        messages[index] = Message(
+            id: streamingMessage.id,
+            role: streamingMessage.role,
+            content: streamingMessage.content + partial
         )
-        notifyMessageUpdate()
     }
 
     /// Mark the streaming message complete with final text
-    func completeStreamingMessage(_ finalContent: String) {
-        guard let id = messageID,
-              let idx = _messages.firstIndex(where: { $0.id == id })
-        else {
-            return
-        }
-        _messages[idx] = Message(
-            id: id,
-            role: .assistant,
-            content: finalContent,
-            state: .complete
-        )
-        messageID = nil
-        notifyMessageUpdate()
-    }
-
-    func clearHistory(keepingSystemPrompt: Bool = true) {
-        messageID = nil
-        if keepingSystemPrompt, let systemMessage = _messages.first, systemMessage.role == .system {
-            _messages = [systemMessage]
-        } else {
-            _messages.removeAll()
-        }
-        notifyMessageUpdate()
-    }
-
-    deinit {
-        continuation?.finish()
+    func completeStreamingMessage() {
+        messageId = nil
     }
 }

Sources/CompilerSwiftAI/Model Calling/Client/CompilerClient+ModelCalling.swift

@@ -0,0 +1,55 @@
+//  Copyright 2025 Compiler, Inc. All rights reserved.
+
+import OSLog
+
+extension CompilerClient {
+    func makeModelCallWithResponse(
+        using metadata: ModelMetadata,
+        request: CompletionRequestDTO
+    ) async throws -> ChatCompletionResponse {
+        let endpoint = "\(baseURL)/v1/apps/\(appID)/end-users/model-call"
+        guard let url = URL(string: endpoint) else {
+            modelLogger.error("Invalid URL: \(self.baseURL)")
+            throw URLError(.badURL)
+        }
+
+        modelLogger.debug("Making completion model call to: \(endpoint)")
+
+        var urlRequest = URLRequest(url: url)
+        urlRequest.httpMethod = "POST"
+        urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
+
+        let token = try await getValidToken()
+        urlRequest.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+        let jsonData = try encoder.encode(request)
+        urlRequest.httpBody = jsonData
+
+        return try await performRequest(urlRequest)
+    }
+
+    func performRequest(_ request: URLRequest) async throws -> ChatCompletionResponse {
+        let (data, response) = try await URLSession.shared.data(for: request)
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            modelLogger.error("Invalid response type received")
+            throw AuthError.invalidResponse
+        }
+
+        modelLogger.debug("Response status: \(httpResponse.statusCode)")
+        modelLogger.debug("Response headers: \(httpResponse.allHeaderFields)")
+
+        if let responseString = String(data: data, encoding: .utf8) {
+            modelLogger.debug("Raw response data: \(responseString)")
+        }
+
+        guard 200 ... 299 ~= httpResponse.statusCode else {
+            modelLogger.error("Model call failed with status \(httpResponse.statusCode)")
+            throw AuthError.serverError("Model call failed with status \(httpResponse.statusCode)")
+        }
+
+        return try JSONDecoder().decode(ChatCompletionResponse.self, from: data)
+    }
+}