SPB Git

Repository Public

SSE.swift 11.9 KB 205 lines swift

1// Author: Simon-Pierre Boucher — contact@spboucher.ai2// File: SPChat/Core/Streaming/SSE.swift3// Description: Incremental Server-Sent Events parser and the typed chat events carried by the backend's generation streams.4import Foundation56public struct SSEEvent: Sendable, Equatable {7    public var event: String8    public var data: String9    /// The SSE `id:` field — index of the event inside its run, used to resume with `after=<index>`.10    public var index: Int?11    public init(event: String = "message", data: String, index: Int? = nil) { self.event = event; self.data = data; self.index = index }12}1314/// Byte-level SSE parser. Frames may be split anywhere (including inside a UTF-8 sequence): bytes are buffered until a15/// blank line closes the frame. Comment lines (`: ping` heartbeats) produce no event but count as activity.16public struct SSEParser: Sendable {17    private var buffer = Data()18    public private(set) var retryMs: Int?19    public init() {}2021    public mutating func feed(_ chunk: Data) -> [SSEEvent] {22        buffer.append(chunk)23        var events: [SSEEvent] = []24        while let range = Self.frameEnd(in: buffer) {25            let frame = buffer.subdata(in: buffer.startIndex..<range.lowerBound)26            buffer.removeSubrange(buffer.startIndex..<range.upperBound)27            if let ev = parse(frame) { events.append(ev) }28        }29        return events30    }3132    /// First blank line (`\n\n` or `\r\n\r\n`).33    private static func frameEnd(in data: Data) -> Range<Data.Index>? {34        let lf = data.range(of: Data([0x0a, 0x0a]))35        let crlf = data.range(of: Data([0x0d, 0x0a, 0x0d, 0x0a]))36        switch (lf, crlf) {37        case (let a?, let b?): return a.lowerBound < b.lowerBound ? a : b38        case (let a?, nil): return a39        case (nil, let b?): return b40        default: return nil41        }42    }4344    private mutating func parse(_ frame: Data) -> SSEEvent? {45        guard let text = String(data: frame, encoding: .utf8) else { return nil }46        var event = "message"; var data: [String] = []; var index: Int?47        for rawLine in text.split(omittingEmptySubsequences: false, whereSeparator: { $0 == "\n" || $0 == "\r\n" }) {48            let line = rawLine.hasSuffix("\r") ? rawLine.dropLast() : rawLine49            if line.isEmpty || line.hasPrefix(":") { continue }50            let field: Substring; var value: Substring51            if let colon = line.firstIndex(of: ":") { field = line[..<colon]; value = line[line.index(after: colon)...]; if value.hasPrefix(" ") { value = value.dropFirst() } }52            else { field = line; value = "" }53            switch field {54            case "event": event = String(value)55            case "data": data.append(String(value))56            case "id": index = Int(value.trimmingCharacters(in: .whitespaces))57            case "retry": retryMs = Int(value.trimmingCharacters(in: .whitespaces))58            default: break59            }60        }61        guard !data.isEmpty else { return nil }62        return SSEEvent(event: event, data: data.joined(separator: "\n"), index: index)63    }64}6566// MARK: - Typed chat events6768/// Events of a chat generation run (see `src/lib/chat/engine.ts` and `launch.ts` on the server).69public enum ChatEvent: Sendable, Equatable {70    case run(runId: String)71    case resync72    case conversation(id: String, created: Bool, userMessageId: String?, regenerated: String?, edited: String?, continued: String?)73    case start(messageId: String, model: String?, provider: String?, routing: Routing?, applied: JSONValue?)74    case text(String)75    case reasoning(String)76    case toolCall(ToolCall)77    case toolResult(id: String, status: ToolCallStatus, output: JSONValue?, error: String?, durationMs: Int?)78    case part(MessagePart)79    case artifacts([Artifact])80    case usage(TokenUsage?, costUsd: Double?, latencyMs: Int?, ttftMs: Int?, exactCost: Bool)81    case followups(messageId: String, suggestions: [String])82    case status(MessageStatus, error: String?, code: String?, stopReason: String?)83    case meta(servedBy: String?, retrying: String?)84    case title(String)85    case warning(String)86    case error(message: String, code: String?, partial: Bool)87    case done(MessageStatus?)88    case end89    case unknown(String)9091    public init(_ sse: SSEEvent) {92        let d = JSONValue.parse(Data(sse.data.utf8)) ?? .null93        func decode<T: Decodable>(_ type: T.Type, _ v: JSONValue?) -> T? {94            guard let v, !v.isNull, let data = try? JSONEncoder().encode(v) else { return nil }95            return try? JSONDecoder.api().decode(T.self, from: data)96        }97        switch sse.event {98        case "run": self = .run(runId: d["runId"]?.stringValue ?? "")99        case "resync": self = .resync100        case "conversation":101            self = .conversation(id: d["id"]?.stringValue ?? "", created: d["created"]?.boolValue ?? false, userMessageId: d["userMessageId"]?.stringValue,102                                 regenerated: d["regenerated"]?.stringValue, edited: d["edited"]?.stringValue, continued: d["continued"]?.stringValue)103        case "start": self = .start(messageId: d["messageId"]?.stringValue ?? "", model: d["model"]?.stringValue, provider: d["provider"]?.stringValue, routing: decode(Routing.self, d["routing"]), applied: d["applied"])104        case "text": self = .text(d["delta"]?.stringValue ?? "")105        case "reasoning": self = .reasoning(d["delta"]?.stringValue ?? "")106        case "tool_call":107            self = .toolCall(ToolCall(id: d["id"]?.stringValue ?? "", name: d["name"]?.stringValue ?? "?", input: d["input"] ?? .null, status: ToolCallStatus(rawValue: d["status"]?.stringValue ?? "running") ?? .running))108        case "tool_result":109            self = .toolResult(id: d["id"]?.stringValue ?? "", status: ToolCallStatus(rawValue: d["status"]?.stringValue ?? "ok") ?? .ok, output: d["output"], error: d["error"]?.stringValue, durationMs: d["durationMs"]?.intValue)110        case "part": if let p = decode(MessagePart.self, d) { self = .part(p) } else { self = .unknown("part") }111        case "artifacts":112            let arts = (d.arrayValue ?? []).compactMap { a -> Artifact? in113                guard let id = a["id"]?.stringValue else { return nil }114                return Artifact(id: id, rootId: id, version: 1, type: a["type"]?.stringValue ?? "text", language: a["language"]?.stringValue, title: a["title"]?.stringValue ?? "Artefact")115            }116            self = .artifacts(arts)117        case "usage": self = .usage(decode(TokenUsage.self, d["usage"]), costUsd: d["costUsd"]?.doubleValue, latencyMs: d["latencyMs"]?.intValue, ttftMs: d["ttftMs"]?.intValue, exactCost: d["exactCost"]?.boolValue ?? false)118        case "followups": self = .followups(messageId: d["messageId"]?.stringValue ?? "", suggestions: (d["suggestions"]?.arrayValue ?? []).compactMap(\.stringValue))119        case "status": self = .status(MessageStatus(rawValue: d["status"]?.stringValue ?? "complete"), error: d["error"]?.stringValue, code: d["code"]?.stringValue, stopReason: d["stopReason"]?.stringValue)120        case "meta":121            let retry: String? = d["retrying"].flatMap { $0.stringValue ?? $0.intValue.map(String.init) }122            self = .meta(servedBy: d["servedBy"]?.stringValue, retrying: retry)123        case "title": self = .title(d["title"]?.stringValue ?? "")124        case "warning": self = .warning(d["message"]?.stringValue ?? "")125        case "error": self = .error(message: d["message"]?.stringValue ?? "Erreur", code: d["code"]?.stringValue, partial: d["partial"]?.boolValue ?? false)126        case "done": self = .done(d["status"]?.stringValue.map(MessageStatus.init(rawValue:)))127        case "end": self = .end128        default: self = .unknown(sse.event)129        }130    }131}132133// MARK: - Accumulator134135/// Builds the assistant message of a run from its events. Pure and deterministic: replaying the same events (after a136/// reconnection the server replays from `after + 1`) yields the same message, and a repeated `start` is ignored.137public struct MessageAccumulator: Sendable, Equatable {138    public private(set) var message: Message?139    public private(set) var artifacts: [Artifact] = []140    public var conversationId: String141    public var parentId: String?142143    public init(conversationId: String, parentId: String? = nil, message: Message? = nil) { self.conversationId = conversationId; self.parentId = parentId; self.message = message }144145    /// Returns true when the visible message changed.146    @discardableResult147    public mutating func apply(_ event: ChatEvent, now: Date = Date()) -> Bool {148        switch event {149        case .start(let messageId, let model, let provider, let routing, let applied):150            if message?.id == messageId { return false }151            message = Message(id: messageId, conversationId: conversationId, parentId: parentId, role: .assistant, parts: [], text: "", modelId: model, provider: provider,152                              settings: applied.map { .object(["applied": $0]) }, routing: routing, status: .streaming, createdAt: now)153            artifacts = []154            return true155        case .resync:156            message = nil; return true157        default: break158        }159        guard var m = message else { return false }160        defer { message = m }161        switch event {162        case .text(let delta):163            if let last = m.parts.indices.last, case .text(let t) = m.parts[last] { m.parts[last] = .text(t + delta) } else { m.parts.append(.text(delta)) }164        case .reasoning(let delta):165            if let i = m.parts.firstIndex(where: { if case .reasoning = $0 { return true }; return false }), case .reasoning(let t, let s) = m.parts[i] { m.parts[i] = .reasoning(text: t + delta, summarized: s) }166            else { m.parts.insert(.reasoning(text: delta, summarized: true), at: 0) }167        case .toolCall(let call):168            if m.parts.contains(where: { if case .toolCall(let c) = $0 { return c.id == call.id }; return false }) { return false }169            m.parts.append(.toolCall(call))170        case .toolResult(let id, let status, let output, let error, let durationMs):171            guard let i = m.parts.firstIndex(where: { if case .toolCall(let c) = $0 { return c.id == id }; return false }), case .toolCall(var c) = m.parts[i] else { return false }172            c.status = status; c.output = output; c.error = error; c.durationMs = durationMs; m.parts[i] = .toolCall(c)173        case .part(let p):174            if m.parts.contains(p) { return false }175            m.parts.append(p)176        case .artifacts(let arts):177            for a in arts where !artifacts.contains(where: { $0.id == a.id }) {178                var a = a; a.messageId = m.id; a.createdAt = now; artifacts.append(a)179                m.parts.append(.artifact(artifactId: a.id, title: a.title, artifactType: a.type, language: a.language))180            }181        case .usage(let usage, let cost, let latency, let ttft, let exact):182            m.usage = usage; m.costUsd = cost; m.latencyMs = latency; m.ttftMs = ttft; m.exactCost = exact183        case .followups(let messageId, let suggestions):184            guard messageId.isEmpty || messageId == m.id else { return false }185            m.followups = suggestions186        case .status(let status, let error, let code, let stop):187            m.status = status; m.error = error; m.errorCode = code; m.stopReason = stop; m.text = m.visibleText188        case .meta(let servedBy, _):189            guard let servedBy else { return false }190            var r = m.routing ?? Routing(); r.servedBy = servedBy; m.routing = r191        case .error(let msg, let code, let partial):192            if m.status == .streaming { m.status = partial ? .incomplete : .error }193            m.error = msg; m.errorCode = code194        case .done(let status):195            guard m.status == .streaming else { return false }196            m.status = status ?? .complete; m.text = m.visibleText197        default: return false198        }199        return true200    }201202    /// Local stop: what was generated is kept and shown as cancelled until the server row is reloaded.203    public mutating func markCancelled() { if message?.status == .streaming { message?.status = .cancelled } }204}205
Files main
Menu

Theme