buzzert
4389f805f4
TestFlight / Build and upload (push) Successful in 5m29s
Integrate the shared Agent room, durable outbox, cursor replay and read state on iPhone and iPad. Reuse message rendering with native messaging layout and expandable tool details. Validated with 58 Xcode package tests, six Simulator UI scenarios, read-only production connectivity and independent review.
328 lines
18 KiB
Swift
328 lines
18 KiB
Swift
import Foundation
|
|
import Testing
|
|
@testable import Sybil
|
|
|
|
private func agentMessage(_ id: String, entry: String, role: MessageRole = .assistant, info: [String: JSONValue] = [:]) -> Message {
|
|
Message(id: id, createdAt: Date(timeIntervalSince1970: 1_700_000_000), role: role, content: "Message \(id)", metadata: .object(["kind": .string(role == .tool ? "tool_call" : "message"), "entryId": .string(entry)].merging(info, uniquingKeysWith: { _, b in b })))
|
|
}
|
|
private func agentPage(_ messages: [Message], cursor: String, more: Bool = false) -> AgentPage {
|
|
AgentPage(conversationId: "root", messages: messages, cursor: cursor, beforeCursor: nil, hasMore: more)
|
|
}
|
|
|
|
private final class MemoryOutbox: @unchecked Sendable {
|
|
private let lock = NSLock()
|
|
private var rows: [AgentOutboxRow] = []
|
|
var storage: AgentOutboxStorage {
|
|
AgentOutboxStorage(read: { self.read() }, write: { self.save($0) })
|
|
}
|
|
func read() -> [AgentOutboxRow] { lock.withLock { rows } }
|
|
func save(_ value: [AgentOutboxRow]) { lock.withLock { rows = value } }
|
|
}
|
|
private actor ControlledAgentSocket: AgentSocket {
|
|
let stream: AsyncThrowingStream<Data, any Error>
|
|
let continuation: AsyncThrowingStream<Data, any Error>.Continuation
|
|
private(set) var closed = false
|
|
init() { (stream, continuation) = AsyncThrowingStream.makeStream() }
|
|
func receive() async throws -> Data {
|
|
var iterator = stream.makeAsyncIterator()
|
|
guard let data = try await iterator.next() else { throw CancellationError() }
|
|
return data
|
|
}
|
|
func send(_ text: String) {}
|
|
func close() { closed = true; continuation.finish(throwing: URLError(.networkConnectionLost)) }
|
|
func closeCode() -> Int { 0 }
|
|
func push(_ text: String) { continuation.yield(Data(text.utf8)) }
|
|
}
|
|
private actor TestAgentClient: AgentAPIClienting {
|
|
var pages: [String: AgentPage]
|
|
var requests: [String] = []
|
|
var submissions: [(String, String)] = []
|
|
var read = "0"
|
|
var failRead = false
|
|
var failSubmit = false
|
|
var malformedReceipt = false
|
|
var socketAfters: [String] = []
|
|
var sockets: [ControlledAgentSocket] = []
|
|
var holdRead = false
|
|
var heldRead: CheckedContinuation<AgentReadState, Never>?
|
|
var beforeSubmit: (@Sendable () -> Bool)?
|
|
init(pages: [String: AgentPage] = [:]) { self.pages = pages }
|
|
func agentDescriptor() -> AgentDescriptor {
|
|
AgentDescriptor(id: "root", title: "Sybil Agent", type: "persistent-agent", model: "test", protocol: "pi-room.v1", activity: AgentActivity(), websocket: "/v1/agent/ws")
|
|
}
|
|
func agentMessages(after: String?, before: String?) -> AgentPage {
|
|
let cursor = after ?? "0"; requests.append(cursor)
|
|
return pages[cursor] ?? agentPage([], cursor: cursor)
|
|
}
|
|
func agentReadState() async -> AgentReadState {
|
|
if holdRead { return await withCheckedContinuation { heldRead = $0 } }
|
|
return AgentReadState(cursor: read)
|
|
}
|
|
func pauseRead() { holdRead = true }
|
|
func releaseRead() { holdRead = false; heldRead?.resume(returning: AgentReadState(cursor: read)); heldRead = nil }
|
|
func hasHeldRead() -> Bool { heldRead != nil }
|
|
func agentMarkRead(cursor: String) throws -> AgentReadState {
|
|
if failRead { throw AgentFailure(message: "Offline") }
|
|
read = try AgentCursor.advance(read, cursor)
|
|
return AgentReadState(cursor: read)
|
|
}
|
|
func agentSubmit(content: String, requestID: String) async throws -> AgentReceipt {
|
|
#expect(beforeSubmit?() ?? true)
|
|
submissions.append((content, requestID))
|
|
try await Task.sleep(for: .milliseconds(80))
|
|
if failSubmit { throw AgentFailure(message: "Lost acknowledgement") }
|
|
return AgentReceipt(id: 1, status: "queued", messageId: malformedReceipt ? "wrong" : "inbound:sybil:\(requestID)")
|
|
}
|
|
func agentSocket(after: String) async -> any AgentSocket {
|
|
socketAfters.append(after)
|
|
let socket = ControlledAgentSocket(); sockets.append(socket)
|
|
await socket.push(#"{"type":"ready","conversationId":"root"}"#)
|
|
return socket
|
|
}
|
|
func connectedAfters() -> [String] { socketAfters }
|
|
func latestSocket() -> ControlledAgentSocket? { sockets.last }
|
|
func setFailures(submit: Bool = false, read: Bool = false, malformed: Bool = false) { failSubmit = submit; failRead = read; malformedReceipt = malformed }
|
|
func requirePersisted(_ check: @escaping @Sendable () -> Bool) { beforeSubmit = check }
|
|
func submittedIDs() -> [String] { submissions.map(\.1) }
|
|
func requestedCursors() -> [String] { requests }
|
|
}
|
|
|
|
@MainActor
|
|
private func eventually(_ predicate: () -> Bool) async -> Bool {
|
|
for _ in 0..<200 {
|
|
if predicate() { return true }
|
|
try? await Task.sleep(for: .milliseconds(10))
|
|
}
|
|
return false
|
|
}
|
|
|
|
struct AgentTests {
|
|
@Test func cursorAndMalformedFrames() throws {
|
|
#expect(try AgentCursor.normalize("00012") == "12")
|
|
#expect(try AgentCursor.advance("9", "10") == "10")
|
|
#expect(try AgentCursor.advance("9007199254740993", "9007199254740992") == "9007199254740993")
|
|
#expect(throws: (any Error).self) { try AgentCursor.normalize("-1") }
|
|
var state = AgentRoomState()
|
|
try state.apply(agentPage([agentMessage("reply", entry: "10")], cursor: "10"))
|
|
let original = state
|
|
#expect(throws: (any Error).self) { try state.apply(agentPage([], cursor: "bad")) }
|
|
#expect(state == original)
|
|
#expect(throws: (any Error).self) { try AgentEvent.decode(Data(#"{"type":"messages","conversationId":"root","cursor":"99","beforeCursor":null,"hasMore":false,"messages":[{"id":"broken"}]}"#.utf8)) }
|
|
#expect(state.cursor == "10")
|
|
let oversizedDuration = agentMessage("tool", entry: "11", role: .tool, info: ["durationMs": .number(1e100)])
|
|
#expect(oversizedDuration.toolCallMetadata?.durationMs == nil)
|
|
}
|
|
|
|
@Test func terminalToolAndRestSocketRace() throws {
|
|
let start = agentMessage("tool:1", entry: "5", role: .tool, info: ["status": .string("initiated"), "toolName": .string("search"), "args": .object(["query": .string("fixture")]), "startedAt": .string("start")])
|
|
var end = agentMessage("tool:1", entry: "8", role: .tool, info: ["status": .string("failed"), "error": .string("fixture failure"), "resultPreview": .string("detail"), "args": .object([:])])
|
|
end.createdAt.addTimeInterval(5)
|
|
var state = AgentRoomState()
|
|
try state.apply(agentPage([start], cursor: "5"))
|
|
try state.apply(agentPage([end, agentMessage("reply", entry: "9")], cursor: "9"))
|
|
try state.apply(agentPage([start], cursor: "5"))
|
|
#expect(state.cursor == "9")
|
|
#expect(state.messages.count == 2)
|
|
let tool = try #require(state.messages.first?.toolCallMetadata)
|
|
#expect(tool.status == "failed")
|
|
#expect(tool.error == "fixture failure")
|
|
#expect(tool.args == .object(["query": .string("fixture")]))
|
|
#expect(tool.startedAt == "start")
|
|
#expect(state.messages.first?.createdAt == start.createdAt)
|
|
}
|
|
|
|
@Test func unreadExcludesToolsAndUsers() throws {
|
|
var state = AgentRoomState()
|
|
try state.apply(agentPage([agentMessage("a", entry: "9"), agentMessage("b", entry: "10"), agentMessage("u", entry: "11", role: .user), agentMessage("t", entry: "12", role: .tool)], cursor: "12"))
|
|
state.readCursor = "9"
|
|
#expect(state.unreadCount == 1)
|
|
state.readCursor = try AgentCursor.advance(state.readCursor, "12")
|
|
state.readCursor = try AgentCursor.advance(state.readCursor, "2")
|
|
#expect(state.unreadCount == 0)
|
|
}
|
|
|
|
@Test func typingReplyAndStaleActivityAreAtomic() throws {
|
|
var presentation = AgentPresentation(), state = AgentRoomState()
|
|
let now = Date(timeIntervalSince1970: 100)
|
|
var busy = AgentActivity(); busy.isThinking = true; busy.backgroundWorkers = 1
|
|
var after = state; after.activity = busy
|
|
presentation.receive(.activity("root", busy), before: state, after: after, replay: false, now: now)
|
|
state = after
|
|
#expect(!presentation.isTyping(now: now.addingTimeInterval(0.249)))
|
|
#expect(presentation.isTyping(now: now.addingTimeInterval(0.251)))
|
|
let reply = agentPage([agentMessage("reply", entry: "1")], cursor: "1")
|
|
try after.apply(reply)
|
|
presentation.receive(.messages(reply), before: state, after: after, replay: false, now: now.addingTimeInterval(1))
|
|
state = after
|
|
#expect(!presentation.isTyping(now: now.addingTimeInterval(2)))
|
|
#expect(state.activity.isBusy)
|
|
presentation.receive(.activity("root", busy), before: state, after: state, replay: false, now: now.addingTimeInterval(3))
|
|
#expect(!presentation.isTyping(now: now.addingTimeInterval(4)))
|
|
for name in AgentPresentation.quietTools {
|
|
busy.tools.append(.init(id: name, name: name, status: "initiated"))
|
|
presentation.receive(.activity("root", busy), before: state, after: state, replay: false, now: now.addingTimeInterval(5))
|
|
#expect(!presentation.isTyping(now: now.addingTimeInterval(6)))
|
|
}
|
|
busy.tools.append(.init(id: "real", name: "search", status: "initiated"))
|
|
presentation.receive(.activity("root", busy), before: state, after: state, replay: false, now: now.addingTimeInterval(7))
|
|
#expect(presentation.isTyping(now: now.addingTimeInterval(7.3)))
|
|
}
|
|
|
|
@Test func socketURLAndAuthentication() throws {
|
|
let config = APIConfiguration(baseURL: URL(string: "https://sybil.bajor.cloud/api/?accidental=query")!, authToken: " token ")
|
|
#expect(try config.agentWebSocketURL().absoluteString == "wss://sybil.bajor.cloud/api/v1/agent/ws")
|
|
let frame = try JSONDecoder().decode(JSONValue.self, from: Data(config.agentAuthFrame(after: "0009").utf8))
|
|
#expect(frame.objectValue?["token"] == .string("token"))
|
|
#expect(frame.objectValue?["after"] == .string("9"))
|
|
let open = APIConfiguration(baseURL: URL(string: "http://localhost:8787")!, authToken: nil)
|
|
let openFrame = try JSONDecoder().decode(JSONValue.self, from: Data(open.agentAuthFrame(after: "0").utf8))
|
|
#expect(openFrame.objectValue?["token"] == .null)
|
|
}
|
|
|
|
@Test @MainActor func emptyPagesAndInitialHistoryDoNotAnimate() async throws {
|
|
let client = TestAgentClient(pages: ["0": agentPage([], cursor: "3", more: true), "3": agentPage([], cursor: "7", more: true), "7": agentPage([agentMessage("reply", entry: "8")], cursor: "8")])
|
|
let room = SybilAgentRoom(); room.configure(client: client, storage: MemoryOutbox().storage)
|
|
defer { room.stop() }
|
|
#expect(await eventually { !room.isLoading })
|
|
#expect(await client.requestedCursors() == ["0", "3", "7"])
|
|
#expect(room.snapshot.room.cursor == "8")
|
|
#expect(room.unreadCount == 1)
|
|
#expect(room.snapshot.entranceIDs.isEmpty)
|
|
try room.receive(.messages(agentPage([agentMessage("late", entry: "9")], cursor: "9")))
|
|
room.flush()
|
|
#expect(room.snapshot.entranceIDs == ["late"])
|
|
try room.receive(.messages(agentPage([agentMessage("late", entry: "9")], cursor: "9")))
|
|
room.flush()
|
|
#expect(room.snapshot.entranceIDs.isEmpty)
|
|
#expect(room.messages.count == 2)
|
|
}
|
|
|
|
@Test @MainActor func outboxPersistsBeforePostAndEchoWinsFailure() async throws {
|
|
let memory = MemoryOutbox(), client = TestAgentClient()
|
|
await client.setFailures(submit: true)
|
|
await client.requirePersisted { !memory.read().isEmpty }
|
|
let room = SybilAgentRoom(); room.configure(client: client, storage: memory.storage)
|
|
defer { room.stop() }
|
|
#expect(await eventually { !room.isLoading })
|
|
#expect(room.send("identical")); #expect(room.send("identical"))
|
|
#expect(room.messages.count == 2)
|
|
let first = room.outbox[0], second = room.outbox[1]
|
|
#expect(first.requestID != second.requestID)
|
|
#expect(memory.read().count == 2)
|
|
try room.receive(.messages(agentPage([agentMessage(first.id, entry: "1", role: .user)], cursor: "1")))
|
|
room.flush()
|
|
#expect(await eventually { room.outbox[1].status == "failed" })
|
|
#expect(room.outbox[0].status == "complete")
|
|
#expect(room.messages.first(where: { $0.id == first.id })?.createdAt == first.createdAt)
|
|
room.retry(second.id)
|
|
#expect(await eventually { room.outbox[1].status == "failed" })
|
|
let ids = await client.submittedIDs()
|
|
#expect(ids.filter { $0 == second.requestID }.count == 2)
|
|
let restored = SybilAgentRoom(); restored.configure(client: client, storage: memory.storage)
|
|
defer { restored.stop() }
|
|
#expect(restored.outbox.count == 1)
|
|
#expect(restored.outbox[0].requestID == second.requestID)
|
|
#expect(restored.outbox[0].createdAt == second.createdAt)
|
|
}
|
|
|
|
@Test @MainActor func malformedReceiptAndStorageFailureRemainRetryable() async {
|
|
let client = TestAgentClient(); await client.setFailures(malformed: true)
|
|
let room = SybilAgentRoom(); room.configure(client: client, storage: MemoryOutbox().storage)
|
|
defer { room.stop() }
|
|
#expect(await eventually { !room.isLoading })
|
|
room.send("fixture")
|
|
#expect(await eventually { room.outbox.first?.status == "failed" })
|
|
#expect(room.outbox.first?.seenOnServer == false)
|
|
let failed = SybilAgentRoom()
|
|
failed.configure(client: client, storage: AgentOutboxStorage(read: { [] }, write: { _ in throw AgentFailure(message: "Disk full") }))
|
|
defer { failed.stop() }
|
|
failed.send("must not submit")
|
|
#expect(failed.outbox.first?.status == "failed")
|
|
#expect(await client.submittedIDs().count == 1)
|
|
}
|
|
|
|
@Test @MainActor func readOnlyAfterAcknowledgementAndCapturedSnapshot() async throws {
|
|
let client = TestAgentClient(pages: ["0": agentPage([agentMessage("a", entry: "1")], cursor: "1")])
|
|
let room = SybilAgentRoom(); room.configure(client: client, storage: MemoryOutbox().storage)
|
|
defer { room.stop() }
|
|
#expect(await eventually { !room.isLoading })
|
|
room.isSelected = true
|
|
await client.setFailures(read: true)
|
|
room.markRead(renderedCursor: "1")
|
|
#expect(await eventually { room.error != nil })
|
|
#expect(room.snapshot.room.readCursor == "0")
|
|
await client.setFailures()
|
|
try room.receive(.messages(agentPage([agentMessage("b", entry: "2")], cursor: "2")))
|
|
room.markRead(renderedCursor: "1")
|
|
#expect(await eventually { room.snapshot.room.readCursor == "1" })
|
|
#expect(room.unreadCount == 1)
|
|
room.isObscured = true; room.markRead(renderedCursor: "2")
|
|
try? await Task.sleep(for: .milliseconds(100))
|
|
#expect(room.snapshot.room.readCursor == "1")
|
|
try room.applyRead(AgentReadState(cursor: "2")); room.flush()
|
|
#expect(room.unreadCount == 0)
|
|
room.setActive(false); room.setActive(true)
|
|
#expect(await eventually { room.connection == "Connecting" })
|
|
#expect(room.messages.count == 2)
|
|
}
|
|
@Test @MainActor func interruptedAdmissionForegroundKeepsRetryIdentity() async throws {
|
|
let client = TestAgentClient(), memory = MemoryOutbox()
|
|
let room = SybilAgentRoom(); room.configure(client: client, storage: memory.storage)
|
|
defer { room.stop() }
|
|
#expect(await eventually { room.connection == "Connected" })
|
|
room.send("interrupted fixture")
|
|
let original = try #require(room.outbox.first)
|
|
room.setActive(false)
|
|
#expect(room.outbox.first?.status == "failed")
|
|
#expect(memory.read().first?.requestID == original.requestID)
|
|
room.setActive(true)
|
|
#expect(await eventually { room.connection == "Connected" })
|
|
room.retry(original.id)
|
|
#expect(await eventually { room.outbox.first?.seenOnServer == true })
|
|
#expect(room.outbox.first?.createdAt == original.createdAt)
|
|
#expect(await client.submittedIDs().allSatisfy { $0 == original.requestID })
|
|
}
|
|
|
|
@Test @MainActor func disconnectCannotRestartOldClientAndStaleReadCannotPoisonNewRun() async throws {
|
|
let old = TestAgentClient(); await old.pauseRead()
|
|
let room = SybilAgentRoom(); room.configure(client: old, storage: MemoryOutbox().storage)
|
|
for _ in 0..<100 {
|
|
if await old.hasHeldRead() { break }
|
|
try? await Task.sleep(for: .milliseconds(10))
|
|
}
|
|
room.disconnect()
|
|
room.setActive(false); room.setActive(true)
|
|
#expect(await old.connectedAfters().isEmpty)
|
|
let next = TestAgentClient(pages: ["0": agentPage([agentMessage("new", entry: "2")], cursor: "2")])
|
|
room.configure(client: next, storage: MemoryOutbox().storage)
|
|
defer { room.stop() }
|
|
#expect(await eventually { room.connection == "Connected" })
|
|
await old.releaseRead()
|
|
try? await Task.sleep(for: .milliseconds(50))
|
|
try await room.catchUp(client: next)
|
|
#expect(room.messages.map(\.id) == ["new"])
|
|
#expect(await next.requestedCursors() == ["0", "2"])
|
|
#expect(await old.connectedAfters().isEmpty)
|
|
}
|
|
|
|
@Test @MainActor func socketReplayAfterForegroundDeduplicatesAndRetainsMergedCursor() async throws {
|
|
let client = TestAgentClient()
|
|
let room = SybilAgentRoom(); room.configure(client: client, storage: MemoryOutbox().storage)
|
|
defer { room.stop() }
|
|
#expect(await eventually { room.connection == "Connected" })
|
|
let socket = try #require(await client.latestSocket())
|
|
let frame = #"{"type":"messages","conversationId":"root","messages":[{"id":"late","createdAt":"2026-10-14T18:00:00Z","role":"assistant","content":"Late reply","metadata":{"kind":"message","entryId":7}}],"cursor":"7","beforeCursor":null,"hasMore":false}"#
|
|
await socket.push(frame)
|
|
#expect(await eventually { room.snapshot.room.cursor == "7" })
|
|
room.setActive(false); room.setActive(true)
|
|
#expect(await eventually { room.connection == "Connected" })
|
|
let next = try #require(await client.latestSocket())
|
|
await next.push(frame)
|
|
try? await Task.sleep(for: .milliseconds(150))
|
|
#expect(await client.connectedAfters() == ["0", "7"])
|
|
#expect(room.messages.count == 1)
|
|
#expect(await socket.closed)
|
|
}
|
|
|
|
}
|