From 1efcc3183d3fd903e48e7f7d7c9bd1d5e4b338e7 Mon Sep 17 00:00:00 2001 From: weishu Date: Wed, 28 Oct 2026 15:52:46 +0800 Subject: [PATCH] feat(ios): switch models for every agent in session settings The settings sheet only had model pickers for Claude and Codex; other agents could not change models after creation. Live sessions now load /sessions/:id/-models. Agy uses its machine catalog, since it has no session route. As on web, grok and copilot skip terminal-controlled sessions. Rows follow web getModelOptionsForFlavor: - Copilot, dsh, grok and kimi offer a Default or Auto row that clears the model. - Cursor's Auto is the explicit 'auto' wire id. - Opencode, agy and pi only switch between listed models. - An unlisted current model stays visible. Pi resolves provider/modelId from metadata.piSelectedModel and switches with a {provider, modelId} reference. Efforts: - Grok and OpenCode options come from their *-reasoning-effort-options routes and reload after a model switch. OpenCode options that still describe the previous model stay hidden. - Pi shows the current model's thinking levels. The sheet's load-failure flag now covers every catalog, not just Codex. Co-Authored-By: Claude Opus 5.5 --- .../Features/Chat/SessionConfigModel.swift | 2 +- .../Chat/ChatInteractionState.swift | 78 ++++++++++++- .../HapiClient/Chat/ChatInteractor.swift | 107 ++++++++++++++++- .../Catalog/AgentModelCatalog.swift | 109 ++++++++++++++++++ .../HapiProtocol/Models/SessionMetadata.swift | 17 ++- .../AgentModelCatalogTests.swift | 100 ++++++++++++++++ .../Chat/ChatInteractorTests.swift | 67 +++++++++++ ios/README.md | 10 +- 8 files changed, 476 insertions(+), 14 deletions(-) diff --git a/ios/Hapi/Features/Chat/SessionConfigModel.swift b/ios/Hapi/Features/Chat/SessionConfigModel.swift index 1bdea6f9..ab2bcdaf 100644 --- a/ios/Hapi/Features/Chat/SessionConfigModel.swift +++ b/ios/Hapi/Features/Chat/SessionConfigModel.swift @@ -14,7 +14,7 @@ final class SessionConfigModel { var config: SessionConfigState { interactor.config } var isApplying: Bool { interactor.configOpPending } - var modelLoadFailed: Bool { interactor.codexModels == .failed } + var modelLoadFailed: Bool { config.modelLoadFailed } var showsModel: Bool { config.modelOptions != nil || config.modelOptionsLoading } var showsEffort: Bool { config.effortOptions?.isEmpty == false } var showsCollaborationMode: Bool { config.flavor == "codex" } diff --git a/ios/Packages/HapiKit/Sources/HapiClient/Chat/ChatInteractionState.swift b/ios/Packages/HapiKit/Sources/HapiClient/Chat/ChatInteractionState.swift index 1b872299..df433734 100644 --- a/ios/Packages/HapiKit/Sources/HapiClient/Chat/ChatInteractionState.swift +++ b/ios/Packages/HapiKit/Sources/HapiClient/Chat/ChatInteractionState.swift @@ -194,6 +194,14 @@ public enum CodexModelsState: Equatable, Sendable { case failed } +/// Load state of a discovered agent's catalog (`-models`). +public enum AgentCatalogLoadState: Equatable, Sendable { + case idle + case loading + case loaded(AgentModelsResponse) + case failed +} + /// Session config sheet model. public struct SessionConfigState: Equatable, Sendable { public let flavor: String? @@ -210,9 +218,12 @@ public struct SessionConfigState: Equatable, Sendable { public let model: String? /// nil → hide the model section (flavor without a known catalog). public let modelOptions: [CatalogOption]? - /// True while the codex model catalog loads (sheet shows a spinner row). + /// True while the model catalog loads (sheet shows a spinner row). public let modelOptionsLoading: Bool - /// Claude `effort` or codex `modelReasoningEffort`, whichever applies. + /// The catalog request failed (sheet offers Retry). + public let modelLoadFailed: Bool + /// `effort` (claude, grok, pi) or `modelReasoningEffort` (codex, + /// opencode), whichever applies. public let effort: String? /// nil → hide the effort section. public let effortOptions: [CatalogOption]? @@ -228,6 +239,7 @@ public struct SessionConfigState: Equatable, Sendable { model: String?, modelOptions: [CatalogOption]?, modelOptionsLoading: Bool, + modelLoadFailed: Bool = false, effort: String?, effortOptions: [CatalogOption]? ) { @@ -241,6 +253,7 @@ public struct SessionConfigState: Equatable, Sendable { self.model = model self.modelOptions = modelOptions self.modelOptionsLoading = modelOptionsLoading + self.modelLoadFailed = modelLoadFailed self.effort = effort self.effortOptions = effortOptions } @@ -251,15 +264,18 @@ public struct SessionConfigState: Equatable, Sendable { public func buildSessionConfigState( detail: Session?, summary: SessionSummary?, - codexModels: CodexModelsState + codexModels: CodexModelsState, + agentModels: AgentCatalogLoadState = .idle, + agentEfforts: ReasoningEffortOptionsResponse? = nil ) -> SessionConfigState { let flavor = detail?.metadata?.flavor ?? summary?.metadata?.flavor let active = detail?.active ?? summary?.active ?? false let controlledByUser = detail?.agentState?.controlledByUser == true && detail?.metadata?.capabilities?.concurrentClients != true - let model = detail?.model + var model = detail?.model var modelOptions: [CatalogOption]? var modelOptionsLoading = false + var modelLoadFailed = false var effort: String? var effortOptions: [CatalogOption]? @@ -288,8 +304,59 @@ public func buildSessionConfigState( case .loading: modelOptions = [] modelOptionsLoading = true - case .idle, .failed: + case .idle: modelOptions = [] + case .failed: + modelOptions = [] + modelLoadFailed = true + } + case let raw? where AgentModelCatalog.scope(for: AgentFlavor(rawValue: raw)) != nil: + // Discovered catalogs need a live session; idle stays hidden until + // the sheet asks for the catalog. + let agent = AgentFlavor(rawValue: raw) + guard active else { break } + switch agentModels { + case .idle: + break + case .loading: + modelOptions = [] + modelOptionsLoading = true + case .failed: + modelOptions = [] + modelLoadFailed = true + case .loaded(let response): + model = AgentModelCatalog.sessionCurrentModel( + flavor: agent, + response: response, + sessionModel: detail?.model, + piSelectedModel: detail?.metadata?.piSelectedModel + ) + modelOptions = AgentModelCatalog.sessionModelOptions( + flavor: agent, + response: response, + currentModel: model + ) + } + switch agent { + case .grok: + effort = detail?.effort + effortOptions = agentEfforts.map(AgentModelCatalog.grokSessionEffortOptions) + case .opencode: + effort = detail?.modelReasoningEffort + effortOptions = agentEfforts.map { response in + AgentModelCatalog.opencodeSessionEffortOptions( + response, + sessionModel: detail?.model, + currentValue: effort + ) + } + case .pi: + effort = detail?.effort + if case .loaded(let response) = agentModels { + effortOptions = AgentModelCatalog.piSessionEffortOptions(response: response, currentModel: model) + } + default: + break } default: modelOptions = nil // Generic fallback: hide the picker. @@ -306,6 +373,7 @@ public func buildSessionConfigState( model: model, modelOptions: modelOptions, modelOptionsLoading: modelOptionsLoading, + modelLoadFailed: modelLoadFailed, effort: effort, effortOptions: effortOptions ) diff --git a/ios/Packages/HapiKit/Sources/HapiClient/Chat/ChatInteractor.swift b/ios/Packages/HapiKit/Sources/HapiClient/Chat/ChatInteractor.swift index 99cadc85..9b0282c8 100644 --- a/ios/Packages/HapiKit/Sources/HapiClient/Chat/ChatInteractor.swift +++ b/ios/Packages/HapiKit/Sources/HapiClient/Chat/ChatInteractor.swift @@ -67,6 +67,10 @@ public final class ChatInteractor { public private(set) var windowState: MessageWindowState? /// Codex model catalog load state (feeds ``config``). public private(set) var codexModels: CodexModelsState = .idle + /// Discovered-agent model catalog (feeds ``config``). + public private(set) var agentModels: AgentCatalogLoadState = .idle + /// Grok/opencode in-session effort options (feeds ``config``). + public private(set) var agentEfforts: ReasoningEffortOptionsResponse? /// One config POST at a time (compare-and-set, like the Android /// `configOpPending`); exposed so the sheet can render a busy state. public private(set) var configOpPending = false @@ -719,7 +723,9 @@ public final class ChatInteractor { buildSessionConfigState( detail: sessionStore.detail(for: sessionId), summary: sessionStore.sessions.first { $0.id == sessionId }, - codexModels: codexModels + codexModels: codexModels, + agentModels: agentModels, + agentEfforts: agentEfforts ) } @@ -746,13 +752,35 @@ public final class ChatInteractor { ) } - /// `POST /model` — nil clears back to the agent default. + /// `POST /model` — nil clears back to the agent default. Pi switches + /// with a `{provider, modelId}` reference; grok/opencode efforts are + /// per model, so their options reload afterwards. public func setModel(_ model: String?) { let api = api let sessionId = sessionId + let agent = currentFlavor().map(AgentFlavor.init(rawValue:)) + var selection = model.map(ModelSelection.id) + var reference: PiModelReference? + if agent == .pi, let model, case .loaded(let response) = agentModels, + let row = AgentModelCatalog.selectedModel(response, flavor: .pi, value: model), + let provider = row.provider { + reference = PiModelReference(provider: provider, modelId: row.modelId) + selection = .catalogReference(provider: provider, modelId: row.modelId) + } + let wireSelection = selection runConfigChange( - optimistic: { $0.model = model }, - call: { try await api.setModel(sessionId: sessionId, model: model.map(ModelSelection.id)) } + optimistic: { session in + if let reference { + session.model = reference.modelId + session.metadata?.piSelectedModel = reference + } else { + session.model = model + } + }, + call: { try await api.setModel(sessionId: sessionId, model: wireSelection) }, + onSuccess: { [weak self] in + if agent == .grok || agent == .opencode { self?.loadEffortOptions(force: true) } + } ) } @@ -784,8 +812,15 @@ public final class ChatInteractor { ) } - /// Fetch the codex model catalog for the picker (no-op for other flavors). + /// Fetch the model catalog for the picker: codex per session, the + /// discovered agents per session (agy per machine), plus grok/opencode + /// effort options. Live sessions only for discovered agents; grok and + /// copilot also skip terminal-controlled ones (web query gates). public func loadModelOptions() { + if let flavor = currentFlavor(), flavor != "codex" { + loadAgentModels(AgentFlavor(rawValue: flavor)) + return + } guard currentFlavor() == "codex" else { return } switch codexModels { case .loading, .loaded: @@ -811,9 +846,68 @@ public final class ChatInteractor { } } + private func loadAgentModels(_ agent: AgentFlavor) { + guard AgentModelCatalog.scope(for: agent) != nil, catalogQueriesAllowed(agent) else { return } + loadEffortOptions(force: false) + switch agentModels { + case .loading, .loaded: + return + case .idle, .failed: + break + } + let machineId = sessionStore.detail(for: sessionId)?.metadata?.machineId + ?? sessionStore.sessions.first { $0.id == sessionId }?.metadata?.machineId + // agy has no session route; its catalog is the machine's. + if agent == .agy, machineId == nil { return } + agentModels = .loading + Task { [weak self] in + guard let self else { return } + do { + let response = if agent == .agy, let machineId { + try await self.api.machineAgentModels(machineId: machineId, flavor: .agy) + } else { + try await self.api.sessionAgentModels(sessionId: self.sessionId, flavor: agent) + } + if response.success { + self.agentModels = .loaded(response) + } else { + self.emit(.notice(response.error ?? "Failed to load models")) + self.agentModels = .failed + } + } catch { + self.emit(.notice(Self.errorMessage(error, fallback: "Failed to load models"))) + self.agentModels = .failed + } + } + } + + /// Grok/opencode effort options; best effort (a failure hides the field). + private func loadEffortOptions(force: Bool) { + guard let agent = currentFlavor().map(AgentFlavor.init(rawValue:)), + agent == .grok || agent == .opencode, + catalogQueriesAllowed(agent), + force || agentEfforts == nil else { return } + Task { [weak self] in + guard let self else { return } + self.agentEfforts = try? await self.api.sessionReasoningEffortOptions( + sessionId: self.sessionId, + flavor: agent + ) + } + } + + private func catalogQueriesAllowed(_ agent: AgentFlavor) -> Bool { + let detail = sessionStore.detail(for: sessionId) + guard currentSessionState().active else { return false } + let controlledByUser = detail?.agentState?.controlledByUser == true + && detail?.metadata?.capabilities?.concurrentClients != true + return !(controlledByUser && (agent == .grok || agent == .copilot)) + } + private func runConfigChange( optimistic: (inout Session) -> Void, - call: @escaping @Sendable () async throws -> Void + call: @escaping @Sendable () async throws -> Void, + onSuccess: (@MainActor () -> Void)? = nil ) { guard !configOpPending else { return } configOpPending = true @@ -823,6 +917,7 @@ public final class ChatInteractor { defer { self.configOpPending = false } do { try await call() + onSuccess?() } catch { // Roll back by rolling forward to server truth (an SSE patch // may have moved other fields since the optimistic write). diff --git a/ios/Packages/HapiKit/Sources/HapiProtocol/Catalog/AgentModelCatalog.swift b/ios/Packages/HapiKit/Sources/HapiProtocol/Catalog/AgentModelCatalog.swift index 8a50577e..68474fe7 100644 --- a/ios/Packages/HapiKit/Sources/HapiProtocol/Catalog/AgentModelCatalog.swift +++ b/ios/Packages/HapiKit/Sources/HapiProtocol/Catalog/AgentModelCatalog.swift @@ -143,6 +143,115 @@ public enum AgentModelCatalog { + list.map { NewSessionOption(value: $0, label: $0) } } + // MARK: - Session settings + + /// The current model as a picker value. Pi resolves `provider/modelId` + /// (metadata first, then the bare id); cursor collapses its auto + /// aliases; flavors without a Default row show the running model. + public static func sessionCurrentModel( + flavor: AgentFlavor, + response: AgentModelsResponse, + sessionModel: String?, + piSelectedModel: PiModelReference? + ) -> String? { + switch flavor { + case .pi: + if let reference = piSelectedModel { + return "\(reference.provider)/\(reference.modelId)" + } + guard let id = sessionModel ?? response.currentModelId else { return nil } + return listedModels(response, flavor: .pi) + .first { $0.modelId == id } + .map { modelValue($0, flavor: .pi) } ?? id + case .cursor: + let normalized = sessionModel?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() ?? "" + return ["", "auto", "default", "default[]"].contains(normalized) ? "auto" : sessionModel + case .opencode, .agy: + return sessionModel ?? response.currentModelId + default: + return sessionModel + } + } + + /// In-session model rows (web `getModelOptionsForFlavor`). `nil` clears + /// to the agent default where the flavor offers that; opencode, agy and + /// pi only switch between listed models. Empty hides the picker. + public static func sessionModelOptions( + flavor: AgentFlavor, + response: AgentModelsResponse, + currentModel: String? + ) -> [CatalogOption] { + let rows = listedModels(response, flavor: flavor).map { model in + CatalogOption(value: modelValue(model, flavor: flavor), label: modelLabel(model, flavor: flavor)) + } + let options: [CatalogOption] + switch flavor { + case .opencode, .agy, .pi: + options = rows + case .dsh: + options = rows.isEmpty ? [] : [CatalogOption(value: nil, label: "Default")] + rows + case .copilot: + options = [CatalogOption(value: nil, label: "Auto")] + rows + case .cursor: + // Cursor's Auto is an explicit wire id. + options = rows.isEmpty ? [] : [CatalogOption(value: "auto", label: "Auto")] + rows + case .grok, .kimi: + options = [CatalogOption(value: nil, label: "Default")] + rows + default: + options = [] + } + return withCurrentModelOption(options, current: currentModel) + } + + /// `withCurrentModelOption`: an unlisted current model stays visible, + /// right after the Default/Auto row. + public static func withCurrentModelOption(_ options: [CatalogOption], current: String?) -> [CatalogOption] { + guard !options.isEmpty, let current, !current.isEmpty, current != "auto", + !options.contains(where: { $0.value == current }) else { return options } + let first = options[0].value + var next = options + next.insert(CatalogOption(value: current, label: current), at: first == nil || first == "auto" ? 1 : 0) + return next + } + + /// Grok in-session efforts (`grok-reasoning-effort-options`). + public static func grokSessionEffortOptions(_ response: ReasoningEffortOptionsResponse) -> [CatalogOption] { + guard response.success, let options = response.options, !options.isEmpty else { return [] } + return [CatalogOption(value: nil, label: "Default")] + + options.map { CatalogOption(value: $0.value, label: $0.name ?? $0.value) } + } + + /// OpenCode in-session reasoning efforts. Empty (hidden) while the + /// options still describe another model than the session's. + public static func opencodeSessionEffortOptions( + _ response: ReasoningEffortOptionsResponse, + sessionModel: String?, + currentValue: String? + ) -> [CatalogOption] { + guard response.success, let options = response.options, !options.isEmpty, + response.currentModelId == (sessionModel ?? response.targetModelId) else { return [] } + var result = [CatalogOption(value: nil, label: "Default")] + if let currentValue, !options.contains(where: { $0.value == currentValue }) { + result.append(CatalogOption(value: currentValue, label: ModelCatalog.capitalizedFirst(currentValue))) + } + return result + options.map { + CatalogOption(value: $0.value, label: $0.name ?? ModelCatalog.capitalizedFirst($0.value)) + } + } + + /// Pi in-session thinking levels of the current model (no Default row); + /// nil while the model is unresolved or has no thinking levels. + public static func piSessionEffortOptions( + response: AgentModelsResponse, + currentModel: String? + ) -> [CatalogOption]? { + guard let model = selectedModel(response, flavor: .pi, value: currentModel), + model.reasoning != false else { return nil } + return piThinkingLevels(map: model.thinkingLevelMap).map { + CatalogOption(value: $0, label: piThinkingLevelLabel($0)) + } + } + // MARK: - Pi thinking levels (`shared/src/piThinkingLevel.ts`) public static let piThinkingLevelOrder = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] diff --git a/ios/Packages/HapiKit/Sources/HapiProtocol/Models/SessionMetadata.swift b/ios/Packages/HapiKit/Sources/HapiProtocol/Models/SessionMetadata.swift index f78f2689..831a5b19 100644 --- a/ios/Packages/HapiKit/Sources/HapiProtocol/Models/SessionMetadata.swift +++ b/ios/Packages/HapiKit/Sources/HapiProtocol/Models/SessionMetadata.swift @@ -78,6 +78,17 @@ public struct SessionCapabilities: Codable, Equatable, Sendable { } } +/// `metadata.piSelectedModel` and the Pi `{provider, modelId}` model switch. +public struct PiModelReference: Codable, Equatable, Sendable { + public var provider: String + public var modelId: String + + public init(provider: String, modelId: String) { + self.provider = provider + self.modelId = modelId + } +} + /// Typed subset of the session `metadata` blob (`MetadataSchema`, /// `shared/src/schemas.ts:54-163`) covering what the app renders. /// @@ -125,6 +136,8 @@ public struct SessionMetadata: Codable, Equatable, Sendable { public var kimiSessionId: String? public var copilotSessionId: String? public var piSessionId: String? + /// Pi model with its provider (`session.model` holds only the id). + public var piSelectedModel: PiModelReference? public init( path: String, @@ -151,7 +164,8 @@ public struct SessionMetadata: Codable, Equatable, Sendable { cursorSessionId: String? = nil, kimiSessionId: String? = nil, copilotSessionId: String? = nil, - piSessionId: String? = nil + piSessionId: String? = nil, + piSelectedModel: PiModelReference? = nil ) { self.path = path self.host = host @@ -178,5 +192,6 @@ public struct SessionMetadata: Codable, Equatable, Sendable { self.kimiSessionId = kimiSessionId self.copilotSessionId = copilotSessionId self.piSessionId = piSessionId + self.piSelectedModel = piSelectedModel } } diff --git a/ios/Packages/HapiKit/Tests/HapiClientTests/AgentModelCatalogTests.swift b/ios/Packages/HapiKit/Tests/HapiClientTests/AgentModelCatalogTests.swift index 7e4f8da5..323a8479 100644 --- a/ios/Packages/HapiKit/Tests/HapiClientTests/AgentModelCatalogTests.swift +++ b/ios/Packages/HapiKit/Tests/HapiClientTests/AgentModelCatalogTests.swift @@ -151,6 +151,106 @@ struct AgentModelCatalogTests { } } +@Suite("Agent model catalogs in session settings") +struct AgentSessionConfigTests { + private func detail( + flavor: String, + model: String? = nil, + effort: String? = nil, + modelReasoningEffort: String? = nil, + active: Bool = true, + piSelectedModel: PiModelReference? = nil + ) -> Session { + Session( + id: "s1", namespace: "default", seq: 1, createdAt: 1, updatedAt: 1, + active: active, activeAt: 1, + metadata: SessionMetadata(path: "/repo", host: "box", flavor: flavor, piSelectedModel: piSelectedModel), + metadataVersion: 1, agentState: nil, agentStateVersion: 1, thinking: false, thinkingAt: 0, + model: model, modelReasoningEffort: modelReasoningEffort, effort: effort + ) + } + + @Test func rowsPerFlavorKeepAnUnlistedCurrentModelVisible() { + let response = AgentModelsResponse(success: true, availableModels: [ + AgentModelSummary(modelId: "a", name: "A"), + AgentModelSummary(modelId: "b"), + ], currentModelId: "b") + #expect(AgentModelCatalog.sessionModelOptions(flavor: .grok, response: response, currentModel: "old") + == [CatalogOption(value: nil, label: "Default"), CatalogOption(value: "old", label: "old"), + CatalogOption(value: "a", label: "A"), CatalogOption(value: "b", label: "b")]) + #expect(AgentModelCatalog.sessionModelOptions(flavor: .opencode, response: response, currentModel: "b").map(\.value) + == ["a", "b"]) + #expect(AgentModelCatalog.sessionModelOptions(flavor: .dsh, response: AgentModelsResponse(success: true), currentModel: nil) + .isEmpty) + #expect(AgentModelCatalog.sessionModelOptions(flavor: .cursor, response: response, currentModel: "auto").first + == CatalogOption(value: "auto", label: "Auto")) + #expect(AgentModelCatalog.sessionCurrentModel(flavor: .cursor, response: response, sessionModel: "default[]", piSelectedModel: nil) + == "auto") + #expect(AgentModelCatalog.sessionCurrentModel(flavor: .opencode, response: response, sessionModel: nil, piSelectedModel: nil) + == "b") + } + + @Test func discoveredFlavorsStayHiddenUntilLoadedAndWhileInactive() { + let idle = buildSessionConfigState(detail: detail(flavor: "kimi"), summary: nil, codexModels: .idle) + #expect(idle.modelOptions == nil) + let loading = buildSessionConfigState(detail: detail(flavor: "kimi"), summary: nil, codexModels: .idle, + agentModels: .loading) + #expect(loading.modelOptionsLoading) + let failed = buildSessionConfigState(detail: detail(flavor: "kimi"), summary: nil, codexModels: .idle, + agentModels: .failed) + #expect(failed.modelLoadFailed) + let inactive = buildSessionConfigState(detail: detail(flavor: "kimi", active: false), summary: nil, + codexModels: .idle, agentModels: .failed) + #expect(inactive.modelOptions == nil && !inactive.modelLoadFailed) + } + + @Test func grokAndOpencodeEffortsComeFromTheirOptionRoutes() { + let grok = buildSessionConfigState( + detail: detail(flavor: "grok", effort: "high"), summary: nil, codexModels: .idle, + agentModels: .loaded(AgentModelsResponse(success: true)), + agentEfforts: ReasoningEffortOptionsResponse(success: true, options: [AgentReasoningEffortOption(value: "high", name: "High")]) + ) + #expect(grok.effort == "high") + #expect(grok.effortOptions == [CatalogOption(value: nil, label: "Default"), CatalogOption(value: "high", label: "High")]) + + let stale = ReasoningEffortOptionsResponse(success: true, options: [AgentReasoningEffortOption(value: "max")], + currentModelId: "old", targetModelId: "new") + let opencode = buildSessionConfigState( + detail: detail(flavor: "opencode", model: "new", modelReasoningEffort: "low"), summary: nil, + codexModels: .idle, agentModels: .loaded(AgentModelsResponse(success: true)), agentEfforts: stale + ) + #expect(opencode.effortOptions == [], "options for another model stay hidden") + var settled = stale + settled.currentModelId = "new" + let ready = buildSessionConfigState( + detail: detail(flavor: "opencode", model: "new", modelReasoningEffort: "low"), summary: nil, + codexModels: .idle, agentModels: .loaded(AgentModelsResponse(success: true)), agentEfforts: settled + ) + #expect(ready.effortOptions?.map(\.value) == [nil, "low", "max"]) + } + + @Test func piResolvesTheProviderAndItsThinkingLevels() { + let response = AgentModelsResponse(success: true, availableModels: [ + AgentModelSummary(modelId: "m", name: "M", provider: "a", reasoning: true, thinkingLevelMap: ["off": nil]), + AgentModelSummary(modelId: "m", name: "M", provider: "b", reasoning: false), + ]) + let fromMetadata = buildSessionConfigState( + detail: detail(flavor: "pi", model: "m", effort: "low", piSelectedModel: PiModelReference(provider: "b", modelId: "m")), + summary: nil, codexModels: .idle, agentModels: .loaded(response) + ) + #expect(fromMetadata.model == "b/m") + #expect(fromMetadata.modelOptions?.map(\.value) == ["a/m", "b/m"]) + #expect(fromMetadata.effortOptions == nil, "b/m has no thinking levels") + + let fromBareId = buildSessionConfigState( + detail: detail(flavor: "pi", model: "m", effort: "low"), + summary: nil, codexModels: .idle, agentModels: .loaded(response) + ) + #expect(fromBareId.model == "a/m") + #expect(fromBareId.effortOptions?.map(\.value) == ["minimal", "low", "medium", "high"]) + } +} + @Suite("Agent model endpoints") struct AgentModelEndpointTests { @Test func machineAndSessionRoutesCarryFlavorAndCwd() async throws { diff --git a/ios/Packages/HapiKit/Tests/HapiClientTests/Chat/ChatInteractorTests.swift b/ios/Packages/HapiKit/Tests/HapiClientTests/Chat/ChatInteractorTests.swift index 0e66260f..6810a942 100644 --- a/ios/Packages/HapiKit/Tests/HapiClientTests/Chat/ChatInteractorTests.swift +++ b/ios/Packages/HapiKit/Tests/HapiClientTests/Chat/ChatInteractorTests.swift @@ -1103,6 +1103,73 @@ struct ChatInteractorTests { }) } + // MARK: Discovered agent catalogs + + @Test func grokLoadsModelsAndEffortsAndReloadsEffortsAfterAModelSwitch() async throws { + let harness = try await ChatInteractionHarness(detail: chatDetail(flavor: "grok", model: "grok-4")) + await harness.performer.serve( + "GET", "/api/sessions/sess-1/grok-models", + json: #"{"success":true,"availableModels":[{"modelId":"grok-4","name":"Grok 4"},{"modelId":"grok-mini"}]}"# + ) + await harness.performer.serve( + "GET", "/api/sessions/sess-1/grok-reasoning-effort-options", + json: #"{"success":true,"options":[{"value":"high","name":"High"}]}"# + ) + + harness.interactor.loadModelOptions() + + #expect(await eventually { harness.interactor.config.modelOptions?.count == 3 }) + #expect(harness.interactor.config.modelOptions?.first == CatalogOption(value: nil, label: "Default")) + #expect(await eventually { harness.interactor.config.effortOptions?.map(\.value) == [nil, "high"] }) + + harness.interactor.setModel("grok-mini") + #expect(await eventually { + await harness.performer.bodies("POST", pathSuffix: "/api/sessions/sess-1/model") == [#"{"model":"grok-mini"}"#] + }) + #expect(await eventually { + await harness.performer.count("GET", pathSuffix: "/grok-reasoning-effort-options") == 2 + }) + } + + @Test func discoveredCatalogsSkipInactiveAndTerminalControlledSessions() async throws { + let inactive = try await ChatInteractionHarness(detail: chatDetail(flavor: "kimi", active: false)) + inactive.interactor.loadModelOptions() + var controlled = chatDetail(flavor: "copilot", agentState: AgentState(controlledByUser: true)) + controlled.metadata?.capabilities = nil + let terminal = try await ChatInteractionHarness(detail: controlled) + terminal.interactor.loadModelOptions() + try? await Task.sleep(for: .milliseconds(50)) + #expect(await inactive.performer.count("GET", pathSuffix: "/kimi-models") == 0) + #expect(await terminal.performer.count("GET", pathSuffix: "/copilot-models") == 0) + #expect(inactive.interactor.config.modelOptions == nil) + } + + @Test func agyReadsTheMachineCatalogAndPiSwitchesWithAProviderReference() async throws { + var agyDetail = chatDetail(flavor: "agy") + agyDetail.metadata?.machineId = "mach-1" + let agy = try await ChatInteractionHarness(detail: agyDetail) + await agy.performer.serve( + "GET", "/api/machines/mach-1/agy-models", + json: #"{"success":true,"availableModels":[{"modelId":"gemini-3.7-flash-high"}]}"# + ) + agy.interactor.loadModelOptions() + #expect(await eventually { agy.interactor.config.modelOptions?.map(\.value) == ["gemini-3.7-flash-high"] }) + + let pi = try await ChatInteractionHarness(detail: chatDetail(flavor: "pi", model: "m")) + await pi.performer.serve( + "GET", "/api/sessions/sess-1/pi-models", + json: #"{"success":true,"availableModels":[{"modelId":"m","provider":"a"},{"modelId":"n","provider":"b"}]}"# + ) + pi.interactor.loadModelOptions() + #expect(await eventually { pi.interactor.config.model == "a/m" }) + pi.interactor.setModel("b/n") + #expect(await eventually { + await pi.performer.bodies("POST", pathSuffix: "/api/sessions/sess-1/model") + == [#"{"model":{"modelId":"n","provider":"b"}}"#] + }) + #expect(pi.store.detail(for: chatSessionID)?.metadata?.piSelectedModel == PiModelReference(provider: "b", modelId: "n")) + } + // MARK: Session lifecycle @Test func renameTrimsAndPatchesTheNameAndAFailureEmitsANotice() async throws { diff --git a/ios/README.md b/ios/README.md index 87740472..23204429 100644 --- a/ios/README.md +++ b/ios/README.md @@ -445,7 +445,15 @@ TEST_RUNNER_HAPI_TYPOGRAPHY_CAPTURE=/tmp/hapi-typography-review \ The chat gear presents a single-page model/effort and permission/collaboration form. All selections use native menus; permission explanations, high-risk indicators, model-loading/retry states and update feedback remain in the form. -Changes apply immediately; Done only dismisses. On regular-width windows the +Changes apply immediately; Done only dismisses. Models follow each agent's +catalog: Claude presets, the Codex session catalog, and for live sessions the +`/api/sessions/:id/-models` routes (agy uses its machine catalog; grok +and copilot skip terminal-controlled sessions). Copilot, cursor, dsh, grok and +kimi offer a Default/Auto row; opencode, agy and pi switch between listed +models only, and Pi switches with a `{provider, modelId}` reference. Grok and +OpenCode efforts come from their `*-reasoning-effort-options` routes (OpenCode +hides options that still describe the previous model); Pi shows the current +model's thinking levels. On regular-width windows the production toolbar button anchors an iPad popover; compact windows adapt that same presenter to a medium/large sheet (large for accessibility text).