@nextclaw/ui 0.15.25 → 0.15.27

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

@@ -1,4 +1,4 @@
-import { useCallback, useMemo } from 'react';
+import { useCallback, useMemo, useState } from 'react';
 import { buildNcpRequestEnvelope } from '@nextclaw/ncp-react';
 import type { UiNcpSessionQueuedInputView } from '@nextclaw/client-sdk';
 import type { NcpAgentSendEnvelope, NcpRunHandle } from '@nextclaw/ncp';
@@ -39,11 +39,13 @@ type SessionConversationAgent = SessionConversationRecoveryAgent & {
 
 export type SessionConversationQueuedInput = {
   readonly id: string;
+  readonly isSubmitting?: boolean;
   readonly preview: string;
 };
 
 type SessionRunQueue = {
   readonly inputs: readonly UiNcpSessionQueuedInputView[];
+  readonly refreshQueuedInputs: () => Promise<readonly UiNcpSessionQueuedInputView[]>;
   readonly removeQueuedInput: (
     queuedInputId: string,
   ) => Promise<UiNcpSessionQueuedInputView | null>;
@@ -85,6 +87,13 @@ type SubmissionDraft = {
   readonly metadata: Record<string, unknown>;
 };
 
+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);
 
@@ -188,6 +197,97 @@ function buildSubmissionEnvelope(
   });
 }
 
+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 };
+}
+
 export function useSessionConversationController(params: UseSessionConversationControllerParams) {
   const {
     agent,
@@ -203,6 +303,17 @@ export function useSessionConversationController(params: UseSessionConversationC
     restoreComposer,
     setSendError,
   } = params;
+  const {
+    clearSubmittingInput,
+    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],
@@ -255,10 +366,17 @@ export function useSessionConversationController(params: UseSessionConversationC
     if (!envelope) {
       return;
     }
+    const queuedSubmission = agent.isRunning ? stageSubmittingInput(envelope) : null;
     resetComposer();
     setSendError(null);
     try {
       const handle = await agent.send(envelope);
+      if (queuedSubmission && handle?.runId === null) {
+        await runQueue.refreshQueuedInputs().catch(() => undefined);
+      }
+      if (queuedSubmission) {
+        clearSubmittingInput(queuedSubmission);
+      }
       const materializedSessionKey =
         handle?.sessionId?.trim() ||
         agent.snapshot.activeRun?.sessionId?.trim() ||
@@ -267,12 +385,16 @@ export function useSessionConversationController(params: UseSessionConversationC
         onSessionMaterialized?.(materializedSessionKey);
       }
     } catch (error) {
+      if (queuedSubmission) {
+        clearSubmittingInput(queuedSubmission);
+      }
       restoreComposer(draft.composerSnapshot);
       setSendError(error instanceof Error ? error.message : String(error));
       throw error;
     }
   }, [
     agent,
+    clearSubmittingInput,
     continueRun,
     inputQuery,
     inputSnapshot,
@@ -284,36 +406,11 @@ export function useSessionConversationController(params: UseSessionConversationC
     selectedAgentId,
     sessionKey,
     setSendError,
+    stageSubmittingInput,
     primaryAction,
+    runQueue,
   ]);
 
-  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,
-        inputQuery.skillRecords,
-      ));
-      setSendError(null);
-    }).catch((error) => {
-      setSendError(error instanceof Error ? error.message : String(error));
-    });
-  }, [inputQuery.skillRecords, 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]);
-
   const stop = useCallback(async () => {
     await agent.abort();
   }, [agent]);
@@ -327,10 +424,7 @@ export function useSessionConversationController(params: UseSessionConversationC
     editQueuedInput,
     hasSendableDraft,
     isSending,
-    queuedInputs: runQueue.inputs.map((input) => ({
-      id: input.id,
-      preview: buildSessionQueuedInputPreview(input),
-    })),
+    queuedInputs,
     send,
     sendDisabled,
     primaryAction,

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

@@ -16,6 +16,7 @@ export function useSessionRunQueue(sessionKey: string | null) {
     retry: false,
     staleTime: 5_000,
   });
+  const { data, isLoading, refetch } = query;
 
   useEffect(() => {
     if (!normalizedSessionKey) {
@@ -43,9 +44,18 @@ export function useSessionRunQueue(sessionKey: string | null) {
     );
   }, [normalizedSessionKey]);
 
+  const refreshQueuedInputs = useCallback(async (): Promise<readonly UiNcpSessionQueuedInputView[]> => {
+    if (!normalizedSessionKey) {
+      return [];
+    }
+    const result = await refetch();
+    return result.data?.inputs ?? [];
+  }, [normalizedSessionKey, refetch]);
+
   return {
-    inputs: query.data?.inputs ?? [],
-    isLoading: query.isLoading,
+    inputs: data?.inputs ?? [],
+    isLoading,
+    refreshQueuedInputs,
     removeQueuedInput,
   };
 }

package/src/features/chat/features/conversation/hooks/use-system-object-reference-select.ts

@@ -0,0 +1,27 @@
+import { useCallback, type RefObject } from 'react';
+import type { ChatInputBarHandle } from '@nextclaw/agent-chat-ui';
+import { CHAT_SYSTEM_OBJECT_TOKEN_KIND } from '@nextclaw/shared';
+import { toast } from 'sonner';
+
+import { nextclawClient } from '@/shared/lib/api';
+import { t } from '@/shared/lib/i18n';
+
+export function useSystemObjectReferenceSelect(
+  inputBarRef: RefObject<ChatInputBarHandle | null>,
+) {
+  return useCallback((uri: string) => {
+    void nextclawClient.systemObjectReferences.resolve(uri)
+      .then((reference) => {
+        inputBarRef.current?.insertInputSurfaceToken({
+          tokenKind: CHAT_SYSTEM_OBJECT_TOKEN_KIND,
+          tokenKey: reference.uri,
+          label: reference.label,
+          data: { reference },
+        });
+      })
+      .catch((error: unknown) => {
+        const message = error instanceof Error ? error.message : t('error');
+        toast.error(`${t('chatSystemObjectResolveFailed')}: ${message}`);
+      });
+  }, [inputBarRef]);
+}

package/src/features/chat/features/conversation/utils/session-message-composer.utils.ts

@@ -6,6 +6,7 @@ import {
 } from '@nextclaw/agent-chat-ui';
 import type { NcpMessage } from '@nextclaw/ncp';
 import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
+import { CHAT_SYSTEM_OBJECT_TOKEN_KIND } from '@nextclaw/shared';
 
 import { deriveChatComposerDraft } from '@/features/chat/features/input/utils/chat-composer-state.utils';
 import {
@@ -44,6 +45,10 @@ function buildTextNodes(
       tokenKind: nextToken.token.kind,
       tokenKey: 'ref' in nextToken.token ? nextToken.token.ref : nextToken.token.key,
       label: nextToken.token.label,
+      data: nextToken.token.kind === CHAT_SYSTEM_OBJECT_TOKEN_KIND &&
+        'reference' in nextToken.token
+        ? { reference: nextToken.token.reference }
+        : undefined,
     }));
     offset = nextToken.index + nextToken.token.rawText.length;
   }

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

@@ -42,6 +42,14 @@ const useServerPathBrowseMock = vi.hoisted(() =>
     isLoading: false,
   })),
 );
+const useSystemObjectReferencesMock = vi.hoisted(() =>
+  vi.fn(() => ({
+    data: { groups: [], total: 0 },
+    error: null,
+    isFetching: false,
+    isLoading: false,
+  })),
+);
 
 vi.mock('@/features/panel-apps', () => ({
   usePanelApps: usePanelAppsMock,
@@ -55,6 +63,9 @@ vi.mock('@/shared/hooks/use-server-path-search', () => ({
 vi.mock('@/shared/hooks/use-server-path-browse', () => ({
   useServerPathBrowse: useServerPathBrowseMock,
 }));
+vi.mock('@/shared/hooks/use-system-object-references', () => ({
+  useSystemObjectReferences: useSystemObjectReferencesMock,
+}));
 
 function createHookParams() {
   return {
@@ -71,6 +82,7 @@ function createHookParams() {
     language: 'zh' as const,
     onSelectPanelApp: vi.fn(),
     onSelectSkill: vi.fn(),
+    onSelectSystemObject: vi.fn(),
     projectRoot: '/tmp/project',
     recentSkillValues: [],
     skillRecords: [],
@@ -82,6 +94,62 @@ beforeEach(() => {
   useProjectsMock.mockClear();
   useServerPathBrowseMock.mockClear();
   useServerPathSearchMock.mockClear();
+  useSystemObjectReferencesMock.mockReset();
+  useSystemObjectReferencesMock.mockReturnValue({
+    data: { groups: [], total: 0 },
+    error: null,
+    isFetching: false,
+    isLoading: false,
+  } as never);
+});
+
+it('loads the catalog at root and scopes queries after entering a system object group', () => {
+  useSystemObjectReferencesMock.mockReturnValue({
+    data: {
+      groups: [{
+        objectType: 'cron-job',
+        label: { default: 'Scheduled Tasks', translations: { zh: '定时任务' } },
+        description: { default: 'Browse tasks', translations: { zh: '浏览定时任务' } },
+        icon: 'calendar-clock',
+        order: 200,
+        items: [],
+        total: 1,
+      }],
+      total: 1,
+    },
+    error: null,
+    isFetching: false,
+    isLoading: false,
+  } as never);
+  const { result } = renderHook(() => useChatInputSurfaceState(createHookParams()));
+
+  act(() => result.current.setInputSurfaceTrigger({
+    end: 1,
+    key: 'context-reference',
+    marker: '@',
+    query: '',
+    start: 0,
+  }));
+  expect(useSystemObjectReferencesMock).toHaveBeenLastCalledWith({
+    enabled: true,
+    query: '',
+    limit: 6,
+    objectType: undefined,
+  });
+  const groupItem = result.current.inputSurfaceState.panel?.items.find(
+    (item) => item.title === '定时任务',
+  );
+  act(() => result.current.inputSurfaceState.panel?.onSelectItem?.(groupItem!));
+
+  expect(useSystemObjectReferencesMock).toHaveBeenLastCalledWith({
+    enabled: true,
+    query: '',
+    limit: 20,
+    objectType: 'cron-job',
+  });
+  expect(useServerPathSearchMock).toHaveBeenLastCalledWith(expect.objectContaining({
+    enabled: false,
+  }));
 });
 
 it('browses nested folders while reserving search for project-wide queries', () => {
@@ -133,6 +201,40 @@ it('browses nested folders while reserving search for project-wide queries', ()
   });
 });
 
+it('uses a folder-only browser and exposes the current folder as the selection', () => {
+  const { result } = renderHook(() => useChatInputSurfaceState(createHookParams()));
+
+  act(() => result.current.setInputSurfaceTrigger({
+    end: 1,
+    key: 'context-reference',
+    marker: '@',
+    query: '',
+    start: 0,
+  }));
+  const foldersItem = result.current.inputSurfaceState.panel?.items.find(
+    (item) => item.title === '文件夹',
+  );
+  act(() => result.current.inputSurfaceState.panel?.onSelectItem?.(foldersItem!));
+
+  expect(useServerPathBrowseMock).toHaveBeenLastCalledWith({
+    path: '.',
+    basePath: '/tmp/project',
+    includeFiles: false,
+    enabled: true,
+  });
+  expect(result.current.inputSurfaceState.panel?.items).toEqual(expect.arrayContaining([
+    expect.objectContaining({
+      title: '引用当前文件夹',
+      tokenKind: 'workspace_directory',
+      tokenKey: '.',
+    }),
+    expect.objectContaining({
+      title: 'src',
+      selectionBehavior: 'navigate',
+    }),
+  ]));
+});
+
 it('keeps equivalent input surface trigger updates from rerendering the composer owner', () => {
   let renderCount = 0;
   const trigger = {