Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🗂️ feat: Choose Conversation Checkout Mode (#16679)
Danny Avila35a2bee409d8
diff --git a/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx b/client/src/components/Chat/Input/CodeWorkspaceMenu.tsxindex 35638c973d..ccc64256e4 100644--- a/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx+++ b/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx@@ -1,5 +1,6 @@-import { useId, useState } from 'react';+import { Fragment, useId, useState } from 'react';import * as Ariakit from '@ariakit/react';+import { isCodeWorkspaceCheckoutAvailable } from 'librechat-data-provider';import { TooltipAnchor, composerControlClasses, useToastContext } from '@librechat/client';import { Check, ChevronDown, Folder, FolderSync, FolderX, RefreshCw, Monitor } from 'lucide-react';import type { CodeWorkspaceSelection, TConversation } from 'librechat-data-provider';@@ -103,10 +104,11 @@ function describeTransition(/** A sole advertised workspace is the only valid pick, so it counts as chosen until changed. */function chosenWorkspaceId(target: CodeWorkspaceEnvironmentResult,- choices: Record<string, string>,+ choices: Record<string, CodeWorkspaceSelection>,): string | undefined {const choice = choices[target.environment.id];- if (choice != null && target.workspaces.some(({ id }) => id === choice)) return choice;+ if (choice != null && target.workspaces.some(({ id }) => id === choice.workspaceId))+ return choice.workspaceId;return target.workspaces.length === 1 ? target.workspaces[0].id : undefined;}@@ -118,6 +120,8 @@ function EnvironmentWorkspaces({hideOnClick,isSelected,onSelect,+ checkout,+ allowCheckoutSelection = false,}: {environment: CodeWorkspaceEnvironmentResult['environment'];requiredBy?: CodeWorkspaceEnvironmentResult['requiredBy'];@@ -126,6 +130,8 @@ function EnvironmentWorkspaces({hideOnClick: boolean;isSelected: (workspaceId: string) => boolean;onSelect: (selection: CodeWorkspaceSelection) => void;+ checkout?: CodeWorkspaceSelection['checkout'];+ allowCheckoutSelection?: boolean;}) {const localize = useLocalize();return (@@ -146,47 +152,106 @@ function EnvironmentWorkspaces({{workspaces.map((descriptor) => {const selected = isSelected(descriptor.id);return (- <Ariakit.MenuItemRadio- key={descriptor.id}- name={`codeWorkspace:${environment.id}`}- value={descriptor.id}- checked={selected}- hideOnClick={hideOnClick}- onChange={() => onSelect({ environmentId: environment.id, workspaceId: descriptor.id })}- className={menuItemClasses(selected)}- >- <Folder className="text-text-secondary mt-0.5 size-4 shrink-0" aria-hidden="true" />- <div className="min-w-0 flex-1 text-left">- <div className="text-text-primary truncate text-sm font-medium">- {descriptor.name ?? descriptor.id}+ <Fragment key={descriptor.id}>+ <Ariakit.MenuItemRadio+ key={descriptor.id}+ name={`codeWorkspace:${environment.id}`}+ value={descriptor.id}+ checked={selected}+ hideOnClick={hideOnClick}+ onChange={() =>+ onSelect({ environmentId: environment.id, workspaceId: descriptor.id })+ }+ className={menuItemClasses(selected)}+ >+ <Folder className="text-text-secondary mt-0.5 size-4 shrink-0" aria-hidden="true" />+ <div className="min-w-0 flex-1 text-left">+ <div className="text-text-primary truncate text-sm font-medium">+ {descriptor.name ?? descriptor.id}+ </div>+ {descriptor.name && (+ <p className="text-text-secondary truncate text-xs">{descriptor.id}</p>+ )}+ {descriptor.instructions !== undefined && (+ <p className="text-text-secondary truncate text-xs">+ {descriptor.instructions.length === 0+ ? localize('com_ui_repository_instructions_none')+ : descriptor.instructions+ .map(+ (file) =>+ `${file.path} · ${(file.bytes / 1024).toFixed(1)} KB${file.truncated ? ` · ${localize('com_ui_repository_instructions_truncated')}` : ''}`,+ )+ .join(', ')}+ </p>+ )}+ {(descriptor.environment?.repo || descriptor.environment?.ref) && (+ <p className="text-text-secondary truncate text-xs">+ {[descriptor.environment.repo, descriptor.environment.ref]+ .filter(Boolean)+ .join(' · ')}+ </p>+ )}</div>- {descriptor.name && (- <p className="text-text-secondary truncate text-xs">{descriptor.id}</p>- )}- {descriptor.instructions !== undefined && (- <p className="text-text-secondary truncate text-xs">- {descriptor.instructions.length === 0- ? localize('com_ui_repository_instructions_none')- : descriptor.instructions- .map(- (file) =>- `${file.path} · ${(file.bytes / 1024).toFixed(1)} KB${file.truncated ? ` · ${localize('com_ui_repository_instructions_truncated')}` : ''}`,- )- .join(', ')}- </p>+ {selected && (+ <Check className="text-text-primary mt-0.5 size-4 shrink-0" aria-hidden="true" />)}- {(descriptor.environment?.repo || descriptor.environment?.ref) && (- <p className="text-text-secondary truncate text-xs">- {[descriptor.environment.repo, descriptor.environment.ref]- .filter(Boolean)- .join(' · ')}- </p>+ </Ariakit.MenuItemRadio>+ {selected &&+ allowCheckoutSelection &&+ environment.configSchema?.workspaces?.allowCheckoutSelection === true && (+ <>+ <Ariakit.MenuHeading render={<div />} className={headingClasses}>+ {localize('com_ui_code_checkout_mode')}+ </Ariakit.MenuHeading>+ {(['isolated', 'source'] as const)+ .filter(+ (mode) =>+ mode === 'source' ||+ descriptor.workspaceInstances?.includes('git_worktree'),+ )+ .map((mode) => (+ <Ariakit.MenuItemRadio+ key={mode}+ name={`codeCheckout:${environment.id}`}+ value={mode}+ checked={checkout === mode}+ hideOnClick={hideOnClick}+ className={menuItemClasses(checkout === mode)}+ onChange={() =>+ onSelect({+ environmentId: environment.id,+ workspaceId: descriptor.id,+ checkout: mode,+ })+ }+ >+ <div className="min-w-0 flex-1 text-left">+ <div className="text-text-primary text-sm font-medium">+ {localize(+ mode === 'isolated'+ ? 'com_ui_code_checkout_isolated'+ : 'com_ui_code_checkout_source',+ )}+ </div>+ <p className="text-text-secondary text-xs">+ {localize(+ mode === 'isolated'+ ? 'com_ui_code_checkout_isolated_info'+ : 'com_ui_code_checkout_source_info',+ )}+ </p>+ </div>+ {checkout === mode && (+ <Check+ className="text-text-primary mt-0.5 size-4 shrink-0"+ aria-hidden="true"+ />+ )}+ </Ariakit.MenuItemRadio>+ ))}+ </>)}- </div>- {selected && (- <Check className="text-text-primary mt-0.5 size-4 shrink-0" aria-hidden="true" />- )}- </Ariakit.MenuItemRadio>+ </Fragment>);})}</div>@@ -240,7 +305,7 @@ export default function CodeWorkspaceMenu({const { refresh, isRefreshing } = useCodeWorkspaceRefresh();const [moveDraft, setMoveDraft] = useState<{conversationId: string;- workspaces: Record<string, string>;+ workspaces: Record<string, CodeWorkspaceSelection>;} | null>(null);if (!workspace.visible) return null;@@ -272,6 +337,12 @@ export default function CodeWorkspaceMenu({const { transition } = workspace;const environmentIds = new Set(workspace.environments.map(({ environment }) => environment.id));const selectWorkspace = (selection: CodeWorkspaceSelection) => {+ const previous = workspace.environments.find(+ ({ environment }) => environment.id === selection.environmentId,+ )?.selected;+ if (selection.checkout == null && previous?.checkout != null) {+ selection = { ...selection, checkout: previous.checkout };+ }workspace.rememberSelection(selection);const replacedIds = new Set(workspace.machineOptionGroups?.filter((ids) => ids.includes(selection.environmentId)).flat(),@@ -329,12 +400,24 @@ export default function CodeWorkspaceMenu({const chosenTargets =transition?.targets.flatMap((target) => {const workspaceId = chosenWorkspaceId(target, moveChoices);- return workspaceId == null+ const previous = transition.from?.filter(+ ({ environmentId, agentIds }) =>+ environmentId === target.environment.id ||+ agentIds?.some((id) => target.selectionOwners?.includes(id)),+ );+ const priorModes = new Set(+ (previous?.length ? previous : (transition.from ?? [])).map(({ checkout }) => checkout),+ );+ const inheritedCheckout = priorModes.size === 1 ? [...priorModes][0] : undefined;+ /** A mixed predecessor decision requires a deliberate mode, never an automatic fallback. */+ return workspaceId == null ||+ (priorModes.size > 1 && moveChoices[target.environment.id]?.checkout == null)? []: [{environmentId: target.environment.id,workspaceId,+ checkout: moveChoices[target.environment.id]?.checkout ?? inheritedCheckout,...(target.selectionOwners?.length ? { agentIds: target.selectionOwners } : {}),},];@@ -347,7 +430,19 @@ export default function CodeWorkspaceMenu({transition.kind !== 'detach' &&(transition.targets.length > 0 || transition.retained.length > 0);const moveReady =- transition != null && chosenTargets.length === transition.targets.length && proposed.length > 0;+ transition != null &&+ chosenTargets.length === transition.targets.length &&+ proposed.length > 0 &&+ chosenTargets.every((selection) => {+ const target = transition.targets.find(+ ({ environment }) => environment.id === selection.environmentId,+ );+ return isCodeWorkspaceCheckoutAvailable(+ selection,+ target?.workspaces.find(({ id }) => id === selection.workspaceId),+ target?.environment.configSchema?.workspaces?.allowCheckoutSelection === true,+ );+ });const applyTransition = (to: CodeWorkspaceSelection[]) => {if (transition == null || disabled || moveMutation.isLoading) return;moveMutation.mutate(@@ -389,6 +484,18 @@ export default function CodeWorkspaceMenu({if (onlyDescriptor && (workspace.machineOptions?.length ?? 0) > 1) {label = `${onlyEnvironment?.environment.name ?? onlyEnvironment?.environment.id} · ${label}`;}+ if (onlyEnvironment?.selected?.checkout != null) {+ label = `${label} · ${localize(onlyEnvironment.selected.checkout === 'isolated' ? 'com_ui_code_checkout_isolated' : 'com_ui_code_checkout_source')}`;+ }+ const checkoutSummaries = workspace.environments.flatMap(+ ({ environment, selected, workspaces }) => {+ if (selected?.checkout == null) return [];+ const descriptor = workspaces.find(({ id }) => id === selected.workspaceId);+ return [+ `${environment.name ?? environment.id} · ${descriptor?.name ?? selected.workspaceId} · ${localize(selected.checkout === 'isolated' ? 'com_ui_code_checkout_isolated' : 'com_ui_code_checkout_source')}`,+ ];+ },+ );const Icon =workspace.mode === 'without_attached' ||workspace.state === 'missing' ||@@ -459,6 +566,12 @@ export default function CodeWorkspaceMenu({<RefreshCw className="text-text-secondary size-3 shrink-0" aria-hidden="true" /></TooltipAnchor><WorkspaceRequirements id={requirementsId} requirements={requirements} />+ {workspace.environments.length > 1 && (+ <WorkspaceRequirements+ id={`${requirementsId}-checkouts`}+ requirements={checkoutSummaries}+ />+ )}</div>);}@@ -537,10 +650,25 @@ export default function CodeWorkspaceMenu({emptyLabel={localize('com_ui_code_workspace_unavailable')}hideOnClick={false}isSelected={(workspaceId) => chosenWorkspaceId(target, moveChoices) === workspaceId}- onSelect={({ environmentId, workspaceId }) =>+ allowCheckoutSelection={true}+ checkout={+ chosenTargets.find(({ environmentId }) => environmentId === target.environment.id)+ ?.checkout+ }+ onSelect={(selection) =>setMoveDraft({conversationId: transition.conversationId,- workspaces: { ...moveChoices, [environmentId]: workspaceId },+ workspaces: {+ ...moveChoices,+ [selection.environmentId]: {+ ...selection,+ checkout:+ selection.checkout ??+ chosenTargets.find(+ ({ environmentId }) => environmentId === selection.environmentId,+ )?.checkout,+ },+ },})}/>@@ -632,6 +760,8 @@ export default function CodeWorkspaceMenu({workspace.mode === 'attached' && workspaceId === selected?.workspaceId}onSelect={selectWorkspace}+ checkout={selected?.checkout}+ allowCheckoutSelection={!workspace.locked}/>),)}@@ -711,6 +841,12 @@ export default function CodeWorkspaceMenu({</span></Ariakit.MenuItem></Ariakit.Menu>+ {workspace.environments.length > 1 && (+ <WorkspaceRequirements+ id={`${requirementsId}-checkouts`}+ requirements={checkoutSummaries}+ />+ )}</Ariakit.MenuProvider>);}diff --git a/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx b/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsxindex b1b7026cbe..8df1f95fc2 100644--- a/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx+++ b/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx@@ -101,6 +101,159 @@ function renderMenu(ui: React.ReactElement) {}describe('CodeWorkspaceMenu', () => {+ test.each(['source', 'isolated'] as const)(+ 'keeps explicit %s when choosing another repository on the same machine',+ async (checkout) => {+ const graph = workspace();+ graph.environments[0].selected = {+ environmentId: environment.id,+ workspaceId: 'project-a',+ checkout,+ };+ graph.environments[0].workspaces.push({ id: 'project-b', name: 'Project B' });+ const setConversation = jest.fn();+ renderMenu(+ <CodeWorkspaceMenu setConversation={setConversation} workspace={graph} disabled={false} />,+ );+ await userEvent.click(screen.getByTestId('code-workspace'));+ await userEvent.click(screen.getByRole('menuitemradio', { name: /Project B/ }));+ expect(setConversation.mock.calls[0][0](conversation)).toMatchObject({+ codeWorkspaces: [{ environmentId: environment.id, workspaceId: 'project-b', checkout }],+ });+ },+ );++ test('reports checkout modes for every environment on a restored sealed chat', () => {+ const graph = workspace({ locked: true, transition: undefined });+ graph.environments = ['source', 'isolated'].map((checkout, index) => ({+ environment: { ...environment, id: `vm-${index}`, name: `Machine ${index}` },+ state: 'ready' as const,+ workspaces: [{ id: 'repo', name: `Repository ${index}` }],+ selected: {+ environmentId: `vm-${index}`,+ workspaceId: 'repo',+ checkout: checkout as 'source' | 'isolated',+ },+ }));+ renderMenu(+ <CodeWorkspaceMenu setConversation={jest.fn()} workspace={graph} disabled={false} />,+ );+ expect(+ screen.getByText('Machine 0 · Repository 0 · com_ui_code_checkout_source'),+ ).toBeInTheDocument();+ expect(+ screen.getByText('Machine 1 · Repository 1 · com_ui_code_checkout_isolated'),+ ).toBeInTheDocument();+ });++ test.each(['source', 'isolated'] as const)(+ 'materializes an explicit %s choice from a legacy automatic selection',+ async (checkout) => {+ const selected = { environmentId: environment.id, workspaceId: 'project-a' };+ const graph = workspace({+ environments: [+ {+ environment: {+ ...environment,+ configSchema: { workspaces: { allowCheckoutSelection: true } },+ },+ state: 'ready',+ workspaces: [{ id: 'project-a', workspaceInstances: ['git_worktree'] }],+ selected,+ },+ ],+ });+ const setConversation = jest.fn();+ renderMenu(+ <CodeWorkspaceMenu setConversation={setConversation} workspace={graph} disabled={false} />,+ );+ await userEvent.click(screen.getByTestId('code-workspace'));+ const isolated = screen.getByRole('menuitemradio', {+ name: /com_ui_code_checkout_isolated/,+ });+ const source = screen.getByRole('menuitemradio', { name: /com_ui_code_checkout_source/ });+ expect(isolated).toHaveAttribute('aria-checked', 'false');+ expect(source).toHaveAttribute('aria-checked', 'false');+ await userEvent.click(checkout === 'isolated' ? isolated : source);+ expect(setConversation.mock.calls[0][0](conversation)).toMatchObject({+ codeWorkspaces: [{ ...selected, checkout }],+ });+ },+ );++ test.each(['source', 'isolated'] as const)(+ 'saves an explicit %s checkout choice before sending',+ async (checkout) => {+ const selected = { environmentId: environment.id, workspaceId: 'project-a' };+ const graph = workspace({+ environments: [+ {+ environment: {+ ...environment,+ configSchema: { workspaces: { allowCheckoutSelection: true } },+ },+ state: 'ready',+ workspaces: [{ id: 'project-a', workspaceInstances: ['git_worktree'] }],+ selected: { ...selected, checkout: checkout === 'source' ? 'isolated' : 'source' },+ },+ ],+ });+ const setConversation = jest.fn();+ renderMenu(+ <CodeWorkspaceMenu setConversation={setConversation} workspace={graph} disabled={false} />,+ );+ await userEvent.click(screen.getByTestId('code-workspace'));+ await userEvent.click(+ screen.getByRole('menuitemradio', {+ name: new RegExp(+ checkout === 'source' ? 'com_ui_code_checkout_source' : 'com_ui_code_checkout_isolated',+ ),+ }),+ );+ expect(setConversation.mock.calls[0][0](conversation)).toMatchObject({+ codeEnvironmentMode: 'attached',+ codeWorkspaces: [{ ...selected, checkout }],+ });+ },+ );++ test.each([+ { enabled: false, capable: true },+ { enabled: true, capable: false },+ ])('gates each checkout choice by policy and capability: %j', async ({ enabled, capable }) => {+ const graph = workspace();+ graph.environments[0].environment = {+ ...environment,+ configSchema: { workspaces: { allowCheckoutSelection: enabled } },+ };+ graph.environments[0].workspaces = [+ {+ id: 'project-a',+ ...(capable ? { workspaceInstances: ['git_worktree'] as ['git_worktree'] } : {}),+ },+ ];+ const setConversation = jest.fn();+ renderMenu(+ <CodeWorkspaceMenu setConversation={setConversation} workspace={graph} disabled={false} />,+ );+ await userEvent.click(screen.getByTestId('code-workspace'));+ if (!enabled) {+ expect(screen.queryByText('com_ui_code_checkout_mode')).not.toBeInTheDocument();+ } else {+ expect(+ screen.queryByRole('menuitemradio', { name: /com_ui_code_checkout_isolated/ }),+ ).not.toBeInTheDocument();+ await userEvent.click(+ screen.getByRole('menuitemradio', { name: /com_ui_code_checkout_source/ }),+ );+ expect(setConversation.mock.calls[0][0](conversation)).toMatchObject({+ codeWorkspaces: [+ { environmentId: environment.id, workspaceId: 'project-a', checkout: 'source' },+ ],+ });+ }+ });+test('explains the missing reviewer workspace while the selected primary workspace is ready', async () => {const reviewerMachine = { ...environment, id: 'reviewer-vm', name: 'Danny Skynet Trusted VM' };const graph = workspace({ state: 'choose', canSubmit: false });@@ -809,6 +962,126 @@ describe('CodeWorkspaceMenu', () => {jest.restoreAllMocks();});+ test.each(['source', 'isolated'] as const)(+ 'chooses an explicit %s checkout during attachment',+ async (checkout) => {+ const selectedTarget = target(+ { ...environment, configSchema: { workspaces: { allowCheckoutSelection: true } } },+ [{ id: 'project-a', workspaceInstances: ['git_worktree'] }],+ );+ const graph = relocatable([selectedTarget]);+ graph.transition = { ...graph.transition!, kind: 'attach', from: [], previous: [] };+ const moveSpy = jest+ .spyOn(dataService, 'moveConversationCodeEnvironment')+ .mockResolvedValue({+ conversationId: 'existing',+ codeEnvironmentMode: 'attached',+ codeWorkspaces: [{ ...moved, checkout }],+ });+ renderMenu(+ <CodeWorkspaceMenu setConversation={jest.fn()} workspace={graph} disabled={false} />,+ );+ await userEvent.click(screen.getByTestId('code-workspace'));+ await userEvent.click(+ screen.getByRole('menuitemradio', {+ name: new RegExp(+ checkout === 'source'+ ? 'com_ui_code_checkout_source'+ : 'com_ui_code_checkout_isolated',+ ),+ }),+ );+ await userEvent.click(+ screen.getByRole('menuitem', { name: /com_ui_code_workspace_attach/ }),+ );+ await waitFor(() =>+ expect(moveSpy).toHaveBeenCalledWith({+ conversationId: 'existing',+ from: [],+ to: [{ ...moved, checkout }],+ }),+ );+ },+ );++ test.each(['unsupported isolation', 'mixed predecessors'] as const)(+ 'requires an explicit source choice for %s',+ async (scenario) => {+ const graph = relocatable([+ target(+ { ...environment, configSchema: { workspaces: { allowCheckoutSelection: true } } },+ [{ id: 'project-a' }],+ ),+ ]);+ graph.transition = {+ ...graph.transition!,+ from:+ scenario === 'unsupported isolation'+ ? [{ ...mac, checkout: 'isolated' }]+ : [+ { ...mac, checkout: 'isolated' },+ { environmentId: 'other-vm', workspaceId: 'repo', checkout: 'source' },+ ],+ };+ const moveSpy = jest+ .spyOn(dataService, 'moveConversationCodeEnvironment')+ .mockResolvedValue({+ conversationId: 'existing',+ codeEnvironmentMode: 'attached',+ codeWorkspaces: [{ ...moved, checkout: 'source' }],+ });+ renderMenu(+ <CodeWorkspaceMenu setConversation={jest.fn()} workspace={graph} disabled={false} />,+ );+ await userEvent.click(screen.getByTestId('code-workspace-move'));+ expect(await confirmItem()).toHaveAttribute('aria-disabled', 'true');+ expect(moveSpy).not.toHaveBeenCalled();+ await userEvent.click(+ screen.getByRole('menuitemradio', { name: /com_ui_code_checkout_source/ }),+ );+ await userEvent.click(await confirmItem());+ await waitFor(() =>+ expect(moveSpy).toHaveBeenCalledWith(+ expect.objectContaining({ to: [{ ...moved, checkout: 'source' }] }),+ ),+ );+ },+ );++ test('preserves registered checkout when recovering onto a replacement workspace', async () => {+ const graph = relocatable([+ target({ ...environment, configSchema: { workspaces: { allowCheckoutSelection: true } } }, [+ { id: 'project-a', workspaceInstances: ['git_worktree'] },+ ]),+ ]);+ const old = {+ environmentId: environment.id,+ workspaceId: 'deleted',+ checkout: 'source' as const,+ };+ graph.transition = { ...graph.transition!, from: [old] };+ const moveSpy = jest.spyOn(dataService, 'moveConversationCodeEnvironment').mockResolvedValue({+ conversationId: 'existing',+ codeEnvironmentMode: 'attached',+ codeWorkspaces: [{ ...moved, checkout: 'source' }],+ });+ renderMenu(+ <CodeWorkspaceMenu setConversation={jest.fn()} workspace={graph} disabled={false} />,+ );+ await userEvent.click(screen.getByTestId('code-workspace-move'));+ expect(+ screen.getByRole('menuitemradio', { name: /com_ui_code_checkout_source/ }),+ ).toHaveAttribute('aria-checked', 'true');+ await userEvent.click(await confirmItem());+ await waitFor(() =>+ expect(moveSpy).toHaveBeenCalledWith({+ conversationId: 'existing',+ from: [old],+ to: [{ ...moved, checkout: 'source' }],+ }),+ );+ });+test('recovers in the same chat only after confirmation, preserving healthy environments', async () => {const missing = { ...moved, workspaceId: 'deleted-project' };const kept = { environmentId: 'team-vm', workspaceId: 'shared' };diff --git a/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx b/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsxindex 0788826421..8dad7c3b52 100644--- a/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx+++ b/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx@@ -43,6 +43,69 @@ const conversation = (codeWorkspaces?: TConversation['codeWorkspaces']): TConver}) as TConversation;describe('useCodeWorkspace', () => {+ it.each([+ { enabled: false, capable: true },+ { enabled: true, capable: false },+ ])('blocks a restored isolation choice when support disappears: %j', ({ enabled, capable }) => {+ mockAgentsConfig().agentsConfig.statefulCodeSessions.environments[0].configSchema = {+ workspaces: { allowCheckoutSelection: enabled },+ };+ mockStatus.mockReturnValue([+ {+ data: {+ environmentId: 'personal-vm',+ status: 'ready',+ workspaces: [+ { id: 'project-a', ...(capable ? { workspaceInstances: ['git_worktree'] } : {}) },+ ],+ },+ },+ ]);+ const selected = [+ { environmentId: 'personal-vm', workspaceId: 'project-a', checkout: 'isolated' as const },+ ];+ const { result } = renderHook(() =>+ useCodeWorkspace({+ ...conversation(selected),+ conversationId: 'saved',+ codeEnvironmentMode: 'attached',+ }),+ );+ expect(result.current.canSubmit).toBe(false);+ expect(result.current.resolveSubmission(selected)).toBeUndefined();+ });++ it.each(['source', 'isolated'] as const)(+ 'retains %s checkout through submission and restored-session resolution',+ (checkout) => {+ mockAgentsConfig().agentsConfig.statefulCodeSessions.environments[0].configSchema = {+ workspaces: { allowCheckoutSelection: true },+ };+ mockStatus.mockReturnValue([+ {+ data: {+ environmentId: 'personal-vm',+ status: 'ready',+ workspaces: [{ id: 'project-a', workspaceInstances: ['git_worktree'] }],+ },+ },+ ]);+ const selection = [{ environmentId: 'personal-vm', workspaceId: 'project-a', checkout }];+ const { result, rerender } = renderHook(+ ({ saved }) =>+ useCodeWorkspace({+ ...conversation(selection),+ conversationId: saved ? 'saved' : 'new',+ codeEnvironmentMode: 'attached',+ }),+ { initialProps: { saved: false } },+ );+ expect(result.current.resolveSubmission(selection)?.codeWorkspaces).toEqual(selection);+ rerender({ saved: true });+ expect(result.current.resolveSubmission(selection)?.codeWorkspaces).toEqual(selection);+ },+ );+describe('per-chat machines', () => {function enableChoices() {const config = mockAgentsConfig().agentsConfig;diff --git a/client/src/hooks/Agents/useCodeWorkspace.ts b/client/src/hooks/Agents/useCodeWorkspace.tsindex d517254933..6bb848d4ab 100644--- a/client/src/hooks/Agents/useCodeWorkspace.ts+++ b/client/src/hooks/Agents/useCodeWorkspace.ts@@ -4,6 +4,7 @@ import {Tools,isEphemeralAgentId,isCodeWorkspaceSelections,+ isCodeWorkspaceCheckoutAvailable,resolveCodeEnvironmentSelection,} from 'librechat-data-provider';import {@@ -412,8 +413,15 @@ export default function useCodeWorkspace() {state = 'unavailable';} else if (status.data.workspaces == null) state = 'unsupported';- else if (selected != null) state = 'ready';- else if (stored != null) state = 'missing';+ else if (selected != null) {+ state = isCodeWorkspaceCheckoutAvailable(+ selected,+ workspaces.find(({ id }) => id === selected.workspaceId),+ environment.configSchema?.workspaces?.allowCheckoutSelection === true,+ )+ ? 'ready'+ : 'unsupported';+ } else if (stored != null) state = 'missing';else if (workspaces.length === 0) state = 'unavailable';return {environment,@@ -448,11 +456,20 @@ export default function useCodeWorkspace(result.state !== 'loading' &&result.state !== 'unavailable' &&result.state !== 'unsupported' &&- result.workspaces.some(({ id }) => id === requested.workspaceId)+ result.workspaces.some(+ (descriptor) =>+ descriptor.id === requested.workspaceId &&+ isCodeWorkspaceCheckoutAvailable(+ requested,+ descriptor,+ result.environment.configSchema?.workspaces?.allowCheckoutSelection === true,+ ),+ )) {resolved.push({environmentId: result.environment.id,workspaceId: requested.workspaceId,+ ...(requested.checkout == null ? {} : { checkout: requested.checkout }),...(requested.agentIds == null ? {} : { agentIds: requested.agentIds }),});continue;diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.jsonindex 187698f420..797ac500a2 100644--- a/client/src/locales/en/translation.json+++ b/client/src/locales/en/translation.json@@ -3315,5 +3315,10 @@"com_ui_schedule_consent_error": "Authorization could not be updated. Reload the current state and try again.","com_ui_schedule_consent_issuer": "Issuer: {{issuer}}","com_ui_schedule_consent_audience": "Audience: {{audience}}",- "com_ui_schedule_consent_scopes": "Scopes: {{scopes}}"+ "com_ui_schedule_consent_scopes": "Scopes: {{scopes}}",+ "com_ui_code_checkout_mode": "Checkout mode",+ "com_ui_code_checkout_isolated": "Isolated worktree",+ "com_ui_code_checkout_isolated_info": "Created on the first workspace operation from the worker's Git snapshot. Uncommitted changes are not copied.",+ "com_ui_code_checkout_source": "Registered checkout",+ "com_ui_code_checkout_source_info": "Use the machine's registered checkout directly. Other chats may share these files."}diff --git a/docs/workspace-checkouts.md b/docs/workspace-checkouts.mdnew file mode 100644index 0000000000..02cc251bb6--- /dev/null+++ b/docs/workspace-checkouts.md@@ -0,0 +1,54 @@+# Conversation checkout choices++A new coding chat can use the registered checkout directly or request its own+isolated worktree. The choice is part of the conversation's existing machine+and workspace decision, not a separate browser preference. Opening the picker+does not create a checkout; the worker provisions isolation on the first+workspace operation.++## Enable++First update every LibreChat API replica and client. Then opt in on the attached+environment (or the control plane whose schema personal environments inherit):++```yaml+configSchema:+ workspaces:+ allowCheckoutSelection: true+```++The isolated choice requires the selected worker workspace to advertise+`workspaceInstances: [git_worktree]`. A worker configured with+`--conversation-worktree-root` can advertise this capability; use a private+storage directory outside its registered roots. Follow the worker's admission,+capacity and setup runbook. Do not restart workers with active assignments.+Conversation-worktree provisioning and linked-worktree lanes are different+worker configurations and cannot be enabled together on the same worker.++In the composer workspace menu, select a repository, reopen the menu and choose+**Isolated worktree** or **Registered checkout**. The recorded mode stays visible+after reload. Once the chat's decision is sealed, the picker does not implicitly+change that execution target. Continue without a workspace or explicitly attach+again through the deployment's supported decision transitions.+Those transitions offer the same checkout choices. A registered checkout is+available even on a worker without isolation support. Mixed predecessor modes+require an explicit choice before confirmation; they never become automatic+shared-root execution silently.++- **Isolated worktree** uses the worker's admitted Git snapshot. It does not copy+ uncommitted source changes. An unavailable isolation capability fails closed;+ the next command never falls back to shared source files.+- **Registered checkout** uses the existing registered root. Other chats may+ share those files. Normal workspace authorization, approvals, sandboxing and+ scheduling still apply.++No flag and no recorded checkout mode preserves the existing behavior:+workers advertising conversation worktrees use them automatically, and other+workers operate in the registered root. No migration is needed for old chats.+Stored explicit modes require compatible readers; do not enable the flag during+a rolling upgrade or roll back to an older reader while such chats are active.++This control does not select a Git base ref, create a named linked-worktree lane,+archive source, or remove dependencies. The descriptor's `environment.ref` is+operator metadata, not proof of the source's current HEAD. Arbitrary base-ref+selection and archive/restore need additional worker-owned protocol operations.diff --git a/packages/api/src/agents/execution.spec.ts b/packages/api/src/agents/execution.spec.tsindex 7bb33d67ba..870defac2a 100644--- a/packages/api/src/agents/execution.spec.ts+++ b/packages/api/src/agents/execution.spec.ts@@ -770,6 +770,17 @@ describe('stateful code approval target binding', () => {{ environmentId: 'environment-a', workspaceId: 'project-a', agentIds: ['agent-a'] },]);});++ it.each(['source', 'isolated'] as const)(+ 'retains the %s checkout when stripping live capabilities',+ (checkout) => {+ const selected = context();+ selected.codeWorkspace!.checkout = checkout;+ expect(getCodeWorkspaceSelections([selected])).toEqual([+ { environmentId: 'environment-a', workspaceId: 'project-a', checkout },+ ]);+ },+ );});describe('codeExecutionAuthHeaders', () => {diff --git a/packages/api/src/agents/execution.ts b/packages/api/src/agents/execution.tsindex f3441b3a04..4a29323c77 100644--- a/packages/api/src/agents/execution.ts+++ b/packages/api/src/agents/execution.ts@@ -92,6 +92,7 @@ export function getCodeWorkspaceSelections(selections.set(workspace.environmentId, {environmentId: workspace.environmentId,workspaceId: workspace.workspaceId,+ ...(workspace.checkout == null ? {} : { checkout: workspace.checkout }),...(workspace.agentIds == null ? {} : { agentIds: [...workspace.agentIds] }),});}diff --git a/packages/api/src/code/capabilities.spec.ts b/packages/api/src/code/capabilities.spec.tsindex 3155ca6d67..93a1b22a7c 100644--- a/packages/api/src/code/capabilities.spec.ts+++ b/packages/api/src/code/capabilities.spec.ts@@ -452,6 +452,75 @@ describe('resolveCodeExecutionWorkspaceContext', () => {expect(resolved.codeWorkspace?.environment).toEqual(environment);});+ it.each(['source', 'isolated'] as const)(+ 'honors an explicit %s checkout choice',+ async (checkout) => {+ jest+ .spyOn(globalThis, 'fetch')+ .mockResolvedValue(+ workspaceStatus([{ id: 'worktree', workspaceInstances: ['git_worktree'] }]),+ );+ const resolved = await resolveCodeExecutionWorkspaceContext({+ context: {+ ...context,+ conversationWorkspaceInstanceId: 'c'.repeat(64),+ codeEnvironmentConfigSchema: { workspaces: { allowCheckoutSelection: true } },+ },+ requestedSelections: [{ environmentId: 'personal', workspaceId: 'worktree', checkout }],+ environments,+ getAppConfig,+ });+ expect(resolved.codeWorkspace?.checkout).toBe(checkout);+ expect(resolved.codeWorkspace?.workspaceInstanceId).toBe(+ checkout === 'isolated' ? 'c'.repeat(64) : undefined,+ );+ },+ );++ it.each([+ { enabled: false, capable: true, instance: 'c'.repeat(64) },+ { enabled: true, capable: false, instance: 'c'.repeat(64) },+ { enabled: true, capable: true, instance: undefined },+ ])(+ 'refuses unsupported isolation instead of executing in the source: %j',+ async ({ enabled, capable, instance }) => {+ jest+ .spyOn(globalThis, 'fetch')+ .mockResolvedValue(+ workspaceStatus([+ { id: 'worktree', ...(capable ? { workspaceInstances: ['git_worktree'] } : {}) },+ ]),+ );+ await expect(+ resolveCodeExecutionWorkspaceContext({+ context: {+ ...context,+ conversationWorkspaceInstanceId: instance,+ codeEnvironmentConfigSchema: { workspaces: { allowCheckoutSelection: enabled } },+ },+ requestedSelections: [+ { environmentId: 'personal', workspaceId: 'worktree', checkout: 'isolated' },+ ],+ environments,+ getAppConfig,+ }),+ ).rejects.toMatchObject({ reason: 'unsupported' });+ },+ );++ it('refuses a checkout choice that changes the sealed decision', async () => {+ const selection = { environmentId: 'personal', workspaceId: 'worktree' };+ await expect(+ resolveCodeExecutionWorkspaceContext({+ context,+ persistedSelections: [{ ...selection, checkout: 'isolated' }],+ requestedSelections: [{ ...selection, checkout: 'source' }],+ environments,+ getAppConfig,+ }),+ ).rejects.toMatchObject({ reason: 'locked' });+ });+it('activates a server-derived instance only when the worker advertises worktree support', async () => {const workspaceInstanceId = 'c'.repeat(64);jest@@ -496,7 +565,9 @@ describe('resolveCodeExecutionWorkspaceContext', () => {resolveCodeExecutionWorkspaceContext({context: {...context,- codeEnvironmentConfigSchema: { workspaces: { linkedWorktrees } },+ codeEnvironmentConfigSchema: {+ workspaces: { linkedWorktrees, allowCheckoutSelection: false },+ },...(instanceId ? { conversationWorkspaceInstanceId: instanceId } : {}),},requestedSelections: [{ environmentId: 'personal', workspaceId }],diff --git a/packages/api/src/code/capabilities.ts b/packages/api/src/code/capabilities.tsindex 2214ce4771..d76e1b089e 100644--- a/packages/api/src/code/capabilities.ts+++ b/packages/api/src/code/capabilities.ts@@ -2,6 +2,7 @@ import { logger } from '@librechat/data-schemas';import {isCodeWorkspaceSelections,canonicalizeCodeWorkspaceSelections,+ isCodeWorkspaceCheckoutAvailable,} from 'librechat-data-provider';import type { CodeWorkspaceSelection } from 'librechat-data-provider';import type { CodeEnvironmentConfig, CodeExecutionContext } from '~/agents/execution';@@ -141,21 +142,28 @@ export async function resolveCodeExecutionWorkspaceContext({if (!workspace) {throw new CodeWorkspaceSelectionError('missing');}+ const supportsIsolation = workspace.workspaceInstances?.includes('git_worktree') === true;+ if (+ !isCodeWorkspaceCheckoutAvailable(+ selection,+ workspace,+ context.codeEnvironmentConfigSchema?.workspaces?.allowCheckoutSelection === true,+ ) ||+ (selection.checkout === 'isolated' && !context.conversationWorkspaceInstanceId)+ ) {+ throw new CodeWorkspaceSelectionError('unsupported');+ }+ const usesIsolation =+ selection.checkout !== 'source' && supportsIsolation && context.conversationWorkspaceInstanceId;return {...context,codeWorkspace: {...selection,operations: [...(workspace.operations ?? status.operations)],- ...(context.conversationWorkspaceInstanceId &&- workspace.workspaceInstances?.includes('git_worktree')- ? { workspaceInstanceId: context.conversationWorkspaceInstanceId }- : {}),+ ...(usesIsolation ? { workspaceInstanceId: context.conversationWorkspaceInstanceId } : {}),...(context.codeEnvironmentConfigSchema?.workspaces?.linkedWorktrees === true &&workspace.workspaceScopes?.includes('git_linked_worktree') &&- !(- context.conversationWorkspaceInstanceId &&- workspace.workspaceInstances?.includes('git_worktree')- )+ !usesIsolation? { linkedWorktrees: true }: {}),...(status.maxCommandTimeoutMs == nulldiff --git a/packages/api/src/code/http.spec.ts b/packages/api/src/code/http.spec.tsindex 71bb7b131b..dde05c7c72 100644--- a/packages/api/src/code/http.spec.ts+++ b/packages/api/src/code/http.spec.ts@@ -1546,6 +1546,7 @@ describe('moving a sealed conversation code-environment decision', () => {function setup({movesEnabled = true,+ checkoutEnabled = false,allowAttachDetach = true,stored = {conversationId: 'conversation-1',@@ -1557,6 +1558,7 @@ describe('moving a sealed conversation code-environment decision', () => {fetchImpl = jest.fn().mockImplementation(async () => workerStatusResponse()),}: {movesEnabled?: boolean;+ checkoutEnabled?: boolean;allowAttachDetach?: boolean;stored?: StoredDecision;job?: CodeEnvironmentGenerationJob;@@ -1607,7 +1609,12 @@ describe('moving a sealed conversation code-environment decision', () => {endpoints: {[EModelEndpoint.agents]: {statefulCodeSessions: {- environments: [controlPlane],+ environments: [+ {+ ...controlPlane,+ configSchema: { workspaces: { allowCheckoutSelection: checkoutEnabled } },+ },+ ],conversationMoves: { enabled: movesEnabled, allowAttachDetach },},},@@ -1673,6 +1680,39 @@ describe('moving a sealed conversation code-environment decision', () => {};}+ test.each([+ { checkout: 'source', enabled: false, capable: true, accepted: false },+ { checkout: 'isolated', enabled: true, capable: false, accepted: false },+ { checkout: 'isolated', enabled: false, capable: true, accepted: false },+ { checkout: 'source', enabled: true, capable: false, accepted: true },+ { checkout: 'isolated', enabled: true, capable: true, accepted: true },+ ] as const)(+ 'validates checkout before persisting a move: %j',+ async ({ checkout, enabled, capable, accepted }) => {+ const { move, replaceDecision } = setup({+ checkoutEnabled: enabled,+ fetchImpl: jest.fn(async () =>+ workerStatusResponse({+ workspaces: [+ { id: vm.workspaceId, ...(capable ? { workspaceInstances: ['git_worktree'] } : {}) },+ ],+ }),+ ),+ });+ const to = [{ ...vm, checkout }];+ const res = await move({ from: [mac], to });+ expect(res.statusCode).toBe(accepted ? 200 : 409);+ if (accepted) {+ expect(replaceDecision).toHaveBeenCalledWith(+ expect.objectContaining({ codeWorkspaces: to }),+ );+ } else {+ expect(res.body).toEqual(expect.objectContaining({ reason: 'unsupported' }));+ expect(replaceDecision).not.toHaveBeenCalled();+ }+ },+ );+test('moves a sealed decision onto a workspace the new machine registers', async () => {const { move, conversations, fetchImpl } = setup();diff --git a/packages/api/src/code/http.ts b/packages/api/src/code/http.tsindex bd9e78e4d3..e7a425db5e 100644--- a/packages/api/src/code/http.ts+++ b/packages/api/src/code/http.ts@@ -1,6 +1,6 @@import { nanoid } from 'nanoid';-import { EModelEndpoint } from 'librechat-data-provider';import { logger, type AppConfig } from '@librechat/data-schemas';+import { EModelEndpoint, isCodeWorkspaceCheckoutAvailable } from 'librechat-data-provider';import type { CodeEnvironmentMode, CodeWorkspaceSelection } from 'librechat-data-provider';import type { Response } from 'express';import type {@@ -363,9 +363,23 @@ export function createCodeEnvironmentHttpHandlers(deps: CodeEnvironmentHttpDeps)if (!current.workspaces || !current.operations) {throw new CodeWorkspaceSelectionError('unsupported');}- if (!current.workspaces.some(({ id }) => id === selection.workspaceId)) {+ const workspace = current.workspaces.find(({ id }) => id === selection.workspaceId);+ if (workspace == null) {throw new CodeWorkspaceSelectionError('missing');}+ const configuration = policy.configurations.find(({ id }) => id === selection.environmentId);+ const effectiveEnvironment = configuration+ ? configuredAttachedControlPlane(policy.effectiveConfig, configuration.controlPlaneId ?? '')+ : configuredControlPlane(policy.effectiveConfig, selection.environmentId);+ if (+ !isCodeWorkspaceCheckoutAvailable(+ selection,+ workspace,+ effectiveEnvironment?.configSchema?.workspaces?.allowCheckoutSelection === true,+ )+ ) {+ throw new CodeWorkspaceSelectionError('unsupported');+ }if (previousWorkspaceId != null &&previousWorkspaceId !== selection.workspaceId &&diff --git a/packages/data-provider/src/code/selection.spec.ts b/packages/data-provider/src/code/selection.spec.tsindex 5b33e8ff35..9051b40616 100644--- a/packages/data-provider/src/code/selection.spec.ts+++ b/packages/data-provider/src/code/selection.spec.ts@@ -1,7 +1,44 @@-import { resolveCodeEnvironmentSelection } from './workspace';+import {+ resolveCodeEnvironmentSelection,+ isCodeWorkspaceSelection,+ canonicalizeCodeWorkspaceSelections,+} from './workspace';+import { EModelEndpoint, tConvoUpdateSchema } from '../schemas';import { appendAgentIdSuffix } from '../agents/identity';+import createPayload from '../createPayload';describe('chat machine selection', () => {+ it.each(['source', 'isolated'] as const)(+ 'validates and retains the %s checkout in the sealed identity',+ (checkout) => {+ const selection = { environmentId: 'vm', workspaceId: 'repo', checkout };+ expect(isCodeWorkspaceSelection(selection)).toBe(true);+ expect(canonicalizeCodeWorkspaceSelections([selection])).toEqual([selection]);+ const conversation = {+ conversationId: null,+ endpoint: EModelEndpoint.agents,+ endpointType: null,+ codeWorkspaces: [selection],+ };+ expect(tConvoUpdateSchema.parse(conversation).codeWorkspaces).toEqual([selection]);+ expect(+ createPayload({+ conversation,+ endpointOption: { endpoint: EModelEndpoint.agents },+ userMessage: { text: 'hello' },+ codeEnvironmentMode: 'attached',+ codeWorkspaces: [selection],+ } as Parameters<typeof createPayload>[0]).payload.codeWorkspaces,+ ).toEqual([selection]);+ },+ );++ it.each([null, 'automatic', 'invalid', {}, 1])('rejects an invalid checkout: %j', (checkout) => {+ expect(isCodeWorkspaceSelection({ environmentId: 'vm', workspaceId: 'repo', checkout })).toBe(+ false,+ );+ });+const defaultId = 'application-vm';const selections = [{ environmentId: 'runtime-vm', workspaceId: 'primary' }];diff --git a/packages/data-provider/src/code/workspace.ts b/packages/data-provider/src/code/workspace.tsindex b3dbc43170..1b6afad5aa 100644--- a/packages/data-provider/src/code/workspace.ts+++ b/packages/data-provider/src/code/workspace.ts@@ -30,6 +30,7 @@ export const CODE_WORKSPACE_OPERATIONS = ['execute_command',] as const;export const CODE_WORKSPACE_INSTANCE_TYPES = ['git_worktree'] as const;+export const CODE_WORKSPACE_CHECKOUT_MODES = ['source', 'isolated'] as const;/** Scheduling scopes a worker can admit beneath one registered root. */export const CODE_WORKSPACE_SCOPES = ['git_linked_worktree'] as const;export const CODE_WORKSPACE_SELECTION_ERROR_REASONS = [@@ -127,10 +128,27 @@ export function isCodeWorkspaceEnvironment(export interface CodeWorkspaceSelection {environmentId: string;workspaceId: string;+ /** Omitted preserves the worker's legacy automatic isolation policy. */+ checkout?: (typeof CODE_WORKSPACE_CHECKOUT_MODES)[number];/** Explicit graph-agent ownership of a chat machine choice; absent on legacy selections. */agentIds?: string[];}+/** Explicit isolation never falls back to shared files when a capability or policy disappears. */+export function isCodeWorkspaceCheckoutAvailable(+ selection: Pick<CodeWorkspaceSelection, 'checkout'>,+ workspace: Pick<CodeWorkspaceDescriptor, 'workspaceInstances'> | undefined,+ allowSelection: boolean,+): boolean {+ return (+ selection.checkout == null ||+ (allowSelection &&+ workspace != null &&+ (selection.checkout === 'source' ||+ workspace.workspaceInstances?.includes('git_worktree') === true))+ );+}+export function isCodeEnvironmentMode(value: unknown): value is CodeEnvironmentMode {return CODE_ENVIRONMENT_MODES.some((mode) => mode === value);}@@ -148,12 +166,15 @@ export function isCodeWorkspaceSelection(value: unknown): value is CodeWorkspaceconst selection = value as Record<string, unknown>;return (Object.keys(selection).every((key) =>- ['environmentId', 'workspaceId', 'agentIds'].includes(key),+ ['environmentId', 'workspaceId', 'agentIds', 'checkout'].includes(key),) &&typeof selection.environmentId === 'string' &&CODE_WORKSPACE_ID_PATTERN.test(selection.environmentId) &&typeof selection.workspaceId === 'string' &&CODE_WORKSPACE_ID_PATTERN.test(selection.workspaceId) &&+ (selection.checkout === undefined ||+ selection.checkout === 'source' ||+ selection.checkout === 'isolated') &&(selection.agentIds === undefined ||(Array.isArray(selection.agentIds) &&selection.agentIds.length > 0 &&@@ -189,9 +210,10 @@ export function canonicalizeCodeWorkspaceSelections(selections: CodeWorkspaceSelection[],): CodeWorkspaceSelection[] {return selections- .map(({ environmentId, workspaceId, agentIds }) => ({+ .map(({ environmentId, workspaceId, agentIds, checkout }) => ({environmentId,workspaceId,+ ...(checkout == null ? {} : { checkout }),...(agentIds == null ? {} : { agentIds: [...agentIds].sort() }),})).sort((left, right) => left.environmentId.localeCompare(right.environmentId));diff --git a/packages/data-provider/src/config.spec.ts b/packages/data-provider/src/config.spec.tsindex 672e5a4549..14fae0dc87 100644--- a/packages/data-provider/src/config.spec.ts+++ b/packages/data-provider/src/config.spec.ts@@ -963,8 +963,18 @@ describe('attached code environment user config schema', () => {});});+ it('keeps checkout selection disabled by default without creating workspace policy', () => {+ expect(codeEnvironmentUserConfigSchema.parse({})).not.toHaveProperty('workspaces');+ expect(codeEnvironmentUserConfigSchema.parse({ workspaces: {} }).workspaces).toEqual({+ allowCheckoutSelection: false,+ });+ });+it.each([[{ linkedWorktrees: true }, true],+ [{ allowCheckoutSelection: true }, true],+ [{ allowCheckoutSelection: false }, true],+ [{ allowCheckoutSelection: 'yes' }, false],[{ linkedWorktrees: 'yes' }, false],[{ linkedWorktrees: true, subdirectories: true }, false],])('validates the linked worktree lane toggle %p', (workspaces, valid) => {diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.tsindex 23e1977960..f64b03666c 100644--- a/packages/data-provider/src/config.ts+++ b/packages/data-provider/src/config.ts@@ -1350,6 +1350,9 @@ export const codeEnvironmentUserConfigSchema = z* worker advertises linked-worktree lanes. Omission keeps every request scoped to* its checkout. */linkedWorktrees: z.boolean().optional(),+ /** Permit explicit per-conversation checkout choices after every API replica supports+ * them. Omission preserves automatic worker isolation and hides the selector. */+ allowCheckoutSelection: z.boolean().optional().default(false),}).strict().optional(),diff --git a/packages/data-provider/src/schemas.ts b/packages/data-provider/src/schemas.tsindex c3960e60f0..2f062b4d33 100644--- a/packages/data-provider/src/schemas.ts+++ b/packages/data-provider/src/schemas.ts@@ -7,6 +7,7 @@ import type { TFile } from './types/files';import {CODE_ENVIRONMENT_MODES,CODE_WORKSPACE_ID_PATTERN,+ CODE_WORKSPACE_CHECKOUT_MODES,MAX_AGENT_CODE_ENVIRONMENT_CHOICES,} from './code/workspace';import { userSubmittedMessageFieldPathSchema } from './filters';@@ -1202,6 +1203,7 @@ export const tConversationSchema = z.object({.object({environmentId: z.string().regex(CODE_WORKSPACE_ID_PATTERN),workspaceId: z.string().regex(CODE_WORKSPACE_ID_PATTERN),+ checkout: z.enum(CODE_WORKSPACE_CHECKOUT_MODES).optional(),agentIds: z.array(z.string().regex(CODE_WORKSPACE_ID_PATTERN)).min(1)diff --git a/packages/data-schemas/src/methods/conversation.spec.ts b/packages/data-schemas/src/methods/conversation.spec.tsindex becc2ed8b3..5795a4231c 100644--- a/packages/data-schemas/src/methods/conversation.spec.ts+++ b/packages/data-schemas/src/methods/conversation.spec.ts@@ -1338,6 +1338,24 @@ describe('Conversation Operations', () => {const userId = 'user123';const unsetFields = { codeEnvironmentMode: 1, codeWorkspaces: 1 };+ it.each(['source', 'isolated'] as const)(+ 'preserves the %s checkout through save, reload and a stale save',+ async (checkout) => {+ const conversationId = uuidv4();+ const codeWorkspaces = [{ ...mac, checkout }];+ await saveConvo(+ { userId },+ { conversationId, codeEnvironmentMode: 'attached', codeWorkspaces },+ );+ expect((await getConvo(userId, conversationId))?.codeWorkspaces).toEqual(codeWorkspaces);+ await saveConvo({ userId }, { conversationId, codeWorkspaces: [mac], title: 'Later save' });+ expect(+ (await methods.readAdmittedConvoCodeEnvironmentDecision(userId, conversationId))+ ?.codeWorkspaces,+ ).toEqual(codeWorkspaces);+ },+ );+it('preserves explicit agent ownership through save, reload and a stale ordinary save', async () => {const conversationId = uuidv4();const codeWorkspaces = [{ ...mac, agentIds: ['primary', 'reviewer'] }];diff --git a/packages/data-schemas/src/schema/defaults.spec.ts b/packages/data-schemas/src/schema/defaults.spec.tsnew file mode 100644index 0000000000..243ea80215--- /dev/null+++ b/packages/data-schemas/src/schema/defaults.spec.ts@@ -0,0 +1,31 @@+import { Schema, model, deleteModel } from 'mongoose';+import { conversationPreset } from './defaults';++describe('conversation checkout persistence', () => {+ const Checkout = model(+ 'CheckoutPersistenceTest',+ new Schema({ codeWorkspaces: conversationPreset.codeWorkspaces }),+ );++ afterAll(() => deleteModel('CheckoutPersistenceTest'));++ it.each(['source', 'isolated'] as const)(+ 'round trips the %s checkout through the real schema',+ (checkout) => {+ const selection = { environmentId: 'machine', workspaceId: 'repo', checkout };+ const saved = new Checkout({ codeWorkspaces: [selection] });+ expect(saved.validateSync()).toBeUndefined();+ expect(saved.toObject().codeWorkspaces).toEqual([selection]);+ },+ );++ it('keeps legacy decisions field-less and rejects unknown modes', () => {+ const selection = { environmentId: 'machine', workspaceId: 'repo' };+ expect(new Checkout({ codeWorkspaces: [selection] }).toObject().codeWorkspaces).toEqual([+ selection,+ ]);+ expect(+ new Checkout({ codeWorkspaces: [{ ...selection, checkout: 'wrong' }] }).validateSync(),+ ).toBeDefined();+ });+});diff --git a/packages/data-schemas/src/schema/defaults.ts b/packages/data-schemas/src/schema/defaults.tsindex 5529ecabb0..d87d530464 100644--- a/packages/data-schemas/src/schema/defaults.ts+++ b/packages/data-schemas/src/schema/defaults.ts@@ -1,5 +1,9 @@import { Schema } from 'mongoose';-import { CODE_APPROVAL_MODES, CODE_ENVIRONMENT_MODES } from 'librechat-data-provider';+import {+ CODE_APPROVAL_MODES,+ CODE_ENVIRONMENT_MODES,+ CODE_WORKSPACE_CHECKOUT_MODES,+} from 'librechat-data-provider';// @ts-ignoreexport const conversationPreset: {@@ -129,6 +133,7 @@ export const conversationPreset: {type: {environmentId: { type: StringConstructor; required: boolean };workspaceId: { type: StringConstructor; required: boolean };+ checkout: { type: StringConstructor; enum: string[]; default: undefined };agentIds: { type: StringConstructor[]; default: undefined };_id: boolean;}[];@@ -330,6 +335,7 @@ export const conversationPreset: {{environmentId: { type: String, required: true },workspaceId: { type: String, required: true },+ checkout: { type: String, enum: [...CODE_WORKSPACE_CHECKOUT_MODES], default: undefined },agentIds: { type: [String], default: undefined },_id: false,},