nolo-cli 0.1.31 → 0.1.32

package/ai/agent/hooks/useAgentConfig.ts

@@ -1,89 +0,0 @@
-import { useEffect, useState } from "react";
-
-import type { Agent } from "../../../app/types";
-import { useAppDispatch, useAppSelector } from "../../../app/store";
-import { read, selectById } from "../../../database/dbSlice";
-import { selectRuntimeSnapshot } from "../../../app/stateViews/runtime";
-
-import {
-  selectCurrentDialogConfig,
-  selectCurrentDialogKey,
-} from "../../../chat/dialog/dialogSlice";
-import { getPrimaryDialogAgentId } from "../../../chat/dialog/dialogAgents";
-
-interface UseAgentConfigResult {
-  agentConfig: Agent | null;
-  isLoading: boolean;
-  loadState: "idle" | "loading" | "ready" | "error";
-}
-
-const useAgentConfig = () => {
-  const dispatch = useAppDispatch();
-  const [loadState, setLoadState] =
-    useState<UseAgentConfigResult["loadState"]>("idle");
-
-  const currentDialogKey = useAppSelector(selectCurrentDialogKey);
-  const currentDialogConfig = useAppSelector(selectCurrentDialogConfig);
-  const agentKey = getPrimaryDialogAgentId(currentDialogConfig);
-  const { currentToken, currentServer } = useAppSelector(selectRuntimeSnapshot);
-  const agentConfig = useAppSelector((state) =>
-    agentKey ? ((selectById(state, agentKey) as Agent | null) ?? null) : null
-  );
-
-  useEffect(() => {
-    if (currentDialogKey && !currentDialogConfig) {
-      setLoadState("loading");
-      return;
-    }
-
-    if (!agentKey) {
-      setLoadState("idle");
-      return;
-    }
-
-    if (agentConfig) {
-      setLoadState("ready");
-      return;
-    }
-
-    if (!currentToken) {
-      setLoadState("loading");
-      return;
-    }
-
-    let cancelled = false;
-    setLoadState("loading");
-
-    void (async () => {
-      try {
-        await dispatch(read({ dbKey: agentKey })).unwrap();
-        if (cancelled) return;
-        setLoadState("ready");
-      } catch (error) {
-        if (cancelled) return;
-        console.warn("[useAgentConfig] Failed to load agent config:", error);
-        setLoadState("error");
-      }
-    })();
-
-    return () => {
-      cancelled = true;
-    };
-  }, [
-    agentConfig,
-    agentKey,
-    currentDialogConfig,
-    currentDialogKey,
-    currentServer,
-    currentToken,
-    dispatch,
-  ]);
-
-  return {
-    agentConfig: agentConfig ?? null,
-    isLoading: loadState === "loading",
-    loadState,
-  } satisfies UseAgentConfigResult;
-};
-
-export default useAgentConfig;

package/ai/agent/hooks/useAgentDialog.ts

@@ -1,35 +0,0 @@
-// 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

@@ -1,202 +0,0 @@
-// 路径: 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 "../../agent/agentSlice";
-import { ContentType } from "../../../app/types";
-import { DEFAULT_MODEL } from "../../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,
-  };
-};

package/ai/agent/hooks/usePublicAgents.ts

@@ -1,377 +0,0 @@
-// 文件路径: ai/agent/hooks/usePublicAgents.ts
-
-import { useEffect, useState, useCallback, useRef } from "react";
-import { useAppDispatch, useAppSelector } from "../../../app/store";
-
-import type { Agent } from "../../../app/types";
-import {
-  selectCurrentServer,
-  selectSyncServers,
-} from "../../../app/settings/settingSlice";
-import { selectUserId } from "../../../auth/authSlice";
-
-import { fetchPublicAgents as fetchLocal } from "../../agent/hooks/fetchPublicAgents";
-import {
-  dedupeRemotePublicAgents,
-  maskRemoteAgentsByLocalTombstones,
-  planPublicAgentCatalogView,
-  type PublicAgentFilterOptions,
-  type PublicAgentListOptions,
-  shouldPruneStalePublicAgentCache as shouldPruneStalePublicAgentCacheImpl,
-} from "../../agent/publicAgentCatalog";
-import {
-  getPublicAgentId,
-  getPublicAgentPruneDbKey,
-  matchesPublicAgentIdentifiers,
-} from "../../agent/publicAgentIdentity";
-import { remove } from "../../../database/dbSlice";
-import { getAllServers } from "../../../database/actions/common";
-import { isTombstoneRecord } from "../../../database/tombstones";
-
-/* -------------------------------------------------------------------------- */
-/* 类型定义                                                                   */
-/* -------------------------------------------------------------------------- */
-
-export interface UsePublicAgentsOptions
-  extends PublicAgentFilterOptions,
-    PublicAgentListOptions {
-  /** Filter agents that include this tool in their tools array */
-  /** Return list-card metadata only from remote public-agent APIs. */
-  summary?: boolean;
-  initialData?: Agent[];
-  reloadMode?: "preview" | "catalog";
-}
-
-interface PublicAgentsState {
-  loading: boolean;
-  error: Error | null;
-  data: Agent[];
-}
-
-/* -------------------------------------------------------------------------- */
-/* 删除策略：最低投入档——误删抑制开关                                          */
-/* -------------------------------------------------------------------------- */
-
-const PRUNE_LIMIT_MULTIPLIER = 5;
-const PRUNE_LIMIT_CAP = 500;
-
-export function shouldPruneStalePublicAgentCache({
-  searchName,
-}: {
-  searchName?: string;
-}) {
-  return shouldPruneStalePublicAgentCacheImpl({ searchName });
-}
-
-/* -------------------------------------------------------------------------- */
-/* 远程获取（支持 Abort）                                                     */
-/* -------------------------------------------------------------------------- */
-
-async function fetchRemoteAgents(
-  serverUrl: string,
-  options: UsePublicAgentsOptions,
-  signal?: AbortSignal
-): Promise<{ data: Agent[] }> {
-  const response = await fetch(`${serverUrl}/rpc/getPublicAgents`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(options),
-    signal,
-  });
-
-  if (!response.ok) {
-    throw new Error(`Remote fetch failed with status ${response.status}`);
-  }
-
-  const data = await response.json();
-  return data as { data: Agent[] };
-}
-
-/* -------------------------------------------------------------------------- */
-/* Hook 主体                                                                  */
-/* -------------------------------------------------------------------------- */
-
-export function usePublicAgents({
-  limit = 20,
-  sortBy = "recommended",
-  searchName = "",
-  userId,
-  imageOutputOnly = false,
-  toolName,
-  summary = false,
-  initialData = [],
-  reloadMode = "catalog",
-}: UsePublicAgentsOptions = {}) {
-  // Intentionally still uses the raw configured server selectors instead of the
-  // newer content/runtime helpers. Public-agent discovery is a mixed path:
-  // local cache hydration + marketplace-style remote aggregation across the
-  // currently configured peers. Keep it out of the local-first content CRUD
-  // refactor until the agent marketplace/server-ownership phase.
-  const currentServer = useAppSelector(selectCurrentServer);
-  const syncServers = useAppSelector(selectSyncServers);
-  const currentUserId = useAppSelector(selectUserId);
-  const dispatch = useAppDispatch();
-
-  const [state, setState] = useState<PublicAgentsState>({
-    loading: initialData.length === 0,
-    error: null,
-    data: initialData,
-  });
-
-  const requestIdRef = useRef(0);
-  const abortRef = useRef<AbortController | null>(null);
-  const pendingExcludedIdsRef = useRef<Set<string>>(new Set());
-
-  const fetchData = useCallback(async () => {
-    const uiOptions: UsePublicAgentsOptions = {
-      limit,
-      sortBy,
-      searchName,
-      userId,
-      imageOutputOnly,
-      toolName,
-      summary,
-    };
-    const myReqId = ++requestIdRef.current;
-
-    // 进入 loading，但保留现有数据；已有数据时不强制 loading，避免 SSR 首屏抖动
-    setState((prev) => ({
-      ...prev,
-      loading: prev.data.length === 0,
-      error: null,
-    }));
-
-    const excludedIds = pendingExcludedIdsRef.current;
-    const servers = getAllServers(currentServer, syncServers);
-    const hasRemoteServers = servers.length > 0;
-
-    /* -------------------------- 1) 本地优先渲染 -------------------------- */
-
-    let localResult: { data: Agent[]; tombstones: Array<Record<string, any>> } = {
-      data: [],
-      tombstones: [],
-    };
-    let localDataForUi: Agent[] = [];
-    let localSortedForFallback: Agent[] = [];
-
-    try {
-      localResult = await fetchLocal(uiOptions);
-      localDataForUi =
-        excludedIds.size > 0
-          ? localResult.data.filter(
-              (agent) => !matchesPublicAgentIdentifiers(agent, excludedIds)
-            )
-          : localResult.data;
-
-      if (myReqId !== requestIdRef.current) return;
-
-      localSortedForFallback = planPublicAgentCatalogView({
-        localAgents: localDataForUi,
-        remoteAgents: [],
-        hasAuthoritativeRemoteResult: false,
-        currentUserId,
-        options: uiOptions,
-      }).localFallbackAgents;
-
-      if (!hasRemoteServers) {
-        setState((prev) => ({ ...prev, data: localSortedForFallback }));
-      }
-    } catch {
-      // 本地失败不阻塞远程
-    }
-
-    /* -------------------------- 2) 构造远程服务器列表 --------------------- */
-
-    // 若没有任何可用远程（离线或未配置），则结束（只保留本地）
-    if (servers.length === 0) {
-      if (excludedIds.size > 0) {
-        const stillPending = new Set(
-          Array.from(excludedIds).filter((identifier) =>
-            localResult.data.some((agent) =>
-              matchesPublicAgentIdentifiers(agent, new Set([identifier]))
-            )
-          )
-        );
-        pendingExcludedIdsRef.current = stillPending;
-      }
-      setState((prev) => ({ ...prev, loading: false }));
-      return;
-    }
-
-    /* -------------------------- 3) 远程请求 + 合并 ------------------------ */
-
-    try {
-      abortRef.current?.abort();
-      abortRef.current = new AbortController();
-
-      const pruneLimit = Math.min(
-        PRUNE_LIMIT_CAP,
-        Math.max(limit, limit * PRUNE_LIMIT_MULTIPLIER)
-      );
-      const remoteOptions: UsePublicAgentsOptions = {
-        ...uiOptions,
-        limit: pruneLimit,
-      };
-
-      const remoteResults = await Promise.allSettled(
-        servers.map((server) =>
-          fetchRemoteAgents(server, remoteOptions, abortRef.current!.signal)
-        )
-      );
-
-      if (myReqId !== requestIdRef.current) return;
-
-      const hasAuthoritativeRemoteResult = remoteResults.some(
-        (res) => res.status === "fulfilled"
-      );
-      const remoteData = maskRemoteAgentsByLocalTombstones(
-        dedupeRemotePublicAgents(
-          remoteResults.flatMap((res, index) => {
-            if (res.status !== "fulfilled") return [];
-            const originServer = servers[index];
-            return (res.value?.data ?? [])
-              .filter((agent: Agent) => !isTombstoneRecord(agent))
-              .map((agent: Agent) => ({
-                ...agent,
-                originServer,
-              }));
-          })
-        ),
-        localResult.tombstones ?? []
-      );
-      const remoteDataForUi =
-        excludedIds.size > 0
-          ? remoteData.filter(
-              (agent) => !matchesPublicAgentIdentifiers(agent, excludedIds)
-            )
-          : remoteData;
-
-      const viewPlan = planPublicAgentCatalogView({
-        localAgents: localDataForUi ?? [],
-        remoteAgents: remoteDataForUi,
-        hasAuthoritativeRemoteResult,
-        currentUserId,
-        options: uiOptions,
-      });
-
-      /* -------------------------- 5) 条件化删除本地缓存 -------------------- */
-
-      const canPruneScene = shouldPruneStalePublicAgentCache({
-        searchName,
-      });
-
-      if (
-        canPruneScene &&
-        viewPlan.pruneIds.length > 0 &&
-        myReqId === requestIdRef.current
-      ) {
-        viewPlan.pruneIds.forEach((id) => {
-          const localItem = localResult.data.find(
-            (agent) => getPublicAgentId(agent) === id
-          );
-          const dbKey = getPublicAgentPruneDbKey(localItem);
-          if (dbKey) {
-            dispatch(remove(dbKey));
-          }
-        });
-      }
-
-      if (myReqId !== requestIdRef.current) return;
-
-      if (excludedIds.size > 0) {
-        const stillPending = new Set(
-          Array.from(excludedIds).filter((identifier) => {
-            const identifierSet = new Set([identifier]);
-            return (
-              localResult.data.some((agent) =>
-                matchesPublicAgentIdentifiers(agent, identifierSet)
-              ) ||
-              remoteData.some((agent) =>
-                matchesPublicAgentIdentifiers(agent, identifierSet)
-              )
-            );
-          })
-        );
-        pendingExcludedIdsRef.current = stillPending;
-      }
-
-      setState({ loading: false, error: null, data: viewPlan.visibleAgents });
-    } catch (err: any) {
-      if (err?.name === "AbortError") return;
-      if (myReqId !== requestIdRef.current) return;
-
-      // 远程失败：没有已渲染数据时回退到本地缓存。
-      setState((prev) => ({
-        ...prev,
-        data: prev.data.length > 0 ? prev.data : localSortedForFallback,
-        loading: false,
-        error: null,
-      }));
-    }
-  }, [
-    limit,
-    sortBy,
-    searchName,
-    userId,
-    imageOutputOnly,
-    toolName,
-    summary,
-    currentServer,
-    syncServers,
-    currentUserId,
-    dispatch,
-  ]);
-
-  useEffect(() => {
-    fetchData();
-    return () => {
-      abortRef.current?.abort();
-    };
-  }, [
-    fetchData,
-    imageOutputOnly,
-    initialData.length,
-    reloadMode,
-    searchName,
-    sortBy,
-    toolName,
-    summary,
-    userId,
-  ]);
-
-  const retry = useCallback((excludedAgentIds: string[] = []) => {
-    if (excludedAgentIds.length > 0) {
-      pendingExcludedIdsRef.current = new Set([
-        ...pendingExcludedIdsRef.current,
-        ...excludedAgentIds.map((value) => String(value)),
-      ]);
-    }
-
-    setState((prev) => {
-      const nextData =
-        excludedAgentIds.length > 0
-          ? prev.data.filter(
-              (agent) =>
-                !matchesPublicAgentIdentifiers(
-                  agent,
-                  new Set(excludedAgentIds.map((value) => String(value)))
-                )
-            )
-          : prev.data;
-      return {
-        ...prev,
-        data: nextData,
-        loading:
-          reloadMode === "catalog" &&
-          excludedAgentIds.length === 0 &&
-          nextData.length === 0,
-        error: null,
-      };
-    });
-    if (reloadMode === "catalog") {
-      fetchData();
-    }
-  }, [fetchData]);
-
-  return { ...state, retry };
-}