nolo-cli 0.1.9 → 0.1.11

package/ai/agent/runAgentBackground.ts

@@ -1,238 +0,0 @@
-// packages/ai/agent/runAgentBackground.ts
-// 后台运行 agent 并通过 SSE 监听结果
-//
-// 使用方式（在组件/thunk 中）：
-//   dispatch(runAgentBackground({
-//     agentKey: "agent-xxx",
-//     userInput: "帮我搜索...",
-//     spaceId: "space-yyy",       // 可选，写入 space 索引
-//     onStatusChange: (s) => ..., // 可选，实时更新 UI 状态
-//     onDone: (result) => ...,    // 可选，成功回调
-//     onFailed: (error) => ...,   // 可选，失败回调
-//   }));
-
-import { createAsyncThunk } from "@reduxjs/toolkit";
-import type { RootState } from "app/store";
-import { selectCurrentServer } from "app/settings/settingSlice";
-import { selectCurrentToken } from "auth/authSlice";
-import { createSSEParser } from "../chat/parseMultilineSSE";
-
-export type DialogStatus = "pending" | "running" | "done" | "failed" | "cancelled" | "reconnecting";
-
-export interface RunAgentBackgroundResult {
-    dialogId: string;
-    content?: string;
-    usage?: unknown;
-}
-
-export interface RunAgentBackgroundArgs {
-    agentKey: string;
-    userInput: string;
-    serverBase?: string;
-    spaceId?: string;
-    /** 任务状态变化时触发（pending → running → done/failed） */
-    onStatusChange?: (status: DialogStatus) => void;
-    /** agent 成功完成时触发 */
-    onDone?: (result: { dialogId: string; content?: string; usage?: unknown }) => void;
-    /** agent 失败时触发 */
-    onFailed?: (error: string) => void;
-    /** 外部取消信号 */
-    signal?: AbortSignal;
-}
-
-const MAX_SSE_RETRIES = 3;
-const SSE_RETRY_DELAY_MS = 1500;
-
-type RetryableError = Error & { retryable?: boolean };
-
-function createRetryableError(message: string): RetryableError {
-    return Object.assign(new Error(message), { retryable: true });
-}
-
-function createSubscriptionError(status: number, hasBody: boolean): RetryableError {
-    const message = !hasBody
-        ? `事件流响应缺少 body (${status})`
-        : `无法订阅事件流 (${status})`;
-
-    if (status === 401 || status === 403) {
-        return new Error(message);
-    }
-
-    return createRetryableError(message);
-}
-
-/**
- * 订阅单次 dialog 事件流，收到 done/failed 则 resolve/reject，
- * 流意外关闭时 reject 并标记 retryable=true 供上层重试。
- */
-async function listenToDialogEvents(
-    dialogId: string,
-    currentServer: string,
-    authHeader: string,
-    signal: AbortSignal,
-    onStatusChange?: (status: DialogStatus) => void,
-    onDone?: (result: { dialogId: string; content?: string; usage?: unknown }) => void,
-    onFailed?: (error: string) => void,
-): Promise<RunAgentBackgroundResult> {
-    let eventsRes: Response;
-    try {
-        eventsRes = await fetch(
-            `${currentServer}/api/events/dialog-${dialogId}`,
-            {
-                method: "GET",
-                headers: {
-                    Accept: "text/event-stream",
-                    ...(authHeader && { Authorization: authHeader }),
-                },
-                signal,
-            }
-        );
-    } catch (e) {
-        if (e instanceof Error && e.name === "AbortError") throw e;
-        throw createRetryableError("事件流连接失败");
-    }
-
-    if (!eventsRes.ok || !eventsRes.body) {
-        throw createSubscriptionError(eventsRes.status, !!eventsRes.body);
-    }
-
-    const reader = eventsRes.body.getReader();
-    const decoder = new TextDecoder();
-    const parseSSE = createSSEParser();
-
-    return new Promise<RunAgentBackgroundResult>((resolve, reject) => {
-        const processStream = async () => {
-            try {
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done) break;
-
-                    const chunk = decoder.decode(value, { stream: true });
-                    const events = parseSSE(chunk);
-
-                    for (const event of events) {
-                        const type = event.type as string;
-
-                        if (type === "status") {
-                            onStatusChange?.(event.status as DialogStatus);
-                        } else if (type === "done") {
-                            const result = {
-                                dialogId,
-                                content: event.content as string | undefined,
-                                usage: event.usage,
-                            };
-                            onStatusChange?.("done");
-                            onDone?.(result);
-                            reader.cancel().catch(() => { });
-                            resolve(result);
-                            return;
-                        } else if (type === "failed") {
-                            const errMsg = (event.error as string) ?? "未知错误";
-                            onStatusChange?.("failed");
-                            onFailed?.(errMsg);
-                            reader.cancel().catch(() => { });
-                            reject(new Error(errMsg));
-                            return;
-                        }
-                    }
-                }
-                // 流正常关闭但未收到 done/failed（服务重启等），标记可重试
-                const err = createRetryableError("事件流意外关闭");
-                reject(err);
-            } catch (e: unknown) {
-                if (e instanceof Error && e.name === "AbortError") {
-                    resolve({ dialogId });
-                } else {
-                    reject(e);
-                }
-            }
-        };
-
-        processStream();
-    });
-}
-
-export const runAgentBackground = createAsyncThunk<
-    RunAgentBackgroundResult,
-    RunAgentBackgroundArgs,
-    { state: RootState }
->("agent/runBackground", async (args, { getState, signal: thunkSignal }) => {
-    const { agentKey, userInput, serverBase, spaceId, onStatusChange, onDone, onFailed } = args;
-
-    const state = getState();
-    const currentServer = serverBase?.trim().replace(/\/+$/, "") || selectCurrentServer(state);
-    const token = selectCurrentToken(state);
-    if (!currentServer) throw new Error("未配置服务器地址");
-
-    const authHeader = token ? `Bearer ${token}` : "";
-
-    // ── Step 1: 触发后台运行，获取 dialogId ──────────────────────────────────
-    const runRes = await fetch(`${currentServer}/api/agent/run`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            ...(authHeader && { Authorization: authHeader }),
-        },
-        body: JSON.stringify({
-            agentKey,
-            userInput,
-            spaceId,
-            background: true,
-            runtimeContext: {
-                surface: "web",
-                host: "browser",
-                runtime: "react",
-                entrypoint: "background-agent-run",
-                capabilities: ["background", "sse-events"],
-            },
-        }),
-        signal: args.signal ?? thunkSignal,
-    });
-
-    if (!runRes.ok) {
-        const err = await runRes.text();
-        throw new Error(`启动后台任务失败 (${runRes.status}): ${err}`);
-    }
-
-    const {
-        dialogId,
-        serverBase: routedServerBase,
-    } = (await runRes.json()) as {
-        dialogId: string;
-        status: string;
-        serverBase?: string;
-    };
-    onStatusChange?.("pending");
-
-    // ── Step 2: 订阅 SSE 事件流（含断线重连，最多 3 次）────────────────────────
-    const effectiveSignal = args.signal ?? thunkSignal;
-    let lastError: Error | undefined;
-
-    const eventServer =
-        typeof routedServerBase === "string" && routedServerBase.trim()
-            ? routedServerBase.trim().replace(/\/+$/, "")
-            : currentServer;
-
-    for (let attempt = 0; attempt <= MAX_SSE_RETRIES; attempt++) {
-        if (attempt > 0) {
-            if (effectiveSignal.aborted) throw new DOMException("Aborted", "AbortError");
-            onStatusChange?.("reconnecting");
-            await new Promise(r => setTimeout(r, SSE_RETRY_DELAY_MS));
-            if (effectiveSignal.aborted) throw new DOMException("Aborted", "AbortError");
-        }
-
-        try {
-            return await listenToDialogEvents(
-                dialogId, eventServer, authHeader, effectiveSignal,
-                onStatusChange, onDone, onFailed,
-            );
-        } catch (e: any) {
-            if (e?.name === "AbortError") throw e;          // 用户主动取消，不重试
-            if (!e?.retryable || attempt >= MAX_SSE_RETRIES) throw e; // 非可重试错误或超限
-            lastError = e;
-            // retryable（流意外关闭）→ 继续重连
-        }
-    }
-
-    throw lastError ?? new Error("事件流重连失败");
-});

package/ai/agent/runAgentClientLoop.ts

@@ -1,138 +0,0 @@
-// packages/ai/agent/runAgentClientLoop.ts
-//
-// 客户端多轮 Agent 循环：复现服务端 runAgentLoop 的逻辑
-// - 不支持 Response API（当前全部走 OpenAI Completions 格式）
-// - 工具执行通过 executeToolCall 在客户端完成
-// - 每轮：调 LLM → 有 tool_calls → 执行工具 → 追加 tool 消息 → 继续
-
-import { RootState } from "app/store";
-import { Message } from "app/types";
-import { read } from "database/dbSlice";
-import { fetchAgentContexts } from "ai/agent/fetchAgentContexts";
-import { generateRequestBody } from "ai/llm/generateRequestBody";
-import { getApiEndpoint } from "ai/llm/providers";
-import { selectCurrentServer } from "app/settings/settingSlice";
-import { selectCurrentToken } from "auth/authSlice";
-import { performFetchRequest } from "ai/chat/fetchUtils";
-import { executeToolCall } from "ai/agent/executeToolCall";
-import { extractCustomId } from "core/prefix";
-import { updateTokensAction } from "chat/dialog/actions/updateTokensAction";
-
-export interface RunAgentClientLoopArgs {
-  agentKey: string;
-  content: any;
-  parentMessageId?: string;
-  billingDialogKey?: string;
-}
-
-export interface RunAgentClientLoopResult {
-  content: string;
-  toolCallCount: number;
-}
-
-/**
- * 客户端多轮 Agent 执行循环。
- *
- * 使用场景：callAgentTool 的 client 模式、runAgent thunk。
- * 不适合需要流式输出的场景（请用 runStreamingAgent）。
- */
-export async function runAgentClientLoop(
-  args: RunAgentClientLoopArgs,
-  thunkApi: any
-): Promise<RunAgentClientLoopResult> {
-  const { agentKey, content, parentMessageId, billingDialogKey } = args;
-  const { getState, dispatch } = thunkApi;
-  const state = getState() as RootState;
-
-  // 1. 加载 Agent 配置
-  const agentConfig = await dispatch(read({ dbKey: agentKey })).unwrap();
-
-  // 2. 加载 Agent 上下文（知识库 / references）
-  const agentContexts = await fetchAgentContexts(
-    agentConfig.references,
-    dispatch
-  );
-
-  // 3. 构造首轮 body（generateRequestBody 会注入 system prompt）
-  const initialMessages: Message[] = [{ role: "user", content }];
-  const body = generateRequestBody({
-    agentConfig,
-    messages: initialMessages,
-    userInput: typeof content === "string" ? content : JSON.stringify(content),
-    contexts: agentContexts,
-  });
-  body.stream = false; // 多轮模式不用流式
-
-  // body.messages 包含了 system 消息 + 用户消息，后续累积 tool 结果入此数组
-  const messages: Message[] = body.messages as Message[];
-
-  const api = getApiEndpoint(agentConfig);
-  const currentServer = selectCurrentServer(state);
-  const token = selectCurrentToken(state);
-
-  let finalContent = "";
-  let toolCallCount = 0;
-
-  // 4. 多轮循环
-  for (;;) {
-    // 更新 messages（含累积的 tool 结果）
-    body.messages = messages;
-
-    const response = await performFetchRequest({
-      agentConfig,
-      api,
-      bodyData: body as any,
-      currentServer,
-      token,
-    });
-
-    const data = await response.json();
-    const choice = data.choices?.[0];
-
-    if (billingDialogKey && data?.usage) {
-      await updateTokensAction(
-        {
-          dialogId: extractCustomId(billingDialogKey),
-          dialogKey: billingDialogKey,
-          usage: data.usage,
-          agentConfig,
-        },
-        thunkApi
-      );
-    }
-
-    if (!choice) {
-      console.warn("[runAgentClientLoop] 响应中找不到 choices[0]，停止");
-      break;
-    }
-
-    const assistantMsg = choice.message;
-    const finishReason: string = choice.finish_reason ?? "";
-
-    // 追加 assistant 消息
-    messages.push(assistantMsg);
-
-    // 记录文本内容
-    if (typeof assistantMsg.content === "string" && assistantMsg.content) {
-      finalContent = assistantMsg.content;
-    }
-
-    // 无工具调用 or 模型明确 stop → 结束
-    if (!assistantMsg.tool_calls?.length || finishReason === "stop") {
-      break;
-    }
-
-    // 5. 执行工具调用
-    for (const tc of assistantMsg.tool_calls) {
-      toolCallCount++;
-      const toolResultContent = await executeToolCall(tc, thunkApi, parentMessageId);
-      messages.push({
-        role: "tool",
-        tool_call_id: tc.id,
-        content: toolResultContent,
-      } as any);
-    }
-  }
-
-  return { content: finalContent, toolCallCount };
-}

package/ai/agent/runtimeGuidance.ts

@@ -1,97 +0,0 @@
-import { canonicalizeToolNames } from "ai/tools/toolNameAliases";
-import { buildContextLayerContractBlock } from "./contextLayerContract";
-import { buildStartupProtocolBlock } from "./startupProtocol";
-
-export type RuntimeGuidanceToolOptions = {
-  hasCheckEnvTool: boolean;
-  hasExecShellTool: boolean;
-  hasRememberMemoryTool: boolean;
-  hasDocTools: boolean;
-  hasBrowserTools: boolean;
-  hasEmailRegistrationTools: boolean;
-  hasEmailRegistrationWorkflow: boolean;
-};
-
-const normalizeToolName = (name: string): string =>
-  name.replace(/[-_]/g, "").toLowerCase();
-
-const hasAnyTool = (normalizedTools: Set<string>, candidates: string[]): boolean =>
-  candidates.some((candidate) => normalizedTools.has(normalizeToolName(candidate)));
-
-const hasAllTools = (normalizedTools: Set<string>, candidates: string[]): boolean =>
-  candidates.every((candidate) => normalizedTools.has(normalizeToolName(candidate)));
-
-const buildEmailRegistrationWorkflowBlock = (
-  enabled: boolean
-): string => {
-  if (!enabled) return "";
-
-  return [
-    "--- 邮箱验证码注册流程 ---",
-    "当用户要求你注册网站账号时，只允许处理用户明确指定的当前目标网站，不要自行扩展到其他网站、批量注册或规避平台风控。",
-    "",
-    "分阶段协议：discover before acting -> assess supportability -> register -> verify -> closeout。",
-    "",
-    "推荐流程：",
-    "1. discover before acting：先用 browser_openSession / browser_readContent 阅读页面，确认目标注册页 URL、账号用途、必填项和停止条件；不要一打开页面就盲点按钮。如果缺少目标网站，先询问用户。",
-    "2. assess supportability：先判断该流程是否支持当前受控自动化。遇到 CAPTCHA、手机号验证、支付、身份/KYC、OAuth-only、服务条款确认、或任何看起来像规避风控的步骤时，必须立即停止并向用户说明 blockingReason；不要硬闯。",
-    "3. register：只有在确认支持后，才使用 email_provision_identity 为当前 agent 生成受控域名邮箱身份，再使用 browser_openSession / browser_typeText / browser_click / browser_readContent 填写并提交注册表单。",
-    "4. verify：提交后使用 email_wait_for 等待该 agent 收件箱里的验证邮件，再用 email_extract_verification 提取验证码或验证链接，回填验证码或打开验证链接完成验证。",
-    "5. closeout：无论成功还是失败都要 always close sessions，主动清理浏览器会话（例如 browser_closeSession）。如果流程失败，必须明确 failedStage 与 blockingReason，并说明可恢复选项；不要盲目尝试无关网站或绕过验证。",
-    "6. 最终只在对话中返回账号、邮箱和一次性生成的密码；不要持久化密码，不要写入 agent metadata、数据库、文档或记忆。",
-    "",
-    "必须暂停并询问用户的情况：CAPTCHA、手机号验证、支付、身份/KYC、OAuth 授权、OAuth-only、服务条款确认、或任何看起来像规避风控的步骤。",
-    "如果流程失败，说明 failedStage、blockingReason 和可恢复选项，不要盲目尝试无关网站或绕过验证。",
-  ].join("\n");
-};
-
-export const resolveRuntimeGuidanceToolOptions = (
-  tools: string[] = []
-): RuntimeGuidanceToolOptions => {
-  const normalizedTools = canonicalizeToolNames(tools);
-  const normalizedToolSet = new Set(normalizedTools.map(normalizeToolName));
-  const hasBrowserTools = hasAllTools(normalizedToolSet, [
-    "browser_openSession",
-    "browser_readContent",
-    "browser_typeText",
-    "browser_click",
-    "browser_closeSession",
-  ]);
-  const hasBrowserProbe = hasAnyTool(normalizedToolSet, ["browser_probePage", "browserProbePage"]);
-  const hasEmailRegistrationTools = hasAllTools(normalizedToolSet, [
-    "email_provision_identity",
-    "email_wait_for",
-    "email_extract_verification",
-  ]);
-
-  return {
-    hasCheckEnvTool: normalizedTools.includes("checkEnv"),
-    hasExecShellTool: normalizedTools.includes("execShell"),
-    hasRememberMemoryTool: normalizedTools.includes("rememberMemory"),
-    hasDocTools: normalizedTools.some((tool) =>
-      ["read", "readDoc", "readPage", "createDoc", "updateDoc"].includes(tool)
-    ),
-    hasBrowserTools,
-    hasEmailRegistrationTools,
-    // Require browser_probePage to be present before enabling email registration workflow guidance.
-    hasEmailRegistrationWorkflow: hasBrowserTools && hasBrowserProbe && hasEmailRegistrationTools,
-  };
-};
-
-export const buildRuntimeGuidanceBlocks = (tools: string[] = []) => {
-  const options = resolveRuntimeGuidanceToolOptions(tools);
-
-  return {
-    startupProtocol: buildStartupProtocolBlock({
-      hasCheckEnvTool: options.hasCheckEnvTool,
-      hasExecShellTool: options.hasExecShellTool,
-    }),
-    contextLayerContract: buildContextLayerContractBlock({
-      hasRememberMemoryTool: options.hasRememberMemoryTool,
-      hasDocTools: options.hasDocTools,
-    }),
-    emailRegistrationWorkflow: buildEmailRegistrationWorkflowBlock(
-      options.hasEmailRegistrationWorkflow
-    ),
-  };
-};

package/ai/agent/runtimeServerBase.ts

@@ -1,37 +0,0 @@
-export const normalizeServerOrigin = (base: string): string | null => {
-  try {
-    return new URL(base).origin.replace(/\/+$/, "");
-  } catch {
-    return null;
-  }
-};
-
-export const extractAgentRuntimeServerBase = (agentRecord: any): string | null => {
-  const candidates = [
-    agentRecord?.delegation?.serverBase,
-    agentRecord?.runtime?.serverBase,
-    agentRecord?.runtimeServerBase,
-  ];
-
-  if (Array.isArray(agentRecord?.runtimes)) {
-    const runtimes = agentRecord.runtimes
-      .filter((runtime: any) => runtime && typeof runtime === "object")
-      .slice()
-      .sort((a: any, b: any) => {
-        const priorityA =
-          typeof a.priority === "number" ? a.priority : Number.MAX_SAFE_INTEGER;
-        const priorityB =
-          typeof b.priority === "number" ? b.priority : Number.MAX_SAFE_INTEGER;
-        return priorityA - priorityB;
-      });
-    candidates.push(...runtimes.map((runtime: any) => runtime.serverBase));
-  }
-
-  for (const candidate of candidates) {
-    if (typeof candidate === "string" && candidate.trim()) {
-      return candidate.trim();
-    }
-  }
-
-  return null;
-};

package/ai/agent/server/fetchPublicAgents.ts

@@ -1,128 +0,0 @@
-import serverDb from "database/server/db";
-import { pubAgentKeys } from "database/keys";
-import { Agent } from "app/types";
-import { sortAgents } from "ai/agent/utils/sortUtils";
-import { supportsImageGeneration } from "ai/agent/utils/imageOutput";
-import { isTombstoneRecord } from "database/tombstones";
-
-export interface FetchPublicAgentsOptions {
-  limit?: number;
-  sortBy?:
-  | "recommended"
-  | "newest"
-  | "popular"
-  | "rating"
-  | "outputPriceAsc"
-  | "outputPriceDesc"
-  | "favorite"; // 新增：按收藏排序
-  searchName?: string;
-  userId?: string;
-  imageOutputOnly?: boolean;
-  /** Filter agents that include this tool in their tools array */
-  toolName?: string;
-}
-
-export interface FetchPublicAgentsResult {
-  data: Agent[];
-  total: number;
-  hasMore: boolean;
-}
-
-// 局部 helpers 已移除，使用 shared utils
-
-async function dbList<T>(
-  gte: string,
-  lte: string,
-  filter?: (v: T) => boolean
-): Promise<T[]> {
-  const res: T[] = [];
-  for await (const [, value] of serverDb.iterator({ gte, lte })) {
-    if (!filter || filter(value as T)) res.push(value as T);
-  }
-  return res;
-}
-
-// 轻量优化：对 public agents 做一个短 TTL 的内存缓存，减少频繁迭代 DB
-const PUBLIC_AGENTS_CACHE_TTL_MS = 5 * 1000; // 5 秒
-let cachedPublicAgents: Agent[] | null = null;
-let cachedPublicAgentsAt = 0;
-
-export function invalidatePublicAgentsCache() {
-  cachedPublicAgents = null;
-  cachedPublicAgentsAt = 0;
-}
-
-async function getPublicAgents(): Promise<Agent[]> {
-  const now = Date.now();
-  if (cachedPublicAgents && now - cachedPublicAgentsAt < PUBLIC_AGENTS_CACHE_TTL_MS) {
-    return cachedPublicAgents;
-  }
-
-  const ranges = pubAgentKeys.allPublicRanges();
-  let list: Agent[] = [];
-
-  for (const { start, end } of ranges) {
-    const res = await dbList<Agent>(
-      start,
-      end,
-      (v) => (v as any).isPublic && !isTombstoneRecord(v)
-    );
-    list = list.concat(res);
-  }
-
-  cachedPublicAgents = list;
-  cachedPublicAgentsAt = now;
-
-  return list;
-}
-
-// 轻量优化：限制单次请求的最大返回条数，避免未来被滥用
-const DEFAULT_LIMIT = 20;
-const MAX_LIMIT = 100;
-
-export async function fetchPublicAgents(
-  options: FetchPublicAgentsOptions = {}
-): Promise<FetchPublicAgentsResult> {
-  const {
-    limit: rawLimit = DEFAULT_LIMIT,
-    sortBy = "recommended",
-    searchName,
-    userId,
-    imageOutputOnly = false,
-    toolName,
-  } = options;
-
-  const limit = Math.min(Math.max(rawLimit, 1), MAX_LIMIT);
-
-  // 使用带缓存的获取函数
-  const baseList = await getPublicAgents();
-
-  // 注意不要修改缓存引用，后续操作都在拷贝/派生数组上做
-  let list = baseList;
-
-  if (searchName) {
-    const kw = searchName.toLowerCase();
-    list = list.filter((agent) => agent.name?.toLowerCase().includes(kw));
-  }
-
-  if (userId) {
-    list = list.filter((agent) => agent.userId === userId);
-  }
-
-  if (imageOutputOnly) {
-    list = list.filter((agent) => supportsImageGeneration(agent));
-  }
-
-  if (toolName) {
-    const kw = toolName.toLowerCase();
-    list = list.filter((agent) =>
-      agent.tools?.some((t) => t.toLowerCase().includes(kw))
-    );
-  }
-
-  // 使用统一的排序逻辑
-  const sorted = sortAgents(list, sortBy);
-
-  const data = sorted.slice(0, limit);
-  return { data, total: list.length, hasMore: list.length > limit };
-}