nolo-cli 0.1.13 → 0.1.14

package/ai/agent/getFullChatContextKeys.ts

@@ -0,0 +1,168 @@
+
+// packages/ai/agent/getFullChatContextKeys.ts
+import { RootState } from "app/store";
+import { selectAllMsgs } from "chat/messages/messageSlice";
+import type { DialogConfig } from "app/types";
+import { extractCustomId } from "core/prefix";
+
+/** 简单的数组差集工具：返回 arrA 中不在 arrB 里的元素 */
+const difference = <T>(arrA: T[], arrB: T[]): T[] => {
+  if (!arrA.length) return [];
+  if (!arrB.length) return [...arrA];
+
+  const exclude = new Set(arrB);
+  return arrA.filter((item) => !exclude.has(item));
+};
+
+/**
+ * Collect all possible reference keys for this chat turn:
+ * - botInstructionKeys: keys from agentConfig.references of type "instruction"
+ * - botKnowledgeKeys: keys from agentConfig.references (non-instruction)
+ * - currentInputKeys: keys referenced directly by the user's current input (array parts with pageKey)
+ * - historyKeys: keys from all previous messages' content parts
+ */
+export const getFullChatContextKeys = async (
+  state: RootState,
+  dispatch: any,
+  agentConfig: any,
+  userInput: string | any[],
+  dialogConfig?: DialogConfig
+): Promise<Record<string, Set<string>>> => {
+  const msgs = selectAllMsgs(
+    state,
+    dialogConfig?.dbKey
+      ? extractCustomId(dialogConfig.dbKey)
+      : dialogConfig?.id
+  );
+
+  const botInstructionKeys = new Set<string>();
+  const botKnowledgeKeys = new Set<string>();
+
+  if (Array.isArray(agentConfig.references)) {
+    for (const ref of agentConfig.references as Array<{
+      dbKey: string;
+      type: string;
+    }>) {
+      if (!ref?.dbKey) continue;
+      if (ref.type === "instruction") {
+        botInstructionKeys.add(ref.dbKey);
+      } else {
+        botKnowledgeKeys.add(ref.dbKey);
+      }
+    }
+  }
+
+  const currentInputKeys = new Set<string>();
+  if (Array.isArray(userInput)) {
+    for (const part of userInput) {
+      if (part?.pageKey) currentInputKeys.add(part.pageKey);
+      if (part?.dialogKey) currentInputKeys.add(part.dialogKey);
+    }
+  }
+
+  const historyKeys = new Set<string>();
+
+  // 1. 从 DialogConfig.referenceKeys 读取（这是主要的、持久化的引用来源）
+  // 即使消息被压缩，这里的 keys 也会保留
+  const savedKeys = dialogConfig?.referenceKeys;
+  if (Array.isArray(savedKeys)) {
+    savedKeys.forEach((k: string) => historyKeys.add(k));
+  }
+
+  // 2. 仅扫描尚未被压缩的近期消息
+  // 已压缩的消息（summarizedBeforeId 之前的部分，包含该条本身）的 keys
+  // 已在压缩时存入 dialogConfig.referenceKeys，步骤 1 已覆盖，无需重复扫描。
+  const scanContentParts = (msg: any) => {
+    if (!msg.content) return;
+    const contentParts = Array.isArray(msg.content) ? msg.content : [msg.content];
+    for (const part of contentParts) {
+      if (part && typeof part === 'object') {
+        if (part?.pageKey) historyKeys.add(part.pageKey);
+        if (part?.dialogKey) historyKeys.add(part.dialogKey);
+      }
+    }
+  };
+
+  if (msgs && msgs.length > 0) {
+    const summarizedBeforeId = dialogConfig?.summarizedBeforeId;
+
+    if (!summarizedBeforeId) {
+      // 无压缩记录，扫描全部消息
+      for (const msg of (msgs as any[])) scanContentParts(msg);
+    } else {
+      let foundMarker = false;
+      let startScan = false;
+
+      for (const msg of (msgs as any[])) {
+        if (!startScan) {
+          if (msg.id === summarizedBeforeId) {
+            foundMarker = true;
+            startScan = true;
+            // summarizedBeforeId 那条消息本身已被压缩，keys 在 referenceKeys 里，跳过
+          }
+          continue;
+        }
+        scanContentParts(msg);
+      }
+
+      // marker 找不到说明 Redux 中的消息都是新的，应该全扫
+      if (!foundMarker) {
+        console.warn(`[getFullChatContextKeys] marker ${summarizedBeforeId} not found, scanning all`);
+        for (const msg of (msgs as any[])) scanContentParts(msg);
+      }
+    }
+  }
+
+  return {
+    botInstructionKeys,
+    currentInputKeys,
+    historyKeys,
+    botKnowledgeKeys,
+  };
+};
+
+/**
+ * Deduplicate keys across priority levels.
+ * Priority order (high -> low):
+ * 1) botInstructionKeys
+ * 2) currentInputKeys
+ * 3) historyKeys
+ * 4) botKnowledgeKeys
+ *
+ * Return field names match context block identifiers expected downstream.
+ */
+export const deduplicateContextKeys = (
+  keys: Record<string, Set<string>>
+): Record<string, string[]> => {
+  const {
+    botInstructionKeys,
+    currentInputKeys,
+    historyKeys,
+    botKnowledgeKeys,
+  } = keys;
+
+  const finalBotInstructionKeys = Array.from(botInstructionKeys);
+
+  const finalCurrentInputKeys = difference(
+    Array.from(currentInputKeys),
+    finalBotInstructionKeys
+  );
+
+  const finalHistoryKeys = difference(Array.from(historyKeys), [
+    ...finalBotInstructionKeys,
+    ...finalCurrentInputKeys,
+  ]);
+
+  const finalBotKnowledgeKeys = difference(Array.from(botKnowledgeKeys), [
+    ...finalBotInstructionKeys,
+    ...finalCurrentInputKeys,
+    ...finalHistoryKeys,
+  ]);
+
+  return {
+    botInstructionsContext: finalBotInstructionKeys,
+    currentInputContext: finalCurrentInputKeys,
+    historyContext: finalHistoryKeys,
+    botKnowledgeContext: finalBotKnowledgeKeys,
+  };
+};

package/ai/agent/hooks/fetchPublicAgents.ts

@@ -0,0 +1,133 @@
+import { getDb } from "database/client/db";
+import { pino } from "pino";
+import { pubAgentKeys } from "database/keys";
+import { Agent } from "app/types";
+import { supportsImageGeneration } from "ai/agent/utils/imageOutput";
+import { getRecordTimestamp, isTombstoneRecord } from "database/tombstones";
+import { buildSortMeta, sortAgents } from "ai/agent/utils/sortUtils";
+
+const logger = pino({ name: "fetchPublicAgents" });
+
+interface FetchPublicAgentsOptions {
+  limit?: number;
+  sortBy?:
+  | "recommended"
+  | "newest"
+  | "popular"
+  | "rating"
+  | "outputPriceAsc"
+  | "outputPriceDesc"
+  | "favorite";
+  searchName?: string;
+  userId?: string;
+  imageOutputOnly?: boolean;
+  toolName?: string;
+}
+
+interface PublicAgentTombstone {
+  id?: string;
+  dbKey?: string;
+  deletedAt?: string | number;
+  updatedAt?: string | number;
+  createdAt?: string | number;
+}
+
+export interface FetchPublicAgentsResult {
+  data: Agent[];
+  total: number;
+  hasMore: boolean;
+  tombstones: PublicAgentTombstone[];
+}
+
+export async function fetchPublicAgents(
+  options: FetchPublicAgentsOptions = {}
+): Promise<FetchPublicAgentsResult> {
+  const {
+    limit = 20,
+    sortBy = "recommended",
+    searchName,
+    userId,
+    imageOutputOnly = false,
+    toolName,
+  } = options;
+
+  try {
+    const ranges = pubAgentKeys.allPublicRanges();
+    let results: Agent[] = [];
+    let tombstones: PublicAgentTombstone[] = [];
+
+    const db = getDb();
+    if (!db) return { data: [], total: 0, hasMore: false };
+
+    for (const { start, end } of ranges) {
+      const iterator = await db.iterator({
+        gte: start,
+        lte: end,
+      });
+      for await (const [, value] of iterator) {
+        if (!value?.isPublic) continue;
+        if (isTombstoneRecord(value)) {
+          tombstones.push(value as PublicAgentTombstone);
+          continue;
+        }
+        results.push(value as Agent);
+      }
+    }
+
+    if (searchName) {
+      const kw = searchName.toLowerCase();
+      results = results.filter((agent) =>
+        agent.name?.toLowerCase().includes(kw)
+      );
+    }
+
+    if (userId) {
+      results = results.filter((agent) => agent.userId === userId);
+    }
+
+    if (imageOutputOnly) {
+      results = results.filter((agent) => supportsImageGeneration(agent));
+    }
+
+    if (toolName) {
+      const kw = toolName.toLowerCase();
+      results = results.filter((agent) =>
+        agent.tools?.some((t) => t.toLowerCase().includes(kw))
+      );
+    }
+
+    results = sortAgents(
+      results.map((agent) => ({
+        ...(agent as any),
+        __sort: buildSortMeta(agent),
+      })),
+      sortBy
+    );
+
+    const paginatedResults = results.slice(0, limit);
+
+    logger.debug(
+      {
+        total: results.length,
+        returned: paginatedResults.length,
+        sortBy,
+        limit,
+        imageOutputOnly,
+        firstItemCreatedAt: paginatedResults[0]?.createdAt,
+      },
+      "Fetched public agents (local)"
+    );
+
+    return {
+      data: paginatedResults,
+      total: results.length,
+      hasMore: limit < results.length,
+      tombstones: tombstones.sort(
+        (left, right) => getRecordTimestamp(right) - getRecordTimestamp(left)
+      ),
+    };
+  } catch (error) {
+    logger.error({ error }, "Failed to fetch public agents (local)");
+    throw error;
+  }
+}

package/ai/agent/hooks/useAgentConfig.ts

@@ -0,0 +1,61 @@
+import { useEffect, useState } from "react";
+
+import type { Agent } from "app/types";
+import { useAppDispatch, useAppSelector } from "app/store";
+import { read } from "database/dbSlice";
+
+import { selectCurrentDialogConfig } from "chat/dialog/dialogSlice";
+import { getPrimaryDialogAgentId } from "chat/dialog/dialogAgents";
+
+interface UseAgentConfigResult {
+  agentConfig: Agent | null;
+  isLoading: boolean;
+}
+
+const useAgentConfig = () => {
+  const dispatch = useAppDispatch();
+  const [agentConfig, setAgentConfig] = useState<Agent | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+
+  const currentDialogConfig = useAppSelector(selectCurrentDialogConfig);
+  const agentKey = getPrimaryDialogAgentId(currentDialogConfig);
+
+  useEffect(() => {
+    if (!agentKey) {
+      setAgentConfig(null);
+      setIsLoading(false);
+      return;
+    }
+
+    let cancelled = false;
+    setAgentConfig(null);
+    setIsLoading(true);
+
+    void (async () => {
+      try {
+        const result = (await dispatch(read({ dbKey: agentKey })).unwrap()) as Agent | null;
+        if (cancelled) return;
+        setAgentConfig(result);
+      } catch (error) {
+        if (cancelled) return;
+        console.warn("[useAgentConfig] Failed to load agent config:", error);
+        setAgentConfig(null);
+      } finally {
+        if (!cancelled) {
+          setIsLoading(false);
+        }
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [agentKey, dispatch]);
+
+  return {
+    agentConfig,
+    isLoading,
+  } satisfies UseAgentConfigResult;
+};
+
+export default useAgentConfig;

package/ai/agent/hooks/useAgentDialog.ts

@@ -0,0 +1,35 @@
+// ai/agent/hooks/useAgentDialog.ts
+import { useCallback } from "react";
+import { useTranslation } from "react-i18next";
+import toast from "react-hot-toast";
+import { useCreateDialog } from "chat/dialog/useCreateDialog";
+
+interface UseAgentDialogOptions {
+  spaceId?: string | null;
+}
+
+export function useAgentDialog(
+  agentKey: string,
+  options: UseAgentDialogOptions = {}
+) {
+  const { t } = useTranslation("ai");
+  const { isLoading, createNewDialog } = useCreateDialog();
+  const { spaceId } = options;
+
+  const startDialog = useCallback(async () => {
+    if (isLoading) return;
+    try {
+      await createNewDialog({
+        agents: [agentKey],
+        ...(spaceId ? { spaceId } : {}),
+      });
+    } catch (err: any) {
+      const msg = err?.message
+        ? `${t("createDialogError")}: ${err.message}`
+        : t("createDialogError");
+      toast.error(msg);
+    }
+  }, [agentKey, createNewDialog, isLoading, spaceId, t]);
+
+  return { isStarting: isLoading, startDialog };
+}

package/ai/agent/hooks/useAgentFormValidation.ts

@@ -0,0 +1,202 @@
+// 路径: app/features/ai/agent/hooks/useAgentValidation.ts
+
+import { useForm } from "react-hook-form";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { useCallback } from "react";
+import { useAppDispatch } from "app/store";
+import { useAuth } from "auth/hooks/useAuth";
+import { useCreateDialog } from "chat/dialog/useCreateDialog";
+import { createAgentKey } from "database/keys";
+import { useTranslation } from "react-i18next";
+import { useAppSelector } from "app/store";
+import {
+  addContentToSpace,
+  selectCurrentSpace,
+  selectCurrentSpaceId,
+  updateContentTitle,
+} from "create/space/spaceSlice";
+import {
+  getCreateAgentSchema,
+  FormData,
+  normalizeReferences,
+} from "../createAgentSchema";
+import { createAgent, updateAgent } from "ai/agent/agentSlice";
+import { ContentType } from "app/types";
+import { DEFAULT_MODEL } from "ai/llm/providers";
+
+type AgentEditIdentityInput = Partial<ExtendedFormData> & {
+  dbKey?: string;
+  contentKey?: string;
+};
+
+// extractAgentId 函数：兼容 id 是路径或纯 id 的老数据 (包括 cybot 和 agent)
+export const extractAgentId = (value: string): string => {
+  const raw = value.trim();
+  if (raw.startsWith("agent-") || raw.startsWith("cybot-")) {
+    const parts = raw.split("-");
+    if (parts.length >= 3) return parts[parts.length - 1];
+  }
+  return raw;
+};
+
+// ExtendedFormData：在原有表单数据上加上一些 meta 字段
+interface ExtendedFormData extends FormData {
+  id?: string;
+  createdAt?: number;
+  dialogCount?: number;
+  messageCount?: number;
+  tokenCount?: number;
+}
+
+export const resolveAgentEditIdentity = (
+  initialValues?: AgentEditIdentityInput
+) => {
+  const rawAgentKey =
+    typeof initialValues?.dbKey === "string" && initialValues.dbKey.trim()
+      ? initialValues.dbKey.trim()
+      : typeof initialValues?.contentKey === "string" && initialValues.contentKey.trim()
+        ? initialValues.contentKey.trim()
+        : undefined;
+
+  const rawAgentId =
+    typeof initialValues?.id === "string" && initialValues.id.trim()
+      ? initialValues.id.trim()
+      : rawAgentKey;
+
+  const agentId = rawAgentId ? extractAgentId(rawAgentId) : undefined;
+
+  return {
+    agentKey: rawAgentKey,
+    agentId,
+    isEditing: Boolean(agentId),
+  };
+};
+
+export const useAgentValidation = (initialValues?: ExtendedFormData) => {
+  const dispatch = useAppDispatch();
+  const { createNewDialog } = useCreateDialog();
+  const auth = useAuth();
+  const { t } = useTranslation("ai");
+  const currentSpaceId = useAppSelector(selectCurrentSpaceId);
+  const currentSpace = useAppSelector(selectCurrentSpace);
+  const { agentId: resolvedAgentId, isEditing } =
+    resolveAgentEditIdentity(initialValues);
+
+  const form = useForm<FormData>({
+    resolver: zodResolver(getCreateAgentSchema(t)),
+    defaultValues: isEditing
+      ? {
+        ...initialValues,
+        // 如果老数据里没有 apiSource，则默认 platform
+        apiSource: initialValues.apiSource ?? "platform",
+        machineId: (initialValues as any).machineId ?? (initialValues as any).runtimeBinding?.machineId ?? "",
+        tags: Array.isArray(initialValues.tags)
+          ? initialValues.tags.join(", ")
+          : (initialValues.tags as any) || "",
+        references: normalizeReferences(initialValues.references || []),
+        whitelist: initialValues.whitelist || [],
+      }
+      : {
+        greeting: t("form.defaults.greeting"),
+        useServerProxy: true,
+        isPublic: false,
+        whitelist: [],
+        // 新建时默认为平台 API
+        apiSource: "platform",
+        provider: DEFAULT_MODEL.provider,
+        model: DEFAULT_MODEL.name,
+      },
+  });
+
+  const { watch } = form;
+
+  const onSubmit = useCallback(
+    async (data: FormData) => {
+      if (!auth.user?.userId) throw new Error(t("errors.noUserId"));
+
+      // -------- 编辑模式：走 updateAgent thunk --------
+      if (isEditing && resolvedAgentId) {
+        await dispatch(
+          updateAgent({
+            userId: auth.user.userId,
+            agentId: resolvedAgentId,
+            formData: data,
+            previousAgent: initialValues as any,
+          })
+        ).unwrap();
+
+        const contentKey = (initialValues as any).dbKey as string | undefined;
+        const nextName = String(data.name ?? "").trim();
+        const previousName = String(initialValues.name ?? "").trim();
+        if (
+          currentSpaceId &&
+          contentKey &&
+          currentSpace?.contents?.[contentKey] &&
+          nextName &&
+          nextName !== previousName
+        ) {
+          await dispatch(
+            updateContentTitle({
+              spaceId: currentSpaceId,
+              contentKey,
+              title: nextName,
+            })
+          ).unwrap();
+        }
+
+        return;
+      }
+
+      // -------- 新建模式：走 createAgent thunk，并在成功后创建默认对话 --------
+      const createdAgent = await dispatch(
+        createAgent({
+          userId: auth.user.userId,
+          formData: data,
+          spaceId: currentSpaceId || undefined, // 传入当前空间 ID
+        })
+      ).unwrap();
+
+      const agentDbKey = createdAgent.isPublic
+        ? createAgentKey.public(createdAgent.id)
+        : createAgentKey.private(auth.user.userId, createdAgent.id);
+
+      // 如果有当前空间，则将 Agent 添加到空间内容中，使其在侧边栏显示
+      if (currentSpaceId) {
+        try {
+          await dispatch((addContentToSpace as any)({
+            spaceId: currentSpaceId,
+            title: createdAgent.name || "未命名智能体",
+            type: ContentType.AGENT,
+            contentKey: agentDbKey,
+          })).unwrap();
+        } catch (error) {
+          console.error("Failed to add agent to space sidebar:", error);
+        }
+      }
+
+      await createNewDialog({
+        agents: [agentDbKey],
+      });
+    },
+    [
+      auth.user,
+      isEditing,
+      initialValues,
+      resolvedAgentId,
+      dispatch,
+      createNewDialog,
+      t,
+      currentSpaceId,
+      currentSpace,
+    ]
+  );
+
+  return {
+    form,
+    provider: watch("provider"),
+    useServerProxy: watch("useServerProxy"),
+    isPublic: watch("isPublic"),
+    onSubmit,
+    isEditing,
+  };
+};