Skip to content

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

🔱 feat: Simplify Steering Controls to Three Modes (#16759)

lia-by-librechat[bot]d55dbc3bd8bc
diff --git a/client/src/Providers/ChatSettingsContext.tsx b/client/src/Providers/ChatSettingsContext.tsx
index bc3e781e7b..aceb093287 100644
--- a/client/src/Providers/ChatSettingsContext.tsx
+++ b/client/src/Providers/ChatSettingsContext.tsx
@@ -5,7 +5,6 @@ import type { ChatSettings } from '~/hooks/Chat/contract';
export const defaultChatSettings: ChatSettings = {
duringRunDefaultAction: 'steer',
setDuringRunDefaultAction: () => undefined,
- steerInterruptsByDefault: false,
resetVisibleArtifacts: () => undefined,
saveDrafts: true,
isTemporary: false,
diff --git a/client/src/components/Chat/Input/ChatForm.tsx b/client/src/components/Chat/Input/ChatForm.tsx
index f522314eeb..3b1ccc7996 100644
--- a/client/src/components/Chat/Input/ChatForm.tsx
+++ b/client/src/components/Chat/Input/ChatForm.tsx
@@ -448,18 +448,16 @@ const ChatForm = memo(function ChatForm({
return () => publishRewake(null);
}, [publishRewake, steeringRewakeDrain]);
- /** ⌘/Ctrl+Enter = the non-default during-run action, ⌥/Alt+Enter =
- * interrupt & send (discards the answer), ⌘/Ctrl+Shift+Enter = interrupt &
- * steer (keeps it): all counterparts of Enter's `submitDuringRun`. */
+ /** Ctrl/Cmd+Enter selects the alternate; both interrupt chords use the same mode. */
const handleDuringRunModifier = useCallback(
(kind: 'other' | 'interrupt' | 'preempt') => {
const text = methods.getValues('text');
let consumed = false;
if (kind === 'interrupt') {
- consumed = steering.interruptAndSend(text);
+ consumed = steering.interruptSteer(text);
} else if (kind === 'preempt') {
consumed = steering.interruptSteer(text);
- } else if (steering.effectiveAction === 'steer') {
+ } else if (steering.effectiveAction !== 'queue') {
consumed = steering.queueFromComposer(text);
} else {
consumed = steering.steerFromComposer(text);
@@ -1052,7 +1050,6 @@ const ChatForm = memo(function ChatForm({
isSubmitting={isSubmitting}
duringRunActive={steering.duringRunActive}
canControlGeneration={steering.canControlGeneration}
- steerInterruptsByDefault={steering.steerInterruptsByDefault}
duringRunAction={steering.effectiveAction}
/* A staged reasoning choice forces the message to queue, and the
send-now chord then queues too; do not advertise it. */
diff --git a/client/src/components/Chat/Input/DuringRunSendButton.tsx b/client/src/components/Chat/Input/DuringRunSendButton.tsx
index a3865f7983..69bc175e05 100644
--- a/client/src/components/Chat/Input/DuringRunSendButton.tsx
+++ b/client/src/components/Chat/Input/DuringRunSendButton.tsx
@@ -1,6 +1,6 @@
import React, { forwardRef, useMemo, useRef } from 'react';
import { useWatch } from 'react-hook-form';
-import { Zap, Clock, OctagonPause, ZapOff } from 'lucide-react';
+import { Zap, Clock, ZapOff } from 'lucide-react';
import { composerSubmitClasses, SendActions, SendIcon } from '@librechat/client';
import type { SendAction } from '@librechat/client';
import type { Control } from 'react-hook-form';
@@ -14,6 +14,12 @@ import { useLocalize } from '~/hooks';
* surface that can submit more than one way — see `SendActions`. */
type ActionRow = SendAction;
+const ACTION_LABELS = {
+ steer: 'com_ui_steer_send',
+ interrupt: 'com_ui_interrupt_steer',
+ queue: 'com_ui_queue_send',
+} as const;
+
type DuringRunSendButtonProps = {
control: Control<{ text: string }>;
steering: SteeringControls;
@@ -26,17 +32,7 @@ type DuringRunSendButtonProps = {
enterToSend: boolean;
};
-/**
- * The send button while a run is generating: it takes over the send/stop slot
- * (and `submitButtonRef`, so Enter's synthetic click routes here) whenever the
- * composer holds text: submitting steers or queues per the effective action.
- * Hovering it reveals the full action list with its shortcuts: steer, queue
- * (⌘/Ctrl+Enter routes to the non-default action), interrupt & steer
- * (⌘/Ctrl+Shift+Enter — requests an earlier safe point when a conversation
- * exists, otherwise stops and sends a new turn), and
- * interrupt & send (⌥/Alt+Enter — discards the answer and starts over).
- * Clearing the composer restores the Stop button.
- */
+/** The active mode owns submission; the menu overrides it for one message. */
const DuringRunSendButton = React.memo(
forwardRef((props: DuringRunSendButtonProps, ref: React.ForwardedRef<HTMLButtonElement>) => {
const localize = useLocalize();
@@ -44,7 +40,6 @@ const DuringRunSendButton = React.memo(
const { steering, enterToSend } = props;
const disabledRef = useRef(props.disabled);
disabledRef.current = props.disabled;
- const { steerInterruptsByDefault } = steering;
const data = useWatch({ control: props.control });
const content = data?.text?.trim();
const primary = steering.effectiveAction;
@@ -85,14 +80,6 @@ const DuringRunSendButton = React.memo(
};
}, [enterToSend, shortcutsEnabled, submitOverride, yieldedChords]);
- /**
- * With the preference on, plain Enter routes through `submitDuringRun`,
- * which preempts. The hint has to follow it: leaving ⏎ on the ordinary
- * Steer row would advertise a key that does something else, and that row
- * deliberately stays non-preempting when CLICKED. No key reaches it in
- * this mode, so it shows none.
- */
- const enterInterrupts = primary === 'steer' && steerInterruptsByDefault;
/** The chord that submits the default action, if any still does. */
let submitHint: string | undefined;
if (verdicts.plainEnter === 'submit') {
@@ -102,7 +89,7 @@ const DuringRunSendButton = React.memo(
}
const alternateHint = verdicts.modEnter === 'other' ? modEnter : undefined;
let interruptSteerKbd: string | undefined;
- if (enterInterrupts && submitHint != null) {
+ if (primary === 'interrupt' && submitHint != null) {
interruptSteerKbd = submitHint;
} else if (verdicts.modShiftEnter === 'preempt') {
interruptSteerKbd = modShiftEnter;
@@ -121,9 +108,9 @@ const DuringRunSendButton = React.memo(
}
};
- let steerKbd: string | undefined = alternateHint;
+ let steerKbd: string | undefined = primary === 'queue' ? alternateHint : undefined;
if (primary === 'steer') {
- steerKbd = enterInterrupts ? undefined : submitHint;
+ steerKbd = submitHint;
}
const steerRow: ActionRow = {
@@ -143,34 +130,24 @@ const DuringRunSendButton = React.memo(
disabled: props.disabled,
onClick: () => runAction((text) => steering.queueFromComposer(text)),
};
- /** When steering is available, keeps visible text; a new chat instead hard-stops. */
+ /** Interrupt never becomes a stop-and-send fallback. */
const interruptSteerRow: ActionRow = {
key: 'interrupt-steer',
- label: localize(
- props.isNewConversation ? 'com_ui_steer_first_turn_stop' : 'com_ui_interrupt_steer',
- ),
+ label: localize('com_ui_interrupt_steer'),
kbd: interruptSteerKbd,
icon: <ZapOff className="text-status-warning h-4 w-4" aria-hidden="true" />,
disabled:
props.disabled ||
steering.pausedOnApproval ||
- !steering.canControlGeneration ||
+ !steering.canSteer ||
steering.pendingReasoningOverride != null,
onClick: () => runAction((text) => steering.interruptSteer(text)),
};
- const interruptRow: ActionRow = {
- key: 'interrupt',
- label: localize('com_ui_interrupt_send'),
- kbd: verdicts.altEnter === 'interrupt' ? altEnter : undefined,
- icon: <OctagonPause className="text-status-error h-4 w-4" aria-hidden="true" />,
- disabled: props.disabled || !steering.canControlGeneration,
- onClick: () => runAction((text) => steering.interruptAndSend(text)),
- };
- const rows = primary === 'steer' ? [steerRow, queueRow] : [queueRow, steerRow];
- rows.push(interruptSteerRow, interruptRow);
-
- const label =
- primary === 'steer' ? localize('com_ui_steer_send') : localize('com_ui_queue_send');
+ if (interruptSteerKbd == null && verdicts.altEnter === 'interrupt') {
+ interruptSteerRow.kbd = altEnter;
+ }
+ const rows = [steerRow, interruptSteerRow, queueRow];
+ const label = localize(ACTION_LABELS[primary]);
return (
<SendActions
diff --git a/client/src/components/Chat/Input/__tests__/DuringRunSendButton.test.tsx b/client/src/components/Chat/Input/__tests__/DuringRunSendButton.test.tsx
index 7da8d50860..f3dc0cacc2 100644
--- a/client/src/components/Chat/Input/__tests__/DuringRunSendButton.test.tsx
+++ b/client/src/components/Chat/Input/__tests__/DuringRunSendButton.test.tsx
@@ -41,18 +41,19 @@ const steeringStub = ({
canSteer = true,
canControlGeneration = true,
steerInterruptsByDefault = false,
-}: StubOptions & { steerInterruptsByDefault?: boolean }) =>
- ({
- effectiveAction: canSteer ? 'steer' : 'queue',
+}: StubOptions & { steerInterruptsByDefault?: boolean }) => {
+ const preferredAction = steerInterruptsByDefault ? 'interrupt' : 'steer';
+ return {
+ effectiveAction: canSteer ? preferredAction : 'queue',
canSteer,
canControlGeneration,
pausedOnApproval,
- steerInterruptsByDefault,
interruptSteer: mockInterruptSteer,
steerFromComposer: mockSteerFromComposer,
queueFromComposer: mockQueueFromComposer,
interruptAndSend: mockInterruptAndSend,
- }) as unknown as SteeringControls;
+ } as unknown as SteeringControls;
+};
function Harness({
steering,
@@ -110,9 +111,7 @@ function openMenu(options: MenuOptions = {}) {
/>
</RecoilRoot>,
);
- expect(
- screen.getByText(isNewConversation ? 'com_ui_steer_first_turn_stop' : 'com_ui_interrupt_steer'),
- ).toBeInTheDocument();
+ expect(screen.getByText('com_ui_interrupt_steer')).toBeInTheDocument();
}
beforeEach(() => {
@@ -128,12 +127,7 @@ describe('DuringRunSendButton — external hold', () => {
</RecoilRoot>
);
const view = render(frame(false));
- const labels = [
- 'com_ui_steer',
- 'com_ui_queue',
- 'com_ui_interrupt_steer',
- 'com_ui_interrupt_send',
- ];
+ const labels = ['com_ui_steer', 'com_ui_queue', 'com_ui_interrupt_steer'];
view.rerender(frame(true));
expect(screen.getByTestId('during-run-send-button')).toBeDisabled();
for (const label of labels) {
@@ -173,22 +167,13 @@ describe('DuringRunSendButton — Interrupt & steer availability', () => {
expect(mockOnConsumed).not.toHaveBeenCalled();
});
- /**
- * Guards the gate against being "simplified" to `!canSteer` like the steer
- * row above it. `canSteer` is also false before a conversation exists, where
- * `interruptSteer` deliberately falls back to interrupt & send — disabling
- * the row there would make it dead for the whole first turn.
- */
- test('labels the first-response fallback as stop and send without changing its action', () => {
- openMenu({ pausedOnApproval: false, canSteer: false, isNewConversation: true });
-
- expect(screen.queryByText('com_ui_interrupt_steer')).not.toBeInTheDocument();
- const row = screen.getByText('com_ui_steer_first_turn_stop').closest('button');
- expect(row).toHaveAttribute('aria-disabled', 'false');
-
+ test('keeps Interrupt disabled until the first conversation can be steered', () => {
+ openMenu({ canSteer: false, isNewConversation: true });
+ const row = screen.getByText('com_ui_interrupt_steer').closest('button');
+ expect(row).toHaveAttribute('aria-disabled', 'true');
fireEvent.click(row as HTMLButtonElement);
- expect(mockInterruptSteer).toHaveBeenCalledWith(TEXT);
- expect(mockOnConsumed).toHaveBeenCalled();
+ expect(mockInterruptSteer).not.toHaveBeenCalled();
+ expect(mockOnConsumed).not.toHaveBeenCalled();
});
test('the ordinary Steer row stays gated on canSteer', () => {
@@ -212,10 +197,6 @@ describe('DuringRunSendButton — Interrupt & steer availability', () => {
'aria-disabled',
'true',
);
- expect(screen.getByText('com_ui_interrupt_send').closest('button')).toHaveAttribute(
- 'aria-disabled',
- 'true',
- );
const queue = screen.getByText('com_ui_queue').closest('button') as HTMLButtonElement;
expect(queue).toHaveAttribute('aria-disabled', 'false');
@@ -280,7 +261,7 @@ describe('DuringRunSendButton — hints follow the effective bindings', () => {
expect(kbdFor('com_ui_steer')).toBe('⏎');
expect(kbdFor('com_ui_queue')).toBe('Ctrl ⏎');
expect(kbdFor('com_ui_interrupt_steer')).toBe('Ctrl ⇧ ⏎');
- expect(kbdFor('com_ui_interrupt_send')).toBe('Alt ⏎');
+ expect(screen.queryByText('com_ui_interrupt_send')).not.toBeInTheDocument();
});
test('drops a hint whose chord is rebound to a global shortcut', () => {
@@ -290,8 +271,8 @@ describe('DuringRunSendButton — hints follow the effective bindings', () => {
focusSearch: { mac: 'Meta+Shift+Enter', other: 'Ctrl+Shift+Enter' },
},
});
- expect(kbdFor('com_ui_interrupt_steer')).toBeNull();
- expect(kbdFor('com_ui_interrupt_send')).toBe('Alt ⏎');
+ expect(kbdFor('com_ui_interrupt_steer')).toBe('Alt ⏎');
+ expect(screen.queryByText('com_ui_interrupt_send')).not.toBeInTheDocument();
expect(kbdFor('com_ui_queue')).toBe('Ctrl ⏎');
});
@@ -302,7 +283,7 @@ describe('DuringRunSendButton — hints follow the effective bindings', () => {
submitMessage: { mac: 'Alt+Enter', other: 'Alt+Enter' },
},
});
- expect(kbdFor('com_ui_interrupt_send')).toBeNull();
+ expect(screen.queryByText('com_ui_interrupt_send')).not.toBeInTheDocument();
expect(kbdFor('com_ui_steer')).toBe('⏎');
expect(kbdFor('com_ui_interrupt_steer')).toBe('Ctrl ⇧ ⏎');
});
@@ -313,7 +294,7 @@ describe('DuringRunSendButton — hints follow the effective bindings', () => {
expect(kbdFor('com_ui_interrupt_steer')).toBeNull();
/** The disabled Steer row drops its alternate-action hint the same way. */
expect(kbdFor('com_ui_steer')).toBeNull();
- expect(kbdFor('com_ui_interrupt_send')).toBe('Alt ⏎');
+ expect(screen.queryByText('com_ui_interrupt_send')).not.toBeInTheDocument();
});
test('moves the default-action hint to Ctrl+Enter when Enter-to-send is off', () => {
@@ -322,7 +303,7 @@ describe('DuringRunSendButton — hints follow the effective bindings', () => {
expect(kbdFor('com_ui_steer')).toBe('Ctrl ⏎');
expect(kbdFor('com_ui_queue')).toBeNull();
expect(kbdFor('com_ui_interrupt_steer')).toBe('Ctrl ⇧ ⏎');
- expect(kbdFor('com_ui_interrupt_send')).toBe('Alt ⏎');
+ expect(screen.queryByText('com_ui_interrupt_send')).not.toBeInTheDocument();
});
test('keeps plain Enter but hides shortcut hints when shortcuts are disabled', () => {
@@ -330,6 +311,18 @@ describe('DuringRunSendButton — hints follow the effective bindings', () => {
expect(kbdFor('com_ui_steer')).toBe('⏎');
expect(kbdFor('com_ui_queue')).toBeNull();
expect(kbdFor('com_ui_interrupt_steer')).toBeNull();
- expect(kbdFor('com_ui_interrupt_send')).toBeNull();
+ expect(screen.queryByText('com_ui_interrupt_send')).not.toBeInTheDocument();
});
});
+
+test('exposes exactly three modes in a stable order', () => {
+ openMenu();
+ const rows = screen
+ .getAllByRole('button')
+ .filter((button) => button.getAttribute('type') === 'button');
+ expect(rows.map((row) => row.textContent?.replace(/Ctrl.*|Alt.*|⏎.*/g, '').trim())).toEqual([
+ 'com_ui_steer',
+ 'com_ui_interrupt_steer',
+ 'com_ui_queue',
+ ]);
+});
diff --git a/client/src/components/Nav/Settings/registry.tsx b/client/src/components/Nav/Settings/registry.tsx
index 8197013b3a..52db5f0b7d 100644
--- a/client/src/components/Nav/Settings/registry.tsx
+++ b/client/src/components/Nav/Settings/registry.tsx
@@ -286,19 +286,6 @@ export const registry: SettingEntry[] = [
keywords: ['steer', 'queue', 'interrupt', 'generating'],
Component: DuringRunAction,
},
- {
- id: 'steerInterruptsByDefault',
- tab: CHAT,
- section: 'sending',
- labelKey: 'com_ui_steer_interrupts_default',
- keywords: ['steer', 'interrupt', 'preempt', 'generating', 'stop'],
- Component: toggleControl({
- stateAtom: store.steerInterruptsByDefault,
- localizationKey: 'com_ui_steer_interrupts_default',
- switchId: 'steerInterruptsByDefault',
- hoverCardText: 'com_ui_steer_interrupts_default_info',
- }),
- },
{
id: 'saveDrafts',
tab: CHAT,
diff --git a/client/src/components/Nav/SettingsTabs/Chat/DuringRunAction.spec.tsx b/client/src/components/Nav/SettingsTabs/Chat/DuringRunAction.spec.tsx
new file mode 100644
index 0000000000..bfc6cac28f
--- /dev/null
+++ b/client/src/components/Nav/SettingsTabs/Chat/DuringRunAction.spec.tsx
@@ -0,0 +1,28 @@
+import { Provider, createStore } from 'jotai';
+import { render, waitFor } from '@testing-library/react';
+import { clickDropdown, flushDropdownEffects } from 'test/dropdown';
+import { duringRunActionAtom } from '~/store/duringRun';
+import DuringRunAction from './DuringRunAction';
+
+jest.mock('~/hooks', () => ({ useLocalize: () => (key: string) => key }));
+
+it('offers three defaults and persists Interrupt', async () => {
+ const store = createStore();
+ store.set(duringRunActionAtom, 'steer');
+ const { getByText, getByTestId, queryByRole } = render(
+ <Provider store={store}>
+ <DuringRunAction />
+ </Provider>,
+ );
+ const selector = getByTestId('duringRunAction');
+ expect(selector).toHaveTextContent('com_ui_steer');
+ await clickDropdown(selector);
+ expect(getByText('com_ui_queue')).toBeInTheDocument();
+ expect(queryByRole('switch')).not.toBeInTheDocument();
+ await clickDropdown(getByText('com_ui_interrupt_steer'));
+ await waitFor(() => expect(selector).toHaveTextContent('com_ui_interrupt_steer'));
+ expect(store.get(duringRunActionAtom)).toBe('interrupt');
+ expect(JSON.parse(localStorage.getItem('duringRunAction') ?? 'null')).toBe('interrupt');
+ await flushDropdownEffects();
+ localStorage.clear();
+});
diff --git a/client/src/components/Nav/SettingsTabs/Chat/DuringRunAction.tsx b/client/src/components/Nav/SettingsTabs/Chat/DuringRunAction.tsx
index cb1825c9d3..3c0704dd48 100644
--- a/client/src/components/Nav/SettingsTabs/Chat/DuringRunAction.tsx
+++ b/client/src/components/Nav/SettingsTabs/Chat/DuringRunAction.tsx
@@ -1,44 +1,34 @@
-import React from 'react';
-import { useRecoilState } from 'recoil';
-import { Button, InfoHoverCard, ESide } from '@librechat/client';
+import { useAtom } from 'jotai';
+import { Dropdown, InfoHoverCard, ESide } from '@librechat/client';
+import { duringRunActionAtom } from '~/store/duringRun';
import { useLocalize } from '~/hooks';
-import store from '~/store';
-/**
- * Toggles what Enter does while a run is generating: steer (inject the
- * message into the live run at the next tool boundary) or queue (send it as a
- * normal follow-up once the run finishes). The composer's during-run menu can
- * still override per send.
- */
-const DuringRunAction = () => {
- const [action, setAction] = useRecoilState(store.duringRunDefaultAction);
+export default function DuringRunAction() {
+ const [action, setAction] = useAtom(duringRunActionAtom);
const localize = useLocalize();
-
- const toggle = () => {
- setAction((prev) => (prev === 'steer' ? 'queue' : 'steer'));
- };
-
- const label =
- action === 'steer'
- ? localize('com_nav_during_run_action_steer')
- : localize('com_nav_during_run_action_queue');
+ const labelId = 'during-run-action-label';
return (
- <div className="flex items-center justify-between">
+ <div className="flex flex-wrap items-center justify-between gap-2">
<div className="flex items-center space-x-2">
- <span id="during-run-action-label">{localize('com_nav_during_run_action')}</span>
+ <span id={labelId}>{localize('com_nav_during_run_action')}</span>
<InfoHoverCard side={ESide.Bottom} text={localize('com_nav_info_during_run_action')} />
</div>
- <Button
- variant="outline"
- aria-labelledby="during-run-action-label"
- onClick={toggle}
- data-testid="duringRunAction"
- >
- {label}
- </Button>
+ <Dropdown
+ value={action}
+ options={[
+ { value: 'steer', label: localize('com_ui_steer') },
+ { value: 'interrupt', label: localize('com_ui_interrupt_steer') },
+ { value: 'queue', label: localize('com_ui_queue') },
+ ]}
+ onChange={(value) => {
+ if (value === 'steer' || value === 'interrupt' || value === 'queue') setAction(value);
+ }}
+ className="z-50"
+ sizeClasses="z-50"
+ testId="duringRunAction"
+ aria-labelledby={labelId}
+ />
</div>
);
-};
-
-export default DuringRunAction;
+}
diff --git a/client/src/hooks/Chat/__tests__/useSteering.spec.tsx b/client/src/hooks/Chat/__tests__/useSteering.spec.tsx
index 0cee03c406..a7a0dce725 100644
--- a/client/src/hooks/Chat/__tests__/useSteering.spec.tsx
+++ b/client/src/hooks/Chat/__tests__/useSteering.spec.tsx
@@ -38,7 +38,9 @@ import { recoveryDispositionsFamily } from '~/components/Chat/Steering/recovery'
import { claimQueuedIntent, releaseQueuedIntent } from '~/utils/queueIntent';
import useUpdateFiles from '~/hooks/Files/useUpdateFiles';
import ChatSettingsProvider from '~/routes/ChatSettings';
+import { duringRunActionAtom } from '~/store/duringRun';
import { applyPendingAction } from '~/utils/approval';
+import English from '~/locales/en/translation.json';
import useQueueDrain from '../useQueueDrain';
import store from '~/store';
@@ -204,6 +206,7 @@ beforeEach(() => resetQueueFamilies());
describe('useSteering', () => {
beforeEach(() => {
+ getDefaultStore().set(duringRunActionAtom, 'steer');
getDefaultStore().set(recoveryDispositionsFamily(CONVO_ID), {});
jest.clearAllMocks();
mockApprovalMode = undefined;
@@ -479,8 +482,8 @@ describe('useSteering', () => {
});
it('honors the queue preference while keeping the steer override available', () => {
- const { result } = setup({}, ({ set }) => {
- set(store.duringRunDefaultAction, 'queue');
+ const { result } = setup({}, () => {
+ getDefaultStore().set(duringRunActionAtom, 'queue');
});
expect(result.current.effectiveAction).toBe('queue');
// The per-send menu can still override to steer: availability is
@@ -490,8 +493,8 @@ describe('useSteering', () => {
it('degrades to queue without a real conversation id', () => {
// Explicitly request steer so this verifies the missing-id fallback to queue.
- const { result } = setup({ conversationId: Constants.NEW_CONVO as string }, ({ set }) => {
- set(store.duringRunDefaultAction, 'steer');
+ const { result } = setup({ conversationId: Constants.NEW_CONVO as string }, () => {
+ getDefaultStore().set(duringRunActionAtom, 'steer');
});
expect(result.current.effectiveAction).toBe('queue');
});
@@ -515,8 +518,8 @@ describe('useSteering', () => {
} as unknown as TMessage,
];
// Explicitly request steer so this verifies the pause fallback to queue.
- const { result } = setup({}, ({ set }) => {
- set(store.duringRunDefaultAction, 'steer');
+ const { result } = setup({}, () => {
+ getDefaultStore().set(duringRunActionAtom, 'steer');
});
expect(result.current.pausedOnApproval).toBe(true);
expect(result.current.effectiveAction).toBe('queue');
@@ -2184,8 +2187,8 @@ describe('useSteering', () => {
describe('submitDuringRun', () => {
it('routes to the steer POST with an optimistic sending chip', () => {
- const { result } = setup({}, ({ set }) => {
- set(store.duringRunDefaultAction, 'steer');
+ const { result } = setup({}, () => {
+ getDefaultStore().set(duringRunActionAtom, 'steer');
});
let consumed = false;
act(() => {
@@ -2203,8 +2206,8 @@ describe('useSteering', () => {
});
it('routes to the client queue when the preference is queue', () => {
- const { result } = setup({}, ({ set }) => {
- set(store.duringRunDefaultAction, 'queue');
+ const { result } = setup({}, () => {
+ getDefaultStore().set(duringRunActionAtom, 'queue');
});
act(() => {
result.current.submitDuringRun('after the run');
@@ -2214,8 +2217,8 @@ describe('useSteering', () => {
it('ignores empty submissions', () => {
// Explicitly request steer so blank-text validation exercises the steer path.
- const { result } = setup({}, ({ set }) => {
- set(store.duringRunDefaultAction, 'steer');
+ const { result } = setup({}, () => {
+ getDefaultStore().set(duringRunActionAtom, 'steer');
});
let consumed = true;
act(() => {
@@ -2339,7 +2342,7 @@ describe('useSteering', () => {
* a real conversationId. Without this fallback the always-visible button
* would be dead for the whole first turn.
*/
- it('falls back to interruptAndSend before a conversation exists', () => {
+ it('refuses Interrupt before a conversation exists without aborting it', () => {
const { result, stopGenerating } = setup({
conversationId: Constants.NEW_CONVO as string,
});
@@ -2347,9 +2350,9 @@ describe('useSteering', () => {
act(() => {
consumed = result.current.interruptSteer('turn one interrupt');
});
- expect(consumed).toBe(true);
+ expect(consumed).toBe(false);
expect(mockMutate).not.toHaveBeenCalled();
- expect(stopGenerating).toHaveBeenCalled();
+ expect(stopGenerating).not.toHaveBeenCalled();
});
it('refuses empty text without touching the run', () => {
@@ -2403,8 +2406,8 @@ describe('useSteering', () => {
* non-preempting, or they become indistinguishable from Interrupt & steer.
*/
it('leaves the explicit Steer action non-preempting even with the preference on', () => {
- const { result } = setup({}, ({ set }) => {
- set(store.steerInterruptsByDefault, true);
+ const { result } = setup({}, () => {
+ getDefaultStore().set(duringRunActionAtom, 'interrupt');
});
act(() => {
result.current.steerFromComposer('explicit steer row');
@@ -2419,8 +2422,8 @@ describe('useSteering', () => {
thread's pending block renders; its own spec covers the preempt carry. */
it('an ordinary steer does not preempt by default', () => {
- const { result } = setup({}, ({ set }) => {
- set(store.duringRunDefaultAction, 'steer');
+ const { result } = setup({}, () => {
+ getDefaultStore().set(duringRunActionAtom, 'steer');
});
act(() => {
result.current.submitDuringRun('just steer');
@@ -2431,10 +2434,10 @@ describe('useSteering', () => {
);
});
- it('steerInterruptsByDefault makes the default Enter route preempt', () => {
- const { result } = setup({}, ({ set }) => {
- set(store.duringRunDefaultAction, 'steer');
- set(store.steerInterruptsByDefault, true);
+ it('the Interrupt default makes Enter preempt', () => {
+ const { result } = setup({}, () => {
+ getDefaultStore().set(duringRunActionAtom, 'steer');
+ getDefaultStore().set(duringRunActionAtom, 'interrupt');
});
act(() => {
result.current.submitDuringRun('enter should interrupt');
@@ -2467,6 +2470,10 @@ describe('useSteering', () => {
expect.objectContaining({ preempt: true }),
expect.anything(),
);
+ expect(mockShowToast).toHaveBeenCalledWith({
+ message: English.com_ui_steer_preempt_unsupported,
+ status: 'warning',
+ });
});
it('serializes rapid steer POSTs in submission order', () => {
@@ -3474,8 +3481,8 @@ describe('useSteering', () => {
});
it('sendQueuedNow steers whenever steering is available, even under the queue preference', () => {
- const { result } = setupWithState({}, ({ set }) => {
- set(store.duringRunDefaultAction, 'queue');
+ const { result } = setupWithState({}, () => {
+ getDefaultStore().set(duringRunActionAtom, 'queue');
});
act(() => {
result.current.steering.enqueue('send me now');
@@ -3774,8 +3781,8 @@ describe('useSteering', () => {
}
it('steers with the composer attachments as one unit', () => {
- const { result, setFiles } = setupWithFiles({}, ({ set }) => {
- set(store.duringRunDefaultAction, 'steer');
+ const { result, setFiles } = setupWithFiles({}, () => {
+ getDefaultStore().set(duringRunActionAtom, 'steer');
});
let consumed = false;
act(() => {
@@ -3931,8 +3938,8 @@ describe('useSteering', () => {
// Seed 'steer' so this covers steerFromComposer's own filesLoading
// guard; the queue-path guard is covered separately (queueFromComposer
// is exercised directly with filesLoading in the composer-draft tests).
- const { result } = setupWithFiles({ filesLoading: true }, ({ set }) => {
- set(store.duringRunDefaultAction, 'steer');
+ const { result } = setupWithFiles({ filesLoading: true }, () => {
+ getDefaultStore().set(duringRunActionAtom, 'steer');
});
let consumed = true;
act(() => {
@@ -4051,8 +4058,8 @@ describe('useSteering', () => {
});
it('does not mark usage on the steer path (the 202 already marked)', () => {
- const { result } = setupWithFiles({}, ({ set }) => {
- set(store.duringRunDefaultAction, 'steer');
+ const { result } = setupWithFiles({}, () => {
+ getDefaultStore().set(duringRunActionAtom, 'steer');
});
act(() => {
result.current.steering.submitDuringRun('steer with media');
diff --git a/client/src/hooks/Chat/contract.ts b/client/src/hooks/Chat/contract.ts
index bc43464abd..79663fb9d6 100644
--- a/client/src/hooks/Chat/contract.ts
+++ b/client/src/hooks/Chat/contract.ts
@@ -168,7 +168,7 @@ export type AddedChatContract = {
};
/** Composer action while a run is in flight: fold the text into the run, or queue a new turn. */
-export type DuringRunAction = 'steer' | 'queue';
+export type DuringRunAction = 'steer' | 'interrupt' | 'queue';
/**
* App-global preferences the chat reads but does not own. The host supplies them, so the chat
@@ -180,8 +180,6 @@ export type ChatSettings = {
/** Default composer action while a run is in flight. */
duringRunDefaultAction: DuringRunAction;
setDuringRunDefaultAction: (action: DuringRunAction) => void;
- /** Whether a steer interrupts the running step instead of waiting for the next one. */
- steerInterruptsByDefault: boolean;
/** Closes the artifacts panel, called when the active conversation changes. */
resetVisibleArtifacts: () => void;
/** Whether composer text and attachments are kept as drafts across navigation. */
diff --git a/client/src/hooks/Chat/useSteering.ts b/client/src/hooks/Chat/useSteering.ts
index 2bd8eb89c3..5cd1bf15b8 100644
--- a/client/src/hooks/Chat/useSteering.ts
+++ b/client/src/hooks/Chat/useSteering.ts
@@ -609,11 +609,8 @@ export default function useSteering({
const { mutate: markFilesUsage } = useMarkFilesUsageMutation();
const { mutate: enqueueAgentQueuedTurn } = useEnqueueAgentQueuedTurnMutation();
const { mutateAsync: cancelAgentQueuedTurn } = useCancelAgentQueuedTurnMutation();
- const {
- duringRunDefaultAction: defaultAction,
- setDuringRunDefaultAction: setDefaultAction,
- steerInterruptsByDefault,
- } = useChatSettings();
+ const { duringRunDefaultAction: defaultAction, setDuringRunDefaultAction: setDefaultAction } =
+ useChatSettings();
const { selected: codeApprovalMode } = useCodeApprovalMode(conversation, addedConversation);
const endpoint = conversation?.endpointType ?? conversation?.endpoint;
@@ -1970,10 +1967,18 @@ export default function useSteering({
}
return;
}
- /** The server's echo is authoritative: a deployment whose SDK
- * cannot seal mid-stream still queues the steer and answers
- * `preempt: false`, which relabels the chip to the ordinary
- * wording instead of surfacing an error. */
+ /** Unsupported runs retain the words as Steer, but never silently
+ * claim to have requested tool cancellation. */
+ if (
+ preempt &&
+ response.preempt !== true &&
+ visibleConversationRef.current === conversationId
+ ) {
+ showToast({
+ message: localize('com_ui_steer_preempt_unsupported'),
+ status: 'warning',
+ });
+ }
const acknowledged = {
steerId: response.steerId,
clientSteerId: localId,
@@ -2533,25 +2538,7 @@ export default function useSteering({
],
);
- /**
- * Interrupt & steer: the same POST, queue, chip lifecycle and degradation
- * ladder as an ordinary steer: the only difference is that the server asks
- * the generating replica to seal its model stream at the next
- * provider-safe boundary instead of waiting for a tool step. The partial
- * answer is kept and generation resumes in the same message.
- *
- * Falls back to `interruptAndSend` ONLY before a conversation exists:
- * steering needs a server-side job, so `submitSteer` hard-refuses without a
- * real conversationId, and an always-visible button would otherwise be dead
- * for the entire first turn, exactly when a user most wants to stop a long
- * answer.
- *
- * A run paused on tool approval refuses outright instead. `canSteer` is
- * false there too, but routing that into `interruptAndSend` would hard-abort
- * the run and discard the partial answer: the exact opposite of what this
- * action promises. The standalone button is disabled while paused; the
- * keyboard and hovercard paths reach here, so the guard lives here.
- */
+ /** Preempt the active step and continue the same response with the message. */
const interruptSteer = useCallback(
(text: string): boolean => {
const trimmed = text.trim();
@@ -2560,7 +2547,8 @@ export default function useSteering({
trimmed.length === 0 ||
filesLoading ||
pausedOnApproval ||
- !canControlGeneration
+ !canControlGeneration ||
+ !hasRealConvoId
) {
return false;
}
@@ -2573,9 +2561,6 @@ export default function useSteering({
if (pendingReasoningOverride != null) {
return false;
}
- if (!hasRealConvoId) {
- return interruptAndSend(trimmed);
- }
const consumed = submitSteer(trimmed, takeComposerFiles(), takeComposerQuotes(), {
preempt: true,
});
@@ -2590,7 +2575,6 @@ export default function useSteering({
canControlGeneration,
hasRealConvoId,
pendingReasoningOverride,
- interruptAndSend,
takeComposerFiles,
takeComposerQuotes,
takeComposerDraft,
@@ -2604,21 +2588,15 @@ export default function useSteering({
if (composerDisabledRef.current || !duringRunActive) {
return false;
}
+ if (effectiveAction === 'interrupt') {
+ return interruptSteer(text);
+ }
if (effectiveAction === 'steer') {
- /** Only the DEFAULT route honours the preference: the explicit Steer
- * row and the Ctrl/Cmd+Enter alternate stay non-preempting, or they
- * would become indistinguishable from Interrupt & steer. */
- return steerFromComposer(text, steerInterruptsByDefault);
+ return steerFromComposer(text);
}
return queueFromComposer(text);
},
- [
- duringRunActive,
- effectiveAction,
- steerInterruptsByDefault,
- steerFromComposer,
- queueFromComposer,
- ],
+ [duringRunActive, effectiveAction, interruptSteer, steerFromComposer, queueFromComposer],
);
/** Memoized so consumers like `memo(Bar)` and `memo(Queue)` can bail on the
@@ -2633,7 +2611,6 @@ export default function useSteering({
canSendQueuedNow,
effectiveAction,
defaultAction,
- steerInterruptsByDefault,
pendingReasoningOverride,
pausedOnApproval,
setDefaultAction,
@@ -2666,7 +2643,6 @@ export default function useSteering({
duringRunActive,
canSendQueuedNow,
effectiveAction,
- steerInterruptsByDefault,
defaultAction,
pendingReasoningOverride,
pausedOnApproval,
diff --git a/client/src/hooks/Input/__tests__/useComposerHint.spec.ts b/client/src/hooks/Input/__tests__/useComposerHint.spec.ts
index 264b4b4c1c..5f2de52bc1 100644
--- a/client/src/hooks/Input/__tests__/useComposerHint.spec.ts
+++ b/client/src/hooks/Input/__tests__/useComposerHint.spec.ts
@@ -84,6 +84,31 @@ describe('composeHint', () => {
expect(hint(state, false)).toContain('Alt+⏎');
});
+ it.each([
+ ['tool approval', true, true],
+ ['staged reasoning', true, false],
+ ['tool approval with Enter inserting a newline', false, false],
+ ['staged reasoning with Enter inserting a newline', false, true],
+ ])('omits unavailable Interrupt during %s', (_reason, enterToSend, isMac) => {
+ const result = hint(
+ {
+ duringRunActive: true,
+ hasText: true,
+ isSubmitting: true,
+ canSteer: false,
+ duringRunAction: 'queue',
+ enterToSend,
+ },
+ isMac,
+ );
+ expect(result).not.toContain('com_ui_composer_hint_interrupt');
+ expect(result).not.toContain('com_ui_composer_hint_send_now');
+ expect(result).not.toContain(isMac ? '⌥⏎' : 'Alt+⏎');
+ expect(result).toContain(
+ enterToSend ? 'com_ui_composer_hint_queue_default' : 'com_ui_composer_hint_queue_verb',
+ );
+ });
+
it('falls back to the running copy when the modifiers have no text to act on', () => {
expect(hint({ duringRunActive: true, hasText: false, isSubmitting: true })).toBe(
'com_ui_composer_hint_running',
@@ -211,3 +236,10 @@ describe('composeHint', () => {
});
});
});
+
+it('names Interrupt as the default while leaving Queue as the alternate', () => {
+ const result = hint({ duringRunActive: true, hasText: true, duringRunAction: 'interrupt' });
+ expect(result).toContain('com_ui_interrupt_steer');
+ expect(result).toContain('com_ui_composer_hint_queue');
+ expect(result).not.toContain('com_ui_composer_hint_steer');
+});
diff --git a/client/src/hooks/Input/useComposerHint.ts b/client/src/hooks/Input/useComposerHint.ts
index 19f54d2e85..067313ffc7 100644
--- a/client/src/hooks/Input/useComposerHint.ts
+++ b/client/src/hooks/Input/useComposerHint.ts
@@ -25,8 +25,7 @@ export interface ComposerHintState {
* Queueing is local, so it works throughout. */
canControlGeneration: boolean;
/** Which action Enter takes during a run, per the effective setting. */
- duringRunAction: 'steer' | 'queue';
- steerInterruptsByDefault?: boolean;
+ duringRunAction: 'steer' | 'interrupt' | 'queue';
/** Whether the steer route can accept input right now. A paused tool
* approval forces the effective action to queue and refuses steers, so the
* live-send alternate must not be advertised through it. */
@@ -103,7 +102,7 @@ export function composeHint(
alternate is named only while the stock chord still works. */
const sendChord = sendBinding.customized ? sendBinding.display : mod;
const isSteer = state.duringRunAction === 'steer';
- const interruptByDefault = isSteer && state.steerInterruptsByDefault === true;
+ const interruptByDefault = state.duringRunAction === 'interrupt';
/* The default action and the live submit route share this preference:
naming plain Enter as Steer while it preempts is materially misleading. */
let defaultAction: string;
@@ -114,9 +113,10 @@ export function composeHint(
} else {
defaultAction = localize('com_ui_composer_hint_queue_default');
}
- const alternateAction = isSteer
- ? `${mod} ${localize('com_ui_composer_hint_queue')}`
- : `${mod} ${localize('com_ui_composer_hint_send_now')}`;
+ const alternateAction =
+ state.duringRunAction !== 'queue'
+ ? `${mod} ${localize('com_ui_composer_hint_queue')}`
+ : `${mod} ${localize('com_ui_composer_hint_send_now')}`;
let chordVerb: Parameters<typeof localize>[0];
if (interruptByDefault) {
chordVerb = 'com_ui_interrupt_steer';
@@ -130,7 +130,7 @@ export function composeHint(
parts.push(defaultAction);
/* The queue alternate is local and always lands; the send-now alternate
rides the steer route, which a paused approval refuses. */
- if (!sendBinding.customized && (isSteer || state.canSteer)) {
+ if (!sendBinding.customized && (state.duringRunAction !== 'queue' || state.canSteer)) {
parts.push(alternateAction);
}
} else if (sendChord) {
@@ -147,12 +147,12 @@ export function composeHint(
};
}
/* The interrupt chord is named only while the keydown resolver still hands
- it back: a `submitMessage` rebound to Alt+Enter, a chord yielded to a
- global shortcut, or shortcuts disabled altogether each make the key do
- something else, and advertising it is worse than omitting it. */
- const text = altEnterInterrupt
- ? [...parts, `${alt} ${localize('com_ui_composer_hint_interrupt')}`].join(SEPARATOR)
- : parts.join(SEPARATOR);
+ it back and the run accepts steering. Approval pauses and staged reasoning
+ refuse Interrupt just like the disabled menu row. */
+ const text =
+ altEnterInterrupt && state.canSteer
+ ? [...parts, `${alt} ${localize('com_ui_composer_hint_interrupt')}`].join(SEPARATOR)
+ : parts.join(SEPARATOR);
return {
text: text || localize('com_ui_composer_hint_running'),
kind: 'state',
diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.json
index 0821d079f4..7f13fc8b3e 100644
--- a/client/src/locales/en/translation.json
+++ b/client/src/locales/en/translation.json
@@ -806,8 +806,6 @@
"com_nav_delete_data_info": "All your data will be deleted.",
"com_nav_delete_warning": "WARNING: This will permanently delete your account.",
"com_nav_during_run_action": "While generating, Enter will",
- "com_nav_during_run_action_queue": "Queue for after",
- "com_nav_during_run_action_steer": "Steer the response",
"com_nav_enable_cache_tts": "Enable cache TTS",
"com_nav_enable_cloud_browser_voice": "Use cloud-based voices",
"com_nav_engine": "Engine",
@@ -842,7 +840,7 @@
"com_nav_info_collapse_user_messages": "When enabled, long user messages render collapsed to a preview with a Show more option, so pasted text or code cannot dominate the conversation. The full text stays in the page, ready to copy or search.",
"com_nav_info_copy_rich_text": "When enabled, copying a message also places a formatted version on the clipboard, so headings, lists, tables and code keep their styling when pasted into apps that do not support Markdown, such as Teams, Outlook or Word.",
"com_nav_info_default_temporary_chat": "When enabled, new chats will start with temporary chat mode activated by default. Temporary chats are not saved to your history.",
- "com_nav_info_during_run_action": "Choose what Enter does while the assistant responds. \"Steer the response\" usually waits for the next tool step or an end-of-response opportunity. Turn on \"Steer sooner on Enter\" to request an earlier safe point. \"Queue for after\" sends a new turn once the response finishes. The send button lets you choose per message.",
+ "com_nav_info_during_run_action": "Steer waits for a safe insertion point without cancelling tools or reasoning. Interrupt requests cancellation of active tools and reasoning, then continues with your message. Queue sends a follow-up after the response finishes. Choose per message in the send menu.",
"com_nav_info_enter_to_send": "When enabled, pressing `ENTER` will send your message. When disabled, pressing Enter will add a new line, and you'll need to press `CTRL + ENTER` / `⌘ + ENTER` to send your message.",
"com_nav_info_fork_change_default": "`Visible messages only` includes just the direct path to the selected message. `Include related branches` adds branches along the path. `Include all to/from here` includes all connected messages and branches.",
"com_nav_info_fork_split_target_setting": "When enabled, forking will commence from the target message to the latest message in the conversation, according to the behavior selected.",
@@ -1388,7 +1386,7 @@
"com_ui_composer_files_images": "Images",
"com_ui_composer_hint_answer": "Answering. Esc to dismiss",
"com_ui_composer_hint_attach": "+ to attach",
- "com_ui_composer_hint_interrupt": "interrupt & send",
+ "com_ui_composer_hint_interrupt": "interrupt",
"com_ui_composer_hint_mentions": "@ for models",
"com_ui_composer_hint_newline": "for newline",
"com_ui_composer_hint_prompts": "/ for prompts",
@@ -1853,9 +1851,8 @@
"com_ui_importing": "Importing",
"com_ui_input": "Input",
"com_ui_instructions": "Instructions",
- "com_ui_interrupt_send": "Interrupt & send",
- "com_ui_interrupt_steer": "Steer sooner",
- "com_ui_interrupt_steer_now": "Steer sooner",
+ "com_ui_interrupt_steer": "Interrupt",
+ "com_ui_interrupt_steer_now": "Interrupt now",
"com_ui_invalid_json": "Invalid JSON",
"com_ui_invocation_auto": "Auto",
"com_ui_invocation_auto_info": "The skill is automatically applied by the agent when relevant to the conversation",
@@ -2855,20 +2852,17 @@
"com_ui_steer_recovery_held": "Recovery paused",
"com_ui_steer_cancel_failed": "Could not cancel the steering message — it may still reach the agent",
"com_ui_steer_delivered": "Delivered",
- "com_ui_steer_delivered_info": "Delivered. Your message can join this response at the next tool step or, when possible, before it finishes.",
+ "com_ui_steer_delivered_info": "Delivered. Waiting for a safe insertion point after the current tool or reasoning step.",
"com_ui_steer_delivery_unconfirmed": "Delivery unconfirmed",
"com_ui_steer_delivery_uncertain": "Delivery status is unknown; this steering message may still reach the agent",
"com_ui_steer_failed": "Steering failed",
"com_ui_steer_failed_inline": "Couldn't add to this reply",
- "com_ui_steer_first_turn_stop": "Stop & send (first response)",
"com_ui_steer_in_flight": "Steering",
- "com_ui_steer_in_flight_preempt": "Steer sooner requested",
- "com_ui_steer_interrupting_info": "Earlier steering requested. The agent may pause a text reply at a safe point or restart an attempt that has produced only reasoning. Running tools finish first. If it cannot pause, your message waits for the next tool step or an end-of-response opportunity.",
- "com_ui_steer_interrupts_default": "Steer sooner on Enter",
- "com_ui_steer_interrupts_default_info": "When steering is the default, Enter requests an earlier safe point instead of waiting for the next tool step. Running tools finish first; a thinking-only attempt may restart. Text already shown is kept.",
+ "com_ui_steer_in_flight_preempt": "Interrupt requested",
+ "com_ui_steer_interrupting_info": "Cancellation requested for active tools and reasoning. Completed output is kept, and the agent continues with your message. External effects already performed cannot be undone.",
"com_ui_steer_moved_to_queue": "Moved to the queue: it sends when this response finishes",
"com_ui_steer_paused_queued": "The agent is waiting for your review — your message was queued instead",
- "com_ui_steer_preempt_unsupported": "This deployment can't steer mid-response. Your message waits for the next tool step or an end-of-response opportunity",
+ "com_ui_steer_preempt_unsupported": "Interrupt is unavailable for this run, including provider-hosted tools such as native search. Your message remains as Steer and waits for a safe insertion point.",
"com_ui_steer_queued_info": "Sends when this response finishes",
"com_ui_steer_send": "Steer the current response",
"com_ui_steer_sending": "Sending…",
diff --git a/client/src/routes/ChatSettings.tsx b/client/src/routes/ChatSettings.tsx
index 68efbc58e4..973236c03e 100644
--- a/client/src/routes/ChatSettings.tsx
+++ b/client/src/routes/ChatSettings.tsx
@@ -1,18 +1,17 @@
import { useMemo } from 'react';
+import { useAtom } from 'jotai';
import { useRecoilState, useRecoilValue, useResetRecoilState } from 'recoil';
import type { ReactNode } from 'react';
import type { ChatSettings } from '~/hooks/Chat/contract';
import { ChatTransportContext, defaultChatTransport } from '~/Providers/ChatTransportContext';
import { ChatSettingsContext } from '~/Providers/ChatSettingsContext';
+import { duringRunActionAtom } from '~/store/duringRun';
import store from '~/store';
/** Supplies the chat's app-global preferences from the app's own settings store, and the
* transport its turns run over. */
export default function ChatSettingsProvider({ children }: { children: ReactNode }) {
- const [duringRunDefaultAction, setDuringRunDefaultAction] = useRecoilState(
- store.duringRunDefaultAction,
- );
- const steerInterruptsByDefault = useRecoilValue(store.steerInterruptsByDefault);
+ const [duringRunDefaultAction, setDuringRunDefaultAction] = useAtom(duringRunActionAtom);
const resetVisibleArtifacts = useResetRecoilState(store.visibleArtifacts);
const saveDrafts = useRecoilValue<boolean>(store.saveDrafts);
const [isTemporary, setIsTemporary] = useRecoilState<boolean>(store.isTemporary);
@@ -21,7 +20,6 @@ export default function ChatSettingsProvider({ children }: { children: ReactNode
() => ({
duringRunDefaultAction,
setDuringRunDefaultAction,
- steerInterruptsByDefault,
resetVisibleArtifacts,
saveDrafts,
isTemporary,
@@ -30,7 +28,6 @@ export default function ChatSettingsProvider({ children }: { children: ReactNode
[
duringRunDefaultAction,
setDuringRunDefaultAction,
- steerInterruptsByDefault,
resetVisibleArtifacts,
saveDrafts,
isTemporary,
diff --git a/client/src/routes/__tests__/ChatSettings.spec.tsx b/client/src/routes/__tests__/ChatSettings.spec.tsx
index 91c37a0187..d7947af244 100644
--- a/client/src/routes/__tests__/ChatSettings.spec.tsx
+++ b/client/src/routes/__tests__/ChatSettings.spec.tsx
@@ -1,7 +1,9 @@
import React from 'react';
+import { useAtomValue, getDefaultStore } from 'jotai';
import { act, renderHook } from '@testing-library/react';
import { RecoilRoot, useRecoilValue, type MutableSnapshot } from 'recoil';
import { defaultChatSettings, useChatSettings } from '~/Providers/ChatSettingsContext';
+import { duringRunActionAtom } from '~/store/duringRun';
import ChatSettingsProvider from '../ChatSettings';
import store from '~/store';
@@ -9,7 +11,7 @@ const renderSettings = (initialize?: (snapshot: MutableSnapshot) => void) =>
renderHook(
() => ({
settings: useChatSettings(),
- storedAction: useRecoilValue(store.duringRunDefaultAction),
+ storedAction: useAtomValue(duringRunActionAtom),
visibleArtifacts: useRecoilValue(store.visibleArtifacts),
}),
{
@@ -22,15 +24,14 @@ const renderSettings = (initialize?: (snapshot: MutableSnapshot) => void) =>
);
describe('ChatSettingsProvider', () => {
+ beforeEach(() => getDefaultStore().set(duringRunActionAtom, 'steer'));
it('supplies the stored preferences to the chat', () => {
- const { result } = renderSettings(({ set }) => {
- set(store.duringRunDefaultAction, 'queue');
- set(store.steerInterruptsByDefault, true);
+ const { result } = renderSettings(() => {
+ getDefaultStore().set(duringRunActionAtom, 'interrupt');
});
expect(result.current.settings).toMatchObject({
- duringRunDefaultAction: 'queue',
- steerInterruptsByDefault: true,
+ duringRunDefaultAction: 'interrupt',
});
});
diff --git a/client/src/store/duringRun.spec.ts b/client/src/store/duringRun.spec.ts
new file mode 100644
index 0000000000..789fd6bc8e
--- /dev/null
+++ b/client/src/store/duringRun.spec.ts
@@ -0,0 +1,28 @@
+import { createStore } from 'jotai';
+import { duringRunActionAtom, migrateDuringRunAction } from './duringRun';
+
+describe('during-run preference', () => {
+ it.each([
+ ['steer', false, 'steer'],
+ ['steer', true, 'interrupt'],
+ ['queue', false, 'queue'],
+ ['queue', true, 'queue'],
+ ['interrupt', false, 'interrupt'],
+ ['invalid', true, 'steer'],
+ ])('migrates %s / %s to %s', (legacy, interrupts, expected) => {
+ expect(migrateDuringRunAction(legacy, interrupts)).toBe(expected);
+ });
+
+ it('persists each mode without overwriting legacy keys', () => {
+ localStorage.setItem('duringRunDefaultAction', JSON.stringify('queue'));
+ localStorage.setItem('steerInterruptsByDefault', JSON.stringify(true));
+ const store = createStore();
+ for (const mode of ['steer', 'interrupt', 'queue'] as const) {
+ store.set(duringRunActionAtom, mode);
+ expect(JSON.parse(localStorage.getItem('duringRunAction') ?? 'null')).toBe(mode);
+ }
+ expect(JSON.parse(localStorage.getItem('duringRunDefaultAction') ?? 'null')).toBe('queue');
+ expect(JSON.parse(localStorage.getItem('steerInterruptsByDefault') ?? 'null')).toBe(true);
+ localStorage.clear();
+ });
+});
diff --git a/client/src/store/duringRun.ts b/client/src/store/duringRun.ts
new file mode 100644
index 0000000000..bda7a27c77
--- /dev/null
+++ b/client/src/store/duringRun.ts
@@ -0,0 +1,23 @@
+import { atom } from 'jotai';
+import type { DuringRunAction } from '~/hooks/Chat/contract';
+import { createStorageAtom, initializeFromStorage } from './jotai-utils';
+
+export function migrateDuringRunAction(action: string, interrupts: boolean): DuringRunAction {
+ if (action === 'queue') return 'queue';
+ if (action === 'interrupt' || (action === 'steer' && interrupts)) return 'interrupt';
+ return 'steer';
+}
+
+/** Keep legacy keys untouched so older clients retain their saved behavior. */
+const storedAction = createStorageAtom<DuringRunAction>(
+ 'duringRunAction',
+ migrateDuringRunAction(
+ initializeFromStorage('duringRunDefaultAction', 'steer'),
+ initializeFromStorage('steerInterruptsByDefault', false),
+ ),
+);
+
+export const duringRunActionAtom = atom(
+ (get) => migrateDuringRunAction(get(storedAction), false),
+ (_get, set, action: DuringRunAction) => set(storedAction, action),
+);
diff --git a/client/src/store/settings.ts b/client/src/store/settings.ts
index 729f59af7f..7546290751 100644
--- a/client/src/store/settings.ts
+++ b/client/src/store/settings.ts
@@ -58,19 +58,6 @@ const localStorageAtoms = {
// Chat settings
enterToSend: atomWithLocalStorage('enterToSend', true),
- /** The action Enter uses while a reply is generating. */
- duringRunDefaultAction: atomWithLocalStorage<'steer' | 'queue'>(
- 'duringRunDefaultAction',
- 'steer',
- ),
- /**
- * Whether a steer interrupts generation at the next safe boundary instead of
- * waiting for the run's next tool step. Orthogonal to
- * `duringRunDefaultAction`: that chooses steer-vs-queue, this chooses how
- * soon a steer lands. The composer's interrupt button always interrupts
- * regardless — this only governs the default Enter/steer route.
- */
- steerInterruptsByDefault: atomWithLocalStorage('steerInterruptsByDefault', false),
maximizeChatSpace: atomWithLocalStorage('maximizeChatSpace', false),
chatDirection: atomWithLocalStorage('chatDirection', 'LTR'),
autoExpandTools: atomWithLocalStorage(LocalStorageKeys.AUTO_EXPAND_TOOLS, false),
diff --git a/e2e/setup/fake-model.js b/e2e/setup/fake-model.js
index 051add55a3..96f14e7600 100644
--- a/e2e/setup/fake-model.js
+++ b/e2e/setup/fake-model.js
@@ -50,6 +50,7 @@ const EMPTY_SLOW_REPLY_MARKER = 'E2E_EMPTY_SLOW_REPLY:';
const EMPTY_REPLY_MARKER = 'E2E_EMPTY_REPLY:';
const SLOW_COUNTED_REPLY_MARKER = 'E2E_SLOW_COUNTED_REPLY:';
const STEER_TOOL_REPLY_MARKER = 'E2E_STEER_TOOL_REPLY:';
+const INTERRUPT_TOOL_REPLY_MARKER = 'E2E_INTERRUPT_TOOL_REPLY:';
const MCP_APP_MARKER = 'E2E_MCP_APP:';
const MCP_APP_PHASE_MARKER = 'E2E_MCP_APP_PHASE:';
const MCP_LINK_APP_MARKER = 'E2E_MCP_LINK_APP:';
@@ -757,9 +758,19 @@ function replyResponses(text) {
* for the user row, then interrupts this whitespace-only stream. */
const emptySlowName = getMarkerValue(text, EMPTY_SLOW_REPLY_MARKER);
if (emptySlowName) {
+ let invocation = 0;
return {
- responses: [' '.repeat(EMPTY_SLOW_REPLY_CHUNKS)],
+ responses: [''],
sleep: SLOW_CHUNK_DELAY_MS,
+ resolveInvocation: async (messages) => {
+ invocation += 1;
+ return {
+ response:
+ invocation === 1
+ ? ' '.repeat(EMPTY_SLOW_REPLY_CHUNKS)
+ : `E2E empty reply continued ${emptySlowName} ${steerEchoSuffix(messages)}`,
+ };
+ },
};
}
@@ -1763,6 +1774,39 @@ function activityProseReplyResponses(label, toolNames) {
};
}
+function interruptToolReplyResponses(label, toolNames) {
+ const remember = Array.from(toolNames).find((name) => name.startsWith(STEER_TOOL_NAME_PREFIX));
+ const slow = Array.from(toolNames).find((name) => name.startsWith(SLOW_ECHO_TOOL_NAME_PREFIX));
+ if (!remember || !slow) return { responses: ['E2E interrupt tools unavailable'] };
+ let invocation = 0;
+ return {
+ responses: [''],
+ resolveInvocation: async (messages) => {
+ invocation += 1;
+ if (invocation === 1) {
+ return {
+ response: `E2E interrupt tools running ${label}`,
+ toolCalls: [
+ {
+ id: `call_interrupt_fast_${label}`,
+ name: remember,
+ args: { fact: `completed ${label}` },
+ type: 'tool_call',
+ },
+ {
+ id: `call_interrupt_slow_${label}`,
+ name: slow,
+ args: { text: `late ${label}`, delay_ms: 5000 },
+ type: 'tool_call',
+ },
+ ],
+ };
+ }
+ return { response: `E2E interrupt tool reply done ${label} ${steerEchoSuffix(messages)}` };
+ },
+ };
+}
+
/**
* A phase whose middle batch holds a failed call beside a slow one: `slow_echo`
* called without its required `text` fails schema validation before the tool
@@ -3383,6 +3427,9 @@ function resolveResponses({ graph, messages, text, toolNames }) {
return statefulCodeResponses(statefulCodeOperation, toolNames);
}
+ const interruptToolLabel = getMarkerValue(text, INTERRUPT_TOOL_REPLY_MARKER);
+ if (interruptToolLabel) return interruptToolReplyResponses(interruptToolLabel, toolNames);
+
const steerToolLabel = getMarkerValue(text, STEER_TOOL_REPLY_MARKER);
if (steerToolLabel) {
return steerToolReplyResponses(steerToolLabel, toolNames);
diff --git a/e2e/specs/mock/scenarios/composer-redesign.spec.ts b/e2e/specs/mock/scenarios/composer-redesign.spec.ts
index 712b15e278..9720d7862f 100644
--- a/e2e/specs/mock/scenarios/composer-redesign.spec.ts
+++ b/e2e/specs/mock/scenarios/composer-redesign.spec.ts
@@ -65,6 +65,7 @@ test.describe('composer redesign contracts', () => {
/* The send-now chord would queue as well, so the hint names only the queue. */
await expect(messageInput(page)).toHaveAccessibleDescription(/Enter queues/);
await expect(messageInput(page)).not.toHaveAccessibleDescription(/send now/i);
+ await expect(messageInput(page)).not.toHaveAccessibleDescription(/interrupt/i);
await page.getByTestId('during-run-send-button').click();
await expect(
page.getByTestId('queued-message-row').filter({ hasText: 'new turn after reasoning' }),
diff --git a/e2e/specs/mock/scenarios/queue-owners.spec.ts b/e2e/specs/mock/scenarios/queue-owners.spec.ts
index 05fc9de584..825c466af5 100644
--- a/e2e/specs/mock/scenarios/queue-owners.spec.ts
+++ b/e2e/specs/mock/scenarios/queue-owners.spec.ts
@@ -6,16 +6,11 @@ import {
sendMessage,
replyPrompt,
replyText,
- MOCK_REPLY_TEXT,
MOCK_ENDPOINTS,
NEW_CHAT_PATH,
} from '../helpers';
-/**
- * The follow-up queue, its run-end signals and the interrupt-drain flag are chat-owned Jotai
- * state. Queueing and draining are covered by the composer-queue scenarios; this one drives the
- * interrupt-drain flag through a real stopped run.
- */
+/** Interrupt preserves the response instead of draining a separate follow-up. */
const messageInput = (page: Page) => page.getByRole('textbox', { name: 'Message input' });
const duringRunSendButton = (page: Page) => page.getByTestId('during-run-send-button');
@@ -46,7 +41,7 @@ test.describe('chat-owned queue state', () => {
});
});
- test('interrupt and send stops the run and sends the follow-up next @scenario:interrupt-and-send-drains-the-follow-up', async ({
+ test('Interrupt continues the current response @scenario:interrupt-and-send-drains-the-follow-up', async ({
page,
}) => {
test.setTimeout(120000);
@@ -64,9 +59,10 @@ test.describe('chat-owned queue state', () => {
await typeDuringRun(page, followUp);
await messageInput(page).press('Alt+Enter');
- await expect(messageTurns(page)).toHaveCount(6, { timeout: 60000 });
- await expect(messageTurns(page).nth(4)).toContainText(followUp);
- await expect(messageTurns(page).nth(5)).toContainText(MOCK_REPLY_TEXT, { timeout: 30000 });
+ await expect(messagesView(page).getByText(`[steers-seen=1] ${followUp}`)).toBeVisible();
+ await expect(messageTurns(page)).toHaveCount(4);
+ await expect(messageTurns(page).nth(3)).toContainText(followUp);
+ await expect(messagesView(page).getByText('chunk-010')).toBeVisible();
await expect(messagesView(page).getByText('chunk-159')).toHaveCount(0);
});
});
diff --git a/e2e/specs/mock/steering-escalation.spec.ts b/e2e/specs/mock/steering-escalation.spec.ts
index c44ff9c064..afd77dfd93 100644
--- a/e2e/specs/mock/steering-escalation.spec.ts
+++ b/e2e/specs/mock/steering-escalation.spec.ts
@@ -5,6 +5,8 @@ import type { Page, Response } from '@playwright/test';
import {
MOCK_ENDPOINTS,
NEW_CHAT_PATH,
+ getAccessToken,
+ requestJson,
messagesView,
replyPrompt,
replyText,
@@ -79,19 +81,16 @@ async function expectModelContinuation(page: Page, label: string, steerText: str
* a real interrupt rather than relabelling a chip.
*/
test.describe('escalating waiting messages to an interrupt', () => {
- /* The composer ships with Enter queueing during a run; escalation rides the
- steer route, so pin the during-run default to steering. */
+ /** Pin Steer so the alternate shortcut queues. */
test.beforeEach(async ({ page }) => {
await page.addInitScript(() => {
- localStorage.setItem('duringRunDefaultAction', JSON.stringify('steer'));
+ localStorage.setItem('duringRunAction', JSON.stringify('steer'));
});
});
- /** `steerInterruptsByDefault` is a localStorage preference; the toggle test
- * flips it, and a mid-test failure must not leak preempt-by-default into
- * the rest of the serial suite. */
+ /** Reset the mode changed by the selector case. */
test.afterEach(async ({ page }) => {
- await page.evaluate(() => window.localStorage.removeItem('steerInterruptsByDefault'));
+ await page.evaluate(() => window.localStorage.removeItem('duringRunAction'));
});
test('queued row escalates as an interrupt: the message seals mid-stream instead of waiting for run end', async ({
@@ -259,10 +258,8 @@ test.describe('escalating waiting messages to an interrupt', () => {
});
}
- test('always-interrupt toggle in a waiting row menu makes plain Enter preempt', async ({
- page,
- }) => {
- test.setTimeout(150000);
+ test('the Interrupt default makes plain Enter preempt', async ({ page }) => {
+ test.setTimeout(45000);
const label = uniqueLabel('toggle');
const queueText = `Queued while toggling ${label}`;
const steerText = `Enter now interrupts ${label}`;
@@ -282,20 +279,16 @@ test.describe('escalating waiting messages to an interrupt', () => {
const row = queuedRows(page).filter({ hasText: queueText });
await expect(row).toBeVisible({ timeout: 10000 });
- // The during-run default lives in Settings > Chat as an ordinary switch.
await page.getByTestId('nav-user').click();
await page.getByRole('menuitem', { name: 'Settings' }).click();
await page.getByRole('tab', { name: 'Chat' }).click();
- const interruptToggle = page.getByRole('switch', {
- name: 'Steer sooner on Enter',
- });
- await expect(interruptToggle).toBeVisible({ timeout: 5000 });
- await interruptToggle.click();
- await expect(interruptToggle).toHaveAttribute('aria-checked', 'true');
+ const mode = page.getByTestId('duringRunAction');
+ await mode.click();
+ await page.getByRole('option', { name: 'Interrupt', exact: true }).click();
+ await expect(mode).toContainText('Interrupt');
await page.keyboard.press('Escape');
- // The toggle is live for the SAME run: plain Enter now routes the default
- // steer through the preempt path (the 202 carries the armed flag).
+ // The selected default applies to the current run.
await typeDuringRun(page, steerText);
const [steerResponse] = await Promise.all([
page.waitForResponse(isSteerRequest, { timeout: 15000 }),
@@ -312,6 +305,98 @@ test.describe('escalating waiting messages to an interrupt', () => {
await expectModelContinuation(page, label, steerText);
});
+ test('native-search runs explicitly retain unsupported Interrupt messages as Steer', async ({
+ page,
+ }) => {
+ const label = uniqueLabel('native-search');
+ const text = `Change direction ${label}`;
+ await page.goto(NEW_CHAT_PATH);
+ const token = await getAccessToken(page);
+ const agent = await requestJson<{ id: string }>(page, {
+ path: '/api/agents',
+ token,
+ method: 'POST',
+ body: {
+ name: `Native search ${label}`,
+ provider: 'Mock Provider A',
+ model: 'mock-model-a',
+ model_parameters: { web_search: true },
+ tools: [],
+ },
+ });
+ try {
+ await page.goto(`${NEW_CHAT_PATH}?agent_id=${encodeURIComponent(agent.id)}`);
+ await establishConversation(page, `native-setup-${label}`);
+ await sendMessage(page, `E2E_SLOW_REPLY:${label}`);
+ await expect(messagesView(page).getByText('chunk-010')).toBeVisible();
+ await typeDuringRun(page, text);
+ const [response] = await Promise.all([
+ page.waitForResponse(isSteerRequest),
+ messageInput(page).press('Alt+Enter'),
+ ]);
+ expect(response.status()).toBe(202);
+ expect((await response.json()).preempt).toBe(false);
+ await expect(
+ page
+ .getByRole('region', { name: 'Notifications (F8)' })
+ .getByText(/Interrupt is unavailable for this run/),
+ ).toBeVisible();
+ if (process.env.E2E_CAPTURE_DIR) {
+ mkdirSync(process.env.E2E_CAPTURE_DIR, { recursive: true });
+ await page.screenshot({
+ path: path.join(process.env.E2E_CAPTURE_DIR, 'native-interrupt-unavailable.png'),
+ animations: 'disabled',
+ });
+ }
+ const bubble = inFlightSteers(page).filter({ hasText: text });
+ await expect(bubble.getByTestId('steer-receipt')).toHaveAttribute(
+ 'data-receipt-state',
+ 'delivered',
+ );
+ await page.getByTestId('stop-generation-button').click();
+ } finally {
+ await requestJson(page, {
+ path: `/api/agents/${encodeURIComponent(agent.id)}`,
+ token,
+ method: 'DELETE',
+ });
+ }
+ });
+
+ test('Interrupt cancels a running foreground tool and continues the same response', async ({
+ page,
+ }) => {
+ const label = uniqueLabel('tool-interrupt');
+ const steerText = `Change direction ${label}`;
+ await page.goto(NEW_CHAT_PATH);
+ await selectMockEndpoint(page, { label: 'Mock Provider C', model: 'mock-model-c' });
+ await establishConversation(page, `tools-${label}`);
+ await page.getByRole('button', { name: 'Attach and tools' }).click();
+ const memory = page
+ .getByRole('dialog', { name: 'Attach and tools' })
+ .getByRole('button', { name: /^E2E Memory\b/ });
+ await memory.click();
+ await page.keyboard.press('Escape');
+ await sendMessage(page, `E2E_INTERRUPT_TOOL_REPLY:${label}`);
+ await expect(
+ messagesView(page).getByText(`E2E interrupt tools running ${label}`),
+ ).toBeVisible();
+ await typeDuringRun(page, steerText);
+ const [response] = await Promise.all([
+ page.waitForResponse(isSteerRequest),
+ messageInput(page).press('ControlOrMeta+Shift+Enter'),
+ ]);
+ expect(response.status()).toBe(202);
+ await expect(messagesView(page).getByText(`[steers-seen=1] ${steerText}`)).toBeVisible();
+ await messagesView(page)
+ .getByRole('button', { name: /^Ran 2 actions/ })
+ .click();
+ await expect(messagesView(page).getByText(/Cancellation was requested/)).toBeVisible();
+ await expect(messageTurns(page)).toHaveCount(4);
+ await page.waitForTimeout(5500);
+ await expect(messagesView(page).getByText(`E2E slow echo: late ${label}`)).toHaveCount(0);
+ });
+
test('the dedicated shortcut escalates the newest waiting steer from the keyboard', async ({
page,
}) => {
diff --git a/e2e/specs/mock/steering.spec.ts b/e2e/specs/mock/steering.spec.ts
index 0e4b80bbcf..a636a60cb4 100644
--- a/e2e/specs/mock/steering.spec.ts
+++ b/e2e/specs/mock/steering.spec.ts
@@ -679,7 +679,7 @@ test.describe('mid-run steering and queuing', () => {
await expect(followupReply.locator('.agent-turn')).toBeVisible();
});
- test('interrupt & send (Alt+Enter) stops the run and auto-sends the text as the next turn', async ({
+ test('Interrupt (Alt+Enter) keeps completed text and continues the same response', async ({
page,
}) => {
test.setTimeout(120000);
@@ -699,23 +699,20 @@ test.describe('mid-run steering and queuing', () => {
await typeDuringRun(page, interruptText);
await messageInput(page).press('Alt+Enter');
- // The abort settles and the text auto-sends as the next user turn.
- await expect(messageTurns(page)).toHaveCount(6, { timeout: 60000 });
- const interruptTurn = messageTurns(page).nth(4);
- await expect(interruptTurn).toContainText(interruptText);
- await expect(interruptTurn.locator('.user-turn')).toBeVisible();
-
- // The follow-up run streams its response into the LIVE view — no reload.
- const freshReply = messageTurns(page).nth(5);
- await expect(freshReply).toContainText(MOCK_REPLY_TEXT, { timeout: 30000 });
- await expect(freshReply.locator('.agent-turn')).toBeVisible();
+ await expect(appliedSteerParts(page).filter({ hasText: interruptText })).toHaveCount(1);
+ await expect(messageTurns(page)).toHaveCount(4);
+ await expect(messagesView(page).getByText('chunk-010')).toBeVisible();
+ await expect(messagesView(page).getByText(`[steers-seen=1] ${interruptText}`)).toBeVisible();
+ await expect(
+ messagesView(page).getByText(`${SLOW_REPLY_CONTINUATION_TEXT} ${label}`),
+ ).toBeVisible();
// The interrupted response was stopped mid-stream: its final chunk never
// arrived (an uninterrupted slow run always ends with it).
await expect(messagesView(page).getByText(SLOW_REPLY_LAST_CHUNK)).toHaveCount(0);
});
- test('interrupt & send drains after a created response with no persistable content', async ({
+ test('Interrupt restarts a silent attempt and preserves the response parent', async ({
page,
}) => {
test.setTimeout(120000);
@@ -754,27 +751,98 @@ test.describe('mid-run steering and queuing', () => {
.toBe(true);
await typeDuringRun(page, interruptText);
+ const [steerResponse] = await Promise.all([
+ page.waitForResponse(isSteerRequest),
+ messageInput(page).press('Alt+Enter'),
+ ]);
+ expect(steerResponse.status()).toBe(202);
+ await expect(messagesView(page).getByText(`E2E empty reply continued ${label}`)).toBeVisible();
+ await expect(messagesView(page).getByText(`[steers-seen=1] ${interruptText}`)).toBeVisible();
+ await expect(appliedSteerParts(page).filter({ hasText: interruptText })).toHaveCount(1);
+ await expect(messageTurns(page)).toHaveCount(4);
+
+ await expect
+ .poll(async () => {
+ const records = await requestJson<PersistedMessage[]>(page, {
+ path: messagesPath,
+ token: accessToken,
+ });
+ return records.some(
+ (message) =>
+ message.isCreatedByUser === false &&
+ message.unfinished !== true &&
+ JSON.stringify(message.content).includes(interruptText),
+ );
+ })
+ .toBe(true);
+ const persisted = await requestJson<PersistedMessage[]>(page, {
+ path: messagesPath,
+ token: accessToken,
+ });
+ const interruptedUser = persisted.find(
+ (message) => message.isCreatedByUser === true && message.text === emptyRunPrompt,
+ );
+ expect(interruptedUser).toBeTruthy();
+ const continued = persisted.find(
+ (message) =>
+ message.isCreatedByUser === false && message.parentMessageId === interruptedUser?.messageId,
+ );
+ expect(continued).toBeTruthy();
+ expect(continued?.unfinished).not.toBe(true);
+ expect(JSON.stringify(continued?.content)).toContain(interruptText);
+ await expect(queuedRows(page)).toHaveCount(0);
+ });
+
+ test('Stop preserves an empty response parent for the next turn', async ({ page }) => {
+ test.setTimeout(120000);
+ const label = uniqueLabel('stop-empty');
+ const emptyRunPrompt = `E2E_EMPTY_SLOW_REPLY:${label}`;
+ const interruptText = `Interrupt empty follow-up ${label}`;
+
+ await page.goto(NEW_CHAT_PATH, { timeout: 10000 });
+ await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);
+ await establishConversation(page, `interrupt-empty-setup-${label}`);
+
+ const conversationId = new URL(page.url()).pathname.split('/').pop();
+ expect(conversationId).toBeTruthy();
+ const accessToken = await getAccessToken(page);
+ const messagesPath = `/api/messages/${encodeURIComponent(conversationId as string)}`;
+
+ const run = await sendMessage(page, emptyRunPrompt);
+ expect(run.ok()).toBeTruthy();
+
+ /** BaseClient starts its user-row write only after `onStart` emitted
+ * `created`. Waiting for that row proves the server is in the exact
+ * created-but-still-whitespace state, without relying on a sleep. */
+ await expect
+ .poll(
+ async () => {
+ const persisted = await requestJson<PersistedMessage[]>(page, {
+ path: messagesPath,
+ token: accessToken,
+ });
+ return persisted.some(
+ (message) => message.isCreatedByUser === true && message.text === emptyRunPrompt,
+ );
+ },
+ { timeout: 30000 },
+ )
+ .toBe(true);
+
const [abortResponse] = await Promise.all([
page.waitForResponse(
(response) =>
response.request().method() === 'POST' &&
new URL(response.url()).pathname === '/api/agents/chat/abort',
- { timeout: 30000 },
),
- messageInput(page).press('Alt+Enter'),
+ page.getByTestId('stop-generation-button').click(),
]);
expect(abortResponse.ok()).toBeTruthy();
+ await expect(page.getByTestId('stop-generation-button')).toHaveCount(0);
+ await sendMessage(page, interruptText);
+ await expect(messageTurns(page)).toHaveCount(6);
+ await expect(messageTurns(page).nth(5)).toContainText(MOCK_REPLY_TEXT);
- // The abort FINAL releases the queued follow-up, which completes live.
- await expect(messageTurns(page)).toHaveCount(6, { timeout: 60000 });
- const followupTurn = messageTurns(page).nth(4);
- await expect(followupTurn).toContainText(interruptText);
- await expect(followupTurn.locator('.user-turn')).toBeVisible();
- await expect(messageTurns(page).nth(5)).toContainText(MOCK_REPLY_TEXT, { timeout: 30000 });
-
- /** The empty assistant is a durable parent, not merely the optimistic
- * row that the created handler rendered. Without that row an underscore
- * preliminary id can reject this same queued submission. */
const persisted = await requestJson<PersistedMessage[]>(page, {
path: messagesPath,
token: accessToken,
@@ -789,26 +857,11 @@ test.describe('mid-run steering and queuing', () => {
message.isCreatedByUser === false &&
message.parentMessageId === interruptedUser?.messageId,
),
- ).toMatchObject({
- content: [],
- unfinished: true,
- isCreatedByUser: false,
- });
+ ).toMatchObject({ content: [], unfinished: true });
await expect(queuedRows(page)).toHaveCount(0);
});
- /**
- * Interrupt & steer is the only path that can inject with NO tool boundary
- * ahead of it: the server asks the generating replica to seal the model
- * stream at the next provider-safe chunk, keeps the partial answer, and
- * resumes in the same message.
- *
- * The contrast with the two tests above IS the feature. `E2E_SLOW_REPLY`
- * streams pure text with no tools, so an ordinary steer there provably
- * degrades to a queued follow-up turn ("steer after the last tool boundary"
- * above), and interrupt & send discards the half-written answer entirely.
- * This path does neither: same absence of a boundary, opposite outcome.
- */
+ /** The other interrupt chord uses the same no-tool-boundary continuation. */
test('interrupt & steer (Cmd/Ctrl+Shift+Enter) seals mid-stream and injects with no tool boundary', async ({
page,
}) => {
diff --git a/packages/api/src/agents/__tests__/run-summarization.test.ts b/packages/api/src/agents/__tests__/run-summarization.test.ts
index 6cc6a8c7f0..86ed5ed27e 100644
--- a/packages/api/src/agents/__tests__/run-summarization.test.ts
+++ b/packages/api/src/agents/__tests__/run-summarization.test.ts
@@ -210,6 +210,8 @@ async function callAndCapture(
user?: IUser;
tenantId?: string;
requestBody?: Parameters<typeof createRun>[0]['requestBody'];
+ steering?: Parameters<typeof createRun>[0]['steering'];
+ customHandlers?: Parameters<typeof createRun>[0]['customHandlers'];
} = {},
) {
const agents = opts.agents ?? [makeAgent()];
@@ -230,6 +232,8 @@ async function callAndCapture(
user: opts.user,
tenantId: opts.tenantId,
requestBody: opts.requestBody,
+ steering: opts.steering,
+ customHandlers: opts.customHandlers,
streaming: true,
streamUsage: true,
});
@@ -5088,3 +5092,40 @@ describe('summarizeOnly resolution', () => {
expect(agents[1].summarizeOnly).toBeUndefined();
});
});
+
+describe('steering provider capabilities', () => {
+ it.each([
+ ['Anthropic search', { type: 'web_search_20250305', name: 'web_search' }],
+ ['Google search', { googleSearch: {} }],
+ ['OpenAI search', { type: 'web_search' }],
+ ['Google URL context', { urlContext: {} }],
+ ])('disables interruption before constructing a run with %s', async (_name, tool) => {
+ const disable = jest.fn(async () => undefined);
+ const handler = { handle: jest.fn() };
+ await callAndCapture({
+ agents: [makeAgent({ tools: [tool] })],
+ customHandlers: { on_tool_execute: handler },
+ steering: { hook: async () => ({}), preemption: { shouldPreempt: () => true, disable } },
+ });
+ expect(disable).toHaveBeenCalledTimes(1);
+ const config = jest.mocked(Run.create).mock.calls[0]?.[0];
+ expect(config?.preemption).toBeUndefined();
+ expect(config?.customHandlers?.on_tool_execute).toBe(handler);
+ });
+
+ it('keeps interruption for host-executed tools', async () => {
+ const disable = jest.fn(async () => undefined);
+ const tool = new DynamicStructuredTool({
+ name: 'web_search',
+ description: 'Host search',
+ schema: z.object({}),
+ func: async () => 'found it',
+ });
+ await callAndCapture({
+ agents: [makeAgent({ tools: [tool] })],
+ steering: { hook: async () => ({}), preemption: { shouldPreempt: () => true, disable } },
+ });
+ expect(disable).not.toHaveBeenCalled();
+ expect(jest.mocked(Run.create).mock.calls[0]?.[0].preemption).toBeDefined();
+ });
+});
diff --git a/packages/api/src/agents/handlers.ts b/packages/api/src/agents/handlers.ts
index acc99c7257..3044b2e229 100644
--- a/packages/api/src/agents/handlers.ts
+++ b/packages/api/src/agents/handlers.ts
@@ -55,6 +55,7 @@ import type {
} from './backgroundCompletion';
import type { ScheduleMCPExecution } from '~/schedules/authorization/execution';
import type { SkillFileRecord, PrimeSkillFilesResult } from './skillFiles';
+import type { InterruptibleToolBatchRequest } from './steering/tools';
import type { ArtifactDeliveryFailure } from '~/files/code';
import type { BackgroundToolResultState } from './harvest';
import type { SandboxTextReader } from '~/files/code/text';
@@ -149,6 +150,7 @@ import {
import { editConflictExcerptText, formatEditConflict, parseEditConflict } from '~/code/edits';
import { buildSkillPrimeMessage, isSkillFilePath, SKILL_FILE_PREFIX } from './skills';
import { resolveCallerCapabilityProjectionSnapshot } from './callerCapabilities';
+import { SteerToolInterrupt, interruptedToolResult } from './steering/tools';
import { BACKGROUND_TOOL_INVOCATION_CONFIG_KEY } from './invocation';
import { mergeCodeFilesIntoContext } from './codeFilesSession';
import { toolValidationFeedback } from './validationFeedback';
@@ -5672,6 +5674,7 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
resolve,
reject,
} = data;
+ const onResultAdmissionStart = (data as InterruptibleToolBatchRequest).onResultAdmissionStart;
const executionContext = (
data as ToolExecuteBatchRequest & { executionContext?: SubagentExecutionContext }
).executionContext;
@@ -6969,6 +6972,10 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
if (filteredArguments != null) {
return reportResult(filteredArguments);
}
+ if (runSignal?.reason instanceof SteerToolInterrupt) {
+ return reportResult(interruptedToolResult(tc.id));
+ }
+ onResultAdmissionStart?.(tc.id);
const pollContent = await runCheckBackgroundTask({
userId: backgroundUserId,
conversationId: backgroundConversationId,
@@ -7041,6 +7048,7 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
* ORIGINAL tool-call identity by the completion harvest. */
if (toolEndCallback && !(isCodeTask && pending.harvestStarted === true)) {
try {
+ onResultAdmissionStart?.(tc.id);
await toolEndCallback(
{
input: tc.args,
@@ -7226,6 +7234,10 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
persistBackgroundCodeResult == null
)
) {
+ if (runSignal?.reason instanceof SteerToolInterrupt) {
+ return reportResult(interruptedToolResult(tc.id));
+ }
+ onResultAdmissionStart?.(tc.id);
return reportResult(await dispatchBackgroundToolCall(tc));
}
@@ -7240,6 +7252,9 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
isFileAuthoringCall &&
typeof (tc.args as { path?: unknown }).path === 'string' &&
!(tc.args as { path: string }).path.startsWith(SKILL_FILE_PREFIX);
+ if (runSignal?.reason instanceof SteerToolInterrupt) {
+ return interruptedToolResult(tc.id);
+ }
let sandboxReadSucceeded = false;
if (
tc.name === Constants.SKILL_TOOL ||
@@ -7359,6 +7374,9 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
};
}
+ if (runSignal?.reason instanceof SteerToolInterrupt) {
+ return interruptedToolResult(tc.id);
+ }
const filteredOutput = filteredToolOutputResult(tc, req, {
content: handlerResult.content,
artifact: handlerResult.artifact,
@@ -7371,6 +7389,7 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
* and re-executed — the blocked output stays blank. */
if (toolEndCallback && handlerResult.errorMessage == null) {
try {
+ onResultAdmissionStart?.(tc.id);
await toolEndCallback(
{
input: tc.args,
@@ -7394,6 +7413,7 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
if (toolEndCallback && handlerResult.artifact) {
try {
+ onResultAdmissionStart?.(tc.id);
await toolEndCallback(
{
input: tc.args,
@@ -7583,7 +7603,11 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
eligiblePtcToolMap.keys(),
ptcReq,
),
- emit: emitPtcProgress,
+ emit: (event) => {
+ if (!(runSignal?.reason instanceof SteerToolInterrupt)) {
+ emitPtcProgress(event);
+ }
+ },
})
: eligiblePtcToolMap;
}
@@ -7625,6 +7649,10 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
...(runSignal != null && { signal: runSignal }),
} as Record<string, unknown>);
+ if (runSignal?.reason instanceof SteerToolInterrupt) {
+ return interruptedToolResult(tc.id);
+ }
+
/* Only sandbox-bound calls carry a runtime session hint, so
* this refreshes the prewarm module's warm window without
* inspecting tool names. */
@@ -7659,6 +7687,7 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
* and re-executed — the blocked output stays blank. */
if (toolEndCallback) {
try {
+ onResultAdmissionStart?.(tc.id);
await toolEndCallback(
{
input: tc.args,
@@ -7681,6 +7710,7 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
}
if (toolEndCallback) {
+ onResultAdmissionStart?.(tc.id);
await toolEndCallback(
{
input: tc.args,
diff --git a/packages/api/src/agents/run.ts b/packages/api/src/agents/run.ts
index 6548723bdc..0867a483e1 100644
--- a/packages/api/src/agents/run.ts
+++ b/packages/api/src/agents/run.ts
@@ -1,7 +1,7 @@
import { randomUUID } from 'crypto';
import { logger } from '@librechat/data-schemas';
import { ensureHandler } from '@langchain/core/callbacks/manager';
-import { Run, Providers, Constants, HookRegistry } from '@librechat/agents';
+import { Run, Providers, Constants, GraphEvents, HookRegistry } from '@librechat/agents';
import {
KnownEndpoints,
EModelEndpoint,
@@ -53,13 +53,13 @@ import type { CallbackHandlerMethods } from '@langchain/core/callbacks/base';
import type { ToolApprovalGrantStorage } from 'librechat-data-provider';
import type { BaseMessage } from '@librechat/agents/langchain/messages';
import type { Callbacks } from '@langchain/core/callbacks/manager';
+import type { TerminalSteerHook, SteerPreemption } from '~/agents/steering/runtime';
import type { ModelBoundChatModelCallback } from '~/middleware/modelBoundContent';
import type { ScheduledMCPPolicyError } from '~/schedules/authorization/policy';
import type { ScheduleMCPExecution } from '~/schedules/authorization/execution';
import type { ModelErrorTrackerCallback } from '~/agents/failures/tracker';
import type { ToolInputValidationError } from '~/agents/toolValidation';
import type { ResolvedToolApprovalHook } from '~/agents/hitl/hooks';
-import type { TerminalSteerHook } from '~/agents/steering/runtime';
import type { LangfuseTraceContext } from '~/langfuse/identity';
import type { ResolvedAlwaysApplySkill } from '~/agents/skills';
import type { CodeExecutionContext } from '~/agents/execution';
@@ -116,6 +116,7 @@ import { applyCustomHandoffPromptKeyCompatibility } from '~/agents/handoffPrompt
import { stripIntentFromToolRegistry, stripIntentFromToolDefinitions } from '~/agents/intent';
import { createAgentToolApprovalSession, bindRunToolApprovalSession } from './hitl/modes';
import { resolveConfigHeaders, resolveModelHeaders, mergeHeaders } from '~/utils/headers';
+import { interruptToolHandler, supportsRunInterruption } from '~/agents/steering/tools';
import { extractDefaultParams, resolveReasoningParams } from '~/endpoints/openai/llm';
import { getLLMConfig as getAnthropicLLMConfig } from '~/endpoints/anthropic/llm';
import { createScheduledMCPRunPolicy } from '~/schedules/authorization/run';
@@ -2287,7 +2288,7 @@ export async function createRun({
* (`createSteerPreemptPoll`). Threaded into `RunConfig.preemption`, which
* also makes the SDK reserve recursion-limit headroom for its seals.
*/
- preemption?: StreamPreemption;
+ preemption?: StreamPreemption & Partial<Pick<SteerPreemption, 'disable'>>;
};
/**
* Run-scoped tool-batch summary hook (PostToolBatch). Like steering, it
@@ -3025,11 +3026,25 @@ export async function createRun({
* runtime) — excess-property checks only apply to fresh literals. Inline
* the field at the call site once the dependency is bumped.
*/
+ let preemption = steering?.preemption;
+ if (preemption != null && !supportsRunInterruption(agentInputs)) {
+ await preemption.disable?.();
+ preemption = undefined;
+ }
+ const toolHandler = customHandlers?.[GraphEvents.ON_TOOL_EXECUTE];
+ const runHandlers =
+ toolHandler != null && preemption != null && isSteerPreemptSupported()
+ ? {
+ ...customHandlers,
+ [GraphEvents.ON_TOOL_EXECUTE]: interruptToolHandler(toolHandler, preemption),
+ }
+ : customHandlers;
+
const runConfig = {
runId: resolvedRunId,
graphConfig,
tokenCounter,
- customHandlers,
+ customHandlers: runHandlers,
initialSessions,
calibrationRatio,
fadingTier,
@@ -3119,8 +3134,7 @@ export async function createRun({
// Preemption is observation-only like the boundary hooks: the poll never
// mutates and the SDK refuses to seal unless a PreemptBoundary matcher is
// live, so gating both on the same capability keeps them in lockstep.
- ...(steering?.preemption != null &&
- isSteerPreemptSupported() && { preemption: steering.preemption }),
+ ...(preemption != null && isSteerPreemptSupported() && { preemption }),
// Stream circuit breakers (librechat.yaml endpoints.agents.maxToolCallArgBytes /
// maxDeltaEventsPerTurn). Omitted when unset so the SDK defaults apply: a runaway
// streamed tool-call argument aborts the run at 64 KiB, the per-turn delta event
diff --git a/packages/api/src/agents/steering/__tests__/runtime.spec.ts b/packages/api/src/agents/steering/__tests__/runtime.spec.ts
index a922838ce9..5f8bf5161f 100644
--- a/packages/api/src/agents/steering/__tests__/runtime.spec.ts
+++ b/packages/api/src/agents/steering/__tests__/runtime.spec.ts
@@ -24,6 +24,7 @@ import {
isSteerTerminalContinuationSupported,
} from '../runtime';
import type { TerminalSteerHookInput } from '../runtime';
+import { handleSteerRequest, handleSteerArm } from '../request';
jest.spyOn(console, 'log').mockImplementation();
@@ -921,6 +922,46 @@ describe('preempt wake channel', () => {
* falls back to the per-chunk poll rather than subscribing to a signal
* nothing reads.
*/
+ it('downgrades pre-armed messages before provider-hosted tools can execute', async () => {
+ const streamId = `provider-hosted-${Date.now()}`;
+ const job = await GenerationJobManager.createJob(streamId, 'user-1', undefined, {
+ initialMetadata: { preemptCapable: true },
+ });
+ await GenerationJobManager.steering.enqueue(streamId, {
+ ...buildSteer('s1', 'change direction'),
+ preempt: true,
+ });
+ await GenerationJobManager.requestPreempt(streamId, 's1', job.createdAt);
+ const poll = createSteerPreemptPoll(streamId, job.createdAt);
+ await poll.disable();
+ expect(poll.shouldPreempt()).toBe(false);
+ expect((await GenerationJobManager.getJob(streamId))?.metadata?.preemptCapable).toBe(false);
+ expect((await GenerationJobManager.steering.peek(streamId))[0].preempt).not.toBe(true);
+ expect(
+ await handleSteerArm({ id: 'user-1' }, { conversationId: streamId, steerId: 's1' }),
+ ).toMatchObject({ body: { armed: false, code: 'PREEMPT_UNSUPPORTED' } });
+ expect(
+ await handleSteerRequest(
+ { id: 'user-1' },
+ { conversationId: streamId, text: 'another message', preempt: true },
+ ),
+ ).toMatchObject({ status: 202, body: { preempt: false } });
+ });
+
+ it('cannot disable a replacement generation with a stale capability callback', async () => {
+ const streamId = `provider-replaced-${Date.now()}`;
+ const oldJob = await GenerationJobManager.createJob(streamId, 'user-1');
+ const oldPoll = createSteerPreemptPoll(streamId, oldJob.createdAt);
+ await GenerationJobManager.abortJob(streamId);
+ await new Promise((resolve) => setTimeout(resolve, 2));
+ const replacement = await GenerationJobManager.createJob(streamId, 'user-1', undefined, {
+ initialMetadata: { preemptCapable: true },
+ });
+ expect(replacement.createdAt).not.toBe(oldJob.createdAt);
+ await oldPoll.disable();
+ expect((await GenerationJobManager.getJob(streamId))?.metadata?.preemptCapable).toBe(true);
+ });
+
it('supplies the channel only when the SDK can act on it', async () => {
const streamId = `preempt-wake-probe-${Date.now()}`;
await GenerationJobManager.createJob(streamId, 'user-1');
diff --git a/packages/api/src/agents/steering/__tests__/tools.spec.ts b/packages/api/src/agents/steering/__tests__/tools.spec.ts
new file mode 100644
index 0000000000..688f407cf7
--- /dev/null
+++ b/packages/api/src/agents/steering/__tests__/tools.spec.ts
@@ -0,0 +1,431 @@
+import { z } from 'zod';
+import { Providers } from '@librechat/agents';
+import { DynamicStructuredTool } from '@librechat/agents/langchain/tools';
+import type { EventHandler, StreamPreemption, ToolExecuteBatchRequest } from '@librechat/agents';
+import type { BackgroundToolResultClaim } from '@librechat/data-schemas';
+import type { InterruptibleToolBatchRequest } from '../tools';
+import { SteerToolInterrupt, interruptToolHandler, supportsRunInterruption } from '../tools';
+import { CHECK_BACKGROUND_TASK_NAME } from '~/agents/background';
+import { createToolExecuteHandler } from '~/agents/handlers';
+
+function control() {
+ let requested = false;
+ const listeners = new Set<() => void>();
+ const preemption: StreamPreemption = {
+ shouldPreempt: () => requested,
+ subscribe: (wake) => {
+ listeners.add(wake);
+ if (requested) wake();
+ return () => listeners.delete(wake);
+ },
+ };
+ return {
+ preemption,
+ listeners,
+ wake: () => {
+ for (const wake of listeners) wake();
+ },
+ interrupt: () => {
+ requested = true;
+ for (const wake of listeners) wake();
+ },
+ };
+}
+
+function batch(overrides: Partial<ToolExecuteBatchRequest> = {}): ToolExecuteBatchRequest {
+ return {
+ toolCalls: [
+ { id: 'one', name: 'search', args: {} },
+ { id: 'two', name: 'search', args: {} },
+ ],
+ resolve: jest.fn(),
+ reject: jest.fn(),
+ ...overrides,
+ };
+}
+
+function pendingHandler() {
+ let request: ToolExecuteBatchRequest | undefined;
+ const handler: EventHandler = {
+ handle: jest.fn(async (_event, data) => {
+ request = data as ToolExecuteBatchRequest;
+ }),
+ };
+ return {
+ handler,
+ request: () => {
+ if (request == null) throw new Error('Tool handler was not called');
+ return request;
+ },
+ };
+}
+
+describe('interruptToolHandler', () => {
+ it('waits for tools during ordinary steering and ignores spurious wakes', async () => {
+ const { handler, request } = pendingHandler();
+ const state = control();
+ const input = batch();
+ const pending = interruptToolHandler(handler, state.preemption).handle(
+ 'on_tool_execute',
+ input,
+ );
+ state.wake();
+ expect(input.resolve).not.toHaveBeenCalled();
+ expect(request().signal?.aborted).toBe(false);
+ request().resolve([]);
+ await pending;
+ expect(state.listeners.size).toBe(0);
+ });
+
+ it('keeps completed results and cancels only the unfinished work without stopping the run', async () => {
+ const { handler, request } = pendingHandler();
+ const state = control();
+ const run = new AbortController();
+ const input = batch({ signal: run.signal });
+ const pending = interruptToolHandler(handler, state.preemption).handle(
+ 'on_tool_execute',
+ input,
+ );
+ const completed = { toolCallId: 'one', status: 'success' as const, content: 'found it' };
+ request().onResult?.(completed);
+ state.interrupt();
+ await pending;
+ expect(request().signal?.aborted).toBe(true);
+ expect(run.signal.aborted).toBe(false);
+ expect(input.resolve).toHaveBeenCalledWith([
+ completed,
+ expect.objectContaining({
+ toolCallId: 'two',
+ status: 'error',
+ errorMessage: expect.stringContaining('Do not repeat'),
+ }),
+ ]);
+ expect(state.listeners.size).toBe(0);
+ });
+
+ it('does not start a side effect when interruption is already armed', async () => {
+ const { handler } = pendingHandler();
+ const state = control();
+ state.interrupt();
+ const input = batch();
+ await interruptToolHandler(handler, state.preemption).handle('on_tool_execute', input);
+ expect(handler.handle).not.toHaveBeenCalled();
+ expect(input.resolve).toHaveBeenCalledTimes(1);
+ expect(state.listeners.size).toBe(0);
+ });
+
+ it('ignores late results and rejects after interruption', async () => {
+ const { handler, request } = pendingHandler();
+ const state = control();
+ const input = batch({ onResult: jest.fn() });
+ const pending = interruptToolHandler(handler, state.preemption).handle(
+ 'on_tool_execute',
+ input,
+ );
+ state.interrupt();
+ await pending;
+ const late = { toolCallId: 'two', status: 'success' as const, content: 'late' };
+ request().onResult?.(late);
+ request().resolve([late]);
+ request().reject(new Error('late error'));
+ expect(input.resolve).toHaveBeenCalledTimes(1);
+ expect(input.onResult).not.toHaveBeenCalled();
+ expect(input.reject).not.toHaveBeenCalled();
+ });
+
+ it('forwards normal failures and releases the subscription', async () => {
+ const { handler, request } = pendingHandler();
+ const state = control();
+ const input = batch();
+ const pending = interruptToolHandler(handler, state.preemption).handle(
+ 'on_tool_execute',
+ input,
+ );
+ const failure = new Error('failed');
+ request().reject(failure);
+ await expect(pending).rejects.toBe(failure);
+ expect(input.reject).toHaveBeenCalledWith(failure);
+ expect(state.listeners.size).toBe(0);
+ });
+
+ it('releases the subscription when Stop aborts the run', async () => {
+ const { handler } = pendingHandler();
+ const state = control();
+ const controller = new AbortController();
+ const input = batch({ signal: controller.signal });
+ const pending = interruptToolHandler(handler, state.preemption).handle(
+ 'on_tool_execute',
+ input,
+ );
+ const failure = new Error('Run stopped');
+ controller.abort(failure);
+ await expect(pending).rejects.toBe(failure);
+ expect(input.reject).toHaveBeenCalledWith(failure);
+ expect(state.listeners.size).toBe(0);
+ });
+
+ it('leaves independently controlled child executions alone', async () => {
+ const { handler } = pendingHandler();
+ const state = control();
+ const input = batch({
+ executionContext: {
+ rootRunId: 'root',
+ depth: 1,
+ ancestry: [],
+ hookSessionId: 'child',
+ },
+ });
+ await interruptToolHandler(handler, state.preemption).handle('on_tool_execute', input);
+ expect(handler.handle).toHaveBeenCalledWith('on_tool_execute', input, undefined, undefined);
+ expect(state.listeners.size).toBe(0);
+ });
+
+ it('keeps admitted output when a cancelled sibling reports a scope-abort failure', async () => {
+ const { handler, request } = pendingHandler();
+ const state = control();
+ const input = batch();
+ const pending = interruptToolHandler(handler, state.preemption).handle(
+ 'on_tool_execute',
+ input,
+ );
+ (request() as InterruptibleToolBatchRequest).onResultAdmissionStart?.('one');
+ state.interrupt();
+ request().reject(new SteerToolInterrupt());
+ expect(input.reject).not.toHaveBeenCalled();
+ expect(input.resolve).not.toHaveBeenCalled();
+ const completed = { toolCallId: 'one', status: 'success' as const, content: 'admitted output' };
+ request().onResult?.(completed);
+ await pending;
+ expect(input.resolve).toHaveBeenCalledWith([
+ completed,
+ expect.objectContaining({ toolCallId: 'two', status: 'error' }),
+ ]);
+ });
+
+ it('preserves a durable background result claimed while interruption is requested', async () => {
+ const state = control();
+ let finishClaim: ((claim: BackgroundToolResultClaim) => void) | undefined;
+ let started: (() => void) | undefined;
+ const ready = new Promise<void>((resolve) => {
+ started = resolve;
+ });
+ const settleClaimed = jest.fn(async () => true);
+ const handler = createToolExecuteHandler({
+ loadTools: async () => ({ loadedTools: [] }),
+ backgroundToolCompletion: {
+ persist: async () => true,
+ claim: async () => {
+ started?.();
+ return new Promise<BackgroundToolResultClaim>((resolve) => {
+ finishClaim = resolve;
+ });
+ },
+ pending: {
+ list: async () => ({ completions: [], dead: [], complete: true }),
+ listSubagentWakeups: async () => ({ taskIds: [], complete: true }),
+ discard: async () => 'not_pending',
+ settleClaimed,
+ },
+ },
+ });
+ const input = batch({
+ toolCalls: [
+ {
+ id: 'poll',
+ name: CHECK_BACKGROUND_TASK_NAME,
+ args: { background_task_id: 'durable-task' },
+ },
+ ],
+ configurable: {
+ req: { user: { id: 'owner' }, body: { conversationId: 'thread' } },
+ backgroundToolNames: ['search'],
+ },
+ metadata: { thread_id: 'thread', run_id: 'root-run' },
+ });
+ const pending = interruptToolHandler(handler, state.preemption).handle(
+ 'on_tool_execute',
+ input,
+ );
+ await ready;
+ state.interrupt();
+ expect(input.resolve).not.toHaveBeenCalled();
+ finishClaim?.({
+ status: 'acquired',
+ results: [
+ {
+ taskId: 'durable-task',
+ toolCallId: 'original',
+ toolName: 'search',
+ status: 'completed',
+ output: 'CLAIMED RESULT',
+ },
+ ],
+ });
+ await pending;
+ expect(settleClaimed).toHaveBeenCalledTimes(1);
+ expect(input.resolve).toHaveBeenCalledWith([
+ expect.objectContaining({
+ status: 'success',
+ content: expect.stringContaining('CLAIMED RESULT'),
+ }),
+ ]);
+ expect(state.listeners.size).toBe(0);
+ });
+
+ it('does not acquire background ownership after interruption during tool loading', async () => {
+ const state = control();
+ let finishLoad: (() => void) | undefined;
+ let started: (() => void) | undefined;
+ const ready = new Promise<void>((resolve) => {
+ started = resolve;
+ });
+ const claim = jest.fn(async () => ({ status: 'not_ready' as const }));
+ const handler = createToolExecuteHandler({
+ loadTools: async () => {
+ started?.();
+ await new Promise<void>((resolve) => {
+ finishLoad = resolve;
+ });
+ return { loadedTools: [] };
+ },
+ backgroundToolCompletion: { persist: async () => true, claim },
+ });
+ const input = batch({
+ toolCalls: [
+ {
+ id: 'poll',
+ name: CHECK_BACKGROUND_TASK_NAME,
+ args: { background_task_id: 'unclaimed-task' },
+ },
+ ],
+ configurable: {
+ req: { user: { id: 'owner' }, body: { conversationId: 'thread' } },
+ backgroundToolNames: ['search'],
+ },
+ metadata: { thread_id: 'thread', run_id: 'root-run' },
+ });
+ const pending = interruptToolHandler(handler, state.preemption).handle(
+ 'on_tool_execute',
+ input,
+ );
+ await ready;
+ state.interrupt();
+ await pending;
+ finishLoad?.();
+ await new Promise((resolve) => setImmediate(resolve));
+ expect(claim).not.toHaveBeenCalled();
+ expect(input.resolve).toHaveBeenCalledTimes(1);
+ });
+
+ it('waits for admitted artifact validation and preserves the successful result', async () => {
+ const state = control();
+ let release: (() => void) | undefined;
+ let start: (() => void) | undefined;
+ const ready = new Promise<void>((resolve) => {
+ start = resolve;
+ });
+ const publications: string[] = [];
+ const tool = new DynamicStructuredTool({
+ name: 'search',
+ description: 'Search',
+ schema: z.object({}),
+ responseFormat: 'content_and_artifact',
+ func: async () => ['completed output', { files: [] }],
+ });
+ const handler = createToolExecuteHandler({
+ loadTools: async () => ({ loadedTools: [tool] }),
+ toolEndCallback: async () => {
+ start?.();
+ await new Promise<void>((resolve) => {
+ release = resolve;
+ });
+ publications.push('file');
+ },
+ });
+ const input = batch({ toolCalls: [{ id: 'one', name: 'search', args: {} }] });
+ const pending = interruptToolHandler(handler, state.preemption).handle(
+ 'on_tool_execute',
+ input,
+ );
+ await ready;
+ state.interrupt();
+ expect(input.resolve).not.toHaveBeenCalled();
+ release?.();
+ await pending;
+ expect(publications).toEqual(['file']);
+ expect(input.resolve).toHaveBeenCalledWith([
+ expect.objectContaining({
+ toolCallId: 'one',
+ status: 'success',
+ content: 'completed output',
+ }),
+ ]);
+ expect(state.listeners.size).toBe(0);
+ });
+
+ it('cancels a real tool invocation and suppresses artifacts from a tool that ignores cancellation', async () => {
+ const state = control();
+ let finish: (() => void) | undefined;
+ let signal: AbortSignal | undefined;
+ let started: (() => void) | undefined;
+ const ready = new Promise<void>((resolve) => {
+ started = resolve;
+ });
+ const tool = new DynamicStructuredTool({
+ name: 'search',
+ description: 'Search',
+ schema: z.object({}),
+ responseFormat: 'content_and_artifact',
+ func: async (_input, _manager, config) => {
+ signal = config?.signal;
+ started?.();
+ await new Promise<void>((resolve) => {
+ finish = resolve;
+ });
+ return ['late result', { files: [] }];
+ },
+ });
+ const callback = jest.fn();
+ const handler = createToolExecuteHandler({
+ loadTools: async () => ({ loadedTools: [tool] }),
+ toolEndCallback: callback,
+ });
+ const input = batch({ toolCalls: [{ id: 'one', name: 'search', args: {} }] });
+ const pending = interruptToolHandler(handler, state.preemption).handle(
+ 'on_tool_execute',
+ input,
+ );
+ await ready;
+ state.interrupt();
+ await pending;
+ expect(signal?.aborted).toBe(true);
+ finish?.();
+ await new Promise((resolve) => setImmediate(resolve));
+ expect(callback).not.toHaveBeenCalled();
+ expect(input.resolve).toHaveBeenCalledTimes(1);
+ expect(input.reject).not.toHaveBeenCalled();
+ });
+});
+
+describe('supportsRunInterruption', () => {
+ it('gates provider search plugins that do not expose tool definitions', () => {
+ expect(
+ supportsRunInterruption([
+ {
+ provider: Providers.OPENAI,
+ agentId: 'agent',
+ clientOptions: { modelKwargs: { plugins: [{ id: 'web' }] } },
+ },
+ ]),
+ ).toBe(false);
+ expect(
+ supportsRunInterruption([
+ {
+ provider: Providers.OPENAI,
+ agentId: 'agent',
+ clientOptions: { modelKwargs: { plugins: [{ id: 'other' }] } },
+ },
+ ]),
+ ).toBe(true);
+ });
+});
diff --git a/packages/api/src/agents/steering/runtime.ts b/packages/api/src/agents/steering/runtime.ts
index 264b2564da..017f90496f 100644
--- a/packages/api/src/agents/steering/runtime.ts
+++ b/packages/api/src/agents/steering/runtime.ts
@@ -338,9 +338,22 @@ export function createSteerTerminalContinuationHook(
* is: a run wired to a generation that has since been replaced must not be
* woken by the replacement's arms.
*/
-export function createSteerPreemptPoll(streamId: string, jobCreatedAt?: number): StreamPreemption {
+export interface SteerPreemption extends StreamPreemption {
+ /** Restrict owner-recorded capability before a provider-hosted tool can start. */
+ disable: () => Promise<void>;
+}
+
+export function createSteerPreemptPoll(streamId: string, jobCreatedAt?: number): SteerPreemption {
+ let enabled = true;
return {
- shouldPreempt: () => GenerationJobManager.isPreemptRequested(streamId),
+ shouldPreempt: () => enabled && GenerationJobManager.isPreemptRequested(streamId),
+ disable: async () => {
+ enabled = false;
+ await GenerationJobManager.updateMetadata(streamId, { preemptCapable: false }, jobCreatedAt);
+ if (jobCreatedAt != null) {
+ await GenerationJobManager.rearmQueuedPreempts(streamId, jobCreatedAt);
+ }
+ },
...(isSteerPreemptRestartSupported() && {
subscribe: (wake: () => void) =>
GenerationJobManager.subscribePreempt(streamId, wake, jobCreatedAt),
diff --git a/packages/api/src/agents/steering/tools.ts b/packages/api/src/agents/steering/tools.ts
new file mode 100644
index 0000000000..88f493d606
--- /dev/null
+++ b/packages/api/src/agents/steering/tools.ts
@@ -0,0 +1,133 @@
+import type {
+ ToolExecuteBatchRequest,
+ ToolExecuteResult,
+ StreamPreemption,
+ EventHandler,
+ AgentInputs,
+} from '@librechat/agents';
+
+/** The pinned SDK cannot cancel unanswered provider-hosted tools without orphaning them. */
+export function supportsRunInterruption(agents: readonly AgentInputs[]): boolean {
+ return agents.every((agent) => {
+ if (agent.tools?.some((tool) => !('invoke' in tool) || typeof tool.invoke !== 'function'))
+ return false;
+ const plugins = (
+ agent.clientOptions as { modelKwargs?: { plugins?: Array<{ id?: string }> } } | undefined
+ )?.modelKwargs?.plugins;
+ return !plugins?.some((plugin) => plugin.id === 'web');
+ });
+}
+
+/** Host-only admission channel for durable claims and completed-output validation. */
+export interface InterruptibleToolBatchRequest extends ToolExecuteBatchRequest {
+ onResultAdmissionStart?: (toolCallId: string) => void;
+}
+
+const INTERRUPTED =
+ 'Interrupted by a user message. Cancellation was requested; external effects may already have occurred. Do not repeat this operation automatically.';
+
+export class SteerToolInterrupt extends Error {
+ constructor() {
+ super('Interrupted by a user message');
+ this.name = 'AbortError';
+ }
+}
+
+export function interruptedToolResult(toolCallId: string): ToolExecuteResult {
+ return { toolCallId, status: 'error', content: '', errorMessage: INTERRUPTED };
+}
+
+/** Cancel the batch, not the run: its PostToolBatch hook still injects the steer. */
+export function interruptToolHandler(
+ handler: EventHandler,
+ preemption: StreamPreemption,
+): EventHandler {
+ return {
+ handle: async (event: string, data: ToolExecuteBatchRequest, metadata, graph) => {
+ if (data.executionContext != null || preemption.subscribe == null) {
+ return handler.handle(event, data, metadata, graph);
+ }
+ const controller = new AbortController();
+ const signal =
+ data.signal == null ? controller.signal : AbortSignal.any([data.signal, controller.signal]);
+ const completed = new Map<string, ToolExecuteResult>();
+ const admitted = new Set<string>();
+ let interrupted = false;
+ let settled = false;
+ let unsubscribe: (() => void) | undefined;
+ let onAbort: (() => void) | undefined;
+ await new Promise<void>((resolve, reject) => {
+ const finish = (results: ToolExecuteResult[]) => {
+ if (settled) return;
+ settled = true;
+ try {
+ data.resolve(results);
+ resolve();
+ } catch (error) {
+ reject(error);
+ }
+ };
+ const fail = (error: Error) => {
+ if (settled) return;
+ if (interrupted && error instanceof SteerToolInterrupt && !data.signal?.aborted) {
+ finishInterrupt();
+ return;
+ }
+ settled = true;
+ data.reject(error);
+ reject(error);
+ };
+ const finishInterrupt = () => {
+ if (!interrupted || admitted.size > 0) return;
+ finish(
+ data.toolCalls.map((call) => completed.get(call.id) ?? interruptedToolResult(call.id)),
+ );
+ };
+ const interrupt = () => {
+ if (settled || interrupted || data.signal?.aborted || !preemption.shouldPreempt()) return;
+ interrupted = true;
+ controller.abort(new SteerToolInterrupt());
+ finishInterrupt();
+ };
+ onAbort = () =>
+ fail(
+ data.signal?.reason instanceof Error
+ ? data.signal.reason
+ : new DOMException('Run aborted', 'AbortError'),
+ );
+ data.signal?.addEventListener('abort', onAbort, { once: true });
+ if (data.signal?.aborted) {
+ onAbort();
+ return;
+ }
+ unsubscribe = preemption.subscribe?.(interrupt);
+ interrupt();
+ if (settled) return;
+ const request: InterruptibleToolBatchRequest = {
+ ...data,
+ signal,
+ resolve: (results) => (interrupted ? finishInterrupt() : finish(results)),
+ reject: fail,
+ onResultAdmissionStart: (toolCallId) => {
+ if (!settled && !interrupted) admitted.add(toolCallId);
+ },
+ onResult: (result) => {
+ if (settled || (interrupted && !admitted.has(result.toolCallId))) return;
+ completed.set(result.toolCallId, result);
+ admitted.delete(result.toolCallId);
+ data.onResult?.(result);
+ finishInterrupt();
+ },
+ };
+ try {
+ Promise.resolve(handler.handle(event, request, metadata, graph)).catch(fail);
+ } catch (error) {
+ fail(error instanceof Error ? error : new Error('Tool execution failed'));
+ }
+ }).finally(() => {
+ unsubscribe?.();
+ if (onAbort != null) data.signal?.removeEventListener('abort', onAbort);
+ });
+ },
+ };
+}