π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
import Combine
import Foundation
import os
import SwiftUI
@MainActor
final class ChatViewModel: ObservableObject {
private struct ModelReadyKey: Equatable {
let id: String
let requestedContextLength: Int?
}
private struct StreamingBuffer {
var text = ""
var tokenCount = 0
var lastUiUpdate = Date.distantPast
var updateTask: Task<Void, Never>?
}
private static let defaultTemperature: Float = 0.5
private static let systemPromptDateFormatter: DateFormatter = {
let formatter = DateFormatter()
formatter.dateFormat = "yyyy-MM-dd"
return formatter
}()
private static let systemPromptDatePlaceholder = ConfigDefaults.shared
.systemPromptDatePlaceholder
private static let overflowSafetyTokens = 256
private static let imageTokenEstimate = 768
private nonisolated static let sessionTitleMaxLength = 40
private static let sessionSummaryMaxWords = 7
private static let sessionSummaryStoreKey = "ensu.session_summaries"
private static let sessionSummarySystemPrompt = ConfigDefaults.shared.sessionSummarySystemPrompt
private func systemPrompt() -> String {
let date = Self.systemPromptDateFormatter.string(from: Date())
let promptBody = ModelSettingsStore.currentSystemPromptBody()
return promptBody.replacingOccurrences(of: Self.systemPromptDatePlaceholder, with: date)
}
private let logger = EnsuLogging.shared.logger("ChatViewModel")
@Published var sessions: [ChatSession]
@Published var currentSessionId: UUID?
@Published var messages: [RenderedChatMessage]
@Published var streamingResponse: String = ""
@Published var streamingParentId: UUID? = nil
@Published var overflowAlert: OverflowAlertState? = nil
@Published var conversationStatus: String?
var displayedStreamingResponse: String {
guard let activeSession = activeGenerationSessionId,
activeSession == currentSessionId,
activeGenerationId != nil
else {
return ""
}
return streamingResponse
}
var displayedStreamingParentId: UUID? {
guard let activeSession = activeGenerationSessionId,
activeSession == currentSessionId,
activeGenerationId != nil
else {
return nil
}
return streamingParentId
}
@Published var isGenerating: Bool = false
@Published private(set) var isSendPending: Bool = false
@Published var isDownloading: Bool = false
@Published var isProcessingAttachments: Bool = false
@Published var draftText: String = "" {
didSet {
if draftText != oldValue {
composerRevision += 1
voiceInsertionCaret = nil
}
}
}
@Published var draftAttachments: [ChatAttachment] = []
private var draftImageAttachmentCount: Int {
draftAttachments.filter { $0.kind == .image }.count
}
@Published var editingMessageId: UUID?
@Published var downloadToast: DownloadToastState?
@Published var isModelDownloaded: Bool = false
@Published var modelDownloadSizeBytes: Int64?
@Published var hasRequestedModelDownload: Bool = false
@Published var deviceCapability: ChatDeviceCapability = .unknown
@Published var showUnsupportedDeviceDialog: Bool = false
@Published var generationErrorMessage: String?
@Published var draftCursorMoveToken = UUID()
let knowledgeStore: KnowledgeStore
let notesStore: NotesStore
private var chatActive = false
private var appForeground = false
private var warmupSuppressed = false
private var warmupTask: Task<Void, Never>?
private var warmupAttempt: (owner: UUID, selection: ModelReadyKey)?
private let provider: LlmProvider
private let knowledgeEmbedding: KnowledgeEmbeddingConfig
private let knowledgeProvider: KnowledgeProvider
let voiceTranscriber: VoiceTranscriptionService
private var composerRevision: UInt64 = 0
private var emptyComposerId = UUID()
var composerSelection = NSRange(location: 0, length: 0)
var composerIsComposing = false
@Published var voiceInsertionCaret: Int?
private var chatDb: EnsuDb
private let attachmentsDir: URL
private let chatDbPath: String
private let chatDbKey: Data
private let modelSettings: ModelSettingsStore
private var messageStore: [UUID: [MessageNode]] = [:]
private var branchSelections: [UUID: [String: UUID]] = [:]
private var childrenByParentCache: [UUID: [UUID: [MessageNode]]] = [:]
private var sessionSummaries: [String: String] = [:]
private var sessionSummaryTask: Task<Void, Never>?
private var reloadTask: Task<Void, Never>?
private let rootId = UUID(uuid: (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
private var generationTask: Task<Void, Never>?
private var pendingSendTask: Task<Void, Never>?
private var pendingSendId: UUID?
private var modelDownloadTask: Task<Void, Never>?
private var sharedModelReadyTask: Task<Void, Error>?
private var sharedModelReadyTaskId: UUID?
private var sharedModelReadyKey: ModelReadyKey?
private var stopRequested = false
private var activeGenerationId: UUID?
private var activeGenerationSessionId: UUID?
private var modelDownloadLoggedStart = false
private let downloadProgressTracker = DownloadProgressTracker()
private var pendingOverflow: PendingOverflow?
private var overflowBypassMessageId: UUID?
init(assetStore: AssetStore) async {
logger.info("Initializing")
let summaries = Self.loadSessionSummaries().reduce(into: [String: String]()) {
result, item in
result[item.key.lowercased()] = item.value
}
let baseDir =
FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
?? FileManager.default.temporaryDirectory
let config = ConfigDefaults.shared
// Must initialize after the asset store migrates the persisted selection.
self.modelSettings = ModelSettingsStore.shared
let transcription = transcriptionModelAsset()
var info = utsname()
uname(&info)
let machine = withUnsafeBytes(of: &info.machine) { bytes in
String(decoding: bytes.prefix { $0 != 0 }, as: UTF8.self)
}
let transcriber = Transcriber.withCache(
modelDir: assetStore.assetDir(transcription).path,
vadModelPath: assetStore.voiceActivityModelPath().path,
cacheDirectory: (FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)
.first
?? FileManager.default.temporaryDirectory).path,
deviceIdentity: "\(machine)|\(ProcessInfo.processInfo.operatingSystemVersionString)"
)
let provider = LlmProvider(
assetStore: assetStore, transcriber: transcriber,
knowledgeEmbedding: config.knowledgeEmbedding)
let notesStore = NotesStore(provider: provider)
provider.modelMaintenance = notesStore
let voiceTranscriber = VoiceTranscriptionService(
provider: provider, assetStore: assetStore)
let knowledgeProvider = KnowledgeProvider(assetStore: assetStore)
let knowledgeStore = KnowledgeStore(
datasets: config.knowledgeDatasets, provider: knowledgeProvider)
let dbDir = baseDir.appendingPathComponent("llmchat", isDirectory: true)
try? FileManager.default.createDirectory(
at: dbDir, withIntermediateDirectories: true, attributes: nil)
let attachmentsDir = dbDir.appendingPathComponent("chat_attachments", isDirectory: true)
try? FileManager.default.createDirectory(
at: attachmentsDir, withIntermediateDirectories: true, attributes: nil)
let chatDbPath = dbDir.appendingPathComponent("llmchat.db").path
let hasChatData =
FileManager.default.fileExists(atPath: chatDbPath)
|| (try? FileManager.default.contentsOfDirectory(atPath: attachmentsDir.path).isEmpty)
!= true
let chatDbKey: Data
do {
chatDbKey = try await CredentialStore.shared.getOrCreateChatDbKey(
hasChatData: hasChatData)
} catch {
fatalError("Failed to load chat DB key: \(error)")
}
let chatDb: EnsuDb
do {
chatDb = try EnsuDb.open(mainDbPath: chatDbPath, key: chatDbKey)
} catch {
fatalError("Failed to open chat DB: \(error)")
}
let loadedResult = try? chatDb.listSessions()
if let loadedResult {
Self.pruneOrphanedAttachments(
sessions: loadedResult,
chatDb: chatDb,
attachmentsDir: attachmentsDir
)
}
let loaded = loadedResult ?? []
let sessions = Self.buildSessions(from: loaded, chatDb: chatDb, summaries: summaries)
self.provider = provider
self.knowledgeEmbedding = config.knowledgeEmbedding
self.knowledgeProvider = knowledgeProvider
self.knowledgeStore = knowledgeStore
self.notesStore = notesStore
self.voiceTranscriber = voiceTranscriber
self.chatDb = chatDb
self.attachmentsDir = attachmentsDir
self.chatDbPath = chatDbPath
self.chatDbKey = chatDbKey
self.sessionSummaries = summaries
self.sessions = sessions
self.currentSessionId = nil
self.messages = []
for session in sessions {
self.messageStore[session.id] = []
self.branchSelections[session.id] = [:]
}
if let current = self.currentSessionId {
loadMessagesFromDb(for: current)
}
voiceTranscriber.onActivityChanged = { [weak self] in self?.refreshChatWarmup() }
refreshDeviceCapability()
refreshModelDownloadInfo()
Task {
async let knowledge: Void = knowledgeStore.bootstrap()
async let notes: Void = notesStore.bootstrap()
_ = await (knowledge, notes)
}
}
func setChatActive(_ active: Bool) {
guard chatActive != active else { return }
chatActive = active
if !active {
sessionSummaryTask?.cancel()
cancelChatWarmup(releaseLoadedModel: false)
}
Task { await provider.setChatForeground(active) }
if active {
warmupSuppressed = false
if warmupTask == nil { warmupAttempt = nil }
}
refreshChatWarmup()
}
func setAppForeground(_ active: Bool) {
guard appForeground != active else { return }
appForeground = active
if !active { cancelChatWarmup(releaseLoadedModel: false) }
Task { await provider.setAppForeground(active) }
}
func handleMemoryPressure() {
voiceTranscriber.interrupt(reason: .memoryUnavailable)
sessionSummaryTask?.cancel()
warmupSuppressed = true
cancelChatWarmup()
Task { await provider.handleMemoryPressure() }
}
private func cancelChatWarmup(releaseLoadedModel: Bool = true) {
warmupTask?.cancel()
warmupTask = nil
let owner = warmupAttempt?.owner
warmupAttempt = nil
if let owner, releaseLoadedModel {
Task { await provider.releaseChatWarmup(owner: owner) }
}
}
private func refreshChatWarmup() {
let selection = modelSettings.currentSelection()
let key = modelReadyKey(for: selection)
let eligible =
appForeground && chatActive && !warmupSuppressed && !isChatUnsupported
&& !voiceTranscriber.active && !voiceTranscriber.hasActiveTasks
if let attempt = warmupAttempt, attempt.selection != key { cancelChatWarmup() }
guard eligible, warmupAttempt == nil, !isGenerating, !isDownloading,
provider.isChatModelReady(selection)
else { return }
let owner = UUID()
warmupAttempt = (owner, key)
warmupTask = Task { [weak self] in
guard let self else { return }
var ready = false
defer {
if warmupAttempt?.owner == owner {
warmupTask = nil
if !ready { warmupAttempt = nil }
}
}
do {
try await Task.sleep(nanoseconds: 350_000_000)
await knowledgeStore.bootstrap()
await notesStore.bootstrap()
ready = try await retryChatWarmup(
isEligible: {
warmupAttempt?.owner == owner
&& modelReadyKey(for: modelSettings.currentSelection()) == key
&& appForeground && chatActive && !warmupSuppressed
&& !isChatUnsupported && !isGenerating && !isDownloading
&& !voiceTranscriber.active && !voiceTranscriber.hasActiveTasks
},
operation: {
try await provider.prewarmChatModelIfDownloaded(selection, owner: owner)
})
} catch {
guard !Task.isCancelled, !isCancellation(error), warmupAttempt?.owner == owner,
modelReadyKey(for: modelSettings.currentSelection()) == key,
!isGenerating, !isDownloading
else { return }
logger.info("Chat warmup skipped", details: error.localizedDescription)
}
}
}
var isChatUnsupported: Bool {
!deviceCapability.isChatSupported
}
var supportsImageAttachments: Bool {
provider.supportsImages(modelSettings.currentSelection())
}
var unsupportedDeviceMessage: String {
Self.unsupportedDeviceMessage
}
func refreshDeviceCapability() {
let capability = currentChatDeviceCapability()
deviceCapability = capability
knowledgeStore.downloadsAllowed = capability.isChatSupported
logger.info("Chat device capability evaluated", details: "\(capability)")
guard !capability.isChatSupported else { return }
cancelPendingSend()
showUnsupportedDeviceDialog = true
isDownloading = false
downloadToast = nil
modelDownloadSizeBytes = nil
hasRequestedModelDownload = false
modelDownloadTask?.cancel()
sharedModelReadyTask?.cancel()
clearSharedModelReadyTask()
discardUnstoredAttachments(draftAttachments)
editingMessageId = nil
draftText = ""
draftAttachments = []
}
func dismissUnsupportedDeviceDialog() {
showUnsupportedDeviceDialog = false
}
static let unsupportedDeviceMessage =
"This device doesn't have enough memory to run Ensu's AI model. "
+ "You can view existing chats, but can't send new messages."
private func reopenChatStoreIfNeeded(force: Bool = false) {
let hasChatDb = FileManager.default.fileExists(atPath: chatDbPath)
if !force && hasChatDb {
return
}
resetGenerationState()
do {
try? FileManager.default.createDirectory(
at: attachmentsDir,
withIntermediateDirectories: true,
attributes: nil
)
chatDb = try EnsuDb.open(
mainDbPath: chatDbPath,
key: chatDbKey
)
} catch {
logger.error("Failed to reopen chat store: \(error)")
}
}
var currentSession: ChatSession? {
guard let currentSessionId else { return nil }
return sessions.first { $0.id == currentSessionId }
}
private func currentSourceSelection() -> ChatSourceSelection? {
guard knowledgeStore.inventoryReady && notesStore.inventoryReady else { return nil }
return ChatSourceSelection(
selectedPackIDs: Set(
knowledgeStore.packs.filter {
$0.activeIdentity != nil && !knowledgeStore.disabledIDs.contains($0.id)
}.map(\.id)),
selectedCollectionIDs: Set(
notesStore.collections
.filter { !notesStore.disabledIDs.contains($0.id) }
.map(\.id)))
}
var modelDownloadSizeText: String {
guard let bytes = modelDownloadSizeBytes else { return "Approx. size varies by model" }
return "Approx. \(bytes.formattedFileSize)"
}
private func resetGenerationState(stopRequested: Bool = false) {
cancelPendingSend()
conversationStatus = nil
generationTask?.cancel()
provider.stopGeneration(invalidatePreparation: true)
self.stopRequested = stopRequested
activeGenerationId = nil
activeGenerationSessionId = nil
isGenerating = false
isDownloading = false
streamingResponse = ""
streamingParentId = nil
downloadToast = nil
}
func sessionTitle(for sessionId: UUID) -> String {
guard let title = sessions.first(where: { $0.id == sessionId })?.title else {
return "Chat"
}
return Self.sessionTitle(from: title, fallback: "Chat")
}
func startNewSession() {
guard !isDownloading else { return }
resetGenerationState()
cancelVoiceInput()
discardUnstoredAttachments(draftAttachments)
draftText = ""
draftAttachments = []
editingMessageId = nil
currentSessionId = nil
messages = []
}
func selectSession(_ session: ChatSession) {
resetGenerationState()
cancelVoiceInput()
currentSessionId = session.id
messages = []
loadMessagesFromDb(for: session.id)
}
func deleteSession(_ session: ChatSession) {
if currentSessionId == session.id {
resetGenerationState()
}
if let nodes = messageStore[session.id] {
for node in nodes {
logger.info(
"Message deleted",
details:
"id=\(node.id.uuidString) session=\(session.id.uuidString) role=\(node.role.rawValue)"
)
}
}
logger.info("Session deleted", details: "id=\(session.id.uuidString)")
guard let attachmentIds = try? chatDb.deleteSession(uuid: session.id.uuidString) else {
return
}
if currentSessionId == session.id {
cancelVoiceInput()
discardUnstoredAttachments(draftAttachments)
}
for id in attachmentIds {
try? FileManager.default.removeItem(at: attachmentsDir.appendingPathComponent(id))
}
sessionSummaries.removeValue(forKey: sessionSummaryKey(session.id))
persistSessionSummaries()
sessions.removeAll { $0.id == session.id }
messageStore[session.id] = nil
branchSelections[session.id] = nil
childrenByParentCache[session.id] = nil
if currentSessionId == session.id {
currentSessionId = sessions.first?.id
if let next = currentSessionId {
messages = []
loadMessagesFromDb(for: next)
} else {
messages = []
}
}
}
func beginEditing(message: RenderedChatMessage) {
guard !isChatUnsupported else {
showUnsupportedDeviceDialog = true
return
}
guard message.role == .user else { return }
cancelVoiceInput()
resetGenerationState()
editingMessageId = message.id
draftText = message.text
draftAttachments = message.attachments
}
func cancelEditing() {
cancelPendingSend()
discardUnstoredAttachments(draftAttachments)
editingMessageId = nil
draftText = ""
draftAttachments = []
}
func toggleVoiceInput() {
guard !isGenerating, !isDownloading, !isSendPending, editingMessageId == nil,
!composerIsComposing, !voiceTranscriber.active, !voiceTranscriber.hasActiveTasks
else { return }
sessionSummaryTask?.cancel()
cancelChatWarmup(releaseLoadedModel: false)
let destination = (currentSessionId ?? emptyComposerId).uuidString
voiceTranscriber.onInsert = { [weak self] insertion, text in
guard let self, self.appForeground else { return false }
do {
let result = try insertion.apply(
destination: (self.currentSessionId ?? self.emptyComposerId).uuidString,
revision: self.composerRevision, text: self.draftText, voiceText: text,
foreground: self.appForeground, keyboardComposing: self.composerIsComposing)
self.draftText = result.text
self.composerRevision = result.revision
self.voiceInsertionCaret = Int(result.caretUtf16)
self.draftCursorMoveToken = UUID()
return true
} catch { return false }
}
voiceTranscriber.open { [weak self] in
guard let self, self.appForeground, self.chatActive,
!self.isGenerating, !self.isDownloading, !self.isSendPending,
self.editingMessageId == nil, !self.composerIsComposing,
(self.currentSessionId ?? self.emptyComposerId).uuidString == destination
else { return nil }
let range = self.composerSelection
let text = self.draftText as NSString
guard range.location >= 0, range.length >= 0, range.location <= text.length,
range.length <= text.length - range.location,
[range.location, NSMaxRange(range)].allSatisfy({
$0 == text.length
|| text.rangeOfComposedCharacterSequence(at: $0).location == $0
})
else { return nil }
return DictationInsertion(
destination: destination, revision: self.composerRevision,
startUtf16: UInt32(range.location), endUtf16: UInt32(NSMaxRange(range)))
}
}
func cancelVoiceInput() {
voiceTranscriber.releaseComposer()
emptyComposerId = UUID()
voiceInsertionCaret = nil
}
func addImageAttachment(data: Data, fileName: String?) {
guard supportsImageAttachments, !isGenerating,
!isDownloading,
draftImageAttachmentCount < ChatAttachmentLimits.maxImagesPerMessage
else { return }
isProcessingAttachments = true
Task.detached { [weak self] in
guard let self else { return }
do {
let id = UUID()
let compressed = try compressAttachmentImage(data: data)
let url = try self.writeAttachment(data: compressed, attachmentId: id)
let attachment = ChatAttachment(
id: id,
name: self.normalizedJpegAttachmentName(fileName),
size: Int64(compressed.count),
kind: .image,
url: url,
isUploading: false
)
await MainActor.run {
if !self.supportsImageAttachments
|| self.draftImageAttachmentCount
>= ChatAttachmentLimits.maxImagesPerMessage
{
try? FileManager.default.removeItem(at: url)
self.isProcessingAttachments = false
return
}
self.draftAttachments.append(attachment)
self.isProcessingAttachments = false
}
} catch {
await MainActor.run { self.isProcessingAttachments = false }
}
}
}
private nonisolated func normalizedJpegAttachmentName(_ fileName: String?) -> String {
let raw =
fileName?
.replacingOccurrences(of: "\0", with: "")
.replacingOccurrences(of: "\\", with: "/")
.split(separator: "/")
.last
.map(String.init)?
.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
let base = (raw as NSString).deletingPathExtension
return "\(base.isEmpty ? "photo" : base).jpg"
}
func addDocumentAttachment(url: URL) {
guard !isGenerating && !isDownloading else { return }
isProcessingAttachments = true
Task.detached { [weak self] in
guard let self else { return }
do {
let id = UUID()
let storedUrl = try self.copyAttachment(from: url, attachmentId: id)
let size =
(try? FileManager.default.attributesOfItem(atPath: storedUrl.path)[.size]
as? NSNumber)?.int64Value ?? 0
let attachment = ChatAttachment(
id: id,
name: url.lastPathComponent,
size: size,
kind: .document,
url: storedUrl,
isUploading: false
)
await MainActor.run {
self.draftAttachments.append(attachment)
self.isProcessingAttachments = false
}
} catch {
await MainActor.run { self.isProcessingAttachments = false }
}
}
}
func removeAttachment(_ attachment: ChatAttachment) {
draftAttachments.removeAll { $0.id == attachment.id }
discardUnstoredAttachments([attachment])
}
private func discardUnstoredAttachments(_ attachments: [ChatAttachment]) {
let storedIds = Set(
messageStore.values.flatMap { messages in
messages.flatMap { $0.attachments.map(\.id) }
})
for attachment in attachments where !storedIds.contains(attachment.id) {
if let url = attachment.url {
try? FileManager.default.removeItem(at: url)
}
}
}
private static func pruneOrphanedAttachments(
sessions: [DbSession],
chatDb: EnsuDb,
attachmentsDir: URL
) {
let referenced: Set<String>
do {
referenced = Set(
try sessions.flatMap { session in
try chatDb.getMessages(sessionUuid: session.uuid)
.flatMap { $0.attachments.map(\.id) }
})
} catch {
return
}
guard
let files = try? FileManager.default.contentsOfDirectory(
at: attachmentsDir,
includingPropertiesForKeys: nil
)
else { return }
for file in files where !referenced.contains(file.lastPathComponent) {
try? FileManager.default.removeItem(at: file)
}
}
private func cancelPendingSend() {
guard isSendPending else { return }
pendingSendTask?.cancel()
clearPendingSend()
}
private func clearPendingSend() {
pendingSendTask = nil
pendingSendId = nil
isSendPending = false
isDownloading = false
if downloadToast?.phase == .loading || downloadToast?.phase == .downloading {
downloadToast = nil
clearDownloadProgressMemory()
}
}
func sendDraft() {
guard !voiceTranscriber.blocksComposer else { return }
guard !isGenerating && !isDownloading && !isSendPending else { return }
guard !isChatUnsupported else {
showUnsupportedDeviceDialog = true
return
}
let text = draftText
let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
let attachments = draftAttachments
guard !trimmed.isEmpty || !attachments.isEmpty else { return }
let sessionId = currentSessionId
let editingId = editingMessageId
let selection = modelSettings.currentSelection()
if attachments.contains(where: { $0.kind == .image }), !provider.supportsImages(selection) {
generationErrorMessage = ModelImagesUnsupported().localizedDescription
return
}
voiceTranscriber.releaseComposer()
let sourceSnapshot = currentSourceSelection()
let sendId = UUID()
pendingSendId = sendId
isSendPending = true
pendingSendTask = Task { @MainActor in
defer {
if self.pendingSendId == sendId {
self.clearPendingSend()
}
}
guard !Task.isCancelled, self.pendingSendId == sendId else { return }
self.hasRequestedModelDownload = true
await knowledgeStore.bootstrap()
await notesStore.bootstrap()
guard !Task.isCancelled, self.pendingSendId == sendId,
currentSessionId == sessionId
else { return }
guard let sources = sourceSnapshot ?? currentSourceSelection() else {
generationErrorMessage = "Couldnβt load sources. Try sending again."
return
}
do {
try await self.ensureChatModelReady(
selection, pendingSendId: sendId, loadContext: false)
} catch {
guard !Task.isCancelled, self.pendingSendId == sendId,
!self.isCancellation(error)
else { return }
self.isDownloading = false
self.downloadToast = DownloadToastState(
phase: .errorDownload,
percent: nil,
status: self.userFacingModelReadyError(error, wasDownloaded: false),
offerRetryDownload: true
)
self.refreshModelDownloadInfo()
self.logger.error("Model readiness check failed before send", error)
return
}
guard !Task.isCancelled, self.pendingSendId == sendId,
self.currentSessionId == sessionId, self.editingMessageId == editingId,
self.draftText == text, self.draftAttachments == attachments,
self.modelSettings.currentSelection() == selection
else { return }
let destination = sessionId ?? self.createSessionForDraft()
self.sendDraftMessage(
trimmed: trimmed, attachments: attachments, sessionId: destination,
sources: sources)
}
}
private func sendDraftMessage(
trimmed: String, attachments: [ChatAttachment], sessionId: UUID,
sources: ChatSourceSelection
) {
let parentId: UUID? = {
if let editingId = editingMessageId {
let existing = messageStore[sessionId]?.first { $0.id == editingId }
return existing?.parentId
}
let childrenMap = childrenByParent(sessionId: sessionId)
return buildSelectedPath(for: sessionId, childrenMap: childrenMap).last?.id
}()
let meta: [DbAttachmentMeta] = attachments.map { attachment in
DbAttachmentMeta(
id: attachment.id.uuidString.lowercased(),
kind: attachment.kind == .image ? .image : .document,
size: attachment.size,
name: attachment.name
)
}
guard
let inserted = try? chatDb.insertMessage(
sessionUuid: sessionId.uuidString,
sender: .selfUser,
text: trimmed,
parentMessageUuid: parentId?.uuidString,
attachments: meta
), let messageId = UUID(uuidString: inserted.uuid)
else {
return
}
logger.info(
"Sent message",
details:
"id=\(messageId.uuidString) session=\(sessionId.uuidString) len=\(trimmed.count) attachments=\(attachments.count) edited=\(editingMessageId != nil)"
)
let timestamp = Date(timeIntervalSince1970: Double(inserted.createdAtUs) / 1_000_000.0)
let userNode = MessageNode(
id: messageId,
sessionId: sessionId,
parentId: parentId,
role: .user,
text: trimmed,
timestamp: timestamp,
attachments: attachments,
isInterrupted: false,
tokensPerSecond: nil
)
messageStore[sessionId, default: []].append(userNode)
invalidateChildrenCache(for: sessionId)
updateSelection(for: sessionId, parentId: parentId, childId: userNode.id)
draftText = ""
draftAttachments = []
editingMessageId = nil
updateSessionPreview(sessionId: sessionId, preview: trimmed, date: timestamp)
rebuildMessages(for: sessionId)
startGeneration(for: userNode, sources: sources)
}
func stopGenerating() {
stopRequested = true
provider.stopGeneration()
generationTask?.cancel()
}
func modelSelectionChanged() {
resetGenerationState()
if let currentSessionId { rebuildMessages(for: currentSessionId) }
refreshModelDownloadInfo()
}
func confirmOverflowTrim() {
guard let pendingOverflow else { return }
guard
let node = messageStore[pendingOverflow.sessionId]?.first(where: {
$0.id == pendingOverflow.messageId
})
else {
cancelOverflowDialog()
return
}
overflowBypassMessageId = pendingOverflow.messageId
self.pendingOverflow = nil
overflowAlert = nil
startGeneration(for: node, sources: pendingOverflow.sources)
}
func cancelOverflowDialog() {
pendingOverflow = nil
overflowBypassMessageId = nil
overflowAlert = nil
}
func refreshModelDownloadInfo() {
defer { refreshChatWarmup() }
notesStore.modelReadinessChanged()
guard !isChatUnsupported else {
isDownloading = false
downloadToast = nil
modelDownloadSizeBytes = nil
hasRequestedModelDownload = false
isModelDownloaded = false
return
}
let selection = modelSettings.currentSelection()
isModelDownloaded = provider.isModelDownloaded(selection)
if isModelDownloaded {
clearDownloadProgressMemory()
modelDownloadSizeBytes = nil
return
}
Task { [weak self] in
guard let self else { return }
let size = await provider.missingModelDownloadSize(selection)
await MainActor.run {
guard
self.modelReadyKey(for: self.modelSettings.currentSelection())
== self.modelReadyKey(for: selection)
else {
return
}
if self.sharedModelReadyTask == nil
&& (self.downloadToast?.phase == .downloading
|| self.downloadToast?.phase == .loading)
{
self.downloadToast = nil
self.isDownloading = false
self.clearDownloadProgressMemory()
}
self.modelDownloadSizeBytes = size ?? self.modelDownloadSizeBytes
}
}
}
private func clearSharedModelReadyTask() {
sharedModelReadyTask = nil
sharedModelReadyTaskId = nil
sharedModelReadyKey = nil
}
private func modelReadyKey(for selection: LlmModelSelection) -> ModelReadyKey {
ModelReadyKey(id: selection.id, requestedContextLength: selection.contextLength)
}
private func ensureChatModelReady(
_ selection: LlmModelSelection, pendingSendId: UUID? = nil,
loadContext: Bool = true
) async throws {
if isChatUnsupported {
throw UnsupportedDeviceMemoryError(capability: deviceCapability)
}
var retryCount = 0
while true {
do {
try Task.checkCancellation()
let onProgress: @Sendable (DownloadProgress) -> Void = { progress in
Task { @MainActor in
if let pendingSendId, self.pendingSendId != pendingSendId { return }
self.handleProgress(progress)
}
}
if loadContext {
try await provider.ensureModelReady(selection, onProgress: onProgress)
} else {
try await provider.ensureChatModelAssetsReady(selection, onProgress: onProgress)
}
try Task.checkCancellation()
return
} catch {
if isCancellation(error) || !shouldRetryModelDownload(error, retryCount: retryCount)
{
throw error
}
retryCount += 1
try await Task.sleep(nanoseconds: retryDelayNanoseconds(for: retryCount))
}
}
}
private func ensureRequiredModelsReadyShared(
_ selection: LlmModelSelection, recoverDownloadedModel: Bool
) async throws {
if isChatUnsupported {
throw UnsupportedDeviceMemoryError(capability: deviceCapability)
}
let modelKey = modelReadyKey(for: selection)
if let existingTask = sharedModelReadyTask, sharedModelReadyKey == modelKey {
try await existingTask.value
return
}
if let existingTask = sharedModelReadyTask, sharedModelReadyKey != modelKey {
existingTask.cancel()
clearSharedModelReadyTask()
}
let taskId = UUID()
let task = Task {
if recoverDownloadedModel {
try await self.ensureChatModelReady(selection)
return
}
var retryCount = 0
while true {
do {
try await provider.ensureRequiredModelsReady(selection) { progress in
Task { @MainActor in
self.handleProgress(progress)
}
}
return
} catch {
if self.isCancellation(error) {
throw error
}
if !self.shouldRetryModelDownload(error, retryCount: retryCount) {
throw error
}
retryCount += 1
try await Task.sleep(nanoseconds: self.retryDelayNanoseconds(for: retryCount))
}
}
}
sharedModelReadyTask = task
sharedModelReadyTaskId = taskId
sharedModelReadyKey = modelKey
do {
try await task.value
} catch {
if sharedModelReadyTaskId == taskId {
clearSharedModelReadyTask()
}
throw error
}
if sharedModelReadyTaskId == taskId {
clearSharedModelReadyTask()
}
}
func startModelDownload(userInitiated: Bool = true) {
guard !isDownloading && !isGenerating else { return }
guard !isChatUnsupported else {
showUnsupportedDeviceDialog = true
return
}
if userInitiated {
hasRequestedModelDownload = true
}
let selection = modelSettings.currentSelection()
let wasDownloaded = provider.isModelDownloaded(selection)
if wasDownloaded && isModelDownloaded {
modelDownloadSizeBytes = nil
return
}
cancelChatWarmup()
isDownloading = true
seedDownloadProgressMemory()
modelDownloadLoggedStart = !wasDownloaded
if modelDownloadLoggedStart {
logger.info("Model download started", details: "model=\(selection.id)")
}
modelDownloadTask?.cancel()
modelDownloadTask = Task {
do {
try await self.ensureRequiredModelsReadyShared(
selection, recoverDownloadedModel: wasDownloaded)
self.handleProgress(DownloadProgress(percent: 100, status: "Ready", phase: .ready))
self.refreshChatWarmup()
} catch {
if isCancellation(error) {
return
}
if self.modelDownloadLoggedStart {
self.logger.error("Model download failed", error)
self.modelDownloadLoggedStart = false
} else {
self.logger.error("Model load failed", error)
}
await MainActor.run {
self.downloadToast = DownloadToastState(
phase: wasDownloaded ? .errorLoad : .errorDownload,
percent: nil,
status: self.userFacingModelReadyError(error, wasDownloaded: wasDownloaded),
offerRetryDownload: true
)
self.isDownloading = false
self.isModelDownloaded = false
}
}
}
}
func cancelDownload() {
resetGenerationState(stopRequested: true)
modelDownloadTask?.cancel()
modelDownloadTask = nil
sharedModelReadyTask?.cancel()
clearSharedModelReadyTask()
if modelDownloadLoggedStart {
logger.info("Model download cancelled")
modelDownloadLoggedStart = false
}
hasRequestedModelDownload = false
clearDownloadProgressMemory()
refreshModelDownloadInfo()
}
func retryDownload() {
startModelDownload(userInitiated: true)
}
func retryAssistantResponse(_ message: RenderedChatMessage) {
let priorGeneration = generationTask
let priorSummary = sessionSummaryTask
guard message.role == .assistant else { return }
if isGenerating {
stopGenerating()
}
guard !isChatUnsupported else {
showUnsupportedDeviceDialog = true
return
}
guard let sessionId = currentSessionId else { return }
let userNode: MessageNode?
if message.isSynthetic {
guard let syntheticIndex = messages.firstIndex(where: { $0.id == message.id }),
syntheticIndex > 0
else { return }
let parentMessage = messages[syntheticIndex - 1]
guard parentMessage.role == .user else { return }
userNode = messageStore[sessionId]?.first(where: { $0.id == parentMessage.id })
} else {
guard
let parentId = messageStore[sessionId]?.first(where: { $0.id == message.id })?
.parentId
else { return }
userNode = messageStore[sessionId]?.first(where: { $0.id == parentId })
}
guard let userNode else { return }
voiceTranscriber.interrupt()
let sourceSnapshot = currentSourceSelection()
cancelPendingSend()
priorGeneration?.cancel()
priorSummary?.cancel()
provider.stopGeneration()
Task { [weak self] in
_ = await priorGeneration?.result
_ = await priorSummary?.result
guard let self else { return }
if !userNode.attachments.contains(where: { $0.kind == .image })
|| provider.supportsImages(modelSettings.currentSelection())
{
await provider.resetContext()
}
startGeneration(for: userNode, sources: sourceSnapshot)
}
}
func changeBranch(for message: RenderedChatMessage, delta: Int) {
cancelPendingSend()
if isGenerating {
stopGenerating()
}
guard let sessionId = currentSessionId else { return }
guard let node = messageStore[sessionId]?.first(where: { $0.id == message.id }) else {
return
}
let parentKey = node.parentId?.uuidString ?? "__root__"
let parentId = node.parentId ?? rootId
let siblings = dedupeSiblings(childrenFor(sessionId: sessionId, parentId: parentId))
guard !siblings.isEmpty else { return }
let selectionMap = branchSelections[sessionId] ?? [:]
let currentId = selectionMap[parentKey] ?? siblings.last?.id
let currentIndex = siblings.firstIndex { $0.id == currentId } ?? (siblings.count - 1)
let nextIndex = max(0, min(siblings.count - 1, currentIndex + delta))
branchSelections[sessionId, default: [:]][parentKey] = siblings[nextIndex].id
rebuildMessages(for: sessionId)
}
private func createSessionForDraft() -> UUID {
let created = (try? chatDb.createSession(title: "New chat"))
let sessionId = created.flatMap { UUID(uuidString: $0.uuid) } ?? UUID()
let updatedAt =
created.map { Date(timeIntervalSince1970: Double($0.updatedAtUs) / 1_000_000.0) }
?? Date()
logger.info("Session created", details: "id=\(sessionId.uuidString)")
let session = ChatSession(
id: sessionId, title: created?.title ?? "New chat", lastMessage: "",
updatedAt: updatedAt)
sessions.insert(session, at: 0)
currentSessionId = session.id
messageStore[session.id] = []
branchSelections[session.id] = [:]
invalidateChildrenCache(for: session.id)
return session.id
}
private func startGeneration(
for userNode: MessageNode, sources sourceSnapshot: ChatSourceSelection?
) {
guard !isChatUnsupported else {
showUnsupportedDeviceDialog = true
return
}
cancelChatWarmup(releaseLoadedModel: false)
let selection = modelSettings.currentSelection()
let priorGeneration = generationTask
let priorSummary = sessionSummaryTask
priorGeneration?.cancel()
priorSummary?.cancel()
provider.stopGeneration(invalidatePreparation: true)
conversationStatus = nil
stopRequested = false
if userNode.attachments.contains(where: { $0.kind == .image }),
!provider.supportsImages(selection)
{
resetGenerationState()
generationErrorMessage = ModelImagesUnsupported().localizedDescription
rebuildMessages(for: userNode.sessionId)
return
}
let prompt = buildPrompt(text: userNode.text, attachments: userNode.attachments)
let generationId = UUID()
activeGenerationId = generationId
activeGenerationSessionId = userNode.sessionId
isGenerating = true
isDownloading = false
hasRequestedModelDownload = true
streamingResponse = ""
streamingParentId = userNode.id
downloadToast = nil
seedDownloadProgressMemory()
rebuildMessages(for: userNode.sessionId)
let notesScope = notesStore.suspendMaintenance()
generationTask = Task { [self] in
defer {
notesScope.close()
settleGenerationIfActive(generationId: generationId, sessionId: userNode.sessionId)
refreshChatWarmup()
}
await notesStore.awaitMaintenance()
_ = await priorGeneration?.result
_ = await priorSummary?.result
guard !Task.isCancelled, activeGenerationId == generationId else { return }
await knowledgeStore.bootstrap()
await notesStore.bootstrap()
guard !Task.isCancelled, activeGenerationId == generationId else { return }
guard let sources = sourceSnapshot ?? currentSourceSelection() else {
generationErrorMessage = "Couldnβt load sources. Try again."
return
}
var embeddingAssetInvalid = false
var knowledgeHits: [GroundedExcerpt] = []
let enabledDatasets = knowledgeStore.readyDatasets.filter {
sources.includesPack($0.stableId)
}
let enabledCollectionIDs = Set(
notesStore.collections.filter {
$0.eligible && sources.includesCollection($0.id)
}.map(\.id))
var followup: ConversationFollowup?
var reloaded: [GroundedExcerpt] = []
defer { followup?.cancel() }
do {
if prompt.imageFiles.isEmpty {
let path = buildConversationPath(for: userNode)
let pathIds = Set(path)
let assistantTexts = (messageStore[userNode.sessionId] ?? [])
.filter { pathIds.contains($0.id.uuidString) && $0.role == .assistant }
.map { $0.text }
followup = try await Task.detached {
[chatDb] () throws -> ConversationFollowup? in
guard
assistantTexts.contains(where: {
!parseGroundedAssistantText(storedText: $0).sources.isEmpty
})
else { return nil }
return try chatDb.startConversationFollowup(
sessionUuid: userNode.sessionId.uuidString, path: path,
question: userNode.text
)
}.value
try Task.checkCancellation()
guard activeGenerationId == generationId else { return }
if followup != nil { conversationStatus = "Finding sources" }
}
} catch {
guard !isCancellation(error), activeGenerationId == generationId else { return }
if case ConversationError.Stale = error {
generationErrorMessage = "Conversation changed. Retry the message."
return
}
logger.warning("Source search preparation failed", details: "\(error)")
}
let queryText = userNode.text.trimmingCharacters(in: .whitespacesAndNewlines)
if !queryText.isEmpty,
(!enabledDatasets.isEmpty
|| !enabledCollectionIDs.isEmpty)
{
do {
let hits = try await provider.withRetrievalContext(
queryBytes: queryText.utf8.count
) { embed in
try Task.checkCancellation()
let query = try embed(queryText)
try Task.checkCancellation()
let packs = await knowledgeProvider.search(
datasets: enabledDatasets, query: query,
maxHits: knowledgeEmbedding.maxHits
)
let notes = try await notesStore.retrieve(
query: query, collectionIDs: enabledCollectionIDs)
let candidates = try selectMixedGroundingCandidates(
packHits: packs.map {
KnowledgePromptHit(datasetId: $0.dataset.stableId, hit: $0.hit)
},
notesHits: notes, notesLimit: UInt32(notes.count)
)
return try await notesStore.verify(candidates)
}
try Task.checkCancellation()
knowledgeHits = hits
} catch {
if isCancellation(error) {
return
}
if error is ModelMemoryUnavailable {
guard !Task.isCancelled, activeGenerationId == generationId else { return }
generationErrorMessage = error.localizedDescription
return
}
embeddingAssetInvalid = error is EmbeddingAssetInvalidError
}
}
do {
if let turn = followup {
let locators = try await Task.detached { [searched = knowledgeHits] in
try turn.searchWithHistory(searched: searched)
}.value
try Task.checkCancellation()
guard activeGenerationId == generationId else { return }
for locator in locators {
if let hit = try await reloadPassage(
locator, datasets: enabledDatasets,
collectionIDs: enabledCollectionIDs)
{
reloaded.append(hit)
}
}
}
} catch {
guard !isCancellation(error), activeGenerationId == generationId else { return }
if case ConversationError.Stale = error {
generationErrorMessage = "Conversation changed. Retry the message."
return
}
logger.warning("Source history search failed", details: "\(error)")
followup?.cancel()
followup = nil
}
do {
try await self.ensureChatModelReady(selection, loadContext: false)
} catch {
if isCancellation(error) {
self.sharedModelReadyTask?.cancel()
self.clearSharedModelReadyTask()
if self.activeGenerationId == generationId {
isGenerating = false
isDownloading = false
streamingParentId = nil
downloadToast = nil
activeGenerationId = nil
activeGenerationSessionId = nil
}
return
}
if self.activeGenerationId == generationId {
isGenerating = false
isDownloading = false
streamingParentId = nil
downloadToast = DownloadToastState(
phase: .errorDownload,
percent: nil,
status: self.userFacingModelReadyError(
error, wasDownloaded: self.provider.isChatModelReady(selection)),
offerRetryDownload: true
)
activeGenerationId = nil
activeGenerationSessionId = nil
}
refreshModelDownloadInfo()
return
}
let normalSystemPrompt = systemPrompt()
var activeCitations: [GroundedSource] = []
var conversationPrepared = false
let buffer = OSAllocatedUnfairLock(initialState: StreamingBuffer())
let uiUpdateInterval: TimeInterval = 0.05
let onToken: @Sendable (String) -> Void = { token in
let snapshot = buffer.withLock { state -> String? in
state.text.append(token)
state.tokenCount += max(1, token.count / 4)
let now = Date()
if now.timeIntervalSince(state.lastUiUpdate) >= uiUpdateInterval {
state.lastUiUpdate = now
state.updateTask?.cancel()
state.updateTask = nil
return state.text
}
if state.updateTask == nil {
state.updateTask = Task { @MainActor [weak self] in
do {
try await Task.sleep(for: .seconds(uiUpdateInterval))
} catch {
return
}
let snapshot = buffer.withLock { state -> String? in
guard !Task.isCancelled else { return nil }
state.updateTask = nil
state.lastUiUpdate = Date()
return state.text
}
guard let self, let snapshot,
self.activeGenerationId == generationId
else { return }
self.streamingResponse = snapshot
}
}
return nil
}
if let snapshot {
Task { @MainActor in
guard self.activeGenerationId == generationId else { return }
self.streamingResponse = snapshot
}
}
}
let finish:
@MainActor (
Result<GenerationSummary, Error>, ConversationPreparation?, [GroundedSource]
) -> Void = {
[self]
result, preparation, citations in
let snapshot = buffer.withLock { $0 }
let interrupted: Bool
let totalTimeMs: Int64?
switch result {
case let .success(summary):
interrupted = false
totalTimeMs = summary.totalTimeMs
case let .failure(error):
interrupted = true
totalTimeMs = nil
let wasCancelled = stopRequested || isCancellation(error)
if activeGenerationId == generationId && !wasCancelled {
let details =
"session=\(userNode.sessionId.uuidString) promptLen=\(prompt.text.count) responseLen=\(snapshot.text.count) tokens=\(snapshot.tokenCount)"
logger.error("Generation failed", error, details: details)
if case ConversationError.CurrentInputTooLarge = error {
generationErrorMessage =
"This message is too long for the model, even without earlier messages. Shorten it or split it into smaller messages. Your full text is still available to edit or copy."
} else if case let ConversationError.Other(detail) = error {
generationErrorMessage = detail
} else if case ConversationError.Stale = error {
generationErrorMessage = "Conversation changed. Retry the message."
} else if error is ModelMemoryUnavailable
|| error is ModelImagesUnsupported
{
generationErrorMessage = error.localizedDescription
} else {
generationErrorMessage = "Response failed. Try again."
}
}
}
finishGeneration(
parent: userNode, response: snapshot.text, tokenCount: snapshot.tokenCount,
totalTimeMs: totalTimeMs, interrupted: interrupted,
generationId: generationId, citations: citations,
preparation: preparation)
}
do {
if prompt.imageFiles.isEmpty {
try await self.generatePreparedChat(
selection,
request: ConversationRequest(
sessionUuid: userNode.sessionId.uuidString,
path: self.buildConversationPath(for: userNode),
system: normalSystemPrompt,
current: prompt.text,
expectedUserText: userNode.text,
historyQuery: userNode.text,
maxTokens: nil,
searched: knowledgeHits,
followup: followup,
reloaded: reloaded
),
temperature: self.resolveTemperature(),
onProgress: {
guard self.activeGenerationId == generationId,
!conversationPrepared
else { return }
self.conversationStatus = "Remembering earlier messages"
},
onPrepared: { prepared in
guard self.activeGenerationId == generationId else {
prepared.cancel()
return
}
conversationPrepared = true
self.conversationStatus = nil
},
onFinished: { result, preparation in finish(result, preparation, []) },
onToken: onToken
)
} else {
let result = try await generateImageChat(
selection, parent: userNode, prompt: prompt,
knowledgeHits: knowledgeHits, systemPrompt: normalSystemPrompt,
onCitations: { activeCitations = $0 },
hasOutput: { buffer.withLock { !$0.text.isEmpty } }, onToken: onToken
)
switch result {
case let .generated(summary):
finish(.success(summary), nil, activeCitations)
case let .overflow(inputTokens, inputBudget, limits):
overflowBypassMessageId = nil
pendingOverflow = PendingOverflow(
sessionId: userNode.sessionId, messageId: userNode.id,
sources: sources)
activeGenerationId = nil
activeGenerationSessionId = nil
isGenerating = false
isDownloading = false
streamingResponse = ""
streamingParentId = nil
overflowAlert = OverflowAlertState(
inputTokens: inputTokens, inputBudget: inputBudget,
contextLength: limits.contextLength, maxOutput: limits.maxOutput)
rebuildMessages(for: userNode.sessionId)
if embeddingAssetInvalid { refreshModelDownloadInfo() }
return
}
}
} catch {
if activeGenerationId == generationId { refreshModelDownloadInfo() }
finish(.failure(error), nil, activeCitations)
}
if embeddingAssetInvalid {
refreshModelDownloadInfo()
}
}
}
private enum ImageChatResult {
case generated(GenerationSummary)
case overflow(inputTokens: Int, inputBudget: Int, GenerationLimits)
}
private func generateImageChat(
_ selection: LlmModelSelection,
parent: MessageNode,
prompt: PromptResult,
knowledgeHits: [GroundedExcerpt],
systemPrompt: String,
onCitations: @escaping @MainActor ([GroundedSource]) -> Void,
hasOutput: @escaping @Sendable () -> Bool,
onToken: @escaping @Sendable (String) -> Void
) async throws -> ImageChatResult {
guard provider.supportsImages(selection) else { throw ModelImagesUnsupported() }
return try await provider.withConversationContext(
selection,
onProgress: { progress in
Task { @MainActor in self.handleProgress(progress) }
}
) { context, control in
let contextLength = Int(context.contextSize())
let limits = GenerationLimits(
contextLength: contextLength,
maxOutput: resolveMaxOutputTokens(contextLength: contextLength))
let normalHistory = buildHistorySelection(
sessionId: parent.sessionId, promptText: prompt.text,
promptImageCount: prompt.imageFiles.count, currentMessageId: parent.id,
limits: limits, systemPrompt: systemPrompt)
if normalHistory.wasTrimmed && overflowBypassMessageId != parent.id {
return .overflow(
inputTokens: normalHistory.inputTokens,
inputBudget: normalHistory.inputBudget, limits)
}
overflowBypassMessageId = nil
pendingOverflow = nil
overflowAlert = nil
let remainingKnowledgeBytes = max(
0, (normalHistory.inputBudget - normalHistory.inputTokens) * 4 - 2)
let knowledgeContext = try? buildGroundedPromptContext(
excerpts: knowledgeHits,
maxUtf8Bytes: UInt32(
min(Int(knowledgeEmbedding.maxContextUtf8Bytes), remainingKnowledgeBytes)))
let candidateSystem = knowledgeContext.map { "\(systemPrompt)\n\n\($0.text)" }
let knowledgeHistory = candidateSystem.map {
buildHistorySelection(
sessionId: parent.sessionId, promptText: prompt.text,
promptImageCount: prompt.imageFiles.count, currentMessageId: parent.id,
limits: limits, systemPrompt: $0)
}
let useKnowledge = knowledgeHistory?.wasTrimmed == false
let history = useKnowledge ? (knowledgeHistory ?? normalHistory) : normalHistory
let citations = useKnowledge ? (knowledgeContext?.sources ?? []) : []
onCitations(citations)
let user = LlmMessage(
text: prompt.text, role: .user, hasAttachments: !parent.attachments.isEmpty)
let effectiveSystem = useKnowledge ? (candidateSystem ?? systemPrompt) : systemPrompt
let messages =
[LlmMessage(text: effectiveSystem, role: .system, hasAttachments: false)]
+ history.messages + [user]
let generate: @MainActor ([LlmMessage]) async throws -> GenerationSummary = {
messages in
try control.checkCancellation()
return try await self.provider.generatePreparedChat(
selection,
messages: messages.map {
LlmChatMessage(role: $0.role.roleString, content: $0.text)
},
imageFiles: prompt.imageFiles, temperature: self.resolveTemperature(),
maxTokens: UInt32(limits.maxOutput), control: control, onToken: onToken)
}
do {
return .generated(try await generate(messages))
} catch {
guard case LlmError.PromptTooLong = error, !hasOutput(), !citations.isEmpty else {
throw error
}
let fallback =
[LlmMessage(text: systemPrompt, role: .system, hasAttachments: false)]
+ normalHistory.messages + [user]
onCitations([])
return .generated(try await generate(fallback))
}
}
}
private func generatePreparedChat(
_ selection: LlmModelSelection,
request: ConversationRequest,
temperature: Float,
onProgress: @escaping @MainActor () -> Void,
onPrepared: @escaping @MainActor (ConversationPreparation) -> Void,
onFinished:
@escaping @MainActor (Result<GenerationSummary, Error>, ConversationPreparation) ->
Void,
onToken: @escaping @Sendable (String) -> Void
) async throws {
let db = chatDb
try await provider.withConversationContext(
selection,
onProgress: { progress in
Task { @MainActor in self.handleProgress(progress) }
}
) { context, control in
let preparation = try await Task.detached {
try control.checkCancellation()
return try db.prepareConversation(context: context, input: request)
}.value
control.setPreparationCancellation { preparation.cancel() }
try control.checkCancellation()
let sink = ConversationProgressSink {
Task { @MainActor in onProgress() }
}
let result = try await Task.detached {
try control.checkCancellation()
return try preparation.run(callback: sink)
}.value
try control.beginAnswer()
onPrepared(preparation)
do {
try await Task.detached { try preparation.validate() }.value
try control.checkCancellation()
let summary = try await self.provider.generatePreparedChat(
selection,
messages: result.messages,
temperature: temperature,
maxTokens: result.maxTokens,
control: control,
onToken: onToken
)
onFinished(.success(summary), preparation)
} catch {
onFinished(.failure(error), preparation)
}
}
}
private func reloadPassage(
_ locator: PassageLocator, datasets: [KnowledgeDatasetConfig],
collectionIDs: Set<String>
) async throws -> GroundedExcerpt? {
do {
switch locator {
case .ensuPack:
return try await knowledgeProvider.reload(
locator, datasets: datasets)
case .localNote(let note):
return try await notesStore.reload(note, collectionIDs: collectionIDs)
}
} catch {
if isCancellation(error) { throw error }
logger.warning("Source reload failed", details: "\(error)")
return nil
}
}
private func finishGeneration(
parent: MessageNode, response: String, tokenCount: Int, totalTimeMs: Int64?,
interrupted: Bool, generationId: UUID, citations: [GroundedSource] = [],
preparation: ConversationPreparation? = nil
) {
let rawText = response.trimmingCharacters(in: .whitespacesAndNewlines)
let trimmed: String
if rawText.isEmpty || preparation != nil {
trimmed = rawText
} else {
do {
trimmed = try finalizeGroundedAssistantText(
rawAssistantText: rawText,
sources: citations
)
} catch {
logger.error("Assistant source finalization failed", error)
trimmed =
(try? finalizeGroundedAssistantText(
rawAssistantText: rawText,
sources: []
)) ?? ""
}
}
let isActiveGeneration = activeGenerationId == generationId
if trimmed.isEmpty {
if isActiveGeneration && !interrupted && generationErrorMessage == nil {
let details =
"session=\(parent.sessionId.uuidString) promptLen=\(parent.text.count)"
logger.warning("Generation returned empty response", details: details)
generationErrorMessage = "No response from model. Try again."
}
} else {
let tokensPerSecond: Double? = {
guard let totalTimeMs, totalTimeMs > 0 else { return nil }
return Double(tokenCount) / (Double(totalTimeMs) / 1000.0)
}()
if isActiveGeneration {
let meta: [DbAttachmentMeta] = []
do {
let inserted: DbMessage
if let preparation {
inserted = try preparation.addAnswer(text: trimmed, attachments: meta)
} else {
inserted = try chatDb.insertMessage(
sessionUuid: parent.sessionId.uuidString,
sender: .other,
text: trimmed,
parentMessageUuid: parent.id.uuidString,
attachments: meta
)
}
if let assistantId = UUID(uuidString: inserted.uuid) {
logger.info(
"Message created",
details:
"id=\(assistantId.uuidString) session=\(parent.sessionId.uuidString) role=assistant"
)
let timestamp = Date(
timeIntervalSince1970: Double(inserted.createdAtUs) / 1_000_000.0)
let assistant = MessageNode(
id: assistantId,
sessionId: parent.sessionId,
parentId: parent.id,
role: .assistant,
text: inserted.text,
timestamp: timestamp,
attachments: [],
isInterrupted: interrupted,
tokensPerSecond: tokensPerSecond
)
messageStore[parent.sessionId, default: []].append(assistant)
invalidateChildrenCache(for: parent.sessionId)
updateSelection(
for: parent.sessionId, parentId: parent.id, childId: assistant.id)
updateSessionPreview(
sessionId: parent.sessionId,
preview: cleanAssistantText(storedText: inserted.text),
date: assistant.timestamp)
} else {
logger.warning(
"Skipping assistant message persistence",
details:
"session=\(parent.sessionId.uuidString) parent=\(parent.id.uuidString) interrupted=\(interrupted) reason=invalid_uuid"
)
}
} catch {
if preparation != nil {
generationErrorMessage =
"The response could not be saved. Retry the message."
}
logger.warning(
"Skipping assistant message persistence",
details:
"session=\(parent.sessionId.uuidString) parent=\(parent.id.uuidString) interrupted=\(interrupted) error=\(error)"
)
}
} else {
logger.info(
"Dropped stale generation response",
details:
"session=\(parent.sessionId.uuidString) parent=\(parent.id.uuidString) interrupted=\(interrupted)"
)
}
}
if isActiveGeneration {
conversationStatus = nil
isGenerating = false
isDownloading = false
streamingResponse = ""
streamingParentId = nil
downloadToast = nil
activeGenerationId = nil
activeGenerationSessionId = nil
}
if currentSessionId == parent.sessionId {
rebuildMessages(for: parent.sessionId)
}
if isActiveGeneration {
scheduleSessionSummary(for: parent.sessionId)
}
}
private func settleGenerationIfActive(generationId: UUID, sessionId: UUID) {
guard activeGenerationId == generationId, isGenerating else { return }
conversationStatus = nil
isGenerating = false
isDownloading = false
streamingResponse = ""
streamingParentId = nil
downloadToast = nil
activeGenerationId = nil
activeGenerationSessionId = nil
rebuildMessages(for: sessionId)
}
private func handleProgress(_ progress: DownloadProgress) {
let resolvedProgress = downloadProgressTracker.resolve(progress)
if resolvedProgress.isLoading {
downloadToast = DownloadToastState(
phase: .loading,
percent: resolvedProgress.percent ?? progress.percent,
status: resolvedProgress.status,
offerRetryDownload: false
)
isDownloading = true
return
}
if resolvedProgress.isReady {
if modelDownloadLoggedStart {
logger.info("Model download complete", details: progress.status)
modelDownloadLoggedStart = false
}
downloadToast = DownloadToastState(
phase: .ready, percent: 100, status: progress.status, offerRetryDownload: false)
isDownloading = false
isModelDownloaded = provider.isModelDownloaded(modelSettings.currentSelection())
modelDownloadSizeBytes = nil
clearDownloadProgressMemory()
Task { @MainActor in
try? await Task.sleep(nanoseconds: 1_500_000_000)
if self.downloadToast?.phase == .ready {
self.downloadToast = nil
}
}
return
}
downloadToast = DownloadToastState(
phase: .downloading,
percent: resolvedProgress.percent ?? 0,
status: resolvedProgress.status,
offerRetryDownload: false
)
isDownloading = true
}
private nonisolated static func buildSessions(
from loaded: [DbSession],
chatDb: EnsuDb,
summaries: [String: String]
) -> [ChatSession] {
let sessions: [ChatSession] = loaded.compactMap { session in
guard let id = UUID(uuidString: session.uuid) else { return nil }
let messages = (try? chatDb.getMessages(sessionUuid: session.uuid)) ?? []
let sortedMessages = messages.sorted { $0.createdAtUs < $1.createdAtUs }
let firstUserMessage =
sortedMessages.first(where: { $0.sender == .selfUser })?.text ?? ""
let lastMessageNode = sortedMessages.last
let lastMessage =
lastMessageNode.map { message in
message.sender == .other
? cleanAssistantText(storedText: message.text) : message.text
} ?? ""
let summary = summaries[session.uuid.lowercased()]
let isPlaceholderTitle =
session.title.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
|| session.title.caseInsensitiveCompare("New chat") == .orderedSame
let seedTitle = summary ?? (isPlaceholderTitle ? firstUserMessage : session.title)
let title = Self.sessionTitle(from: seedTitle, fallback: session.title)
let updatedAtUs = lastMessageNode?.createdAtUs ?? session.updatedAtUs
return ChatSession(
id: id,
title: title,
lastMessage: lastMessage,
updatedAt: Date(timeIntervalSince1970: Double(updatedAtUs) / 1_000_000.0)
)
}
return sessions.sorted { $0.updatedAt > $1.updatedAt }
}
private func reloadFromDb() {
reloadTask?.cancel()
reopenChatStoreIfNeeded()
let chatDb = chatDb
let summaries = sessionSummaries
let selected = currentSessionId
reloadTask = Task.detached { [weak self, chatDb, summaries, selected] in
let loaded = (try? chatDb.listSessions()) ?? []
let refreshed = Self.buildSessions(from: loaded, chatDb: chatDb, summaries: summaries)
let resolved =
selected.flatMap { id in
refreshed.first(where: { $0.id == id })?.id
} ?? (selected == nil ? nil : refreshed.first?.id)
if Task.isCancelled { return }
await MainActor.run {
guard let self else { return }
if Task.isCancelled { return }
let previousSessionId = self.currentSessionId
let shouldPreserveMessages = resolved == previousSessionId && !self.messages.isEmpty
let preservedMessages = self.messages
let preservedMessageStore = self.messageStore
let preservedBranchSelections = self.branchSelections
self.sessions = refreshed
self.currentSessionId = resolved
self.messageStore = [:]
self.branchSelections = [:]
self.childrenByParentCache = [:]
for session in refreshed {
if shouldPreserveMessages, session.id == resolved,
let nodes = preservedMessageStore[session.id]
{
self.messageStore[session.id] = nodes
self.branchSelections[session.id] =
preservedBranchSelections[session.id] ?? [:]
} else {
self.messageStore[session.id] = []
self.branchSelections[session.id] = [:]
}
}
if shouldPreserveMessages {
self.messages = preservedMessages
} else {
self.messages = []
}
if let current = resolved {
self.loadMessagesFromDb(for: current)
}
}
}
}
private func loadMessagesFromDb(for sessionId: UUID) {
reopenChatStoreIfNeeded()
if messageStore[sessionId] == nil {
messageStore[sessionId] = []
branchSelections[sessionId] = [:]
}
let chatDb = chatDb
let attachmentsDir = attachmentsDir
Task.detached { [weak self, chatDb, attachmentsDir] in
guard let self else { return }
let rawMessages = (try? chatDb.getMessages(sessionUuid: sessionId.uuidString)) ?? []
let nodes: [MessageNode] = rawMessages.compactMap { msg in
guard let messageId = UUID(uuidString: msg.uuid) else { return nil }
let parentId = msg.parentMessageUuid.flatMap { UUID(uuidString: $0) }
let role: RenderedChatMessage.Role = (msg.sender == .selfUser) ? .user : .assistant
let timestamp = Date(timeIntervalSince1970: Double(msg.createdAtUs) / 1_000_000.0)
let attachments: [ChatAttachment] = msg.attachments.compactMap { meta in
guard let attachmentId = UUID(uuidString: meta.id) else { return nil }
let kind: ChatAttachment.Kind = (meta.kind == .image) ? .image : .document
let file = attachmentsDir.appendingPathComponent(meta.id)
return ChatAttachment(
id: attachmentId,
name: meta.name,
size: meta.size,
kind: kind,
url: FileManager.default.fileExists(atPath: file.path) ? file : nil,
isUploading: false
)
}
return MessageNode(
id: messageId,
sessionId: sessionId,
parentId: parentId,
role: role,
text: msg.text,
timestamp: timestamp,
attachments: attachments,
isInterrupted: false,
tokensPerSecond: nil
)
}
await MainActor.run {
guard self.messageStore[sessionId] != nil else { return }
self.messageStore[sessionId] = nodes
// Branch selection is computed in-memory.
self.branchSelections[sessionId] = [:]
self.invalidateChildrenCache(for: sessionId)
if self.currentSessionId == sessionId {
self.rebuildMessages(for: sessionId)
}
}
}
}
private func rebuildMessages(for sessionId: UUID) {
let childrenMap = childrenByParent(sessionId: sessionId)
let path = buildSelectedPath(for: sessionId, childrenMap: childrenMap)
let selectionMap = branchSelections[sessionId, default: [:]]
messages = path.map { node in
let parentKey = node.parentId?.uuidString ?? "__root__"
let parentId = node.parentId ?? rootId
let siblings = dedupeSiblings(childrenMap[parentId] ?? [])
let selectedId = selectionMap[parentKey]
let index = siblings.firstIndex { $0.id == selectedId } ?? (siblings.count - 1)
return RenderedChatMessage(
id: node.id,
role: node.role,
text: node.text,
timestamp: node.timestamp,
attachments: node.attachments,
isInterrupted: node.isInterrupted,
isSynthetic: false,
tokensPerSecond: node.tokensPerSecond,
branchIndex: max(1, index + 1),
branchCount: max(1, siblings.count)
)
}
var augmented: [RenderedChatMessage] = []
for (i, msg) in messages.enumerated() {
augmented.append(msg)
if msg.role == .user {
let next = i + 1 < messages.count ? messages[i + 1] : nil
let isLastAndGenerating = i == messages.count - 1 && isGenerating
if next?.role != .assistant && !isLastAndGenerating {
augmented.append(
RenderedChatMessage(
id: deterministicSyntheticMessageId(parentId: msg.id),
role: .assistant,
text: "Response was interrupted",
timestamp: msg.timestamp,
isInterrupted: true,
isSynthetic: true
))
}
}
}
messages = augmented
}
private func deterministicSyntheticMessageId(parentId: UUID) -> UUID {
var uuid = parentId.uuid
uuid.0 ^= 0xA5
uuid.15 ^= 0x5A
return UUID(uuid: uuid)
}
private func buildConversationPath(for target: MessageNode) -> [String] {
let byId = Dictionary(
uniqueKeysWithValues: (messageStore[target.sessionId] ?? []).map { ($0.id, $0) })
var path: [String] = []
var visited = Set<UUID>()
var current: MessageNode? = target
while let node = current, visited.insert(node.id).inserted {
path.append(node.id.uuidString)
current = node.parentId.flatMap { byId[$0] }
}
return path.reversed()
}
private func buildSelectedPath(for sessionId: UUID, childrenMap: [UUID: [MessageNode]])
-> [MessageNode]
{
guard let nodes = messageStore[sessionId], !nodes.isEmpty else { return [] }
let byId = Dictionary(uniqueKeysWithValues: nodes.map { ($0.id, $0) })
let roots = dedupeSiblings(
nodes.filter { node in
guard let parentId = node.parentId else { return true }
return byId[parentId] == nil
})
guard !roots.isEmpty else { return [] }
let selectionMap = branchSelections[sessionId, default: [:]]
var current = selectChild(
selectionMap: selectionMap, selectionKey: "__root__", candidates: roots)
var path: [MessageNode] = []
var visited = Set<UUID>()
while let node = current, visited.insert(node.id).inserted {
path.append(node)
if node.id == streamingParentId { break }
let children = dedupeSiblings(childrenMap[node.id] ?? [])
if children.isEmpty { break }
current = selectChild(
selectionMap: selectionMap, selectionKey: node.id.uuidString, candidates: children)
}
return path
}
private func selectChild(
selectionMap: [String: UUID], selectionKey: String, candidates: [MessageNode]
) -> MessageNode? {
guard !candidates.isEmpty else { return nil }
if let selectedId = selectionMap[selectionKey],
let selected = candidates.first(where: { $0.id == selectedId })
{
return selected
}
return candidates.last
}
private func invalidateChildrenCache(for sessionId: UUID) {
childrenByParentCache[sessionId] = nil
}
private func childrenByParent(sessionId: UUID) -> [UUID: [MessageNode]] {
if let cached = childrenByParentCache[sessionId] {
return cached
}
var map: [UUID: [MessageNode]] = [:]
guard let nodes = messageStore[sessionId] else { return map }
let byId = Dictionary(uniqueKeysWithValues: nodes.map { ($0.id, $0) })
for node in nodes {
let parent = node.parentId.flatMap { byId[$0] != nil ? $0 : nil } ?? rootId
map[parent, default: []].append(node)
}
childrenByParentCache[sessionId] = map
return map
}
private func childrenFor(sessionId: UUID, parentId: UUID) -> [MessageNode] {
let map = childrenByParent(sessionId: sessionId)
return map[parentId] ?? []
}
private func dedupeSiblings(_ nodes: [MessageNode]) -> [MessageNode] {
guard nodes.count > 1 else { return nodes.sorted(by: { $0.timestamp < $1.timestamp }) }
let sorted = nodes.sorted(by: { $0.timestamp < $1.timestamp })
var result: [MessageNode] = []
for node in sorted {
if let last = result.last, isDuplicate(last, node) {
continue
}
result.append(node)
}
return result
}
private func isDuplicate(_ lhs: MessageNode, _ rhs: MessageNode) -> Bool {
guard lhs.role == rhs.role else { return false }
guard lhs.text == rhs.text else { return false }
guard attachmentSignature(lhs.attachments) == attachmentSignature(rhs.attachments) else {
return false
}
return abs(lhs.timestamp.timeIntervalSince(rhs.timestamp)) <= 2
}
private func attachmentSignature(_ attachments: [ChatAttachment]) -> [String] {
attachments.map { "\($0.kind)-\($0.name)" }
}
private func updateSelection(for sessionId: UUID, parentId: UUID?, childId: UUID) {
let key = parentId?.uuidString ?? "__root__"
branchSelections[sessionId, default: [:]][key] = childId
}
private func updateSessionPreview(sessionId: UUID, preview: String, date: Date) {
sessions = sessions.map { session in
guard session.id == sessionId else { return session }
var updated = session
let isPlaceholderTitle =
session.title.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
|| session.title.caseInsensitiveCompare("New chat") == .orderedSame
if isPlaceholderTitle {
let updatedTitle = Self.sessionTitle(from: preview, fallback: session.title)
if updatedTitle != session.title {
_ = try? chatDb.updateSessionTitle(
uuid: sessionId.uuidString, title: updatedTitle)
}
updated.title = updatedTitle
}
updated.lastMessage = preview
updated.updatedAt = date
return updated
}
}
private func scheduleSessionSummary(for sessionId: UUID) {
guard !isChatUnsupported else { return }
sessionSummaryTask?.cancel()
let summaryKey = sessionSummaryKey(sessionId)
guard sessionSummaries[summaryKey] == nil else { return }
guard let summaryInput = buildSessionSummaryInput(sessionId: sessionId) else { return }
let existingSummary = sessionSummaries[summaryKey]
let selection = modelSettings.currentSelection()
let provider = provider
let notes = notesStore
let notesScope = notes.suspendMaintenance()
sessionSummaryTask = Task.detached(priority: .utility) { [weak self] in
defer { notesScope.close() }
await notes.awaitMaintenance()
guard let self else { return }
do {
try await Task.sleep(nanoseconds: 200_000_000)
} catch {
return
}
guard !Task.isCancelled else { return }
let summary = await Self.generateSessionSummary(
input: summaryInput.text,
fallback: summaryInput.fallback,
existingSummary: existingSummary,
provider: provider,
selection: selection
)
guard !Task.isCancelled, let summary else { return }
await MainActor.run {
self.applySessionSummary(sessionId: sessionId, summary: summary)
}
}
}
private func buildSessionSummaryInput(sessionId: UUID) -> (text: String, fallback: String)? {
guard let nodes = messageStore[sessionId], !nodes.isEmpty else { return nil }
let sorted = nodes.sorted(by: { $0.timestamp < $1.timestamp })
guard let firstUser = sorted.first(where: { $0.role == .user }) else { return nil }
let input = "User: \(firstUser.text)"
let fallback = Self.summarizeQuestion(firstUser.text)
return (text: input, fallback: fallback)
}
private func applySessionSummary(sessionId: UUID, summary: String) {
let sanitized = Self.sessionTitle(from: summary, fallback: "New chat")
guard !sanitized.isEmpty else { return }
let summaryKey = sessionSummaryKey(sessionId)
if sessionSummaries[summaryKey] == sanitized { return }
sessionSummaries[summaryKey] = sanitized
persistSessionSummaries()
_ = try? chatDb.updateSessionTitle(uuid: sessionId.uuidString, title: sanitized)
sessions = sessions.map { session in
guard session.id == sessionId else { return session }
var updated = session
updated.title = sanitized
return updated
}
}
private func persistSessionSummaries() {
guard let data = try? JSONEncoder().encode(sessionSummaries) else { return }
UserDefaults.standard.set(data, forKey: Self.sessionSummaryStoreKey)
}
private func sessionSummaryKey(_ id: UUID) -> String {
id.uuidString.lowercased()
}
private func sessionSummaryKey(_ id: String) -> String {
id.lowercased()
}
private static func loadSessionSummaries() -> [String: String] {
guard let data = UserDefaults.standard.data(forKey: Self.sessionSummaryStoreKey) else {
return [:]
}
return (try? JSONDecoder().decode([String: String].self, from: data)) ?? [:]
}
private static func summarizeQuestion(_ text: String) -> String {
let cleaned = sanitizeTitleText(text)
guard !cleaned.isEmpty else { return "" }
let words = cleaned.split(separator: " ").map {
String($0).trimmingCharacters(in: .punctuationCharacters)
}.filter { !$0.isEmpty }
guard !words.isEmpty else { return "" }
let summaryWords = words.prefix(Self.sessionSummaryMaxWords)
return summaryWords.joined(separator: " ")
}
private nonisolated static func sanitizeTitleText(_ text: String) -> String {
text
.replacingOccurrences(of: "[\\r\\n\\t]+", with: " ", options: .regularExpression)
.replacingOccurrences(of: "\\s+", with: " ", options: .regularExpression)
.trimmingCharacters(in: .whitespacesAndNewlines)
}
nonisolated static func sessionTitle(from text: String, fallback: String = "New chat") -> String
{
let trimmed = sanitizeTitleText(text)
guard !trimmed.isEmpty else { return fallback }
if trimmed.count <= Self.sessionTitleMaxLength {
return trimmed
}
let prefix = trimmed.prefix(Self.sessionTitleMaxLength)
return String(prefix).trimmingCharacters(in: .whitespacesAndNewlines) + "β¦"
}
private static func generateSessionSummary(
input: String,
fallback: String,
existingSummary: String?,
provider: LlmProvider,
selection: LlmModelSelection
) async -> String? {
if let existingSummary, !existingSummary.isEmpty { return nil }
let cleanedInput = sanitizeTitleText(input)
guard !cleanedInput.isEmpty else { return sessionTitle(from: fallback, fallback: fallback) }
let messages = [
LlmMessage(text: sessionSummarySystemPrompt, role: .system, hasAttachments: false),
LlmMessage(text: cleanedInput, role: .user, hasAttachments: false),
]
let buffer = OSAllocatedUnfairLock(initialState: "")
do {
try await provider.generateTitle(
selection,
messages: messages
) { token in
buffer.withLock { $0.append(token) }
}
} catch {
let fallbackSummary = summarizeQuestion(fallback)
return fallbackSummary.isEmpty
? nil : sessionTitle(from: fallbackSummary, fallback: fallback)
}
let raw = sanitizeTitleText(buffer.withLock { $0 })
guard !raw.isEmpty else { return sessionTitle(from: fallback, fallback: fallback) }
let words = raw.split(separator: " ").map { String($0) }.filter { !$0.isEmpty }
guard !words.isEmpty else { return nil }
let summaryWords = words.prefix(Self.sessionSummaryMaxWords)
let summary = summaryWords.joined(separator: " ")
return sessionTitle(from: summary, fallback: fallback)
}
private func isCancellation(_ error: Error) -> Bool {
if error is CancellationError { return true }
if case LlmError.Cancelled = error { return true }
if case ConversationError.Cancelled = error { return true }
if case AssetDownloadError.Cancelled = error { return true }
return (error as? URLError)?.code == .cancelled
}
private func seedDownloadProgressMemory() {
downloadProgressTracker.seed(from: downloadToast)
}
private func clearDownloadProgressMemory() {
downloadProgressTracker.clear()
}
private func shouldRetryModelDownload(_ error: Error, retryCount: Int) -> Bool {
if retryCount >= 5 { return false }
if isCancellation(error) { return false }
if isOutOfStorageError(error) { return false }
if error is RequiredModelValidationError {
return false
}
switch error {
case AssetDownloadError.Validation:
return false
case let AssetDownloadError.Http(_, retryable):
return retryable
default:
break
}
return true
}
private func retryDelayNanoseconds(for retryCount: Int) -> UInt64 {
let shift = max(0, retryCount - 1)
let multiplier = UInt64(1 << shift)
let delayMs = min(12_000, 1_500 * Int(multiplier))
return UInt64(delayMs) * 1_000_000
}
private func userFacingModelReadyError(_ error: Error, wasDownloaded: Bool) -> String {
if error is UnsupportedDeviceMemoryError {
return Self.unsupportedDeviceMessage
}
if isOutOfStorageError(error) {
return
"Not enough storage space to download the model. Please free up space and try again."
}
return wasDownloaded ? "Model load failed" : "Download failed. Please try again."
}
private func isOutOfStorageError(_ error: Error) -> Bool {
if case AssetDownloadError.StorageFull = error { return true }
return error.isOutOfDiskSpace
}
private nonisolated func attachmentsDirectory() throws -> URL {
let base =
FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
?? FileManager.default.temporaryDirectory
let dir = base.appendingPathComponent("llmchat", isDirectory: true)
.appendingPathComponent("chat_attachments", isDirectory: true)
try FileManager.default.createDirectory(
at: dir, withIntermediateDirectories: true, attributes: nil)
return dir
}
private nonisolated func writeAttachment(data: Data, attachmentId: UUID) throws -> URL {
let dir = try attachmentsDirectory()
let destination = dir.appendingPathComponent(attachmentId.uuidString.lowercased())
try data.write(to: destination, options: .atomic)
return destination
}
private nonisolated func copyAttachment(from url: URL, attachmentId: UUID) throws -> URL {
let dir = try attachmentsDirectory()
let destination = dir.appendingPathComponent(attachmentId.uuidString.lowercased())
let needsSecurity = url.startAccessingSecurityScopedResource()
defer {
if needsSecurity {
url.stopAccessingSecurityScopedResource()
}
}
if FileManager.default.fileExists(atPath: destination.path) {
try FileManager.default.removeItem(at: destination)
}
try FileManager.default.copyItem(at: url, to: destination)
return destination
}
private struct HistorySelection {
let messages: [LlmMessage]
let inputTokens: Int
let inputBudget: Int
let wasTrimmed: Bool
}
private struct GenerationLimits {
let contextLength: Int
let maxOutput: Int
}
private struct PendingOverflow {
let sessionId: UUID
let messageId: UUID
let sources: ChatSourceSelection
}
private func buildPrompt(text: String, attachments: [ChatAttachment]) -> PromptResult {
var prompt = text
let documents = attachments.filter { $0.kind == .document }
let images = attachments.filter { $0.kind == .image }
let imageFiles = images.compactMap { $0.url }
if !imageFiles.isEmpty && text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
prompt = "Describe the attached images."
}
for (index, attachment) in documents.enumerated() {
prompt += "\n\n----- BEGIN DOCUMENT: Document \(index + 1) -----\n"
prompt += "Attached document: \(attachment.name)\n"
prompt += "----- END DOCUMENT: Document \(index + 1) -----"
}
if !imageFiles.isEmpty {
let mediaMarker = "<__media__>"
prompt += "\n\n[\(imageFiles.count) image attachment"
if imageFiles.count > 1 { prompt += "s" }
prompt += " provided]"
for _ in imageFiles {
prompt += "\n\(mediaMarker)"
}
}
return PromptResult(text: prompt, imageFiles: imageFiles)
}
private func buildHistorySelection(
sessionId: UUID,
promptText: String,
promptImageCount: Int,
currentMessageId: UUID,
limits: GenerationLimits,
systemPrompt: String
) -> HistorySelection {
let childrenMap = childrenByParent(sessionId: sessionId)
let path = buildSelectedPath(for: sessionId, childrenMap: childrenMap)
let historyMessages = path.prefix { $0.id != currentMessageId }
let inputBudget = max(
0, limits.contextLength - limits.maxOutput - Self.overflowSafetyTokens)
let systemTokens = estimateTokens(systemPrompt)
let promptTokens = estimatePromptTokens(
promptText: promptText, imageCount: promptImageCount)
let historyTokens = historyMessages.reduce(0) { total, node in
total + estimateTokens(historyText(node))
}
let inputTokens = systemTokens + promptTokens + historyTokens
let remaining = inputBudget - systemTokens - promptTokens
if remaining <= 0 || historyMessages.isEmpty {
return HistorySelection(
messages: [], inputTokens: inputTokens, inputBudget: inputBudget,
wasTrimmed: inputTokens > inputBudget)
}
let quantum = max(1, inputBudget / 4)
let overflow = max(0, historyTokens - remaining)
let quantaToDiscard = (overflow + quantum - 1) / quantum
let discardTarget = quantaToDiscard * quantum
var discarded = 0
var startIndex = historyMessages.startIndex
while startIndex < historyMessages.endIndex && discarded < discardTarget {
discarded += estimateTokens(historyText(historyMessages[startIndex]))
startIndex = historyMessages.index(after: startIndex)
}
var retained = historyMessages[startIndex...]
if retained.isEmpty, let last = historyMessages.last,
estimateTokens(historyText(last)) <= remaining
{
retained = historyMessages.suffix(1)
}
let selected = retained.map { node in
let text = historyText(node)
return LlmMessage(
text: text, role: node.role == .user ? .user : .assistant,
hasAttachments: !node.attachments.isEmpty)
}
return HistorySelection(
messages: selected, inputTokens: inputTokens, inputBudget: inputBudget,
wasTrimmed: inputTokens > inputBudget)
}
private func resolveMaxOutputTokens(contextLength: Int) -> Int {
let maxAllowed = max(1, contextLength - Self.overflowSafetyTokens)
let implicitMax = automaticMaxOutputTokens(contextLength: contextLength)
return min(maxAllowed, implicitMax)
}
private func historyText(_ node: MessageNode) -> String {
var text = node.text
if node.role == .assistant {
text = cleanAssistantText(storedText: text)
if let regex = ChatMessageTagRegex.think {
let range = NSRange(text.startIndex..., in: text)
text = regex.stringByReplacingMatches(
in: text, options: [], range: range, withTemplate: "")
} else {
text = text.replacingOccurrences(
of: "<think>[\\s\\S]*?</think>", with: "", options: .regularExpression)
}
if let regex = ChatMessageTagRegex.todoList {
let range = NSRange(text.startIndex..., in: text)
text = regex.stringByReplacingMatches(
in: text, options: [], range: range, withTemplate: "")
} else {
text = text.replacingOccurrences(
of: "<todo_list>[\\s\\S]*?</todo_list>", with: "", options: .regularExpression)
}
} else if !node.attachments.isEmpty {
text += "\n\n[\(node.attachments.count) attachments attached]"
}
return text.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)
}
private func trimToBudget(_ text: String, budget: Int) -> String {
guard budget > 0 else { return "" }
let maxChars = budget * 4
if text.count <= maxChars { return text }
return String(text.suffix(maxChars))
}
private func estimateTokens(_ text: String) -> Int {
max(1, text.count / 4)
}
private func estimateImageTokens(_ imageCount: Int) -> Int {
imageCount * Self.imageTokenEstimate
}
private func estimatePromptTokens(promptText: String, imageCount: Int) -> Int {
estimateTokens(promptText) + estimateImageTokens(imageCount)
}
private func resolveTemperature() -> Float {
let value = Float(
modelSettings.temperature.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines))
let resolved = value.map { max(0, $0) } ?? Self.defaultTemperature
return min(max(resolved, 0.35), 0.7)
}
private struct MessageNode: Identifiable {
let id: UUID
let sessionId: UUID
let parentId: UUID?
let role: RenderedChatMessage.Role
let text: String
let timestamp: Date
let attachments: [ChatAttachment]
let isInterrupted: Bool
let tokensPerSecond: Double?
}
private struct PromptResult {
let text: String
let imageFiles: [URL]
}
}
private struct ResolvedDownloadProgress {
let percent: Int?
let status: String
let isLoading: Bool
let isReady: Bool
}
private final class DownloadProgressTracker {
private var lastVisiblePercent: Int?
private var lastVisibleStatus: String?
func seed(from toast: DownloadToastState?) {
if let toast, let percent = toast.percent {
lastVisiblePercent = percent
lastVisibleStatus = toast.status
} else {
lastVisiblePercent = 0
lastVisibleStatus = "Starting download..."
}
}
func clear() {
lastVisiblePercent = nil
lastVisibleStatus = nil
}
func resolve(_ progress: DownloadProgress) -> ResolvedDownloadProgress {
let isLoading = progress.phase == .loading
let isReady = progress.phase == .ready
let rawPercent = progress.percent
let previousPercent = lastVisiblePercent
let previousStatus = lastVisibleStatus
let resolvedPercent: Int? = {
if isReady { return 100 }
if let rawPercent {
if let previousPercent {
return max(rawPercent, previousPercent)
}
return rawPercent
}
return previousPercent
}()
let regressed = {
guard let rawPercent, let previousPercent else { return false }
return rawPercent < previousPercent
}()
let resolvedStatus: String = {
if isReady || isLoading {
return progress.status
}
if regressed {
return previousStatus ?? progress.status
}
return progress.status
}()
if !isReady {
lastVisiblePercent = resolvedPercent
lastVisibleStatus = resolvedStatus
}
return ResolvedDownloadProgress(
percent: resolvedPercent,
status: resolvedStatus,
isLoading: isLoading,
isReady: isReady
)
}
}
private final class ConversationProgressSink: ConversationProgressCallback {
private let handler: @Sendable () -> Void
init(handler: @escaping @Sendable () -> Void) {
self.handler = handler
}
func onProgress() {
handler()
}
}