SPB Git

Repository Public

ChatViewModel.swift 26.3 KB 458 lines swift

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
Files main
Menu

Theme