@nextclaw/ui 0.26.5 → 0.27.1

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

@@ -5,12 +5,14 @@ import type {
   UiNcpSessionQueuedInputView,
 } from '@nextclaw/client-sdk';
 import type { NcpAgentSendEnvelope, NcpRunHandle } from '@nextclaw/ncp';
+import { NcpHttpSendError } from '@nextclaw/ncp-http-agent-client';
 
 import {
   createChatComposerNodesFromDraft,
   deriveNcpMessagePartsFromComposer,
 } from '@/features/chat/features/input/utils/chat-composer-state.utils';
 import { isNcpChatSendDisabled } from '@/features/chat/features/input/utils/ncp-chat-input-availability.utils';
+import { t } from '@/shared/lib/i18n';
 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 type { SessionQueuedInputAttachmentPreview } from '@/features/chat/features/conversation/utils/session-queued-input.utils';
@@ -25,6 +27,7 @@ import {
   useSessionConversationRecoveryActions,
   type SessionConversationRecoveryAgent,
 } from './use-session-conversation-recovery-actions';
+import { useSessionSubmissionRecovery } from './use-session-submission-recovery';
 
 type SessionConversationInputQuery = ReturnType<typeof useSessionConversationInputQuery>;
 type ComposerDraftSnapshot = Pick<
@@ -80,8 +83,12 @@ type UseSessionConversationControllerParams = {
   readonly selectedAgentId: string;
   readonly sessionKey: string | null;
   readonly onSessionMaterialized?: (sessionKey: string) => void;
-  readonly resetComposer: () => void;
   readonly restoreComposer: (snapshot: ComposerDraftSnapshot) => void;
+  readonly beginSubmission: (envelope: NcpAgentSendEnvelope, composer: ComposerDraftSnapshot) => void;
+  readonly acceptSubmission: (messageId: string) => void;
+  readonly failSubmission: (messageId: string, status: 'uncertain' | 'rejected', message: string) => void;
+  readonly restoreSubmission: (messageId: string) => void;
+  readonly discardSubmission: (messageId: string) => void;
   readonly setSendError: (message: string | null) => void;
 };
 
@@ -90,7 +97,6 @@ type BuildSubmissionDraftParams = {
   readonly composerSnapshot?: ComposerDraftSnapshot;
   readonly inputSnapshot: SessionConversationInputSnapshot;
   readonly inputQuery: SessionConversationInputQuery;
-  readonly isRuntimeBlocked: boolean;
   readonly materializationContext?: SessionConversationMaterializationContext | null;
   readonly selectedAgentId: string;
   readonly sessionKey: string | null;
@@ -111,21 +117,12 @@ const resolveModelForSend = (value: string | null | undefined): string | undefin
   return trimmed || undefined;
 };
 
-function buildInputAvailabilitySnapshot(inputQuery: SessionConversationInputQuery) {
-  return {
-    isProviderStateResolved: inputQuery.isProviderStateResolved,
-    modelOptions: inputQuery.modelOptions,
-    sessionTypeUnavailable: inputQuery.sessionTypeState.sessionTypeUnavailable,
-  };
-}
-
 function buildSubmissionDraft(params: BuildSubmissionDraftParams): SubmissionDraft | null {
   const {
     agentIsSending,
     composerSnapshot: requestedComposerSnapshot,
     inputQuery,
     inputSnapshot,
-    isRuntimeBlocked,
     materializationContext,
     selectedAgentId,
     sessionKey,
@@ -142,10 +139,9 @@ function buildSubmissionDraft(params: BuildSubmissionDraftParams): SubmissionDra
     composerSnapshot.attachments,
   );
   if (
+    inputSnapshot.pendingSubmission ||
     isNcpChatSendDisabled({
-      snapshot: buildInputAvailabilitySnapshot(inputQuery),
       hasSendableDraft: hasSendableMessagePart(currentParts),
-      isRuntimeBlocked,
     }) ||
     agentIsSending
   ) {
@@ -197,6 +193,7 @@ function buildSubmissionEnvelope(
 ): NcpAgentSendEnvelope | null {
   const envelope = buildNcpRequestEnvelope({
     sessionId: sessionKey ?? undefined,
+    messageId: `user-${crypto.randomUUID()}`,
     text: draft.composerSnapshot.text.trim(),
     attachments: [...draft.composerSnapshot.attachments],
     parts: deriveNcpMessagePartsFromComposer(
@@ -205,7 +202,7 @@ function buildSubmissionEnvelope(
     ),
     metadata: draft.metadata,
   });
-  return envelope ? { ...envelope, delivery } : null;
+  return envelope ? { ...envelope, delivery, idempotencyKey: envelope.message.id } : null;
 }
 
 function useSubmissionDraftRunner(params: {
@@ -213,8 +210,9 @@ function useSubmissionDraftRunner(params: {
   readonly clearSubmittingInput: (input: SubmittingQueuedInput) => void;
   readonly materializationContext?: SessionConversationMaterializationContext | null;
   readonly onSessionMaterialized?: (sessionKey: string) => void;
-  readonly resetComposer: () => void;
-  readonly restoreComposer: (snapshot: ComposerDraftSnapshot) => void;
+  readonly beginSubmission: (envelope: NcpAgentSendEnvelope, composer: ComposerDraftSnapshot) => void;
+  readonly acceptSubmission: (messageId: string) => void;
+  readonly failSubmission: (messageId: string, status: 'uncertain' | 'rejected', message: string) => void;
   readonly runQueue: SessionRunQueue;
   readonly sessionKey: string | null;
   readonly setSendError: (message: string | null) => void;
@@ -225,8 +223,9 @@ function useSubmissionDraftRunner(params: {
     clearSubmittingInput,
     materializationContext,
     onSessionMaterialized,
-    resetComposer,
-    restoreComposer,
+    beginSubmission,
+    acceptSubmission,
+    failSubmission,
     runQueue,
     sessionKey,
     setSendError,
@@ -244,10 +243,16 @@ function useSubmissionDraftRunner(params: {
     const queuedSubmission = agent.isRunning && delivery === 'queue'
       ? stageSubmittingInput(envelope)
       : null;
-    if (composerBehavior === 'reset-and-restore') resetComposer();
+    if (composerBehavior === 'reset-and-restore') beginSubmission(envelope, draft.composerSnapshot);
     setSendError(null);
+    let definitelyRejected = false;
     try {
       const handle = await agent.send(envelope);
+      if (!handle) {
+        definitelyRejected = true;
+        throw new Error(t('chatSendFailed'));
+      }
+      if (composerBehavior === 'reset-and-restore') acceptSubmission(envelope.message.id);
       if (handle?.delivery === 'steered') {
         await runQueue.refreshPendingInputs().catch(() => undefined);
       } else if (handle?.delivery === 'queued') {
@@ -261,8 +266,12 @@ function useSubmissionDraftRunner(params: {
       }
     } catch (error) {
       if (queuedSubmission) clearSubmittingInput(queuedSubmission);
-      if (composerBehavior === 'reset-and-restore') restoreComposer(draft.composerSnapshot);
-      setSendError(error instanceof Error ? error.message : String(error));
+      const message = error instanceof Error ? error.message : String(error);
+      if (composerBehavior === 'reset-and-restore') {
+        failSubmission(envelope.message.id,
+          definitelyRejected || (error instanceof NcpHttpSendError && error.sendRejected) ? 'rejected' : 'uncertain',
+          message);
+      } else setSendError(message);
       throw error;
     }
   }, [
@@ -270,8 +279,9 @@ function useSubmissionDraftRunner(params: {
     clearSubmittingInput,
     materializationContext,
     onSessionMaterialized,
-    resetComposer,
-    restoreComposer,
+    beginSubmission,
+    acceptSubmission,
+    failSubmission,
     runQueue,
     sessionKey,
     setSendError,
@@ -283,7 +293,6 @@ 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;
@@ -297,7 +306,6 @@ function useSteeringSubmission(params: {
     agent,
     inputQuery,
     inputSnapshot,
-    isRuntimeBlocked,
     materializationContext,
     selectedAgentId,
     sessionKey,
@@ -308,7 +316,6 @@ function useSteeringSubmission(params: {
       agentIsSending: agent.isSending,
       inputSnapshot,
       inputQuery,
-      isRuntimeBlocked,
       materializationContext,
       selectedAgentId,
       sessionKey,
@@ -318,7 +325,6 @@ function useSteeringSubmission(params: {
     agent.isSending,
     inputQuery,
     inputSnapshot,
-    isRuntimeBlocked,
     materializationContext,
     selectedAgentId,
     sessionKey,
@@ -331,7 +337,6 @@ function usePrimarySubmission(params: {
   readonly continueRun: () => Promise<void>;
   readonly inputSnapshot: SessionConversationInputSnapshot;
   readonly inputQuery: SessionConversationInputQuery;
-  readonly isRuntimeBlocked: boolean;
   readonly materializationContext?: SessionConversationMaterializationContext | null;
   readonly primaryAction: 'continue' | 'send';
   readonly selectedAgentId: string;
@@ -346,7 +351,6 @@ function usePrimarySubmission(params: {
     continueRun,
     inputQuery,
     inputSnapshot,
-    isRuntimeBlocked,
     materializationContext,
     primaryAction,
     selectedAgentId,
@@ -359,7 +363,6 @@ function usePrimarySubmission(params: {
       agentIsSending: agent.isSending,
       inputSnapshot,
       inputQuery,
-      isRuntimeBlocked,
       materializationContext,
       selectedAgentId,
       sessionKey,
@@ -370,7 +373,6 @@ function usePrimarySubmission(params: {
     continueRun,
     inputQuery,
     inputSnapshot,
-    isRuntimeBlocked,
     materializationContext,
     primaryAction,
     selectedAgentId,
@@ -379,6 +381,32 @@ function usePrimarySubmission(params: {
   ]);
 }
 
+function usePresetSubmission(params: {
+  readonly agent: SessionConversationAgent;
+  readonly inputSnapshot: SessionConversationInputSnapshot;
+  readonly inputQuery: SessionConversationInputQuery;
+  readonly materializationContext?: SessionConversationMaterializationContext | null;
+  readonly selectedAgentId: string;
+  readonly sessionKey: string | null;
+  readonly submitDraft: (draft: SubmissionDraft, behavior: SubmissionComposerBehavior) => Promise<void>;
+}) {
+  const { agent, inputSnapshot, inputQuery, materializationContext, selectedAgentId, sessionKey, submitDraft } = params;
+  return useCallback(async (message: string) => {
+    const text = message.trim();
+    if (!text) return;
+    const draft = buildSubmissionDraft({
+      agentIsSending: agent.isSending,
+      composerSnapshot: {
+        text,
+        nodes: createChatComposerNodesFromDraft(text),
+        selectedSkills: [], skillRecords: [], attachments: [],
+      },
+      inputSnapshot, inputQuery, materializationContext, selectedAgentId, sessionKey,
+    });
+    if (draft) await submitDraft(draft, 'preserve');
+  }, [agent.isSending, inputQuery, inputSnapshot, materializationContext, selectedAgentId, sessionKey, submitDraft]);
+}
+
 export function useSessionConversationController(params: UseSessionConversationControllerParams) {
   const {
     agent,
@@ -390,8 +418,12 @@ export function useSessionConversationController(params: UseSessionConversationC
     selectedAgentId,
     sessionKey,
     onSessionMaterialized,
-    resetComposer,
     restoreComposer,
+    beginSubmission,
+    acceptSubmission,
+    failSubmission,
+    restoreSubmission,
+    discardSubmission,
     setSendError,
   } = params;
   const {
@@ -421,12 +453,10 @@ export function useSessionConversationController(params: UseSessionConversationC
   );
   const primaryAction: 'continue' | 'send' =
     canContinue && !hasSendableDraft ? 'continue' : 'send';
-  const sendDisabled = primaryAction === 'continue'
+  const sendDisabled = inputSnapshot.pendingSubmission ? true : primaryAction === 'continue'
     ? false
     : isNcpChatSendDisabled({
-        snapshot: buildInputAvailabilitySnapshot(inputQuery),
         hasSendableDraft,
-        isRuntimeBlocked,
       }) || agent.isSending;
 
   const { continueRun, editMessage } = useSessionConversationRecoveryActions({
@@ -440,8 +470,9 @@ export function useSessionConversationController(params: UseSessionConversationC
     clearSubmittingInput,
     materializationContext,
     onSessionMaterialized,
-    resetComposer,
-    restoreComposer,
+    beginSubmission,
+    acceptSubmission,
+    failSubmission,
     runQueue,
     sessionKey,
     setSendError,
@@ -453,7 +484,6 @@ export function useSessionConversationController(params: UseSessionConversationC
     continueRun,
     inputQuery,
     inputSnapshot,
-    isRuntimeBlocked,
     materializationContext,
     primaryAction,
     selectedAgentId,
@@ -465,52 +495,33 @@ export function useSessionConversationController(params: UseSessionConversationC
     agent,
     inputQuery,
     inputSnapshot,
-    isRuntimeBlocked,
     materializationContext,
     selectedAgentId,
     sessionKey,
     submitDraft,
   });
 
-  const sendPresetMessage = useCallback(async (message: string) => {
-    const text = message.trim();
-    if (!text) {
-      return;
-    }
-    const draft = buildSubmissionDraft({
-      agentIsSending: agent.isSending,
-      composerSnapshot: {
-        text,
-        nodes: createChatComposerNodesFromDraft(text),
-        selectedSkills: [],
-        skillRecords: [],
-        attachments: [],
-      },
-      inputSnapshot,
-      inputQuery,
-      isRuntimeBlocked,
-      materializationContext,
-      selectedAgentId,
-      sessionKey,
-    });
-    if (draft) {
-      await submitDraft(draft, 'preserve');
-    }
-  }, [
-    agent.isSending,
-    inputQuery,
-    inputSnapshot,
-    isRuntimeBlocked,
-    materializationContext,
-    selectedAgentId,
-    sessionKey,
-    submitDraft,
-  ]);
+  const sendPresetMessage = usePresetSubmission({
+    agent, inputSnapshot, inputQuery, materializationContext,
+    selectedAgentId, sessionKey, submitDraft,
+  });
 
   const stop = useCallback(async () => {
     await agent.abort();
   }, [agent]);
 
+  const submissionRecovery = useSessionSubmissionRecovery({
+    agent,
+    submission: inputSnapshot.pendingSubmission,
+    sessionKey,
+    onSessionMaterialized,
+    acceptSubmission,
+    failSubmission,
+    restoreSubmission,
+    discardSubmission,
+    setSendError,
+  });
+
   return {
     canContinue,
     canStopGeneration: agent.isRunning,
@@ -525,6 +536,7 @@ export function useSessionConversationController(params: UseSessionConversationC
     send,
     sendSteering,
     sendPresetMessage,
+    ...submissionRecovery,
     sendDisabled,
     primaryAction,
     stop,

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

@@ -12,7 +12,7 @@ import {
   filterNcpChatModelOptionsBySessionType,
 } from '@/features/chat/features/ncp/utils/ncp-chat-query-derived.utils';
 import { adaptNcpSessionSummaries } from '@/features/chat/features/session/utils/ncp-session-adapter.utils';
-import { resolveRecentSessionPreferredValue } from '@/features/chat/features/session/utils/chat-session-preference-governance.utils';
+import { resolveRecentSessionPreferenceSnapshot } from '@/features/chat/features/session/utils/chat-session-preference-governance.utils';
 import { useChatSessionTypeState } from '@/features/chat/features/session-type/hooks/use-chat-session-type-state';
 import { chatRecentModelsManager } from '@/features/chat/managers/chat-recent-models.manager';
 import { useChatQueryStore } from '@/features/chat/stores/ncp-chat-query.store';
@@ -112,27 +112,17 @@ export function useSessionConversationInputQuery(params: UseSessionConversationI
   const recentSessionTypeModel = chatRecentModelsManager
     .read({ namespace: sessionTypeState.selectedSessionType })
     .find((value) => availableModelValueSet.has(value));
-  const fallbackPreferredModel = useMemo(
+  const recentSessionPreferences = useMemo(
     () =>
-      recentSessionTypeModel ??
-      resolveRecentSessionPreferredValue<string>({
+      resolveRecentSessionPreferenceSnapshot({
         sessions,
         selectedSessionKey,
         sessionType: sessionTypeState.selectedSessionType,
-        readPreference: (session) => session.preferredModel?.trim() || undefined,
-      }),
-    [recentSessionTypeModel, selectedSessionKey, sessionTypeState.selectedSessionType, sessions],
-  );
-  const fallbackPreferredThinking = useMemo(
-    () =>
-      resolveRecentSessionPreferredValue({
-        sessions,
-        selectedSessionKey,
-        sessionType: sessionTypeState.selectedSessionType,
-        readPreference: (session) => session.preferredThinking ?? undefined,
       }),
     [selectedSessionKey, sessionTypeState.selectedSessionType, sessions],
   );
+  const fallbackPreferredModel = recentSessionPreferences?.model ?? recentSessionTypeModel;
+  const fallbackPreferredThinking = recentSessionPreferences?.thinking;
 
   const defaultProjectRoot = normalizeSessionProjectRootValue(
     config?.agents.defaults.workspace,

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

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useMemo, type SetStateAction } from 'react';
 import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
 import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
+import type { NcpAgentSendEnvelope } from '@nextclaw/ncp';
 
 import type { ThinkingLevel } from '@/shared/lib/api';
 import { DEFAULT_SESSION_TYPE } from '@/features/chat/features/session-type/utils/chat-session-type.utils';
@@ -10,6 +11,7 @@ import {
   resolveChatComposerDraftKey,
   useChatComposerDraftStore,
   type ChatComposerDraftSnapshot,
+  type ChatComposerSubmission,
 } from '@/features/chat/stores/chat-composer-draft.store';
 import {
   useSessionConversationPreferenceActions,
@@ -38,6 +40,7 @@ export type SessionConversationInputSnapshot = SessionConversationComposerState
   readonly pendingProjectRoot: string | null;
   readonly composerFocusRequestId: number;
   readonly sendError: string | null;
+  readonly pendingSubmission?: ChatComposerSubmission | null;
 };
 
 type SessionConversationOwnedInputSnapshot = ChatComposerDraftSnapshot;
@@ -49,7 +52,11 @@ export type SessionConversationInputPatch =
 export type SessionConversationInputActions = {
   readonly update: (patch: SessionConversationInputPatch) => void;
   readonly syncComposer: (composer: SessionConversationComposerState) => void;
-  readonly resetComposer: () => void;
+  readonly beginSubmission: (envelope: NcpAgentSendEnvelope, composer: ChatComposerSubmission['composer']) => void;
+  readonly acceptSubmission: (messageId: string) => void;
+  readonly failSubmission: (messageId: string, status: 'uncertain' | 'rejected', message: string) => void;
+  readonly restoreSubmission: (messageId: string) => void;
+  readonly discardSubmission: (messageId: string) => void;
   readonly restoreComposer: (
     composer: SessionConversationComposerState & {
       readonly attachments?: readonly NcpDraftAttachment[];
@@ -176,6 +183,7 @@ function usePersistedConversationInputSnapshot(
   const snapshot = useChatComposerDraftStore(
     (state) => state.drafts[draftKey] ?? initialSnapshot,
   );
+  const pendingSubmission = useChatComposerDraftStore((state) => state.submissions[draftKey] ?? null);
 
   useEffect(() => {
     useChatComposerDraftStore.getState().ensureDraft(draftKey, initialSnapshot);
@@ -196,7 +204,35 @@ function usePersistedConversationInputSnapshot(
     });
   }, [draftKey, initialSnapshot]);
 
-  return { draftKey, snapshot, update };
+  const beginSubmission = useCallback((
+    envelope: NcpAgentSendEnvelope,
+    composer: ChatComposerSubmission['composer'],
+  ) => {
+    useChatComposerDraftStore.getState().beginSubmission(draftKey, snapshot, {
+      envelope, composer, status: 'sending',
+    });
+  }, [draftKey, snapshot]);
+  const acceptSubmission = useCallback((messageId: string) => {
+    useChatComposerDraftStore.getState().acceptSubmission(draftKey, messageId);
+  }, [draftKey]);
+  const failSubmission = useCallback((
+    messageId: string,
+    status: 'uncertain' | 'rejected',
+    message: string,
+  ) => {
+    useChatComposerDraftStore.getState().failSubmission(draftKey, messageId, status, message);
+  }, [draftKey]);
+  const restoreSubmission = useCallback((messageId: string) => {
+    useChatComposerDraftStore.getState().restoreSubmission(draftKey, messageId);
+  }, [draftKey]);
+  const discardSubmission = useCallback((messageId: string) => {
+    useChatComposerDraftStore.getState().discardSubmission(draftKey, messageId);
+  }, [draftKey]);
+
+  return {
+    draftKey, snapshot, pendingSubmission, update,
+    beginSubmission, acceptSubmission, failSubmission, restoreSubmission, discardSubmission,
+  };
 }
 
 export const useSessionConversationInputState = (
@@ -204,7 +240,10 @@ export const useSessionConversationInputState = (
   sessionKey: string | null = null,
 ) => {
   const pendingProjectRoot = useChatThreadStore((state) => state.snapshot.draftProjectRoot);
-  const { draftKey, snapshot, update } = usePersistedConversationInputSnapshot(
+  const {
+    draftKey, snapshot, pendingSubmission, update,
+    beginSubmission, acceptSubmission, failSubmission, restoreSubmission, discardSubmission,
+  } = usePersistedConversationInputSnapshot(
     initialPrompt,
     sessionKey,
   );
@@ -219,14 +258,6 @@ export const useSessionConversationInputState = (
     });
   }, [update]);
 
-  const resetComposer = useCallback(() => {
-    update({
-      ...EMPTY_COMPOSER_STATE,
-      attachments: [],
-      sendError: null,
-    });
-  }, [update]);
-
   const restoreComposer = useCallback((
     composer: SessionConversationComposerState & {
       readonly attachments?: readonly NcpDraftAttachment[];
@@ -309,7 +340,11 @@ export const useSessionConversationInputState = (
   const actions = useMemo<SessionConversationInputActions>(() => ({
     update,
     syncComposer,
-    resetComposer,
+    beginSubmission,
+    acceptSubmission,
+    failSubmission,
+    restoreSubmission,
+    discardSubmission,
     restoreComposer,
     applyPromptSuggestion,
     requestComposerFocusAtEnd,
@@ -325,7 +360,11 @@ export const useSessionConversationInputState = (
   }), [
     update,
     syncComposer,
-    resetComposer,
+    beginSubmission,
+    acceptSubmission,
+    failSubmission,
+    restoreSubmission,
+    discardSubmission,
     restoreComposer,
     applyPromptSuggestion,
     requestComposerFocusAtEnd,
@@ -344,6 +383,7 @@ export const useSessionConversationInputState = (
     inputSnapshot: {
       ...snapshot,
       pendingProjectRoot,
+      pendingSubmission,
     },
     inputActions: actions,
   };

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

@@ -0,0 +1,83 @@
+import { useCallback, useEffect, useRef } from 'react';
+import type { NcpAgentSendEnvelope, NcpRunHandle } from '@nextclaw/ncp';
+import { NcpHttpSendError } from '@nextclaw/ncp-http-agent-client';
+import { fetchNcpSessionMessages } from '@/shared/lib/api';
+import { t } from '@/shared/lib/i18n';
+import type { ChatComposerSubmission } from '@/features/chat/stores/chat-composer-draft.store';
+
+async function hasAcceptedSubmission(submission: ChatComposerSubmission): Promise<boolean> {
+  const sessionId = submission.envelope.sessionId?.trim();
+  if (!sessionId) return false;
+  try {
+    const response = await fetchNcpSessionMessages(sessionId, { limit: 100 });
+    return response.messages.some((message) => message.id === submission.envelope.message.id);
+  } catch {
+    return false;
+  }
+}
+
+export function useSessionSubmissionRecovery(params: {
+  readonly agent: { send: (envelope: NcpAgentSendEnvelope) => Promise<NcpRunHandle | null> };
+  readonly submission?: ChatComposerSubmission | null;
+  readonly sessionKey: string | null;
+  readonly onSessionMaterialized?: (sessionKey: string) => void;
+  readonly acceptSubmission: (messageId: string) => void;
+  readonly failSubmission: (messageId: string, status: 'uncertain' | 'rejected', message: string) => void;
+  readonly restoreSubmission: (messageId: string) => void;
+  readonly discardSubmission: (messageId: string) => void;
+  readonly setSendError: (message: string | null) => void;
+}) {
+  const {
+    agent, submission, sessionKey, onSessionMaterialized,
+    acceptSubmission, failSubmission, restoreSubmission, discardSubmission, setSendError,
+  } = params;
+  const retryPendingSubmission = useCallback(async () => {
+    if (!submission || submission.status !== 'uncertain') return;
+    const { envelope } = submission;
+    if (await hasAcceptedSubmission(submission)) {
+      acceptSubmission(envelope.message.id);
+      if (!sessionKey && envelope.sessionId) onSessionMaterialized?.(envelope.sessionId);
+      return;
+    }
+    if (!envelope.sessionId) {
+      setSendError(t('chatSendResultUnknownChild'));
+      return;
+    }
+    try {
+      const handle = await agent.send(envelope);
+      if (!handle) throw new Error(t('chatSendFailed'));
+      acceptSubmission(envelope.message.id);
+      if (!sessionKey) onSessionMaterialized?.(handle.sessionId);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      failSubmission(envelope.message.id,
+        error instanceof NcpHttpSendError && error.sendRejected ? 'rejected' : 'uncertain',
+        message);
+    }
+  }, [acceptSubmission, agent, failSubmission, onSessionMaterialized, sessionKey, setSendError, submission]);
+
+  const checkedSubmissionRef = useRef<string | null>(null);
+  useEffect(() => {
+    if (!submission || submission.status !== 'uncertain' ||
+      checkedSubmissionRef.current === submission.envelope.message.id) return;
+    checkedSubmissionRef.current = submission.envelope.message.id;
+    void hasAcceptedSubmission(submission).then((accepted) => {
+      if (accepted) {
+        acceptSubmission(submission.envelope.message.id);
+        if (!sessionKey && submission.envelope.sessionId) {
+          onSessionMaterialized?.(submission.envelope.sessionId);
+        }
+      }
+    });
+  }, [acceptSubmission, onSessionMaterialized, sessionKey, submission]);
+
+  return {
+    retryPendingSubmission,
+    restorePendingSubmission: () => {
+      if (submission) restoreSubmission(submission.envelope.message.id);
+    },
+    discardPendingSubmission: () => {
+      if (submission?.status === 'rejected') discardSubmission(submission.envelope.message.id);
+    },
+  };
+}

package/src/features/chat/features/conversation/types/session-conversation-input.types.ts

@@ -0,0 +1,38 @@
+import type { ChatContextWindowIndicator } from '@nextclaw/agent-chat-ui';
+import type { SessionConversationQueuedInput } from '@/features/chat/features/conversation/hooks/use-session-conversation-controller';
+import type { useSessionConversationInputQuery } from '@/features/chat/features/conversation/hooks/use-session-conversation-input-query';
+import type {
+  SessionConversationInputActions,
+  SessionConversationInputSnapshot,
+} from '@/features/chat/features/conversation/hooks/use-session-conversation-input-state';
+
+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 retryPendingSubmission: () => Promise<void> | void;
+  readonly restorePendingSubmission: () => void;
+  readonly discardPendingSubmission: () => void;
+  readonly stop: () => Promise<void> | void;
+  readonly steerQueuedInput: (id: string) => void;
+};
+
+export type SessionConversationInputProps = {
+  readonly contextWindow: ChatContextWindowIndicator | null;
+  readonly controller: SessionConversationInputController;
+  readonly inputActions: SessionConversationInputActions;
+  readonly inputQuery: ReturnType<typeof useSessionConversationInputQuery>;
+  readonly inputSnapshot: SessionConversationInputSnapshot;
+  readonly onContextCompactingChange?: (sessionId: string, isCompacting: boolean) => void;
+  readonly placeholder?: string;
+  readonly surface?: 'default' | 'embedded';
+};