From a9f179e9dbebf1a7a70530e9e84b4a0a7231476d Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 14:14:05 +0800 Subject: [PATCH] Import apps/android/src/screens/chat-screen.tsx --- apps/android/src/screens/chat-screen.tsx | 1424 ++++++++++++++++++++++ 1 file changed, 1424 insertions(+) create mode 100644 apps/android/src/screens/chat-screen.tsx diff --git a/apps/android/src/screens/chat-screen.tsx b/apps/android/src/screens/chat-screen.tsx new file mode 100644 index 0000000..c11b8f0 --- /dev/null +++ b/apps/android/src/screens/chat-screen.tsx @@ -0,0 +1,1424 @@ +import * as Haptics from 'expo-haptics' +import { ArrowDown, ArrowLeft, FileText, ListTree, Menu, MessageSquare, RefreshCw, X } from 'lucide-react-native' +import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react' +import { + AccessibilityInfo, + ActivityIndicator, + Alert, + Animated, + DeviceEventEmitter, + Easing, + FlatList, + Image, + Keyboard, + Modal, + NativeModules, + PanResponder, + Pressable, + ScrollView, + StyleSheet, + Text, + View +} from 'react-native' +import { shouldConfirmSwipeRightOpen, shouldStartSwipeRightToOpen } from '../lib/gesture-swipe-rules' +import { isSubagentSession } from '../lib/session-kind' +import { workspaceStableKey } from '../lib/workspace-key' +import { strings } from '../locales/i18n' +import { sessionPermissions } from '../services/session-permissions' +import type { CustomPrompt } from '../services/storage' +import { BUILT_IN_PROMPTS } from '../services/storage' +import type { ChatSection } from '../state/message-helpers' +import { isKnownBotSessionId, useBotTeamStore } from '../state/bot-store' +import { chatImageConnectionGeneration, requireConnectionRpc, requireSessionTools, sessionChatImageLoader, useAppStore } from '../state/store' +import { type UiArtifact } from '../state/ui-artifacts' +import type { + ChatItem, + ModelCatalogModel, + ModelProviderGroup, + PermissionSelect, + PromptImage, + WorkspaceView +} from '../types' +import { AnimatedEllipsis } from '../ui/animated-ellipsis' +import { ChatImageProvider } from '../ui/chat-image' +import { BlurHeaderFrame, IconButton, TopBar } from '../ui/components' +import { KeyboardInset } from '../ui/keyboard-inset' +import { decodeSessionMentionUri, markdownFilePath, MarkdownLinkProvider, openSafeExternalUrl } from '../ui/markdown' +import { OfficialMenuIcons } from '../ui/official-menu-icons' +import { useResponsiveLayout } from '../ui/responsive' +import { spacing } from '../ui/theme' +import { useTheme } from '../ui/theme-context' +import { useThemedStyles } from '../ui/use-themed-styles' +import { easingCurve, resolveMotion, type Rect } from '../ui/motion' +import { useReduceMotion } from '../ui/use-reduce-motion' +import { AutomationTasksModal } from './automation-tasks-modal' +import { ChatErrorBoundary } from './chat-error-boundary' +import { + formatFileBytes, + formatUploadedFilesPrompt, + formatUploadedFilesReferencePrompt, + MAX_TOTAL_FILES_BYTES, + uploadStagedFilesToWorkspace, + type StagedFile +} from './chat-files' +import { ChatTrajectory } from './chat-trajectory' +import { ChatActionMenu } from './chat/action-menu' +import { ChatComposer } from './chat/composer' +import { composerEditable, submitIntent } from './chat/composer-gate' +import { ExpandedComposer } from './chat/expanded-composer' +import { + ChatImages, + ChatItemView, + ChatProcessGroup, + isActiveChatItem, + QueueDock, + WelcomeMessage +} from './chat/messages' +import { + agentPresetName, + builtinPresetName, + ModelPicker, + ModePicker, + permissionDisplayName, + PermissionPicker, + PromptEditor, + PromptsManager, + PromptsPicker, + ToolAccessPicker, + WorkspacePicker, +} from './chat/pickers' +import { sessionTitle } from './chat/presentation' +import { SessionActivityDock } from './chat/session-activity' +import { SessionInfo } from './chat/session-info' +import { createStyles } from './chat/styles' +import { useChatAttachments } from './chat/use-chat-attachments' +import { useChatBackHandler } from './chat/use-chat-back-handler' +import { useChatMentions } from './chat/use-chat-mentions' +import { useChatPrompts } from './chat/use-chat-prompts' +import { useChatScroll } from './chat/use-chat-scroll' +import { useChatTranscript } from './chat/use-chat-transcript' +import { useLiveSessionStatus } from './device-screens' +import { BotModeScreen } from './bot-mode-screen' +import { HostSessionsDrawer } from './host-sessions-drawer' +import { PluginsModal } from './plugins-modal' +import { ReferenceChatModal, ReferencedChatPills } from './bot/reference-chat-modal' +import type { ReferenceChatCandidate } from './bot/at-menu' +import { SessionToolsPanel } from './session-tools-panel' + +import { browseKey, browseScope, updateBrowseEntry, useBrowseMemory } from '../services/browse-memory' +import { formatQuoteText, QuotePreview } from '../ui/quote-preview' +const EMPTY_QUOTES: string[] = [] +const EMPTY_IMAGES: PromptImage[] = [] +const EMPTY_CHAT_ITEMS: ChatItem[] = [] +const EMPTY_UI_ARTIFACTS: UiArtifact[] = [] + +/** Hard cap mirroring the largest backend prompt budget (ACP/CodeX 256 KiB). */ +const LONG_DRAFT_MAX = 256_000 + +export function ChatScreen({ + onBack = () => {}, + onOpenDevices: _onOpenDevices, + onNewSession, + onOpenWorkspaces, + onOpenDeviceInfo, + onOpenHostSwitcher, + onOpenSettings, + onOpenAbout, + botMode = false, + externalOpenRevision, + botConversationId, + onBotModeChange, + onSelectBot, +}: { + onBack?: () => void + onOpenDevices?: () => void + onNewSession?: () => void + onOpenWorkspaces?: (focusWorkspaceKey?: string) => void + onOpenDeviceInfo?: () => void + onOpenHostSwitcher?: () => void + onOpenSettings?: () => void + onOpenAbout?: () => void + botMode?: boolean + externalOpenRevision?: number + botConversationId?: string + onBotModeChange?: (botMode: boolean) => void + onSelectBot?: (id?: string) => void +}) { + const reduceMotion = useReduceMotion() + // New subagent children and running-state changes must reach `sessions` + // without leaving the chat (the list screens unmount here). + const session = useAppStore(state => state.selectedSession) + const archivedSessionIds = useAppStore(state => state.archivedSessionIds) + useLiveSessionStatus(!botMode && session !== undefined && (session.backend ?? 'harness') === 'harness') + const hostId = useAppStore(state => state.selectedDevice?.deviceId) + const hostPlatform = useAppStore(state => state.selectedDevice?.platform) + const messages = useAppStore(state => session === undefined ? EMPTY_CHAT_ITEMS : state.messages[session.sessionId] ?? EMPTY_CHAT_ITEMS) + const busy = useAppStore(state => state.busyAction) + const codexReadySessionId = useAppStore(state => state.codexReadySessionId) + const connection = useAppStore(state => state.connection) + const imageGeneration = chatImageConnectionGeneration() + const imageLoader = useMemo(() => session === undefined || connection.phase !== 'connected' + ? undefined : sessionChatImageLoader(session), [session?.sessionId, session?.backend, hostId, imageGeneration, connection.phase]) + const historyHasMore = useAppStore(state => state.historyHasMore) + const historyLoadingOlder = useAppStore(state => state.historyLoadingOlder) + const sessionModels = useAppStore(state => state.sessionModels) + const modelSelecting = useAppStore(state => state.modelSelecting) + const permissionSelecting = useAppStore(state => state.permissionSelecting) + const sendMessage = useAppStore(state => state.sendMessage) + const stopSession = useAppStore(state => state.stopSession) + const reconnect = useAppStore(state => state.reconnect) + const openSession = useAppStore(state => state.openSession) + const respondApproval = useAppStore(state => state.respondApproval) + const respondQuestion = useAppStore(state => state.respondQuestion) + const loadOlderHistory = useAppStore(state => state.loadOlderHistory) + const selectModel = useAppStore(state => state.selectModel) + const selectPermission = useAppStore(state => state.selectPermission) + const loadAgentPresets = useAppStore(state => state.loadAgentPresets) + const selectAgentPreset = useAppStore(state => state.selectAgentPreset) + const createSession = useAppStore(state => state.createSession) + const archiveSession = useAppStore(state => state.archiveSession) + const workspaces = useAppStore(state => state.workspaces) + const sessions = useAppStore(state => state.sessions) + const agentPresetOptions = useAppStore(state => state.agentPresetOptions) + const agentPresetLoading = useAppStore(state => state.agentPresetLoading) + const agentPresetSelecting = useAppStore(state => state.agentPresetSelecting) + const previewImageUri = useAppStore(state => state.previewImageUri) + const setPreviewImageUri = useAppStore(state => state.setPreviewImageUri) + // Lightbox grows from the tap instead of a whole-screen cross fade. + const lightboxMotion = useRef(new Animated.Value(0)).current + useEffect(() => { + if (previewImageUri === undefined) return + lightboxMotion.setValue(0) + const animation = Animated.timing(lightboxMotion, { + toValue: 1, + duration: resolveMotion('fullscreen', reduceMotion).duration, + easing: Easing.bezier(...easingCurve('expand')), + useNativeDriver: true, + }) + animation.start() + return () => animation.stop() + }, [previewImageUri, lightboxMotion, reduceMotion]) + const memoryScope = browseScope(useAppStore.getState()) + const memoryKey = browseKey(memoryScope, session?.sessionId ?? '') + const draft = useBrowseMemory(state => state.entries[memoryKey]?.draft ?? '') + const memoryError = useBrowseMemory(state => state.error) + const setDraft = (value: string) => updateBrowseEntry(memoryScope, session?.sessionId ?? '', {draft: value}) + const [trajectory, setTrajectory] = useState(false) + // Enter-only motion for the transcript <-> trajectory swap. Both views keep + // their own scroll state; only the incoming view moves. + const trajectoryMotion = useRef(new Animated.Value(1)).current + useEffect(() => { + trajectoryMotion.setValue(0) + const animation = Animated.timing(trajectoryMotion, { + toValue: 1, + duration: resolveMotion('fullscreen', reduceMotion).duration, + easing: Easing.bezier(...easingCurve('expand')), + useNativeDriver: true, + }) + animation.start() + return () => animation.stop() + }, [trajectory, trajectoryMotion, reduceMotion]) + const [composingDuringRun, setComposingDuringRun] = useState(false) + + const [sessionsOpen, setSessionsOpen] = useState(true) + // Cold start parks the sidebar full-screen before any page is chosen; swiping + // or pressing back must not drop the user into an arbitrary conversation. + const [drawerSwipeUnlocked, setDrawerSwipeUnlocked] = useState(false) + const markConversationChosen = () => setDrawerSwipeUnlocked(true) + const lastHostIdRef = useRef(hostId) + useEffect(() => { + if (hostId === lastHostIdRef.current) return + lastHostIdRef.current = hostId + setDrawerSwipeUnlocked(false) + setSessionsOpen(true) + }, [hostId]) + // Explicit navigation must also reveal an already selected conversation. + // A revision (rather than session identity) handles repeated notification taps. + useEffect(() => { + if (externalOpenRevision === undefined) return + setDrawerSwipeUnlocked(true) + setSessionsOpen(false) + }, [externalOpenRevision]) + const [automationTasksOpen, setAutomationTasksOpen] = useState(false) + const [pluginsOpen, setPluginsOpen] = useState(false) + const pluginsAvailable = useAppStore(state => state.connection.phase === 'connected') + const [sessionInfoOpen, setSessionInfoOpen] = useState(false) + + // Web-style blue marks: `/` commands and `@` references render in accent blue. + const images = useBrowseMemory(state => state.entries[memoryKey]?.images ?? EMPTY_IMAGES) + const setImages = (value: PromptImage[] | ((previous: PromptImage[]) => PromptImage[])) => { + const previous = useBrowseMemory.getState().entries[memoryKey]?.images ?? EMPTY_IMAGES + updateBrowseEntry(memoryScope, session?.sessionId ?? '', {images: typeof value === 'function' ? value(previous) : value}) + } + const quotes = useBrowseMemory(state => state.entries[memoryKey]?.quotes ?? EMPTY_QUOTES) + const setQuotes = (value: string[] | ((previous: string[]) => string[])) => { + const previous = useBrowseMemory.getState().entries[memoryKey]?.quotes ?? EMPTY_QUOTES + updateBrowseEntry(memoryScope, session?.sessionId ?? '', {quotes: typeof value === 'function' ? value(previous) : value}) + } + const [modelPickerOpen, setModelPickerOpen] = useState(false) + const [permissionPickerOpen, setPermissionPickerOpen] = useState(false) + const mentionInput = useChatMentions({ + session, sessions, workspaces, connectionPhase: connection.phase, draft, setDraft, + setPermissionPickerOpen, setModelPickerOpen, + }) + const { composerInputRef, draftRef, mentionType, setMentionType, applyDraft, closeMention, resetSelection } = mentionInput + const lastQuoteCountRef = useRef(quotes.length) + useEffect(() => { + if (quotes.length > lastQuoteCountRef.current) { + composerInputRef.current?.focus() + } + lastQuoteCountRef.current = quotes.length + }, [quotes.length, composerInputRef]) + + useEffect(() => { + if (NativeModules.DshProcessText?.getInitialText) { + NativeModules.DshProcessText.getInitialText().then((text: string | null) => { + if (text && text.trim().length > 0) { + setQuotes(current => [...current, text.trim()]) + composerInputRef.current?.focus() + } + }).catch(() => {}) + } + + const sub = DeviceEventEmitter.addListener('onProcessText', (text: string) => { + if (text && text.trim().length > 0) { + setQuotes(current => [...current, text.trim()]) + composerInputRef.current?.focus() + } + }) + + return () => { + sub.remove() + } + }, [setQuotes, composerInputRef]) + const [stagedFiles, setStagedFiles] = useState([]) + const [uploadingFiles, setUploadingFiles] = useState(false) + const uploadingRef = useRef(false) + const uploadControllerRef = useRef(undefined) + const sessionGenerationRef = useRef(0) + useLayoutEffect(() => { + let lastSessionId = useAppStore.getState().selectedSession?.sessionId + return useAppStore.subscribe((state) => { + const currentId = state.selectedSession?.sessionId + if (currentId !== lastSessionId) { + lastSessionId = currentId + sessionGenerationRef.current += 1 + uploadControllerRef.current?.abort() + setStagedFiles([]) + } + }) + }, []) + useEffect(() => () => { uploadControllerRef.current?.abort() }, []) + useEffect(() => { + if (connection.phase !== 'connected') uploadControllerRef.current?.abort() + }, [connection.phase]) + const { canAttachImages, attachmentPicking, pickImages, takePhoto, pickFiles } = useChatAttachments({ + session, memoryKey, images, setImages, stagedFiles, setStagedFiles, sessionGenerationRef, + }) + const [plusMenuOpen, setPlusMenuOpen] = useState(false) + const [sheetAnchor, setSheetAnchor] = useState() + const composerAnchorRef = useRef(null) + const [referenceChatOpen, setReferenceChatOpen] = useState(false) + const [stagedReferences, setStagedReferences] = useState([]) + const [modePickerOpen, setModePickerOpen] = useState(false) + const [workspacePickerOpen, setWorkspacePickerOpen] = useState(false) + const [toolPickerOpen, setToolPickerOpen] = useState(false) + const [toolsMode, setToolsMode] = useState<'files' | 'terminal'>() + const [fileLinkPath, setFileLinkPath] = useState() + const { promptsPickerOpen, setPromptsPickerOpen, customPrompts, promptEditing, + setPromptEditing, promptsManagerOpen, setPromptsManagerOpen, promptsLoading, savePromptEdit, deletePrompt } = useChatPrompts(connection.phase) + const [permissionOptions, setPermissionOptions] = useState() + const [permissionError, setPermissionError] = useState() + const [permissionRevision, setPermissionRevision] = useState(0) + const [permissionLoading, setPermissionLoading] = useState(false) + const inlinePermissionOptions = session?.projections?.values?.permissions + useEffect(() => { + setPermissionOptions(undefined) + setPermissionError(undefined) + setPermissionLoading(false) + if (session === undefined || session.backend === 'codex' || connection.phase !== 'connected') return + const projected = sessionPermissions(session) + if (projected === undefined || projected.options.length > 0) return + const controller = new AbortController() + setPermissionLoading(true) + void Promise.resolve().then(() => requireSessionTools().permissionOptions(controller.signal)) + .then(options => { if (!controller.signal.aborted) setPermissionOptions(options) }) + .catch(() => { if (!controller.signal.aborted) setPermissionError(strings.tools.permissionUnavailable) }) + .finally(() => { if (!controller.signal.aborted) setPermissionLoading(false) }) + return () => controller.abort() + }, [session?.sessionId, session?.backend, inlinePermissionOptions, connection.phase, permissionPickerOpen, permissionRevision]) + // A carrier drop must not close the full-screen editor: the draft stays + // editable offline, so only a conversation change collapses it. + useEffect(() => { setToolsMode(undefined) }, [session?.sessionId, connection.phase]) + useEffect(() => { setComposerExpanded(false) }, [session?.sessionId]) + // The mode (agent-preset) roster is deployment-level; fetch it once per connection. + useEffect(() => { + if (connection.phase !== 'connected' || session?.backend === 'codex') return + if (useAppStore.getState().agentPresetOptions !== undefined) return + void loadAgentPresets() + }, [connection.phase, session?.sessionId, session?.backend, loadAgentPresets]) + const [composerExpanded, setComposerExpanded] = useState(false) + const [reconnectingSession, setReconnectingSession] = useState(false) + const [newSessionPending, setNewSessionPending] = useState(false) + const creatingSessionRef = useRef(false) + const lastNewSessionTimeRef = useRef(0) + const { visibleMessages, visibleSections, uiBySection, visibleUiIds, queueItems, childSessions, teamState } = useChatTranscript({ session, sessions, messages, hostId }) + const panelOpen = composerExpanded || plusMenuOpen || modelPickerOpen || modePickerOpen || permissionPickerOpen + || workspacePickerOpen || toolPickerOpen || toolsMode !== undefined || trajectory || mentionType !== null + || promptsPickerOpen || promptsManagerOpen || promptEditing !== null || sessionInfoOpen + const { listRef, viewability, awayFromLatest, newContent, jumpToLatest, beginSendScroll, + onListLayout, onListContentSizeChange, onListScroll, onListDragEnd, onListMomentumEnd, + onScrollBeginDrag, onMomentumScrollBegin } = useChatScroll({ + session, messages, visibleMessages, visibleSections, memoryScope, memoryKey, + panelOpen, historyLoadingOlder, busy, setTrajectory, + }) + + const { colors } = useTheme() + const styles = useThemedStyles(createStyles) + // Landscape phones are short: keep the composer compact when the IME is up + // and let the list use a readable centred column on wide windows. + const { landscape, compactHeight, height, width, contentMaxWidth } = useResponsiveLayout() + const compactComposer = landscape || compactHeight + const composerInputMaxHeight = compactComposer ? Math.max(48, Math.min(96, Math.round(height * 0.22))) : 126 + // Tablets keep the session list visible beside the conversation. Short + // landscape phone windows stay single-pane; a wide tablet keeps the split + // even while the IME reduces the window height. + const tabletSplit = width >= 760 && (height >= 520 || width >= 1000) + useEffect(() => { + if (tabletSplit) setSessionsOpen(false) + }, [tabletSplit]) + const readableColumn = { width: '100%' as const, maxWidth: contentMaxWidth, alignSelf: 'center' as const } + + const openSessionsDrawer = useCallback(() => { + Keyboard.dismiss() + setMentionType(null) + void Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Light).catch(() => undefined) + // Reached from a conversation, so the sidebar may be swiped away again. + setDrawerSwipeUnlocked(true) + setSessionsOpen(true) + }, [setMentionType]) + + // Swipe right gesture to open sessions drawer with haptic feedback + const edgeSwipeResponder = useMemo( + () => + PanResponder.create({ + onStartShouldSetPanResponder: () => false, + onStartShouldSetPanResponderCapture: () => false, + onMoveShouldSetPanResponder: (_evt, g) => { + if (tabletSplit || sessionsOpen) return false + return shouldStartSwipeRightToOpen({ dx: g.dx, dy: g.dy, x0: g.x0 }, trajectory) + }, + onMoveShouldSetPanResponderCapture: (_evt, g) => { + if (tabletSplit || sessionsOpen) return false + return shouldStartSwipeRightToOpen({ dx: g.dx, dy: g.dy, x0: g.x0 }, trajectory) + }, + onPanResponderTerminationRequest: () => false, + onPanResponderRelease: (_evt, g) => { + if (tabletSplit || sessionsOpen) return + if (shouldConfirmSwipeRightOpen({ dx: g.dx, dy: g.dy, x0: g.x0, vx: g.vx })) { + openSessionsDrawer() + } + }, + }), + [sessionsOpen, tabletSplit, trajectory, openSessionsDrawer] + ) + const swipeStartRef = useRef<{ x0: number; y0: number; t0: number } | undefined>(undefined) + const swipeRightTouchProps = useMemo( + () => ({ + ...edgeSwipeResponder.panHandlers, + onTouchStart: (e: { nativeEvent: { pageX: number; pageY: number } }) => { + swipeStartRef.current = { x0: e.nativeEvent.pageX, y0: e.nativeEvent.pageY, t0: Date.now() } + }, + onTouchEnd: (e: { nativeEvent: { pageX: number; pageY: number } }) => { + const start = swipeStartRef.current + swipeStartRef.current = undefined + if (start === undefined || tabletSplit || sessionsOpen) return + const dx = e.nativeEvent.pageX - start.x0 + const dy = e.nativeEvent.pageY - start.y0 + const dt = Math.max(16, Date.now() - start.t0) + const vx = dx / dt + if ( + shouldStartSwipeRightToOpen({ dx, dy, x0: start.x0 }, trajectory) + && shouldConfirmSwipeRightOpen({ dx, dy, x0: start.x0, vx }) + ) { + openSessionsDrawer() + } + }, + }), + [edgeSwipeResponder, tabletSplit, sessionsOpen, trajectory, openSessionsDrawer], + ) + + // Artifact changes must invalidate FlatList cells even when their section is + // reused (a later turn can patch a card owned by an earlier turn). + const renderChatItem = useCallback(({ item }: { item: ChatSection }) => item.kind === 'process' + ? + : , + [busy, respondApproval, respondQuestion, uiBySection, visibleUiIds]) + + // Keep chat's back action at the top of the Android responder stack. The + // navigator also handles back globally, but a freshly mounted FlatList can + // otherwise win the first dispatch while its cells are being measured. + // Back inside a subagent child returns to its parent conversation (the + // official subagent UI's navigation), instead of leaving the chat entirely. + const backFromChat = () => { + const parent = session !== undefined && isSubagentSession(session) + ? sessions.find(item => item.sessionId === session.parentSessionId) + : undefined + if (parent !== undefined) { + Keyboard.dismiss() + void openSession(parent) + return + } + if (!tabletSplit && !sessionsOpen) { + openSessionsDrawer() + return + } + Keyboard.dismiss() + onBack() + } + const onBackRef = useRef(backFromChat) + onBackRef.current = backFromChat + useChatBackHandler(composerInputRef, () => onBackRef.current(), [ + { open: composerExpanded, close: () => setComposerExpanded(false) }, + { open: plusMenuOpen, close: () => { Keyboard.dismiss(); setPlusMenuOpen(false) } }, + { open: referenceChatOpen, close: () => setReferenceChatOpen(false) }, + { open: modelPickerOpen, close: () => setModelPickerOpen(false) }, + { open: modePickerOpen, close: () => setModePickerOpen(false) }, + { open: permissionPickerOpen, close: () => setPermissionPickerOpen(false) }, + { open: workspacePickerOpen, close: () => setWorkspacePickerOpen(false) }, + { open: toolPickerOpen, close: () => setToolPickerOpen(false) }, + { open: promptEditing !== null, close: () => { setPromptEditing(null); setPromptsManagerOpen(true) } }, + { open: promptsManagerOpen, close: () => { setPromptsManagerOpen(false); setPromptsPickerOpen(true) } }, + { open: promptsPickerOpen, close: () => setPromptsPickerOpen(false) }, + { open: toolsMode !== undefined, close: () => { setToolsMode(undefined); setFileLinkPath(undefined) } }, + { open: trajectory, close: () => setTrajectory(false) }, + ]) + + const botTeamState = useBotTeamStore(state => state.state) + + const openLink = useCallback((href: string) => { + // 1. Session reference navigation: dsh-session: + const targetSessionId = decodeSessionMentionUri(href) + if (targetSessionId !== undefined) { + const matchedBot = botTeamState?.bots.find(entry => entry.sessionId === targetSessionId) + if (matchedBot !== undefined) { + onBotModeChange?.(true) + onSelectBot?.(matchedBot.id) + return + } + const targetSession = sessions.find(candidate => candidate.sessionId === targetSessionId) + if (targetSession !== undefined) { + void openSession(targetSession) + } + return + } + + // 2. Safe external web URLs (http, https, mailto, www.*) + if (openSafeExternalUrl(href)) return + + // 3. Workspace file link + const path = markdownFilePath(href) + if (path === undefined) return + setFileLinkPath(path) + setToolsMode('files') + }, [openSession, session?.backend, sessions, botTeamState?.bots, onBotModeChange, onSelectBot]) + + const connected = connection.phase === 'connected' && !reconnectingSession + const hasActiveChatItem = visibleMessages.some(isActiveChatItem) + const replyActive = connected && (busy === 'send-message' || busy === 'stop-session' || (session?.running ?? false) || hasActiveChatItem) + + const lastAgentSessionByScopeRef = useRef>({}) + useEffect(() => { + if (!botMode && session !== undefined && !isKnownBotSessionId(session.sessionId, botTeamState, memoryScope)) { + lastAgentSessionByScopeRef.current[memoryScope] = session + } + }, [botMode, session, botTeamState, memoryScope]) + + const autoSelectingRef = useRef(false) + useEffect(() => { + if (botMode) return + const sessionIsBot = session !== undefined && isKnownBotSessionId(session.sessionId, botTeamState, memoryScope) + if (sessionIsBot) { + useAppStore.setState({ selectedSession: undefined }) + } + if ((session !== undefined && !sessionIsBot) || busy !== undefined || autoSelectingRef.current) return + const candidates = sessions.filter( + item => !archivedSessionIds.includes(item.sessionId) && !isKnownBotSessionId(item.sessionId, botTeamState, memoryScope), + ) + const remembered = lastAgentSessionByScopeRef.current[memoryScope] + const preferred = remembered + ? candidates.find(item => item.sessionId === remembered.sessionId && (item.backend ?? 'harness') === (remembered.backend ?? 'harness')) + : undefined + const target = preferred ?? [...candidates].sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0))[0] + if (target) { + const capturedScope = memoryScope + autoSelectingRef.current = true + void openSession(target).finally(() => { + if (browseScope(useAppStore.getState()) === capturedScope) { + autoSelectingRef.current = false + } else { + autoSelectingRef.current = false + } + }) + } + }, [botMode, session, connected, busy, sessions, archivedSessionIds, openSession, botTeamState, memoryScope]) + + useEffect(() => { + if (!replyActive) setComposingDuringRun(false) + else if (composingDuringRun) composerInputRef.current?.focus() + }, [replyActive, composingDuringRun]) + + const drawerElement = (inlineMode: boolean) => ( + { + markConversationChosen() + onSelectBot?.(id) + }} + onOpenDeviceInfo={() => { + Keyboard.dismiss() + onOpenDeviceInfo?.() + }} + onOpenWorkspaces={() => { + Keyboard.dismiss() + if (onOpenWorkspaces) onOpenWorkspaces() + }} + onBack={inlineMode ? undefined : () => { + Keyboard.dismiss() + setSessionsOpen(false) + }} + backLabel={strings.chat.backToChat} + onClose={() => { + if (inlineMode) Keyboard.dismiss() + else setSessionsOpen(false) + }} + onOpenAutomationTasks={() => { + Keyboard.dismiss() + setAutomationTasksOpen(true) + }} + onOpenPlugins={pluginsAvailable ? () => { + Keyboard.dismiss() + setPluginsOpen(true) + } : undefined} + onOpenHostSwitcher={onOpenHostSwitcher ? () => { + Keyboard.dismiss() + onOpenHostSwitcher() + } : undefined} + onOpenAbout={onOpenAbout} + onOpenSettings={() => { + Keyboard.dismiss() + onOpenSettings?.() + }} + onSelect={async next => { + markConversationChosen() + onBotModeChange?.(false) + const pending = openSession(next) + const visible = useAppStore.getState().selectedSession?.sessionId === next.sessionId + if (!inlineMode && visible) { + setSessionsOpen(false) + } + if (await pending && !inlineMode && !visible) { + setSessionsOpen(false) + } + }} + /> + ) + + if (botMode) { + return ( + + + {tabletSplit && {drawerElement(true)}} + + onSelectBot?.(id)} + onAgentMode={() => onBotModeChange?.(false)} + onOpenDrawer={openSessionsDrawer} + onDeviceInfo={() => onOpenDeviceInfo?.()} + onMore={() => onOpenSettings?.()} + splitView={tabletSplit} + drawerOpen={sessionsOpen || tabletSplit} + /> + + + {sessionsOpen && !tabletSplit && drawerElement(false)} + setPluginsOpen(false)} /> + setAutomationTasksOpen(false)} + onOpenSession={async targetSession => { + setAutomationTasksOpen(false) + markConversationChosen() + setSessionsOpen(false) + onBotModeChange?.(false) + await openSession(targetSession) + }} + onNewTask={async () => { + setAutomationTasksOpen(false) + markConversationChosen() + setSessionsOpen(false) + onBotModeChange?.(false) + await createSession(workspaces[0]?.workspaceId) + }} + /> + + ) + } + + if (session === undefined) { + const emptyHeader = ( + + void createSession(workspaces[0]?.workspaceId)} + disabled={!connected || busy !== undefined} + /> + {!connected && ( + { + if (onOpenHostSwitcher) onOpenHostSwitcher() + else void reconnect() + }} + /> + )} + + } + /> + ) + return ( + + + {tabletSplit && {drawerElement(true)}} + + + {headerHeight => ( + + {busy !== undefined ? ( + + + + ) : ( + + )} + + )} + + + + {sessionsOpen && !tabletSplit && drawerElement(false)} + setPluginsOpen(false)} /> + setAutomationTasksOpen(false)} + onOpenSession={async targetSession => { + setAutomationTasksOpen(false) + markConversationChosen() + setSessionsOpen(false) + await openSession(targetSession) + }} + onNewTask={async () => { + setAutomationTasksOpen(false) + markConversationChosen() + setSessionsOpen(false) + await createSession(workspaces[0]?.workspaceId) + }} + /> + + ) + } + + const submit = async () => { + if (session === undefined) return + // Read the live ref: the render-closure `draft` can lag the last keystrokes + // typed right before the tap, silently dropping the tail of the message. + const submittedDraft = draftRef.current + const rawText = submittedDraft.trim() + const submittedReferences = stagedReferences + const refPrefix = submittedReferences.map(item => item.mentionText.trim()).join(' ') + const text = [refPrefix, rawText].filter(Boolean).join(' ') + const submittedQuotes = quotes + const submittedImages = images + const submittedFiles = stagedFiles + // Everything below this gate clears the composer, so an offline tap has to + // stop here: the draft stays, no optimistic row is created and the manual + // send after reconnection is the only submission path. + const intent = submitIntent({ + connected, sendReady, permissionSelecting, uploading: uploadingRef.current, + hasContent: text.length > 0 || submittedQuotes.length > 0 || images.length > 0 || stagedFiles.length > 0, + }) + if (intent !== 'submit') return + let promptWithQuotes = text + if (submittedQuotes.length > 0) { + const formattedQuotes = submittedQuotes.map(formatQuoteText).join('\n\n') + promptWithQuotes = text.length > 0 ? `${formattedQuotes}\n\n${text}` : formattedQuotes + } + let promptText = promptWithQuotes + const targetSessionId = session.sessionId + const sendSessionGen = sessionGenerationRef.current + if (submittedFiles.length > 0) { + const controller = new AbortController() + uploadControllerRef.current?.abort() + uploadControllerRef.current = controller + uploadingRef.current = true + setUploadingFiles(true) + try { + const rpc = requireConnectionRpc() + const uploaded = await uploadStagedFilesToWorkspace(rpc, session.sessionId, submittedFiles, controller.signal) + // A navigation, session switch, reconnection or unmount during a long + // upload must never leak the prompt into another conversation. + if (controller.signal.aborted) return + if (sessionGenerationRef.current !== sendSessionGen + || useAppStore.getState().selectedSession?.sessionId !== targetSessionId) return + if (useAppStore.getState().connection.phase !== 'connected') { + Alert.alert(strings.messageActions.failed, strings.messageActions.unavailable) + return + } + promptText = formatUploadedFilesReferencePrompt(promptWithQuotes, uploaded) + } catch (uploadError) { + // Aborted uploads already restored (or discarded) their composer state; + // do not surface a cancellation as a failure. + if (controller.signal.aborted || (uploadError as Error | undefined)?.name === 'AbortError') return + const isUnsupported = (uploadError as { code?: string })?.code === 'FEATURE_NOT_SUPPORTED' + const errorMsg = isUnsupported + ? strings.chat.uploadUnavailable + : strings.chat.uploadFileFailed(submittedFiles[0]?.name ?? '', (uploadError as Error).message) + Alert.alert(strings.messageActions.failed, errorMsg) + return + } finally { + if (uploadControllerRef.current === controller) { + uploadControllerRef.current = undefined + uploadingRef.current = false + setUploadingFiles(false) + } + } + } + if (promptText.length > LONG_DRAFT_MAX) { + Alert.alert(strings.chat.draftTooLongTitle, strings.chat.draftTooLong(LONG_DRAFT_MAX)) + return + } + applyDraft('') + setQuotes([]) + setImages([]) + setStagedFiles([]) + setStagedReferences([]) + setMentionType(null) + resetSelection() + const restoreScrollAfterRejectedSend = beginSendScroll() + const outcome = await sendMessage(promptText, submittedImages) + if (outcome === 'rejected') { + restoreScrollAfterRejectedSend() + // Nothing was persisted (command failure): restore the draft without + // clobbering input typed while the send was in flight. + if (sessionGenerationRef.current === sendSessionGen && useAppStore.getState().selectedSession?.sessionId === targetSessionId) { + const inFlight = useBrowseMemory.getState().entries[memoryKey]?.draft ?? '' + setDraft(inFlight.length === 0 ? submittedDraft : `${submittedDraft}\n${inFlight}`) + setQuotes(previous => previous.length === 0 ? submittedQuotes : [...submittedQuotes, ...previous]) + setImages(previous => previous.length === 0 ? submittedImages : [...submittedImages, ...previous]) + setStagedReferences(previous => previous.length === 0 ? submittedReferences : [...submittedReferences, ...previous]) + setStagedFiles(current => { + const combined = [...submittedFiles, ...current] + let acc = 0 + return combined.filter(f => { + if (acc + f.size <= MAX_TOTAL_FILES_BYTES) { + acc += f.size + return true + } + return false + }) + }) + } + Alert.alert(strings.messageActions.failed, useAppStore.getState().error ?? strings.messageActions.unavailable) + } else if (outcome === 'sent') { + const result = useAppStore.getState().commandResult + if (result?.sessionId === session.sessionId && useAppStore.getState().selectedSession?.sessionId === session.sessionId) { + Alert.alert(strings.mention.commandSection, result.text) + useAppStore.setState({ commandResult: undefined }) + } + } + // 'kept': the row stays in the timeline with an inline failed/unconfirmed + // state and a retry affordance — no Alert and no draft restore. + } + + const openPlusMenu = () => { + // The composer TextInput often still owns focus when the user taps +. + // Dismissing the IME first gives the transparent Modal the full window and + // keeps its sheet (including the close target) out of the keyboard's touch + // region on Android. + Keyboard.dismiss() + const node = composerAnchorRef.current + if (node === null) { + setSheetAnchor(undefined) + setPlusMenuOpen(true) + return + } + // One frame of measurement so the sheet can grow out of the composer + // instead of the screen edge; a missing measurement falls back to a + // bottom rise inside SheetModal. + node.measureInWindow((x, y, width, height) => { + setSheetAnchor(width > 0 && height > 0 ? { x, y, width, height } : undefined) + setPlusMenuOpen(true) + }) + } + + const closePlusMenu = () => { + Keyboard.dismiss() + setPlusMenuOpen(false) + } + + const openPromptsPicker = () => { + Keyboard.dismiss() + setMentionType(null) + setPromptsPickerOpen(true) + } + + const handleBack = () => { + Keyboard.dismiss() + if (trajectory) { + setTrajectory(false) + return + } + onBackRef.current() + } + + const pickModel = async (group: ModelProviderGroup, model: ModelCatalogModel, reasoningEffort?: string) => { + setModelPickerOpen(false) + await selectModel({ + provider: group.id, + model: model.id, + ...(reasoningEffort === undefined ? {} : { reasoningEffort }), + }) + } + + const reconnectCurrentSession = async () => { + if (reconnectingSession) return + setReconnectingSession(true) + try { + await reconnect() + } finally { + setReconnectingSession(false) + } + } + + const supportsModeSelection = !['codex', 'cursor', 'antigravity', 'pi', 'opencode', 'claude', 'hermes'].includes(session.backend ?? 'harness') + const currentAgentPresetId = session.agentPreset ?? agentPresetOptions?.find(option => option.isDefault)?.id + const currentWorkspace = workspaces.find(workspace => workspace.sessionIds.includes(session.sessionId)) + const workspaceLabel = currentWorkspace?.title ?? strings.chat.workspaceNone + const currentPresetRow = agentPresetOptions?.find(option => option.id === currentAgentPresetId) + const modeLabel = currentAgentPresetId === undefined + ? strings.chat.modeDefault + : currentPresetRow === undefined + ? builtinPresetName(currentAgentPresetId) ?? currentAgentPresetId + : agentPresetName(currentPresetRow) + + const connectionRetrying = reconnectingSession || connection.phase === 'connecting' || connection.phase === 'reconnecting' + const sendReady = connected && !busy?.startsWith('session:') + && (session.backend !== 'codex' || codexReadySessionId === session.sessionId) + const hasComposerContent = draft.trim().length > 0 || quotes.length > 0 || images.length > 0 || stagedFiles.length > 0 || stagedReferences.length > 0 + const compactRunning = replyActive && !hasComposerContent && !composingDuringRun + const stopping = busy === 'stop-session' + // Action entries (attachments, tools, prompts) still need the channel, but the + // text field itself only blocks on composer-local states so an offline draft + // can be typed, edited and kept for the manual send after reconnection. + const inputEditable = composerEditable({ permissionSelecting, uploading: uploadingFiles }) + const composerDisabled = !connected || permissionSelecting || uploadingFiles + const sendDisabled = !sendReady || permissionSelecting || !hasComposerContent || uploadingFiles + const projectedPermissions = sessionPermissions(session) + const permissions = projectedPermissions === undefined ? undefined : { ...projectedPermissions, options: permissionOptions ?? projectedPermissions.options } + const currentPermission = permissions?.options.find(option => option.value === permissions.currentValue) + const currentModel = sessionModels?.groups + .find(group => group.id === sessionModels.current.provider) + ?.models.find(model => model.id === sessionModels.current.model) + const currentEffortId = sessionModels?.current.reasoningEffort ?? currentModel?.reasoning?.defaultEffort + const currentEffortName = currentModel?.reasoning?.efforts.find(effort => effort.id === currentEffortId)?.name + ?? currentEffortId + const currentModelName = currentModel?.name ?? sessionModels?.current.model + const currentModelLabel = currentEffortName === undefined + ? currentModelName + : `${currentModelName} · ${currentEffortName}` + + const pickMode = async (preset: string) => { + setModePickerOpen(false) + if (!connected || preset === session.agentPreset) return + const applied = await selectAgentPreset(preset) + if (!applied) { + Alert.alert( + strings.chat.modeLockedTitle, + session.blank ? strings.chat.modeSelectFailedBody : strings.chat.modeLockedBody, + ) + } + } + + const pickToolMode = (mode: 'files' | 'terminal') => { + setToolPickerOpen(false) + setFileLinkPath(undefined) + setToolsMode(mode) + } + + const sessionBlank = visibleMessages.length === 0 && session.blank !== false + + const startNewSession = async () => { + if (!connected) { + Alert.alert(strings.chat.newChatFailedTitle, strings.chat.offlineNotice) + return + } + const now = Date.now() + if (now - lastNewSessionTimeRef.current < 800) return + if (creatingSessionRef.current || newSessionPending || busy !== undefined) return + + if (sessionBlank) { + Keyboard.dismiss() + setMentionType(null) + applyDraft('') + setImages([]) + return + } + + creatingSessionRef.current = true + lastNewSessionTimeRef.current = now + setNewSessionPending(true) + try { + const created = await createSession(currentWorkspace?.workspaceId) + if (created) { + onNewSession?.() + } else { + Alert.alert(strings.chat.newChatFailedTitle, strings.chat.newChatFailedBody) + } + } finally { + creatingSessionRef.current = false + setNewSessionPending(false) + } + } + + const sendPrompt = async (prompt: CustomPrompt) => { + setPromptsPickerOpen(false) + if (!connected) { + Alert.alert(strings.chat.toolPromptSendFailed, strings.chat.offlineNotice) + return + } + const outcome = await sendMessage(prompt.text) + if (outcome === 'sent') AccessibilityInfo.announceForAccessibility(strings.chat.toolPromptSent(prompt.title)) + else if (outcome === 'rejected') Alert.alert(strings.chat.toolPromptSendFailed, strings.chat.toolPromptSendFailed) + } + + const moveSessionToWorkspace = async (workspace: WorkspaceView) => { + if (!connected) { + Alert.alert(strings.chat.moveFailedTitle, strings.chat.offlineNotice) + return + } + const previousId = session.sessionId + const opened = await createSession(workspace.workspaceId) + if (!opened) { + Alert.alert(strings.chat.moveFailedTitle, strings.chat.moveFailedBody) + return + } + // A blank conversation carries nothing to lose: recreate it inside the + // chosen workspace and archive the old placeholder so it reads as a move. + if (sessionBlank) await archiveSession(previousId) + } + + const pickWorkspace = (workspace: WorkspaceView) => { + setWorkspacePickerOpen(false) + if (!connected) { + Alert.alert(strings.chat.moveFailedTitle, strings.chat.offlineNotice) + return + } + if (workspace.sessionIds.includes(session.sessionId)) return + if (sessionBlank) { + void moveSessionToWorkspace(workspace) + return + } + Alert.alert( + strings.chat.moveStartedTitle, + strings.chat.moveStartedBody(workspace.title), + [ + { text: strings.common.cancel, style: 'cancel' }, + { text: strings.chat.moveStartedConfirm, onPress: () => void moveSessionToWorkspace(workspace) }, + ], + ) + } + + const pickPermission = (preset: string) => { + setPermissionPickerOpen(false) + const apply = () => void selectPermission(preset) + if (preset === 'danger-full-access') { + Alert.alert( + session.backend === 'codex' ? strings.chat.codexFullAccessTitle : strings.chat.fullAccessTitle, + session.backend === 'codex' ? strings.chat.codexFullAccessBody : strings.chat.fullAccessBody, + [ + { text: strings.common.cancel, style: 'cancel' }, + { text: strings.chat.enable, style: 'destructive', onPress: apply }, + ], + ) + } else apply() + } + + const header = <> + { Keyboard.dismiss(); setMentionType(null); setSessionInfoOpen(true) }} + titleLines={1} + onBack={tabletSplit ? undefined : trajectory ? handleBack : openSessionsDrawer} + backIcon={trajectory ? ArrowLeft : Menu} + backLabel={trajectory ? strings.common.back : strings.chat.openHostSessions} + action={<> + { Keyboard.dismiss(); setMentionType(null); setTrajectory(value => !value) }} /> + void startNewSession()} disabled={newSessionPending || busy !== undefined} /> + } + /> + {!connected && ( + void reconnectCurrentSession()}> + + + {connectionRetrying ? <>{strings.chat.reconnecting.replace(/…$/, '')} : strings.chat.offline} + + + )} + {connected && busy === `session:${session.sessionId}` && ( + + + + {strings.chat.syncingHistory} + + + )} + + return ( + + {memoryError !== undefined && {memoryError}} + + {tabletSplit && ( + + {drawerElement(true)} + + )} + + {/* Messages scroll beneath the frosted header; the trajectory view keeps its own fixed search bar below it. */} + {headerHeight => {trajectory ? } hasMore={historyHasMore} loading={historyLoadingOlder} loadOlder={() => void loadOlderHistory()} renderItem={item => } /> : <> + item.key} + renderItem={renderChatItem} + initialNumToRender={6} + maxToRenderPerBatch={6} + updateCellsBatchingPeriod={16} + windowSize={7} + removeClippedSubviews + keyboardShouldPersistTaps="handled" + keyboardDismissMode="on-drag" + onLayout={onListLayout} + onContentSizeChange={onListContentSizeChange} + onScroll={onListScroll} + onViewableItemsChanged={viewability} + onScrollToIndexFailed={info => { + listRef.current?.scrollToOffset({offset: Math.max(0, info.averageItemLength * info.index), animated: false}) + }} + maintainVisibleContentPosition={{minIndexForVisible: 0}} + scrollEventThrottle={16} + onScrollBeginDrag={onScrollBeginDrag} + onScrollEndDrag={onListDragEnd} + onMomentumScrollBegin={onMomentumScrollBegin} + onMomentumScrollEnd={onListMomentumEnd} + ListEmptyComponent={busy === `session:${session.sessionId}` + ? + : } + ListHeaderComponent={historyHasMore ? ( + void loadOlderHistory()} + style={styles.olderButton} + > + {historyLoadingOlder + ? + : {strings.chat.older}} + + ) : undefined} + /> + {/* Floats over the last row only while an older turn owns the viewport. */} + {awayFromLatest && ( + + + [styles.latestTurnButton, pressed && styles.latestTurnButtonPressed]} + > + + + + + )} + }} + + + {mentionType !== null && ( + { closeMention(); Keyboard.dismiss() }} + accessibilityRole="button" + accessibilityLabel={strings.common.close} + /> + )} + + + {connected && (session.backend === undefined || session.backend === 'harness' || Boolean(session.projections?.values?.todos) || Boolean(session.projections?.values?.goal) || childSessions.length > 0 || (teamState !== undefined && teamState.members.length > 0)) && ( + void openSession(targetSession)} + /> + )} + {queueItems.length > 0 && } + + {images.length > 0 && ( + + {images.map((image, index) => ( + + + setImages(current => current.filter((_, imageIndex) => imageIndex !== index))} + style={styles.removeImageButton} + > + + + + ))} + + )} + {stagedFiles.length > 0 && ( + + {stagedFiles.map((file, index) => ( + + + + {file.name} + {formatFileBytes(file.size)} + + setStagedFiles(current => current.filter((_, fileIndex) => fileIndex !== index))} + style={styles.removeFileButton} + > + + + + ))} + + )} + {uploadingFiles && ( + + {strings.chat.uploadingFile(stagedFiles[0]?.name ?? '')} + + )} + setStagedReferences(current => current.filter(item => item.sessionId !== sid))} + /> + setQuotes(current => current.filter((_, i) => i !== index))} + replyActive={replyActive} stopping={stopping} compactRunning={compactRunning} + hasComposerContent={hasComposerContent} connected={connected} editable={inputEditable} + composerDisabled={composerDisabled} sendDisabled={sendDisabled} + compactComposer={compactComposer} composerInputMaxHeight={composerInputMaxHeight} + model={{ available: sessionModels !== undefined, label: currentModelLabel, selecting: modelSelecting, onOpen: () => setModelPickerOpen(true) }} + promptsPickerOpen={promptsPickerOpen} onExpand={() => setComposingDuringRun(true)} + onOpenExpand={() => setComposerExpanded(true)} + onOpenActions={openPlusMenu} onOpenPrompts={openPromptsPicker} + onSubmit={() => void submit()} onStop={() => void stopSession()} + /> + + + setComposerExpanded(false)} + backend={session.backend} + draft={draft} + quotes={quotes} + onRemoveQuote={index => setQuotes(current => current.filter((_, i) => i !== index))} + input={mentionInput} + replyActive={replyActive} + stopping={stopping} + sendDisabled={sendDisabled} + onSubmit={() => void submit()} + onStop={() => void stopSession()} + /> + + + + setReferenceChatOpen(true) : undefined} + onOpenWorkspace={() => setWorkspacePickerOpen(true)} onOpenMode={() => setModePickerOpen(true)} + onOpenTools={() => setToolPickerOpen(true)} onOpenPermissions={() => setPermissionPickerOpen(true)} + /> + + setReferenceChatOpen(false)} + onPick={(_mentionText, candidate) => { + setStagedReferences(current => + current.some(item => item.sessionId === candidate.sessionId) + ? current + : [...current, candidate], + ) + }} + /> + + setModelPickerOpen(false)} + onPick={pickModel} + /> + {toolsMode !== undefined && connected && ( + { setToolsMode(undefined); setFileLinkPath(undefined) }} + /> + )} + setPermissionRevision(v => v + 1)} visible={permissionPickerOpen} permissions={permissions} onClose={() => setPermissionPickerOpen(false)} onPick={pickPermission} /> + setModePickerOpen(false)} onPick={pickMode} /> + setSessionInfoOpen(false)} + onOpenWorkspace={() => { + setSessionInfoOpen(false) + if (onOpenWorkspaces !== undefined) onOpenWorkspaces(currentWorkspace === undefined ? undefined : workspaceStableKey(currentWorkspace, hostPlatform)) + else openSessionsDrawer() + }} + /> + {sessionsOpen && !tabletSplit && drawerElement(false)} + setWorkspacePickerOpen(false)} onPick={pickWorkspace} onManage={() => { setWorkspacePickerOpen(false); openSessionsDrawer() }} /> + setToolPickerOpen(false)} onPick={pickToolMode} /> + setPromptsPickerOpen(false)} + onPick={prompt => void sendPrompt(prompt)} + onManage={() => { setPromptsPickerOpen(false); setPromptsManagerOpen(true) }} + /> + { setPromptsManagerOpen(false); setPromptsPickerOpen(true) }} + onClose={() => setPromptsManagerOpen(false)} + onAdd={() => { setPromptsManagerOpen(false); setPromptEditing('new') }} + onEdit={prompt => { setPromptsManagerOpen(false); setPromptEditing(prompt) }} + onDelete={prompt => { + Alert.alert(strings.chat.toolPromptDeleteTitle(prompt.title), strings.chat.toolPromptDeleteBody, [ + { text: strings.common.cancel, style: 'cancel' }, + { text: strings.common.delete, style: 'destructive', onPress: () => void deletePrompt(prompt) }, + ]) + }} + /> + { setPromptEditing(null); setPromptsManagerOpen(true) }} + onClose={() => setPromptEditing(null)} + onSave={(title, text) => void savePromptEdit(title, text)} + /> + setPreviewImageUri(undefined)} + statusBarTranslucent + > + + setPreviewImageUri(undefined)} /> + {previewImageUri !== undefined && ( + + )} + setPreviewImageUri(undefined)} + accessibilityRole="button" + accessibilityLabel={strings.common.close} + hitSlop={12} + > + + + + + setPluginsOpen(false)} /> + setAutomationTasksOpen(false)} + onOpenSession={async targetSession => { + setAutomationTasksOpen(false) + await openSession(targetSession) + }} + onNewTask={async () => { + setAutomationTasksOpen(false) + await createSession(currentWorkspace?.workspaceId) + }} + /> + + ) +} + +export { ModalSurface,usePickerListMaxHeight } from './chat/modal'