@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
tsx 337 lines 13.3 KB
Raw
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 }