Lift to SpeziLLM

Package.swift

@@ -26,9 +26,11 @@ let package = Package(
     dependencies: [
         .package(url: "https://github.com/apple/FHIRModels", .upToNextMinor(from: "0.5.0")),
         .package(url: "https://github.com/StanfordBDHG/HealthKitOnFHIR", .upToNextMinor(from: "0.2.4")),
-        .package(url: "https://github.com/StanfordSpezi/Spezi", .upToNextMinor(from: "0.8.0")),
-        .package(url: "https://github.com/StanfordSpezi/SpeziHealthKit.git", .upToNextMinor(from: "0.4.0")),
-        .package(url: "https://github.com/StanfordSpezi/SpeziML.git", .upToNextMinor(from: "0.3.1"))
+        .package(url: "https://github.com/StanfordSpezi/Spezi", from: "1.1.0"),
+        .package(url: "https://github.com/StanfordSpezi/SpeziHealthKit.git", .upToNextMinor(from: "0.5.0")),
+        .package(url: "https://github.com/StanfordSpezi/SpeziLLM.git", branch: "feat/structural-improvments"),
+        .package(url: "https://github.com/StanfordSpezi/SpeziStorage.git", from: "1.0.0"),
+        .package(url: "https://github.com/StanfordSpezi/SpeziChat.git", .upToNextMinor(from: "0.1.4"))
     ],
     targets: [
         .target(
@@ -54,7 +56,10 @@ let package = Package(
                 .target(name: "SpeziFHIR"),
                 .product(name: "Spezi", package: "Spezi"),
                 .product(name: "ModelsR4", package: "FHIRModels"),
-                .product(name: "SpeziOpenAI", package: "SpeziML")
+                .product(name: "SpeziLLM", package: "SpeziLLM"),
+                .product(name: "SpeziLLMOpenAI", package: "SpeziLLM"),
+                .product(name: "SpeziLocalStorage", package: "SpeziStorage"),
+                .product(name: "SpeziChat", package: "SpeziChat")
             ],
             resources: [
                 .process("Resources")

Sources/SpeziFHIRInterpretation/FHIRResourceInterpreter.swift

@@ -7,25 +7,25 @@
 //
 
 import Foundation
-import Observation
 import SpeziFHIR
+import SpeziLLM
 import SpeziLocalStorage
-import SpeziOpenAI
 
 
 /// Responsible for interpreting FHIR resources.
 @Observable
 public class FHIRResourceInterpreter {
-    private let resourceProcesser: FHIRResourceProcesser<String>
+    private let resourceProcessor: FHIRResourceProcessor<String>
 
 
     /// - Parameters:
     ///   - localStorage: Local storage module that needs to be passed to the ``FHIRResourceInterpreter`` to allow it to cache interpretations.
     ///   - openAIModel: OpenAI module that needs to be passed to the ``FHIRResourceInterpreter`` to allow it to retrieve interpretations.
-    public init(localStorage: LocalStorage, openAIModel: OpenAIModel) {
-        self.resourceProcesser = FHIRResourceProcesser(
+    public init(localStorage: LocalStorage, llmRunner: LLMRunner, llmSchema: any LLMSchema) {
+        self.resourceProcessor = FHIRResourceProcessor(
             localStorage: localStorage,
-            openAIModel: openAIModel,
+            llmRunner: llmRunner,
+            llmSchema: llmSchema,
             storageKey: "FHIRResourceInterpreter.Interpretations",
             prompt: FHIRPrompt.interpretation
         )
@@ -40,15 +40,15 @@
     /// - Returns: An asynchronous `String` representing the interpretation of the resource.
     @discardableResult
     public func interpret(resource: FHIRResource, forceReload: Bool = false) async throws -> String {
-        try await resourceProcesser.process(resource: resource, forceReload: forceReload)
+        try await resourceProcessor.process(resource: resource, forceReload: forceReload)
     }
 
     /// Retrieve the cached interpretation of a given FHIR resource. Returns a human-readable interpretation or `nil` if it is not present.
     ///
     /// - Parameter resource: The resource where the cached interpretation should be loaded from.
     /// - Returns: The cached interpretation. Returns `nil` if the resource is not present.
     public func cachedInterpretation(forResource resource: FHIRResource) -> String? {
-        resourceProcesser.results[resource.id]
+        resourceProcessor.results[resource.id]
     }
 }
 

Sources/SpeziFHIRInterpretation/FHIRResourceProcesser.swift → Sources/SpeziFHIRInterpretation/FHIRResourceProcessor.swift

@@ -6,19 +6,20 @@
 // SPDX-License-Identifier: MIT
 //
 
-import Observation
+import SpeziChat
 import SpeziFHIR
+import SpeziLLM
+import SpeziLLMOpenAI
 import SpeziLocalStorage
-import SpeziOpenAI
 
 
-@Observable
-class FHIRResourceProcesser<Content: Codable & LosslessStringConvertible> {
+class FHIRResourceProcessor<Content: Codable & LosslessStringConvertible> {
     typealias Results = [FHIRResource.ID: Content]
 
 
     private let localStorage: LocalStorage
-    private let openAIModel: OpenAIModel
+    private let llmRunner: LLMRunner
+    private let llmSchema: any LLMSchema
     private let storageKey: String
     private let prompt: FHIRPrompt
 
@@ -36,12 +37,14 @@
 
     init(
         localStorage: LocalStorage,
-        openAIModel: OpenAIModel,
+        llmRunner: LLMRunner,
+        llmSchema: any LLMSchema,
         storageKey: String,
         prompt: FHIRPrompt
     ) {
         self.localStorage = localStorage
-        self.openAIModel = openAIModel
+        self.llmRunner = llmRunner
+        self.llmSchema = llmSchema
         self.storageKey = storageKey
         self.prompt = prompt
         self.results = (try? localStorage.read(storageKey: storageKey)) ?? [:]
@@ -54,27 +57,21 @@
             return result
         }
 
-        let chatStreamResults = try await openAIModel.queryAPI(withChat: [systemPrompt(forResource: resource)])
+        let chatStreamResults = try await llmRunner.oneShot(
+            with: llmSchema,
+            chat: .init(systemMessages: prompt.prompt(withFHIRResource: resource.jsonDescription))
+        )
         var result = ""
 
         for try await chatStreamResult in chatStreamResults {
-            for choice in chatStreamResult.choices {
-                result.append(choice.delta.content ?? "")
-            }
+            result.append(chatStreamResult)
         }
 
         guard let content = Content(result) else {
-            throw FHIRResourceProcesserError.notParsableAsAString
+            throw FHIRResourceProcessorError.notParsableAsAString
         }
 
         results[resource.id] = content
         return content
     }
-
-    private func systemPrompt(forResource resource: FHIRResource) -> Chat {
-        Chat(
-            role: .system,
-            content: prompt.prompt(withFHIRResource: resource.jsonDescription)
-        )
-    }
 }

Sources/SpeziFHIRInterpretation/FHIRResourceProcesserError.swift → Sources/SpeziFHIRInterpretation/FHIRResourceProcessorError.swift

@@ -9,7 +9,7 @@
 import Foundation
 
 
-enum FHIRResourceProcesserError: LocalizedError {
+enum FHIRResourceProcessorError: LocalizedError {
     case notParsableAsAString
 
 

Sources/SpeziFHIRInterpretation/FHIRResourceSummary.swift

@@ -7,16 +7,15 @@
 //
 
 import Foundation
-import Observation
 import SpeziFHIR
+import SpeziLLM
 import SpeziLocalStorage
-import SpeziOpenAI
 
 
 /// Responsible for summarizing FHIR resources.
 @Observable
 public class FHIRResourceSummary {
-    /// Summary of a FHIR resource emited by the ``FHIRResourceSummary``.
+    /// Summary of a FHIR resource emitted by the ``FHIRResourceSummary``.
     public struct Summary: Codable, LosslessStringConvertible {
         /// Title of the FHIR resource, should be shorter than 4 words.
         public let title: String
@@ -41,16 +40,17 @@ public class FHIRResourceSummary {
     }
 
 
-    private let resourceProcesser: FHIRResourceProcesser<Summary>
+    private let resourceProcesser: FHIRResourceProcessor<Summary>
 
 
     /// - Parameters:
     ///   - localStorage: Local storage module that needs to be passed to the ``FHIRResourceSummary`` to allow it to cache summaries.
     ///   - openAIModel: OpenAI module that needs to be passed to the ``FHIRResourceSummary`` to allow it to retrieve summaries.
-    public init(localStorage: LocalStorage, openAIModel: OpenAIModel) {
-        self.resourceProcesser = FHIRResourceProcesser(
+    public init(localStorage: LocalStorage, llmRunner: LLMRunner, llmSchema: any LLMSchema) {
+        self.resourceProcesser = FHIRResourceProcessor(
             localStorage: localStorage,
-            openAIModel: openAIModel,
+            llmRunner: llmRunner,
+            llmSchema: llmSchema,
             storageKey: "FHIRResourceSummary.Summaries",
             prompt: FHIRPrompt.summary
         )

Sources/SpeziFHIRInterpretation/FHIRResourceSummaryView.swift

@@ -16,13 +16,14 @@
     @Environment(FHIRResourceSummary.self) private var fhirResourceSummary
 
     @State private var viewState: ViewState = .idle
+    @State private var cachedSummary: FHIRResourceSummary.Summary?
 
     private let resource: FHIRResource
 
 
     public var body: some View {
         Group {
-            if let summary = fhirResourceSummary.cachedSummary(forResource: resource) {
+            if let summary = cachedSummary {
                 VStack(alignment: .leading, spacing: 0) {
                     Text(summary.title)
                     if let date = resource.date {
@@ -58,6 +59,9 @@
             }
         }
             .viewStateAlert(state: $viewState)
+            .task {
+                cachedSummary = await fhirResourceSummary.cachedSummary(forResource: resource)
+            }
     }
 
 

Sources/SpeziFHIRInterpretation/Settings/FHIRPrompt.swift

@@ -44,7 +44,7 @@ public struct FHIRPrompt: Hashable {
     }
 
 
-    /// Saves a new version of the propmpt.
+    /// Saves a new version of the prompt.
     /// - Parameter prompt: The new prompt.
     public func save(prompt: String) {
         UserDefaults.standard.set(prompt, forKey: storageKey)

Tests/UITests/TestApp/ExampleModule.swift

@@ -8,21 +8,29 @@
 
 import Spezi
 import SpeziFHIRInterpretation
+import SpeziLLM
 import SpeziLocalStorage
-import class SpeziOpenAI.OpenAIModule
-import class SpeziOpenAI.OpenAIModel
 
 
-class ExampleModule: Module {
+class ExampleModule: Module, @unchecked Sendable {
     @Dependency private var localStorage: LocalStorage
-    @Dependency private var openAI: OpenAIModule
+    @Dependency private var llmRunner: LLMRunner
 
     @Model private var resourceSummary: FHIRResourceSummary
     @Model private var resourceInterpreter: FHIRResourceInterpreter
 
+    let llmSchema = LLMMockSchema()
 
     func configure() {
-        resourceSummary = FHIRResourceSummary(localStorage: localStorage, openAIModel: openAI.model)
-        resourceInterpreter = FHIRResourceInterpreter(localStorage: localStorage, openAIModel: openAI.model)
+        resourceSummary = FHIRResourceSummary(
+            localStorage: localStorage,
+            llmRunner: llmRunner,
+            llmSchema: llmSchema
+        )
+        resourceInterpreter = FHIRResourceInterpreter(
+            localStorage: localStorage,
+            llmRunner: llmRunner,
+            llmSchema: llmSchema
+        )
     }
 }

Tests/UITests/TestApp/TestAppDelegate.swift

@@ -8,12 +8,16 @@
 
 import Spezi
 import SpeziFHIR
+import SpeziLLM
 import SwiftUI
 
 
 class TestAppDelegate: SpeziAppDelegate {
     override var configuration: Configuration {
         Configuration(standard: FHIR()) {
+            LLMRunner {
+                LLMMockPlatform()
+            }
             ExampleModule()
         }
     }