| import SwiftUI |
| import UIKit |
|
|
| struct AssistantAppView: View { |
| @Bindable var session: AssistantSession |
| @State private var selection: AssistantTab = .chat |
|
|
| var body: some View { |
| TabView(selection: $selection) { |
| ChatView(session: session) |
| .tabItem { |
| Label("Chat", systemImage: "bubble.left.and.bubble.right") |
| } |
| .tag(AssistantTab.chat) |
|
|
| ActivityView(session: session) |
| .tabItem { |
| Label("Activity", systemImage: "list.bullet.rectangle.portrait") |
| } |
| .badge(activeActivityCount) |
| .tag(AssistantTab.activity) |
|
|
| KnowledgeView(session: session) |
| .tabItem { |
| Label("Knowledge", systemImage: "books.vertical") |
| } |
| .tag(AssistantTab.knowledge) |
|
|
| SettingsView(session: session) |
| .tabItem { |
| Label("Settings", systemImage: "gearshape") |
| } |
| .tag(AssistantTab.settings) |
| } |
| .sheet(item: pendingApprovalBinding) { request in |
| ToolApprovalSheet( |
| request: request, |
| approve: session.approvePending, |
| deny: session.denyPending |
| ) |
| } |
| .onReceive( |
| NotificationCenter.default.publisher( |
| for: .dolphinIntentHandoffConsumed |
| ) |
| ) { _ in |
| selection = .chat |
| } |
| } |
|
|
| private var activeActivityCount: Int { |
| session.pendingApproval != nil ? 1 : (session.isRunning ? 1 : 0) |
| } |
|
|
| private var pendingApprovalBinding: Binding<ToolApprovalRequest?> { |
| Binding( |
| get: { session.pendingApproval }, |
| set: { newValue in |
| if newValue == nil, session.pendingApproval != nil { |
| session.denyPending() |
| } |
| } |
| ) |
| } |
| } |
|
|
| private enum AssistantTab: Hashable { |
| case chat |
| case activity |
| case knowledge |
| case settings |
| } |
|
|
| struct ChatView: View { |
| @Bindable var session: AssistantSession |
| @State private var showingClearConfirmation = false |
|
|
| var body: some View { |
| NavigationStack { |
| ScrollViewReader { proxy in |
| ScrollView { |
| LazyVStack(spacing: 14) { |
| ModelStatusBanner(session: session) |
|
|
| if session.workspace.messages.isEmpty { |
| EmptyChatView(isModelLoaded: session.isModelLoaded) |
| .padding(.top, 36) |
| } else { |
| ForEach(session.workspace.messages) { message in |
| MessageBubble(message: message) |
| .id(message.id) |
| } |
| } |
|
|
| if session.isRunning { |
| HStack(spacing: 10) { |
| ProgressView() |
| .controlSize(.small) |
| Text("Dolphin is working…") |
| .font(.footnote) |
| .foregroundStyle(.secondary) |
| Spacer() |
| } |
| .padding(.horizontal, 4) |
| .id(Self.runningAnchor) |
| } |
| } |
| .padding(.horizontal) |
| .padding(.vertical, 12) |
| .frame(maxWidth: 760) |
| .frame(maxWidth: .infinity) |
| } |
| .defaultScrollAnchor(.bottom) |
| .onChange(of: session.workspace.messages.count) { _, _ in |
| scrollToLatest(using: proxy) |
| } |
| .onChange(of: session.isRunning) { _, _ in |
| scrollToLatest(using: proxy) |
| } |
| .scrollDismissesKeyboard(.interactively) |
| } |
| .safeAreaInset(edge: .bottom, spacing: 0) { |
| ChatComposer(session: session) |
| } |
| .navigationTitle("Dolphin") |
| .navigationBarTitleDisplayMode(.inline) |
| .toolbar { |
| ToolbarItem(placement: .topBarTrailing) { |
| Menu { |
| Button("Clear Chat & Run Activity", systemImage: "trash", role: .destructive) { |
| showingClearConfirmation = true |
| } |
| .disabled(session.workspace.messages.isEmpty || session.isRunning) |
|
|
| if session.isModelLoaded { |
| Button("Release Model", systemImage: "eject") { |
| session.releaseModel() |
| } |
| .disabled(session.isRunning) |
| } |
| } label: { |
| Image(systemName: "ellipsis.circle") |
| } |
| .accessibilityLabel("Chat actions") |
| } |
| } |
| .confirmationDialog( |
| "Clear chat and run activity?", |
| isPresented: $showingClearConfirmation, |
| titleVisibility: .visible |
| ) { |
| Button("Clear Chat & Run Activity", role: .destructive) { |
| session.clearConversation() |
| } |
| Button("Cancel", role: .cancel) {} |
| } message: { |
| Text("Messages, run records, run-scoped Activity receipts, and copied recent-chat excerpts in handoffs will be removed. Saved knowledge, memories, handoffs, tasks, and standalone Activity entries remain.") |
| } |
| } |
| } |
|
|
| private func scrollToLatest(using proxy: ScrollViewProxy) { |
| withAnimation(.easeOut(duration: 0.2)) { |
| if session.isRunning { |
| proxy.scrollTo(Self.runningAnchor, anchor: .bottom) |
| } else if let lastID = session.workspace.messages.last?.id { |
| proxy.scrollTo(lastID, anchor: .bottom) |
| } |
| } |
| } |
|
|
| private static let runningAnchor = "assistant-running" |
| } |
|
|
| private struct ModelStatusBanner: View { |
| @Bindable var session: AssistantSession |
|
|
| var body: some View { |
| VStack(alignment: .leading, spacing: 10) { |
| HStack(spacing: 10) { |
| Image(systemName: statusSymbol) |
| .font(.title3) |
| .foregroundStyle(statusColor) |
| .symbolEffect( |
| .pulse, |
| isActive: session.isRunning || session.isModelLoading |
| ) |
| .accessibilityHidden(true) |
|
|
| VStack(alignment: .leading, spacing: 2) { |
| Text(session.modelStatus) |
| .font(.subheadline.weight(.semibold)) |
| Text("Private, on-device tools and Core ML assistant") |
| .font(.caption) |
| .foregroundStyle(.secondary) |
| } |
|
|
| Spacer(minLength: 8) |
|
|
| if session.isModelLoading { |
| ProgressView() |
| .controlSize(.small) |
| .accessibilityLabel("Loading model") |
|
|
| Button("Cancel") { |
| session.cancelModelLoad() |
| } |
| .buttonStyle(.bordered) |
| .controlSize(.small) |
| .accessibilityLabel("Cancel model load") |
| .accessibilityIdentifier("cancel-model-load") |
| } else if !session.isModelLoaded { |
| Button("Load") { |
| session.loadModel() |
| } |
| .buttonStyle(.borderedProminent) |
| .controlSize(.small) |
| .disabled(!session.isWorkspaceReady) |
| .accessibilityIdentifier("load-model") |
| } |
| } |
|
|
| if let error = session.errorMessage, !error.isEmpty { |
| Label(error, systemImage: "exclamationmark.triangle.fill") |
| .font(.footnote) |
| .foregroundStyle(.red) |
| .textSelection(.enabled) |
| .accessibilityIdentifier("assistant-error") |
| } |
|
|
| if let warning = session.resourceWarning, !warning.isEmpty { |
| Label(warning, systemImage: "gauge.with.dots.needle.50percent") |
| .font(.footnote) |
| .foregroundStyle(.orange) |
| .accessibilityIdentifier("resource-warning") |
| } |
| } |
| .padding(14) |
| .background(.thinMaterial, in: RoundedRectangle(cornerRadius: 16)) |
| } |
|
|
| private var statusSymbol: String { |
| if session.isRunning { return "sparkles" } |
| if !session.isWorkspaceReady { return "exclamationmark.triangle.fill" } |
| if session.isModelLoading { return "memorychip.fill" } |
| return session.isModelLoaded ? "checkmark.circle.fill" : "memorychip" |
| } |
|
|
| private var statusColor: Color { |
| if session.isRunning { return .orange } |
| if !session.isWorkspaceReady { return .red } |
| if session.isModelLoading { return .orange } |
| return session.isModelLoaded ? .green : .secondary |
| } |
| } |
|
|
| private struct EmptyChatView: View { |
| let isModelLoaded: Bool |
|
|
| var body: some View { |
| ContentUnavailableView { |
| Label("Your on-device assistant", systemImage: "sparkles") |
| } description: { |
| Text( |
| isModelLoaded |
| ? "Ask a question, save a memory, or manage a task. Actions stay bounded and auditable." |
| : "Explicit local commands work now. Load the model when you want a private conversation." |
| ) |
| } |
| } |
| } |
|
|
| private struct MessageBubble: View { |
| let message: AssistantMessage |
|
|
| var body: some View { |
| HStack(alignment: .bottom, spacing: 8) { |
| if message.role == .user { |
| Spacer(minLength: 46) |
| } |
|
|
| VStack(alignment: message.role == .user ? .trailing : .leading, spacing: 5) { |
| Text(message.content) |
| .font(.body) |
| .foregroundStyle(message.role == .user ? Color.white : Color.primary) |
| .textSelection(.enabled) |
|
|
| HStack(spacing: 5) { |
| if message.wasStopped { |
| Image(systemName: "stop.circle") |
| Text("Stopped") |
| } |
| Text(message.createdAt, format: .dateTime.hour().minute()) |
| } |
| .font(.caption2) |
| .foregroundStyle(message.role == .user ? Color.white.opacity(0.75) : .secondary) |
| } |
| .padding(.horizontal, 14) |
| .padding(.vertical, 10) |
| .background(bubbleColor, in: RoundedRectangle(cornerRadius: 17)) |
| .accessibilityElement(children: .combine) |
|
|
| if message.role == .assistant { |
| Spacer(minLength: 46) |
| } |
| } |
| .frame(maxWidth: .infinity) |
| } |
|
|
| private var bubbleColor: Color { |
| message.role == .user ? .accentColor : Color(uiColor: .secondarySystemBackground) |
| } |
| } |
|
|
| private struct ChatComposer: View { |
| @Bindable var session: AssistantSession |
|
|
| var body: some View { |
| HStack(alignment: .bottom, spacing: 10) { |
| TextField( |
| session.isModelLoaded |
| ? "Message Dolphin" |
| : "Local command, or load model to chat", |
| text: $session.draft, |
| axis: .vertical |
| ) |
| .lineLimit(1...5) |
| .textFieldStyle(.plain) |
| .padding(.horizontal, 14) |
| .padding(.vertical, 11) |
| .background(Color(uiColor: .secondarySystemBackground), in: RoundedRectangle(cornerRadius: 20)) |
| .disabled( |
| session.isRunning |
| || session.isModelLoading |
| || !session.isWorkspaceReady |
| ) |
| .submitLabel(.send) |
| .onSubmit(sendIfPossible) |
| .accessibilityIdentifier("assistant-composer") |
|
|
| if session.isRunning { |
| Button(role: .destructive) { |
| session.stop() |
| } label: { |
| Image(systemName: "stop.fill") |
| .font(.headline) |
| .frame(width: 44, height: 44) |
| } |
| .buttonStyle(.borderedProminent) |
| .clipShape(Circle()) |
| .accessibilityLabel("Stop assistant") |
| .accessibilityIdentifier("stop-assistant") |
| } else { |
| Button(action: sendIfPossible) { |
| Image(systemName: "arrow.up") |
| .font(.headline) |
| .frame(width: 44, height: 44) |
| } |
| .buttonStyle(.borderedProminent) |
| .clipShape(Circle()) |
| .disabled(!canSend) |
| .accessibilityLabel("Send message") |
| .accessibilityIdentifier("send-message") |
| } |
| } |
| .padding(.horizontal) |
| .padding(.vertical, 10) |
| .background(.bar) |
| } |
|
|
| private var canSend: Bool { |
| session.canSubmitDraft |
| } |
|
|
| private func sendIfPossible() { |
| guard canSend else { return } |
| session.send() |
| } |
| } |
|
|
| struct ActivityView: View { |
| @Bindable var session: AssistantSession |
| @State private var expandedRunIDs: Set<UUID> = [] |
|
|
| var body: some View { |
| NavigationStack { |
| Group { |
| if session.workspace.runs.isEmpty && session.workspace.events.isEmpty { |
| ContentUnavailableView( |
| "No activity yet", |
| systemImage: "list.bullet.rectangle.portrait", |
| description: Text("Model turns, approvals, and tool actions will appear here.") |
| ) |
| } else { |
| List { |
| if !orderedRuns.isEmpty { |
| Section("Runs") { |
| ForEach(orderedRuns) { run in |
| DisclosureGroup( |
| isExpanded: expansionBinding(for: run.id) |
| ) { |
| let events = runEvents(for: run.id) |
| if events.isEmpty { |
| Text("No timeline events were recorded for this run.") |
| .font(.footnote) |
| .foregroundStyle(.secondary) |
| .padding(.vertical, 6) |
| } else { |
| ForEach(events) { event in |
| ActivityRow(event: event) |
| .padding(.leading, 4) |
| } |
| } |
| } label: { |
| RunSummaryCard(run: run) |
| } |
| } |
| } |
| } |
|
|
| if !standaloneEvents.isEmpty { |
| Section("Standalone events") { |
| ForEach(standaloneEvents) { event in |
| ActivityRow(event: event) |
| } |
| } |
| } |
| } |
| .listStyle(.insetGrouped) |
| } |
| } |
| .navigationTitle("Activity") |
| .navigationBarTitleDisplayMode(.inline) |
| .toolbar { |
| ToolbarItem(placement: .topBarTrailing) { |
| if session.isRunning { |
| Button("Stop", systemImage: "stop.fill", role: .destructive) { |
| session.stop() |
| } |
| } |
| } |
| } |
| } |
| } |
|
|
| private var orderedRuns: [AgentRunRecord] { |
| session.workspace.runs.sorted { first, second in |
| first.createdAt > second.createdAt |
| } |
| } |
|
|
| private var standaloneEvents: [AgentEvent] { |
| let currentRunIDs = Set(session.workspace.runs.map(\.id)) |
| return session.workspace.events.filter { event in |
| guard let runID = event.runID else { return true } |
| return !currentRunIDs.contains(runID) |
| }.sorted { first, second in |
| first.createdAt > second.createdAt |
| } |
| } |
|
|
| private func runEvents(for runID: UUID) -> [AgentEvent] { |
| session.workspace.events.filter { $0.runID == runID }.sorted { |
| first, second in |
| if first.sequence == second.sequence { |
| return first.createdAt < second.createdAt |
| } |
| return first.sequence < second.sequence |
| } |
| } |
|
|
| private func expansionBinding(for runID: UUID) -> Binding<Bool> { |
| Binding( |
| get: { expandedRunIDs.contains(runID) }, |
| set: { isExpanded in |
| if isExpanded { |
| expandedRunIDs.insert(runID) |
| } else { |
| expandedRunIDs.remove(runID) |
| } |
| } |
| ) |
| } |
| } |
|
|
| private struct RunSummaryCard: View { |
| let run: AgentRunRecord |
|
|
| var body: some View { |
| VStack(alignment: .leading, spacing: 10) { |
| Text(run.requestText.isEmpty ? "Untitled request" : run.requestText) |
| .font(.headline) |
| .lineLimit(3) |
|
|
| HStack(spacing: 8) { |
| StatusPill(text: run.status.label, color: run.status.tint) |
|
|
| if let stopReason = run.stopReason { |
| Label(stopReason.label, systemImage: "stop.circle") |
| .font(.caption) |
| .foregroundStyle(.secondary) |
| } |
|
|
| Spacer(minLength: 4) |
|
|
| Text(run.createdAt, format: .dateTime.month().day().hour().minute()) |
| .font(.caption) |
| .foregroundStyle(.tertiary) |
| } |
|
|
| Label( |
| "Phase: \(run.checkpoint.phase.label)", |
| systemImage: run.checkpoint.phase.symbolName |
| ) |
| .font(.subheadline) |
| .foregroundStyle(.secondary) |
|
|
| HStack(spacing: 14) { |
| RunMetric( |
| value: run.checkpoint.modelTurns, |
| label: "model", |
| systemImage: "memorychip" |
| ) |
| RunMetric( |
| value: run.checkpoint.toolCallsUsed, |
| label: "tools", |
| systemImage: "wrench.and.screwdriver" |
| ) |
| RunMetric( |
| value: run.checkpoint.completedReceipts.count, |
| label: "verified", |
| systemImage: "checkmark.shield" |
| ) |
| } |
|
|
| if let error = run.errorSummary, !error.isEmpty { |
| Label(error, systemImage: "exclamationmark.triangle.fill") |
| .font(.footnote) |
| .foregroundStyle(.red) |
| .textSelection(.enabled) |
| } |
| } |
| .padding(.vertical, 6) |
| } |
| } |
|
|
| private struct RunMetric: View { |
| let value: Int |
| let label: String |
| let systemImage: String |
|
|
| var body: some View { |
| Label("\(value) \(label)", systemImage: systemImage) |
| .font(.caption) |
| .foregroundStyle(.secondary) |
| .accessibilityLabel("\(value) \(label)") |
| } |
| } |
|
|
| private struct ActivityRow: View { |
| let event: AgentEvent |
|
|
| var body: some View { |
| HStack(alignment: .top, spacing: 12) { |
| Image(systemName: event.status.symbolName) |
| .foregroundStyle(event.status.tint) |
| .font(.title3) |
| .frame(width: 26) |
| .accessibilityHidden(true) |
|
|
| VStack(alignment: .leading, spacing: 5) { |
| HStack(alignment: .firstTextBaseline) { |
| Text(event.title) |
| .font(.headline) |
| Spacer() |
| StatusPill(text: event.status.label, color: event.status.tint) |
| } |
|
|
| if !event.detail.isEmpty { |
| Text(event.detail) |
| .font(.subheadline) |
| .foregroundStyle(.secondary) |
| .textSelection(.enabled) |
| } |
|
|
| HStack(spacing: 6) { |
| Label(event.kind.label, systemImage: event.kind.symbolName) |
| Text("·") |
| Text("Step \(event.sequence)") |
| Text("·") |
| Text(event.createdAt, format: .dateTime.hour().minute().second()) |
| } |
| .font(.caption) |
| .foregroundStyle(.tertiary) |
| } |
| } |
| .padding(.vertical, 4) |
| .accessibilityElement(children: .combine) |
| } |
| } |
|
|
| struct SettingsView: View { |
| @Bindable var session: AssistantSession |
| @Environment(\.openURL) private var openURL |
| @State private var settingsDraft = AgentSettings() |
| @State private var hasSynchronizedSettings = false |
|
|
| var body: some View { |
| NavigationStack { |
| Form { |
| modelSection |
| autonomySection |
| permissionsSection |
| systemContextSection |
| instructionSection |
| privacySection |
| } |
| .navigationTitle("Settings") |
| .navigationBarTitleDisplayMode(.inline) |
| .toolbar { |
| ToolbarItem(placement: .topBarTrailing) { |
| Button("Save") { |
| if let appliedSettings = session.saveSettings(settingsDraft) { |
| settingsDraft = appliedSettings |
| hasSynchronizedSettings = true |
| } |
| } |
| .disabled( |
| !session.isWorkspaceReady |
| || session.isRunning |
| || !hasUnsavedSettings |
| ) |
| .accessibilityIdentifier("save-settings") |
| } |
| } |
| .onAppear { |
| synchronizeSettingsIfNeeded() |
| } |
| .onChange(of: session.isWorkspaceReady) { _, isReady in |
| if isReady { |
| synchronizeSettings(force: true) |
| } else { |
| hasSynchronizedSettings = false |
| } |
| } |
| .onChange( |
| of: session.workspace.settings.enabledSystemCapabilities |
| ) { _, capabilities in |
| settingsDraft.enabledSystemCapabilities = capabilities |
| } |
| .task(id: session.isWorkspaceReady) { |
| guard session.isWorkspaceReady else { return } |
| session.refreshResourceSnapshot() |
| await session.refreshCalendarAuthorization() |
| } |
| } |
| } |
|
|
| private var modelSection: some View { |
| Section("On-device model") { |
| LabeledContent("Status") { |
| HStack(spacing: 6) { |
| Circle() |
| .fill( |
| !session.isWorkspaceReady |
| ? Color.red |
| : (session.isModelLoaded ? Color.green : Color.secondary) |
| ) |
| .frame(width: 8, height: 8) |
| Text(session.modelStatus) |
| } |
| } |
|
|
| if session.isModelLoaded { |
| Button("Release Model", systemImage: "eject") { |
| session.releaseModel() |
| } |
| .disabled(session.isRunning) |
| } else if session.isModelLoading { |
| HStack { |
| ProgressView() |
| .controlSize(.small) |
| Text("Loading model…") |
| .foregroundStyle(.secondary) |
| Spacer() |
| Button("Cancel Load", systemImage: "xmark.circle") { |
| session.cancelModelLoad() |
| } |
| .accessibilityIdentifier("settings-cancel-model-load") |
| } |
| } else { |
| Button("Load Model", systemImage: "memorychip") { |
| session.loadModel() |
| } |
| .buttonStyle(.borderedProminent) |
| .disabled(!session.isWorkspaceReady || session.isModelLoading) |
| } |
|
|
| Text("The 1.81 GB stateful INT4 model stays on this device. Releasing it recovers memory.") |
| .font(.footnote) |
| .foregroundStyle(.secondary) |
|
|
| if let snapshot = session.resourceSnapshot { |
| LabeledContent("Thermal state", value: snapshot.thermalLevel.label) |
| LabeledContent( |
| "Low Power Mode", |
| value: snapshot.lowPowerModeEnabled ? "On" : "Off" |
| ) |
| if let availableMemory = snapshot.availableMemoryBytes { |
| LabeledContent( |
| "Available memory (advisory)", |
| value: ByteCountFormatter.string( |
| fromByteCount: Int64(clamping: availableMemory), |
| countStyle: .memory |
| ) |
| ) |
| } |
| } |
|
|
| if let warning = session.resourceWarning, !warning.isEmpty { |
| Label(warning, systemImage: "exclamationmark.triangle") |
| .font(.footnote) |
| .foregroundStyle(.orange) |
| } |
| } |
| } |
|
|
| private var autonomySection: some View { |
| Section("Run limits") { |
| Stepper( |
| "Tool steps: \(settingsDraft.maxToolSteps)", |
| value: settingBinding(\.maxToolSteps), |
| in: AgentSettings.maxToolStepsRange |
| ) |
|
|
| Stepper( |
| "Output budget: \(settingsDraft.maxNewTokens) tokens", |
| value: settingBinding(\.maxNewTokens), |
| in: AgentSettings.maxNewTokensRange, |
| step: 32 |
| ) |
|
|
| Stepper( |
| "Time limit: \(settingsDraft.maxRunSeconds) seconds", |
| value: settingBinding(\.maxRunSeconds), |
| in: AgentSettings.maxRunSecondsRange, |
| step: 30 |
| ) |
|
|
| Text("Tool and output limits are hard boundaries. At the time deadline, Dolphin requests cancellation; a Core ML prediction already in progress must return before the stop is observed.") |
| .font(.footnote) |
| .foregroundStyle(.secondary) |
| } |
| .disabled(!session.isWorkspaceReady || session.isRunning) |
| } |
|
|
| private var permissionsSection: some View { |
| Section("Permissions") { |
| Toggle( |
| "Require approval for local changes", |
| isOn: settingBinding(\.requireApprovalForLocalWrites) |
| ) |
|
|
| Label( |
| "External network tools are disabled until connected-peer validation can be enforced.", |
| systemImage: "network.slash" |
| ) |
| .font(.footnote) |
| .foregroundStyle(.secondary) |
| } |
| .disabled(!session.isWorkspaceReady || session.isRunning) |
| } |
|
|
| private var systemContextSection: some View { |
| Section("System context") { |
| LabeledContent("Calendar") { |
| Label( |
| calendarStatusText, |
| systemImage: calendarContextEnabled |
| ? "checkmark.shield.fill" |
| : "calendar.badge.exclamationmark" |
| ) |
| .foregroundStyle( |
| calendarContextEnabled ? Color.green : Color.secondary |
| ) |
| } |
|
|
| if session.isCalendarAccessRequesting { |
| HStack(spacing: 10) { |
| ProgressView() |
| Text("Waiting for Calendar permission…") |
| .foregroundStyle(.secondary) |
| } |
| } else if calendarContextEnabled { |
| Button("Disable Calendar Context", systemImage: "calendar.badge.minus") { |
| session.disableCalendarContext() |
| } |
| } else { |
| calendarEnableAction |
| } |
|
|
| Text( |
| "Calendar is opt-in. Dolphin exposes only bounded event titles and times, only in the foreground, and asks you to approve each exact read. It never creates or edits events." |
| ) |
| .font(.footnote) |
| .foregroundStyle(.secondary) |
| } |
| .disabled( |
| !session.isWorkspaceReady |
| || session.isRunning |
| || session.isCalendarAccessRequesting |
| ) |
| } |
|
|
| @ViewBuilder |
| private var calendarEnableAction: some View { |
| switch session.calendarAuthorization { |
| case .notDetermined: |
| Button("Grant and Enable Calendar", systemImage: "calendar.badge.plus") { |
| Task { await session.requestAndEnableCalendarAccess() } |
| } |
| .buttonStyle(.borderedProminent) |
| .accessibilityIdentifier("grant-calendar-access") |
|
|
| case .fullAccess: |
| Button("Enable Calendar Context", systemImage: "calendar.badge.plus") { |
| session.enableCalendarContext() |
| } |
| .buttonStyle(.borderedProminent) |
| .accessibilityIdentifier("enable-calendar-context") |
|
|
| case .denied, .writeOnly: |
| Button("Open iOS Settings", systemImage: "gear") { |
| guard let url = URL(string: UIApplication.openSettingsURLString) else { |
| return |
| } |
| openURL(url) |
| } |
| .accessibilityIdentifier("open-calendar-settings") |
|
|
| case .restricted: |
| Label( |
| "Calendar access is restricted on this iPhone.", |
| systemImage: "lock.trianglebadge.exclamationmark" |
| ) |
| .foregroundStyle(.secondary) |
| } |
| } |
|
|
| private var calendarContextEnabled: Bool { |
| session.workspace.settings.enabledSystemCapabilities.contains(.calendarRead) |
| && session.calendarAuthorization == .fullAccess |
| } |
|
|
| private var calendarStatusText: String { |
| if calendarContextEnabled { return "Enabled" } |
| switch session.calendarAuthorization { |
| case .fullAccess: return "OS access granted; Dolphin disabled" |
| case .notDetermined: return "Not requested" |
| case .denied: return "Denied in iOS" |
| case .restricted: return "Restricted" |
| case .writeOnly: return "Write-only; read access required" |
| } |
| } |
|
|
| private var instructionSection: some View { |
| Section("Assistant instruction") { |
| TextEditor(text: settingBinding(\.systemPrompt)) |
| .frame(minHeight: 150) |
| .font(.body.monospaced()) |
| .disabled(session.isRunning) |
|
|
| Button("Restore Default") { |
| settingsDraft.systemPrompt = AgentSettings.defaultSystemPrompt |
| } |
| .disabled(session.isRunning) |
| } |
| .disabled(!session.isWorkspaceReady || session.isRunning) |
| } |
|
|
| private var privacySection: some View { |
| Section("Privacy and control") { |
| Label("Conversation, memories, tasks, and activity are stored locally.", systemImage: "iphone") |
| Label("Tool actions are recorded in Activity.", systemImage: "checkmark.shield") |
| Label("Closing or backgrounding the app stops an active run.", systemImage: "stop.circle") |
| } |
| .font(.footnote) |
| .foregroundStyle(.secondary) |
| } |
|
|
| private func settingBinding<Value>( |
| _ keyPath: WritableKeyPath<AgentSettings, Value> |
| ) -> Binding<Value> { |
| Binding( |
| get: { settingsDraft[keyPath: keyPath] }, |
| set: { settingsDraft[keyPath: keyPath] = $0 } |
| ) |
| } |
|
|
| private var hasUnsavedSettings: Bool { |
| hasSynchronizedSettings |
| && settingsDraft != session.workspace.settings |
| } |
|
|
| private func synchronizeSettingsIfNeeded() { |
| guard session.isWorkspaceReady, !hasSynchronizedSettings else { return } |
| synchronizeSettings(force: true) |
| } |
|
|
| private func synchronizeSettings(force: Bool) { |
| guard session.isWorkspaceReady else { return } |
| guard force || !hasUnsavedSettings else { return } |
| settingsDraft = session.workspace.settings |
| hasSynchronizedSettings = true |
| } |
| } |
|
|
| private struct ToolApprovalSheet: View { |
| let request: ToolApprovalRequest |
| let approve: () -> Void |
| let deny: () -> Void |
|
|
| var body: some View { |
| NavigationStack { |
| ScrollView { |
| VStack(alignment: .leading, spacing: 20) { |
| Label("Dolphin is waiting for you", systemImage: "hand.raised.fill") |
| .font(.title2.weight(.bold)) |
| .foregroundStyle(.orange) |
|
|
| VStack(alignment: .leading, spacing: 8) { |
| Text(request.toolName) |
| .font(.headline) |
| Text(request.reason) |
| .foregroundStyle(.secondary) |
| } |
|
|
| VStack(alignment: .leading, spacing: 8) { |
| Text("Exact action") |
| .font(.caption.weight(.semibold)) |
| .foregroundStyle(.secondary) |
| .textCase(.uppercase) |
| Text(request.call.name) |
| .font(.body.monospaced().weight(.semibold)) |
| Text(JSONValue.object(request.call.arguments).canonicalJSON) |
| .font(.footnote.monospaced()) |
| .textSelection(.enabled) |
| .frame(maxWidth: .infinity, alignment: .leading) |
| .padding(12) |
| .background(Color(uiColor: .secondarySystemBackground), in: RoundedRectangle(cornerRadius: 10)) |
| } |
|
|
| Label( |
| request.isExpired() |
| ? "This approval has expired. Deny it and run the request again." |
| : "Approval applies once, only to the exact action shown above, and expires at \(request.expiresAt.formatted(date: .omitted, time: .shortened)).", |
| systemImage: request.isExpired() ? "clock.badge.xmark" : "lock.shield" |
| ) |
| .font(.footnote) |
| .foregroundStyle(request.isExpired() ? .red : .secondary) |
|
|
| VStack(spacing: 10) { |
| Button { |
| approve() |
| } label: { |
| Label("Approve Once", systemImage: "checkmark.shield.fill") |
| .frame(maxWidth: .infinity) |
| } |
| .buttonStyle(.borderedProminent) |
| .controlSize(.large) |
| .disabled(request.isExpired()) |
| .accessibilityIdentifier("approve-tool") |
|
|
| Button("Deny", systemImage: "xmark", role: .destructive) { |
| deny() |
| } |
| .buttonStyle(.bordered) |
| .controlSize(.large) |
| .frame(maxWidth: .infinity) |
| .accessibilityIdentifier("deny-tool") |
| } |
| } |
| .padding(20) |
| .frame(maxWidth: 620) |
| .frame(maxWidth: .infinity) |
| } |
| .navigationTitle("Approve Action") |
| .navigationBarTitleDisplayMode(.inline) |
| .toolbar { |
| ToolbarItem(placement: .cancellationAction) { |
| Button("Deny", role: .cancel) { |
| deny() |
| } |
| } |
| } |
| } |
| .interactiveDismissDisabled() |
| .presentationDetents([.medium, .large]) |
| } |
| } |
|
|
| private struct StatusPill: View { |
| let text: String |
| let color: Color |
|
|
| var body: some View { |
| Text(text) |
| .font(.caption2.weight(.semibold)) |
| .foregroundStyle(color) |
| .padding(.horizontal, 7) |
| .padding(.vertical, 3) |
| .background(color.opacity(0.12), in: Capsule()) |
| } |
| } |
|
|
| private extension AgentEventStatus { |
| var label: String { |
| switch self { |
| case .information: "Info" |
| case .running: "Running" |
| case .awaitingApproval: "Approval" |
| case .succeeded: "Succeeded" |
| case .denied: "Denied" |
| case .failed: "Failed" |
| case .cancelled: "Cancelled" |
| } |
| } |
|
|
| var symbolName: String { |
| switch self { |
| case .information: "info.circle.fill" |
| case .running: "arrow.trianglehead.2.clockwise.rotate.90" |
| case .awaitingApproval: "hand.raised.fill" |
| case .succeeded: "checkmark.circle.fill" |
| case .denied: "hand.raised.slash.fill" |
| case .failed: "xmark.octagon.fill" |
| case .cancelled: "stop.circle.fill" |
| } |
| } |
|
|
| var tint: Color { |
| switch self { |
| case .information: .blue |
| case .running: .orange |
| case .awaitingApproval: .orange |
| case .succeeded: .green |
| case .denied: .secondary |
| case .failed: .red |
| case .cancelled: .secondary |
| } |
| } |
| } |
|
|
| private extension AgentEventKind { |
| var label: String { |
| switch self { |
| case .run: "Run" |
| case .model: "Model" |
| case .tool: "Tool" |
| case .approval: "Approval" |
| case .persistence: "Storage" |
| } |
| } |
|
|
| var symbolName: String { |
| switch self { |
| case .run: "play.circle" |
| case .model: "memorychip" |
| case .tool: "wrench.and.screwdriver" |
| case .approval: "hand.raised" |
| case .persistence: "externaldrive" |
| } |
| } |
| } |
|
|
| private extension AgentRunStatus { |
| var label: String { |
| switch self { |
| case .running: "Running" |
| case .cancellationRequested: "Stopping" |
| case .succeeded: "Succeeded" |
| case .failed: "Failed" |
| case .cancelled: "Cancelled" |
| case .interrupted: "Interrupted" |
| } |
| } |
|
|
| var tint: Color { |
| switch self { |
| case .running, .cancellationRequested: .orange |
| case .succeeded: .green |
| case .failed, .interrupted: .red |
| case .cancelled: .secondary |
| } |
| } |
| } |
|
|
| private extension AgentRunPhase { |
| var label: String { |
| switch self { |
| case .preparing: "Preparing" |
| case .routing: "Routing" |
| case .modelGeneration: "Model generation" |
| case .awaitingApproval: "Awaiting approval" |
| case .toolExecution: "Tool execution" |
| case .finalizing: "Finalizing" |
| } |
| } |
|
|
| var symbolName: String { |
| switch self { |
| case .preparing: "list.clipboard" |
| case .routing: "arrow.triangle.branch" |
| case .modelGeneration: "memorychip" |
| case .awaitingApproval: "hand.raised" |
| case .toolExecution: "wrench.and.screwdriver" |
| case .finalizing: "checkmark.seal" |
| } |
| } |
| } |
|
|
| private extension AgentRunStopReason { |
| var label: String { |
| switch self { |
| case .user: "Stopped by user" |
| case .background: "App backgrounded" |
| case .deadline: "Time limit reached" |
| case .storageFailure: "Storage failure" |
| case .processEnded: "App process ended" |
| } |
| } |
| } |
|
|
| private extension AssistantThermalLevel { |
| var label: String { |
| switch self { |
| case .nominal: "Nominal" |
| case .fair: "Fair" |
| case .serious: "Serious" |
| case .critical: "Critical" |
| case .unknown: "Unknown" |
| } |
| } |
| } |
|
|
