nolo-cli 0.1.13 → 0.1.15

package/ai/tools/createSkillDocTool.ts

@@ -0,0 +1,155 @@
+import { createDoc } from "render/page/docSlice";
+import { selectCurrentSpaceId } from "create/space/spaceSlice";
+import type { RootState } from "app/store";
+import {
+  buildSkillDocFromArgs,
+  type CreateSkillDocArgs,
+} from "ai/skills/skillDocBuilder";
+import { buildSkillFollowupResult } from "./skillFollowup";
+
+export interface CreateSkillDocToolArgs extends CreateSkillDocArgs {
+  spaceId?: string;
+  categoryId?: string;
+}
+
+export const createSkillDocFunctionSchema = {
+  name: "createSkillDoc",
+  description: [
+    "创建一个本地 skill 文档，并自动写入隐藏的 skill-config / eval-config 协议块。",
+    "适合把某个能力流程沉淀成可被 agent 引用的 skill，而不是手写协议注释。",
+    "创建成功后，如果用户还没说明下一步，优先调用 ui_ask_choice 继续询问：仅保存、挂到现有 Agent，还是新建一个 Agent 来使用它。",
+  ].join("\n"),
+  parameters: {
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        description: "可选：文档标题。未提供时回退到 name。",
+      },
+      name: {
+        type: "string",
+        description: "可选：skill 名称。未提供时回退到 title。",
+      },
+      description: {
+        type: "string",
+        description: "必填：skill 的用途说明。",
+      },
+      body: {
+        type: "string",
+        description: "可选：skill 的正文说明、步骤、注意事项等 Markdown 内容。",
+      },
+      spaceId: {
+        type: "string",
+        description: '可选：目标 spaceId；不传则优先使用当前 space。可传空字符串 ""。',
+      },
+      categoryId: {
+        type: "string",
+        description: '可选：目标分类 categoryId；不传时传空字符串 ""。',
+      },
+      toolNames: {
+        type: "array",
+        items: { type: "string" },
+        description: "可选：该 skill 绑定的工具名列表。",
+      },
+      requiredSkills: {
+        type: "array",
+        items: { type: "string" },
+        description: "可选：硬依赖的 skill key/page key 列表。",
+      },
+      recommendedSkills: {
+        type: "array",
+        items: { type: "string" },
+        description: "可选：推荐但不强制的 skill key/page key 列表。",
+      },
+      promptPatch: {
+        type: "string",
+        description: "可选：附加到 system prompt 的技能提示。",
+      },
+      budgetTier: {
+        type: "string",
+        enum: ["low", "medium", "high"],
+        description: "可选：该 skill 的预算等级。",
+      },
+      dispatchPreferred: {
+        type: "boolean",
+        description: "可选：是否建议优先走 agent dispatch 而不是直接本 agent 执行。",
+      },
+      modalities: {
+        type: "array",
+        items: { type: "string", enum: ["text", "image", "video", "audio", "3d"] },
+        description: "可选：该 skill 涉及的模态。",
+      },
+      preferredAgents: {
+        type: "array",
+        items: { type: "string" },
+        description: "可选：更适合执行该 skill 的 agent 名称或 key。",
+      },
+      discoverKeywords: {
+        type: "array",
+        items: { type: "string" },
+        description: "可选：触发/发现关键字。",
+      },
+      discoverExamples: {
+        type: "array",
+        items: { type: "string" },
+        description: "可选：示例任务或问法。",
+      },
+      evalCases: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            input: { type: "string" },
+            expectedTools: {
+              type: "array",
+              items: { type: "string" },
+            },
+            expectedSignals: {
+              type: "array",
+              items: { type: "string" },
+            },
+            forbiddenSignals: {
+              type: "array",
+              items: { type: "string" },
+            },
+          },
+          required: ["input"],
+        },
+        description: "可选：skill 的评估用例，写入 eval-config。",
+      },
+    },
+    required: ["description"],
+  } as const,
+};
+
+export async function createSkillDocFunc(
+  args: CreateSkillDocToolArgs,
+  thunkApi: any
+): Promise<{ rawData: unknown; displayData: string }> {
+  const { dispatch, getState } = thunkApi;
+  const state = getState() as RootState;
+  const { title, content, skillConfig, evalConfig } = buildSkillDocFromArgs(args);
+
+  const explicitSpaceId = (args.spaceId ?? "").trim() || undefined;
+  const currentSpaceId = selectCurrentSpaceId(state) || undefined;
+  const spaceId = explicitSpaceId ?? currentSpaceId;
+  const categoryId = (args.categoryId ?? "").trim() || undefined;
+
+  const id = await (dispatch as any)(
+    (createDoc as any)({
+      title,
+      spaceId,
+      categoryId,
+      content,
+    })
+  ).unwrap();
+
+  return buildSkillFollowupResult({
+    dbKey: id,
+    title,
+    skillId: skillConfig.id,
+    spaceId: spaceId ?? null,
+    toolNames: skillConfig.toolNames ?? [],
+    hasEvalConfig: !!evalConfig,
+  });
+}

package/ai/tools/createWorkflowTool.ts

@@ -0,0 +1,154 @@
+/**
+ * createWorkflow tool
+ *
+ * LLM calls this ONCE to define and immediately execute a workflow.
+ * The execution engine runs all steps deterministically — no further
+ * LLM involvement needed for orchestration, so token cost is O(1)
+ * regardless of step count.
+ *
+ * Use when the task path is known upfront.
+ * Use agent loop when the path needs dynamic discovery.
+ */
+
+import { runWorkflow } from "ai/workflow/workflowExecutor";
+import type {
+  WorkflowDefinition,
+  WorkflowStep,
+} from "ai/workflow/workflowTypes";
+
+export const createWorkflowFunctionSchema = {
+  name: "createWorkflow",
+  description:
+    "当你已知完整执行路径时使用本工具。定义一个多步骤 workflow，引擎自动执行全部步骤，" +
+    "不需要每步都调用 LLM 决策，大幅节省 token。" +
+    "步骤类型：" +
+    "'tool'——直接执行注册工具；" +
+    "'llm'——单次 LLM 调用（无 tool loop）；" +
+    "'parallel'——子步骤并发执行；" +
+    "'condition'——纯逻辑判断分支，无需 LLM。" +
+    "步骤间通过 {{steps.STEP_ID.result}} 传递数据。",
+  parameters: {
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        description: "Workflow 标题，简明描述整体目标。",
+      },
+      steps: {
+        type: "array",
+        description: "有序步骤列表。每步声明类型和所需参数，引擎顺序执行（parallel 步骤内部并发）。",
+        items: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "步骤唯一 ID，后续步骤通过 {{steps.ID.result}} 引用。",
+            },
+            type: {
+              type: "string",
+              enum: ["tool", "llm", "parallel", "condition"],
+              description: "步骤类型。",
+            },
+            title: {
+              type: "string",
+              description: "步骤人类可读描述（可选）。",
+            },
+            // tool step
+            tool: {
+              type: "string",
+              description: "type='tool' 时必填，工具名称。",
+            },
+            args: {
+              type: "object",
+              description:
+                "type='tool' 时必填，工具参数。支持 {{steps.ID.result}} 和 {{steps.ID.result[N]}} 占位符。" +
+                "parallel 子步骤结果也可直接通过其自身 ID 引用，例如 {{steps.subStepId.result}}。",
+            },
+            // llm step
+            prompt: {
+              type: "string",
+              description: "type='llm' 时必填，发送给模型的 prompt。支持占位符。",
+            },
+            model: {
+              type: "string",
+              description: "type='llm' 时可选，指定模型名。",
+            },
+            // parallel step
+            steps: {
+              type: "array",
+              description:
+                "type='parallel' 时必填，子步骤列表（tool 或 llm 类型），并发执行。" +
+                "子步骤执行完成后，其结果同时以子步骤自身 ID 注册到全局 steps map，" +
+                "后续步骤可通过 {{steps.subStepId.result}} 直接引用，无需通过父 parallel 步骤中转。",
+              items: { type: "object" },
+            },
+            // condition step
+            check: {
+              type: "string",
+              description:
+                "type='condition' 时必填，纯 JS 布尔表达式。" +
+                "steps.<stepId>.<prop> 表示某步骤结果的属性（点路径，不支持 bracket notation，无 .result 包装）。" +
+                "支持：点路径 / 字符串和数字字面量 / 布尔 null / 比较运算符 === !== > < >= <= / 逻辑运算符 && || ! / 括号。" +
+                "例: \"steps.validate.isValid === true\" 或 \"steps.score.value >= 80 && steps.flag.ok !== false\"",
+            },
+            ifTrue: {
+              type: "array",
+              items: { type: "string" },
+              description: "条件为真时执行的步骤 ID 列表，其余步骤跳过。",
+            },
+            ifFalse: {
+              type: "array",
+              items: { type: "string" },
+              description: "条件为假时执行的步骤 ID 列表，其余步骤跳过。",
+            },
+            // error handling
+            onError: {
+              type: "string",
+              enum: ["stop", "skip", "retry"],
+              description:
+                "步骤失败时策略：stop（默认，终止 workflow）/ skip（跳过，结果记为 null 继续）" +
+                "/ retry（按 retryCount 次数重试，耗尽后若仍失败则触发 stop）。",
+            },
+            retryCount: {
+              type: "integer",
+              description: "onError='retry' 时重试次数，默认 1（即最多执行 2 次）。",
+            },
+          },
+          required: ["id", "type"],
+        },
+      },
+    },
+    required: ["title", "steps"],
+  },
+};
+
+interface CreateWorkflowArgs {
+  title: string;
+  steps: WorkflowStep[];
+}
+
+export async function createWorkflowFunc(
+  args: CreateWorkflowArgs,
+  thunkApi: any
+): Promise<{ rawData: any; displayData?: string }> {
+  const { title, steps } = args;
+
+  if (!steps?.length) {
+    throw new Error("createWorkflow: steps 不能为空。");
+  }
+
+  const definition: WorkflowDefinition = { title, steps };
+
+  const { dispatch } = thunkApi;
+  const result = await dispatch(runWorkflow({ definition })).unwrap();
+
+  const completedCount = Object.values(result.results).filter(
+    (v) => v !== null && v !== undefined
+  ).length;
+
+  const displayData = result.success
+    ? `✅ **${title}** 完成，共执行 ${completedCount} 步`
+    : `❌ **${title}** 在步骤 \`${result.failedStep}\` 失败：${result.error}`;
+
+  return { rawData: result, displayData };
+}

package/ai/tools/deepseekOcrTool.ts

@@ -0,0 +1,34 @@
+import { ToolDefinition } from ".";
+import { callToolApi } from "./toolApiClient";
+
+export const deepseekOcrSchema = {
+    name: "deepseek_ocr",
+    description: "使用 deepseek-ai/DeepSeek-OCR 模型进行光学字符识别 (OCR)。擅长中英文混合文档、手写体及复杂版式的精准识别。",
+    parameters: {
+        type: "object",
+        properties: {
+            imageUrl: {
+                type: "string",
+                description: "要进行 OCR 的图片 URL、base64 编码的图片数据，或者内部文件 ID (如 'file-...')。",
+            },
+            prompt: {
+                type: "string",
+                description: "可选的提示词，用于指导模型如何提取信息（例如：'提取所有表格数据' 或 '识别图片中的所有文字'）。默认为 '识别图片中的所有文字'。",
+                default: "识别图片中的所有文字"
+            }
+        },
+        required: ["imageUrl"],
+    },
+};
+
+export const deepseekOcrFunc: ToolDefinition["executor"] = async (input: any, thunkApi) => {
+    const { imageUrl, prompt = "识别图片中的所有文字" } = input;
+
+    const data = await callToolApi(thunkApi, "/api/deepseek-ocr", { imageUrl, prompt }, { withAuth: true });
+
+    return {
+        summary: "OCR processing completed",
+        text: data.choices?.[0]?.message?.content || "No text detected",
+        rawData: data
+    };
+};

package/ai/tools/delayTool.ts

@@ -0,0 +1,31 @@
+// ai/tools/delayTool.ts
+
+export const delayFunctionSchema = {
+  name: "delay",
+  description:
+    "让计划暂停一小段时间（毫秒），用于节流批量操作（例如连续下载多个文件）。",
+  parameters: {
+    type: "object",
+    properties: {
+      ms: {
+        type: "integer",
+        description: "需要等待的时间（毫秒），建议 200~1000 之间。",
+      },
+    },
+    required: ["ms"],
+  },
+};
+
+export async function delayFunc(
+  args: { ms: number },
+  _thunkApi: any
+): Promise<{ rawData: object; displayData: string }> {
+  const ms = typeof args.ms === "number" && args.ms > 0 ? args.ms : 200;
+
+  await new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+  const rawData = { success: true, ms };
+  const displayData = `已等待 ${ms} 毫秒，继续执行后续步骤。`;
+
+  return { rawData, displayData };
+}

package/ai/tools/deleteSpacesTool.ts

@@ -0,0 +1,325 @@
+import { selectUserId } from "auth/authSlice";
+import { createSpaceKey } from "create/space/spaceKeys";
+import { deleteSpace, selectAllMemberSpaces } from "create/space/spaceSlice";
+import { read } from "database/dbSlice";
+import { getRuntimeServerContext } from "database/runtimeServerContext";
+
+import {
+  buildDeleteSpacesPreview,
+  filterSpaceDeletionCandidates,
+  resolveConfirmedSpaceDeletionTargets,
+  type DeleteSpacesMatchMode,
+  type SpaceDeletionPreview,
+  type SpaceMembershipLike,
+  type SpaceRecordLike,
+} from "./deleteSpacesToolModel";
+
+export interface DeleteSpacesToolArgs {
+  query: string;
+  matchMode?: DeleteSpacesMatchMode;
+  confirmedSpaceIds?: string[];
+}
+
+interface DeleteSpacesToolDeps {
+  selectCurrentUserId: (state: any) => string | undefined;
+  selectMemberSpaces: (state: any) => SpaceMembershipLike[];
+  readSpaceRecord: (thunkApi: any, spaceId: string) => Promise<SpaceRecordLike | null>;
+  selectDeleteServers: (state: any) => string[];
+  deleteServerKey: (
+    thunkApi: any,
+    server: string,
+    dbKey: string
+  ) => Promise<{ ok: boolean; status: number; detail: string }>;
+  deleteOwnedSpace: (
+    thunkApi: any,
+    input: { spaceId: string; strategy: "delete-space-only" }
+  ) => Promise<void>;
+}
+
+export const deleteSpacesFunctionSchema = {
+  name: "deleteSpaces",
+  description: [
+    "按名称或 ID 查找并删除当前用户拥有的 Space。",
+    "这是危险操作：第一次调用会返回待删除列表并等待用户确认；确认后才执行删除。",
+    "默认只删除 Space 壳和成员关系，不删除其中挂载的 doc/dialog/file 内容。",
+    "非 owner 的 Space 会被跳过，不会删除。",
+  ].join("\n"),
+  parameters: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description:
+          "要删除的 Space 筛选词，例如 rn_owner_verify_0504，或配合 matchMode=spaceId 传入 space id。",
+      },
+      matchMode: {
+        type: "string",
+        enum: ["prefix", "exact", "contains", "spaceId"],
+        description:
+          "匹配方式。prefix=名称前缀，exact=名称完全匹配，contains=名称包含，spaceId=按 Space ID 匹配。默认 prefix。",
+        default: "prefix",
+      },
+      confirmedSpaceIds: {
+        type: "array",
+        items: { type: "string" },
+        description:
+          "可选：确认阶段要删除的 Space ID 列表。不传时，用户点击确认会删除预览列表中的全部可删除项。",
+      },
+    },
+    required: ["query"],
+  },
+};
+
+const defaultDeps: DeleteSpacesToolDeps = {
+  selectCurrentUserId: selectUserId,
+  selectMemberSpaces: (state) => selectAllMemberSpaces(state) as SpaceMembershipLike[],
+  readSpaceRecord: async (thunkApi, spaceId) => {
+    try {
+      const record = await thunkApi.dispatch(
+        read({ dbKey: createSpaceKey.space(spaceId), waitRemote: true } as any)
+      ).unwrap();
+      return record ?? null;
+    } catch {
+      return null;
+    }
+  },
+  selectDeleteServers: (state) => {
+    const { currentServer, remoteServers } = getRuntimeServerContext(state);
+    return remoteServers.length > 0
+      ? remoteServers
+      : currentServer
+        ? [currentServer]
+        : [];
+  },
+  deleteServerKey: async (thunkApi, server, dbKey) => {
+    const state = thunkApi.getState();
+    const token = state?.auth?.currentToken;
+    if (!server) {
+      return { ok: false, status: 0, detail: "missing server" };
+    }
+    if (!token) {
+      return { ok: false, status: 401, detail: "missing auth token" };
+    }
+
+    const res = await fetch(
+      `${server.replace(/\/+$/, "")}/api/v1/db/delete/${encodeURIComponent(dbKey)}`,
+      {
+        method: "DELETE",
+        headers: { Authorization: `Bearer ${token}` },
+      }
+    );
+    return {
+      ok: res.ok,
+      status: res.status,
+      detail: await res.text().catch(() => ""),
+    };
+  },
+  deleteOwnedSpace: async (thunkApi, input) => {
+    await thunkApi.dispatch(deleteSpace(input as any)).unwrap();
+  },
+};
+
+const readSpaceRecordsById = async (
+  thunkApi: any,
+  memberships: SpaceMembershipLike[],
+  deps: DeleteSpacesToolDeps
+) => {
+  const recordsById: Record<string, SpaceRecordLike | null> = {};
+
+  for (const membership of memberships) {
+    const spaceId = String(membership.spaceId ?? "").replace(/^space-/, "");
+    if (!spaceId) continue;
+    recordsById[spaceId] = await deps.readSpaceRecord(thunkApi, spaceId);
+  }
+
+  return recordsById;
+};
+
+const loadDeletionContext = async (
+  args: DeleteSpacesToolArgs,
+  thunkApi: any,
+  deps: DeleteSpacesToolDeps
+): Promise<{
+  currentUserId: string;
+  preview: SpaceDeletionPreview;
+  spaceRecordsById: Record<string, SpaceRecordLike | null>;
+  deleteServers: string[];
+}> => {
+  const state = thunkApi.getState();
+  const currentUserId = deps.selectCurrentUserId(state);
+  if (!currentUserId) {
+    throw new Error("deleteSpaces 需要当前登录用户。");
+  }
+
+  const memberships = deps.selectMemberSpaces(state);
+  const deleteServers = deps.selectDeleteServers(state);
+  const candidates = filterSpaceDeletionCandidates(memberships, {
+    query: args.query,
+    matchMode: args.matchMode,
+  });
+  const spaceRecordsById = await readSpaceRecordsById(thunkApi, candidates, deps);
+
+  const preview = buildDeleteSpacesPreview({
+    currentUserId,
+    candidates,
+    spaceRecordsById,
+  });
+
+  return { currentUserId, preview, spaceRecordsById, deleteServers };
+};
+
+const loadPreview = async (
+  args: DeleteSpacesToolArgs,
+  thunkApi: any,
+  deps: DeleteSpacesToolDeps
+): Promise<SpaceDeletionPreview> => {
+  const { preview } = await loadDeletionContext(args, thunkApi, deps);
+  return preview;
+};
+
+const spaceMemberKeysForDelete = (
+  currentUserId: string,
+  spaceId: string,
+  record: SpaceRecordLike
+) => {
+  const memberIds = new Set<string>([currentUserId]);
+  if (Array.isArray(record.members)) {
+    for (const memberId of record.members) {
+      if (typeof memberId === "string" && memberId.trim()) {
+        memberIds.add(memberId.trim());
+      }
+    }
+  } else if (record.members && typeof record.members === "object") {
+    for (const memberId of Object.keys(record.members)) {
+      if (memberId.trim()) memberIds.add(memberId.trim());
+    }
+  }
+  return Array.from(memberIds).map((memberId) =>
+    createSpaceKey.member(memberId, spaceId)
+  );
+};
+
+const formatPreview = (preview: SpaceDeletionPreview) => {
+  if (preview.deletable.length === 0 && preview.skipped.length === 0) {
+    return "没有找到匹配的 Space。";
+  }
+
+  const lines = [
+    `找到 ${preview.deletable.length} 个可删除 Space，${preview.skipped.length} 个跳过。`,
+    "",
+  ];
+
+  if (preview.deletable.length > 0) {
+    lines.push("将删除这些 Space 壳和成员关系，不删除其中 doc/dialog/file：");
+    for (const item of preview.deletable) {
+      lines.push(
+        `- ${item.name} (${item.spaceId})，成员 ${item.memberCount}，内容 ${item.contentCount}`
+      );
+    }
+    lines.push("");
+    lines.push("需要确认后才会删除。");
+  }
+
+  if (preview.skipped.length > 0) {
+    lines.push("跳过：");
+    for (const item of preview.skipped) {
+      const owner = item.ownerId ? `，owner=${item.ownerId}` : "";
+      lines.push(`- ${item.name || item.spaceId} (${item.spaceId})：${item.reason}${owner}`);
+    }
+  }
+
+  return lines.join("\n");
+};
+
+export function createDeleteSpacesToolHandlers(deps: DeleteSpacesToolDeps) {
+  return {
+    preview: async (args: DeleteSpacesToolArgs, thunkApi: any) => {
+      const preview = await loadPreview(args, thunkApi, deps);
+      return {
+        rawData: preview,
+        displayData: formatPreview(preview),
+      };
+    },
+    execute: async (args: DeleteSpacesToolArgs, thunkApi: any) => {
+      const { currentUserId, preview, spaceRecordsById, deleteServers } =
+        await loadDeletionContext(args, thunkApi, deps);
+      const confirmedIds =
+        Array.isArray(args.confirmedSpaceIds) && args.confirmedSpaceIds.length > 0
+          ? args.confirmedSpaceIds
+          : preview.deletable.map((item) => item.spaceId);
+      const { targets, missingConfirmedSpaceIds } =
+        resolveConfirmedSpaceDeletionTargets(preview, confirmedIds);
+
+      const deletedSpaceIds: string[] = [];
+      const deletedKeys: string[] = [];
+      const deletedRecords: Array<{ server: string; dbKey: string }> = [];
+      const failures: Array<{ server?: string; dbKey: string; status: number; detail: string }> = [];
+      for (const target of targets) {
+        const record = spaceRecordsById[target.spaceId];
+        if (!record) {
+          failures.push({
+            dbKey: createSpaceKey.space(target.spaceId),
+            status: 404,
+            detail: "space record disappeared before deletion",
+          });
+          continue;
+        }
+        if (deleteServers.length === 0) {
+          failures.push({
+            dbKey: createSpaceKey.space(target.spaceId),
+            status: 0,
+            detail: "no delete server configured",
+          });
+          continue;
+        }
+        const keys = [
+          ...spaceMemberKeysForDelete(currentUserId, target.spaceId, record),
+          createSpaceKey.space(target.spaceId),
+        ];
+        let targetFailed = false;
+        for (const server of deleteServers) {
+          for (const dbKey of keys) {
+            const result = await deps.deleteServerKey(thunkApi, server, dbKey);
+            if (!result.ok) {
+              targetFailed = true;
+              failures.push({ server, dbKey, status: result.status, detail: result.detail });
+            } else {
+              deletedKeys.push(dbKey);
+              deletedRecords.push({ server, dbKey });
+            }
+          }
+        }
+        if (targetFailed) continue;
+
+        await deps.deleteOwnedSpace(thunkApi, {
+          spaceId: target.spaceId,
+          strategy: "delete-space-only",
+        });
+        deletedSpaceIds.push(target.spaceId);
+      }
+
+      const displayData =
+        deletedSpaceIds.length > 0
+          ? `已删除 ${deletedSpaceIds.length} 个 Space：${deletedSpaceIds.join(", ")}。内容记录未被删除。`
+          : "没有删除任何 Space。";
+
+      return {
+        rawData: {
+          deletedSpaceIds,
+          deletedKeys,
+          deletedRecords,
+          deleteServers,
+          missingConfirmedSpaceIds,
+          skipped: preview.skipped,
+          failures,
+        },
+        displayData,
+      };
+    },
+  };
+}
+
+const defaultHandlers = createDeleteSpacesToolHandlers(defaultDeps);
+
+export const deleteSpacesPreviewFunc = defaultHandlers.preview;
+export const deleteSpacesFunc = defaultHandlers.execute;