Files
hapi/ios/Packages/HapiKit/Sources/HapiProtocol/Chat/Reducer.swift
T
52ac85a3ba feat(ios): expand session creation and chat status surfaces
- Fetch Claude models from the machine catalog, expose the full grouped picker with per-model efforts, and remember launch defaults.
- Add directory quick-create, known-directory suggestions, live machine CPU/memory in filters, and the DeepSeek agent icon.
- Add the collapsible session status card (goal, tasks, subagents, terminals, team), context-usage meter, and compaction/background/fast/collaboration composer chips without the redundant inline model controls.
- Add code block line numbers, wrapping and collapse; per-message share and rewind; a floating session search that does not push the list; and move sign out to the bottom of Settings.

via [HAPI](https://hapi.run)

Co-Authored-By: HAPI <noreply@hapi.run>

Co-Authored-By: Claude Code <noreply@anthropic.com>
2026-11-08 11:59:29 +08:00

187 lines
6.7 KiB
Swift

import Foundation
// Port of web/src/chat/reducer.ts — the pipeline entry point:
// trace → timeline → pending-permission synthesis → latestUsage →
// api-error fold → dedupe → silent-goal filtering.
/// Port of `calculateContextSize`.
private func calculateContextSize(_ usage: UsageData) -> Double {
if let contextTokens = usage.contextTokens {
return contextTokens
}
return (usage.cacheCreationInputTokens ?? 0) + (usage.cacheReadInputTokens ?? 0) + usage.inputTokens
}
/// Some Claude-compatible providers emit assistant snapshots with an all-zero
/// usage object after long tool runs. Looking through them prevents the
/// context bar from resetting to 0%.
private func hasContextUsageSignal(_ usage: UsageData) -> Bool {
(usage.contextTokens ?? 0) > 0
|| usage.inputTokens > 0
|| (usage.cacheCreationInputTokens ?? 0) > 0
|| (usage.cacheReadInputTokens ?? 0) > 0
}
/// Port of `isUsageVisibleInParentContext` — subagent usage must not drive
/// the parent thread's context bar.
private func isUsageVisibleInParentContext(_ msg: NormalizedMessage) -> Bool {
if msg.isSidechain { return false }
return msg.usage?.scopeRole != "child"
}
private let goalCommandRegex = JSRegex("\\A\\s*/goal(?:\\s|\\z)", caseInsensitive: true)
/// Port of `getLatestThreadGoal`. Returns the normalized goal record
/// (advisory; not part of the fixture projection).
func getLatestThreadGoal(_ normalized: [NormalizedMessage]) -> JSONValue? {
var sawNewerNonGoalUserMessage = false
for msg in normalized.reversed() {
if case .user(let text, _) = msg.content {
if !goalCommandRegex.test(text) {
sawNewerNonGoalUserMessage = true
}
continue
}
guard let event = msg.eventContent else { continue }
if event.type == "thread-goal-cleared" { return nil }
if event.type == "thread-goal-updated" {
let goal = event["goal"]
if goal?["status"] == .string("complete") && sawNewerNonGoalUserMessage {
return nil
}
return goal
}
}
return nil
}
/// Port of `isRedundantGoalStatusMessage`.
private func isRedundantGoalStatusMessage(_ event: AgentEvent) -> Bool {
guard event.type == "message" else { return false }
return isRedundantGoalStatusMessageText(event["message"]?.stringValue)
}
/// Port of `isSilentGoalEventBlock`.
private func isSilentGoalEventBlock(_ block: ChatBlock) -> Bool {
guard case .agentEvent(let eventBlock) = block else { return false }
return eventBlock.event.type == "thread-goal-updated"
|| eventBlock.event.type == "thread-goal-cleared"
|| isRedundantGoalStatusMessage(eventBlock.event)
}
/// Port of `filterSilentGoalBlocks` — recursive over tool children.
func filterSilentGoalBlocks(_ blocks: [ChatBlock]) -> [ChatBlock] {
var filtered: [ChatBlock] = []
for block in blocks {
if isSilentGoalEventBlock(block) { continue }
if case .toolCall(var toolBlock) = block, !toolBlock.children.isEmpty {
toolBlock.children = filterSilentGoalBlocks(toolBlock.children)
filtered.append(.toolCall(toolBlock))
continue
}
filtered.append(block)
}
return filtered
}
/// Result of `reduceChatBlocks`.
public struct ReducedChat: Equatable, Sendable {
public var blocks: [ChatBlock]
public var hasReadyEvent: Bool
public var latestUsage: LatestUsage?
/// The latest thread goal record (advisory, dropped by the projection).
public var latestGoal: JSONValue?
}
/// Port of `reduceChatBlocks`.
public func reduceChatBlocks(
_ normalized: [NormalizedMessage],
agentState: AgentState?,
goalStateMessages: [NormalizedMessage]? = nil
) -> ReducedChat {
let permissionsById = getPermissions(agentState)
let toolIdsInMessages = collectToolIdsFromMessages(normalized)
let titleChangesByToolUseId = collectTitleChanges(normalized)
let traced = traceMessages(normalized)
var groups: [String: [NormalizedMessage]] = [:]
var root: [NormalizedMessage] = []
for msg in traced {
if let sidechainId = msg.sidechainId {
groups[sidechainId, default: []].append(msg)
} else {
root.append(msg)
}
}
let reducerContext = ReducerContext(
permissionsById: permissionsById,
groups: groups,
consumedGroupIds: [],
titleChangesByToolUseId: titleChangesByToolUseId,
emittedTitleChangeToolUseIds: []
)
var rootResult = reduceTimeline(root, context: reducerContext)
let hasReadyEvent = rootResult.hasReadyEvent
// Synthesize a tool card only for a *pending* permission that has no
// tool call/result in the transcript, and only when it is not older than
// the oldest message in the current window (older ones surface when the
// user pages back).
let oldestMessageTime: Int? = normalized.map(\.createdAt).min()
for (id, entry) in permissionsById.entriesInOrder {
if entry.permission.status != .pending { continue }
if toolIdsInMessages.contains(id) { continue }
if rootResult.toolBlocksById[id] != nil { continue }
let createdAt = entry.permission.createdAt
?? Int(Date().timeIntervalSince1970 * 1000)
if let oldestMessageTime, createdAt < oldestMessageTime {
continue
}
ensureToolBlock(&rootResult.blocks, &rootResult.toolBlocksById, id: id, seed: ToolBlockSeed(
createdAt: createdAt,
localId: nil,
name: entry.toolName,
input: entry.input,
description: nil,
permission: entry.permission
))
}
// Latest usage: the most recent parent-context message with usage data.
var latestUsage: LatestUsage?
for msg in normalized.reversed() {
if let usage = msg.usage,
isUsageVisibleInParentContext(msg),
hasContextUsageSignal(usage) {
latestUsage = LatestUsage(
inputTokens: usage.inputTokens,
outputTokens: usage.outputTokens,
cacheCreation: usage.cacheCreationInputTokens ?? 0,
cacheRead: usage.cacheReadInputTokens ?? 0,
contextSize: calculateContextSize(usage),
contextWindow: usage.contextWindow,
model: msg.model,
timestamp: msg.createdAt
)
break
}
}
let materialized = rootResult.blocks.materialized
return ReducedChat(
blocks: filterSilentGoalBlocks(dedupeAgentEvents(foldApiErrorEvents(materialized))),
hasReadyEvent: hasReadyEvent,
latestUsage: latestUsage,
latestGoal: getLatestThreadGoal(goalStateMessages ?? normalized)
)
}