@nextclaw/ui 0.19.2 → 0.19.4

package/src/features/chat/features/conversation/hooks/__tests__/use-session-conversation-controller.test.tsx

@@ -60,6 +60,7 @@ function createControllerParams(params: {
     queuedInputs.find((item) => item.id === id) ?? null,
   );
   const refreshQueuedInputs = vi.fn(async () => queuedInputs);
+  const steerQueuedInput = vi.fn(async () => null);
   return {
     agent: {
       abort: vi.fn(),
@@ -119,6 +120,7 @@ function createControllerParams(params: {
       inputs: queuedInputs,
       refreshQueuedInputs,
       removeQueuedInput,
+      steerQueuedInput,
     },
     selectedAgentId: 'main',
     sessionKey: 'session-1',
@@ -172,6 +174,7 @@ describe('useSessionConversationController backend run queue', () => {
 
     expect(send).toHaveBeenCalledTimes(1);
     expect(send.mock.calls[0]?.[0]).toMatchObject({
+      delivery: 'queue',
       sessionId: 'session-1',
       message: expect.objectContaining({
         parts: [{ type: 'text', text: 'next task' }],
@@ -180,6 +183,22 @@ describe('useSessionConversationController backend run queue', () => {
     expect(params.resetComposer).toHaveBeenCalledTimes(1);
   });
 
+  it('uses prefer-steer for command/control-enter submission without changing the send button path', async () => {
+    const send = createSendMock(createRunHandle({ delivery: 'steered' }));
+    const params = createControllerParams({ isRunning: true, send });
+    const { result } = renderHook(() => useSessionConversationController(params));
+
+    await act(async () => {
+      await result.current.sendSteering();
+    });
+
+    expect(send.mock.calls[0]?.[0]).toMatchObject({
+      delivery: 'prefer-steer',
+      message: { parts: [{ type: 'text', text: 'next task' }] },
+    });
+    expect(result.current.queuedInputs).toEqual([]);
+  });
+
   it('sends a preset message without clearing the existing composer draft', async () => {
     const send = createSendMock();
     const params = createControllerParams({ isRunning: false, send });
@@ -249,7 +268,7 @@ describe('useSessionConversationController backend run queue', () => {
     expect(params.runQueue.refreshQueuedInputs).not.toHaveBeenCalled();
 
     await act(async () => {
-      resolveSend(createRunHandle({ runId: null }));
+      resolveSend(createRunHandle({ delivery: 'queued', runId: null }));
       await submission;
     });
 
@@ -303,6 +322,8 @@ describe('useSessionConversationController backend run queue', () => {
   it('projects the backend queue and returns a removed item to the composer for editing', async () => {
     const queuedInput = createQueuedInput();
     const params = createControllerParams({ isRunning: true, queuedInputs: [queuedInput] });
+    params.inputSnapshot.nodes = [];
+    params.inputSnapshot.text = '';
     const { result } = renderHook(() => useSessionConversationController(params));
 
     expect(result.current.queuedInputs).toEqual([
@@ -321,6 +342,19 @@ describe('useSessionConversationController backend run queue', () => {
     }));
   });
 
+  it('keeps the queued item unchanged when the composer already contains a draft', () => {
+    const queuedInput = createQueuedInput();
+    const params = createControllerParams({ isRunning: true, queuedInputs: [queuedInput] });
+    const { result } = renderHook(() => useSessionConversationController(params));
+
+    act(() => result.current.editQueuedInput(queuedInput.id));
+
+    expect(result.current.canEditQueuedInput).toBe(false);
+    expect(params.runQueue.removeQueuedInput).not.toHaveBeenCalled();
+    expect(params.restoreComposer).not.toHaveBeenCalled();
+    expect(params.setSendError).toHaveBeenCalledWith(expect.any(String));
+  });
+
   it('deletes through the backend queue owner without restoring the composer', async () => {
     const queuedInput = createQueuedInput();
     const params = createControllerParams({ isRunning: true, queuedInputs: [queuedInput] });

package/src/features/chat/features/conversation/hooks/__tests__/use-session-run-queue.test.tsx

@@ -2,19 +2,25 @@ import type { ReactNode } from 'react';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { act, renderHook, waitFor } from '@testing-library/react';
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import { eventKeys, type UiNcpSessionQueuedInputsView } from '@nextclaw/client-sdk';
+import {
+  eventKeys,
+  type UiNcpSessionPendingInputsView,
+  type UiNcpSessionQueuedInputView,
+} from '@nextclaw/client-sdk';
 
 import { useSessionRunQueue } from '@/features/chat/features/conversation/hooks/use-session-run-queue';
 import { nextclawClient } from '@/shared/lib/api';
 
-function createQueue(sessionId: string, text: string): UiNcpSessionQueuedInputsView {
+function createQueue(sessionId: string, text: string): UiNcpSessionPendingInputsView {
   return {
     sessionId,
     inputs: [{
       id: `queued-${sessionId}`,
   sessionId,
   enqueuedAt: '2026-07-22T10:00:00.000Z',
-  metadata: {},
+      metadata: {},
+      placement: 'queued',
+      intendedRunId: null,
   message: {
         id: `message-${sessionId}`,
         sessionId,
@@ -42,7 +48,7 @@ describe('useSessionRunQueue', () => {
   });
 
   it('keys backend queue data by session instead of sharing one frontend queue', async () => {
-    vi.spyOn(nextclawClient.sessions, 'listQueuedInputs').mockImplementation(async (sessionId) =>
+    vi.spyOn(nextclawClient.sessions, 'listPendingInputs').mockImplementation(async (sessionId) =>
       createQueue(sessionId, sessionId === 'session-1' ? 'first session' : 'second session'),
     );
     const { result, rerender } = renderHook(
@@ -53,18 +59,18 @@ describe('useSessionRunQueue', () => {
     await waitFor(() => expect(result.current.inputs[0]?.message.parts[0]).toMatchObject({ text: 'first session' }));
     rerender({ sessionKey: 'session-2' });
     await waitFor(() => expect(result.current.inputs[0]?.message.parts[0]).toMatchObject({ text: 'second session' }));
-    expect(nextclawClient.sessions.listQueuedInputs).toHaveBeenCalledWith('session-1');
-    expect(nextclawClient.sessions.listQueuedInputs).toHaveBeenCalledWith('session-2');
+    expect(nextclawClient.sessions.listPendingInputs).toHaveBeenCalledWith('session-1');
+    expect(nextclawClient.sessions.listPendingInputs).toHaveBeenCalledWith('session-2');
   });
 
   it('refetches only when the matching session queue changes', async () => {
-    const listQueuedInputs = vi.spyOn(nextclawClient.sessions, 'listQueuedInputs')
+    const listPendingInputs = vi.spyOn(nextclawClient.sessions, 'listPendingInputs')
       .mockResolvedValue(createQueue('session-1', 'queued'));
     const { unmount } = renderHook(
       () => useSessionRunQueue('session-1'),
       { wrapper: createWrapper() },
     );
-    await waitFor(() => expect(listQueuedInputs).toHaveBeenCalledTimes(1));
+    await waitFor(() => expect(listPendingInputs).toHaveBeenCalledTimes(1));
 
     act(() => {
       nextclawClient.eventBus.emit(eventKeys.sessionRunQueueUpdated, {
@@ -72,55 +78,55 @@ describe('useSessionRunQueue', () => {
       });
     });
     await new Promise((resolve) => setTimeout(resolve, 0));
-    expect(listQueuedInputs).toHaveBeenCalledTimes(1);
+    expect(listPendingInputs).toHaveBeenCalledTimes(1);
 
     act(() => {
       nextclawClient.eventBus.emit(eventKeys.sessionRunQueueUpdated, {
         sessionKey: 'session-1',
       });
     });
-    await waitFor(() => expect(listQueuedInputs).toHaveBeenCalledTimes(2));
+    await waitFor(() => expect(listPendingInputs).toHaveBeenCalledTimes(2));
     unmount();
   });
 
   it('refreshes the authoritative queue on demand after a submission is accepted', async () => {
-    const listQueuedInputs = vi.spyOn(nextclawClient.sessions, 'listQueuedInputs')
+    const listPendingInputs = vi.spyOn(nextclawClient.sessions, 'listPendingInputs')
       .mockResolvedValue(createQueue('session-1', 'queued'));
     const { result } = renderHook(
       () => useSessionRunQueue('session-1'),
       { wrapper: createWrapper() },
     );
-    await waitFor(() => expect(listQueuedInputs).toHaveBeenCalledTimes(1));
+    await waitFor(() => expect(listPendingInputs).toHaveBeenCalledTimes(1));
 
-    let refreshed: UiNcpSessionQueuedInputsView['inputs'] = [];
+    let refreshed: UiNcpSessionQueuedInputView[] = [];
     await act(async () => {
       refreshed = [...await result.current.refreshQueuedInputs()];
     });
 
-    expect(listQueuedInputs).toHaveBeenCalledTimes(2);
+    expect(listPendingInputs).toHaveBeenCalledTimes(2);
     expect(refreshed[0]?.message.parts[0]).toMatchObject({ text: 'queued' });
   });
 
   it('replaces an in-flight stale queue read after the queue changes', async () => {
-    let resolveInitialRead!: (queue: UiNcpSessionQueuedInputsView) => void;
-    const initialRead = new Promise<UiNcpSessionQueuedInputsView>((resolve) => {
+    let resolveInitialRead!: (queue: UiNcpSessionPendingInputsView) => void;
+    const initialRead = new Promise<UiNcpSessionPendingInputsView>((resolve) => {
       resolveInitialRead = resolve;
     });
-    const listQueuedInputs = vi.spyOn(nextclawClient.sessions, 'listQueuedInputs')
+    const listPendingInputs = vi.spyOn(nextclawClient.sessions, 'listPendingInputs')
       .mockImplementationOnce(async () => await initialRead)
       .mockResolvedValue({ sessionId: 'session-1', inputs: [] });
     const { result } = renderHook(
       () => useSessionRunQueue('session-1'),
       { wrapper: createWrapper() },
     );
-    await waitFor(() => expect(listQueuedInputs).toHaveBeenCalledTimes(1));
+    await waitFor(() => expect(listPendingInputs).toHaveBeenCalledTimes(1));
 
     act(() => {
       nextclawClient.eventBus.emit(eventKeys.sessionRunQueueUpdated, {
         sessionKey: 'session-1',
       });
     });
-    await waitFor(() => expect(listQueuedInputs).toHaveBeenCalledTimes(2));
+    await waitFor(() => expect(listPendingInputs).toHaveBeenCalledTimes(2));
 
     await act(async () => {
       resolveInitialRead(createQueue('session-1', 'stale queued input'));

package/src/features/chat/features/conversation/hooks/use-session-conversation-controller.ts

@@ -1,6 +1,9 @@
-import { useCallback, useMemo, useState } from 'react';
+import { useCallback, useMemo } from 'react';
 import { buildNcpRequestEnvelope } from '@nextclaw/ncp-react';
-import type { UiNcpSessionQueuedInputView } from '@nextclaw/client-sdk';
+import type {
+  UiNcpSessionPendingInputView,
+  UiNcpSessionQueuedInputView,
+} from '@nextclaw/client-sdk';
 import type { NcpAgentSendEnvelope, NcpRunHandle } from '@nextclaw/ncp';
 
 import {
@@ -10,12 +13,14 @@ import {
 import { isNcpChatSendDisabled } from '@/features/chat/features/input/utils/ncp-chat-input-availability.utils';
 import { buildChatRunMetadata } from '@/features/chat/features/session/utils/chat-run-metadata.utils';
 import { createNcpSessionId } from '@/features/chat/features/session/utils/ncp-session-adapter.utils';
-import {
-  buildSessionQueuedInputComposerSnapshot,
-  buildSessionQueuedInputPreview,
-} from '@/features/chat/features/conversation/utils/session-queued-input.utils';
+import type { SessionQueuedInputAttachmentPreview } from '@/features/chat/features/conversation/utils/session-queued-input.utils';
 import type { SessionConversationInputSnapshot } from './use-session-conversation-input-state';
 import type { useSessionConversationInputQuery } from './use-session-conversation-input-query';
+import {
+  useQueuedInputActions,
+  useSubmittingQueuedInputProjection,
+  type SubmittingQueuedInput,
+} from './use-session-pending-input-actions';
 import {
   useSessionConversationRecoveryActions,
   type SessionConversationRecoveryAgent,
@@ -41,6 +46,7 @@ type SessionConversationAgent = SessionConversationRecoveryAgent & {
 };
 
 export type SessionConversationQueuedInput = {
+  readonly attachments?: readonly SessionQueuedInputAttachmentPreview[];
   readonly id: string;
   readonly isSubmitting?: boolean;
   readonly preview: string;
@@ -52,6 +58,9 @@ type SessionRunQueue = {
   readonly removeQueuedInput: (
     queuedInputId: string,
   ) => Promise<UiNcpSessionQueuedInputView | null>;
+  readonly steerQueuedInput: (
+    queuedInputId: string,
+  ) => Promise<UiNcpSessionPendingInputView | null>;
 };
 
 export type SessionConversationMaterializationContext = {
@@ -93,13 +102,6 @@ type SubmissionDraft = {
 
 type SubmissionComposerBehavior = 'preserve' | 'reset-and-restore';
 
-type SubmittingQueuedInput = {
-  readonly id: string;
-  readonly preview: string;
-  readonly sessionId: string;
-  readonly userMessageId: string;
-};
-
 const hasSendableMessagePart = (parts: ReturnType<typeof deriveNcpMessagePartsFromComposer>): boolean =>
   parts.some((part) => part.type !== 'text' || part.text.trim().length > 0);
 
@@ -191,8 +193,9 @@ function buildSubmissionDraft(params: BuildSubmissionDraftParams): SubmissionDra
 function buildSubmissionEnvelope(
   draft: SubmissionDraft,
   sessionKey: string | null,
+  delivery: NcpAgentSendEnvelope['delivery'] = 'queue',
 ): NcpAgentSendEnvelope | null {
-  return buildNcpRequestEnvelope({
+  const envelope = buildNcpRequestEnvelope({
     sessionId: sessionKey ?? undefined,
     text: draft.composerSnapshot.text.trim(),
     attachments: [...draft.composerSnapshot.attachments],
@@ -202,97 +205,7 @@ function buildSubmissionEnvelope(
     ),
     metadata: draft.metadata,
   });
-}
-
-function buildSubmittingQueuedInput(
-  envelope: NcpAgentSendEnvelope,
-): SubmittingQueuedInput | null {
-  const sessionId = envelope.sessionId?.trim();
-  if (!sessionId) {
-    return null;
-  }
-  const message = {
-    ...envelope.message,
-    sessionId,
-  };
-  const enqueuedAt = new Date().toISOString();
-  const input: UiNcpSessionQueuedInputView = {
-    id: `submitting-${message.id}`,
-    sessionId,
-    enqueuedAt,
-    message,
-    metadata: structuredClone(envelope.metadata ?? {}),
-  };
-  return {
-    id: input.id,
-    preview: buildSessionQueuedInputPreview(input),
-    sessionId,
-    userMessageId: message.id,
-  };
-}
-
-function useSubmittingQueuedInputProjection(
-  serverInputs: readonly UiNcpSessionQueuedInputView[],
-  sessionKey: string | null,
-) {
-  const [submittingInput, setSubmittingInput] =
-    useState<SubmittingQueuedInput | null>(null);
-  const stageSubmittingInput = useCallback((envelope: NcpAgentSendEnvelope) => {
-    const input = buildSubmittingQueuedInput(envelope);
-    if (input) {
-      setSubmittingInput(input);
-    }
-    return input;
-  }, []);
-  const clearSubmittingInput = useCallback((input: SubmittingQueuedInput) => {
-    setSubmittingInput((current) =>
-      current?.userMessageId === input.userMessageId ? null : current
-    );
-  }, []);
-  const queuedInputs = useMemo<SessionConversationQueuedInput[]>(() => {
-    const projected: SessionConversationQueuedInput[] = serverInputs.map((input) => ({
-      id: input.id,
-      preview: buildSessionQueuedInputPreview(input),
-    }));
-    if (
-      submittingInput?.sessionId === sessionKey &&
-      !serverInputs.some((input) => input.message.id === submittingInput.userMessageId)
-    ) {
-      projected.push({
-        id: submittingInput.id,
-        isSubmitting: true,
-        preview: submittingInput.preview,
-      });
-    }
-    return projected;
-  }, [serverInputs, sessionKey, submittingInput]);
-  return { clearSubmittingInput, queuedInputs, stageSubmittingInput };
-}
-
-function useQueuedInputActions(params: {
-  readonly availableSkills: readonly { ref: string; name: string }[];
-  readonly restoreComposer: (snapshot: ComposerDraftSnapshot) => void;
-  readonly runQueue: SessionRunQueue;
-  readonly setSendError: (message: string | null) => void;
-}) {
-  const { availableSkills, restoreComposer, runQueue, setSendError } = params;
-  const editQueuedInput = useCallback((id: string) => {
-    const input = runQueue.inputs.find((item) => item.id === id);
-    if (!input) return;
-    void runQueue.removeQueuedInput(id).then((removed) => {
-      if (!removed) return;
-      restoreComposer(buildSessionQueuedInputComposerSnapshot(removed, availableSkills));
-      setSendError(null);
-    }).catch((error) => {
-      setSendError(error instanceof Error ? error.message : String(error));
-    });
-  }, [availableSkills, restoreComposer, runQueue, setSendError]);
-  const deleteQueuedInput = useCallback((id: string) => {
-    void runQueue.removeQueuedInput(id).then(() => setSendError(null)).catch((error) => {
-      setSendError(error instanceof Error ? error.message : String(error));
-    });
-  }, [runQueue, setSendError]);
-  return { deleteQueuedInput, editQueuedInput };
+  return envelope ? { ...envelope, delivery } : null;
 }
 
 function useSubmissionDraftRunner(params: {
@@ -322,17 +235,20 @@ function useSubmissionDraftRunner(params: {
   return useCallback(async (
     draft: SubmissionDraft,
     composerBehavior: SubmissionComposerBehavior,
+    delivery: NcpAgentSendEnvelope['delivery'] = 'queue',
   ) => {
     const submissionSessionKey =
       sessionKey ?? (materializationContext ? null : createNcpSessionId());
-    const envelope = buildSubmissionEnvelope(draft, submissionSessionKey);
+    const envelope = buildSubmissionEnvelope(draft, submissionSessionKey, delivery);
     if (!envelope) return;
-    const queuedSubmission = agent.isRunning ? stageSubmittingInput(envelope) : null;
+    const queuedSubmission = agent.isRunning && delivery === 'queue'
+      ? stageSubmittingInput(envelope)
+      : null;
     if (composerBehavior === 'reset-and-restore') resetComposer();
     setSendError(null);
     try {
       const handle = await agent.send(envelope);
-      if (queuedSubmission && handle?.runId === null) {
+      if (queuedSubmission && handle?.delivery === 'queued') {
         await runQueue.refreshQueuedInputs().catch(() => undefined);
       }
       if (queuedSubmission) clearSubmittingInput(queuedSubmission);
@@ -361,6 +277,106 @@ function useSubmissionDraftRunner(params: {
   ]);
 }
 
+function useSteeringSubmission(params: {
+  readonly agent: SessionConversationAgent;
+  readonly inputSnapshot: SessionConversationInputSnapshot;
+  readonly inputQuery: SessionConversationInputQuery;
+  readonly isRuntimeBlocked: boolean;
+  readonly materializationContext?: SessionConversationMaterializationContext | null;
+  readonly selectedAgentId: string;
+  readonly sessionKey: string | null;
+  readonly submitDraft: (
+    draft: SubmissionDraft,
+    composerBehavior: SubmissionComposerBehavior,
+    delivery?: NcpAgentSendEnvelope['delivery'],
+  ) => Promise<void>;
+}) {
+  const {
+    agent,
+    inputQuery,
+    inputSnapshot,
+    isRuntimeBlocked,
+    materializationContext,
+    selectedAgentId,
+    sessionKey,
+    submitDraft,
+  } = params;
+  return useCallback(async () => {
+    const draft = buildSubmissionDraft({
+      agentIsSending: agent.isSending,
+      inputSnapshot,
+      inputQuery,
+      isRuntimeBlocked,
+      materializationContext,
+      selectedAgentId,
+      sessionKey,
+    });
+    if (draft) await submitDraft(draft, 'reset-and-restore', 'prefer-steer');
+  }, [
+    agent.isSending,
+    inputQuery,
+    inputSnapshot,
+    isRuntimeBlocked,
+    materializationContext,
+    selectedAgentId,
+    sessionKey,
+    submitDraft,
+  ]);
+}
+
+function usePrimarySubmission(params: {
+  readonly agent: SessionConversationAgent;
+  readonly continueRun: () => Promise<void>;
+  readonly inputSnapshot: SessionConversationInputSnapshot;
+  readonly inputQuery: SessionConversationInputQuery;
+  readonly isRuntimeBlocked: boolean;
+  readonly materializationContext?: SessionConversationMaterializationContext | null;
+  readonly primaryAction: 'continue' | 'send';
+  readonly selectedAgentId: string;
+  readonly sessionKey: string | null;
+  readonly submitDraft: (
+    draft: SubmissionDraft,
+    composerBehavior: SubmissionComposerBehavior,
+  ) => Promise<void>;
+}) {
+  const {
+    agent,
+    continueRun,
+    inputQuery,
+    inputSnapshot,
+    isRuntimeBlocked,
+    materializationContext,
+    primaryAction,
+    selectedAgentId,
+    sessionKey,
+    submitDraft,
+  } = params;
+  return useCallback(async () => {
+    if (primaryAction === 'continue') return await continueRun();
+    const draft = buildSubmissionDraft({
+      agentIsSending: agent.isSending,
+      inputSnapshot,
+      inputQuery,
+      isRuntimeBlocked,
+      materializationContext,
+      selectedAgentId,
+      sessionKey,
+    });
+    if (draft) await submitDraft(draft, 'reset-and-restore');
+  }, [
+    agent.isSending,
+    continueRun,
+    inputQuery,
+    inputSnapshot,
+    isRuntimeBlocked,
+    materializationContext,
+    primaryAction,
+    selectedAgentId,
+    sessionKey,
+    submitDraft,
+  ]);
+}
+
 export function useSessionConversationController(params: UseSessionConversationControllerParams) {
   const {
     agent,
@@ -381,17 +397,18 @@ export function useSessionConversationController(params: UseSessionConversationC
     queuedInputs,
     stageSubmittingInput,
   } = useSubmittingQueuedInputProjection(runQueue.inputs, sessionKey);
-  const { deleteQueuedInput, editQueuedInput } = useQueuedInputActions({
-    availableSkills: inputQuery.skillRecords,
-    restoreComposer,
-    runQueue,
-    setSendError,
-  });
   const parts = useMemo(
     () => deriveNcpMessagePartsFromComposer([...inputSnapshot.nodes], inputSnapshot.attachments),
     [inputSnapshot.attachments, inputSnapshot.nodes],
   );
   const hasSendableDraft = hasSendableMessagePart(parts);
+  const { deleteQueuedInput, editQueuedInput, steerQueuedInput } = useQueuedInputActions({
+    availableSkills: inputQuery.skillRecords,
+    hasComposerContent: hasSendableDraft,
+    restoreComposer,
+    runQueue,
+    setSendError,
+  });
   const isSending = agent.isSending || agent.isRunning;
   const activityState = inputQuery.selectedSession?.activityPreview?.state;
   const canContinue = Boolean(
@@ -429,25 +446,8 @@ export function useSessionConversationController(params: UseSessionConversationC
     stageSubmittingInput,
   });
 
-  const send = useCallback(async () => {
-    if (primaryAction === 'continue') {
-      await continueRun();
-      return;
-    }
-    const draft = buildSubmissionDraft({
-      agentIsSending: agent.isSending,
-      inputSnapshot,
-      inputQuery,
-      isRuntimeBlocked,
-      materializationContext,
-      selectedAgentId,
-      sessionKey,
-    });
-    if (draft) {
-      await submitDraft(draft, 'reset-and-restore');
-    }
-  }, [
-    agent.isSending,
+  const send = usePrimarySubmission({
+    agent,
     continueRun,
     inputQuery,
     inputSnapshot,
@@ -457,7 +457,18 @@ export function useSessionConversationController(params: UseSessionConversationC
     selectedAgentId,
     sessionKey,
     submitDraft,
-  ]);
+  });
+
+  const sendSteering = useSteeringSubmission({
+    agent,
+    inputQuery,
+    inputSnapshot,
+    isRuntimeBlocked,
+    materializationContext,
+    selectedAgentId,
+    sessionKey,
+    submitDraft,
+  });
 
   const sendPresetMessage = useCallback(async (message: string) => {
     const text = message.trim();
@@ -505,14 +516,17 @@ export function useSessionConversationController(params: UseSessionConversationC
     deleteQueuedInput,
     editMessage,
     editQueuedInput,
+    canEditQueuedInput: !hasSendableDraft,
     hasSendableDraft,
     isSending,
     queuedInputs,
     send,
+    sendSteering,
     sendPresetMessage,
     sendDisabled,
     primaryAction,
     stop,
     stopDisabled: !agent.isRunning,
+    steerQueuedInput,
   };
 }