nolo-cli 0.1.44 → 0.1.46

package/ai/tools/toolResultError.ts

@@ -1,42 +0,0 @@
-export class ToolResultError extends Error {
-  code?: string;
-  rawData?: unknown;
-  displayData?: string;
-  retryable?: boolean;
-
-  constructor(
-    message: string,
-    options?: {
-      code?: string;
-      rawData?: unknown;
-      displayData?: string;
-      retryable?: boolean;
-    }
-  ) {
-    super(message);
-    this.name = "ToolResultError";
-    this.code = options?.code;
-    this.rawData = options?.rawData;
-    this.displayData = options?.displayData;
-    this.retryable = options?.retryable;
-  }
-}
-
-export const getToolResultErrorData = (error: unknown) => {
-  if (!error || typeof error !== "object") return null;
-  const candidate = error as {
-    rawData?: unknown;
-    displayData?: string;
-    code?: string;
-    retryable?: boolean;
-    message?: string;
-  };
-  return {
-    rawData: candidate.rawData,
-    displayData: candidate.displayData,
-    code: candidate.code,
-    retryable: candidate.retryable,
-    message: candidate.message,
-  };
-};
-

package/ai/tools/toolRunSlice.ts

@@ -1,303 +0,0 @@
-// File: ai/tools/toolRunSlice.ts
-import {
-  createSlice,
-  createEntityAdapter,
-  EntityState,
-  PayloadAction,
-  createAsyncThunk,
-  createSelector,
-} from "@reduxjs/toolkit";
-import type { RootState } from "../../app/store";
-import type { ToolBehavior, ToolInteraction } from ".";
-import { getToolResultErrorData } from "./toolResultError";
-
-export type ToolRunStatus = "pending" | "running" | "succeeded" | "failed";
-export type ToolRunStepStatus = ToolRunStatus;
-
-export interface ToolRunStep {
-  id: string;
-  label: string;
-  status: ToolRunStepStatus;
-  detail?: string;
-}
-
-export interface ToolRun {
-  id: string;
-  messageId: string; // 这次工具调用属于哪条消息或步骤消息
-  toolName: string;
-  behavior?: ToolBehavior;
-  inputSummary?: string;
-  outputSummary?: string;
-  steps?: ToolRunStep[];
-  status: ToolRunStatus;
-  error?: string;
-  startedAt: number;
-  finishedAt?: number;
-
-  // 交互模式（从 ToolDefinition 抄过来）
-  interaction?: ToolInteraction;
-
-  // 保存本次调用的完整参数，后续确认或重放时会用到
-  input?: any;
-}
-
-const toolRunAdapter = createEntityAdapter<ToolRun>({
-  selectId: (run) => run.id,
-  sortComparer: (a, b) => a.startedAt - b.startedAt,
-});
-
-export interface ToolRunSliceState {
-  runs: EntityState<ToolRun>;
-}
-
-const initialState: ToolRunSliceState = {
-  runs: toolRunAdapter.getInitialState(),
-};
-
-export const createToolRunId = () =>
-  `toolrun_${Date.now().toString(36)}_${Math.random()
-    .toString(36)
-    .slice(2, 8)}`;
-
-const toolRunSlice = createSlice({
-  name: "toolRun",
-  initialState,
-  reducers: {
-    toolRunStarted: (
-      state,
-      action: PayloadAction<{
-        id: string;
-        messageId: string;
-        toolName: string;
-        behavior?: ToolBehavior;
-        inputSummary?: string;
-        startedAt?: number;
-        interaction?: ToolInteraction;
-        input?: any;
-      }>
-    ) => {
-      const {
-        id,
-        messageId,
-        toolName,
-        behavior,
-        inputSummary,
-        startedAt,
-        interaction,
-        input,
-      } = action.payload;
-
-      // 每次开始（包括重试）都清空上一次的 error / 输出 / 结束时间
-      toolRunAdapter.upsertOne(state.runs, {
-        id,
-        messageId,
-        toolName,
-        behavior,
-        inputSummary,
-        status: "running",
-        startedAt: startedAt ?? Date.now(),
-        interaction,
-        input,
-          error: undefined,
-          finishedAt: undefined,
-          outputSummary: undefined,
-          steps: undefined,
-        });
-    },
-
-    // 把某个 ToolRun 状态设为 pending（用于“预览但未执行”的阶段）
-    toolRunSetPending: (
-      state,
-      action: PayloadAction<{
-        id: string;
-      }>
-    ) => {
-      const { id } = action.payload;
-      toolRunAdapter.updateOne(state.runs, {
-        id,
-        changes: {
-          status: "pending",
-        },
-      });
-    },
-
-    toolRunSucceeded: (
-      state,
-      action: PayloadAction<{
-        id: string;
-        outputSummary?: string;
-        steps?: ToolRunStep[];
-        finishedAt?: number;
-      }>
-    ) => {
-      const { id, outputSummary, steps, finishedAt } = action.payload;
-      toolRunAdapter.updateOne(state.runs, {
-        id,
-        changes: {
-          status: "succeeded",
-          outputSummary,
-          ...(steps === undefined ? {} : { steps }),
-          finishedAt: finishedAt ?? Date.now(),
-        },
-      });
-    },
-    toolRunUpdated: (
-      state,
-      action: PayloadAction<{
-        id: string;
-        outputSummary?: string;
-        steps?: ToolRunStep[];
-      }>
-    ) => {
-      const { id, outputSummary, steps } = action.payload;
-      toolRunAdapter.updateOne(state.runs, {
-        id,
-        changes: {
-          ...(outputSummary === undefined ? {} : { outputSummary }),
-          ...(steps === undefined ? {} : { steps }),
-        },
-      });
-    },
-    toolRunFailed: (
-      state,
-      action: PayloadAction<{
-        id: string;
-        error: string;
-        outputSummary?: string;
-        steps?: ToolRunStep[];
-        finishedAt?: number;
-      }>
-    ) => {
-      const { id, error, outputSummary, steps, finishedAt } = action.payload;
-      toolRunAdapter.updateOne(state.runs, {
-        id,
-        changes: {
-          status: "failed",
-          error,
-          ...(outputSummary === undefined ? {} : { outputSummary }),
-          ...(steps === undefined ? {} : { steps }),
-          finishedAt: finishedAt ?? Date.now(),
-        },
-      });
-    },
-    resetToolRunsForMessage: (
-      state,
-      action: PayloadAction<{ messageId: string }>
-    ) => {
-      const { messageId } = action.payload;
-      const all = state.runs.ids as string[];
-      const toRemove = all.filter((id) => {
-        const run = state.runs.entities[id];
-        return run?.messageId === messageId;
-      });
-      toolRunAdapter.removeMany(state.runs, toRemove);
-    },
-    resetAllToolRuns: (state) => {
-      toolRunAdapter.removeAll(state.runs);
-    },
-  },
-});
-
-export const {
-  toolRunStarted,
-  toolRunSetPending,
-  toolRunSucceeded,
-  toolRunUpdated,
-  toolRunFailed,
-  resetToolRunsForMessage,
-  resetAllToolRuns,
-} = toolRunSlice.actions;
-
-export default toolRunSlice.reducer;
-
-// ===== selectors =====
-const selectors = toolRunAdapter.getSelectors<RootState>(
-  (state) => state.toolRun.runs
-);
-
-export const selectAllToolRuns = selectors.selectAll;
-
-export const selectToolRunsByMessageId = createSelector(
-  [selectors.selectAll, (_state: RootState, messageId: string) => messageId],
-  (runs, messageId) => runs.filter((run) => run.messageId === messageId)
-);
-
-// 按 id 精确获取（导出给组件用）
-export const selectToolRunById = (
-  state: RootState,
-  id: string
-): ToolRun | undefined => selectors.selectById(state, id);
-
-// ===== 通用执行 thunk：基于已有 ToolRun.input 再次执行工具（可作为重试） =====
-export const executeToolRun = createAsyncThunk(
-  "toolRun/executeToolRun",
-  async ({ id }: { id: string }, thunkApi) => {
-    const state = thunkApi.getState() as RootState;
-    const run = selectToolRunById(state, id);
-
-    if (!run) {
-      throw new Error(`ToolRun not found: ${id}`);
-    }
-    if (!run.input) {
-      throw new Error(`ToolRun ${id} has no input to execute with.`);
-    }
-
-    const { findToolExecutor } = await import(".");
-    const { executor } = findToolExecutor(run.toolName);
-
-    // 点击按钮时，把状态重新置为 running，方便 UI 显示“执行中…”；这同时也清掉旧错误
-    thunkApi.dispatch(
-      toolRunStarted({
-        id: run.id,
-        messageId: run.messageId,
-        toolName: run.toolName,
-        behavior: run.behavior,
-        inputSummary: run.inputSummary,
-        startedAt: Date.now(),
-        interaction: run.interaction,
-        input: run.input,
-      })
-    );
-
-    try {
-      const result = await executor(run.input, thunkApi, {
-        parentMessageId: run.messageId,
-      });
-
-      thunkApi.dispatch(
-        toolRunSucceeded({
-          id: run.id,
-          outputSummary: result?.displayData || "",
-        })
-      );
-
-      if (run.toolName === "deleteSpaces") {
-        const latestState = thunkApi.getState() as RootState;
-        const userId = latestState.auth?.currentUser?.userId;
-        if (userId) {
-          const { fetchUserSpaceMemberships } = await import("../../create/space/spaceSlice");
-          await thunkApi.dispatch(fetchUserSpaceMemberships(userId) as any);
-        }
-      }
-
-      return {
-        id: run.id,
-        rawData: result?.rawData,
-        displayData: result?.displayData,
-      };
-    } catch (e: any) {
-      const msg = e?.message || String(e);
-      const structured = getToolResultErrorData(e);
-      thunkApi.dispatch(
-        toolRunFailed({
-          id: run.id,
-          error: msg,
-          outputSummary:
-            (typeof structured?.displayData === "string" && structured.displayData.trim()) ||
-            undefined,
-        })
-      );
-      throw e;
-    }
-  }
-);

package/ai/tools/toolSchemaCompatibility.ts

@@ -1,53 +0,0 @@
-const COMPOSITION_KEYS = ["anyOf", "oneOf", "allOf"] as const;
-
-const LIMITED_JSON_SCHEMA_PROVIDERS = new Set([
-  "fireworks",
-]);
-
-const isPlainObject = (value: unknown): value is Record<string, any> =>
-  !!value && typeof value === "object" && !Array.isArray(value);
-
-const sanitizeSchemaNode = (value: unknown): unknown => {
-  if (Array.isArray(value)) {
-    return value.map((item) => sanitizeSchemaNode(item));
-  }
-
-  if (!isPlainObject(value)) {
-    return value;
-  }
-
-  const next: Record<string, any> = {};
-  for (const [key, child] of Object.entries(value)) {
-    if (COMPOSITION_KEYS.includes(key as (typeof COMPOSITION_KEYS)[number])) {
-      continue;
-    }
-    next[key] = sanitizeSchemaNode(child);
-  }
-  return next;
-};
-
-const shouldSanitizeProviderSchema = (provider: string | undefined): boolean =>
-  typeof provider === "string" &&
-  LIMITED_JSON_SCHEMA_PROVIDERS.has(provider.trim().toLowerCase());
-
-export const sanitizeToolForProvider = (
-  tool: any,
-  provider: string | undefined
-) => {
-  if (!shouldSanitizeProviderSchema(provider)) {
-    return tool;
-  }
-
-  const parameters = tool?.function?.parameters;
-  if (!isPlainObject(parameters)) {
-    return tool;
-  }
-
-  return {
-    ...tool,
-    function: {
-      ...tool.function,
-      parameters: sanitizeSchemaNode(parameters),
-    },
-  };
-};

package/ai/tools/uiAskChoiceTool.ts

@@ -1,104 +0,0 @@
-// 文件: ai/tools/uiAskChoiceTool.ts
-
-export const uiAskChoiceFunctionSchema = {
-    name: "ui_ask_choice",
-    description: [
-        "当你需要让用户在几个互斥的选项之间做选择时，使用本工具。",
-        "",
-        "这是一个通用的“出选项”工具，适用于多种场景，例如：",
-        "1）用户的需求比较宽泛或模糊，你可以给出 2～5 个不同方向的候选方案，让 TA 先选一个方向；",
-        "2）一个计划 / 流程到了分支节点，需要用户决定下一步做什么；",
-        "3）你想为用户设计一组练习题、测试题或问卷题（如出题练习、人格测试等单选题）；",
-        "4）在新阶段/新会话中，根据系统提示或用户画像，给出若干“接下来可以尝试的事情”（例如功能导航或使用技巧）。",
-        "",
-        "使用建议：",
-        "- 当你判断“先给出 2～5 个明确选项能显著帮用户理清下一步要做什么”时，可以主动调用本工具；",
-        "- 如果用户的目标已经非常具体、清晰，并且你可以直接给出高质量答案，优先直接回答，而不是再弹出选择菜单；",
-        "- 默认情况下，不要在完全没有有效上下文的场景（例如用户只说“你好”）立刻调用本工具，除非系统提示中已经明确要求你在新会话开头用它来生成欢迎菜单或功能导航；",
-        "- 请把给用户看的问题写在 question 字段中，不要在同一轮 assistant 普通文本里重复这句话；",
-        "- 每个选项的 userMessage 建议写成完整的一句话，方便后续理解上下文；如果留空，将自动使用 label 作为 userMessage。",
-        "",
-        "在代码协作场景下的推荐用法：",
-        "- 如果你已经在本轮 assistant 的 content 中给出了分析、说明或多个备选方案，可以在同一轮消息的结尾调用本工具，请用户选择“是否根据上述方案开始实际修改代码”或“优先执行哪一个方案/步骤”。",
-        "- 在这种情况下，question 字段通常是一个简短的问题（例如：“接下来你希望我按哪个方案来具体修改代码？”），而详细的解释和方案描述放在 content 中。",
-        "- 如果当前对话只需要一个简单的选择，而不需要额外解释，你也可以不输出额外的 content，而只调用本工具，由 question 字段直接向用户提问。"
-    ].join("\n"),
-    parameters: {
-        type: "object",
-        properties: {
-            question: {
-                type: "string",
-                description:
-                    "展示给用户的问题文案，用一句话说明要做什么选择。例如：“接下来你更希望我帮你做哪件事？”。不要在同一轮 assistant 普通文本里重复这句话。"
-            },
-            choices: {
-                type: "array",
-                description:
-                    "备选项列表。每个选项会渲染成一个按钮，供用户点击选择。",
-                items: {
-                    type: "object",
-                    properties: {
-                        id: {
-                            type: "string",
-                            description:
-                                "选项内部标识（用于后续逻辑或调试，不会直接展示给用户）。"
-                        },
-                        label: {
-                            type: "string",
-                            description:
-                                "显示给用户看的按钮文字。例如：“生成本周周报”。"
-                        },
-                        userMessage: {
-                            type: "string",
-                            description: [
-                                "用户点击此选项后，你希望作为下一条 user 消息发送给模型的自然语言内容。",
-                                "建议写成完整的一句话，例如：“帮我生成一份本周的工作周报”。",
-                                "如果留空，将使用 label 作为 userMessage。"
-                            ].join(" ")
-                        }
-                    },
-                    required: ["id", "label"]
-                }
-            },
-            blocking: {
-                type: "boolean",
-                description: [
-                    "是否需要等待用户选择之后，再继续当前流程（例如 Plan）。",
-                    "默认 true：即发出问题后，等待用户点击某个选项再继续。"
-                ].join(" "),
-                default: true
-            }
-        },
-        required: ["question", "choices"]
-    }
-};
-export async function uiAskChoiceFunc(
-    args: any,
-    _thunkApi: AppThunkApi
-): Promise<{
-    rawData: {
-        type: "ui_ask_choice";
-        question: string;
-        choices: any[];
-        blocking: boolean;
-    };
-    displayData: string;
-}> {
-    const question = String(args?.question ?? "").trim();
-    const choices = Array.isArray(args?.choices) ? args.choices : [];
-    const blocking = args?.blocking !== false;
-
-    if (!question || choices.length === 0) {
-        throw new Error("ui_ask_choice 需要 question 和至少一个 choice。");
-    }
-
-    return {
-        rawData: {
-            type: "ui_ask_choice",
-            question,
-            choices,
-            blocking,
-        },
-        displayData: question,
-    };
-}

package/ai/tools/updateContentTitleTool.ts

@@ -1,84 +0,0 @@
-import { updateContentTitle } from "../../create/space/spaceSlice"; // 假设有一个对应的 action
-import { selectCurrentSpaceId } from "../../create/space/spaceSlice";
-
-// Tool definition
-export const updateContentTitleTool = {
-  type: "function",
-  function: {
-    name: "update_content_title",
-    description: "更新当前空间中某个内容的标题",
-    parameters: {
-      type: "object",
-      properties: {
-        contentId: {
-          type: "string",
-          description: "要更新的内容ID",
-        },
-        title: {
-          type: "string",
-          description: "新的页面标题",
-        },
-      },
-      required: ["contentId", "title"],
-    },
-  },
-};
-
-/**
- * 更新当前空间中某个内容标题的实现
- * @param args 工具参数 { contentId: string, title: string }
- * @param thunkApi Redux Thunk API { dispatch, getState }
- * @returns Promise<{ success: true, id: string, title: string } | never> - 成功时返回包含 id 和新标题的对象，失败时抛出错误
- */
-export const updateContentTitleFunc = async (
-  args: { contentId: string; title: string },
-  thunkApi: any /* Replace 'any' with your actual ThunkApi type */
-) => {
-  const { dispatch, getState } = thunkApi;
-  const state = getState(); // Assuming getState returns RootState
-  const spaceId = selectCurrentSpaceId(state); // 获取当前空间ID
-  const { contentId, title } = args;
-
-  console.log(
-    `[updateContentTitleFunc] spaceId: ${spaceId}, contentId: ${contentId}, title: ${title}`
-  );
-
-  if (!spaceId) {
-    console.error("[updateContentTitleFunc] 更新标题失败：未找到当前空间ID");
-    throw new Error("无法更新标题，因为当前空间未设定。");
-  }
-
-  if (!contentId) {
-    console.error("[updateContentTitleFunc] 更新标题失败：未提供内容ID");
-    throw new Error("无法更新标题，因为内容ID未提供。");
-  }
-
-  try {
-    // 调用 updateContentTitle action (直接从 spaceSlice 中导入)
-    console.log(
-      "[updateContentTitleFunc] Dispatching updateContentTitle action..."
-    );
-    const updatedContentId = await dispatch(
-      updateContentTitle({
-        spaceId,
-        contentId,
-        title: title.trim(), // 确保标题去除首尾空格
-      })
-    ).unwrap(); // unwrap 会在失败时抛出错误
-
-    console.log(
-      `[updateContentTitleFunc] Content title updated successfully. contentId: ${updatedContentId}`
-    );
-
-    // 返回结构化数据
-    return {
-      success: true, // 明确表示成功
-      id: updatedContentId, // 返回内容ID
-      title: title, // 返回使用的新标题
-    };
-  } catch (error: any) {
-    console.error("[updateContentTitleFunc] 更新标题失败:", error);
-    const errorMessage = error?.message || JSON.stringify(error) || "未知错误";
-    throw new Error(`更新标题时出错: ${errorMessage}`);
-  }
-};

package/ai/tools/updateDocTool.ts

@@ -1,105 +0,0 @@
-// ai/tools/updateDocTool.ts
-
-import { readAction } from "../../database/actions/read";
-import { write } from "../../database/dbSlice";
-import { markdownToSlate } from "../../create/editor/transforms/markdownToSlate";
-import { slateToRenderMarkdown } from "../../create/editor/transforms/slateToRenderMarkdown";
-import { extractMentionsFromSlate } from "../../create/editor/utils/slateUtils";
-import type { PageData } from "../../render/page/types";
-import { parseSkillDocProtocol } from "../skills/skillDocProtocol";
-
-export const updateDocFunctionSchema = {
-    name: "updateDoc",
-    description: "更新指定页面/文档的内容。支持全量覆盖或在末尾追加内容。",
-    parameters: {
-        type: "object",
-        properties: {
-            id: {
-                type: "string",
-                description: "页面/文档的 dbKey，通常以 page- 开头，例如 page-user-01ABC...",
-            },
-            content: {
-                type: "string",
-                description: "要更新或追加的 Markdown 格式内容。",
-            },
-            mode: {
-                type: "string",
-                enum: ["replace", "append"],
-                description: "更新模式：'replace' 表示全量覆盖（默认），'append' 表示在页面末尾追加。",
-                default: "replace",
-            },
-        },
-        required: ["id", "content"],
-    },
-};
-
-/**
- * [Executor] 'updateDoc' 工具的执行函数。
- */
-export async function updateDocFunc(
-    args: { id: string; content: string; mode?: "replace" | "append" },
-    thunkApi: any
-): Promise<{ rawData: any; displayData: string }> {
-    const { id, content, mode = "replace" } = args;
-    const { dispatch } = thunkApi;
-
-    if (!id.toLowerCase().startsWith("page-")) {
-        throw new Error("updateDoc 工具仅支持更新页面 (page-xxx)。");
-    }
-    try {
-        // 1. 读取原页面数据
-        const originalData = (await readAction({ dbKey: id }, thunkApi)) as PageData;
-        if (!originalData) {
-            throw new Error(`未找到 ID 为 ${id} 的页面。`);
-        }
-
-        const currentMarkdown =
-            typeof originalData.content === "string" && originalData.content.trim()
-                ? originalData.content
-                : slateToRenderMarkdown(
-                    Array.isArray(originalData.slateData) ? originalData.slateData : [],
-                );
-
-        const mergedMarkdown = mode === "append"
-            ? [currentMarkdown, content].filter(Boolean).join("\n\n")
-            : content;
-        const parsedProtocol = parseSkillDocProtocol(
-            mergedMarkdown,
-            originalData.meta,
-            originalData.tools,
-        );
-        const finalSlateData = markdownToSlate(parsedProtocol.content);
-        const tools = extractMentionsFromSlate(finalSlateData as any);
-
-        // 3. 构造更新后的数据
-        const updatedPageData: PageData = {
-            ...originalData,
-            slateData: finalSlateData,
-            content: parsedProtocol.content,
-            tools,
-            ...(parsedProtocol.meta ? { meta: parsedProtocol.meta } : {}),
-            updated_at: new Date().toISOString(),
-        };
-
-        // 4. 写入数据库
-        // 4. 写入数据库
-        await (dispatch as any)(write({ data: updatedPageData, customKey: id })).unwrap();
-
-        const displayData = mode === "append"
-            ? `已成功在页面《${originalData.title}》末尾追加了内容。`
-            : `页面《${originalData.title}》的内容已成功更新。`;
-
-        return {
-            rawData: { success: true, id, title: originalData.title },
-            displayData,
-        };
-    } catch (error: any) {
-        console.error("执行 updateDoc 工具时出错:", error);
-        throw new Error(`更新页面失败：${error?.message || String(error)}`);
-    }
-}
-// ── 向后兼容别名（旧名 updatePage / update_page）────────────────────────────
-/** @deprecated 使用 updateDocFunctionSchema */
-export const updatePageFunctionSchema = updateDocFunctionSchema;
-/** @deprecated 使用 updateDocFunc */
-export const updatePageFunc = updateDocFunc;