Search agent settings in Cmd-K before the first message (#10182)

* fix(app): make agent controls searchable before the first message

New workspace already renders the shared draft controls, but Command Center registration lived in the workspace tab. Register from the draft controls and use the active composer scope so each host gets the same behavior.

Co-authored-by: Christoph Leiter <135764+cleiter@users.noreply.github.com>

* fix(app): keep agent settings searchable in fullscreen

Compact fullscreen editing used to unmount the toolbar and remove the active composer settings from Command Center. Keep the controls registered while fullscreen hides the inline toolbar.

* fix(app): show composer settings from compact sidebar search

The sidebar suspends editor shortcuts while it covers the pane. Give Command Center an explicit target so sidebar search still uses the center composer and Explorer keeps its own scope when open.

* test(app): cover compact Command Center settings for running agents

---------

Co-authored-by: Christoph Leiter <135764+cleiter@users.noreply.github.com>
This commit is contained in:
Mohamed Boudra
2026-11-19 11:20:09 +07:00
committed by GitHub
co-authored by Christoph Leiter
parent 2327701497
commit 4e78d15bdc
11 changed files with 313 additions and 132 deletions
@@ -1,6 +1,17 @@
import { expect, test } from "../support/fixtures";
import type { FormPreferences } from "@/create-agent-preferences/preferences";
import { closeCommandCenter, openCommandCenter } from "../support/helpers/command-center";
import {
closeCommandCenter,
openCommandCenter,
openCommandCenterWithShortcut,
} from "../support/helpers/command-center";
import {
enterComposerFullscreen,
exitComposerFullscreen,
expectComposerVisible,
fillComposerDraft,
resizeComposerViewport,
} from "../support/helpers/composer";
import {
applyCommandCenterAgentControls,
chooseCommandCenterAgentControl,
@@ -14,8 +25,18 @@ import {
} from "../support/helpers/command-center-agent-controls";
import { clickNewChat, gotoWorkspace } from "../support/helpers/launcher";
import { openAgentRoute, seedMockAgentWorkspace } from "../support/helpers/mock-agent";
import {
assertNewWorkspaceSidebarAndHeader,
connectNewWorkspaceDaemonClient,
openGlobalNewWorkspaceComposer,
selectNewWorkspaceProject,
selectWorkspaceIsolation,
submitNewWorkspacePrompt,
} from "../support/helpers/new-workspace";
import { getServerId } from "../support/helpers/server-id";
import { expectAppRoute } from "../support/helpers/route-assertions";
import { seedWorkspace } from "../support/helpers/seed-client";
import { closeMobileAgentSidebar, openMobileAgentSidebar } from "../support/helpers/sidebar";
import { buildSchedulesRoute } from "@/utils/host-routes";
const CREATE_AGENT_PREFERENCES_KEY = "@paseo:create-agent-preferences";
@@ -30,7 +51,7 @@ async function seedMockDraftPreferences(page: import("@playwright/test").Page):
providerPreferences: {
mock: {
model: "five-minute-stream",
mode: "load-test",
mode: "approval-test",
},
},
} satisfies FormPreferences),
@@ -221,6 +242,94 @@ test.describe("Command Center agent controls", () => {
await workspace.cleanup();
}
});
test("applies New workspace model and mode choices before the first message", async ({
page,
}) => {
const workspace = await seedWorkspace({ repoPrefix: "command-center-new-workspace-controls-" });
await seedMockDraftPreferences(page);
const client = await connectNewWorkspaceDaemonClient();
try {
const backgroundAgent = await workspace.client.createAgent({
provider: "mock",
cwd: workspace.repoPath,
workspaceId: workspace.workspaceId,
title: "Background agent",
model: "five-minute-stream",
modeId: "approval-test",
});
await openAgentRoute(page, {
workspaceId: workspace.workspaceId,
agentId: backgroundAgent.id,
});
await openGlobalNewWorkspaceComposer(page);
await selectNewWorkspaceProject(page, workspace);
await selectWorkspaceIsolation(page, "local");
await applyCommandCenterAgentControls(page, DRAFT_AGENT_CONTROL_CHOICES);
await closeCommandCenter(page);
await submitNewWorkspacePrompt(page, "Create with Command Center choices");
const created = await assertNewWorkspaceSidebarAndHeader(page, {
serverId: getServerId(),
client,
previousWorkspaceId: workspace.workspaceId,
projectDisplayName: workspace.projectDisplayName,
});
await expectWorkspaceAgentConfiguration(
{ client: workspace.client, workspaceId: created.workspaceId },
{ provider: "mock", model: "ten-second-stream", modeId: "load-test" },
);
await expectWorkspaceAgentConfiguration(workspace, {
id: backgroundAgent.id,
provider: "mock",
model: "five-minute-stream",
modeId: "approval-test",
});
} finally {
await client.close().catch(() => undefined);
await workspace.cleanup();
}
});
test("keeps draft settings searchable from the compact sidebar and fullscreen editor", async ({
page,
}) => {
const workspace = await seedWorkspace({ repoPrefix: "command-center-fullscreen-draft-" });
await seedMockDraftPreferences(page);
try {
await openDraftComposer(page, workspace.workspaceId);
await resizeComposerViewport(page, "portrait");
await applyCompactComposerSettings(page);
} finally {
await workspace.cleanup();
}
});
test("applies compact sidebar and fullscreen settings to the running agent", async ({ page }) => {
const workspace = await seedMockAgentWorkspace({
repoPrefix: "command-center-fullscreen-agent-",
title: "Compact Command Center settings",
model: "five-minute-stream",
modeId: "approval-test",
});
try {
await resizeComposerViewport(page, "portrait");
await openAgentRoute(page, workspace);
await applyCompactComposerSettings(page);
await expectWorkspaceAgentConfiguration(workspace, {
id: workspace.agentId,
provider: "mock",
model: "ten-second-stream",
modeId: "load-test",
});
} finally {
await workspace.cleanup();
}
});
});
const DRAFT_AGENT_CONTROL_CHOICES = [
@@ -233,3 +342,22 @@ async function openDraftComposer(page: import("@playwright/test").Page, workspac
await clickNewChat(page);
await waitForDraftComposer(page);
}
async function applyCompactComposerSettings(page: import("@playwright/test").Page): Promise<void> {
const [model, mode] = DRAFT_AGENT_CONTROL_CHOICES;
await expectComposerVisible(page);
await openMobileAgentSidebar(page);
await openCommandCenter(page);
await chooseCommandCenterAgentControl({ page, ...mode });
await closeMobileAgentSidebar(page);
await fillComposerDraft(page, "First line\nSecond line\nThird line");
await enterComposerFullscreen(page);
await openCommandCenterWithShortcut(page);
await chooseCommandCenterAgentControl({ page, ...model });
await exitComposerFullscreen(page);
await openCommandCenterWithShortcut(page);
await expectCommandCenterAgentControlSelected({ page, ...model });
await expectCommandCenterAgentControlSelected({ page, ...mode });
}
@@ -23,6 +23,11 @@ export async function openCommandCenter(page: Page): Promise<Locator> {
return panel;
}
export async function openCommandCenterWithShortcut(page: Page): Promise<void> {
await page.keyboard.press("ControlOrMeta+k");
await expect(page.getByTestId("command-center-panel")).toBeVisible();
}
export async function closeCommandCenter(page: Page): Promise<void> {
await page.keyboard.press("Escape");
await expect(page.getByTestId("command-center-panel")).not.toBeVisible();
@@ -148,6 +148,7 @@ export interface DraftAgentControlsProps {
onSelectMode: (modeId: string) => void;
models: AgentModelDefinition[];
selectedModel: string;
effectiveModelId: string;
onSelectModel: (modelId: string) => void;
isModelLoading: boolean;
modelSelectorProviders: ProviderSelectorProvider[];
@@ -178,6 +179,7 @@ export interface DraftAgentControlsProps {
}
interface AgentControlsProps {
showToolbar: boolean;
agentId: string;
serverId: string;
onDropdownClose?: () => void;
@@ -193,10 +195,10 @@ function AgentControlCommandCenterRegistration({
enabled: boolean;
controls: AgentControlCommandCenterSource;
}) {
const { isActiveComposer } = useComposerKeyboardScope();
const { isCommandCenterTarget } = useComposerKeyboardScope();
useAgentControlCommandCenterActions({
sourceId,
enabled: enabled && isActiveComposer,
enabled: enabled && isCommandCenterTarget,
controls,
});
return null;
@@ -1010,6 +1012,7 @@ function useAgentOptionControls(
}
export const AgentControls = memo(function AgentControls({
showToolbar,
agentId,
serverId,
onDropdownClose,
@@ -1269,37 +1272,44 @@ export const AgentControls = memo(function AgentControls({
return (
<ComposerModelProvider value={composer}>
{commandCenterRegistration}
{profileEditor.element}
<ControlledAgentControls
provider={agent.provider}
modelSelectorProviders={agentModelSelectorProviders}
modelOptions={modelOptions}
selectedModelId={modelSelection.activeModelId ?? undefined}
onSelectModel={handleSelectModel}
agentProfiles={agentProfiles}
onApplyAgentProfile={agentProfiles?.applyProfile}
onEditAgentProfiles={handleEditAgentProfiles}
onCreateAgentProfile={profileActions.create}
onEditAgentProfile={profileActions.edit}
thinkingOptions={thinkingOptions.length > 0 ? thinkingOptions : undefined}
selectedThinkingOptionId={modelSelection.selectedThinkingId ?? undefined}
onSelectThinkingOption={handleSelectThinkingOption}
optionControls={agentOptionControls}
isModelLoading={snapshotIsLoading || selectedProviderIsLoading}
onModelSelectorOpen={handleModelSelectorOpen}
onRetryModelProvider={handleRetryModelProvider}
isRetryingModelProvider={snapshotIsRefreshing}
onDropdownClose={onDropdownClose}
disabled={!client}
modeControl={modeControl}
modelSelectorServerId={serverId}
isCompactLayout={isCompactLayout}
/>
{showToolbar ? (
<>
{profileEditor.element}
<ControlledAgentControls
provider={agent.provider}
modelSelectorProviders={agentModelSelectorProviders}
modelOptions={modelOptions}
selectedModelId={modelSelection.activeModelId ?? undefined}
onSelectModel={handleSelectModel}
agentProfiles={agentProfiles}
onApplyAgentProfile={agentProfiles?.applyProfile}
onEditAgentProfiles={handleEditAgentProfiles}
onCreateAgentProfile={profileActions.create}
onEditAgentProfile={profileActions.edit}
thinkingOptions={thinkingOptions.length > 0 ? thinkingOptions : undefined}
selectedThinkingOptionId={modelSelection.selectedThinkingId ?? undefined}
onSelectThinkingOption={handleSelectThinkingOption}
optionControls={agentOptionControls}
isModelLoading={snapshotIsLoading || selectedProviderIsLoading}
onModelSelectorOpen={handleModelSelectorOpen}
onRetryModelProvider={handleRetryModelProvider}
isRetryingModelProvider={snapshotIsRefreshing}
onDropdownClose={onDropdownClose}
disabled={!client}
modeControl={modeControl}
modelSelectorServerId={serverId}
isCompactLayout={isCompactLayout}
/>
</>
) : null}
</ComposerModelProvider>
);
});
export function DraftAgentControls({
showToolbar,
draftId,
serverId,
providerDefinitions,
selectedProvider,
modeOptions,
@@ -1307,6 +1317,7 @@ export function DraftAgentControls({
onSelectMode,
models,
selectedModel,
effectiveModelId,
onSelectModel,
isModelLoading: _isModelLoading,
modelSelectorProviders,
@@ -1329,7 +1340,7 @@ export function DraftAgentControls({
context = "draft",
metadata,
onSetMetadata,
}: DraftAgentControlsProps) {
}: DraftAgentControlsProps & { draftId: string; serverId: string; showToolbar: boolean }) {
const mappedThinkingOptions = useMemo<AgentControlOption[]>(() => {
return toThinkingControlOptions(thinkingOptions);
}, [thinkingOptions]);
@@ -1437,36 +1448,83 @@ export function DraftAgentControls({
[composerAgent, composerInput],
);
const commandCenterControls = useMemo<AgentControlCommandCenterSource>(
() => ({
serverId,
ownerKey: draftId,
provider: selectedProvider,
providerDefinitions,
models: {
providers: modelSelectorProviders,
selectedProvider,
selectedModelId: effectiveModelId,
select: (provider, modelId) => {
onSelectProviderAndModel(provider, modelId);
},
},
thinking: {
options: thinkingOptions,
selectedId: selectedThinkingOptionId,
select: onSelectThinkingOption,
},
modes: toCommandCenterModes(modeControl),
optionControls: optionControls ?? null,
}),
[
serverId,
draftId,
selectedProvider,
providerDefinitions,
modelSelectorProviders,
effectiveModelId,
onSelectProviderAndModel,
thinkingOptions,
selectedThinkingOptionId,
onSelectThinkingOption,
modeControl,
optionControls,
],
);
return (
<ComposerAgentProvider value={composerAgent}>
<ComposerModelProvider value={composerModel}>
{profileEditor.element}
<ControlledAgentControls
provider={selectedProvider ?? ""}
modelSelectorProviders={modelSelectorProviders}
modelOptions={modelOptions}
selectedModelId={selectedModel}
onSelectModel={onSelectModel}
onSelectProviderAndModel={onSelectProviderAndModel}
isModelLoading={isAllModelsLoading}
agentProfiles={agentProfiles}
onApplyAgentProfile={agentProfiles?.applyProfile}
onEditAgentProfiles={handleEditAgentProfiles}
onCreateAgentProfile={profileActions.create}
onEditAgentProfile={profileActions.edit}
thinkingOptions={mappedThinkingOptions.length > 0 ? mappedThinkingOptions : undefined}
selectedThinkingOptionId={effectiveSelectedThinkingOption}
onSelectThinkingOption={onSelectThinkingOption}
optionControls={optionControls}
onDropdownClose={onDropdownClose}
onModelSelectorOpen={onModelSelectorOpen}
onRetryModelProvider={onRetryModelProvider}
isRetryingModelProvider={isRetryingModelProvider}
disabled={disabled}
modeControl={modeControl}
modelSelectorServerId={modelSelectorServerId}
isCompactLayout={isCompactLayout}
<AgentControlCommandCenterRegistration
sourceId={`draft:${serverId}:${draftId}`}
enabled={!disabled}
controls={commandCenterControls}
/>
{showToolbar ? (
<>
{profileEditor.element}
<ControlledAgentControls
provider={selectedProvider ?? ""}
modelSelectorProviders={modelSelectorProviders}
modelOptions={modelOptions}
selectedModelId={selectedModel}
onSelectModel={onSelectModel}
onSelectProviderAndModel={onSelectProviderAndModel}
isModelLoading={isAllModelsLoading}
agentProfiles={agentProfiles}
onApplyAgentProfile={agentProfiles?.applyProfile}
onEditAgentProfiles={handleEditAgentProfiles}
onCreateAgentProfile={profileActions.create}
onEditAgentProfile={profileActions.edit}
thinkingOptions={mappedThinkingOptions.length > 0 ? mappedThinkingOptions : undefined}
selectedThinkingOptionId={effectiveSelectedThinkingOption}
onSelectThinkingOption={onSelectThinkingOption}
optionControls={optionControls}
onDropdownClose={onDropdownClose}
onModelSelectorOpen={onModelSelectorOpen}
onRetryModelProvider={onRetryModelProvider}
isRetryingModelProvider={isRetryingModelProvider}
disabled={disabled}
modeControl={modeControl}
modelSelectorServerId={modelSelectorServerId}
isCompactLayout={isCompactLayout}
/>
</>
) : null}
</ComposerModelProvider>
</ComposerAgentProvider>
);
@@ -25,6 +25,7 @@ describe("resolveAgentControlsMode", () => {
onSelectMode: () => undefined,
models: [],
selectedModel: "",
effectiveModelId: "",
onSelectModel: () => true,
isModelLoading: false,
modelSelectorProviders: [],
@@ -21,6 +21,7 @@ export function resolveDraftKey(input: {
export function buildDraftAgentControls(input: {
formState: UseAgentFormStateResult;
effectiveModelId: string;
optionControls?: DraftAgentControlsProps["optionControls"];
options: DraftAgentControlsProps["options"];
onSetOption: DraftAgentControlsProps["onSetOption"];
@@ -49,6 +50,7 @@ export function buildDraftAgentControls(input: {
onSelectMode: formState.setModeFromUser,
models: formState.availableModels,
selectedModel: formState.selectedModel,
effectiveModelId: input.effectiveModelId,
onSelectModel: formState.setModelFromUser,
isModelLoading: formState.isModelLoading,
modelSelectorProviders: formState.modelSelectorProviders,
@@ -357,6 +357,7 @@ export function useAgentInputDraft(input: UseAgentInputDraftInput): AgentInputDr
metadata,
agentControls: buildDraftAgentControls({
formState: draftForm,
effectiveModelId,
optionControls: draftOptionControls,
options: draftShownOptions,
onSetOption: setDraftOption,
@@ -21,7 +21,6 @@ import { useCreateFlowStore } from "@/stores/create-flow-store";
import type { Agent } from "@/stores/session-store";
import { useWorkspaceFields } from "@/stores/session-store-hooks";
import { useWorkspaceDraftSubmissionStore } from "@/stores/workspace-draft-submission-store";
import { useAgentControlCommandCenterActions } from "@/command-center/agent-control-registration";
import { encodeImages } from "@/utils/encode-images";
import { shouldAutoFocusWorkspaceDraftComposer } from "@/screens/workspace/workspace-draft-pane-focus";
import {
@@ -330,16 +329,6 @@ export function WorkspaceDraftComposer({
throw new Error("Workspace draft composer state is required");
}
const draftProvider = composerState.selectedProvider;
const draftProviderDefinitions = composerState.providerDefinitions;
const draftThinkingOptions = composerState.availableThinkingOptions;
const draftSelectedThinkingId = composerState.selectedThinkingOptionId;
const draftSetThinkingOption = composerState.setThinkingOptionFromUser;
const draftModeOptions = composerState.modeOptions;
const draftSelectedMode = composerState.selectedMode;
const draftSetMode = composerState.setModeFromUser;
const draftOptionControls = composerState.agentControls.optionControls;
const clearDraftInput = draftInput.clear;
const replaceDraftText = draftInput.replaceText;
const setDraftAttachments = draftInput.setAttachments;
@@ -471,35 +460,6 @@ export function WorkspaceDraftComposer({
onCreated(result);
},
});
useAgentControlCommandCenterActions({
sourceId: `draft:${serverId}:${tabId}`,
enabled: isPaneFocused && !isSubmitting,
controls: {
serverId,
ownerKey: tabId,
provider: draftProvider,
providerDefinitions: draftProviderDefinitions,
models: {
providers: composerState.modelSelectorProviders,
selectedProvider: draftProvider,
selectedModelId: composerState.effectiveModelId,
select: (provider, modelId) => {
composerState.setProviderAndModelFromUser(provider, modelId);
},
},
thinking: {
options: draftThinkingOptions,
selectedId: draftSelectedThinkingId,
select: draftSetThinkingOption,
},
modes: {
options: draftModeOptions,
selectedId: draftSelectedMode,
select: draftSetMode,
},
optionControls: draftOptionControls ?? null,
},
});
const isReadyForPendingAutoSubmit = Boolean(
pendingAutoSubmit &&
draftInput.isHydrated &&
+21 -6
View File
@@ -313,13 +313,22 @@ interface RenderLeftContentArgs {
focusInput: () => void;
isCompactLayout: boolean;
showAgentControls: boolean;
showToolbar: boolean;
}
function renderLeftContent(args: RenderLeftContentArgs): ReactElement | null {
const { agentControls, agentId, serverId, focusInput, isCompactLayout } = args;
const { agentControls, agentId, serverId, focusInput, isCompactLayout, showToolbar } = args;
if (!args.showAgentControls) return null;
if (resolveAgentControlsMode(agentControls) === "draft" && agentControls) {
return <DraftAgentControls {...agentControls} isCompactLayout={isCompactLayout} />;
return (
<DraftAgentControls
{...agentControls}
draftId={agentId}
serverId={serverId}
isCompactLayout={isCompactLayout}
showToolbar={showToolbar}
/>
);
}
return (
<AgentControls
@@ -327,6 +336,7 @@ function renderLeftContent(args: RenderLeftContentArgs): ReactElement | null {
serverId={serverId}
onDropdownClose={focusInput}
isCompactLayout={isCompactLayout}
showToolbar={showToolbar}
/>
);
}
@@ -1243,14 +1253,17 @@ export function Composer({ isPaneFocused, ...props }: ComposerProps) {
// user's own pane: closing the panel does not bring focus back.
const isCompact = useIsCompactFormFactor();
const paneHost = usePaneHost();
const overlayPanelRequested = usePanelStore((state) =>
isMobilePanelCoveringHost(state.mobilePanel.target, paneHost),
);
const coveredByOverlayPanel = isCompact && overlayPanelRequested;
const mobilePanelTarget = usePanelStore((state) => state.mobilePanel.target);
const coveredByOverlayPanel = isCompact && isMobilePanelCoveringHost(mobilePanelTarget, paneHost);
// Search from the sidebar uses the center pane as its context.
const commandCenterPanel = mobilePanelTarget === "agent-list" ? "agent" : mobilePanelTarget;
const coveredForCommandCenter =
isCompact && isMobilePanelCoveringHost(commandCenterPanel, paneHost);
return (
<ComposerKeyboardScopeProvider
isPaneFocused={isPaneFocused}
isActiveComposer={isPaneFocused && !coveredByOverlayPanel}
isCommandCenterTarget={isPaneFocused && !coveredForCommandCenter}
>
<OverlayDismissalScope>
<RenderProfile id="ComposerContent">
@@ -2346,6 +2359,7 @@ function ComposerContentImpl({
focusInput,
isCompactLayout,
showAgentControls: mode.showAgentControls,
showToolbar: !isFullscreen,
});
return controls ? (
<ComposerInputProvider value={composerInput}>{controls}</ComposerInputProvider>
@@ -2356,6 +2370,7 @@ function ComposerContentImpl({
composerInput,
focusInput,
isCompactLayout,
isFullscreen,
mode.showAgentControls,
serverId,
]);
+32 -26
View File
@@ -2224,42 +2224,47 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
);
const toolbar = useMemo(
() => (
<View style={buttonRowStyle}>
<View style={isFullscreen ? styles.hiddenToolbar : buttonRowStyle}>
{/* Toolbar left: attachment button + agent controls */}
<View style={styles.leftButtonGroup}>
<AttachmentDropdown
visible={mode.showAttachments}
isConnected={isConnected}
disabled={disabled}
attachButtonStyle={attachButtonStyle}
renderAttachButtonIcon={renderAttachButtonIcon}
attachmentMenuItems={attachmentMenuItems}
addAttachmentLabel={t("composer.input.addAttachment")}
/>
{!isFullscreen && (
<AttachmentDropdown
visible={mode.showAttachments}
isConnected={isConnected}
disabled={disabled}
attachButtonStyle={attachButtonStyle}
renderAttachButtonIcon={renderAttachButtonIcon}
attachmentMenuItems={attachmentMenuItems}
addAttachmentLabel={t("composer.input.addAttachment")}
/>
)}
{leftContent}
</View>
{/* Right: dictation, then the trailing action (voice mode, send or stop) */}
<View style={styles.rightButtonGroup}>
{beforeVoiceContent}
<VoiceButtonTooltip
visible={mode.showVoice}
onVoicePress={handleVoicePress}
isDictationStartEnabled={isDictationStartEnabled}
voiceButtonAccessibilityLabel={voiceButtonAccessibilityLabel}
voiceButtonStyle={voiceButtonStyle}
renderVoiceButtonIcon={renderVoiceButtonIcon}
voiceTooltipText={voiceTooltipText}
isRealtimeVoiceForCurrentAgent={isRealtimeVoiceForCurrentAgent}
voiceMuteToggleKeys={voiceMuteToggleKeys}
dictationToggleKeys={dictationToggleKeys}
/>
<View style={styles.trailingDisc}>{sendButton}</View>
</View>
{!isFullscreen && (
<View style={styles.rightButtonGroup}>
{beforeVoiceContent}
<VoiceButtonTooltip
visible={mode.showVoice}
onVoicePress={handleVoicePress}
isDictationStartEnabled={isDictationStartEnabled}
voiceButtonAccessibilityLabel={voiceButtonAccessibilityLabel}
voiceButtonStyle={voiceButtonStyle}
renderVoiceButtonIcon={renderVoiceButtonIcon}
voiceTooltipText={voiceTooltipText}
isRealtimeVoiceForCurrentAgent={isRealtimeVoiceForCurrentAgent}
voiceMuteToggleKeys={voiceMuteToggleKeys}
dictationToggleKeys={dictationToggleKeys}
/>
<View style={styles.trailingDisc}>{sendButton}</View>
</View>
)}
</View>
),
[
buttonRowStyle,
isFullscreen,
mode.showAttachments,
isConnected,
disabled,
@@ -2463,6 +2468,7 @@ const styles = StyleSheet.create((theme: Theme) => ({
minHeight: MIN_INPUT_HEIGHT,
color: theme.colors.foregroundMuted,
},
hiddenToolbar: { display: "none" },
// The row keeps a full touch target's height; its disc-sized controls centre in it.
buttonRow: {
minHeight: TOOLBAR_CONTROL_HEIGHT,
@@ -126,7 +126,8 @@ export function ComposerInputPresentation({
</Button>
) : null}
</View>
{fullscreen ? null : toolbar}
{/* Keep the agent controls mounted for composer commands in fullscreen. */}
{toolbar}
</View>
</ComposerFullscreenBody>
{fullscreen ? (
+6 -2
View File
@@ -18,21 +18,25 @@ interface ComposerKeyboardScopeValue {
* pane, which does not take pane focus.
*/
isActiveComposer: boolean;
/** The composer whose settings appear in Command Center. */
isCommandCenterTarget: boolean;
}
const ComposerKeyboardScopeContext = createContext<ComposerKeyboardScopeValue>({
isPaneFocused: false,
isActiveComposer: false,
isCommandCenterTarget: false,
});
export function ComposerKeyboardScopeProvider({
isPaneFocused,
isActiveComposer,
isCommandCenterTarget,
children,
}: PropsWithChildren<ComposerKeyboardScopeValue>): ReactElement {
const value = useMemo(
() => ({ isPaneFocused, isActiveComposer }),
[isPaneFocused, isActiveComposer],
() => ({ isPaneFocused, isActiveComposer, isCommandCenterTarget }),
[isPaneFocused, isActiveComposer, isCommandCenterTarget],
);
return (
<ComposerKeyboardScopeContext.Provider value={value}>