@nextclaw/ui 0.26.5 → 0.27.1

package/src/features/chat/components/providers/chat-runtime.provider.tsx

@@ -21,7 +21,7 @@ function ChatRuntime({ children }: { children: ReactNode }) {
   const navigate = useNavigate();
   const { confirm, ConfirmDialog } = useConfirmDialog();
   const match = useMatch('/chat/:sessionId');
-  const sessionKey = parseSessionKeyFromRoute(match?.params.sessionId);
+  const sessionKey = parseSessionKeyFromRoute(match ? location.pathname.slice('/chat/'.length) : undefined);
   const workspaceMinimized = useWorkbenchSurfaceStore((state) => state.surfaces[`session-workspace:${sessionKey ?? 'draft'}`]?.minimized ?? false);
   const workspaceSessionKey = useChatThreadStore(({ snapshot }) =>
     snapshot.workspacePanelParentKey === sessionKey && sessionKey && !snapshot.workspacePanelHidden && !workspaceMinimized &&

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

@@ -13,7 +13,6 @@ const mocks = vi.hoisted(() => {
   const inputActions = {
     update: vi.fn(),
     syncComposer: vi.fn(),
-    resetComposer: vi.fn(),
     restoreComposer: vi.fn(),
     applyPromptSuggestion: vi.fn(),
     requestComposerFocusAtEnd: vi.fn(),

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

@@ -245,6 +245,9 @@ const controller: SessionConversationInputController = {
   send: vi.fn(),
   sendSteering: vi.fn(),
   sendPresetMessage: vi.fn(),
+  retryPendingSubmission: vi.fn(),
+  restorePendingSubmission: vi.fn(),
+  discardPendingSubmission: vi.fn(),
   sendDisabled: true,
   stop: vi.fn(),
   stopDisabled: false,
@@ -352,8 +355,12 @@ function StreamingSessionConversationInputHarness({
     consumeComposerFocusRequest: vi.fn(),
     removeAttachment: vi.fn(),
     requestComposerFocusAtEnd: vi.fn(),
-    resetComposer: vi.fn(),
     restoreComposer: vi.fn(),
+    beginSubmission: vi.fn(),
+    acceptSubmission: vi.fn(),
+    failSubmission: vi.fn(),
+    restoreSubmission: vi.fn(),
+    discardSubmission: vi.fn(),
     setAttachments: vi.fn(),
     setPendingProjectRoot: vi.fn(),
     setPendingSessionType: vi.fn(),
@@ -665,8 +672,12 @@ function AttachmentSubmitHarness({
     },
     selectedAgentId: 'main',
     sessionKey: 'session-attachment',
-    resetComposer: inputActions.resetComposer,
     restoreComposer: inputActions.restoreComposer,
+    beginSubmission: inputActions.beginSubmission,
+    acceptSubmission: inputActions.acceptSubmission,
+    failSubmission: inputActions.failSubmission,
+    restoreSubmission: inputActions.restoreSubmission,
+    discardSubmission: inputActions.discardSubmission,
     setSendError: inputActions.setSendError,
   });
 

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

@@ -1,7 +1,6 @@
 import { PageResourceActionsMenu } from '@/features/right-panel-resources';
 import { pageResourceFromTarget } from '@/features/right-panel-resources';
 import { buildSessionPanelUrl } from '@/features/chat/features/session/utils/chat-session-route.utils';
-import { MessageSquare } from 'lucide-react';
 import { useNavigate } from 'react-router-dom';
 import { getAppPresenter } from '@/app/presenters/app.presenter';
 import { sessionSurfaceManager } from '@/features/chat/managers/session-surface.manager';
@@ -17,8 +16,8 @@ export function FloatingSessionConversation() {
   const presenter = getAppPresenter();
   if (!session) return null;
   return <WorkbenchSurface id={SESSION_WORKBENCH_SURFACE} manager={presenter.workbenchSurfaceManager}
-    title={session.title} icon={<MessageSquare className="h-4 w-4 shrink-0" />} testId="floating-session-conversation" focusOnOpen
-    navigation={<div className="flex min-w-0 flex-1 items-center gap-2"><span className="min-w-0 flex-1 truncate text-xs">{session.title}</span><PageResourceActionsMenu page={pageResourceFromTarget({ kind: 'chat-session', title: session.title, url: buildSessionPanelUrl(session.sessionKey), resourceUri: buildSessionPanelUrl(session.sessionKey), historyPolicy: 'none' })} /></div>}
+    title={session.title} testId="floating-session-conversation" focusOnOpen
+    moreActions={<PageResourceActionsMenu page={pageResourceFromTarget({ kind: 'chat-session', title: session.title, url: buildSessionPanelUrl(session.sessionKey), resourceUri: buildSessionPanelUrl(session.sessionKey), historyPolicy: 'none' })} />}
     onClose={sessionSurfaceManager.close}
     onPlace={() => sessionSurfaceManager.dock(session, presenter.docBrowserManager)}
     onOpenMain={() => { navigate(buildSessionPath(session.sessionKey)); sessionSurfaceManager.close(); }}>

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

@@ -304,8 +304,12 @@ export function SessionConversationArea(props: SessionConversationAreaProps) {
     selectedAgentId,
     sessionKey,
     onSessionMaterialized,
-    resetComposer: inputActions.resetComposer,
     restoreComposer: inputActions.restoreComposer,
+    beginSubmission: inputActions.beginSubmission,
+    acceptSubmission: inputActions.acceptSubmission,
+    failSubmission: inputActions.failSubmission,
+    restoreSubmission: inputActions.restoreSubmission,
+    discardSubmission: inputActions.discardSubmission,
     setSendError: inputActions.setSendError,
   });
   const conversationMessages = useMemo(() => {
@@ -336,6 +340,9 @@ export function SessionConversationArea(props: SessionConversationAreaProps) {
       sendSteering: () => controllerRef.current.sendSteering(),
       sendPresetMessage: (message: string) =>
         controllerRef.current.sendPresetMessage(message).catch(() => undefined),
+      retryPendingSubmission: () => controllerRef.current.retryPendingSubmission(),
+      restorePendingSubmission: () => controllerRef.current.restorePendingSubmission(),
+      discardPendingSubmission: () => controllerRef.current.discardPendingSubmission(),
       sendDisabled: controller.sendDisabled,
       stop: () => controllerRef.current.stop(),
       stopDisabled: controller.stopDisabled,
@@ -437,6 +444,7 @@ export function SessionConversationArea(props: SessionConversationAreaProps) {
         onEditMessage={(payload) => controllerRef.current.editMessage(payload)}
         welcomeSlot={
           <ChatConversationWelcome
+            hasDraftContent={Boolean(inputSnapshot.text.trim() || inputSnapshot.attachments.length || inputSnapshot.selectedSkills.length)}
             inputSlot={
               <div className="space-y-2">
                 {renderInput("embedded", t("chatWelcomeInputPlaceholder"))}

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

@@ -0,0 +1,44 @@
+import type { ChatComposerSubmission } from '@/features/chat/stores/chat-composer-draft.store';
+import type { SessionConversationInputController } from '@/features/chat/features/conversation/types/session-conversation-input.types';
+import type { SessionConversationInputSnapshot } from '@/features/chat/features/conversation/hooks/use-session-conversation-input-state';
+import { t } from '@/shared/lib/i18n';
+import { SessionQueuedInputRows } from './session-queued-input-rows';
+
+export function SessionConversationInputTopSlot({ inputSnapshot, controller }: {
+  readonly inputSnapshot: SessionConversationInputSnapshot;
+  readonly controller: SessionConversationInputController;
+}) {
+  const submission = inputSnapshot.pendingSubmission;
+  if (!submission && controller.queuedInputs.length === 0) return null;
+  return <>
+    {controller.queuedInputs.length > 0 && <SessionQueuedInputRows controller={controller} />}
+    {submission && <SubmissionStatus submission={submission} controller={controller}
+      hasComposerContent={Boolean(inputSnapshot.text.trim() || inputSnapshot.selectedSkills.length || inputSnapshot.attachments.length)} />}
+  </>;
+}
+
+function SubmissionStatus({ submission, controller, hasComposerContent }: {
+  readonly submission: ChatComposerSubmission;
+  readonly controller: SessionConversationInputController;
+  readonly hasComposerContent: boolean;
+}) {
+  const statusText = submission.status === 'sending'
+    ? t('chatSubmissionSending')
+    : submission.status === 'rejected'
+      ? t('chatSubmissionRejected')
+      : t(submission.envelope.sessionId ? 'chatSendResultUnknown' : 'chatSendResultUnknownChild');
+  return <div className="rounded-lg border border-border bg-muted/50 px-3 py-2 text-sm" role="status">
+    <p>{statusText}</p>
+    <p className="mt-1 max-h-16 overflow-auto whitespace-pre-wrap text-muted-foreground">{submission.composer.text}</p>
+    <div className="mt-2 flex gap-3">
+      {submission.status === 'uncertain' && submission.envelope.sessionId &&
+        <button type="button" className="text-primary underline" onClick={controller.retryPendingSubmission}>{t('chatSubmissionRetry')}</button>}
+      {submission.status === 'rejected' && <>
+        <button type="button" className="text-primary underline" disabled={hasComposerContent} onClick={controller.restorePendingSubmission}>{t('chatSubmissionRestore')}</button>
+        <button type="button" className="text-muted-foreground underline" onClick={() => {
+          if (window.confirm(t('chatSubmissionDiscardConfirm'))) controller.discardPendingSubmission();
+        }}>{t('chatSubmissionDiscard')}</button>
+      </>}
+    </div>
+  </div>;
+}

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

@@ -7,7 +7,6 @@ import {
 } from 'react';
 import {
   ChatInputBar,
-  type ChatContextWindowIndicator,
   type ChatInputBarHandle,
 } from '@nextclaw/agent-chat-ui';
 import { isRuntimeDefaultModelValue } from '@nextclaw/shared';
@@ -56,41 +55,19 @@ import { useSystemObjectReferenceSelect } from '@/features/chat/features/convers
 import { ChatConversationTrack } from '@/features/chat/components/conversation/chat-conversation-track';
 import { useChatMessageLayoutStore } from '@/features/chat/stores/chat-message-layout.store';
 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,
-} from '@/features/chat/features/conversation/hooks/use-session-conversation-input-state';
 import {
   buildSessionConversationSkillPicker,
   buildSessionConversationToolbarSelects,
   resolveThinkingForConversationModel,
 } from '@/features/chat/features/conversation/utils/session-conversation-input-toolbar.utils';
-import { SessionQueuedInputRows } from './session-queued-input-rows';
+import { SessionConversationInputTopSlot } from './session-conversation-input-top-slot';
+import type { SessionConversationInputProps } from '@/features/chat/features/conversation/types/session-conversation-input.types';
+export type { SessionConversationInputController } from '@/features/chat/features/conversation/types/session-conversation-input.types';
 import { toast } from 'sonner';
 
 type SessionConversationInputQuery = ReturnType<typeof useSessionConversationInputQuery>;
 type SkillSource = SessionSkillEntryView['source'];
 
-export type SessionConversationInputController = {
-  readonly canEditQueuedInput: boolean;
-  readonly canStopGeneration: boolean;
-  readonly deleteQueuedInput: (id: string) => void;
-  readonly editQueuedInput: (id: string) => void;
-  readonly isSending: boolean;
-  readonly queuedInputs: readonly SessionConversationQueuedInput[];
-  readonly primaryAction: 'continue' | 'send';
-  readonly sendDisabled: boolean;
-  readonly stopDisabled: boolean;
-  readonly send: () => Promise<void> | void;
-  readonly sendSteering: () => Promise<void> | void;
-  readonly sendPresetMessage: (message: string) => Promise<void> | void;
-  readonly stop: () => Promise<void> | void;
-  readonly steerQueuedInput: (id: string) => void;
-};
-
 function toSkillRecords(
   snapshotRecords: SessionSkillEntryView[],
   scopeLabels: Record<SkillSource, string>,
@@ -181,17 +158,6 @@ function useSessionConversationInputCollections(params: {
   };
 }
 
-type SessionConversationInputProps = {
-  readonly contextWindow: ChatContextWindowIndicator | null;
-  readonly controller: SessionConversationInputController;
-  readonly inputActions: SessionConversationInputActions;
-  readonly inputQuery: SessionConversationInputQuery;
-  readonly inputSnapshot: SessionConversationInputSnapshot;
-  readonly onContextCompactingChange?: (sessionId: string, isCompacting: boolean) => void;
-  readonly placeholder?: string;
-  readonly surface?: 'default' | 'embedded';
-};
-
 export const SessionConversationInput = memo(function SessionConversationInput(props: SessionConversationInputProps) {
   const {
     contextWindow,
@@ -431,7 +397,7 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
     <ChatInputBar
       ref={inputBarRef}
       surface={useReadingTrack ? 'embedded' : surface}
-      topSlot={controller.queuedInputs.length > 0 ? <SessionQueuedInputRows controller={controller} /> : null}
+      topSlot={<SessionConversationInputTopSlot inputSnapshot={inputSnapshot} controller={controller} />}
       floatingSlot={voice.phase !== 'idle' ? <ChatVoiceInputPanel manager={voiceManager} snapshot={voice}
         desktop={!isMobile} onStart={startVoice} /> : null}
       composer={{

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

@@ -2,8 +2,13 @@ import { act, renderHook, waitFor } from '@testing-library/react';
 import { describe, expect, it, vi } from 'vitest';
 import { NextClawClientError, type UiNcpSessionQueuedInputView } from '@nextclaw/client-sdk';
 import type { NcpAgentSendEnvelope, NcpMessage, NcpRunHandle } from '@nextclaw/ncp';
+import { NcpHttpSendError } from '@nextclaw/ncp-http-agent-client';
+
+const fetchNcpSessionMessages = vi.hoisted(() => vi.fn());
+vi.mock('@/shared/lib/api', () => ({ fetchNcpSessionMessages }));
 
 import { useSessionConversationController } from '@/features/chat/features/conversation/hooks/use-session-conversation-controller';
+import type { ChatComposerSubmission } from '@/features/chat/stores/chat-composer-draft.store';
 
 type TestAgentSend = (envelope: NcpAgentSendEnvelope) => Promise<NcpRunHandle | null>;
 
@@ -107,6 +112,7 @@ function createControllerParams(params: {
       composerFocusRequestId: 0,
       nodes: [createTextNode('next task')],
       pendingProjectRoot: null,
+      pendingSubmission: null as ChatComposerSubmission | null,
       pendingSessionType: 'default',
       selectedModel: undefined,
       selectedSessionType: 'default',
@@ -126,8 +132,12 @@ function createControllerParams(params: {
     },
     selectedAgentId: 'main',
     sessionKey: 'session-1',
-    resetComposer: vi.fn(),
     restoreComposer: vi.fn(),
+    beginSubmission: vi.fn(),
+    acceptSubmission: vi.fn(),
+    failSubmission: vi.fn(),
+    restoreSubmission: vi.fn(),
+    discardSubmission: vi.fn(),
     onSessionMaterialized: vi.fn(),
     setSendError: vi.fn(),
   };
@@ -162,6 +172,7 @@ describe('useSessionConversationController backend run queue', () => {
     const envelope = send.mock.calls[0]?.[0];
     expect(envelope?.sessionId).toMatch(/^ncp-/);
     expect(envelope?.message.sessionId).toBe(envelope?.sessionId);
+    expect(envelope?.idempotencyKey).toBe(envelope?.message.id);
     expect(params.onSessionMaterialized).toHaveBeenCalledWith(envelope?.sessionId);
   });
 
@@ -182,7 +193,21 @@ describe('useSessionConversationController backend run queue', () => {
         parts: [{ type: 'text', text: 'next task' }],
       }),
     });
-    expect(params.resetComposer).toHaveBeenCalledTimes(1);
+    expect(params.beginSubmission).toHaveBeenCalledTimes(1);
+  });
+
+  it('attempts a send when a nonempty draft has a stale blocked runtime status', async () => {
+    const send = createSendMock();
+    const params = { ...createControllerParams({ isRunning: false, send }), isRuntimeBlocked: true };
+    const { result } = renderHook(() => useSessionConversationController(params));
+
+    expect(result.current.sendDisabled).toBe(false);
+    await act(async () => {
+      await result.current.send();
+    });
+
+    expect(send).toHaveBeenCalledTimes(1);
+    expect(params.setSendError).toHaveBeenLastCalledWith(null);
   });
 
   it('uses prefer-steer for command/control-enter submission without changing the send button path', async () => {
@@ -241,7 +266,7 @@ describe('useSessionConversationController backend run queue', () => {
       }),
     });
     expect(envelope?.metadata).not.toHaveProperty('ui_inline_tokens');
-    expect(params.resetComposer).not.toHaveBeenCalled();
+    expect(params.beginSubmission).not.toHaveBeenCalled();
     expect(params.restoreComposer).not.toHaveBeenCalled();
   });
 
@@ -257,7 +282,7 @@ describe('useSessionConversationController backend run queue', () => {
       await expect(result.current.sendPresetMessage('Update title')).rejects.toThrow(sendError);
     });
 
-    expect(params.resetComposer).not.toHaveBeenCalled();
+    expect(params.beginSubmission).not.toHaveBeenCalled();
     expect(params.restoreComposer).not.toHaveBeenCalled();
     expect(params.setSendError).toHaveBeenLastCalledWith(sendError.message);
   });
@@ -275,7 +300,7 @@ describe('useSessionConversationController backend run queue', () => {
       submission = result.current.send();
     });
 
-    expect(params.resetComposer).toHaveBeenCalledTimes(1);
+    expect(params.beginSubmission).toHaveBeenCalledTimes(1);
     expect(result.current.queuedInputs).toEqual([
       expect.objectContaining({
         isSubmitting: true,
@@ -306,13 +331,64 @@ describe('useSessionConversationController backend run queue', () => {
     });
 
     expect(result.current.queuedInputs).toEqual([]);
-    expect(params.restoreComposer).toHaveBeenCalledWith(expect.objectContaining({
-      text: 'next task',
-    }));
-    expect(params.setSendError).toHaveBeenLastCalledWith(sendError.message);
+    expect(params.failSubmission).toHaveBeenCalledWith(expect.any(String), 'uncertain', sendError.message);
     expect(params.runQueue.refreshQueuedInputs).not.toHaveBeenCalled();
   });
 
+  it('shows a send failure and restores the draft when the client returns no acceptance handle', async () => {
+    const send = createSendMock(null);
+    const params = createControllerParams({ isRunning: false, send });
+    const { result } = renderHook(() => useSessionConversationController(params));
+
+    await act(async () => {
+      await expect(result.current.send()).rejects.toThrow('Failed to send message');
+    });
+
+    expect(params.failSubmission).toHaveBeenCalledWith(expect.any(String), 'rejected', 'Failed to send message');
+    expect(params.onSessionMaterialized).not.toHaveBeenCalled();
+  });
+
+  it('classifies an explicit HTTP rejection so the draft can be restored', async () => {
+    const error = new NcpHttpSendError('invalid request', true);
+    const send = vi.fn<TestAgentSend>(async () => { throw error; });
+    const params = createControllerParams({ isRunning: false, send });
+    const { result } = renderHook(() => useSessionConversationController(params));
+    await act(async () => {
+      await expect(result.current.send()).rejects.toThrow(error);
+    });
+    expect(params.failSubmission).toHaveBeenCalledWith(expect.any(String), 'rejected', 'invalid request');
+  });
+
+  it('rechecks the original message before retrying with the same identity', async () => {
+    fetchNcpSessionMessages.mockResolvedValue({ messages: [] });
+    const params = createControllerParams({ isRunning: false });
+    const envelope: NcpAgentSendEnvelope = {
+      sessionId: 'session-1', idempotencyKey: 'user-original',
+      message: {
+        id: 'user-original', sessionId: 'session-1', role: 'user', status: 'final',
+        timestamp: '2026-09-24T00:00:00.000Z', parts: [{ type: 'text', text: 'next task' }],
+      },
+    };
+    params.inputSnapshot.pendingSubmission = {
+      envelope,
+      composer: {
+        text: 'next task', nodes: [createTextNode('next task')],
+        selectedSkills: [], skillRecords: [], attachments: [],
+      },
+      status: 'uncertain',
+    };
+    const { result } = renderHook(() => useSessionConversationController(params));
+    expect(result.current.sendDisabled).toBe(true);
+    await act(async () => {
+      await result.current.send();
+      await result.current.retryPendingSubmission();
+    });
+    expect(fetchNcpSessionMessages).toHaveBeenCalledWith('session-1', { limit: 100 });
+    expect(params.agent.send).toHaveBeenCalledTimes(1);
+    expect(params.agent.send).toHaveBeenCalledWith(envelope);
+    expect(params.acceptSubmission).toHaveBeenCalledWith('user-original');
+  });
+
   it('keeps an existing session bound to its agent instead of the global draft selection', async () => {
     const send = createSendMock();
     const params = createControllerParams({ isRunning: false, send });
@@ -406,7 +482,7 @@ describe('useSessionConversationController backend run queue', () => {
 
     expect(params.agent.continueRun).toHaveBeenCalledWith({ sessionId: 'session-1' });
     expect(params.agent.send).not.toHaveBeenCalled();
-    expect(params.resetComposer).not.toHaveBeenCalled();
+    expect(params.beginSubmission).not.toHaveBeenCalled();
   });
 
   it('keeps continuation available but restores send as primary when the user types', () => {

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

@@ -36,7 +36,7 @@ const THINKING_MODEL_OPTIONS: ChatModelOption[] = [
 describe('useSessionConversationInputState session preferences', () => {
   beforeEach(() => {
     window.localStorage.clear();
-    useChatComposerDraftStore.setState({ drafts: {} });
+    useChatComposerDraftStore.setState({ drafts: {}, submissions: {}, recentSubmittedNodes: {} });
     useChatThreadStore.getState().setSnapshot({ draftProjectRoot: null });
   });
 
@@ -198,4 +198,47 @@ describe('useSessionConversationInputState session preferences', () => {
     rerender({ sessionKey: null });
     expect(result.current.inputSnapshot.text).toBe('新会话草稿');
   });
+
+  it('keeps a successfully cleared draft empty after switching away and back', () => {
+    const { result, rerender } = renderHook(
+      ({ sessionKey }: { sessionKey: string }) =>
+        useSessionConversationInputState(null, sessionKey),
+      { initialProps: { sessionKey: 'session-sent' } },
+    );
+
+    act(() => {
+      result.current.inputActions.syncComposer({
+        text: '已经发送的消息',
+        nodes: [],
+        selectedSkills: [],
+        skillRecords: [],
+      });
+      result.current.inputActions.beginSubmission({
+        sessionId: 'session-sent',
+        message: {
+          id: 'user-sent', sessionId: 'session-sent', role: 'user', status: 'final',
+          timestamp: '2026-09-24T00:00:00.000Z',
+          parts: [{ type: 'text', text: '已经发送的消息' }],
+        },
+      }, {
+        text: '已经发送的消息', nodes: [], selectedSkills: [], skillRecords: [], attachments: [],
+      });
+      result.current.inputActions.acceptSubmission('user-sent');
+    });
+    rerender({ sessionKey: 'session-unsent' });
+    act(() => {
+      result.current.inputActions.syncComposer({
+        text: '仍未发送的草稿',
+        nodes: [],
+        selectedSkills: [],
+        skillRecords: [],
+      });
+    });
+
+    rerender({ sessionKey: 'session-sent' });
+    expect(result.current.inputSnapshot.text).toBe('');
+
+    rerender({ sessionKey: 'session-unsent' });
+    expect(result.current.inputSnapshot.text).toBe('仍未发送的草稿');
+  });
 });