@nextclaw/ui 0.14.4 → 0.15.0

package/src/features/chat/features/conversation/components/__tests__/session-conversation-input.streaming.test.tsx

@@ -11,6 +11,7 @@ import {
   createChatComposerTextNode,
   type ChatComposerNode,
 } from '@nextclaw/agent-chat-ui';
+import type { NcpAgentSendEnvelope, NcpRunHandle } from '@nextclaw/ncp';
 
 import { I18nProvider } from '@/app/components/i18n-provider';
 import { ChatPresenterProvider, type ChatPresenterLike } from '@/features/chat/components/providers/chat-presenter.provider';
@@ -18,11 +19,15 @@ import {
   SessionConversationInput,
   type SessionConversationInputController,
 } from '@/features/chat/features/conversation/components/session-conversation-input';
+import { useSessionConversationController } from '@/features/chat/features/conversation/hooks/use-session-conversation-controller';
 import type {
   SessionConversationInputActions,
   SessionConversationInputPatch,
   SessionConversationInputSnapshot,
 } from '@/features/chat/features/conversation/hooks/use-session-conversation-input-state';
+import { useSessionConversationInputState } from '@/features/chat/features/conversation/hooks/use-session-conversation-input-state';
+
+const uploadNcpAssetsMock = vi.hoisted(() => vi.fn());
 
 vi.mock('@/app/hooks/use-viewport-layout', () => ({
   useViewportLayout: () => ({ isDesktop: true, isMobile: false }),
@@ -49,6 +54,7 @@ vi.mock('@/shared/lib/api', async (importOriginal) => {
   return {
     ...(actual as object),
     updateNcpSession: vi.fn(),
+    uploadNcpAssets: uploadNcpAssetsMock,
   };
 });
 
@@ -62,12 +68,16 @@ const presenter = {
   },
   chatUiManager: {
     goToProviders: vi.fn(),
+    showContent: vi.fn(),
   },
 } as unknown as ChatPresenterLike;
 
 const controller: SessionConversationInputController = {
   canStopGeneration: true,
+  deleteQueuedInput: vi.fn(),
+  editQueuedInput: vi.fn(),
   isSending: true,
+  queuedInputs: [],
   send: vi.fn(),
   sendDisabled: true,
   stop: vi.fn(),
@@ -96,8 +106,10 @@ function createStreamingInputSnapshot(
 }
 
 function StreamingSessionConversationInputHarness({
+  controllerOverride = controller,
   controlRef,
 }: {
+  controllerOverride?: SessionConversationInputController;
   controlRef: MutableRefObject<StreamingInputControl | null>;
 }) {
   const [nodes, setNodes] = useState<readonly ChatComposerNode[]>([
@@ -167,7 +179,7 @@ function StreamingSessionConversationInputHarness({
         <div data-testid="stream-chunk">{streamChunk}</div>
         <SessionConversationInput
           contextWindow={null}
-          controller={controller}
+          controller={controllerOverride}
           inputActions={inputActions}
           inputQuery={inputQuery}
           inputSnapshot={inputSnapshot}
@@ -196,4 +208,161 @@ describe('SessionConversationInput streaming stability', () => {
 
     await waitFor(() => expect(textbox.textContent).toBe('你'));
   });
+
+  it('renders queued inputs above the composer with edit and delete actions', () => {
+    const controlRef: MutableRefObject<StreamingInputControl | null> = { current: null };
+    const deleteQueuedInput = vi.fn();
+    const editQueuedInput = vi.fn();
+    render(
+      <StreamingSessionConversationInputHarness
+        controlRef={controlRef}
+        controllerOverride={{
+          ...controller,
+          deleteQueuedInput,
+          editQueuedInput,
+          queuedInputs: [
+            { id: 'queued-1', preview: '先做 A' },
+            { id: 'queued-2', preview: '再做 B' },
+          ],
+        }}
+      />,
+    );
+
+    expect(screen.getByText('先做 A')).toBeTruthy();
+    expect(screen.getByText('再做 B')).toBeTruthy();
+    const inputShell = document.querySelector('.nextclaw-chat-input-bar-shell');
+    expect(inputShell?.contains(screen.getByText('先做 A'))).toBe(true);
+    expect(inputShell?.contains(screen.getByText('再做 B'))).toBe(true);
+
+    fireEvent.click(screen.getAllByRole('button', { name: 'Edit queued input' })[0]);
+    fireEvent.click(screen.getAllByRole('button', { name: 'Delete queued input' })[1]);
+
+    expect(editQueuedInput).toHaveBeenCalledWith('queued-1');
+    expect(deleteQueuedInput).toHaveBeenCalledWith('queued-2');
+  });
+});
+
+type AttachmentSubmitAgentSend = (envelope: NcpAgentSendEnvelope) => Promise<NcpRunHandle | null>;
+
+function createAttachmentRunHandle(): NcpRunHandle {
+  return {
+    assistantMessageId: null,
+    correlationId: undefined,
+    runId: 'run-attachment',
+    sessionId: 'session-attachment',
+    userMessageId: 'user-message-attachment',
+  };
+}
+
+function AttachmentSubmitHarness({ send }: { readonly send: AttachmentSubmitAgentSend }) {
+  const { inputActions, inputSnapshot } = useSessionConversationInputState();
+  const inputQuery = useMemo(() => ({
+    defaultModel: 'test-model',
+    defaultProjectRoot: null,
+    fallbackPreferredModel: undefined,
+    fallbackPreferredThinking: undefined,
+    isProviderStateResolved: true,
+    isSkillsLoading: false,
+    modelOptions: [
+      {
+        value: 'test-model',
+        modelLabel: 'Test Model',
+        providerLabel: 'Test',
+        thinkingCapability: null,
+      },
+    ],
+    selectedSession: null,
+    selectedSessionKey: 'session-attachment',
+    sessionTypeState: {
+      canEditSessionType: true,
+      defaultSessionType: 'default',
+      selectedSessionType: 'default',
+      selectedSessionTypeOption: null,
+      sessionTypeOptions: [],
+      sessionTypeUnavailable: false,
+      sessionTypeUnavailableMessage: null,
+    },
+    skillRecords: [],
+  }), []);
+  const agent = useMemo(() => ({
+    abort: vi.fn(),
+    isHydrating: false,
+    isRunning: false,
+    isSending: false,
+    send,
+    snapshot: {
+      activeRun: null,
+    },
+    visibleMessages: [],
+  }), [send]);
+  const controller = useSessionConversationController({
+    agent,
+    inputSnapshot,
+    inputQuery,
+    isRuntimeBlocked: false,
+    selectedAgentId: 'main',
+    sessionKey: 'session-attachment',
+    resetComposer: inputActions.resetComposer,
+    restoreComposer: inputActions.restoreComposer,
+    setSendError: inputActions.setSendError,
+  });
+
+  return (
+    <I18nProvider>
+      <ChatPresenterProvider presenter={presenter}>
+        <SessionConversationInput
+          contextWindow={null}
+          controller={controller}
+          inputActions={inputActions}
+          inputQuery={inputQuery}
+          inputSnapshot={inputSnapshot}
+        />
+      </ChatPresenterProvider>
+    </I18nProvider>
+  );
+}
+
+describe('SessionConversationInput attachment submit', () => {
+  it('keeps uploaded file attachments in the outgoing send envelope after token insertion', async () => {
+    uploadNcpAssetsMock.mockResolvedValueOnce([
+      {
+        id: 'uploaded-image',
+        name: 'sample.png',
+        mimeType: 'image/png',
+        sizeBytes: 11,
+        assetUri: 'asset://store/sample.png',
+        url: '/api/ncp/assets/content?uri=asset%3A%2F%2Fstore%2Fsample.png',
+      },
+    ]);
+    const send = vi.fn<AttachmentSubmitAgentSend>(async () => createAttachmentRunHandle());
+
+    render(<AttachmentSubmitHarness send={send} />);
+
+    const fileInput = document.querySelector('input[type="file"]') as HTMLInputElement | null;
+    expect(fileInput).toBeTruthy();
+    await act(async () => {
+      fireEvent.change(fileInput!, {
+        target: {
+          files: [new File(['image-bytes'], 'sample.png', { type: 'image/png' })],
+        },
+      });
+      await Promise.resolve();
+    });
+
+    await waitFor(() => expect(screen.getByText('sample.png')).toBeTruthy());
+
+    fireEvent.click(screen.getByRole('button', { name: /Send|发送/ }));
+
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+    expect(send.mock.calls[0]?.[0].message.parts).toEqual([
+      {
+        type: 'file',
+        name: 'sample.png',
+        mimeType: 'image/png',
+        assetUri: 'asset://store/sample.png',
+        url: '/api/ncp/assets/content?uri=asset%3A%2F%2Fstore%2Fsample.png',
+        sizeBytes: 11,
+      },
+    ]);
+  });
 });

package/src/features/chat/features/conversation/components/session-conversation-area.tsx

@@ -214,7 +214,7 @@ export function SessionConversationArea(props: SessionConversationAreaProps) {
   const controllerAgent = useMemo(() => ({
     ...agent,
     isRunning: currentSessionRunning,
-    isSending: agent.isSending || currentSessionRunning,
+    isSending: agent.isSending,
   }), [agent, currentSessionRunning]);
   const controller = useSessionConversationController({
     agent: controllerAgent,
@@ -235,7 +235,10 @@ export function SessionConversationArea(props: SessionConversationAreaProps) {
   }, [controller]);
   const inputController = useMemo<SessionConversationInputController>(() => ({
     canStopGeneration: controller.canStopGeneration,
+    deleteQueuedInput: (id: string) => controllerRef.current.deleteQueuedInput(id),
+    editQueuedInput: (id: string) => controllerRef.current.editQueuedInput(id),
     isSending: controller.isSending,
+    queuedInputs: controller.queuedInputs,
     send: () => controllerRef.current.send(),
     sendDisabled: controller.sendDisabled,
     stop: () => controllerRef.current.stop(),
@@ -243,6 +246,7 @@ export function SessionConversationArea(props: SessionConversationAreaProps) {
   }), [
     controller.canStopGeneration,
     controller.isSending,
+    controller.queuedInputs,
     controller.sendDisabled,
     controller.stopDisabled,
   ]);
@@ -254,6 +258,23 @@ export function SessionConversationArea(props: SessionConversationAreaProps) {
     ...inputSnapshot,
     sendError: lastSendError ?? inputSnapshot.sendError,
   }), [inputSnapshot, lastSendError]);
+  const sessionFailurePreview = inputQuery.selectedSession?.activityPreview;
+  const sessionFailureMessage =
+    sessionFailurePreview?.state === 'failed'
+      ? sessionFailurePreview.statusText?.trim() ||
+        sessionFailurePreview.replyText?.trim() ||
+        null
+      : null;
+  const sessionFailureSlot = sessionFailureMessage ? (
+    <div className="rounded-lg border border-red-200/80 bg-red-50/80 px-3 py-2.5 shadow-sm">
+      <div className="text-xs font-semibold text-red-800">
+        {t('chatSessionErrorTitle')}
+      </div>
+      <div className="mt-1 whitespace-pre-wrap break-words text-xs leading-5 text-red-700">
+        {sessionFailureMessage}
+      </div>
+    </div>
+  ) : null;
   useSessionConversationDraftIntent({
     consumeDraftIntent,
     applyPromptSuggestion: inputActions.applyPromptSuggestion,
@@ -287,6 +308,7 @@ export function SessionConversationArea(props: SessionConversationAreaProps) {
         isAwaitingAssistantOutput={controller.isSending && currentSessionRunning}
         isHistoryLoading={agent.isHydrating}
         isSending={controller.isSending}
+        bottomSlot={sessionFailureSlot}
         messages={agent.visibleMessages}
         sessionKey={sessionKey}
         showWelcome={showWelcome}

package/src/features/chat/features/conversation/components/session-conversation-input.tsx

@@ -50,6 +50,9 @@ import {
 
 import { useSessionConversationInputAttachments } from '@/features/chat/features/conversation/hooks/use-session-conversation-input-attachments';
 import type { useSessionConversationInputQuery } from '@/features/chat/features/conversation/hooks/use-session-conversation-input-query';
+import type {
+  SessionConversationQueuedInput,
+} from '@/features/chat/features/conversation/hooks/use-session-conversation-controller';
 import type {
   SessionConversationInputActions,
   SessionConversationInputSnapshot,
@@ -59,12 +62,16 @@ import {
   buildSessionConversationToolbarSelects,
   resolveThinkingForConversationModel,
 } from '@/features/chat/features/conversation/utils/session-conversation-input-toolbar.utils';
+import { SessionQueuedInputRows } from './session-queued-input-rows';
 
 type SessionConversationInputQuery = ReturnType<typeof useSessionConversationInputQuery>;
 
 export type SessionConversationInputController = {
   readonly canStopGeneration: boolean;
+  readonly deleteQueuedInput: (id: string) => void;
+  readonly editQueuedInput: (id: string) => void;
   readonly isSending: boolean;
+  readonly queuedInputs: readonly SessionConversationQueuedInput[];
   readonly sendDisabled: boolean;
   readonly stopDisabled: boolean;
   readonly send: () => Promise<void> | void;
@@ -215,6 +222,13 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
     language,
     presenter.chatThreadManager,
   ]);
+  const handleSlashPanelAppSelect = useCallback(
+    (appId: string) =>
+      void presenter.chatUiManager.showContent({
+        target: { type: 'panel_app', payload: { appId } },
+      }),
+    [presenter.chatUiManager],
+  );
   const { inputSurfaceState, setInputSurfaceTrigger } = useChatInputSurfaceState({
     commands: slashCommands,
     isSkillsLoading: inputQuery.isSkillsLoading,
@@ -222,6 +236,7 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
       slashTexts: labels.slashTexts,
     },
     language,
+    onSelectPanelApp: handleSlashPanelAppSelect,
     onSelectSkill: chatRecentSkillsManager.remember,
     recentSkillValues,
     skillRecords,
@@ -275,15 +290,14 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
   }, [inputQuery.selectedSession, inputQuery.selectedSessionKey]);
   const handleNodesChange = useCallback((nodes: SessionConversationInputSnapshot['nodes']) => {
     const nextNodes = [...nodes];
-    const attachments = pruneComposerAttachments(nextNodes, inputSnapshot.attachments);
-    inputActions.update({
+    inputActions.update((current) => ({
       nodes: nextNodes,
-      attachments,
+      attachments: pruneComposerAttachments(nextNodes, current.attachments),
       text: deriveChatComposerDraft(nextNodes),
       selectedSkills: deriveSelectedSkillsFromComposer(nextNodes),
       sendError: null,
-    });
-  }, [inputActions, inputSnapshot.attachments]);
+    }));
+  }, [inputActions]);
   const handleModelChange = useCallback((value: string) => {
     const nextThinkingLevel = resolveThinkingForConversationModel(
       modelRecords.find((option) => option.value === value),
@@ -380,6 +394,9 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
       <ChatInputBar
         ref={inputBarRef}
         surface={surface}
+        topSlot={controller.queuedInputs.length > 0
+          ? <SessionQueuedInputRows controller={controller} />
+          : null}
         composer={{
           nodes: [...inputSnapshot.nodes],
           placeholder: textareaPlaceholder,
@@ -407,7 +424,7 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
               label: t('chatInputAttach'),
               icon: 'paperclip' as const,
               iconOnly: true,
-              disabled: !attachmentSupported || inputDisabled || controller.isSending,
+              disabled: !attachmentSupported || inputDisabled,
               onClick: () => fileInputRef.current?.click(),
             },
           ],
@@ -419,7 +436,7 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
             sendDisabled: controller.sendDisabled,
             stopDisabled: controller.stopDisabled,
             stopHint: t('chatStopUnavailable'),
-            sendButtonLabel: t('chatSend'),
+            sendButtonLabel: controller.isSending ? t('chatQueueSend') : t('chatSend'),
             stopButtonLabel: t('chatStop'),
             contextWindow,
             onSend: controller.send,

package/src/features/chat/features/conversation/components/session-queued-input-rows.tsx

@@ -0,0 +1,96 @@
+import type { ReactNode } from 'react';
+import { CornerDownRight, Pencil, Trash2 } from 'lucide-react';
+
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+} from '@/shared/components/ui/tooltip';
+import { t } from '@/shared/lib/i18n';
+import type {
+  SessionConversationQueuedInput,
+} from '@/features/chat/features/conversation/hooks/use-session-conversation-controller';
+
+type SessionQueuedInputRowsController = {
+  readonly deleteQueuedInput: (id: string) => void;
+  readonly editQueuedInput: (id: string) => void;
+  readonly queuedInputs: readonly SessionConversationQueuedInput[];
+};
+
+type SessionQueuedInputRowsProps = {
+  readonly controller: SessionQueuedInputRowsController;
+};
+
+type QueuedInputIconButtonProps = {
+  readonly children: ReactNode;
+  readonly disabled?: boolean;
+  readonly label: string;
+  readonly onClick: () => void;
+};
+
+function QueuedInputIconButton({
+  children,
+  disabled = false,
+  label,
+  onClick,
+}: QueuedInputIconButtonProps) {
+  return (
+    <Tooltip>
+      <TooltipTrigger asChild>
+        <span className="inline-flex">
+          <button
+            type="button"
+            aria-label={label}
+            disabled={disabled}
+            onClick={onClick}
+            className="inline-flex h-7 w-7 shrink-0 items-center justify-center rounded-sm text-muted-foreground transition-colors hover:bg-muted hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:cursor-not-allowed disabled:text-muted-foreground/50"
+          >
+            {children}
+          </button>
+        </span>
+      </TooltipTrigger>
+      <TooltipContent side="top">{label}</TooltipContent>
+    </Tooltip>
+  );
+}
+
+export function SessionQueuedInputRows({
+  controller,
+}: SessionQueuedInputRowsProps) {
+  if (controller.queuedInputs.length === 0) {
+    return null;
+  }
+
+  return (
+    <TooltipProvider delayDuration={120}>
+      <div className="flex flex-col gap-0.5">
+        {controller.queuedInputs.map((item) => (
+          <div
+            key={item.id}
+            className="flex min-h-8 min-w-0 items-center gap-2 text-sm"
+          >
+            <CornerDownRight className="h-4 w-4 shrink-0 text-muted-foreground/70" />
+            <span className="min-w-0 flex-1 truncate font-medium text-foreground/80">
+              {item.preview || t('chatQueuedBannerAttachmentFallback')}
+            </span>
+            <div className="flex shrink-0 items-center gap-1.5">
+              <QueuedInputIconButton
+                label={t('chatQueuedEdit')}
+                onClick={() => controller.editQueuedInput(item.id)}
+              >
+                <Pencil className="h-4 w-4" />
+              </QueuedInputIconButton>
+              <QueuedInputIconButton
+                label={t('chatQueuedDelete')}
+                onClick={() => controller.deleteQueuedInput(item.id)}
+              >
+                <Trash2 className="h-4 w-4" />
+              </QueuedInputIconButton>
+            </div>
+          </div>
+        ))}
+      </div>
+    </TooltipProvider>
+  );
+}

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

@@ -0,0 +1,181 @@
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { NcpAgentSendEnvelope, NcpRunHandle } from '@nextclaw/ncp';
+
+import { useSessionConversationController } from '@/features/chat/features/conversation/hooks/use-session-conversation-controller';
+
+type TestAgentSendEnvelope = NcpAgentSendEnvelope;
+type TestAgentSend = (envelope: TestAgentSendEnvelope) => Promise<NcpRunHandle | null>;
+
+function createTextNode(text: string) {
+  return {
+    id: 'text-1',
+    type: 'text' as const,
+    text,
+  };
+}
+
+function createRunHandle(overrides: Partial<NcpRunHandle> = {}): NcpRunHandle {
+  return {
+    assistantMessageId: null,
+    correlationId: undefined,
+    runId: 'run-1',
+    sessionId: 'session-1',
+    userMessageId: 'user-message-1',
+    ...overrides,
+  };
+}
+
+function createSendMock() {
+  return vi.fn<TestAgentSend>(async () => createRunHandle());
+}
+
+function createAgent(params: {
+  isRunning: boolean;
+  send: ReturnType<typeof createSendMock>;
+}) {
+  return {
+    abort: vi.fn(),
+    isHydrating: false,
+    isRunning: params.isRunning,
+    isSending: false,
+    send: params.send,
+    snapshot: {
+      activeRun: params.isRunning ? { sessionId: 'session-1' } : null,
+    },
+    visibleMessages: [],
+  };
+}
+
+function createControllerParams(params: {
+  isRunning: boolean;
+  send?: ReturnType<typeof createSendMock>;
+}) {
+  const send = params.send ?? createSendMock();
+  return {
+    agent: createAgent({ isRunning: params.isRunning, send }),
+    inputQuery: {
+      defaultModel: 'test-model',
+      defaultProjectRoot: null,
+      fallbackPreferredModel: undefined,
+      fallbackPreferredThinking: undefined,
+      isProviderStateResolved: true,
+      isSkillsLoading: false,
+      modelOptions: [],
+      selectedSession: null,
+      selectedSessionKey: 'session-1',
+      sessionTypeState: {
+        canEditSessionType: true,
+        defaultSessionType: 'default',
+        selectedSessionType: 'default',
+        selectedSessionTypeOption: null,
+        sessionTypeOptions: [],
+        sessionTypeUnavailable: false,
+        sessionTypeUnavailableMessage: null,
+      },
+      skillRecords: [],
+    },
+    inputSnapshot: {
+      attachments: [],
+      composerFocusRequestId: 0,
+      nodes: [createTextNode('next task')],
+      pendingProjectRoot: null,
+      pendingSessionType: 'default',
+      selectedModel: undefined,
+      selectedSessionType: 'default',
+      selectedSkills: [],
+      selectedThinkingLevel: null,
+      sendError: null,
+      skillRecords: [],
+      text: 'next task',
+    },
+    isRuntimeBlocked: false,
+    selectedAgentId: 'main',
+    sessionKey: 'session-1',
+    resetComposer: vi.fn(),
+    restoreComposer: vi.fn(),
+    setSendError: vi.fn(),
+  };
+}
+
+describe('useSessionConversationController queued input delivery', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('queues a draft while the agent is running and sends it when the run becomes idle', async () => {
+    vi.useFakeTimers({ toFake: ['Date'] });
+    vi.setSystemTime(new Date('2026-07-05T10:00:00.000Z'));
+    const send = createSendMock();
+    const { result, rerender } = renderHook(
+      ({ isRunning }) => useSessionConversationController(createControllerParams({ isRunning, send })),
+      { initialProps: { isRunning: true } },
+    );
+
+    await act(async () => {
+      await result.current.send();
+    });
+
+    expect(send).not.toHaveBeenCalled();
+    expect(result.current.queuedInputs).toEqual([{ id: expect.any(String), preview: 'next task' }]);
+
+    vi.setSystemTime(new Date('2026-07-05T10:01:00.000Z'));
+    rerender({ isRunning: false });
+
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+    expect(send.mock.calls[0]?.[0]).toMatchObject({
+      message: expect.objectContaining({
+        parts: [{ type: 'text', text: 'next task' }],
+        timestamp: '2026-07-05T10:01:00.000Z',
+      }),
+      sessionId: 'session-1',
+    });
+    expect(send.mock.calls[0]?.[0]).not.toHaveProperty('runDelivery');
+  });
+
+  it('returns a queued draft to the composer for editing and cancels its queue entry', async () => {
+    const send = createSendMock();
+    const params = createControllerParams({ isRunning: true, send });
+    const { result } = renderHook(() => useSessionConversationController(params));
+
+    await act(async () => {
+      await result.current.send();
+    });
+    const queuedId = result.current.queuedInputs[0]?.id;
+    expect(queuedId).toBeTruthy();
+
+    act(() => {
+      result.current.editQueuedInput(queuedId ?? '');
+    });
+
+    expect(result.current.queuedInputs).toEqual([]);
+    expect(params.restoreComposer).toHaveBeenCalledWith({
+      attachments: [],
+      nodes: [createTextNode('next task')],
+      selectedSkills: [],
+      skillRecords: [],
+      text: 'next task',
+    });
+    expect(send).not.toHaveBeenCalled();
+  });
+
+  it('deletes a queued draft without restoring it to the composer', async () => {
+    const send = createSendMock();
+    const params = createControllerParams({ isRunning: true, send });
+    const { result } = renderHook(() => useSessionConversationController(params));
+
+    await act(async () => {
+      await result.current.send();
+    });
+    const queuedId = result.current.queuedInputs[0]?.id;
+    expect(queuedId).toBeTruthy();
+
+    act(() => {
+      result.current.deleteQueuedInput(queuedId ?? '');
+    });
+
+    expect(result.current.queuedInputs).toEqual([]);
+    expect(params.restoreComposer).not.toHaveBeenCalled();
+    expect(send).not.toHaveBeenCalled();
+  });
+});