import { ChildThreadApprovals } from "./chat/ChildThreadApprovals";
import { workspaceAreaProps } from "../lib/workspaceFocus";
import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients";
import { resolveNewThreadModelSelection } from "@t3tools/shared/usageLimits";
import { queuedRunEditBlockedReason } from "@t3tools/client-runtime/queued-run-edit";
import { ScrollToEndButton, WorkspaceFileDropOverlay } from "./chat/TimelineOverlays";
import { usePasteToFocusComposer } from "./chat/usePasteToFocusComposer";
import { configuredHostedAppUrl } from "../hostedPairing";
import { announcedRun, isDetailBehindShell } from "./chat/threadActivityAnnouncement";
import {
deriveAvailableRevertTurnCounts,
deriveThreadPendingBackgroundTasks,
presentThreadShellFromProjection,
} from "./ChatView.logic";
import { usePullRequestDraftThread } from "./chat/usePullRequestDraftThread";
import { useComposerSelection } from "./chat/useComposerSelection";
import { useProjectCloneBanner } from "./chat/useProjectCloneBanner";
import { useAttachmentPreviewHandoff } from "./chat/useAttachmentPreviewHandoff";
import {
applyOptimisticUserMessagesAction,
createOptimisticBlobPreviews,
emptyOptimisticUserMessages,
reconcileOptimisticUserMessages,
} from "./chat/optimisticUserMessages";
import { useTimelineRewind } from "./chat/useTimelineRewind";
import { useThreadLifecycle } from "./chat/useThreadLifecycle";
import { useRightPanelActions } from "./chat/useRightPanelActions";
import { type TerminalLaunchContext, useChatTerminalActions } from "./chat/useChatTerminalActions";
import { useComposerSend } from "./chat/useComposerSend";
import { useComposerResume } from "./chat/useComposerResume";
import { useImplementPlanInNewThread } from "./chat/useProposedPlanSend";
import { ThreadFind, ThreadFindCanvas } from "./chat/ThreadFindProvider";
import { closeThreadFind, openThreadFind, useThreadFindOpen } from "./chat/threadFindStore";
import { THREAD_FIND_BAR_RESERVED_HEIGHT } from "./chat/ThreadFindBar";
import { usageLimitRecoveryBannerItem } from "./chat/UsageLimitRecoveryBanner";
import { resolveDraftHeroState } from "./ChatView.logic";
import { useQueuedRunEdit } from "./chat/useQueuedRunEdit";
import { recallCheckoutIsRepo, rememberCheckoutIsRepo } from "./ChatView.logic";
import { useLogicalProjectEnvironments } from "../hooks/useLogicalProjectEnvironments";
import { useStableCallback } from "../hooks/useStableCallback";
import { useProjectScriptEditing } from "./chat/useProjectScriptEditing";
import { RightPanelSurfaceContent } from "./chat/RightPanelSurfaceContent";
import { usePendingThreadRequests } from "./chat/usePendingThreadRequests";
import { isScratchProject } from "@t3tools/client-runtime/state/projects";
import { visibleThreadPullRequests } from "@t3tools/shared/threadPullRequests";
import type { UsageLimitSourceSnapshots } from "@t3tools/contracts";
import { feedbackBannerItem } from "./chat/ComposerFeedback";
import { freshSessionBannerItem } from "./chat/ComposerFreshSession";
import { armFreshSession, disarmFreshSession, useFreshSessionArmed } from "./chat/freshSessionArms";
import { useUsageLimitsPanel } from "./chat/useUsageLimitsPanel";
import { useWorktreeSetup } from "./chat/useWorktreeSetup";
import { useChatShortcuts } from "./chat/useChatShortcuts";
import { ChatBannerLane } from "./chat/ChatBannerLane";
import * as Schema from "effect/Schema";
import {
AuthOrchestrationOperateScope,
AuthSourceControlWriteScope,
AuthPreviewOperateScope,
AuthTerminalOperateScope,
type AssistantCitation,
type ChatFileAttachment,
isProviderNativeSubagentThread,
orchestrationV2WorktreePending,
type EnvironmentId,
type MessageId,
type ModelSelection,
type PreviewAnnotationPayload,
ProviderInstanceId,
type ServerProvider,
type ScopedThreadRef,
type ThreadId,
ProviderInteractionMode,
resolveIdleCompaction,
RuntimeMode,
} from "@t3tools/contracts";
import {
deriveProviderSubagentStatus,
deriveProviderExtensionStatuses,
deriveReportedModelSelection,
deriveResumableRunId,
formatModelSelectionEffort,
deriveRunlessWorkStartedAt,
deriveThreadActivityRun,
deriveLatestThreadRun,
deriveThreadStructureRuntime,
limitRecoveryOwnsSnooze,
} from "@t3tools/client-runtime/state/thread-execution";
import {
resolveWorkflowOpening,
workflowOpeningParentThreadId,
} from "@t3tools/client-runtime/state/subagentRuntime";
import {
getUserQueuedThreadRuns,
threadSupportsProviderHandoff,
} from "@t3tools/client-runtime/state/thread-workflows";
import { resolvePendingHandoff } from "@t3tools/client-runtime/handoff";
import { HandoffRow } from "./chat/V2LifecycleRow";
import {
codexFeedbackMessage,
deriveWorkspaceMutationId,
isCompleteTurnItemRow,
shouldShowLoadEarlierControl,
type CodexFeedbackSubmission,
} from "@t3tools/client-runtime/state/threads";
import {
parseScopedThreadKey,
scopedThreadKey,
scopeProjectRef,
scopeThreadRef,
} from "@t3tools/client-runtime/environment";
import { formatModelSlugName, resolveSelectableModel } from "@t3tools/shared/model";
import { projectScriptCwd, resolveProjectScripts } from "@t3tools/shared/projectScripts";
import { resolveProjectSettings } from "@t3tools/shared/projectSettings";
import { resolveThreadReferenceCopyTarget } from "@t3tools/client-runtime/thread-reference";
import { resolveTerminalSessionLabel } from "@t3tools/shared/terminalLabels";
import { useAtomValue } from "@effect/atom-react";
import { type SetStateAction, use, useEffect, useLayoutEffect, useRef, useState } from "react";
import { BackgroundThreadContext } from "./chat/backgroundThread";
import { WorkspaceMutationIdContext } from "./chat/ChatMarkdownMedia";
import { useLocation, useNavigate } from "@tanstack/react-router";
import { assistantCitationFromLocation } from "../lib/assistantCitationNavigation";
import type { AssistantCitationSourceAnchor } from "~/lib/assistantTextSelection";
import { useStore } from "zustand";
import { shallow } from "zustand/vanilla/shallow";
import { useShallow } from "zustand/react/shallow";
import {
isAtomCommandInterrupted,
mapAtomCommandResult,
squashAtomCommandFailure,
type AtomCommandResult,
} from "@t3tools/client-runtime/state/runtime";
import { AsyncResult } from "effect/reactivity";
import { isElectron } from "../env";
import { useDiffPanelStore } from "../diffPanelStore";
import { useActiveThreadRef } from "../hooks/useActiveThreadRef";
import { composerRequiresModifier } from "../composer-logic";
import {
derivePhase,
deriveActiveWorkStartedAt,
deriveCanInterruptRunningThread,
findLatestProposedPlan,
findRevertCheckpoint,
hasActionableProposedPlan,
isLatestRunSettled,
} from "../session-logic";
import { type LegendListRef } from "@legendapp/list/react";
import { useWorkspaceMutationRefresh } from "../hooks/useWorkspaceMutationRefresh";
import { DEFAULT_INTERACTION_MODE, type ChatMessage } from "../types";
import { buildThreadRouteParams } from "../threadRoutes";
import { useTheme } from "../hooks/useTheme";
import { copyThreadReference } from "../lib/copyThreadReference";
import { subscribeSnapShotComposerFocus } from "../lib/desktopSnapShot";
import { useMediaQuery } from "../hooks/useMediaQuery";
import { FileMetadataThreadProvider } from "../hooks/FileMetadataThreadProvider";
import { RIGHT_PANEL_INLINE_LAYOUT_MEDIA_QUERY } from "../rightPanelLayout";
import { PopoverCreateHandle } from "./ui/popover";
import {
selectActiveRightPanel,
selectActiveRightPanelSurface,
selectThreadPanelOpen,
selectThreadRightPanelState,
useRightPanelStore,
} from "../rightPanelStore";
import { isPreviewSupportedInRuntime, useThreadPreviewState } from "../previewStateStore";
import { previewRuntimeTabId } from "../browser/previewRuntimeTabId";
import {
ThreadPreviewMiniPlayer,
useThreadPreviewCanvasSource,
} from "./preview/ThreadPreviewMiniPlayer";
import { createChatCanvasStore, resolveChatCanvasModel } from "./chat/canvasStore";
import { usePreviewSession } from "./preview/usePreviewSession";
import { getConfiguredPreviewUrls } from "./preview/previewEmptyStateLogic";
import {
previewMiniPlayerSourceKey,
selectThreadPreviewMiniPlayer,
usePreviewMiniPlayerStore,
} from "../previewMiniPlayerStore";
import { threadPullRequestPanelTarget } from "./pullRequest/pullRequestDetail.logic";
import { LinkPullRequestDialogHost } from "./pullRequest/LinkPullRequestDialog";
import { GuestPendingMessages } from "./chat/GuestShareControls";
import { useDeviceState } from "~/state/device";
import { BranchToolbar, type BranchToolbarHandle } from "./BranchToolbar";
import { ComposerContextPermissions } from "./ComposerContextPermissions";
import { makeWorkspaceFileDropHandlers } from "./chat/workspaceFileDrop";
import { isEditableFocused } from "../lib/editableFocus";
import { DEFAULT_RESOLVED_KEYBINDINGS } from "@t3tools/shared/keybindings";
import { shortcutLabelForCommand } from "../keybindings";
import { cn } from "~/lib/utils";
import { isModelPickerOpen } from "../modelPickerVisibility";
import { COLLAPSED_SIDEBAR_TITLEBAR_INSET_CLASS } from "~/workspaceTitlebar";
import { toastManager } from "./ui/toast";
import { projectScriptIdFromCommand } from "~/projectScripts";
import { newMessageId } from "~/lib/utils";
import { isInSideChatPane, type SideChatParentPanel } from "~/lib/sideChatPane";
import {
NO_PROVIDER_MODEL_SELECTION,
providerInstanceEntriesFor,
resolveProjectDefaultProviderModelSelection,
shouldShowInstanceBadge,
} from "../providerInstances";
import {
useClientSettings,
useClientSettingsHydrated,
useEnvironmentSettings,
} from "../hooks/useSettings";
import { useNowMinute } from "../hooks/useNowMinute";
import { usePanelAnimationSettings, usePanelPresence } from "../panelAnimations";
import { useNewThreadHandler } from "../hooks/useHandleNewThread";
import { useOpenPanelPullRequestUrl } from "../hooks/useOpenPanelPullRequestUrl";
import { isPreviewFocused } from "../lib/previewFocus";
import { focusTerminalOnThreadEnter, getTerminalFocusOwner } from "../lib/terminalFocus";
import {
deriveLogicalProjectKeyFromSettings,
selectProjectGroupingSettings,
} from "@t3tools/client-runtime/state/project-grouping";
import {
isSameSidebarThreadRef,
useSidebarPendingFileDropStore,
} from "../sidebarPendingFileDropStore";
import {
composerDraftHasUserContent,
type ComposerFileAttachment,
type ComposerImageAttachment,
type DraftThreadEnvMode,
useComposerDraftStore,
DraftId,
} from "../composerDraftStore";
import { type TerminalContextDraft } from "../lib/terminalContext";
import { collectInlineContextIds } from "../lib/composerContextReferences";
import { selectThreadTerminalUiState, useTerminalUiStateStore } from "../terminalUiStateStore";
import { useKnownTerminalSessions, useThreadRunningTerminalIds } from "../state/terminalSessions";
import { useEnvironmentQuery } from "../state/query";
import { useEnvironmentScope } from "~/state/session";
import {
primaryServerAvailableEditorsAtom,
primaryServerKeybindingsAtom,
serverEnvironment,
} from "../state/server";
import { threadEnvironment } from "../state/threads";
import { resolveProviderSkillsForCwd } from "@t3tools/client-runtime/providerSkills";
import { vcsEnvironment } from "../state/vcs";
import {
type EnvironmentPresentation,
useEnvironment,
useEnvironmentProviders,
useEnvironments,
usePrimaryEnvironment,
} from "../state/environments";
import {
resolveThreadDetailRef,
useEnvironmentSupportsServerBrowser,
useProject,
useQuietThreadProjection,
useThreadUpdatedAt,
useThreadLastVisitedAt,
useQuietThreadVisibleTurnItems,
useThreadStatus,
useThreadHistory,
useQuietThreadShell,
useThreadCheckpointSummaries,
} from "../state/entities";
import { useEnvironmentShellHasSnapshot } from "../state/shell";
import { ChatComposer, type ChatComposerHandle } from "./chat/ChatComposer";
import { DraftHeroHeadline } from "./chat/DraftHeroHeadline";
import { ExpandedImageDialogHost, openExpandedImagePreview } from "./chat/ExpandedImageDialog";
import {
BranchRestoreConfirmHost,
DeviceSetupDialogHost,
openBranchRestoreConfirm,
PullRequestThreadDialogHost,
RevertConfirmHost,
} from "./chat/ChatOverlayHosts";
import type { AssistantCitationRequest } from "./chat/AssistantCitationSource";
import { useCitedHistory } from "./chat/citationProcedure";
import type { MessagesTimelineHistoryControls } from "./chat/MessagesTimeline";
import { ThreadTimeline } from "./chat/ThreadTimeline";
import { NativeChildWorkDialog } from "./chat/NativeChildWorkDialog";
import { ProviderSubagentBar } from "./chat/ProviderSubagentBar";
import { getTriggerDisplayModelName } from "./chat/providerIconUtils";
import { resolveScrollToEndClearance } from "./composerFooterLayout";
import { ChatHeader } from "./chat/ChatHeader";
import { useSideChat } from "./chat/useSideChat";
import { useRemoteOpenState } from "~/remoteOpen";
import { shouldShowOpenInPicker } from "./chat/OpenInPicker.logic";
import { useOpenFavoriteEditorShortcut } from "./chat/OpenInPickerShortcut";
import {
PanelLayoutControls,
type PanelLayoutControlsProps,
RightPanelMaximizeControl,
ThreadPanelHeaderControl,
WorkspaceTitlebarControls,
} from "./chat/PanelLayoutControls";
import type { ExpandedImagePreview } from "./chat/ExpandedImagePreview";
import { ThreadDetailsPanel } from "./chat/ThreadDetailsPanel";
import { NoActiveThreadState } from "./NoActiveThreadState";
import {
resolveEffectiveEnvMode,
resolveLocalCheckoutBranchMismatch,
shouldShowComposerContextStrip,
shouldShowEnvironmentIndicator,
} from "./BranchToolbar.logic";
import {
getProviderStatusBannerKey,
shouldShowProviderStatusBanner,
} from "./chat/ProviderStatusBanner";
import {
getThreadErrorBannerKey,
isThreadErrorBannerDismissedForSession,
shouldShowThreadErrorBanner,
} from "./chat/ThreadErrorBanner";
import { QueuedRunsControl, type QueuedRunsControlHandle } from "./chat/QueuedRunsControl";
import { useThreadLinkedPullRequest } from "./pullRequest/useThreadLinkedPullRequest";
import { useProactivePanels } from "../hooks/useProactivePanels";
import { useIncrementalTimelineEntries } from "../hooks/useIncrementalTimelineEntries";
import { useRightPanelSurfaceClose } from "../hooks/useRightPanelSurfaceClose";
import { ComposerBannerStack, type ComposerBannerStackItem } from "./chat/ComposerBannerStack";
import { modelFallbackBannerItem } from "./chat/ComposerUsageLimits";
import { ComposerSurface } from "./chat/ComposerSurface";
import { resolveThreadSyncPhase } from "../threadSync";
import { hasAvailableCompactionProvider } from "./chat/ContextWindowMeter.logic";
import {
deriveLatestContextWindowSnapshot,
hasDismissedResumeCompaction,
latestProviderTurnTokenUsage,
shouldOfferResumeCompaction,
} from "@t3tools/client-runtime/state/context-window";
import {
MOBILE_COMPOSER_VIEW_TRANSITION_NAME,
MOBILE_DRAFT_HEADLINE_VIEW_TRANSITION_NAME,
} from "./chat/draftHeroTransition";
import {
buildLocalDraftThread,
deriveCommittedServerUserMessageIds,
dismissBranchMismatchForSession,
shouldShowPlanFollowUpPrompt,
shouldRenderPreviewMiniPlayer,
deriveLockedProvider,
resolveFileAttachmentUrl,
resolveComposerInteractionMode,
resolveComposerProviderSelection,
resolveThreadMetadataUpdateForNextTurn,
resolveSendEnvMode,
startNewThreadForProject,
codexArtifactTemplatePromptToAppend,
shouldRefocusComposerOnWindowFocus,
} from "./ChatView.logic";
import { useLocalStorage } from "~/hooks/useLocalStorage";
import { useComposerHandleContext } from "../composerHandleContext";
import { clampFileAttachmentUploadBytes } from "@t3tools/client-runtime/state/attachments";
import { appAtomRegistry } from "../rpc/atomRegistry";
import { assetEnvironment } from "../state/assets";
import { readEnvironmentScope, readPreparedConnection } from "../state/session";
import { useAtomCommand } from "../state/use-atom-command";
import { useOrchestrationCommand } from "../state/use-orchestration-command";
import { useAtomQueryRunner } from "../state/use-atom-query-runner";
import { observeResize } from "~/lib/observeResize";
import { ThreadVisitWatermark } from "./chat/ThreadVisitWatermark";
import { ChatTerminalDrawers } from "./chat/ChatTerminalDrawers";
import { ChatRightPanel } from "./chat/ChatRightPanel";
import { useDraftEnvironmentRouting } from "./chat/useDraftEnvironmentRouting";
import { branchMismatchBannerItem, extensionStatusBannerItem } from "./chat/ThreadActivityBanners";
import { ThreadNow } from "./chat/ThreadNow";
import type { ThreadStructure } from "@t3tools/client-runtime/state/shell";
import { useDelayedStatus } from "../hooks/useDelayedStatus";
import { useTimelineFollow } from "./chat/useTimelineFollow";
import {
type EnvironmentUnavailableState,
useSystemComposerBanners,
} from "./chat/useSystemComposerBanners";
import { useDraftHeroLayoutTransition } from "./chat/useDraftHeroLayoutTransition";
import { useLocalDispatchState } from "./chat/useLocalDispatchState";
import { draftFanoutSelectionsAtom, draftSendState } from "./chat/chatViewSend";
import {
isCompactCommandMessage,
type LocalThreadErrorEntry,
makeThreadErrorSetter,
} from "./ChatView.logic";
const EMPTY_PROVIDERS: ServerProvider[] = [];
const EMPTY_PROVIDER_MODELS: ServerProvider["models"] = [];
const EMPTY_USAGE_LIMIT_SOURCES: UsageLimitSourceSnapshots = [];
import type { CodexArtifactTemplate } from "@t3tools/shared/codexArtifactTemplates";
const EMPTY_FEEDBACK_SUBMISSIONS: ReadonlyArray<CodexFeedbackSubmission> = [];
const EMPTY_PROVIDER_SKILLS: ServerProvider["skills"] = [];
const EMPTY_TURN_ITEMS: ThreadStructure["turnItems"] = [];
const EMPTY_AUTO_UPDATE_ENVIRONMENTS: ReadonlyArray<EnvironmentPresentation> = [];
const EMPTY_COMPOSER_BANNER_ITEMS: ReadonlyArray<ComposerBannerStackItem> = [];
const EMPTY_PENDING_FILE_SURFACE_IDS: ReadonlySet<string> = new Set();
type ChatViewProps =
| {
environmentId: EnvironmentId;
threadId: ThreadId;
onDiffPanelOpen?: () => void;
reserveTitleBarControlInset?: boolean;
forceExpandedMobileComposer?: boolean;
/** A side chat in its parent's right panel; the parent keeps the keyboard and workspace UI. */
embedded?: SideChatParentPanel;
routeKind: "server";
draftId?: never;
}
| {
environmentId: EnvironmentId;
threadId: ThreadId;
onDiffPanelOpen?: () => void;
reserveTitleBarControlInset?: boolean;
forceExpandedMobileComposer?: boolean;
embedded?: never;
routeKind: "draft";
draftId: DraftId;
};
const DismissedFallbackWindowSchema = Schema.NullOr(Schema.String);
export default function ChatView(props: ChatViewProps) {
const {
environmentId,
threadId,
routeKind,
onDiffPanelOpen,
reserveTitleBarControlInset = true,
forceExpandedMobileComposer = false,
embedded: parentPanel,
} = props;
const embedded = parentPanel !== undefined;
const canOperateThread = useEnvironmentScope(environmentId, AuthOrchestrationOperateScope);
const canOperateTerminal = useEnvironmentScope(environmentId, AuthTerminalOperateScope);
const draftId = routeKind === "draft" ? props.draftId : null;
const handleNewThread = useNewThreadHandler();
const routeThreadRef = scopeThreadRef(environmentId, threadId);
const routeThreadKey = scopedThreadKey(routeThreadRef);
const currentRouteThreadKeyRef = useRef<string | null>(routeThreadKey);
// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- publishes the committed route thread key to a ref that async handlers check before applying results
useLayoutEffect(() => {
currentRouteThreadKeyRef.current = routeThreadKey;
return () => {
currentRouteThreadKeyRef.current = null;
};
}, [routeThreadKey]);
const updateThreadMetadata = useOrchestrationCommand(threadEnvironment.updateMetadata, {
reportFailure: false,
});
const canWriteSourceControl = useEnvironmentScope(environmentId, AuthSourceControlWriteScope);
const setThreadRuntimeMode = useOrchestrationCommand(threadEnvironment.setRuntimeMode, {
reportFailure: false,
});
const setThreadInteractionMode = useOrchestrationCommand(threadEnvironment.setInteractionMode, {
reportFailure: false,
});
const startThreadTurn = useOrchestrationCommand(threadEnvironment.startTurn, {
reportFailure: false,
});
const createAttachmentAssetUrl = useAtomQueryRunner(assetEnvironment.createUrl, {
reportFailure: false,
refresh: true,
});
const interruptThreadTurn = useOrchestrationCommand(threadEnvironment.interruptTurn, {
reportFailure: false,
});
const loadEarlierThreadHistory = useAtomCommand(threadEnvironment.loadEarlierHistory, {
label: "load earlier thread history",
reportFailure: false,
});
const { environments } = useEnvironments();
const providersByEnvironment = useEnvironmentProviders();
const primaryEnvironment = usePrimaryEnvironment();
const environmentById = new Map(
environments.map((environment) => [environment.environmentId, environment]),
);
const baseComposerDraftTarget: ScopedThreadRef | DraftId =
routeKind === "server" ? routeThreadRef : props.draftId;
const draftThread = useComposerDraftStore((store) =>
routeKind === "server"
? store.getDraftSessionByRef(routeThreadRef)
: draftId
? store.getDraftSession(draftId)
: null,
);
const serverThreadShell = useQuietThreadShell(routeThreadRef);
const routeThreadDetailRef = resolveThreadDetailRef(routeThreadRef, {
shellExists: serverThreadShell !== null,
waitForShell: draftThread !== null,
});
const serverThreadProjection = useQuietThreadProjection(routeThreadDetailRef);
const serverProjection = serverThreadProjection?.projection ?? null;
// Only the shell-less fallback needs these; with a shell, the shell carries them.
const fallbackDetailRef = serverThreadShell === null ? routeThreadDetailRef : null;
const fallbackUpdatedAt = useThreadUpdatedAt(fallbackDetailRef);
const fallbackLastVisitedAt = useThreadLastVisitedAt(fallbackDetailRef);
const serverThread =
serverThreadShell !== null || serverProjection === null || fallbackUpdatedAt === null
? serverThreadShell
: presentThreadShellFromProjection(environmentId, threadId, serverProjection, {
updatedAt: fallbackUpdatedAt,
lastVisitedAt: fallbackLastVisitedAt,
});
const promptRef = useRef("");
const localComposerRef = useRef<ChatComposerHandle | null>(null);
const composerRef = useComposerHandleContext() ?? localComposerRef;
const queuedRunEdit = useQueuedRunEdit({
environmentId,
routeThreadRef,
threadDraftTarget: baseComposerDraftTarget,
activeThreadId: serverThread !== null || draftThread !== null ? threadId : null,
serverProjection,
promptRef,
composerRef,
});
const composerDraftTarget = queuedRunEdit.draftTarget;
const reportedModelSelection = serverProjection
? deriveReportedModelSelection(serverProjection)
: null;
const threadStatus = useThreadStatus(routeThreadDetailRef);
const threadSyncPhase = resolveThreadSyncPhase({
detailExists: serverProjection !== null,
shellExists: serverThread !== null,
status: threadStatus,
});
const threadDetailLoading = threadSyncPhase === "loading";
// Held back briefly, so a quick sync does not flash a status line at the end of the timeline.
const delayedThreadSyncPhase = useDelayedStatus(routeThreadKey, threadSyncPhase);
const activeProviderThread = serverProjection?.providerThreads.find(
(thread) => thread.id === serverProjection.thread.activeProviderThreadId,
);
const activeThreadLiveTokenUsage = latestProviderTurnTokenUsage(
serverProjection?.providerTurns ?? [],
serverProjection,
activeProviderThread,
);
const serverVisibleTurnItems = useQuietThreadVisibleTurnItems(routeThreadDetailRef);
const serverThreadHistory = useThreadHistory(routeThreadDetailRef);
const threadHistoryControls = (() => {
if (routeThreadDetailRef === null || !shouldShowLoadEarlierControl(serverThreadHistory)) {
return undefined;
}
return {
hasMoreHistory: serverThreadHistory.hasMoreHistory,
loading: serverThreadHistory.loading,
error: serverThreadHistory.error,
onLoadEarlier: (throughEntryId) => {
void loadEarlierThreadHistory({
environmentId: routeThreadDetailRef.environmentId,
input: {
threadId: routeThreadDetailRef.threadId,
...(throughEntryId === undefined ? {} : { throughEntryId }),
},
});
},
};
})() as MessagesTimelineHistoryControls | undefined;
const committedServerMessageIds = deriveCommittedServerUserMessageIds(serverVisibleTurnItems);
// Queued messages have no turn item until starting, so cancellation must retire their optimistic rows
// separately.
const serverAcknowledgedUserMessageIds = (() => {
const ids = new Set(committedServerMessageIds);
for (const message of serverProjection?.messages ?? []) {
if (message.role === "user") ids.add(message.id);
}
return ids;
})();
const settings = useEnvironmentSettings(environmentId);
const clientSettingsHydrated = useClientSettingsHydrated();
const timestampFormat = settings.timestampFormat;
const navigate = useNavigate();
// Selects primitives: an object here is new on every router store update, which
// re-renders ChatView on unrelated navigation state changes.
const citationHref = useLocation({ select: (location) => location.href });
const citationKey = useLocation({
select: (location) => location.state.assistantCitationActivation ?? location.state.__TSR_key,
});
const citationLocation = { href: citationHref, key: citationKey };
const citationRequest = (() => {
const citation = assistantCitationFromLocation(citationLocation.href);
return citation && citation.environmentId === environmentId && citation.threadId === threadId
? { citation, key: citationLocation.key ?? citationLocation.href }
: null;
})() as AssistantCitationRequest | null;
const citationHistory = useCitedHistory(citationRequest);
const { resolvedTheme } = useTheme();
const composerRuntimeMode = useComposerDraftStore(
(store) => store.getComposerDraft(composerDraftTarget)?.runtimeMode ?? null,
);
const composerInteractionMode = useComposerDraftStore(
(store) => store.getComposerDraft(composerDraftTarget)?.interactionMode ?? null,
);
const composerActiveProvider = useComposerDraftStore(
(store) => store.getComposerDraft(composerDraftTarget)?.activeProvider ?? null,
);
const composerSelectedModelSelection = useComposerDraftStore((store) => {
const draft = store.getComposerDraft(composerDraftTarget);
return draft?.activeProvider
? (draft.modelSelectionByProvider[draft.activeProvider] ?? null)
: null;
});
const composerModelSelectionExplicit = useComposerDraftStore(
(store) => store.getComposerDraft(composerDraftTarget)?.modelSelectionExplicit === true,
);
const composerHasAttachments = useComposerDraftStore((store) => {
const draft = store.getComposerDraft(composerDraftTarget);
return (draft?.images.length ?? 0) > 0 || (draft?.files.length ?? 0) > 0;
});
const referencedThreadContexts = useComposerDraftStore(
useShallow((store) => {
const draft = store.getComposerDraft(composerDraftTarget);
if (!draft?.threadContexts.length) return [];
// Linked prompts can replace text without pruning stored context records.
const referenced = new Set(collectInlineContextIds(draft.prompt));
return draft.threadContexts.filter((record) => referenced.has(record.contextId));
}),
);
const composerHasNonPromptContent = useComposerDraftStore((store) => {
const draft = store.getComposerDraft(composerDraftTarget);
return draft ? composerDraftHasUserContent({ ...draft, prompt: "" }) : false;
});
const setComposerDraftPrompt = useComposerDraftStore((store) => store.setPrompt);
const setDraftThreadContext = useComposerDraftStore((store) => store.setDraftThreadContext);
const composerImagesRef = useRef<ComposerImageAttachment[]>([]);
const composerFilesRef = useRef<ComposerFileAttachment[]>([]);
const composerTerminalContextsRef = useRef<TerminalContextDraft[]>([]);
const branchToolbarRef = useRef<BranchToolbarHandle>(null);
const citeAssistantText = (
citation: AssistantCitation,
sourceAnchor: AssistantCitationSourceAnchor,
) => {
const inserted = composerRef.current?.citeAssistantText(citation, sourceAnchor) ?? false;
if (!inserted) {
toastManager.add({
type: "warning",
title: "The composer is not ready",
description: "Try citing the selection after the connection or pending input is resolved.",
});
}
return inserted;
};
const citeAssistantTextStable = useStableCallback(citeAssistantText);
const [isWorkspaceFileDragActive, setIsWorkspaceFileDragActive] = useState(false);
const [optimisticBlobPreviews] = useState(createOptimisticBlobPreviews);
const [heldOptimisticUserMessages, setHeldOptimisticUserMessages] = useState(() =>
emptyOptimisticUserMessages(threadId),
);
// Acknowledged messages leave the timeline in the same render the server's copy enters it.
const optimisticState = reconcileOptimisticUserMessages(
heldOptimisticUserMessages,
threadId,
serverAcknowledgedUserMessageIds,
);
if (optimisticState !== heldOptimisticUserMessages) {
// Idempotent, and a discarded render only delays revocation to the thread's end.
optimisticBlobPreviews.handOff(optimisticState);
setHeldOptimisticUserMessages(optimisticState);
}
const optimisticUserMessages = optimisticState.messages;
const setOptimisticUserMessages = (action: SetStateAction<ChatMessage[]>) =>
setHeldOptimisticUserMessages((state) =>
applyOptimisticUserMessagesAction(state, threadId, action),
);
// Draft ids survive promotion and expire on navigation, keeping the pending resend scoped correctly.
const [workLocallyResendDraftId, setWorkLocallyResendDraftId] = useState<DraftId | null>(null);
const [feedbackSubmissionsByThreadKey, setFeedbackSubmissionsByThreadKey] = useState<
Record<string, ReadonlyArray<CodexFeedbackSubmission>>
>({});
const feedbackSubmissions =
feedbackSubmissionsByThreadKey[routeThreadKey] ?? EMPTY_FEEDBACK_SUBMISSIONS;
const feedbackUploading = feedbackSubmissions.some(
(submission) => submission.status === "uploading",
);
const [localDraftErrorsByDraftId, setLocalDraftErrorsByDraftId] = useState<
Record<string, LocalThreadErrorEntry>
>({});
const [localServerErrorsByThreadKey, setLocalServerErrorsByThreadKey] = useState<
Record<string, LocalThreadErrorEntry>
>({});
const isRevertingCheckpoint = useComposerDraftStore((store) =>
store.rewindingThreadKeys.has(routeThreadKey),
);
const workspaceFileDragRouteKey = `${routeThreadKey}:${draftId ?? ""}`;
const [workspaceFileDragRoute, setWorkspaceFileDragRoute] = useState(workspaceFileDragRouteKey);
if (workspaceFileDragRoute !== workspaceFileDragRouteKey) {
setWorkspaceFileDragRoute(workspaceFileDragRouteKey);
setIsWorkspaceFileDragActive(false);
}
// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- window dragend listener that clears the workspace file drag state
useEffect(() => {
if (!isWorkspaceFileDragActive) return;
const clearWorkspaceFileDrag = () => setIsWorkspaceFileDragActive(false);
window.addEventListener("dragend", clearWorkspaceFileDrag);
return () => window.removeEventListener("dragend", clearWorkspaceFileDrag);
}, [isWorkspaceFileDragActive]);
const prefersPlanSidebarSheet = useMediaQuery(RIGHT_PANEL_INLINE_LAYOUT_MEDIA_QUERY);
const isMobileViewport = useMediaQuery("max-sm");
const [workspaceLayoutElement, setWorkspaceLayoutElement] = useState<HTMLDivElement | null>(null);
const threadPanelPopoverAnchorRef = useRef<HTMLElement | null>(null);
const [terminalUiLaunchContext, setTerminalUiLaunchContext] =
useState<TerminalLaunchContext | null>(null);
// Overrides chosen before a server thread's first turn; they belong to that thread only.
const [pendingServerThreadEnvModeEntry, setPendingServerThreadEnvModeEntry] = useState<{
readonly threadId: ThreadId;
readonly mode: DraftThreadEnvMode;
} | null>(null);
const [pendingServerThreadBranchEntry, setPendingServerThreadBranchEntry] = useState<{
readonly threadId: ThreadId;
readonly branch: string | null;
} | null>(null);
const [
pendingServerThreadStartFromOriginByThreadId,
setPendingServerThreadStartFromOriginByThreadId,
] = useState<Record<string, boolean>>({});
const legendListRef = useRef<LegendListRef | null>(null);
const conversationArea = workspaceAreaProps("conversation", 1, "Conversation");
const composerArea = workspaceAreaProps("composer", 2, "Message input");
const [composerOverlayElement, setComposerOverlayElement] = useState<HTMLDivElement | null>(null);
const [composerTimelineInset, setComposerTimelineInset] = useState(0);
const composerTimelineInsetRef = useRef(0);
const [composerReservedHeight, setComposerReservedHeight] = useState(0);
const composerReservedHeightRef = useRef(0);
const composerExpandedHeightRef = useRef(0);
const [scrollToEndClearance, setScrollToEndClearance] = useState(0);
const fanoutSelectionsAtom = draftFanoutSelectionsAtom(routeThreadKey);
const { sendInFlight: sendInFlightRef } = draftSendState(routeThreadKey);
const multipleModelSelections = useAtomValue(fanoutSelectionsAtom);
const setMultipleModelSelections = (
selections: SetStateAction<ReadonlyArray<ModelSelection> | null>,
) => {
appAtomRegistry.update(fanoutSelectionsAtom, (current) =>
typeof selections === "function" ? selections(current) : selections,
);
};
const setMultipleModelSelectionsStable = useStableCallback(setMultipleModelSelections);
const feedbackUploadsInFlightRef = useRef(new Set<string>());
const terminalUiState = useTerminalUiStateStore((state) =>
selectThreadTerminalUiState(state.terminalUiStateByThreadKey, routeThreadRef),
);
const fallbackDraftProjectRef = draftThread
? scopeProjectRef(draftThread.environmentId, draftThread.projectId)
: null;
const fallbackDraftProject = useProject(fallbackDraftProjectRef);
const localDraftError = serverThread
? null
: ((draftId ? localDraftErrorsByDraftId[draftId]?.message : null) ?? null);
const localServerError = localServerErrorsByThreadKey[routeThreadKey]?.message ?? null;
const promotedDraftError =
serverThread && draftId ? localDraftErrorsByDraftId[draftId] : undefined;
if (promotedDraftError !== undefined && draftId) {
const remainingDraftErrors = { ...localDraftErrorsByDraftId };
delete remainingDraftErrors[draftId];
setLocalDraftErrorsByDraftId(remainingDraftErrors);
const currentEntry = localServerErrorsByThreadKey[routeThreadKey];
if (
currentEntry === undefined ||
(currentEntry.at <= promotedDraftError.at &&
currentEntry.message !== promotedDraftError.message)
) {
setLocalServerErrorsByThreadKey({
...localServerErrorsByThreadKey,
[routeThreadKey]: promotedDraftError,
});
}
}
const nowMinute = useNowMinute();
const draftDefaultModelSelection = draftThread
? resolveProjectSettings(
settings,
fallbackDraftProject?.id ?? null,
fallbackDraftProject ?? undefined,
).settings.defaultModelSelection
: null;
const draftModelResolution = draftThread
? resolveNewThreadModelSelection({
defaultSelection:
draftDefaultModelSelection ??
resolveProjectDefaultProviderModelSelection(
providersByEnvironment.get(draftThread.environmentId) ?? [],
settings,
draftThread.projectId,
),
fallbackSelection: settings.fallbackModelSelection,
providers: providersByEnvironment.get(draftThread.environmentId) ?? [],
settings,
projectId: draftThread.projectId,
now: Date.parse(`${nowMinute}:00Z`),
})
: null;
const draftFallback = draftModelResolution?.fallback ? draftModelResolution : null;
const localDraftThread = draftThread
? buildLocalDraftThread(
threadId,
draftThread,
(draftFallback ? draftFallback.selection : draftDefaultModelSelection) ??
NO_PROVIDER_MODEL_SELECTION,
)
: undefined;
const isServerThread = serverThread !== null;
const activeThread = isServerThread ? serverThread : localDraftThread;
const serverLatestRun =
serverProjection === null ? null : deriveLatestThreadRun(serverProjection);
const serverActivityRun =
serverProjection === null ? null : deriveThreadActivityRun(serverProjection);
const serverRuntime =
serverProjection === null ? null : deriveThreadStructureRuntime(serverProjection);
const runlessWorkStartedAt =
serverProjection === null ? null : deriveRunlessWorkStartedAt(serverProjection);
const providerSubagentStatus =
serverProjection === null ? null : deriveProviderSubagentStatus(serverProjection);
const isProviderSubagent =
serverThread !== null && isProviderNativeSubagentThread(serverThread.source);
const supportsProviderSwitchingViaHandoff = threadSupportsProviderHandoff(serverProjection);
const activeLatestRun = isServerThread ? serverLatestRun : (activeThread?.latestRun ?? null);
const activeActivityRun = isServerThread ? serverActivityRun : (activeThread?.latestRun ?? null);
const activeRuntime = isServerThread ? serverRuntime : (activeThread?.runtime ?? null);
const hasHeldQueuedRuns =
isServerThread &&
serverProjection?.runs.some((run) => run.status === "queued" && run.queueHeld === true) ===
true;
const resumableRunId =
!isServerThread || serverProjection === null
? null
: deriveResumableRunId(serverProjection, serverRuntime);
const parentSubagentThreadId =
activeThread?.lineage.relationshipToParent === "subagent"
? activeThread.lineage.parentThreadId
: null;
const parentSubagentEnvironmentId = activeThread?.environmentId ?? null;
const parentSubagentThreadRef = (() => {
if (parentSubagentEnvironmentId === null || parentSubagentThreadId === null) {
return null;
}
return scopeThreadRef(parentSubagentEnvironmentId, parentSubagentThreadId);
})();
const parentSubagentThread = useQuietThreadShell(parentSubagentThreadRef);
// Workflow threads open with a script; their replacement plan lives on the parent's coordinator row.
const workflowOpeningParentId =
serverProjection === null
? null
: workflowOpeningParentThreadId({
thread: serverProjection.thread,
messages: serverProjection.messages,
});
const workflowOpeningParentProjection = useQuietThreadProjection(
workflowOpeningParentId === null || parentSubagentEnvironmentId === null
? null
: scopeThreadRef(parentSubagentEnvironmentId, workflowOpeningParentId),
);
const workflowOpening =
serverProjection === null || workflowOpeningParentId === null
? null
: resolveWorkflowOpening({
thread: serverProjection.thread,
messages: serverProjection.messages,
parentSubagents: workflowOpeningParentProjection?.projection.subagents ?? null,
});
// A linked environment's agent may have delegated this thread from there.
const delegatedFrom = activeThread?.delegatedFrom ?? null;
const delegatedFromEnvironment = useEnvironment(delegatedFrom?.environmentId ?? null);
const delegatedFromRef =
delegatedFrom === null
? null
: scopeThreadRef(delegatedFrom.environmentId, delegatedFrom.threadId);
// The title it had at delegation, until this client sees the parent itself.
const delegatedFromThread = useQuietThreadShell(delegatedFromRef);
const sideChatParentRef =
activeThread?.lineage.sideChat === true && activeThread.lineage.parentThreadId !== null
? scopeThreadRef(activeThread.environmentId, activeThread.lineage.parentThreadId)
: null;
const sideChatParent = useQuietThreadShell(sideChatParentRef);
const parentThreadLink = (() => {
if (sideChatParentRef !== null) {
const title = sideChatParent?.title ?? "Parent thread";
// Embedded, the parent is the view around it.
if (embedded) return { title, sideChat: true };
return {
title,
sideChat: true,
open: (): void => {
void navigate({
to: "/$environmentId/$threadId",
params: buildThreadRouteParams(sideChatParentRef),
});
},
};
}
if (parentSubagentThreadRef !== null) {
return {
title: parentSubagentThread?.title ?? "Parent thread",
open: (): void => {
void navigate({
to: "/$environmentId/$threadId",
params: buildThreadRouteParams(parentSubagentThreadRef),
});
},
};
}
if (delegatedFrom === null || delegatedFromRef === null) return null;
const parentRef = delegatedFromRef;
return {
title: delegatedFromThread?.title ?? delegatedFrom.title,
environmentLabel: delegatedFromEnvironment?.label ?? activeThread?.linkOrigin?.label ?? "",
// Only an environment this client is connected to can open the parent.
...(delegatedFromEnvironment === null
? {}
: {
open: (): void => {
void navigate({
to: "/$environmentId/$threadId",
params: buildThreadRouteParams(parentRef),
});
},
}),
};
})();
// The header's breadcrumb opens a parent in this environment only.
const headerParentThreadLink =
parentSubagentThreadRef === null
? null
: {
threadId: parentSubagentThreadRef.threadId,
title: parentSubagentThread?.title ?? "Parent thread",
};
const threadError = isServerThread
? (localServerError ?? serverRuntime?.lastError ?? null)
: localDraftError;
const threadErrorBannerKey = getThreadErrorBannerKey(routeThreadKey, threadError);
const visibleThreadError = shouldShowThreadErrorBanner(
routeThreadKey,
threadError,
isThreadErrorBannerDismissedForSession(threadErrorBannerKey),
)
? threadError
: null;
const [, setThreadErrorBannerDismissTick] = useState(0);
const threadErrorIsServerRuntimeError =
localServerError === null && visibleThreadError === serverRuntime?.lastError;
const defaultRuntimeMode = resolveProjectSettings(settings, activeThread?.projectId ?? null)
.settings.defaultRuntimeMode;
const runtimeMode =
composerRuntimeMode ??
(isServerThread ? activeThread?.runtimeMode : undefined) ??
defaultRuntimeMode;
const isLocalDraftThread = !isServerThread && localDraftThread !== undefined;
const canCheckoutPullRequestIntoThread = canWriteSourceControl && isLocalDraftThread;
const activeThreadId = activeThread?.id ?? null;
// Turn items can lag projection hydration; keep the environment locked through that gap.
const activeMessageCount = isServerThread
? Math.max(committedServerMessageIds.size, serverProjection?.messages.length ?? 0)
: 0;
const runningTerminalIds = useThreadRunningTerminalIds({
environmentId: activeThread?.environmentId ?? null,
threadId: activeThreadId,
});
const activeThreadKnownSessionsRaw = useKnownTerminalSessions({
environmentId: activeThread?.environmentId ?? null,
threadId: activeThreadId,
});
const activeThreadKnownSessions = (() => {
if (activeThreadId === null || activeThreadKnownSessionsRaw === null) {
return [];
}
return activeThreadKnownSessionsRaw.filter(
(session) => session.target.threadId === activeThreadId,
);
})();
const activeServerOrderedTerminalIds = activeThreadKnownSessions.map(
(session) => session.target.terminalId,
);
const activeTerminalLabelsById = (() => {
const labels = new Map<string, string>();
for (const session of activeThreadKnownSessions) {
labels.set(
session.target.terminalId,
resolveTerminalSessionLabel(session.target.terminalId, session.state.summary),
);
}
return labels;
})();
const activeThreadRef = useActiveThreadRef(activeThread);
const activeThreadKey = activeThreadRef ? scopedThreadKey(activeThreadRef) : null;
const activeEnvironmentServerBrowser = useEnvironmentSupportsServerBrowser(
activeThreadRef?.environmentId ?? null,
);
const browserAvailable = isPreviewSupportedInRuntime() || activeEnvironmentServerBrowser;
const activeThreadShell = serverThread;
const limitRecoveryRun =
serverRuntime?.status === "failed" && serverRuntime.lastErrorClass === "usage_limit"
? (activeThreadShell?.latestRun ?? null)
: null;
// The recovery banner offers Wake now for a snooze it set.
const limitRecoveryHoldsSnooze = limitRecoveryOwnsSnooze({
runId: limitRecoveryRun?.runId,
resetAt: serverRuntime?.usageLimitResetAt,
recovery: activeThreadShell?.limitRecovery,
snoozedUntil: activeThreadShell?.snoozedUntil,
});
const timelineThreadError =
limitRecoveryRun !== null && visibleThreadError === serverRuntime?.lastError
? null
: visibleThreadError;
const [timelineAnchor, setTimelineAnchor] = useState<{
readonly threadKey: string | null;
readonly messageId: MessageId | null;
}>({ threadKey: activeThreadKey, messageId: null });
if (timelineAnchor.threadKey !== activeThreadKey) {
setTimelineAnchor({ threadKey: activeThreadKey, messageId: null });
}
const timelineAnchorMessageId = timelineAnchor.messageId;
// LegendList never recomputes anchored end-space geometry, leaving phantom scroll range after content fits.
const anchorRunSettled = (() => {
if (timelineAnchorMessageId === null) return false;
const anchorRun = serverProjection?.runs.find(
(run) => run.userMessageId === timelineAnchorMessageId,
);
if (anchorRun === undefined) return false;
return (
anchorRun.status !== "preparing" &&
anchorRun.status !== "queued" &&
anchorRun.status !== "starting" &&
anchorRun.status !== "running" &&
anchorRun.status !== "waiting"
);
})();
if (anchorRunSettled) {
setTimelineAnchor({ threadKey: activeThreadKey, messageId: null });
}
const activeRightPanelKind = useRightPanelStore((state) =>
selectActiveRightPanel(state.byThreadKey, activeThreadRef),
);
const diffOpen = activeRightPanelKind === "diff";
const explicitDiffOpenRef = useRef<ScopedThreadRef | null>(null);
// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- resets the diff panel store to branch scope when the diff opens without an explicit request
useLayoutEffect(() => {
const explicitThreadRef = explicitDiffOpenRef.current;
explicitDiffOpenRef.current = null;
if (
diffOpen &&
activeThreadRef &&
explicitThreadRef !== activeThreadRef &&
!useDiffPanelStore.getState().consumeKeepSelectionOnOpen(activeThreadRef)
) {
useDiffPanelStore.getState().selectGitScope(activeThreadRef, "branch");
}
}, [activeThreadRef, diffOpen]);
const rightPanelState = useRightPanelStore((state) =>
selectThreadRightPanelState(state.byThreadKey, activeThreadRef),
);
const shouldUsePlanSidebarSheet = prefersPlanSidebarSheet && rightPanelState.maximized !== true;
const activeRightPanelSurface = useRightPanelStore((state) =>
selectActiveRightPanelSurface(state.byThreadKey, activeThreadRef),
);
const activePreviewState = useThreadPreviewState(activeThreadRef);
const activePreviewServerEpoch = activePreviewState.serverEpoch;
const resolvePreviewRuntimeTabId = activeThreadRef
? (tabId: string) => previewRuntimeTabId(activeThreadRef, activePreviewServerEpoch, tabId)
: undefined;
const activePreviewMiniPlayer = usePreviewMiniPlayerStore((state) =>
selectThreadPreviewMiniPlayer(state.byThreadKey, activeThreadRef),
);
const panelTerminalIds = new Set(
rightPanelState.surfaces.flatMap((surface) =>
surface.kind === "terminal" ? surface.terminalIds : [],
),
);
const canReuseTerminal = activeThreadKnownSessionsRaw !== null;
const previewPanelOpen = activeRightPanelKind === "preview" && browserAvailable;
const rightPanelOpen = rightPanelState.isOpen;
const { active: panelAnimationsActive, durationMs: panelAnimationDurationMs } =
usePanelAnimationSettings();
const rightPanelPresenceValue = {
activeSurface: activeRightPanelSurface,
surfaces: rightPanelState.surfaces,
};
const rightPanelPresence = usePanelPresence(
rightPanelOpen && activeThreadRef !== null,
rightPanelPresenceValue,
panelAnimationsActive,
activeThreadKey,
panelAnimationDurationMs,
);
const rightPanelPresent = rightPanelPresence.present;
const rightPanelControlsInPanel =
shouldUsePlanSidebarSheet && rightPanelPresent && rightPanelOpen;
const rightPanelControlsAtRoot = rightPanelPresent && !shouldUsePlanSidebarSheet;
const renderedRightPanelSurface = rightPanelPresence.value?.activeSurface ?? null;
const renderedRightPanelSurfaces = rightPanelPresence.value?.surfaces ?? [];
const previewMiniPlayerVisible = shouldRenderPreviewMiniPlayer(
activePreviewMiniPlayer?.source ?? null,
renderedRightPanelSurface,
);
const canMaximizeRightPanel = rightPanelOpen;
// An embedded side chat has no panel; a stale maximized flag would hide its own column.
const rightPanelMaximized =
!embedded && canMaximizeRightPanel && rightPanelState.maximized === true;
const inlineRightPanelOwnsTitleBar = rightPanelOpen && !shouldUsePlanSidebarSheet;
const [threadPanelPopoverHandle] = useState(PopoverCreateHandle);
const [chatCanvasStore] = useState(createChatCanvasStore);
const latestRunSettled = isLatestRunSettled(activeLatestRun, activeRuntime);
const activeThreadEnvironmentId = activeThread?.environmentId;
const activeThreadProjectId = activeThread?.projectId;
const activeProjectRef =
activeThreadEnvironmentId !== undefined && activeThreadProjectId !== undefined
? scopeProjectRef(activeThreadEnvironmentId, activeThreadProjectId)
: null;
const activeProject = useProject(activeProjectRef);
const activeProjectSettings = resolveProjectSettings(
settings,
activeProject?.id ?? null,
activeProject ?? undefined,
);
const activeProjectScripts = activeProject ? resolveProjectScripts(settings, activeProject) : [];
const { projectCloneBannerItem, projectCloneSendBlockReason } =
useProjectCloneBanner(activeProjectRef);
const activeProjectDefaultModelSelection =
!isServerThread && draftFallback
? draftFallback.selection
: activeProjectSettings.settings.defaultModelSelection;
const handleNewThreadInActiveProject = () => {
startNewThreadForProject(activeProjectRef, handleNewThread);
};
const handleNewThreadInActiveProjectStable = useStableCallback(handleNewThreadInActiveProject);
const projectGroupingSettings = selectProjectGroupingSettings(settings);
const activeDraftLogicalProjectKey =
!isServerThread && activeProject
? deriveLogicalProjectKeyFromSettings(activeProject, projectGroupingSettings)
: undefined;
const handleOpenDraftProjectSettings = () => {
if (!activeDraftLogicalProjectKey) return;
void navigate({
to: "/projects/$projectKey",
params: { projectKey: activeDraftLogicalProjectKey },
});
};
const handleOpenDraftProjectSettingsStable = useStableCallback(handleOpenDraftProjectSettings);
const activeEnvironmentBootstrapComplete = useEnvironmentShellHasSnapshot(
activeThread?.environmentId ?? null,
);
const activeProjectKey = activeProject
? `${activeProject.environmentId}:${activeProject.workspaceRoot}`
: null;
const [pendingFileSurfaceIdsByProject, setPendingFileSurfaceIdsByProject] = useState<
ReadonlyMap<string, ReadonlySet<string>>
>(() => new Map());
const pendingFileSurfaceIds = activeProjectKey
? (pendingFileSurfaceIdsByProject.get(activeProjectKey) ?? EMPTY_PENDING_FILE_SURFACE_IDS)
: EMPTY_PENDING_FILE_SURFACE_IDS;
const handleFilePendingChange = (relativePath: string, pending: boolean) => {
if (!activeProjectKey) return;
setPendingFileSurfaceIdsByProject((currentByProject) => {
const current = currentByProject.get(activeProjectKey) ?? EMPTY_PENDING_FILE_SURFACE_IDS;
const surfaceId = `file:${relativePath}`;
if (current.has(surfaceId) === pending) return currentByProject;
const next = new Set(current);
if (pending) next.add(surfaceId);
else next.delete(surfaceId);
const nextByProject = new Map(currentByProject);
if (next.size === 0) nextByProject.delete(activeProjectKey);
else nextByProject.set(activeProjectKey, next);
return nextByProject;
});
};
const handleFilePendingChangeStable = useStableCallback(handleFilePendingChange);
const configuredPreviewUrls = getConfiguredPreviewUrls(activeProjectScripts);
// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- drops file surfaces from the right panel store once bootstrap shows the thread has no workspace
useEffect(() => {
if (!activeThreadRef || !activeEnvironmentBootstrapComplete) return;
useRightPanelStore.getState().reconcileFileSurfaces(activeThreadRef, activeProject !== null);
}, [activeEnvironmentBootstrapComplete, activeProject, activeThreadRef]);
const primaryEnvironmentId = primaryEnvironment?.environmentId ?? null;
const activeEnvironment =
activeThread == null ? null : (environmentById.get(activeThread.environmentId) ?? null);
const activeEnvironmentUnavailable =
activeEnvironment !== null && activeEnvironment.connection.phase !== "connected";
const activeEnvironmentUnavailableLabel = activeEnvironment?.label ?? null;
const activeEnvironmentUnavailableState = (() => {
if (!activeEnvironmentUnavailable || !activeEnvironmentUnavailableLabel || !activeEnvironment) {
return null;
}
return {
environmentId: activeEnvironment.environmentId,
label: activeEnvironmentUnavailableLabel,
connection: activeEnvironment.connection,
};
})() as EnvironmentUnavailableState | null;
const activeProjectIsScratch =
activeProject !== null &&
isScratchProject(
activeProject,
environmentById.get(activeProject.environmentId)?.serverConfig?.scratchWorkspaceRoot ?? null,
);
const logicalProjectEnvironments = useLogicalProjectEnvironments(
activeProject,
activeProjectIsScratch && draftId !== null,
);
const hasMultipleEnvironments = logicalProjectEnvironments.length > 1;
const canAutoBalanceEnvironments = hasMultipleEnvironments && !activeProjectIsScratch;
const activeEnvironmentOption =
logicalProjectEnvironments.find(
(environment) => environment.environmentId === activeThread?.environmentId,
) ?? null;
const showComposerEnvironmentIndicator = shouldShowEnvironmentIndicator({
activeEnvironment: activeEnvironmentOption,
canPickEnvironment: hasMultipleEnvironments,
});
const { handlePreparedPullRequestThreadStable, openPullRequestDialogStable } =
usePullRequestDraftThread({
routeKind,
draftId,
settings,
projectGroupingSettings,
activeProject,
activeThreadKey,
isServerThread,
canCheckoutPullRequestIntoThread,
});
const serverConfig = activeThread
? (activeEnvironment?.serverConfig ?? null)
: (primaryEnvironment?.serverConfig ?? null);
const providerEnvironmentId = (activeThread ? activeEnvironment : primaryEnvironment)
?.environmentId;
const providerStatuses =
(providerEnvironmentId === undefined
? undefined
: providersByEnvironment.get(providerEnvironmentId)) ?? EMPTY_PROVIDERS;
const selectedProviderByThreadId = composerActiveProvider ?? null;
const threadProvider =
activeThread?.modelSelection.instanceId ??
activeProjectDefaultModelSelection?.instanceId ??
null;
const lockedProvider = deriveLockedProvider({
thread: activeThread,
selectedProvider: selectedProviderByThreadId,
threadProvider,
providers: providerStatuses,
});
const modelPickerLockedProvider = supportsProviderSwitchingViaHandoff ? null : lockedProvider;
const pullRequestsCapabilityKnown = serverConfig !== null;
const supportsPullRequests = serverConfig !== null;
const attachmentEnvironmentConfig = environmentById.get(environmentId)?.serverConfig ?? null;
const attachmentUploadsCapabilityKnown = attachmentEnvironmentConfig !== null;
const supportsQuestionAttachments = attachmentEnvironmentConfig !== null;
const supportsAttachmentUploads = attachmentEnvironmentConfig !== null;
const advertisedFileAttachmentBytes =
attachmentEnvironmentConfig?.environment.capabilities.fileAttachments?.maxUploadBytes ?? null;
const maxFileAttachmentBytes =
advertisedFileAttachmentBytes === null
? null
: clampFileAttachmentUploadBytes(advertisedFileAttachmentBytes);
const envLocked = Boolean(activeThread && (activeMessageCount > 0 || activeRuntime !== null));
// onEnvironmentChange only retargets an unsent draft. envLocked alone does not
// rule out a started thread: one whose machine is offline never loads its
// messages, so it would otherwise be offered a machine picker that does nothing.
const canChangeEnvironment =
hasMultipleEnvironments && !envLocked && draftId !== null && !draftThread?.promotedTo;
const loadBalancingSettings = useClientSettings((settings) => ({
loadBalancingEnabled: settings.loadBalancingEnabled,
loadBalancingWeights: settings.loadBalancingWeights,
}));
const automaticEnvironment = Boolean(
clientSettingsHydrated &&
draftId &&
!envLocked &&
canAutoBalanceEnvironments &&
loadBalancingSettings.loadBalancingEnabled &&
draftThread?.environmentSelection !== "manual" &&
(!composerHasAttachments || Boolean(draftThread?.loadBalancedEnvironmentId)) &&
(!draftThread?.branch || draftThread.environmentSelection === "auto") &&
!draftThread?.worktreePath,
);
const autoUpdateEnvironments = automaticEnvironment
? logicalProjectEnvironments.flatMap(({ environmentId }) => {
const environment = environmentById.get(environmentId);
return environment ? [environment] : [];
})
: EMPTY_AUTO_UPDATE_ENVIRONMENTS;
const systemComposerBannerItems = useSystemComposerBanners({
activeEnvironment,
activeEnvironmentUnavailable,
activeEnvironmentUnavailableState,
activeThreadEnvironmentId: activeThread?.environmentId ?? null,
serverConfig,
hasMultipleRegisteredEnvironments: environments.length > 1,
automaticEnvironment,
autoUpdateEnvironments,
});
const providerInstanceEntries = providerInstanceEntriesFor(
providerStatuses,
settings,
activeProject?.id ?? null,
);
const activeThreadModelInstanceId = activeThread?.modelSelection.instanceId;
const { selectedProviderEntry, requestedDriverKind } = resolveComposerProviderSelection({
entries: providerInstanceEntries,
candidateInstanceIds: [
selectedProviderByThreadId,
activeRuntime?.providerInstanceId,
activeThreadModelInstanceId,
activeProjectDefaultModelSelection?.instanceId,
],
lockedProvider,
lockedInstanceId: activeRuntime?.providerInstanceId ?? activeThreadModelInstanceId,
});
const selectedProvider = selectedProviderEntry?.driverKind ?? requestedDriverKind;
const activeProviderInstanceId = selectedProviderEntry?.instanceId ?? null;
const activeProviderStatus = selectedProviderEntry?.snapshot ?? null;
const { enabled: interactionModeEnabled, interactionMode } = resolveComposerInteractionMode({
planModeEnabled: settings.planModeEnabled,
provider: activeProviderStatus,
interactionMode:
composerInteractionMode ?? activeThread?.interactionMode ?? DEFAULT_INTERACTION_MODE,
});
const conversationProviderStatus =
providerStatuses.find((status) => status.instanceId === activeRuntime?.providerInstanceId) ??
activeProviderStatus;
const supportsConversationRollback =
canOperateThread &&
conversationProviderStatus !== null &&
conversationProviderStatus.supportsConversationRollback !== false;
const phase = derivePhase(activeRuntime);
const serverThreadId = serverThread?.id;
const serverThreadEnvironmentId = serverThread?.environmentId;
const setThreadError = makeThreadErrorSetter({
routeThreadRef,
routeThreadKey,
draftId,
serverThreadRef:
serverThreadId !== undefined && serverThreadEnvironmentId !== undefined
? { threadId: serverThreadId, environmentId: serverThreadEnvironmentId }
: null,
setLocalServerErrorsByThreadKey,
setLocalDraftErrorsByDraftId,
});
const {
pendingApprovals,
pendingUserInputs,
activePendingApproval,
activePendingUserInput,
activePendingDraftAnswers,
activePendingQuestionIndex,
activePendingProgress,
activePendingResolvedAnswers,
activePendingIsResponding,
respondingRequestIds,
onRespondToApproval: onRespondToApprovalStable,
onDismissUserInput: onDismissUserInputStable,
onSelectActivePendingUserInputOption: onSelectActivePendingUserInputOptionStable,
onChangeActivePendingUserInputCustomAnswer,
onAdvanceActivePendingUserInput,
onAdvanceActivePendingUserInputStable,
onPreviousActivePendingUserInputQuestion: onPreviousActivePendingUserInputQuestionStable,
} = usePendingThreadRequests({
environmentId,
activeThreadId,
serverProjection,
supportsQuestionAttachments,
composerDraftTarget,
setComposerDraftPrompt,
promptRef,
composerRef,
setThreadError,
});
const [heldApprovalRequestIds, setHeldApprovalRequestIds] = useState<ReadonlySet<string>>(
() => new Set(),
);
const onHeldRequestIdsChange = useStableCallback((requestIds: ReadonlySet<string>) => {
setHeldApprovalRequestIds((current) => (shallow(current, requestIds) ? current : requestIds));
});
const activeProposedPlan = (() => {
if (!latestRunSettled) {
return null;
}
return findLatestProposedPlan(serverProjection, activeLatestRun?.runId ?? null);
})();
const showPlanFollowUpPrompt = shouldShowPlanFollowUpPrompt({
pendingUserInputCount: pendingUserInputs.length,
interactionMode,
latestTurnSettled: latestRunSettled,
hasActionableProposedPlan: hasActionableProposedPlan(activeProposedPlan),
hasComposerAttachments: composerHasAttachments,
});
// Answering an approval or question on any client resumes quota spending, so include it in the key.
const usageLimitsKey =
activeProviderInstanceId === null || (isServerThread && activeThread === undefined)
? null
: [
routeThreadKey,
activeProviderInstanceId,
activeThread?.latestRun?.runId ?? "",
activePendingApproval?.requestId ?? activePendingUserInput?.requestId ?? "",
].join(":");
const {
banner: usageLimitsBanner,
offered: usageLimitsOffered,
open: openUsageLimits,
clearFor: clearUsageLimitsFor,
} = useUsageLimitsPanel({
environmentId,
threadKey: routeThreadKey,
panelKey: usageLimitsKey,
providerInstanceId: activeProviderInstanceId,
providerDriver: activeProviderStatus?.driver ?? null,
providers: providerStatuses,
sources: serverConfig?.usageLimitSources ?? EMPTY_USAGE_LIMIT_SOURCES,
});
const {
beginLocalDispatch,
resetLocalDispatch,
localDispatchStartedAt,
isPreparingWorktree: isLocallyPreparingWorktree,
isSendBusy,
backgroundSubmissionPending,
} = useLocalDispatchState({
activeThread,
activeLatestRun,
latestUserMessageId:
serverProjection?.messages.findLast((message) => message.role === "user")?.id ?? null,
phase,
activePendingApproval: activePendingApproval?.requestId ?? null,
activePendingUserInput: activePendingUserInput?.requestId ?? null,
threadError,
});
const optimisticCompactionMessage = optimisticUserMessages.at(-1);
const latestServerUserItem = serverVisibleTurnItems.findLast(
(row) => row.item.type === "user_message",
)?.item;
const compactRequestIsActive =
(isSendBusy &&
optimisticCompactionMessage !== undefined &&
isCompactCommandMessage(optimisticCompactionMessage)) ||
(latestServerUserItem?.type === "user_message" &&
latestServerUserItem.text.trim().toLowerCase() === "/compact" &&
latestServerUserItem.attachments.length === 0 &&
latestServerUserItem.runId === activeActivityRun?.runId &&
!isLatestRunSettled(activeActivityRun, activeRuntime));
const compactionSettled = serverVisibleTurnItems.some(
({ item }) =>
item.type === "compaction" &&
item.runId === activeActivityRun?.runId &&
(item.status === "completed" ||
item.status === "failed" ||
item.status === "interrupted" ||
item.status === "cancelled"),
);
const compactionRunning = serverVisibleTurnItems.some(
({ item }) =>