CodexBar 是一个 macOS 菜单栏应用,用于查看本机 Codex 账号状态、额度、Token 用量、详细统计信息
Swift appkitcodexcodex-clideveloper-toolsmacosmacos-appmenu-bar-appopenai-codexproductivityswiftswiftuiusage-tracker
import Foundation
import Testing
struct AppServerActivityTests {
private let now = TestFixtures.now
@Test(arguments: ["item/started", "item/completed"], [[], ["synthetic reasoning"]] as [[String]])
func reasoningContentPreservesActivity(method: String, content: [String]) throws {
var reducer = try prepared()
let text = try #require(String(data: JSONEncoder().encode(content), encoding: .utf8))
let input = try message(method, params: """
{"threadId":"main","turnId":"turn","item":{"id":"reasoning","type":"reasoning","summary":[],"content":\(text)}}
""")
#expect(input.params.item?.type == .reasoning)
#expect(input.params.item?.questionReplies == nil)
#expect(reducer.consume(input, now: now).isEmpty)
#expect(reducer.states.values.first?.presentation?.summary.current.key == (method == "item/started" ? "thinking" : "processing"))
}
@Test func paginatedReasoningContentDecodes() throws {
let page = try TestFixtures.decode(ActivityItemsPage.self, #"""
{"data":[{"turnId":"turn","item":{"id":"reasoning","type":"reasoning","summary":[],"content":["synthetic reasoning"]}}]}
"""#)
#expect(page.data.first?.item.type == .reasoning)
let turn = try TestFixtures.decode(ActivityTurn.self, #"""
{"id":"turn","status":"inProgress","items":[{"id":"reasoning","type":"reasoning","summary":[],"content":["synthetic reasoning"]}]}
"""#)
#expect(turn.items?.first?.type == .reasoning)
}
@Test func protocolBoundaryNormalizesStatusAndTimeUnits() throws {
let input = try TestFixtures.decode(ActivityInput.self, """
{"method":"turn/completed","params":{"threadId":"thread","turn":{"id":"turn","status":"completed","startedAt":1000,"completedAt":1002,"durationMs":1500}}}
""")
#expect(input.kind == .turnFinished)
#expect(input.params.turn?.status == .completed)
#expect(input.params.turn?.startedAt == Date(timeIntervalSince1970: 1000))
#expect(input.params.turn?.duration == 1.5)
let unknown = try TestFixtures.decode(ActivityInput.self, "{\"method\":\"future/event\",\"params\":{}}")
#expect(unknown.kind == .ignored)
}
private func thread(_ id: String = "main", source: String = #""cli""#) throws -> ActivityThread {
try TestFixtures.decode(ActivityThread.self, """
{"id":"\(id)","cwd":"/test","model":"gpt-5","reasoningEffort":"high","createdAt":\(now.timeIntervalSince1970),
"status":{"type":"active","activeFlags":[]},"source":\(source)}
""")
}
private func turn(_ id: String = "turn", status: String = "inProgress") -> ActivityTurn {
ActivityTurn(id: id, status: ActivityTurnStatus(rawValue: status == "inProgress" ? "running" : status) ?? .unknown, rootTurnId: id, startedAt: now)
}
private func message(_ method: String, params: String, id: Int? = nil) throws -> ActivityInput {
var fields = try #require(JSONSerialization.jsonObject(with: Data(params.utf8)) as? [String: Any])
if method.hasSuffix("/requestApproval"), fields["startedAtMs"] == nil {
fields["startedAtMs"] = now.timeIntervalSince1970 * 1000
}
var envelope: [String: Any] = ["method": method, "params": fields]
if let id {
envelope["id"] = id
}
return try JSONDecoder().decode(ActivityInput.self, from: JSONSerialization.data(withJSONObject: envelope))
}
private func prepared() throws -> AppServerActivityReducer {
var reducer = AppServerActivityReducer()
_ = try reducer.reconcile(thread: thread(), turns: [turn()], now: now)
return reducer
}
@Test(arguments: [
"item/started", "item/completed", "thread/tokenUsage/updated",
"item/commandExecution/requestApproval", "item/fileChange/requestApproval", "item/permissions/requestApproval",
"item/agentMessage/delta", "item/reasoning/textDelta", "item/reasoning/summaryTextDelta", "item/commandExecution/outputDelta"
], [nil, ""] as [String?])
func turnScopedNotificationsRejectMissingIdentity(_ method: String, turnID: String?) throws {
var params: [String: Any] = ["threadId": "main", "itemId": "item", "item": ["id": "item", "type": "commandExecution"]]
if let turnID {
params["turnId"] = turnID
}
let json = try #require(String(data: JSONSerialization.data(withJSONObject: params), encoding: .utf8))
#expect(throws: DecodingError.self) { try message(method, params: json) }
}
@Test(arguments: [
"item/agentMessage/delta", "item/reasoning/textDelta", "item/reasoning/summaryTextDelta",
"item/commandExecution/outputDelta"
])
func recognizedProgressOnlyRefreshesActivity(_ method: String) throws {
var reducer = try prepared()
_ = try reducer.consume(message("item/commandExecution/requestApproval", params: """
{"threadId":"main","turnId":"turn","itemId":"command"}
""", id: 1), now: now)
reducer.applyTokenUsage(TokenUsageThreadSnapshot(threadID: "main", position: 1, turns: ["turn": TestFixtures.tokenUsage(10)]))
let tokens = reducer.tokenUsageTurns
let later = now.addingTimeInterval(30)
let events = try reducer.consume(message(method, params: """
{"threadId":"main","turnId":"turn","itemId":"item","delta":"Test response"}
"""), now: later)
let state = try #require(reducer.states.values.first)
#expect(state.lastProgressAt == later)
#expect(state.isWaitingApproval == true)
#expect(state.approvalChangedAt == now)
#expect(events.isEmpty)
#expect(reducer.tokenUsageTurns == tokens)
#expect(state.tokenUsage?.totalTokens == 10)
}
@Test(arguments: [
"thread/settings/updated", "thread/environment/connected", "thread/environment/disconnected",
"item/plan/delta", "item/autoApprovalReview/started", "item/autoApprovalReview/completed",
"item/fileChange/outputDelta", "item/future/delta", "item/future/outputDelta", "hook/delta", "command/exec/outputDelta",
"process/outputDelta", "item/reasoning/textDelta/extra", "item/agentMessage/Delta"
])
func unknownMethodsCannotRefreshActivity(_ method: String) throws {
var reducer = try prepared()
let events = try reducer.consume(message(method, params: """
{"threadId":"main","turnId":"turn","delta":"Test response"}
"""), now: now.addingTimeInterval(30))
let state = try #require(reducer.states.values.first)
#expect(AppServerActivityProtocol.kind(for: method).category == .ignored)
#expect(state.lastProgressAt == now)
#expect(events.isEmpty)
#expect(reducer.tokenUsageTurns.isEmpty)
}
@Test(arguments: ["agentMessage", "reasoning", "userMessage", "plan", "subAgentActivity"])
func nonToolsNeverIncreaseToolCalls(_ type: String) throws {
var reducer = try prepared()
let events = try reducer.consume(message("item/completed", params: """
{"threadId":"main","turnId":"turn","item":{"id":"item","type":"\(type)","kind":"interacted","agentThreadId":"child"}}
"""), now: now)
#expect(events.isEmpty)
}
@Test(
arguments: ["commandExecution", "fileChange", "webSearch", "imageView", "imageGeneration", "sleep", "mcpToolCall", "dynamicToolCall", "collabAgentToolCall"],
[false, true]
)
func toolStartAndEndPreserveOneInvocation(_ type: String, hasToolName: Bool) throws {
var reducer = try prepared()
let expectedTool = hasToolName && type != "commandExecution" ? "test" : nil
let toolField = hasToolName ? #""tool":"test","# : ""
let params = """
{"threadId":"main","turnId":"turn","item":{"id":"item","type":"\(type)",\(toolField)"status":"completed"}}
"""
let started = try reducer.consume(message("item/started", params: params), now: now)
let ended = try reducer.consume(message("item/completed", params: params), now: now)
#expect(started.first?.eventKind == .toolStarted)
#expect(started.first?.context?.method == "item/started")
#expect(started.first?.context?.threadID == "main")
#expect(started.first?.context?.itemType == type)
#expect(started.first?.toolName == expectedTool)
#expect(ended.first?.toolName == expectedTool)
#expect(ended.first?.eventKind == .toolCompleted)
#expect(started.first?.name == "toolStarted")
#expect(started.first?.id == "main:turn:item:toolStarted")
#expect(ended.first?.name == "toolCompleted")
#expect(ended.first?.id == "main:turn:item:toolCompleted")
#expect(try reducer.consume(message("item/completed", params: params), now: now).isEmpty)
var accumulator = ActivityDataAccumulator(rebuilding: CodexDateFormat.dayString(from: now))
for event in started + ended {
accumulator.record(event)
}
#expect(accumulator.finalized(identifierStorage: .retained).metrics.toolCallCount == 1)
let event = try #require(started.first)
let data = try AppServerEventRecord(activityData: event, recordedAt: now).jsonLineData()
let object = try #require(JSONSerialization.jsonObject(with: data) as? [String: Any])
let activity = try #require(object["activityData"] as? [String: Any])
#expect(activity["toolName"] as? String == expectedTool)
#expect(activity["tool"] == nil)
#expect(activity["commandActionTypes"] == nil)
#expect((object["context"] as? [String: Any])?["itemType"] as? String == type)
let restored = try #require(AppServerEventRecord.decode(from: data).activityData)
#expect(restored.toolName == expectedTool)
#expect(restored.context?.itemType == type)
}
@Test(arguments: ["item/started", "item/completed"])
func commandActionTypesKeepRawOrderAndLocalizeDisplay(_ method: String) throws {
var reducer = try prepared()
let events = try reducer.consume(message(method, params: """
{"threadId":"main","turnId":"turn","item":{"id":"command","type":"commandExecution","commandActions":[
{"type":"search","command":"private command","query":"private query"},
{"type":"unknown","command":"private command"},
{"type":"read","name":"private file","path":"/private/file"},
{"type":"search"},{"type":"listFiles"},{"type":"read"}
]}}
"""), now: now)
let event = try #require(events.first)
let data = try AppServerEventRecord(activityData: event, recordedAt: now).jsonLineData()
let storedText = try #require(String(data: data, encoding: .utf8))
#expect(!storedText.contains("private"))
let object = try #require(JSONSerialization.jsonObject(with: data) as? [String: Any])
let payload = try #require(object["activityData"] as? [String: Any])
#expect(payload["commandActionTypes"] as? [String] == ["search", "unknown", "read", "search", "listFiles", "read"])
#expect(payload["commandActions"] == nil)
#expect(payload["toolName"] == nil)
#expect(payload["tool"] == nil)
let restored = try #require(AppServerEventRecord.decode(from: data).activityData)
let approval = ActivityApproval(
requestedAt: now, toolName: restored.toolName, sequence: 0,
itemType: restored.context?.itemType, commandActionTypes: restored.commandActionTypes
)
#expect(restored.toolName == nil)
#expect(restored.commandActionTypes == ["search", "unknown", "read", "search", "listFiles", "read"])
#expect(approval.commandActionTypes == restored.commandActionTypes)
let expectedDisplay = String(localized: "activity.live.actions-read-listfiles-search")
#expect(approval.actionText == expectedDisplay)
#expect(restored.context?.itemType == "commandExecution")
#expect(restored.eventKind == (method == "item/started" ? .toolStarted : .toolCompleted))
}
@Test(arguments: ["", #", "commandActions":null"#, #", "commandActions":[]"#, #", "commandActions":[{"type":"unknown"},{"type":"unknown"}]"#])
func commandWithoutKnownActionsFallsBackToItemType(_ actions: String) throws {
var reducer = try prepared()
let events = try reducer.consume(message("item/started", params: """
{"threadId":"main","turnId":"turn","item":{"id":"command","type":"commandExecution"\(actions)}}
"""), now: now)
let event = try #require(events.first)
let approval = ActivityApproval(
requestedAt: now, toolName: event.toolName, sequence: 0,
itemType: event.context?.itemType, commandActionTypes: event.commandActionTypes
)
#expect(event.toolName == nil)
#expect(approval.actionText == String(localized: "activity.action.command"))
}
@Test(arguments: ["item/started", "item/completed"])
func parsedCommandSummaryStaysOutOfHistory(_ method: String) throws {
var reducer = try prepared()
let input = try message(method, params: #"""
{"threadId":"main","turnId":"turn","item":{"id":"command","type":"commandExecution",
"commandActions":[{"type":"unknown","command":"/private/path/private_tool private_argument"}]}}
"""#)
#expect(input.params.item?.commandSummary == .tool("private_tool"))
let event = try #require(reducer.consume(input, now: now).first)
#expect(event.toolName == nil)
#expect(event.commandActionTypes == ["unknown"])
let data = try AppServerEventRecord(activityData: event).jsonLineData()
let text = try #require(String(data: data, encoding: .utf8))
#expect(!text.contains("private"))
#expect(!text.contains("commandSummary"))
}
@Test(arguments: ["actual_tool", "search/read"])
func commandActionTypesDoNotOverrideOtherToolNames(_ name: String) throws {
var reducer = try prepared()
let events = try reducer.consume(message("item/started", params: """
{"threadId":"main","turnId":"turn","item":{"id":"tool","type":"mcpToolCall","tool":"\(name)","commandActions":[{"type":"read"}]}}
"""), now: now)
let event = try #require(events.first)
#expect(event.toolName == name)
#expect(event.commandActionTypes == nil)
let restored = try #require(AppServerEventRecord.decode(from: AppServerEventRecord(activityData: event).jsonLineData()).activityData)
let approval = ActivityApproval(
requestedAt: now, toolName: restored.toolName, sequence: 0,
itemType: restored.context?.itemType, commandActionTypes: restored.commandActionTypes
)
#expect(approval.actionText == name)
}
@Test func approvalKeepsCommandActionTypesWhenAnotherToolUpdatesTheTask() throws {
var reducer = try prepared()
let started = try reducer.consume(message("item/started", params: """
{"threadId":"main","turnId":"turn","item":{"id":"command","type":"commandExecution","commandActions":[{"type":"read"},{"type":"search"}]}}
"""), now: now)
let event = try #require(started.first)
var task = try ActivityTask(
displayID: UUID(), key: #require(ActivityTaskKey(event: event)), event: event,
state: .running, startedAt: now, progressGeneration: 0
)
let approvals = try reducer.consume(message("item/commandExecution/requestApproval", params: """
{"threadId":"main","turnId":"turn","itemId":"command","commandActions":[{"type":"read"},{"type":"search"}]}
""", id: 1), now: now.addingTimeInterval(1))
let approval = try #require(approvals.first)
let restored = try #require(AppServerEventRecord.decode(from: AppServerEventRecord(activityData: approval).jsonLineData()).activityData)
let enteredWaiting = task.recordApprovalRequest(from: restored)
#expect(enteredWaiting)
let others = try reducer.consume(message("item/started", params: """
{"threadId":"main","turnId":"turn","item":{"id":"other","type":"mcpToolCall","tool":"search/read"}}
"""), now: now.addingTimeInterval(2))
try task.mergeMetadata(from: #require(others.first))
try task.resumeExecution(from: #require(others.first))
#expect(task.state == .waitingApproval)
let lifecycle = try #require(reducer.states[ActivityTurnReference(threadID: "main", turnID: "turn")])
task.mergeExecutionLifecycle(lifecycle, owner: ActivityExecutionKey(agentThreadID: nil, turnID: "turn"))
#expect(task.displayedApproval?.toolName == nil)
#expect(task.displayedApproval?.commandActionTypes == ["read", "search"])
#expect(task.snapshot.approvalActionText == String(localized: "activity.live.actions-read-search"))
let notification = NotificationContent.taskWaiting(project: task.snapshot.projectName, actionText: task.snapshot.approvalActionText)
#expect(notification.body.contains(String(localized: "activity.live.actions-read-search")))
}
@Test func approvalResolutionDoesNotInventAnotherToolCall() throws {
var reducer = try prepared()
let events = try reducer.consume(message("item/commandExecution/requestApproval", params: """
{"threadId":"main","turnId":"turn","itemId":"command"}
""", id: 1), now: now)
#expect(events.first?.eventKind == .approvalRequested)
#expect(events.first?.context?.requestID != nil)
#expect(events.first?.context?.itemID == "command")
#expect(events.first?.context?.itemType == "commandExecution")
#expect(events.first?.toolName == nil)
let key = ActivityTurnReference(threadID: "main", turnID: "turn")
#expect(reducer.states[key]?.isWaitingApproval == true)
#expect(try reducer.consume(message("serverRequest/resolved", params: #"{"threadId":"main","requestId":1}"#), now: now).isEmpty)
#expect(reducer.states[key]?.isWaitingApproval == false)
}
@Test func automaticReviewDoesNotCountRequest() throws {
var reducer = try prepared()
let events = try reducer.consume(message("item/autoApprovalReview/started", params: """
{"threadId":"main","turnId":"turn","targetItemId":"command","reviewId":"review"}
"""), now: now)
#expect(events.isEmpty)
#expect(reducer.states.values.first?.isWaitingApproval != true)
}
@Test func snapshotWaitingDoesNotInventHistoricalApprovalCount() throws {
var reducer = try prepared()
let events = try reducer.consume(message("thread/status/changed", params: """
{"threadId":"main","status":{"type":"active","activeFlags":["waitingOnApproval"]}}
"""), now: now)
#expect(events.isEmpty)
#expect(reducer.states.values.first?.isWaitingApproval == true)
}
@Test func detachedHistoryWithoutTerminalTimestampDoesNotEndLiveTask() throws {
var reducer = try prepared()
var detached = try thread()
detached.status = ActivityThreadStatus(type: .notLoaded)
_ = reducer.reconcile(thread: detached, turns: [turn(status: "interrupted")], now: now)
#expect(reducer.states.values.first?.terminal == nil)
#expect(reducer.states.values.first?.readStatus == .unavailable)
}
@Test func reconnectRestoresActiveSnapshotWithoutRecountingPrompt() throws {
var reducer = try prepared()
reducer.reconnect()
let events = try reducer.reconcile(thread: thread(), turns: [turn()], now: now, bootstrap: true)
#expect(events.count == 1)
#expect(events.first?.timestamp == now)
}
@Test func compactionAndSubagentActivitiesRetainTheirOwnMeaning() throws {
var reducer = try prepared()
let compact = try reducer.consume(message("item/completed", params: """
{"threadId":"main","turnId":"turn","item":{"id":"compact","type":"contextCompaction"}}
"""), now: now)
#expect(compact.first?.eventKind == .compactionCompleted)
let agent = try reducer.consume(message("item/completed", params: """
{"threadId":"main","turnId":"turn","item":{"id":"spawn","type":"subAgentActivity","kind":"started","agentThreadId":"child"}}
"""), now: now)
#expect(agent.first?.eventKind == .subagentStarted)
#expect(agent.first?.toolName == nil)
}
private func usageMessage(_ total: Int, last: Int = 1, thread: String = "main", turn: String = "turn") throws -> ActivityInput {
try message("thread/tokenUsage/updated", params: """
{"threadId":"\(thread)","turnId":"\(turn)","tokenUsage":{
"total":{"inputTokens":\(total),"cachedInputTokens":0,"outputTokens":0,"reasoningOutputTokens":0,"totalTokens":\(total)},
"last":{"inputTokens":\(last),"cachedInputTokens":0,"outputTokens":0,"reasoningOutputTokens":0,"totalTokens":\(last)}}}
""")
}
@Test func eventRecorderDeduplicatesAcrossInstancesAndRestarts() async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let first = ActivityDataRecorder(directoryURL: directory.url)
let second = ActivityDataRecorder(directoryURL: directory.url)
var reducer = try prepared()
let events = try reducer.consume(message("item/started", params: """
{"threadId":"main","turnId":"turn","item":{"id":"command","type":"commandExecution"}}
"""), now: now)
let event = try #require(events.first)
try await first.record(event: event)
try await second.record(event: event)
try await first.record(event: event)
var stored: [ActivityDataRecord] = []
try HistoryDatabase(directoryURL: directory.url).entries { entry in
let record = entry.record
if let event = record.activityData {
stored.append(event)
}
}
#expect(stored.count == 1)
}
@Test func multipleApprovalRequestsResolveIndependently() throws {
var reducer = try prepared()
let event = TestFixtures.event(at: now, thread: "main", turn: "turn")
var task = ActivityTask(displayID: UUID(), key: .init(thread: "main", turn: "turn"), event: event, state: .running, startedAt: now, progressGeneration: 0)
let reference = ActivityTurnReference(threadID: "main", turnID: "turn")
let owner = ActivityExecutionKey(agentThreadID: nil, turnID: "turn")
for id in [1, 2] {
let action = id == 1 ? "read" : "search"
_ = try reducer.consume(message("item/commandExecution/requestApproval", params: """
{"threadId":"main","turnId":"turn","itemId":"command-\(id)","commandActions":[{"type":"\(action)"}]}
""", id: id), now: now)
}
try task.mergeExecutionLifecycle(#require(reducer.states[reference]), owner: owner)
#expect(task.displayedApproval?.commandActionTypes == ["read"])
_ = try reducer.consume(message("serverRequest/resolved", params: #"{"threadId":"main","requestId":999}"#), now: now)
#expect(reducer.states[reference]?.pendingApprovals.count == 2)
_ = try reducer.consume(message("serverRequest/resolved", params: #"{"threadId":"main","requestId":1}"#), now: now)
#expect(reducer.states.values.first?.isWaitingApproval == true)
try task.mergeExecutionLifecycle(#require(reducer.states[reference]), owner: owner)
#expect(task.state == .waitingApproval)
#expect(task.displayedApproval?.commandActionTypes == ["search"])
_ = try reducer.consume(message("serverRequest/resolved", params: #"{"threadId":"main","requestId":2}"#), now: now)
#expect(reducer.states.values.first?.isWaitingApproval == false)
try task.mergeExecutionLifecycle(#require(reducer.states[reference]), owner: owner)
#expect(task.state == .running)
#expect(task.snapshot.approvalActionText == nil)
}
@Test(arguments: ["thread/status/changed", "turn/completed"])
func authoritativeStateClearsPendingRequests(method: String) throws {
var reducer = try prepared()
_ = try reducer.consume(message("item/commandExecution/requestApproval", params: #"{"threadId":"main","turnId":"turn","itemId":"command"}"#, id: 1), now: now)
let params = method == "turn/completed"
? #"{"threadId":"main","turn":{"id":"turn","status":"completed"}}"#
: #"{"threadId":"main","status":{"type":"active","activeFlags":[]}}"#
_ = try reducer.consume(message(method, params: params), now: now)
let state = try #require(reducer.states[ActivityTurnReference(threadID: "main", turnID: "turn")])
#expect(state.pendingApprovals.isEmpty)
#expect(state.isWaitingApproval == false)
}
@Test func eachChildTurnUsesItsDeclaredRoot() throws {
var reducer = try prepared()
var parentTurn = turn()
parentTurn.items = [ActivityItem(id: "spawn", type: .subAgentActivity, agentThreadId: "child", kind: "started", reasoningEffort: "low")]
_ = try reducer.reconcile(thread: thread(), turns: [parentTurn], now: now)
let child = try thread("child", source: #"{"subAgent":{"thread_spawn":{"parent_thread_id":"main"}}}"#)
var first = turn("child-turn")
first.rootTurnId = "turn"
_ = reducer.reconcile(thread: child, turns: [first], now: now)
let next = ActivityTurn(id: "next", status: .running, rootTurnId: "next", startedAt: now.addingTimeInterval(10))
_ = try reducer.reconcile(thread: thread(), turns: [next], now: now.addingTimeInterval(10))
var followup = turn("child-followup")
followup.rootTurnId = "next"
_ = reducer.reconcile(thread: child, turns: [followup], now: now.addingTimeInterval(11))
#expect(reducer.states[.init(threadID: "child", turnID: first.id)]?.rootTurnID == "turn")
let state = reducer.states[ActivityTurnReference(threadID: "child", turnID: followup.id)]
#expect(state?.rootThreadID == "main")
#expect(state?.rootTurnID == "next")
#expect(state?.effort == "high")
#expect(reducer.states[.init(threadID: "child", turnID: first.id)]?.effort == "mixed")
}
@Test func absentRootDoesNotInferFromParentTime() throws {
var reducer = try prepared()
let child = try thread("child", source: #"{"subAgent":{"thread_spawn":{"parent_thread_id":"main"}}}"#)
let unknown = ActivityTurn(id: "child-turn", status: .running, startedAt: now)
_ = reducer.reconcile(thread: child, turns: [unknown], now: now)
let state = reducer.states[.init(threadID: "child", turnID: unknown.id)]
#expect(state?.rootTurnID == nil)
#expect(state?.rootThreadID == nil)
}
@Test func lateRootResolvesNestedChildAndRetainsObservedTokens() throws {
var reducer = AppServerActivityReducer()
let child = try thread("child", source: #"{"subAgent":{"thread_spawn":{"parent_thread_id":"middle"}}}"#)
var childTurn = turn("child-turn")
childTurn.rootTurnId = "turn"
_ = reducer.reconcile(thread: child, turns: [childTurn], now: now)
#expect(reducer.missingRootTurns()["middle"] == ["turn"])
_ = try reducer.consume(usageMessage(15, thread: "child", turn: "child-turn"), now: now)
let pending = try #require(reducer.takeTokenUsageSamples().first)
#expect(pending.current.total.totalTokens == 15)
reducer.applyTokenUsage(TokenUsageThreadSnapshot(threadID: "child", position: 1, turns: ["child-turn": TestFixtures.tokenUsage(15)]))
_ = try reducer.reconcile(thread: thread(), turns: [turn()], now: now)
let state = reducer.states[.init(threadID: "child", turnID: childTurn.id)]
#expect(state?.rootThreadID == "main")
#expect(reducer.takeTokenUsageSamples().isEmpty)
#expect(state?.tokenUsage?.totalTokens == 15)
_ = try reducer.reconcile(thread: thread(), turns: [turn()], now: now)
#expect(reducer.takeTokenUsageSamples().isEmpty)
}
@Test func creationMetadataUsesChildModelWithoutInventingChildTurn() throws {
var reducer = try prepared()
let events = try reducer.consume(message("item/completed", params: """
{"threadId":"main","turnId":"turn","item":{"id":"spawn","type":"subAgentActivity","kind":"started",
"agentThreadId":"child","model":"child-model","reasoningEffort":"low"}}
"""), now: now)
let event = try #require(events.first)
#expect(event.model == "child-model")
#expect(event.effort == "low")
#expect(event.turnID == nil)
#expect(event.context?.turnID == "turn")
var accumulator = ActivityDataAccumulator(rebuilding: "2026-10-09")
accumulator.record(event)
#expect(accumulator.finalized(identifierStorage: .retained).modelCounts == ["child-model": 1])
let parentEvent = try #require(reducer.reconcile(thread: thread(), turns: [turn()], now: now, bootstrap: true).first)
var task = ActivityTask(displayID: UUID(), key: .init(thread: "main", turn: "turn"), event: parentEvent, state: .running, startedAt: now, progressGeneration: 0)
task.mergeMetadata(from: event)
#expect(task.modelName == "gpt-5")
#expect(task.effort == "mixed")
}
@Test func missingCreationMetadataDoesNotBorrowParentConfiguration() throws {
var reducer = try prepared()
let events = try reducer.consume(message("item/completed", params: """
{"threadId":"main","turnId":"turn","item":{"id":"spawn","type":"subAgentActivity","kind":"started","agentThreadId":"child"}}
"""), now: now)
let event = try #require(events.first)
#expect(event.model == nil)
#expect(event.effort == nil)
#expect(event.turnID == nil)
}
@Test func creationBeforeChildDiscoverySurvivesPruning() throws {
var reducer = try prepared()
_ = try reducer.consume(message("item/completed", params: """
{"threadId":"main","turnId":"turn","item":{"id":"spawn","type":"subAgentActivity","kind":"started",
"agentThreadId":"child","model":"child-model","reasoningEffort":"low"}}
"""), now: now)
var child = try thread("child", source: #"{"subAgent":{"thread_spawn":{"parent_thread_id":"main"}}}"#)
child.reasoningEffort = nil
var childTurn = turn("child-turn")
childTurn.rootTurnId = "turn"
_ = reducer.reconcile(thread: child, turns: [childTurn], now: now)
#expect(reducer.missingSubagentParents().isEmpty)
#expect(reducer.states[.init(threadID: "child", turnID: "child-turn")]?.effort == "low")
}
@Test func snapshotCreationMetadataBackfillsKnownChildWithoutRecounting() throws {
var reducer = try prepared()
var child = try thread("child", source: #"{"subAgent":{"thread_spawn":{"parent_thread_id":"main"}}}"#)
child.reasoningEffort = nil
var childTurn = turn("child-turn")
childTurn.rootTurnId = "turn"
_ = reducer.reconcile(thread: child, turns: [childTurn], now: now)
#expect(reducer.missingSubagentParents() == ["main"])
var parentTurn = turn()
parentTurn.items = [ActivityItem(id: "spawn", type: .subAgentActivity, agentThreadId: "child", kind: "started", model: "child-model", reasoningEffort: "low")]
let events = try reducer.reconcile(thread: thread(), turns: [parentTurn], now: now)
#expect(events.isEmpty)
#expect(reducer.missingSubagentParents().isEmpty)
#expect(reducer.states[.init(threadID: "child", turnID: "child-turn")]?.effort == "low")
}
@Test func threadReadReplacesConfigurationIncludingUnsetValues() throws {
var reducer = try prepared()
let events = try reducer.consume(message("thread/settings/updated", params: """
{"threadId":"main","threadSettings":{"model":"new-model","effort":"low","approvalsReviewer":"auto_review"}}
"""), now: now)
#expect(events.isEmpty)
var snapshot = try thread()
snapshot.cwd = "/updated"
snapshot.model = nil
snapshot.reasoningEffort = nil
_ = reducer.reconcile(thread: snapshot, turns: [turn()], now: now)
let command = try reducer.consume(message("item/started", params: """
{"threadId":"main","turnId":"turn","item":{"id":"command","type":"commandExecution"}}
"""), now: now)
#expect(command.first?.cwd == "/updated")
#expect(command.first?.model == nil)
#expect(command.first?.effort == nil)
}
}
extension AppServerActivityTests {
@Test(arguments: ["completed", "failed", "interrupted"])
func loadedTerminalWithoutTimestampEndsLiveTurn(status: String) throws {
var reducer = try prepared()
let idle = ActivityThread(id: "main", status: ActivityThreadStatus(type: .idle))
_ = reducer.reconcile(
thread: idle,
turns: [ActivityTurn(id: "turn", status: ActivityTurnStatus(rawValue: status == "inProgress" ? "running" : status) ?? .unknown)],
now: now.addingTimeInterval(30)
)
let state = try #require(reducer.states.values.first { $0.turnID == "turn" })
#expect(state.terminal != nil)
#expect(state.readStatus == .complete)
#expect(state.isHistoricalTerminal)
if case let .completed(at, duration) = state.terminal {
#expect(at == nil)
#expect(duration == nil)
}
}
@Test func unknownTurnStatusNeverFabricatesCompletion() throws {
var reducer = try prepared()
let events = try reducer.consume(message("turn/completed", params: #"{"threadId":"main","turn":{"id":"turn","status":"futureStatus"}}"#), now: now)
#expect(events.isEmpty)
#expect(reducer.states.values.first?.terminal == nil)
}
}
extension AppServerActivityTests {
@Test func repeatedHistoricalTerminalKeepsObservationTimeAndNotificationPolicy() throws {
var reducer = try prepared()
let idle = ActivityThread(id: "main", status: ActivityThreadStatus(type: .idle))
let completed = ActivityTurn(id: "turn", status: .completed)
_ = reducer.reconcile(thread: idle, turns: [completed], now: now)
_ = reducer.reconcile(thread: idle, turns: [completed], now: now.addingTimeInterval(60))
let state = try #require(reducer.states.values.first)
#expect(state.terminalObservedAt == now)
#expect(state.lastProgressAt == now)
#expect(state.isHistoricalTerminal)
}
}
extension AppServerActivityTests {
@Test(arguments: [true, false])
func distinctApprovalCallbacksArePersistedButReplayIsDeduplicated(hasApprovalID: Bool) async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
var reducer = try prepared()
let activityDataRecorder = ActivityDataRecorder(directoryURL: directory.url)
let date = Date()
var events: [ActivityDataRecord] = []
for (index, callback) in [1, 2, 1].enumerated() {
let started = date.timeIntervalSince1970 * 1000 + (hasApprovalID ? 0 : Double(callback))
let approval = hasApprovalID ? ",\"approvalId\":\"callback-\(callback)\"" : ""
let notification = try message("item/commandExecution/requestApproval", params: """
{"threadId":"main","turnId":"turn","itemId":"command","startedAtMs":\(started)\(approval)}
""", id: index)
events += reducer.consume(notification, now: date)
}
#expect(events.count == 2)
#expect(Set(events.compactMap(\.id)).count == 2)
for event in events + events {
try await activityDataRecorder.record(event: event)
}
var count = 0
try HistoryDatabase(directoryURL: directory.url).entries { entry in
let record = entry.record
if record.activityData?.eventKind == .approvalRequested {
count += 1
}
}
#expect(count == 2)
}
@Test func inactiveThreadMetadataExpiresWhileRunningAndLoadedThreadsRemain() throws {
var reducer = AppServerActivityReducer()
for index in 0 ..< 100 {
_ = try reducer.reconcile(thread: thread("old-\(index)"), turns: [turn(status: "completed")], now: now)
}
_ = try reducer.reconcile(thread: thread("running"), turns: [turn()], now: now)
_ = try reducer.reconcile(thread: thread("loaded"), turns: [turn(status: "completed")], now: now)
reducer.maintain(loadedThreads: ["loaded"], now: now.addingTimeInterval(2 * 86400))
#expect(Set(reducer.threads.keys) == ["running", "loaded"])
#expect(reducer.states.count == 1)
}
@Test func transientTurnUsageIsReleasedWithExpiredLifecycle() throws {
var reducer = try prepared()
reducer.applyTokenUsage(TokenUsageThreadSnapshot(threadID: "main", position: 1, turns: ["turn": TestFixtures.tokenUsage(100)]))
let completed = ActivityTurn(id: "turn", status: .completed, completedAt: now)
_ = try reducer.reconcile(thread: thread(), turns: [completed], now: now)
reducer.maintain(loadedThreads: [], now: now.addingTimeInterval(2 * 86400))
#expect(reducer.tokenUsageTurns.isEmpty)
}
}
extension AppServerActivityTests {
@Test func malformedApprovalCannotInventPersistentIdentity() throws {
#expect(throws: DecodingError.self) {
try TestFixtures.decode(ActivityInput.self, """
{"id":1,"method":"item/commandExecution/requestApproval","params":{"threadId":"main","turnId":"turn","itemId":"command"}}
""")
}
}
}
extension AppServerActivityTests {}