Repository Public
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