The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import type { ModelSelection, ProviderInstanceId, RuntimeMode } from "@t3tools/contracts"; |
| 2 | import { createModelSelection } from "@t3tools/shared/model"; |
| 3 | import { T, useGT, useMessages } from "gt-react"; |
| 4 | import { type ComponentProps, memo, useId, useRef, useState } from "react"; |
| 5 | |
| 6 | import { Menu as MenuPrimitive } from "@base-ui/react/menu"; |
| 7 | import { Menu, MenuPopup, MenuTrigger } from "../ui/menu"; |
| 8 | import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip"; |
| 9 | import { ComposerControl, ComposerControlIcon } from "./ComposerControl"; |
| 10 | import { focusRequestedPermission, useComposerMenuProps } from "./composerEventScope"; |
| 11 | import { ComposerPrimaryActions } from "./ComposerPrimaryActions"; |
| 12 | import { resolveModelPickerSelectedModel } from "./ModelPickerContent"; |
| 13 | import { ProviderModelPicker } from "./ProviderModelPicker"; |
| 14 | import { resolveRuntimeModeOption, runtimeModeConfig } from "./runtimeModeConfig"; |
| 15 | import { useComposerMenuState } from "./useComposerMenuState"; |
| 16 | |
| 17 | export type RuntimeModeOption = { |
| 18 | mode: RuntimeMode; |
| 19 | disabledReason?: string; |
| 20 | } & (typeof runtimeModeConfig)[RuntimeMode]; |
| 21 | export const ComposerFooterModeControls = memo(function ComposerFooterModeControls(props: { |
| 22 | runtimeMode: RuntimeMode; |
| 23 | runtimeModeOptions: ReadonlyArray<RuntimeModeOption>; |
| 24 | size?: "sm" | "xs"; |
| 25 | hidden?: boolean; |
| 26 | /** How the permissions chip shows: hidden while the thread matches the user's default. */ |
| 27 | accessDisplay?: "label" | "icon" | "hidden"; |
| 28 | /** Draw the icon in the label color, not muted (the mode differs from the user's default). */ |
| 29 | emphasized?: boolean; |
| 30 | onRuntimeModeChange: (mode: RuntimeMode) => void; |
| 31 | }) { |
| 32 | const gt = useGT(); |
| 33 | const messages = useMessages(); |
| 34 | const size = props.size ?? "sm"; |
| 35 | const accessDisplay = props.accessDisplay ?? "label"; |
| 36 | const composerFloatingLayerProps = useComposerMenuProps(); |
| 37 | const [open, setOpen] = useComposerMenuState(props.hidden); |
| 38 | const permissionsChipRef = useRef<HTMLButtonElement>(null); |
| 39 | const runtimeModeOption = |
| 40 | props.runtimeModeOptions.find((option) => option.mode === props.runtimeMode) ?? |
| 41 | resolveRuntimeModeOption("approval-required", messages); |
| 42 | const RuntimeModeIcon = runtimeModeOption.icon; |
| 43 | // The chip opens the same Permissions toggle used in the model picker and the overflow menu. |
| 44 | const permissionsTooltip = gt("Permissions: {mode}. {description}", { |
| 45 | mode: runtimeModeOption.label, |
| 46 | description: runtimeModeOption.description, |
| 47 | }); |
| 48 | const permissionsChip = ( |
| 49 | <Menu |
| 50 | open={open} |
| 51 | onOpenChange={setOpen} |
| 52 | onOpenChangeComplete={(isOpen) => |
| 53 | focusRequestedPermission(isOpen, permissionsChipRef.current) |
| 54 | } |
| 55 | > |
| 56 | <Tooltip> |
| 57 | <TooltipTrigger |
| 58 | render={ |
| 59 | <MenuTrigger |
| 60 | render={ |
| 61 | <ComposerControl |
| 62 | ref={permissionsChipRef} |
| 63 | data-composer-shortcut="composer.mode" |
| 64 | size={size} |
| 65 | // Mirrors the model trigger's trailing pe-1 so the gaps on both sides of the chip match. |
| 66 | className="ps-1.5" |
| 67 | aria-label={gt("Permissions: {mode}", { mode: runtimeModeOption.label })} |
| 68 | /> |
| 69 | } |
| 70 | /> |
| 71 | } |
| 72 | > |
| 73 | <ComposerControlIcon |
| 74 | icon={RuntimeModeIcon} |
| 75 | size={size} |
| 76 | // Match the label, not full foreground: the chip's presence already marks the mode. |
| 77 | {...(props.emphasized ? { className: "text-current" } : {})} |
| 78 | /> |
| 79 | <span |
| 80 | data-composer-control-label |
| 81 | className={accessDisplay === "icon" ? "sr-only" : undefined} |
| 82 | > |
| 83 | {runtimeModeOption.label} |
| 84 | </span> |
| 85 | </TooltipTrigger> |
| 86 | <TooltipPopup side="top">{permissionsTooltip}</TooltipPopup> |
| 87 | </Tooltip> |
| 88 | <MenuPopup align="start" {...composerFloatingLayerProps}> |
| 89 | <ComposerPermissionsSection |
| 90 | runtimeMode={props.runtimeMode} |
| 91 | runtimeModeOptions={props.runtimeModeOptions} |
| 92 | onRuntimeModeChange={props.onRuntimeModeChange} |
| 93 | /> |
| 94 | </MenuPopup> |
| 95 | </Menu> |
| 96 | ); |
| 97 | |
| 98 | return accessDisplay === "hidden" ? null : permissionsChip; |
| 99 | }); |
| 100 | |
| 101 | /** |
| 102 | * Permission modes as one horizontal toggle, with the shown mode named below. |
| 103 | * Each segment is a real menu radio item, so arrow keys reach it from the rest of the menu |
| 104 | * and a pick closes the menu. Lives inside a Menu: the permissions chip, the model picker, |
| 105 | * or the overflow menu. |
| 106 | */ |
| 107 | export function ComposerPermissionsSection(props: { |
| 108 | runtimeMode: RuntimeMode; |
| 109 | runtimeModeOptions: ReadonlyArray<RuntimeModeOption>; |
| 110 | onRuntimeModeChange: (mode: RuntimeMode) => void; |
| 111 | }) { |
| 112 | const gt = useGT(); |
| 113 | const messages = useMessages(); |
| 114 | // Hover or keyboard focus previews a mode's name and description before a pick. |
| 115 | const [previewMode, setPreviewMode] = useState<RuntimeMode | null>(null); |
| 116 | const shownMode = previewMode ?? props.runtimeMode; |
| 117 | const shown = |
| 118 | props.runtimeModeOptions.find((option) => option.mode === shownMode) ?? |
| 119 | resolveRuntimeModeOption("approval-required", messages); |
| 120 | const descriptionId = useId(); |
| 121 | return ( |
| 122 | <div data-composer-permissions className="grid w-72 gap-1.5 px-2 py-1.5"> |
| 123 | <div className="font-medium text-muted-foreground text-xs"> |
| 124 | <T>Permissions</T> |
| 125 | </div> |
| 126 | <MenuPrimitive.RadioGroup |
| 127 | aria-label={gt("Permissions")} |
| 128 | value={props.runtimeMode} |
| 129 | onValueChange={(value: RuntimeMode) => { |
| 130 | if (value !== props.runtimeMode) props.onRuntimeModeChange(value); |
| 131 | }} |
| 132 | className="flex rounded-lg bg-input/40 p-0.5" |
| 133 | // Menus navigate with Up/Down only; the row reads horizontally, so Left/Right move too. |
| 134 | onKeyDown={(event) => { |
| 135 | if (event.key !== "ArrowLeft" && event.key !== "ArrowRight") return; |
| 136 | const items = Array.from( |
| 137 | event.currentTarget.querySelectorAll<HTMLElement>('[role="menuitemradio"]'), |
| 138 | ); |
| 139 | const index = items.findIndex((item) => item === document.activeElement); |
| 140 | const next = items[index + (event.key === "ArrowRight" ? 1 : -1)]; |
| 141 | if (index < 0 || !next) return; |
| 142 | event.preventDefault(); |
| 143 | event.stopPropagation(); |
| 144 | next.focus(); |
| 145 | }} |
| 146 | > |
| 147 | {props.runtimeModeOptions.map((option) => { |
| 148 | const OptionIcon = option.icon; |
| 149 | return ( |
| 150 | <MenuPrimitive.RadioItem |
| 151 | key={option.mode} |
| 152 | value={option.mode} |
| 153 | disabled={option.disabledReason !== undefined} |
| 154 | label={option.label} |
| 155 | aria-label={option.label} |
| 156 | aria-describedby={`${descriptionId}-${option.mode}`} |
| 157 | closeOnClick |
| 158 | onPointerEnter={() => setPreviewMode(option.mode)} |
| 159 | onPointerLeave={() => setPreviewMode(null)} |
| 160 | onFocus={() => setPreviewMode(option.mode)} |
| 161 | onBlur={() => setPreviewMode(null)} |
| 162 | className="flex h-6 flex-1 cursor-pointer items-center justify-center text-muted-foreground outline-none first:rounded-l-md last:rounded-r-md data-disabled:cursor-not-allowed data-disabled:opacity-40 data-checked:bg-input/72 data-checked:text-foreground data-highlighted:text-foreground not-data-checked:data-highlighted:bg-accent focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-inset" |
| 163 | > |
| 164 | <OptionIcon aria-hidden="true" className="size-3.5" /> |
| 165 | </MenuPrimitive.RadioItem> |
| 166 | ); |
| 167 | })} |
| 168 | </MenuPrimitive.RadioGroup> |
| 169 | {/* Static per-mode descriptions for screen readers; the preview below is visual only. */} |
| 170 | {props.runtimeModeOptions.map((option) => ( |
| 171 | <span key={option.mode} id={`${descriptionId}-${option.mode}`} className="sr-only"> |
| 172 | {option.disabledReason ?? option.description} |
| 173 | </span> |
| 174 | ))} |
| 175 | <div className="grid gap-0.5" aria-hidden="true"> |
| 176 | <span |
| 177 | className={ |
| 178 | shownMode === props.runtimeMode |
| 179 | ? "text-foreground text-sm" |
| 180 | : "text-muted-foreground text-sm" |
| 181 | } |
| 182 | > |
| 183 | {shown.label} |
| 184 | </span> |
| 185 | {/* Two lines reserved so the menu does not shift while you preview modes. */} |
| 186 | <span className="min-h-8 text-muted-foreground text-xs leading-4"> |
| 187 | {shown.disabledReason ?? shown.description} |
| 188 | </span> |
| 189 | </div> |
| 190 | </div> |
| 191 | ); |
| 192 | } |
| 193 | |
| 194 | export const ComposerFooterPrimaryActions = memo(function ComposerFooterPrimaryActions(props: { |
| 195 | children?: React.ReactNode; |
| 196 | compact: boolean; |
| 197 | canOperateThread: boolean; |
| 198 | isPreparingWorktree: boolean; |
| 199 | pendingAction: { |
| 200 | questionIndex: number; |
| 201 | isLastQuestion: boolean; |
| 202 | canAdvance: boolean; |
| 203 | isResponding: boolean; |
| 204 | isComplete: boolean; |
| 205 | } | null; |
| 206 | isRunning: boolean; |
| 207 | canInterrupt: boolean; |
| 208 | runId: string | null; |
| 209 | followUpBehavior: "queue" | "steer"; |
| 210 | canSteer: boolean; |
| 211 | alternateShortcutLabel: string | null; |
| 212 | voiceInputActive?: boolean; |
| 213 | isSendBusy: boolean; |
| 214 | sendDisabledReason: string | null; |
| 215 | isEnvironmentUnavailable: boolean; |
| 216 | hasSendableContent: boolean; |
| 217 | canResume: boolean; |
| 218 | preserveComposerFocusOnPointerDown?: boolean; |
| 219 | isEditingQueuedMessage: boolean; |
| 220 | onSubmitMessage: React.MouseEventHandler<HTMLButtonElement>; |
| 221 | onResume: () => void; |
| 222 | onPreviousPendingQuestion: () => void; |
| 223 | onInterrupt: () => void; |
| 224 | compactBeforeSendTokens: number | null; |
| 225 | hideCompactToggle: boolean; |
| 226 | keepFullHistory: boolean; |
| 227 | onToggleKeepFullHistory: () => void; |
| 228 | }) { |
| 229 | return ( |
| 230 | <> |
| 231 | <ComposerPrimaryActions |
| 232 | compact={props.compact} |
| 233 | canOperateThread={props.canOperateThread} |
| 234 | pendingAction={props.pendingAction} |
| 235 | isRunning={props.isRunning} |
| 236 | canInterrupt={props.canInterrupt} |
| 237 | runId={props.runId} |
| 238 | followUpBehavior={props.followUpBehavior} |
| 239 | canSteer={props.canSteer} |
| 240 | alternateShortcutLabel={props.alternateShortcutLabel} |
| 241 | voiceInputActive={props.voiceInputActive ?? false} |
| 242 | isSendBusy={props.isSendBusy} |
| 243 | sendDisabledReason={props.sendDisabledReason} |
| 244 | isEnvironmentUnavailable={props.isEnvironmentUnavailable} |
| 245 | isPreparingWorktree={props.isPreparingWorktree} |
| 246 | hasSendableContent={props.hasSendableContent} |
| 247 | canResume={props.canResume} |
| 248 | preserveComposerFocusOnPointerDown={props.preserveComposerFocusOnPointerDown ?? false} |
| 249 | isEditingQueuedMessage={props.isEditingQueuedMessage} |
| 250 | onSubmitMessage={props.onSubmitMessage} |
| 251 | onResume={props.onResume} |
| 252 | onPreviousPendingQuestion={props.onPreviousPendingQuestion} |
| 253 | onInterrupt={props.onInterrupt} |
| 254 | compactBeforeSendTokens={props.compactBeforeSendTokens} |
| 255 | hideCompactToggle={props.hideCompactToggle} |
| 256 | keepFullHistory={props.keepFullHistory} |
| 257 | onToggleKeepFullHistory={props.onToggleKeepFullHistory} |
| 258 | > |
| 259 | {props.children} |
| 260 | </ComposerPrimaryActions> |
| 261 | </> |
| 262 | ); |
| 263 | }); |
| 264 | |
| 265 | /** |
| 266 | * The composer's model picker. It owns the single- and multi-model selection |
| 267 | * handlers so they are cached against the selection state, not rebuilt on |
| 268 | * every ChatComposer render. |
| 269 | */ |
| 270 | export function ComposerModelPicker({ |
| 271 | multipleModelsEnabled, |
| 272 | multipleModelSelections, |
| 273 | onMultipleModelSelectionsChange, |
| 274 | selectedModelSelection, |
| 275 | onProviderModelSelect, |
| 276 | ...pickerProps |
| 277 | }: Omit< |
| 278 | ComponentProps<typeof ProviderModelPicker>, |
| 279 | "selectedModels" | "onToggleModel" | "onInstanceModelChange" |
| 280 | > & { |
| 281 | readonly multipleModelsEnabled: boolean; |
| 282 | readonly multipleModelSelections: ReadonlyArray<ModelSelection> | null; |
| 283 | readonly onMultipleModelSelectionsChange: ( |
| 284 | selections: ReadonlyArray<ModelSelection> | null, |
| 285 | ) => void; |
| 286 | readonly selectedModelSelection: ModelSelection; |
| 287 | readonly onProviderModelSelect: ( |
| 288 | instanceId: ProviderInstanceId, |
| 289 | model: string, |
| 290 | options?: { focusComposer?: boolean }, |
| 291 | ) => void; |
| 292 | }) { |
| 293 | const { instanceEntries, modelOptionsByInstance } = pickerProps; |
| 294 | const toggleModel = (instanceId: ProviderInstanceId, model: string) => { |
| 295 | const current = multipleModelSelections ?? [selectedModelSelection]; |
| 296 | const matchesModel = (selection: ModelSelection) => { |
| 297 | if (selection.instanceId !== instanceId) return false; |
| 298 | const entry = instanceEntries.find((entry) => entry.instanceId === selection.instanceId); |
| 299 | const resolvedModel = resolveModelPickerSelectedModel({ |
| 300 | driverKind: entry?.driverKind, |
| 301 | model: selection.model, |
| 302 | options: modelOptionsByInstance?.get(selection.instanceId) ?? [], |
| 303 | }); |
| 304 | return (resolvedModel?.slug ?? selection.model) === model; |
| 305 | }; |
| 306 | const exists = current.some(matchesModel); |
| 307 | const next = exists |
| 308 | ? current.filter((selection) => !matchesModel(selection)) |
| 309 | : [...current, createModelSelection(instanceId, model)]; |
| 310 | if (next.length > 1) { |
| 311 | onMultipleModelSelectionsChange(next); |
| 312 | } else { |
| 313 | onMultipleModelSelectionsChange(null); |
| 314 | const remaining = next[0] ?? selectedModelSelection; |
| 315 | onProviderModelSelect(remaining.instanceId, remaining.model, { |
| 316 | focusComposer: false, |
| 317 | }); |
| 318 | } |
| 319 | }; |
| 320 | return ( |
| 321 | <ProviderModelPicker |
| 322 | {...pickerProps} |
| 323 | {...(multipleModelsEnabled |
| 324 | ? { |
| 325 | ...(multipleModelSelections !== null |
| 326 | ? { selectedModels: multipleModelSelections } |
| 327 | : {}), |
| 328 | onToggleModel: toggleModel, |
| 329 | } |
| 330 | : {})} |
| 331 | onInstanceModelChange={(instanceId, model) => { |
| 332 | onMultipleModelSelectionsChange(null); |
| 333 | onProviderModelSelect(instanceId, model); |
| 334 | }} |
| 335 | /> |
| 336 | ); |
| 337 | } |