npm - @nextclaw/ui - Versions diffs - 0.6.10 → 0.6.12 - Mend

@nextclaw/ui 0.6.10 → 0.6.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (90) hide show

package/dist/index.html CHANGED Viewed

@@ -6,9 +6,9 @@
   <link rel="icon" type="image/svg+xml" href="/logo.svg" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>NextClaw - 系统配置</title>
-  <script type="module" crossorigin src="/assets/index-D6_5HaDl.js"></script>
-  <link rel="modulepreload" crossorigin href="/assets/vendor-C--HHaLf.js">
-  <link rel="stylesheet" crossorigin href="/assets/index-BUiahmWm.css">
+  <script type="module" crossorigin src="/assets/index-Dl6t70wA.js"></script>
+  <link rel="modulepreload" crossorigin href="/assets/vendor-d7E8OgNx.js">
+  <link rel="stylesheet" crossorigin href="/assets/index-BXwjfCEO.css">
 </head>
 <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/ui",
-  "version": "0.6.10",
+  "version": "0.6.12",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -24,10 +24,12 @@
     "react-router-dom": "^7.13.0",
     "rehype-sanitize": "^6.0.0",
     "remark-gfm": "^4.0.1",
+    "rxjs": "^7.8.2",
     "sonner": "^1.7.1",
     "tailwind-merge": "^2.5.4",
     "zod": "^3.23.8",
-    "zustand": "^5.0.2"
+    "zustand": "^5.0.2",
+    "@nextclaw/agent-chat": "0.1.1"
   },
   "devDependencies": {
     "@types/react": "^18.3.12",

package/src/App.tsx CHANGED Viewed

@@ -16,6 +16,7 @@ const queryClient = new QueryClient({
 const ModelConfigPage = lazy(async () => ({ default: (await import('@/components/config/ModelConfig')).ModelConfig }));
 const ChatPage = lazy(async () => ({ default: (await import('@/components/chat/ChatPage')).ChatPage }));
+const SearchConfigPage = lazy(async () => ({ default: (await import('@/components/config/SearchConfig')).SearchConfig }));
 const ProvidersListPage = lazy(async () => ({ default: (await import('@/components/config/ProvidersList')).ProvidersList }));
 const ChannelsListPage = lazy(async () => ({ default: (await import('@/components/config/ChannelsList')).ChannelsList }));
 const RuntimeConfigPage = lazy(async () => ({ default: (await import('@/components/config/RuntimeConfig')).RuntimeConfig }));
@@ -41,11 +42,11 @@ function AppContent() {
           <Routes>
             <Route path="/chat/skills" element={<Navigate to="/skills" replace />} />
             <Route path="/chat/cron" element={<Navigate to="/cron" replace />} />
-            <Route path="/chat/:sessionId" element={<LazyRoute><ChatPage view="chat" /></LazyRoute>} />
-            <Route path="/chat" element={<LazyRoute><ChatPage view="chat" /></LazyRoute>} />
+            <Route path="/chat/:sessionId?" element={<LazyRoute><ChatPage view="chat" /></LazyRoute>} />
             <Route path="/skills" element={<LazyRoute><ChatPage view="skills" /></LazyRoute>} />
             <Route path="/cron" element={<LazyRoute><ChatPage view="cron" /></LazyRoute>} />
             <Route path="/model" element={<LazyRoute><ModelConfigPage /></LazyRoute>} />
+            <Route path="/search" element={<LazyRoute><SearchConfigPage /></LazyRoute>} />
             <Route path="/providers" element={<LazyRoute><ProvidersListPage /></LazyRoute>} />
             <Route path="/channels" element={<LazyRoute><ChannelsListPage /></LazyRoute>} />
             <Route path="/runtime" element={<LazyRoute><RuntimeConfigPage /></LazyRoute>} />

package/src/api/config.ts CHANGED Viewed

@@ -14,6 +14,8 @@ import type {
   ProviderAuthPollRequest,
   ProviderAuthPollResult,
   ProviderAuthImportResult,
+  SearchConfigUpdate,
+  SearchConfigView,
   ProviderCreateRequest,
   ProviderCreateResult,
   ProviderDeleteResult,
@@ -27,7 +29,12 @@ import type {
   SessionPatchUpdate,
   ChatTurnRequest,
   ChatTurnView,
+  ChatTurnStreamDeltaEvent,
+  ChatTurnStreamErrorEvent,
+  ChatTurnStreamReadyEvent,
+  ChatTurnStreamSessionEvent,
   ChatCapabilitiesView,
+  ChatSessionTypesView,
   ChatTurnStopRequest,
   ChatTurnStopResult,
   ChatRunListView,
@@ -36,10 +43,7 @@ import type {
   CronListView,
   CronEnableRequest,
   CronRunRequest,
-  CronActionResult,
-  ChatTurnStreamReadyEvent,
-  ChatTurnStreamDeltaEvent,
-  ChatTurnStreamSessionEvent
+  CronActionResult
 } from './types';
 // GET /api/app/meta
@@ -89,6 +93,17 @@ export async function updateModel(data: {
   return response.data;
 }
+// PUT /api/config/search
+export async function updateSearch(
+  data: SearchConfigUpdate
+): Promise<SearchConfigView> {
+  const response = await api.put<SearchConfigView>('/api/config/search', data);
+  if (!response.ok) {
+    throw new Error(response.error.message);
+  }
+  return response.data;
+}
 // PUT /api/config/providers/:provider
 export async function updateProvider(
   provider: string,
@@ -304,91 +319,24 @@ export async function sendChatTurn(data: ChatTurnRequest): Promise<ChatTurnView>
   return response.data;
 }
-// GET /api/chat/capabilities
-export async function fetchChatCapabilities(params?: { sessionKey?: string; agentId?: string }): Promise<ChatCapabilitiesView> {
-  const query = new URLSearchParams();
-  if (params?.sessionKey?.trim()) {
-    query.set('sessionKey', params.sessionKey.trim());
-  }
-  if (params?.agentId?.trim()) {
-    query.set('agentId', params.agentId.trim());
-  }
-  const suffix = query.toString();
-  const response = await api.get<ChatCapabilitiesView>(suffix ? `/api/chat/capabilities?${suffix}` : '/api/chat/capabilities');
-  if (!response.ok) {
-    throw new Error(response.error.message);
-  }
-  return response.data;
-}
-// POST /api/chat/turn/stop
-export async function stopChatTurn(data: ChatTurnStopRequest): Promise<ChatTurnStopResult> {
-  const response = await api.post<ChatTurnStopResult>('/api/chat/turn/stop', data);
-  if (!response.ok) {
-    throw new Error(response.error.message);
-  }
-  return response.data;
-}
-// GET /api/chat/runs
-export async function fetchChatRuns(params?: {
-  sessionKey?: string;
-  states?: ChatRunState[];
-  limit?: number;
-}): Promise<ChatRunListView> {
-  const query = new URLSearchParams();
-  if (params?.sessionKey?.trim()) {
-    query.set('sessionKey', params.sessionKey.trim());
-  }
-  if (Array.isArray(params?.states) && params.states.length > 0) {
-    query.set('states', params.states.join(','));
-  }
-  if (typeof params?.limit === 'number' && Number.isFinite(params.limit)) {
-    query.set('limit', String(Math.max(0, Math.trunc(params.limit))));
-  }
-  const suffix = query.toString();
-  const response = await api.get<ChatRunListView>(suffix ? `/api/chat/runs?${suffix}` : '/api/chat/runs');
-  if (!response.ok) {
-    throw new Error(response.error.message);
-  }
-  return response.data;
-}
-// GET /api/chat/runs/:runId
-export async function fetchChatRun(runId: string): Promise<ChatRunView> {
-  const response = await api.get<ChatRunView>(`/api/chat/runs/${encodeURIComponent(runId)}`);
-  if (!response.ok) {
-    throw new Error(response.error.message);
-  }
-  return response.data;
-}
-type ChatTurnStreamOptions = {
-  signal?: AbortSignal;
-  onReady?: (event: ChatTurnStreamReadyEvent) => void;
-  onDelta?: (event: ChatTurnStreamDeltaEvent) => void;
-  onSessionEvent?: (event: ChatTurnStreamSessionEvent) => void;
-};
-type SseParsedEvent = {
-  event: string;
-  data: string;
-};
-function parseSseFrame(frame: string): SseParsedEvent | null {
-  const lines = frame.split(/\r?\n/);
-  let event = 'message';
+function parseSseFrame(frame: string): { event: string; data: string } | null {
+  const lines = frame.split('\n');
+  let event = '';
   const dataLines: string[] = [];
-  for (const line of lines) {
+  for (const raw of lines) {
+    const line = raw.trimEnd();
+    if (!line || line.startsWith(':')) {
+      continue;
+    }
     if (line.startsWith('event:')) {
-      event = line.slice('event:'.length).trim() || 'message';
+      event = line.slice(6).trim();
       continue;
     }
     if (line.startsWith('data:')) {
-      dataLines.push(line.slice('data:'.length).trimStart());
+      dataLines.push(line.slice(5).trimStart());
     }
   }
-  if (dataLines.length === 0) {
+  if (!event) {
     return null;
   }
   return {
@@ -397,178 +345,242 @@ function parseSseFrame(frame: string): SseParsedEvent | null {
   };
 }
-async function consumeChatTurnSseStream(
-  response: Response,
-  options: ChatTurnStreamOptions = {}
-): Promise<ChatTurnView> {
+async function readSseStream(params: {
+  path: string;
+  method: 'GET' | 'POST';
+  body?: unknown;
+  signal?: AbortSignal;
+  onReady: (event: ChatTurnStreamReadyEvent) => void;
+  onDelta: (event: ChatTurnStreamDeltaEvent) => void;
+  onSessionEvent: (event: ChatTurnStreamSessionEvent) => void;
+}): Promise<{ sessionKey: string; reply: string }> {
+  const response = await fetch(`${API_BASE}${params.path}`, {
+    method: params.method,
+    headers: {
+      'Content-Type': 'application/json',
+      Accept: 'text/event-stream'
+    },
+    ...(params.body !== undefined ? { body: JSON.stringify(params.body) } : {}),
+    ...(params.signal ? { signal: params.signal } : {})
+  });
   if (!response.ok) {
-    let message = `chat stream failed (${response.status} ${response.statusText})`;
-    try {
-      const payload = await response.json() as { ok?: boolean; error?: { message?: string } };
-      if (payload?.error?.message) {
-        message = payload.error.message;
-      }
-    } catch {
-      const text = await response.text().catch(() => '');
-      if (text.trim()) {
-        message = text.trim();
-      }
-    }
-    throw new Error(message);
+    const text = await response.text();
+    const fallback = `HTTP ${response.status}`;
+    const trimmed = text.trim();
+    throw new Error(trimmed || fallback);
   }
-  if (!response.body) {
-    throw new Error('chat stream is not readable');
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error('SSE response body unavailable');
   }
-  const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let buffer = '';
-  let finalView: ChatTurnView | null = null;
+  let finalResult: { sessionKey: string; reply: string } | null = null;
+  let readySessionKey: string | null = null;
-  const handleFrame = (frame: string) => {
+  const consumeFrame = (frame: string) => {
     const parsed = parseSseFrame(frame);
     if (!parsed) {
       return;
     }
-    if (parsed.event === 'ready') {
+    let payload: unknown = undefined;
+    if (parsed.data) {
       try {
-        const readyPayload = JSON.parse(parsed.data) as {
-          sessionKey?: string;
-          requestedAt?: string;
-          runId?: string;
-          stopSupported?: boolean;
-          stopReason?: string;
-        };
-        options.onReady?.({
-          event: 'ready',
-          sessionKey: String(readyPayload.sessionKey ?? ''),
-          requestedAt: String(readyPayload.requestedAt ?? ''),
-          ...(typeof readyPayload.runId === 'string' && readyPayload.runId.trim().length > 0
-            ? { runId: readyPayload.runId.trim() }
-            : {}),
-          ...(typeof readyPayload.stopSupported === 'boolean'
-            ? { stopSupported: readyPayload.stopSupported }
-            : {}),
-          ...(typeof readyPayload.stopReason === 'string' && readyPayload.stopReason.trim().length > 0
-            ? { stopReason: readyPayload.stopReason.trim() }
-            : {})
-        });
+        payload = JSON.parse(parsed.data);
       } catch {
-        // ignore malformed ready event payload
+        payload = undefined;
       }
+    }
+    if (parsed.event === 'ready') {
+      const ready = (payload ?? {}) as ChatTurnStreamReadyEvent;
+      readySessionKey = typeof ready.sessionKey === 'string' && ready.sessionKey.trim() ? ready.sessionKey : readySessionKey;
+      params.onReady(ready);
       return;
     }
     if (parsed.event === 'delta') {
-      try {
-        const deltaPayload = JSON.parse(parsed.data) as { delta?: string };
-        if (typeof deltaPayload.delta === 'string' && deltaPayload.delta.length > 0) {
-          options.onDelta?.({
-            event: 'delta',
-            delta: deltaPayload.delta
-          });
-        }
-      } catch {
-        // ignore malformed delta event payload
-      }
+      params.onDelta((payload ?? { delta: '' }) as ChatTurnStreamDeltaEvent);
       return;
     }
     if (parsed.event === 'session_event') {
-      try {
-        options.onSessionEvent?.({
-          event: 'session_event',
-          data: JSON.parse(parsed.data)
-        });
-      } catch {
-        // ignore malformed session_event payload
-      }
+      params.onSessionEvent({ data: payload as ChatTurnStreamSessionEvent['data'] });
       return;
     }
     if (parsed.event === 'final') {
-      finalView = JSON.parse(parsed.data) as ChatTurnView;
+      const result = payload as ChatTurnView;
+      finalResult = {
+        sessionKey: typeof result?.sessionKey === 'string' && result.sessionKey.trim()
+          ? result.sessionKey
+          : (readySessionKey ?? ''),
+        reply: typeof result?.reply === 'string' ? result.reply : ''
+      };
       return;
     }
     if (parsed.event === 'error') {
-      try {
-        const errPayload = JSON.parse(parsed.data) as { message?: string };
-        throw new Error(typeof errPayload.message === 'string' && errPayload.message ? errPayload.message : 'chat stream failed');
-      } catch (error) {
-        if (error instanceof Error) {
-          throw error;
-        }
-        throw new Error('chat stream failed');
-      }
+      const errorPayload = (payload ?? {}) as ChatTurnStreamErrorEvent;
+      throw new Error((errorPayload.message ?? '').trim() || 'chat stream failed');
     }
   };
-  let streamDone = false;
-  while (!streamDone) {
-    const { done, value } = await reader.read();
-    if (done) {
-      streamDone = true;
-      continue;
-    }
-    buffer += decoder.decode(value, { stream: true });
-    let boundary = buffer.indexOf('\n\n');
-    while (boundary !== -1) {
-      const frame = buffer.slice(0, boundary).trim();
-      buffer = buffer.slice(boundary + 2);
-      if (frame) {
-        handleFrame(frame);
+  try {
+    let isReading = true;
+    while (isReading) {
+      const { value, done } = await reader.read();
+      if (done) {
+        isReading = false;
+        continue;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      let boundary = buffer.indexOf('\n\n');
+      while (boundary !== -1) {
+        const frame = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        consumeFrame(frame);
+        boundary = buffer.indexOf('\n\n');
       }
-      boundary = buffer.indexOf('\n\n');
     }
+    if (buffer.trim()) {
+      consumeFrame(buffer);
+    }
+  } finally {
+    reader.releaseLock();
   }
-  const trailing = buffer.trim();
-  if (trailing) {
-    handleFrame(trailing);
+  if (finalResult) {
+    return finalResult;
   }
-  if (!finalView) {
-    throw new Error('chat stream ended without final result');
+  if (readySessionKey) {
+    return { sessionKey: readySessionKey, reply: '' };
   }
-  return finalView;
+  throw new Error('chat stream ended without final event');
 }
+// POST /api/chat/turn/stream
 export async function sendChatTurnStream(
   data: ChatTurnRequest,
-  options: ChatTurnStreamOptions = {}
-): Promise<ChatTurnView> {
-  const response = await fetch(`${API_BASE}/api/chat/turn/stream`, {
+  params: {
+    signal?: AbortSignal;
+    onReady: (event: ChatTurnStreamReadyEvent) => void;
+    onDelta: (event: ChatTurnStreamDeltaEvent) => void;
+    onSessionEvent: (event: ChatTurnStreamSessionEvent) => void;
+  }
+): Promise<{ sessionKey: string; reply: string }> {
+  return readSseStream({
+    path: '/api/chat/turn/stream',
     method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Accept: 'text/event-stream'
-    },
-    body: JSON.stringify(data),
-    signal: options.signal
+    body: data,
+    signal: params.signal,
+    onReady: params.onReady,
+    onDelta: params.onDelta,
+    onSessionEvent: params.onSessionEvent
   });
-  return consumeChatTurnSseStream(response, options);
 }
+// GET /api/chat/runs/:runId/stream
 export async function streamChatRun(
-  params: {
+  data: {
     runId: string;
     fromEventIndex?: number;
   },
-  options: ChatTurnStreamOptions = {}
-): Promise<ChatTurnView> {
+  params: {
+    signal?: AbortSignal;
+    onReady: (event: ChatTurnStreamReadyEvent) => void;
+    onDelta: (event: ChatTurnStreamDeltaEvent) => void;
+    onSessionEvent: (event: ChatTurnStreamSessionEvent) => void;
+  }
+): Promise<{ sessionKey: string; reply: string }> {
   const query = new URLSearchParams();
-  if (typeof params.fromEventIndex === 'number' && Number.isFinite(params.fromEventIndex)) {
-    query.set('fromEventIndex', String(Math.max(0, Math.trunc(params.fromEventIndex))));
+  if (typeof data.fromEventIndex === 'number' && Number.isFinite(data.fromEventIndex)) {
+    query.set('fromEventIndex', String(Math.max(0, Math.trunc(data.fromEventIndex))));
   }
   const suffix = query.toString();
-  const url = `${API_BASE}/api/chat/runs/${encodeURIComponent(params.runId)}/stream${suffix ? `?${suffix}` : ''}`;
-  const response = await fetch(url, {
+  const path = `/api/chat/runs/${encodeURIComponent(data.runId)}/stream${suffix ? `?${suffix}` : ''}`;
+  return readSseStream({
+    path,
     method: 'GET',
-    headers: {
-      Accept: 'text/event-stream'
-    },
-    signal: options.signal
+    signal: params.signal,
+    onReady: params.onReady,
+    onDelta: params.onDelta,
+    onSessionEvent: params.onSessionEvent
   });
-  return consumeChatTurnSseStream(response, options);
+}
+// GET /api/chat/capabilities
+export async function fetchChatCapabilities(params?: { sessionKey?: string; agentId?: string }): Promise<ChatCapabilitiesView> {
+  const query = new URLSearchParams();
+  if (params?.sessionKey?.trim()) {
+    query.set('sessionKey', params.sessionKey.trim());
+  }
+  if (params?.agentId?.trim()) {
+    query.set('agentId', params.agentId.trim());
+  }
+  const suffix = query.toString();
+  const response = await api.get<ChatCapabilitiesView>(suffix ? `/api/chat/capabilities?${suffix}` : '/api/chat/capabilities');
+  if (!response.ok) {
+    throw new Error(response.error.message);
+  }
+  return response.data;
+}
+// GET /api/chat/session-types
+export async function fetchChatSessionTypes(): Promise<ChatSessionTypesView> {
+  const response = await api.get<ChatSessionTypesView>('/api/chat/session-types');
+  if (!response.ok) {
+    throw new Error(response.error.message);
+  }
+  return response.data;
+}
+// POST /api/chat/turn/stop
+export async function stopChatTurn(data: ChatTurnStopRequest): Promise<ChatTurnStopResult> {
+  const response = await api.post<ChatTurnStopResult>('/api/chat/turn/stop', data);
+  if (!response.ok) {
+    throw new Error(response.error.message);
+  }
+  return response.data;
+}
+// GET /api/chat/runs
+export async function fetchChatRuns(params?: {
+  sessionKey?: string;
+  states?: ChatRunState[];
+  limit?: number;
+}): Promise<ChatRunListView> {
+  const query = new URLSearchParams();
+  if (params?.sessionKey?.trim()) {
+    query.set('sessionKey', params.sessionKey.trim());
+  }
+  if (Array.isArray(params?.states) && params.states.length > 0) {
+    query.set('states', params.states.join(','));
+  }
+  if (typeof params?.limit === 'number' && Number.isFinite(params.limit)) {
+    query.set('limit', String(Math.max(0, Math.trunc(params.limit))));
+  }
+  const suffix = query.toString();
+  const response = await api.get<ChatRunListView>(suffix ? `/api/chat/runs?${suffix}` : '/api/chat/runs');
+  if (!response.ok) {
+    throw new Error(response.error.message);
+  }
+  return response.data;
+}
+// GET /api/chat/runs/:runId
+export async function fetchChatRun(runId: string): Promise<ChatRunView> {
+  const response = await api.get<ChatRunView>(`/api/chat/runs/${encodeURIComponent(runId)}`);
+  if (!response.ok) {
+    throw new Error(response.error.message);
+  }
+  return response.data;
 }
 // GET /api/cron