import type {
ModelSelection,
ProviderInstanceId,
ProviderInteractionMode,
RuntimeMode,
} from "@t3tools/contracts";
import { createModelSelection } from "@t3tools/shared/model";
import { BotIcon, PencilRulerIcon } from "lucide-react";
import { type ComponentProps, memo, useId, useRef, useState } from "react";
import type { ContextWindowSnapshot } from "@t3tools/client-runtime/state/context-window";
import { Menu as MenuPrimitive } from "@base-ui/react/menu";
import { Menu, MenuPopup, MenuTrigger } from "../ui/menu";
import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
import { ComposerControl, ComposerControlIcon } from "./ComposerControl";
import { focusRequestedPermission, useComposerMenuProps } from "./composerEventScope";
import { ComposerPrimaryActions } from "./ComposerPrimaryActions";
import { ContextWindowMeter, ContextWindowMeterPlaceholder } from "./ContextWindowMeter";
import { resolveModelPickerSelectedModel } from "./ModelPickerContent";
import { ProviderModelPicker } from "./ProviderModelPicker";
import { runtimeModeConfig } from "./runtimeModeConfig";
import { useComposerMenuState } from "./useComposerMenuState";
export type RuntimeModeOption = {
mode: RuntimeMode;
disabledReason?: string;
} & (typeof runtimeModeConfig)[RuntimeMode];
const supervisedRuntimeModeOption: RuntimeModeOption = {
mode: "approval-required" as const,
...runtimeModeConfig["approval-required"],
};
export const ComposerFooterModeControls = memo(function ComposerFooterModeControls(props: {
showInteractionModeToggle: boolean;
interactionMode: ProviderInteractionMode;
runtimeMode: RuntimeMode;
runtimeModeOptions: ReadonlyArray<RuntimeModeOption>;
size?: "sm" | "xs";
hidden?: boolean;
/** How the permissions chip shows: hidden while the thread matches the user's default. */
accessDisplay?: "label" | "icon" | "hidden";
/** Draw the icon in the label color, not muted (the mode differs from the user's default). */
emphasized?: boolean;
onToggleInteractionMode: () => void;
onRuntimeModeChange: (mode: RuntimeMode) => void;
}) {
const size = props.size ?? "sm";
const accessDisplay = props.accessDisplay ?? "label";
const composerFloatingLayerProps = useComposerMenuProps();
const [open, setOpen] = useComposerMenuState(props.hidden);
const permissionsChipRef = useRef<HTMLButtonElement>(null);
const runtimeModeOption =
props.runtimeModeOptions.find((option) => option.mode === props.runtimeMode) ??
supervisedRuntimeModeOption;
const RuntimeModeIcon = runtimeModeOption.icon;
const interactionModeTooltip =
props.interactionMode === "plan"
? "Plan mode. Click to return to normal build mode"
: "Default mode. Click to enter plan mode";
const interactionModeToggle = props.showInteractionModeToggle ? (
<Tooltip>
<TooltipTrigger
render={
<ComposerControl
size={size}
className="shrink-0 whitespace-nowrap"
aria-pressed={props.interactionMode === "plan"}
type="button"
onClick={props.onToggleInteractionMode}
aria-label={interactionModeTooltip}
/>
}
>
{props.interactionMode === "plan" ? (
<ComposerControlIcon
icon={PencilRulerIcon}
size={size}
className="text-current opacity-100"
/>
) : (
<ComposerControlIcon
icon={BotIcon}
size={size}
opticalSize={size === "xs" ? "default" : "large"}
/>
)}
{/* The compacted row (xs) keeps this icon-only, like the other controls there. */}
<span
data-composer-control-label
className={size === "xs" ? "sr-only" : "sr-only sm:not-sr-only"}
>
{props.interactionMode === "plan" ? "Plan" : "Build"}
</span>
</TooltipTrigger>
<TooltipPopup side="top">{interactionModeTooltip}</TooltipPopup>
</Tooltip>
) : null;
// The chip opens the same Permissions toggle used in the model picker and the overflow menu.
const permissionsTooltip = `Permissions: ${runtimeModeOption.label}. ${runtimeModeOption.description}`;
const permissionsChip = (
<Menu
open={open}
onOpenChange={setOpen}
onOpenChangeComplete={(isOpen) =>
focusRequestedPermission(isOpen, permissionsChipRef.current)
}
>
<Tooltip>
<TooltipTrigger
render={
<MenuTrigger
render={
<ComposerControl
ref={permissionsChipRef}
data-composer-shortcut="composer.mode"
size={size}
// Mirrors the model trigger's trailing pe-1 so the gaps on both sides of the chip match.
className="ps-1.5"
aria-label={`Permissions: ${runtimeModeOption.label}`}
/>
}
/>
}
>
<ComposerControlIcon
icon={RuntimeModeIcon}
size={size}
// Match the label, not full foreground: the chip's presence already marks the mode.
{...(props.emphasized ? { className: "text-current" } : {})}
/>
<span
data-composer-control-label
className={accessDisplay === "icon" ? "sr-only" : undefined}
>
{runtimeModeOption.label}
</span>
</TooltipTrigger>
<TooltipPopup side="top">{permissionsTooltip}</TooltipPopup>
</Tooltip>
<MenuPopup align="start" {...composerFloatingLayerProps}>
<ComposerPermissionsSection
runtimeMode={props.runtimeMode}
runtimeModeOptions={props.runtimeModeOptions}
onRuntimeModeChange={props.onRuntimeModeChange}
/>
</MenuPopup>
</Menu>
);
return (
<>
{accessDisplay === "hidden" ? null : permissionsChip}
{interactionModeToggle}
</>
);
});
/**
* Permission modes as one horizontal toggle, with the shown mode named below.
* Each segment is a real menu radio item, so arrow keys reach it from the rest of the menu
* and a pick closes the menu. Lives inside a Menu: the permissions chip, the model picker,
* or the overflow menu.
*/
export function ComposerPermissionsSection(props: {
runtimeMode: RuntimeMode;
runtimeModeOptions: ReadonlyArray<RuntimeModeOption>;
onRuntimeModeChange: (mode: RuntimeMode) => void;
}) {
// Hover or keyboard focus previews a mode's name and description before a pick.
const [previewMode, setPreviewMode] = useState<RuntimeMode | null>(null);
const shownMode = previewMode ?? props.runtimeMode;
const shown =
props.runtimeModeOptions.find((option) => option.mode === shownMode) ??
supervisedRuntimeModeOption;
const descriptionId = useId();
return (
<div data-composer-permissions className="grid w-72 gap-1.5 px-2 py-1.5">
<div className="font-medium text-muted-foreground text-xs">Permissions</div>
<MenuPrimitive.RadioGroup
aria-label="Permissions"
value={props.runtimeMode}
onValueChange={(value: RuntimeMode) => {
if (value !== props.runtimeMode) props.onRuntimeModeChange(value);
}}
className="flex rounded-lg bg-input/40 p-0.5"
// Menus navigate with Up/Down only; the row reads horizontally, so Left/Right move too.
onKeyDown={(event) => {
if (event.key !== "ArrowLeft" && event.key !== "ArrowRight") return;
const items = Array.from(
event.currentTarget.querySelectorAll<HTMLElement>('[role="menuitemradio"]'),
);
const index = items.findIndex((item) => item === document.activeElement);
const next = items[index + (event.key === "ArrowRight" ? 1 : -1)];
if (index < 0 || !next) return;
event.preventDefault();
event.stopPropagation();
next.focus();
}}
>
{props.runtimeModeOptions.map((option) => {
const OptionIcon = option.icon;
return (
<MenuPrimitive.RadioItem
key={option.mode}
value={option.mode}
disabled={option.disabledReason !== undefined}
label={option.label}
aria-label={option.label}
aria-describedby={`${descriptionId}-${option.mode}`}
closeOnClick
onPointerEnter={() => setPreviewMode(option.mode)}
onPointerLeave={() => setPreviewMode(null)}
onFocus={() => setPreviewMode(option.mode)}
onBlur={() => setPreviewMode(null)}
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"
>
<OptionIcon aria-hidden="true" className="size-3.5" />
</MenuPrimitive.RadioItem>
);
})}
</MenuPrimitive.RadioGroup>
{/* Static per-mode descriptions for screen readers; the preview below is visual only. */}
{props.runtimeModeOptions.map((option) => (
<span key={option.mode} id={`${descriptionId}-${option.mode}`} className="sr-only">
{option.disabledReason ?? option.description}
</span>
))}
<div className="grid gap-0.5" aria-hidden="true">
<span
className={
shownMode === props.runtimeMode
? "text-foreground text-sm"
: "text-muted-foreground text-sm"
}
>
{shown.label}
</span>
{/* Two lines reserved so the menu does not shift while you preview modes. */}
<span className="min-h-8 text-muted-foreground text-xs leading-4">
{shown.disabledReason ?? shown.description}
</span>
</div>
</div>
);
}
export const ComposerFooterPrimaryActions = memo(function ComposerFooterPrimaryActions(props: {
children?: React.ReactNode;
compact: boolean;
canOperateThread: boolean;
activeContextWindow: ContextWindowSnapshot | null;
reserveContextWindowMeter: boolean;
activeThreadModelDisplayName: string | null;
isPreparingWorktree: boolean;
pendingAction: {
questionIndex: number;
isLastQuestion: boolean;
canAdvance: boolean;
isResponding: boolean;
isComplete: boolean;
} | null;
isRunning: boolean;
canInterrupt: boolean;
followUpBehavior: "queue" | "steer";
canSteer: boolean;
alternateShortcutLabel: string | null;
showPlanFollowUpPrompt: boolean;
promptHasText: boolean;
voiceInputActive?: boolean;
isSendBusy: boolean;
sendDisabledReason: string | null;
isEnvironmentUnavailable: boolean;
hasSendableContent: boolean;
canResume: boolean;
preserveComposerFocusOnPointerDown?: boolean;
isEditingQueuedMessage: boolean;
onSubmitMessage: React.MouseEventHandler<HTMLButtonElement>;
onResume: () => void;
onPreviousPendingQuestion: () => void;
onInterrupt: () => void;
onImplementPlanInNewThread: () => void;
onCompactContext?: (() => void) | undefined;
compactDisabled: boolean;
compactDisabledReason: string | null;
compactBeforeSendTokens: number | null;
keepFullHistory: boolean;
onToggleKeepFullHistory: () => void;
}) {
return (
<>
{props.activeContextWindow ? (
<ContextWindowMeter
usage={props.activeContextWindow}
modelDisplayName={props.activeThreadModelDisplayName}
onCompact={props.onCompactContext}
compactDisabled={props.compactDisabled}
compactDisabledReason={props.compactDisabledReason}
/>
) : props.reserveContextWindowMeter ? (
<ContextWindowMeterPlaceholder />
) : null}
{props.children}
<ComposerPrimaryActions
compact={props.compact}
canOperateThread={props.canOperateThread}
pendingAction={props.pendingAction}
isRunning={props.isRunning}
canInterrupt={props.canInterrupt}
followUpBehavior={props.followUpBehavior}
canSteer={props.canSteer}
alternateShortcutLabel={props.alternateShortcutLabel}
showPlanFollowUpPrompt={props.showPlanFollowUpPrompt}
promptHasText={props.promptHasText}
voiceInputActive={props.voiceInputActive ?? false}
isSendBusy={props.isSendBusy}
sendDisabledReason={props.sendDisabledReason}
isEnvironmentUnavailable={props.isEnvironmentUnavailable}
isPreparingWorktree={props.isPreparingWorktree}
hasSendableContent={props.hasSendableContent}
canResume={props.canResume}
preserveComposerFocusOnPointerDown={props.preserveComposerFocusOnPointerDown ?? false}
isEditingQueuedMessage={props.isEditingQueuedMessage}
onSubmitMessage={props.onSubmitMessage}
onResume={props.onResume}
onPreviousPendingQuestion={props.onPreviousPendingQuestion}
onInterrupt={props.onInterrupt}
onImplementPlanInNewThread={props.onImplementPlanInNewThread}
compactBeforeSendTokens={props.compactBeforeSendTokens}
keepFullHistory={props.keepFullHistory}
onToggleKeepFullHistory={props.onToggleKeepFullHistory}
/>
</>
);
});
/**
* The composer's model picker. It owns the single- and multi-model selection
* handlers so they are cached against the selection state, not rebuilt on
* every ChatComposer render.
*/
export function ComposerModelPicker({
multipleModelsEnabled,
multipleModelSelections,
onMultipleModelSelectionsChange,
selectedModelSelection,
onProviderModelSelect,
...pickerProps
}: Omit<
ComponentProps<typeof ProviderModelPicker>,
"selectedModels" | "onToggleModel" | "onInstanceModelChange"
> & {
readonly multipleModelsEnabled: boolean;
readonly multipleModelSelections: ReadonlyArray<ModelSelection> | null;
readonly onMultipleModelSelectionsChange: (
selections: ReadonlyArray<ModelSelection> | null,
) => void;
readonly selectedModelSelection: ModelSelection;
readonly onProviderModelSelect: (
instanceId: ProviderInstanceId,
model: string,
options?: { focusComposer?: boolean },
) => void;
}) {
const { instanceEntries, modelOptionsByInstance } = pickerProps;
const toggleModel = (instanceId: ProviderInstanceId, model: string) => {
const current = multipleModelSelections ?? [selectedModelSelection];
const matchesModel = (selection: ModelSelection) => {
if (selection.instanceId !== instanceId) return false;
const entry = instanceEntries.find((entry) => entry.instanceId === selection.instanceId);
const resolvedModel = resolveModelPickerSelectedModel({
driverKind: entry?.driverKind,
model: selection.model,
options: modelOptionsByInstance?.get(selection.instanceId) ?? [],
});
return (resolvedModel?.slug ?? selection.model) === model;
};
const exists = current.some(matchesModel);
const next = exists
? current.filter((selection) => !matchesModel(selection))
: [...current, createModelSelection(instanceId, model)];
if (next.length > 1) {
onMultipleModelSelectionsChange(next);
} else {
onMultipleModelSelectionsChange(null);
const remaining = next[0] ?? selectedModelSelection;
onProviderModelSelect(remaining.instanceId, remaining.model, {
focusComposer: false,
});
}
};
return (
<ProviderModelPicker
{...pickerProps}
{...(multipleModelsEnabled
? {
...(multipleModelSelections !== null
? { selectedModels: multipleModelSelections }
: {}),
onToggleModel: toggleModel,
}
: {})}
onInstanceModelChange={(instanceId, model) => {
onMultipleModelSelectionsChange(null);
onProviderModelSelect(instanceId, model);
}}
/>
);
}