@tablestore/tablestore-agent-cli 0.1.7 → 0.1.9

package/dist/dashboard-runtime/dashboard/src/hooks/use-qa-chat.ts

@@ -4,7 +4,13 @@ import { useCallback, useEffect, useRef, useState } from "react";
 
 import { streamChat } from "@/services/llm-chat";
 import { newId } from "@/lib/random-id";
-import type { ChatMessage, ChatRequestBody } from "@/types/llm-chat";
+import { devFlag } from "@/lib/dev-flags";
+import {
+  removeAt,
+  removePair,
+  truncateUpToAndIncluding,
+} from "@/lib/chat-message-ops";
+import type { ChatMessage, ChatRequestBody, ChatRole } from "@/types/llm-chat";
 
 /**
  * Token deltas can arrive faster than React can profitably re-render
@@ -17,6 +23,7 @@ import type { ChatMessage, ChatRequestBody } from "@/types/llm-chat";
 type StreamPatch = { content?: string; reasoning?: string };
 
 export interface UseQaChatOptions {
+  activeInstance: string | null;
   providerId: string;
   model: string;
   systemPrompt: string;
@@ -35,6 +42,17 @@ export interface UseQaChatResult {
   isStreaming: boolean;
   error: string | null;
   send(userInput: string): Promise<void>;
+  /** Truncate to and including the given user message, then re-run the
+   *  assistant pipeline. Powers resend / regenerate / edit-and-resend. */
+  reissueTurn(anchorUserId: string): Promise<void>;
+  /** Remove a message by id. When the target is a user message and
+   *  `withNextAssistant` is true, the immediately-following assistant
+   *  message (if any) is removed too. Persists immediately. */
+  deleteMessage(id: string, opts?: { withNextAssistant?: boolean }): void;
+  /** Rewrite the content of a user message in place. Returns the message
+   *  id on success so the caller can chain `reissueTurn(id)` for the
+   *  edit-and-resend flow, or null if the id wasn't a user message. */
+  editUserMessage(id: string, nextContent: string): string | null;
   stop(): void;
   clear(): void;
   /** Replace the entire message list, e.g. when switching sessions. */
@@ -133,57 +151,51 @@ export function useQaChat(options: UseQaChatOptions): UseQaChatResult {
 
   const clear = useCallback(() => {
     abortRef.current?.abort();
+    // Sync the ref before triggering the async setMessages so a `send` that
+    // happens to land in the same JS task — between this call and React's
+    // next commit — sees an empty history instead of the previous session's
+    // messages. The render-body assignment below catches the steady state;
+    // this assignment closes the in-flight window.
+    messagesRef.current = [];
     setMessages([]);
     setError(null);
   }, []);
 
   const replaceMessages = useCallback((next: ChatMessage[]) => {
     abortRef.current?.abort();
+    // Same race-window guard as in `clear` — see the comment there.
+    messagesRef.current = next;
     setMessages(next);
     setError(null);
   }, []);
 
-  const send = useCallback(
-    async (userInput: string) => {
-      const trimmed = userInput.trim();
-      if (!trimmed || isStreamingRef.current) return;
+  /**
+   * Internal: run one assistant turn against an already-prepared message
+   * list. Shared between `send` (which prepends a fresh user+assistant
+   * placeholder) and `reissueTurn` (which truncates and re-anchors on an
+   * existing user message).
+   *
+   * Pre-conditions:
+   *   - `assistantId` matches a message in the current list (the placeholder)
+   *   - `historyToSend` is the exact wire payload, already trimmed
+   *   - the caller has already set isStreaming = true and abortRef
+   */
+  const _runAssistantTurn = useCallback(
+    async (
+      assistantId: string,
+      historyToSend: Array<{ role: ChatRole; content: string }>,
+    ) => {
       const opts = optionsRef.current;
-      if (!opts.providerId || !opts.model) {
-        setError("请先选择模型与 Provider");
-        return;
-      }
-
-      setError(null);
-      const userMsg: ChatMessage = {
-        id: newId(),
-        role: "user",
-        content: trimmed,
-        createdAt: Date.now(),
-        status: "done",
-      };
-      const assistantId = newId();
-      const assistantMsg: ChatMessage = {
-        id: assistantId,
-        role: "assistant",
-        content: "",
-        reasoning: "",
-        createdAt: Date.now(),
-        status: "streaming",
-      };
-
-      // Capture the history to send BEFORE inserting the placeholder so we
-      // don't include an empty assistant turn in the request payload.
-      const historyToSend = [...messagesRef.current, userMsg].map((m) => ({
-        role: m.role,
-        content: m.content,
-      }));
-
-      setMessages((prev) => [...prev, userMsg, assistantMsg]);
-      setIsStreaming(true);
-
       const controller = new AbortController();
       abortRef.current = controller;
 
+      // Per-turn one-shot latches for the reasoning timing stamps. Refs
+      // (not state) because we observe them from inside the streaming loop
+      // closure — re-rendering on every flip would defeat the rAF batching
+      // that keeps token streaming at 60fps.
+      const reasoningStartedRef = { current: false };
+      const reasoningCompletedRef = { current: false };
+
       const updateAssistant = (patch: Partial<ChatMessage>) => {
         setMessages((prev) =>
           prev.map((m) => (m.id === assistantId ? { ...m, ...patch } : m)),
@@ -192,6 +204,7 @@ export function useQaChat(options: UseQaChatOptions): UseQaChatResult {
 
       try {
         const body: ChatRequestBody = {
+          activeInstance: opts.activeInstance,
           providerId: opts.providerId,
           model: opts.model,
           messages: historyToSend,
@@ -200,6 +213,18 @@ export function useQaChat(options: UseQaChatOptions): UseQaChatResult {
           rag: opts.rag,
         };
 
+        if (devFlag("logChatRequest")) {
+          // Diagnostic surface for the cross-session bleed investigation.
+          // Off by default; enable via
+          //   localStorage.setItem("tsagent.dev.logChatRequest","1")
+          // in the browser devtools console.
+          console.groupCollapsed("[chat] outgoing turn");
+          console.log("assistantId", assistantId);
+          console.log("messages", historyToSend);
+          console.log("rag.knowledgeBases", opts.rag?.knowledgeBases);
+          console.groupEnd();
+        }
+
         for await (const event of streamChat(body, controller.signal)) {
           if (event.type === "query.rewritten") {
             updateAssistant({
@@ -207,11 +232,14 @@ export function useQaChat(options: UseQaChatOptions): UseQaChatResult {
               retrievalQueryRewritten: event.query !== event.original,
             });
           } else if (event.type === "query.fallback") {
-            // Rewriter failed; surface the original query without the
-            // "rewritten" badge so the UI stays quiet.
+            // Rewriter failed; record the failure so the UI can surface a
+            // non-blocking warning chip while the pipeline continues with
+            // the original query.
             updateAssistant({
               retrievalQuery: event.original,
               retrievalQueryRewritten: false,
+              queryRewriteFailed: true,
+              queryRewriteError: event.reason,
             });
           } else if (event.type === "retrieval.done") {
             updateAssistant({
@@ -222,52 +250,72 @@ export function useQaChat(options: UseQaChatOptions): UseQaChatResult {
             const buf = pendingDeltasRef.current.get(assistantId) ?? {};
             buf.reasoning = (buf.reasoning ?? "") + event.delta;
             pendingDeltasRef.current.set(assistantId, buf);
+            if (!reasoningStartedRef.current) {
+              reasoningStartedRef.current = true;
+              updateAssistant({ reasoningStartedAt: Date.now() });
+            }
             scheduleFlush();
           } else if (event.type === "content.delta") {
             const buf = pendingDeltasRef.current.get(assistantId) ?? {};
             buf.content = (buf.content ?? "") + event.delta;
             pendingDeltasRef.current.set(assistantId, buf);
+            if (reasoningStartedRef.current && !reasoningCompletedRef.current) {
+              reasoningCompletedRef.current = true;
+              updateAssistant({ reasoningCompletedAt: Date.now() });
+            }
             scheduleFlush();
           } else if (event.type === "error") {
-            // Terminal event: drain any buffered deltas synchronously
-            // before applying the status patch so the user sees the full
-            // partial answer alongside the error badge.
             cancelScheduledFlush();
             flushDeltas();
-            updateAssistant({
+            const patch: Partial<ChatMessage> = {
               status: "error",
               errorMessage: `${event.code}: ${event.message}`,
-            });
+            };
+            if (reasoningStartedRef.current && !reasoningCompletedRef.current) {
+              patch.reasoningCompletedAt = Date.now();
+            }
+            updateAssistant(patch);
             setError(event.message);
             break;
           } else if (event.type === "done") {
             cancelScheduledFlush();
             flushDeltas();
-            updateAssistant({ status: "done" });
+            const patch: Partial<ChatMessage> = { status: "done" };
+            if (reasoningStartedRef.current && !reasoningCompletedRef.current) {
+              patch.reasoningCompletedAt = Date.now();
+            }
+            updateAssistant(patch);
             break;
           }
         }
       } catch (err) {
-        // AbortError is expected when the user clicks "stop"; do not treat
-        // it as a hard failure. Either way, drain any buffered deltas so
-        // the partial answer is preserved on screen.
+        // AbortError is expected when the user clicks "stop" or starts a new
+        // turn; do not treat it as a hard failure. Either way drain buffered
+        // deltas so any partial answer is preserved.
         cancelScheduledFlush();
         flushDeltas();
         const isAbort =
           err instanceof DOMException && err.name === "AbortError";
+        const closeReasoning =
+          reasoningStartedRef.current && !reasoningCompletedRef.current
+            ? { reasoningCompletedAt: Date.now() }
+            : undefined;
         if (!isAbort) {
           const message = err instanceof Error ? err.message : String(err);
-          updateAssistant({ status: "error", errorMessage: message });
+          updateAssistant({
+            status: "error",
+            errorMessage: message,
+            ...closeReasoning,
+          });
           setError(message);
         } else {
-          updateAssistant({ status: "done" });
+          updateAssistant({ status: "done", ...closeReasoning });
         }
       } finally {
         setIsStreaming(false);
         abortRef.current = null;
-        // Flush the latest snapshot to the persist handler. Using the functional
-        // setter avoids racing with the in-flight closure: we observe whatever
-        // the reducer has just committed.
+        // Flush the latest snapshot to the persist handler. Functional
+        // setter avoids racing with the in-flight closure.
         const persist = onPersistRef.current;
         if (persist) {
           setMessages((prev) => {
@@ -277,18 +325,175 @@ export function useQaChat(options: UseQaChatOptions): UseQaChatResult {
         }
       }
     },
-    // No `messages`/`options`/`isStreaming` in deps: we read them through
-    // refs above so the callback identity stays stable across the entire
-    // streaming session, which prevents downstream memos (composer, message
-    // list) from invalidating on every token.
     [scheduleFlush, flushDeltas, cancelScheduledFlush],
   );
 
+  const send = useCallback(
+    async (userInput: string) => {
+      const trimmed = userInput.trim();
+      if (!trimmed || isStreamingRef.current) return;
+      const opts = optionsRef.current;
+      if (!opts.providerId || !opts.model) {
+        setError("请先选择模型与 Provider");
+        return;
+      }
+
+      setError(null);
+      const userMsg: ChatMessage = {
+        id: newId(),
+        role: "user",
+        content: trimmed,
+        createdAt: Date.now(),
+        status: "done",
+      };
+      const assistantId = newId();
+      // Snapshot whether this turn is RAG-enabled. The pill uses this to pick
+      // pre-stream labels (intent extraction → retrieval → thinking) instead
+      // of a single generic "正在思考" that sits unchanged for several
+      // seconds while the server runs the rewriter and KB queries.
+      const usingRag = (opts.rag?.knowledgeBases?.length ?? 0) > 0;
+      const assistantMsg: ChatMessage = {
+        id: assistantId,
+        role: "assistant",
+        content: "",
+        reasoning: "",
+        createdAt: Date.now(),
+        status: "streaming",
+        usingRag,
+      };
+
+      // Capture the history to send BEFORE inserting the placeholder so we
+      // don't include an empty assistant turn in the request payload.
+      const historyToSend = [...messagesRef.current, userMsg].map((m) => ({
+        role: m.role,
+        content: m.content,
+      }));
+
+      // Sync the ref alongside setMessages so a follow-up reissueTurn or a
+      // racing read sees the new state immediately, not on the next commit.
+      const nextMessages = [...messagesRef.current, userMsg, assistantMsg];
+      messagesRef.current = nextMessages;
+      setMessages(nextMessages);
+      setIsStreaming(true);
+
+      await _runAssistantTurn(assistantId, historyToSend);
+    },
+    [_runAssistantTurn],
+  );
+
+  /**
+   * Truncate to and including `anchorUserId`, then re-run the assistant
+   * pipeline against that user message. Powers UI-level「重新发送」、
+   *「重新生成」、「编辑后保存」 — the editing path mutates the anchor's
+   * content via `editUserMessage` first and then calls this.
+   *
+   * No-op if streaming is already in flight, the anchor is missing, or
+   * the anchor isn't a user message.
+   */
+  const reissueTurn = useCallback(
+    async (anchorUserId: string) => {
+      if (isStreamingRef.current) return;
+      const opts = optionsRef.current;
+      if (!opts.providerId || !opts.model) {
+        setError("请先选择模型与 Provider");
+        return;
+      }
+
+      const truncated = truncateUpToAndIncluding(
+        messagesRef.current,
+        anchorUserId,
+      );
+      const anchor = truncated[truncated.length - 1];
+      if (!anchor || anchor.role !== "user") return;
+
+      setError(null);
+
+      const assistantId = newId();
+      const usingRag = (opts.rag?.knowledgeBases?.length ?? 0) > 0;
+      const assistantMsg: ChatMessage = {
+        id: assistantId,
+        role: "assistant",
+        content: "",
+        reasoning: "",
+        createdAt: Date.now(),
+        status: "streaming",
+        usingRag,
+      };
+
+      const historyToSend = truncated.map((m) => ({
+        role: m.role,
+        content: m.content,
+      }));
+
+      const nextMessages = [...truncated, assistantMsg];
+      messagesRef.current = nextMessages;
+      setMessages(nextMessages);
+      setIsStreaming(true);
+
+      await _runAssistantTurn(assistantId, historyToSend);
+    },
+    [_runAssistantTurn],
+  );
+
+  /**
+   * Remove a single message by id. When `withNextAssistant` is true and the
+   * target is a user message immediately followed by an assistant message,
+   * remove that assistant too (the "paired delete" semantic from the spec).
+   *
+   * Persists immediately via the registered onPersist callback — pure
+   * deletes don't trigger a streaming turn so we cannot rely on the
+   * `finally` block in `_runAssistantTurn` to write to localStorage.
+   */
+  const deleteMessage = useCallback(
+    (id: string, opts?: { withNextAssistant?: boolean }) => {
+      if (isStreamingRef.current) return;
+      const list = messagesRef.current;
+      const target = list.find((m) => m.id === id);
+      if (!target) return;
+
+      const next =
+        target.role === "user" && opts?.withNextAssistant
+          ? removePair(list, id)
+          : removeAt(list, id);
+
+      messagesRef.current = next;
+      setMessages(next);
+      onPersistRef.current?.(next);
+    },
+    [],
+  );
+
+  /**
+   * Replace the textual content of a user message in place — used by the
+   * inline edit affordance before it calls `reissueTurn` to rerun the
+   * assistant pipeline against the new content. Returns the message id on
+   * success so the caller can chain `reissueTurn(id)` without re-querying;
+   * returns null when the id isn't a user message.
+   */
+  const editUserMessage = useCallback(
+    (id: string, nextContent: string) => {
+      const list = messagesRef.current;
+      const idx = list.findIndex((m) => m.id === id);
+      if (idx < 0 || list[idx].role !== "user") return null;
+      const updated = list.slice();
+      updated[idx] = { ...list[idx], content: nextContent };
+      messagesRef.current = updated;
+      setMessages(updated);
+      // Do NOT persist here — the typical caller follows up with
+      // reissueTurn, which will persist after the stream settles.
+      return id;
+    },
+    [],
+  );
+
   return {
     messages,
     isStreaming,
     error,
     send,
+    reissueTurn,
+    deleteMessage,
+    editUserMessage,
     stop,
     clear,
     setMessages: replaceMessages,

package/dist/dashboard-runtime/dashboard/src/hooks/use-update-kb.ts

@@ -1,17 +1,15 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { updateKnowledgeBase } from "@/services/knowledge-base";
 import type { UpdateKBRequest } from "@/types/knowledge-base";
+import { invalidateKnowledgeBaseQueries } from "@/lib/query-keys";
 
 export function useUpdateKB() {
   const queryClient = useQueryClient();
 
   return useMutation({
     mutationFn: (request: UpdateKBRequest) => updateKnowledgeBase(request),
-    onSuccess: (_data, variables) => {
-      queryClient.invalidateQueries({ queryKey: ["knowledge-bases"] });
-      queryClient.invalidateQueries({
-        queryKey: ["knowledge-bases", variables.knowledgeBaseName],
-      });
+    onSuccess: () => {
+      invalidateKnowledgeBaseQueries(queryClient);
     },
   });
 }

package/dist/dashboard-runtime/dashboard/src/hooks/use-update-llm-provider.ts

@@ -2,16 +2,14 @@ import { useMutation, useQueryClient } from "@tanstack/react-query";
 
 import { updateProvider } from "@/services/llm-providers";
 import type { UpdateLLMProviderInput } from "@/types/llm-provider";
-
-import { LLM_PROVIDERS_QUERY_KEY } from "./use-llm-providers";
+import { invalidateLLMProviderQueries } from "@/lib/query-keys";
 
 export function useUpdateLLMProvider(id: string) {
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: (patch: UpdateLLMProviderInput) => updateProvider(id, patch),
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: LLM_PROVIDERS_QUERY_KEY });
-      queryClient.invalidateQueries({ queryKey: ["llm-providers", id] });
+      invalidateLLMProviderQueries(queryClient);
     },
   });
 }

package/dist/dashboard-runtime/dashboard/src/hooks/use-update-memory-store.ts

@@ -1,17 +1,15 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { updateMemoryStore } from "@/services/memory";
 import type { UpdateMemoryStoreRequest } from "@/types/memory";
+import { invalidateMemoryQueries } from "@/lib/query-keys";
 
 export function useUpdateMemoryStore() {
   const queryClient = useQueryClient();
 
   return useMutation({
     mutationFn: (request: UpdateMemoryStoreRequest) => updateMemoryStore(request),
-    onSuccess: (_data, variables) => {
-      queryClient.invalidateQueries({ queryKey: ["memory", "stores"] });
-      queryClient.invalidateQueries({
-        queryKey: ["memory", "stores", variables.memoryStoreName],
-      });
+    onSuccess: () => {
+      invalidateMemoryQueries(queryClient);
     },
   });
 }

package/dist/dashboard-runtime/dashboard/src/hooks/use-update-memory-unit.ts

@@ -1,14 +1,15 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { updateMemoryUnit } from "@/services/memory";
 import type { UpdateMemoryUnitRequest } from "@/types/memory";
+import { invalidateMemoryQueries } from "@/lib/query-keys";
 
 export function useUpdateMemoryUnit() {
   const queryClient = useQueryClient();
 
   return useMutation({
     mutationFn: (request: UpdateMemoryUnitRequest) => updateMemoryUnit(request),
-    onSuccess: (_data, variables) => {
-      queryClient.invalidateQueries({ queryKey: ["memory", "stores", variables.memoryStoreName, "units"] });
+    onSuccess: () => {
+      invalidateMemoryQueries(queryClient);
     },
   });
 }

package/dist/dashboard-runtime/dashboard/src/hooks/use-upload-documents.ts

@@ -1,5 +1,10 @@
+import { useCallback, useRef, useState } from "react";
 import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { uploadDocuments } from "@/services/documents";
+import {
+  uploadDocumentsBatched,
+  type BatchUploadProgress,
+} from "@/services/documents";
+import { invalidateKnowledgeBaseQueries } from "@/lib/query-keys";
 
 interface UploadDocumentsVariables {
   knowledgeBaseName: string;
@@ -10,14 +15,28 @@ interface UploadDocumentsVariables {
 
 export function useUploadDocuments() {
   const queryClient = useQueryClient();
+  const [progress, setProgress] = useState<BatchUploadProgress | null>(null);
+  const progressRef = useRef(progress);
+  progressRef.current = progress;
 
-  return useMutation({
+  const resetProgress = useCallback(() => setProgress(null), []);
+
+  const mutation = useMutation({
     mutationFn: ({ knowledgeBaseName, files, subspace, metadata }: UploadDocumentsVariables) =>
-      uploadDocuments(knowledgeBaseName, files, { subspace, metadata }),
-    onSuccess: (_data, variables) => {
-      queryClient.invalidateQueries({
-        queryKey: ["knowledge-bases", variables.knowledgeBaseName, "documents"],
-      });
+      uploadDocumentsBatched(knowledgeBaseName, files, {
+        subspace,
+        metadata,
+        onProgress: setProgress,
+      }),
+    onSuccess: () => {
+      invalidateKnowledgeBaseQueries(queryClient);
+    },
+    onSettled: () => {
+      // Keep progress visible briefly so the user can read the final state,
+      // then clear it for the next upload.
+      setTimeout(resetProgress, 300);
     },
   });
+
+  return { ...mutation, progress };
 }

package/dist/dashboard-runtime/dashboard/src/lib/chat-message-ops.ts

@@ -0,0 +1,76 @@
+/**
+ * Pure message-list mutators powering the chat surface's destructive
+ * operations (delete, truncate-and-rerun). Kept free of React, of the
+ * concrete `ChatMessage` shape, and of any side effects so we can test
+ * the rules in isolation under vitest's existing node environment.
+ *
+ * Consumers thread their own `ChatMessage` (or a structural subtype) — we
+ * only need `id` and `role`.
+ */
+export interface MinimalMsg {
+  id: string;
+  role: "user" | "assistant" | "system";
+  content?: string;
+}
+
+/** Identity-preserving slice: returns the input array unchanged when the
+ *  anchor isn't present, so React reference equality keeps memoised
+ *  consumers from re-rendering on a no-op. */
+export function truncateUpToAndIncluding<T extends MinimalMsg>(
+  list: T[],
+  anchorId: string,
+): T[] {
+  const idx = list.findIndex((m) => m.id === anchorId);
+  if (idx < 0) return list;
+  return list.slice(0, idx + 1);
+}
+
+/** Drops the anchor and everything after it. */
+export function truncateBefore<T extends MinimalMsg>(
+  list: T[],
+  anchorId: string,
+): T[] {
+  const idx = list.findIndex((m) => m.id === anchorId);
+  if (idx < 0) return list;
+  return list.slice(0, idx);
+}
+
+/** Remove a single message by id. */
+export function removeAt<T extends MinimalMsg>(list: T[], id: string): T[] {
+  const idx = list.findIndex((m) => m.id === id);
+  if (idx < 0) return list;
+  const next = list.slice();
+  next.splice(idx, 1);
+  return next;
+}
+
+/**
+ * Remove a user message AND the immediately-following assistant message
+ * (the "paired delete" semantic). When the next slot isn't an assistant —
+ * either because it's another user message or because the user message is
+ * at the tail — only the user message is removed.
+ */
+export function removePair<T extends MinimalMsg>(list: T[], userId: string): T[] {
+  const idx = list.findIndex((m) => m.id === userId);
+  if (idx < 0) return list;
+  const next = list.slice();
+  const removeCount =
+    list[idx + 1] && list[idx + 1].role === "assistant" ? 2 : 1;
+  next.splice(idx, removeCount);
+  return next;
+}
+
+/** Walk backwards from the given assistant message and return the nearest
+ *  user message above it. Returns null when none exists or the target id
+ *  isn't in the list. */
+export function findUserAnchorAbove<T extends MinimalMsg>(
+  list: T[],
+  fromId: string,
+): T | null {
+  const idx = list.findIndex((m) => m.id === fromId);
+  if (idx < 0) return null;
+  for (let i = idx - 1; i >= 0; i -= 1) {
+    if (list[i].role === "user") return list[i];
+  }
+  return null;
+}

package/dist/dashboard-runtime/dashboard/src/lib/constants.ts

@@ -0,0 +1,22 @@
+export const DEFAULT_PAGE_SIZE = 20;
+
+export const KB_NAME_REGEX = /^[a-zA-Z][a-zA-Z0-9_-]{1,62}[a-zA-Z0-9]$/;
+
+export const ERROR_CODE_MAP = {
+  INVALID_PARAMETER: "参数错误",
+  NOT_FOUND: "资源不存在",
+  ALREADY_EXISTS: "资源已存在",
+  INTERNAL_ERROR: "服务内部错误",
+  UNAUTHORIZED: "未授权",
+  RATE_LIMITED: "请求过于频繁",
+} as const satisfies Record<string, string>;
+
+export const METADATA_TYPES = [
+  "keyword",
+  "text",
+  "long",
+  "double",
+  "boolean",
+] as const;
+
+export type MetadataType = (typeof METADATA_TYPES)[number];