Repository Public
1// Author: Simon-Pierre Boucher — contact@spboucher.ai2// File: SPChat/Features/Chat/ChatViewModel.swift3// Description: State of one conversation: cache-first loading, sending, streaming (throttled), stop, regenerate, edit, tool approval, versions, drafts, attachments.4import SwiftUI5import SPChatCore67/// Options of the next turn, as chosen in the toolbar.8struct TurnSettings: Equatable {9 var modelId: String?10 var routingMode: RoutingMode = .manual11 var effort: Effort?12 var toolsEnabled = true13 var presetId: String?14 /// « Recherche web » toggle of the composer (`settings.webSearch`): the model must search before answering.15 var webSearch = false16 /// Tools allowed for the next turns (composer tool picker); nil = every tool the server offers.17 var toolNames: Set<String>?18 var temperature: Double?19 var maxOutputTokens: Int?20 var reasoningSummary: Bool?2122 var options: TurnOptions {23 // a preset fills what is left unset: explicit choices are only sent when no preset is active24 if let presetId { return TurnOptions(presetId: presetId, webSearch: webSearch ? true : nil) }25 return TurnOptions(modelId: modelId, routingMode: routingMode, effort: effort, maxOutputTokens: maxOutputTokens, temperature: temperature, reasoningSummary: reasoningSummary,26 toolsEnabled: toolsEnabled || webSearch, toolNames: toolsEnabled || webSearch ? effectiveToolNames : nil, webSearch: webSearch ? true : nil)27 }28 /// The subset sent as `toolNames`; the web toggle always brings `web_search` along.29 private var effectiveToolNames: [String]? {30 guard var names = toolNames else { return toolsEnabled ? nil : (webSearch ? ["fetch_page", "web_search"] : nil) }31 if !toolsEnabled { names = [] }32 if webSearch { names.insert("web_search") }33 return names.sorted()34 }35 var hasAdvancedOverrides: Bool { effort != nil || temperature != nil || maxOutputTokens != nil || reasoningSummary != nil }36}3738@Observable final class ChatViewModel {39 private(set) var conversationId: String?40 private(set) var conversation: Conversation?41 /// Whole message tree (active and inactive versions), as last received.42 private(set) var detail: ConversationDetail?43 /// Settled messages of the displayed thread.44 private(set) var messages: [Message] = []45 /// The answer being generated. Kept apart from `messages` so that streaming never invalidates the settled rows.46 private(set) var live: Message?47 private(set) var phase: GenerationPhase = .idle48 private(set) var isLoading = false49 private(set) var loadFailed: String?50 /// The thread on screen comes from the local cache (server unreachable).51 private(set) var isFromCache = false52 var errorBanner: String?53 var warning: String?54 /// Parameters the server did not apply to the turn in progress / the last turn (`start.applied.ignored`):55 /// images dropped for a model without vision, « recherche web » for a model without tools…56 private(set) var ignoredNotice: [AppliedParameters.Ignored] = []57 /// Advisory « modèle suggéré » for the text being written (never applied by itself).58 private(set) var suggestion: RouteSuggestion?59 @ObservationIgnored private var suggestionTask: Task<Void, Never>?60 @ObservationIgnored private var suggestionFor = ""61 var draft = "" { didSet { if draft != oldValue { scheduleDraftSave(); refreshSuggestion() } } }62 var pending: [PendingAttachment] = []63 var settings = TurnSettings()64 var projectId: String?65 /// Message to bring into view (search hit, deep link).66 var scrollTarget: String?67 /// Reading position remembered when the conversation leaves the screen.68 @ObservationIgnored var savedScrollId: String?69 @ObservationIgnored var onConversationCreated: ((String) -> Void)?70 @ObservationIgnored let draftKey = UUID().uuidString7172 /// Strong on purpose: turns outlive views, and the environment drops its view models at sign-out (no permanent cycle).73 @ObservationIgnored private let env: AppEnvironment74 @ObservationIgnored private var accumulator = MessageAccumulator(conversationId: "")75 @ObservationIgnored private var streamTask: Task<Void, Never>?76 @ObservationIgnored private var flushTask: Task<Void, Never>?77 @ObservationIgnored private var draftTask: Task<Void, Never>?78 @ObservationIgnored private var runId: String?79 @ObservationIgnored private var optimisticId: String?80 @ObservationIgnored private var failedDraft: (text: String, attachments: [PendingAttachment])?81 @ObservationIgnored private var didLoad = false82 @ObservationIgnored private var suppressDraftSave = false8384 init(conversationId: String?, env: AppEnvironment) {85 self.conversationId = conversationId; self.env = env86 settings = TurnSettings(modelId: env.preferences.modelId, routingMode: env.preferences.routingMode, effort: env.preferences.effort, toolsEnabled: env.preferences.toolsEnabled, presetId: env.preferences.presetId, webSearch: env.preferences.webSearch)87 }8889 var isStreaming: Bool { phase != .idle }90 var isEmpty: Bool { messages.isEmpty && live == nil }91 var title: String { conversation?.title ?? "Nouvelle conversation" }92 var hasUploadsInFlight: Bool { pending.contains { if case .uploading = $0.state { return true }; return false } }93 var canSend: Bool { !isStreaming && !hasUploadsInFlight && (!draft.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty || pending.contains { $0.attachment != nil }) }94 /// Every message on screen, the streaming one last.95 var displayed: [Message] { live.map { messages + [$0] } ?? messages }96 var totalCost: Double { displayed.compactMap(\.costUsd).reduce(0, +) }9798 /// Picks a selectable model once the catalogue is known (it may load after the conversation opens).99 func ensureModel() {100 if settings.modelId == nil || env.catalog.model(settings.modelId)?.isSelectableForChat != true { settings.modelId = env.catalog.initialModelId(preferred: conversation?.modelId ?? settings.modelId) }101 }102103 // MARK: Loading104105 func loadIfNeeded() async {106 guard !didLoad else { return }107 didLoad = true108 ensureModel()109 guard let id = conversationId else {110 if let text = env.pendingComposerText { env.pendingComposerText = nil; setDraftSilently(text) }111 else if let d = try? await env.api.draft(scope: draftScope), draft.isEmpty { setDraftSilently(d.text); adoptDraftAttachments(d.attachments) }112 return113 }114 isLoading = true115 if let cached = try? await env.cache?.detail(id) { apply(cached.detail, fromCache: true) }116 await reload(attach: true)117 isLoading = false118 }119120 /// Fetches the conversation. `attach`: follow a generation that is still running on the server.121 func reload(attach: Bool = false) async {122 guard let id = conversationId else { return }123 do {124 let d = try await env.api.conversation(id)125 apply(d, fromCache: false); loadFailed = nil126 try? await env.cache?.saveDetail(d)127 if attach, let run = d.liveRun, !isStreaming { follow(runId: run) }128 } catch let e as APIError {129 if e.isNetwork { isFromCache = detail != nil; if detail == nil { loadFailed = "Hors ligne : cette conversation n'est pas dans le cache local." } }130 else if e.status == 404 { loadFailed = "Cette conversation n'existe plus."; env.conversations.reset(); Task { await env.conversations.refresh() } }131 else if e.kind != .locked { loadFailed = e.message }132 } catch {}133 }134135 private func apply(_ d: ConversationDetail, fromCache: Bool) {136 detail = d; conversation = d.conversation; isFromCache = fromCache; projectId = d.conversation.projectId137 // while an answer streams here, its database row (status "streaming") is represented by `live`138 messages = d.activeMessages.filter { !(isStreaming && ($0.id == live?.id || $0.status == .streaming)) }139 if !isStreaming { live = nil }140 if let m = d.conversation.modelId, env.catalog.model(m)?.isSelectableForChat == true, settings.presetId == nil, settings.routingMode == .manual { settings.modelId = m }141 if let text = d.draft, draft.isEmpty, !fromCache { setDraftSilently(text) }142 if !fromCache, env.conversations.conversation(d.conversation.id) != nil || d.conversation.messageCount > 0 {143 var row = d.conversation144 if let existing = env.conversations.conversation(row.id) { row.projectName = existing.projectName; row.projectColor = existing.projectColor }145 env.conversations.upsert(row)146 }147 }148149 // MARK: Turns150151 func send() {152 let text = draft.trimmingCharacters(in: .whitespacesAndNewlines)153 let ready = pending.filter { $0.attachment != nil }154 guard canSend else { return }155 let atts = ready.compactMap(\.attachment)156 let tmp = "tmp_\(UUID().uuidString)"157 messages.append(Message(id: tmp, conversationId: conversationId ?? "", parentId: messages.last?.id, role: .user, parts: atts.map(\.asPart) + (text.isEmpty ? [] : [.text(text)])))158 optimisticId = tmp; failedDraft = (text, ready)159 setDraftSilently(""); pending.removeAll { $0.attachment != nil }160 draftTask?.cancel()161 var payload: [String: JSONValue] = ["text": .string(text)]162 if let conversationId { payload["conversationId"] = .string(conversationId) } else if let projectId { payload["projectId"] = .string(projectId) }163 if !atts.isEmpty { payload["attachmentIds"] = .array(atts.map { .string($0.id) }) }164 rememberChoices(); env.catalog.markUsed(settings.presetId == nil && settings.routingMode == .manual ? settings.modelId : nil)165 suggestion = nil; suggestionTask?.cancel()166 run(.send, payload: payload.merging(settings.options.payload) { $1 })167 }168169 /// Regenerates an answer (also the way to retry a failed or incomplete one), optionally with another model.170 func regenerate(_ message: Message, modelId: String? = nil) {171 guard !isStreaming, message.role == .assistant else { return }172 if let i = messages.firstIndex(where: { $0.id == message.id }) { messages.removeSubrange(i...) }173 var opts = settings.options174 if let modelId {175 var s = settings; s.presetId = nil; s.routingMode = .manual; s.modelId = modelId176 if let e = s.effort, let levels = env.catalog.model(modelId)?.effortLevels, !levels.isEmpty, !levels.contains(e.rawValue) { s.effort = nil }177 opts = s.options; env.catalog.markUsed(modelId)178 }179 run(.regenerate, payload: ["messageId": .string(message.id)].merging(opts.payload) { $1 }, parentId: message.parentId)180 }181182 /// Replaces a question by an edited version and answers it; the previous exchange stays reachable as a version.183 func edit(_ message: Message, text: String) {184 let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)185 guard !isStreaming, message.role == .user, !trimmed.isEmpty else { return }186 if let i = messages.firstIndex(where: { $0.id == message.id }) { messages.removeSubrange(i...) }187 let tmp = "tmp_\(UUID().uuidString)"188 messages.append(Message(id: tmp, conversationId: message.conversationId, parentId: message.parentId, role: .user, parts: message.parts.filter { $0.textValue == nil } + [.text(trimmed)]))189 optimisticId = tmp190 run(.edit, payload: ["messageId": .string(message.id), "text": .string(trimmed)].merging(settings.options.payload) { $1 })191 }192193 /// Continues a turn whose tool calls were waiting for the owner's decision.194 func decideToolCalls(on message: Message, approve: [String], deny: [String]) {195 guard !isStreaming else { return }196 if let i = messages.firstIndex(where: { $0.id == message.id }) { messages.removeSubrange((i + 1)...) }197 run(.approve, payload: ["messageId": .string(message.id), "approve": .array(approve.map(JSONValue.string)), "deny": .array(deny.map(JSONValue.string))], parentId: message.id)198 }199200 private func run(_ endpoint: TurnEndpoint, payload: [String: JSONValue], parentId: String? = nil) {201 errorBanner = nil; warning = nil; ignoredNotice = []; phase = .sending; runId = nil202 accumulator = MessageAccumulator(conversationId: conversationId ?? "", parentId: parentId ?? messages.last?.id)203 let stream = env.engine.start(endpoint, payload: payload)204 streamTask = Task { [weak self] in205 for await update in stream { guard let self, !Task.isCancelled else { return }; await self.handle(update) }206 }207 }208209 private func follow(runId: String) {210 guard !isStreaming else { return }211 self.runId = runId; phase = .reconnecting212 // the server replays the run from its first event: the partial database row is rebuilt from the stream213 messages.removeAll { $0.status == .streaming }214 accumulator = MessageAccumulator(conversationId: conversationId ?? "", parentId: messages.last?.id)215 let stream = env.engine.follow(runId: runId)216 streamTask = Task { [weak self] in217 for await update in stream { guard let self, !Task.isCancelled else { return }; await self.handle(update) }218 }219 }220221 private func handle(_ update: GenerationUpdate) async {222 switch update {223 case .phase(let p): if phase != .idle { phase = p }224 case .warning(let w): warning = w225 case .event(let event): await handle(event)226 case .ended(let end): await finish(end)227 }228 }229230 private func handle(_ event: ChatEvent) async {231 switch event {232 case .run(let id): runId = id233 case .resync: flushNow(); await reload(attach: false); accumulator.apply(.resync); live = nil234 case .conversation(let id, _, let userMessageId, _, _, _):235 if conversationId == nil {236 conversationId = id; env.adopt(self, draftKey: draftKey, conversationId: id)237 conversation = Conversation(id: id, projectId: projectId, title: "Nouvelle conversation", modelId: settings.modelId, messageCount: 1, lastMessageAt: Date())238 if let c = conversation { env.conversations.upsert(c) }239 onConversationCreated?(id)240 }241 accumulator.conversationId = id242 if let tmp = optimisticId, let uid = userMessageId, let i = messages.firstIndex(where: { $0.id == tmp }) { messages[i].id = uid; messages[i].conversationId = id; accumulator.parentId = uid; optimisticId = nil }243 failedDraft = nil // the server has the message: nothing to give back to the composer any more244 case .title(let t):245 conversation?.title = t246 if var c = conversation { c.lastMessageAt = Date(); env.conversations.upsert(c) }247 case .warning(let w): warning = w248 case .meta(_, let retrying):249 if let retrying { warning = "Connexion au fournisseur instable : nouvelle tentative (\(retrying))…" }250 if accumulator.apply(event) { scheduleFlush() }251 case .error(let message, _, _) where accumulator.message == nil: errorBanner = message252 case .start(_, _, _, _, let applied):253 if let applied, let data = try? JSONEncoder().encode(applied), let ap = try? JSONDecoder().decode(AppliedParameters.self, from: data) { ignoredNotice = ap.ignored }254 if accumulator.apply(event) { scheduleFlush() }255 default: if accumulator.apply(event) { scheduleFlush() }256 }257 }258259 private func finish(_ end: GenerationEnd) async {260 flushNow()261 let finished = live262 phase = .idle; streamTask = nil; runId = nil263 switch end {264 case .completed, .runGone:265 if let m = finished { messages.append(m) }; live = nil266 await reload(attach: false)267 if let m = finished ?? messages.last, m.role == .assistant { env.notifyCompletion(of: self, message: m) }268 case .deduplicated(let cid):269 live = nil270 if conversationId == nil { conversationId = cid; env.adopt(self, draftKey: draftKey, conversationId: cid); onConversationCreated?(cid) }271 await reload(attach: true)272 case .notSent(let error), .refused(let error):273 live = nil274 if let tmp = optimisticId { messages.removeAll { $0.id == tmp }; optimisticId = nil }275 // nothing was accepted by the server: the text and its files go back to the composer, never lost276 if let f = failedDraft { if draft.isEmpty { setDraftSilently(f.text) }; pending.insert(contentsOf: f.attachments, at: 0); failedDraft = nil }277 errorBanner = error.message278 if conversationId != nil, case .refused = end { await reload(attach: false) }279 case .sessionEnded: live = nil280 }281 await env.conversations.refreshQuietly()282 }283284 /// Stop: the server cancels the run (so the provider call really ends) and what was generated is kept.285 func stop(notifyServer: Bool = true) {286 guard isStreaming else { return }287 streamTask?.cancel(); streamTask = nil288 flushTask?.cancel(); flushTask = nil289 accumulator.markCancelled()290 let partial = accumulator.message; let run = runId291 if let partial { messages.append(partial) }292 live = nil; phase = .idle; runId = nil293 guard notifyServer else { return }294 Task {295 try? await env.api.cancelGeneration(runId: run, messageId: partial?.id)296 try? await Task.sleep(for: .milliseconds(600))297 await reload(attach: false)298 }299 }300301 // MARK: Streaming display (throttled)302303 /// Tokens arrive far faster than the screen refreshes: the accumulator absorbs every event, the observable304 /// `live` message is refreshed at most ~30 times per second.305 private func scheduleFlush() {306 guard flushTask == nil else { return }307 flushTask = Task { [weak self] in308 try? await Task.sleep(for: .milliseconds(33))309 guard let self, !Task.isCancelled else { return }310 self.flushTask = nil; self.live = self.accumulator.message311 }312 }313 private func flushNow() { flushTask?.cancel(); flushTask = nil; if isStreaming { live = accumulator.message } }314315 // MARK: Versions, fork316317 func versions(of message: Message) -> [Message] { detail?.versions(of: message) ?? [message] }318319 func showVersion(_ target: Message) async {320 guard let id = conversationId, !isStreaming else { return }321 do { try await env.api.activateBranch(conversationId: id, messageId: target.id); await reload(attach: false) } catch { env.toasts.error(error) }322 }323324 /// Copies the thread up to `message` into a new conversation and returns its id.325 func fork(at message: Message, label: String? = nil) async -> String? {326 guard let id = conversationId else { return nil }327 do { let c = try await env.api.forkConversation(id, at: message.id, label: label); await env.conversations.refresh(); return c.id } catch { env.toasts.error(error); return nil }328 }329330 // MARK: Draft (kept on the server, resumed on any device)331332 private var draftScope: String { conversationId ?? (projectId.map { "new:\($0)" } ?? "new") }333 private func setDraftSilently(_ text: String) { suppressDraftSave = true; draft = text; suppressDraftSave = false }334 private func scheduleDraftSave() {335 guard !suppressDraftSave else { return }336 draftTask?.cancel()337 let scope = draftScope; let text = draft; let ids = pending.compactMap(\.attachment?.id)338 draftTask = Task { [api = env.api, outbox = env.outbox] in339 try? await Task.sleep(for: .milliseconds(900))340 guard !Task.isCancelled else { return }341 do { try await api.saveDraft(scope: scope, text: text, attachmentIds: ids); await outbox.discard(scope: scope) }342 catch let e as APIError where e.isNetwork { await outbox.keep(PendingDraft(scope: scope, text: text, attachmentIds: ids)) } // offline: kept locally, pushed when back online343 catch {}344 }345 }346 private func adoptDraftAttachments(_ atts: [Attachment]) {347 for a in atts where !pending.contains(where: { $0.attachment?.id == a.id }) { pending.append(PendingAttachment(filename: a.filename, mime: a.mime, size: a.sizeBytes ?? 0, state: .ready(a))) }348 }349 private func rememberChoices() {350 let p = env.preferences351 p.modelId = settings.modelId; p.routingMode = settings.routingMode; p.effort = settings.effort; p.toolsEnabled = settings.toolsEnabled; p.presetId = settings.presetId; p.webSearch = settings.webSearch352 }353354 // MARK: Sync, model switching, suggestion355356 /// Another device changed this conversation (sync feed): re-read it, and follow a generation started elsewhere.357 func syncRefresh() async { guard conversationId != nil, didLoad, !isStreaming else { return }; await reload(attach: true) }358359 /// A draft changed on another device: adopt it only when the composer here is empty (never overwrite what is being typed).360 func syncDraft() async {361 guard didLoad, !isStreaming, draft.isEmpty, let d = try? await env.api.draft(scope: draftScope), draft.isEmpty, !d.text.isEmpty else { return }362 setDraftSilently(d.text); adoptDraftAttachments(d.attachments)363 }364365 /// Picks a model for the next turns (chip, picker, dock, palette, `@`): manual routing, no preset, effort kept when the model accepts it.366 func selectModel(_ m: AIModel) {367 settings.presetId = nil; settings.routingMode = .manual; settings.modelId = m.id368 if let e = settings.effort, let levels = m.effortLevels, !levels.isEmpty, !levels.contains(e.rawValue) { settings.effort = nil }369 if suggestion?.decision?.selected == m.id { suggestion = nil }370 }371 var currentModel: AIModel? { env.catalog.model(settings.modelId) }372 /// What the next turn will run on, for the composer chip: a model, a routing mode or a preset.373 var modelIdentity: ModelIdentity { env.catalog.identity(for: settings.modelId, short: true) }374375 /// Asks the server's router (advisory mode) which verified model it would pick for the text being written.376 /// Debounced, only for substantial drafts, never switches anything.377 func refreshSuggestion() {378 let text = draft.trimmingCharacters(in: .whitespacesAndNewlines)379 guard env.preferences.suggestModel, settings.presetId == nil, settings.routingMode == .manual, text.count >= 24, !text.hasPrefix("/") else { suggestionTask?.cancel(); suggestion = nil; return }380 guard text != suggestionFor else { return }381 suggestionTask?.cancel()382 suggestionTask = Task { [weak self] in383 try? await Task.sleep(for: .milliseconds(1400))384 guard let self, !Task.isCancelled else { return }385 let hasImages = self.pending.contains { $0.mime.hasPrefix("image/") }386 guard let s = try? await self.env.api.suggestRoute(text: text, hasImages: hasImages, wantsTools: self.settings.webSearch), !Task.isCancelled else { return }387 self.suggestionFor = text388 // only worth showing when it differs from the current choice389 self.suggestion = (s.decision?.selected).flatMap { $0 != self.settings.modelId && self.env.catalog.model($0) != nil ? s : nil }390 }391 }392 func dismissSuggestion() { suggestion = nil }393394 /// Sends a Smart Follow-Up as the next message.395 func sendFollowUp(_ text: String) { guard !isStreaming else { return }; draft = text; send() }396397 /// Inserts text at the end of the composer (prompt library, dictation).398 func appendToDraft(_ text: String) { draft = draft.isEmpty ? text : draft + (draft.hasSuffix("\n") ? "" : "\n") + text }399400 // MARK: Attachments401402 func addFiles(_ urls: [URL]) {403 let limit = env.catalog.settings.limits404 let room = limit.maxFilesPerMessage - pending.count405 guard room > 0 else { env.toasts.show("\(limit.maxFilesPerMessage) fichiers au maximum par message.", isError: true); return }406 if urls.count > room { env.toasts.show("Seuls les \(room) premiers fichiers ont été ajoutés.", isError: true) }407 for url in urls.prefix(room) {408 Task {409 switch await AttachmentService.prepare(url: url, maxUploadMb: limit.maxUploadMb, compressImages: env.preferences.compressImages) {410 case .success(let file): upload(file)411 case .failure(let r): env.toasts.show(r.description, isError: true)412 }413 }414 }415 }416417 func addData(_ data: Data, filename: String) {418 let limit = env.catalog.settings.limits419 guard pending.count < limit.maxFilesPerMessage else { env.toasts.show("\(limit.maxFilesPerMessage) fichiers au maximum par message.", isError: true); return }420 switch AttachmentService.prepare(data: data, filename: filename, maxUploadMb: limit.maxUploadMb, compressImages: env.preferences.compressImages) {421 case .success(let file): upload(file)422 case .failure(let r): env.toasts.show(r.description, isError: true)423 }424 }425426 private func upload(_ file: UploadFile) {427 let item = PendingAttachment(filename: file.filename, mime: file.mime, size: file.data.count, state: .uploading(0))428 pending.append(item)429 let id = item.id430 Task {431 do {432 let a = try await env.files.upload(file, conversationId: conversationId, projectId: conversationId == nil ? projectId : nil) { [weak self] fraction in433 Task { @MainActor in self?.setState(id, .uploading(fraction)) }434 }435 setState(id, .ready(a)); scheduleDraftSave()436 } catch { setState(id, .failed((error as? LocalizedError)?.errorDescription ?? "Échec de l'envoi")) }437 }438 }439 private func setState(_ id: UUID, _ state: PendingAttachment.State) {440 guard let i = pending.firstIndex(where: { $0.id == id }) else { return }441 if case .ready = pending[i].state, case .uploading = state { return } // a late progress callback never downgrades a finished upload442 pending[i].state = state443 }444 func removePending(_ item: PendingAttachment) {445 pending.removeAll { $0.id == item.id }446 if let a = item.attachment { Task { try? await env.api.deleteAttachment(a.id) } }447 scheduleDraftSave()448 }449450 // MARK: Conversation-level actions451452 func rename(_ title: String) async {453 let t = title.trimmingCharacters(in: .whitespacesAndNewlines)454 guard let id = conversationId, !t.isEmpty else { return }455 do { try await env.conversations.update(id, ConversationPatch(title: t)); conversation?.title = t } catch { env.toasts.error(error) }456 }457}458