nolo-cli 0.1.39 → 0.1.41

package/ai/tools/toolApiClient.ts

@@ -0,0 +1,279 @@
+/**
+ * toolApiClient.ts
+ *
+ * 所有 AI tool 调用后端 API 的统一工具模块。
+ *
+ * 解决的问题：
+ * - 相对路径（如 "/api/xxx"）在 React Native 中无法解析。
+ * - 多个 tool 文件中重复定义相同的 getRequestConfig / buildRequestHeaders 等辅助函数。
+ *
+ * 使用方式：
+ *   const data = await callToolApi(thunkApi, "/api/exa-search", body);
+ *   const data = await callToolApi(thunkApi, "/api/apify-actor", body, { withAuth: true });
+ */
+
+import { extractCustomId } from "../../core/prefix";
+
+// ─────────────────────────────────────────────
+// 基础提取：从 Redux state 中获取服务器配置
+// ─────────────────────────────────────────────
+
+export interface RequestConfig {
+    currentServer: string;
+    token: string | null;
+}
+
+export interface ToolRequestContext extends RequestConfig {
+    baseUrl: string;
+}
+
+const MAIN_SERVER = "https://nolo.chat";
+
+const getIsDesktopApp = (): boolean =>
+    typeof window !== "undefined" && Boolean((window as any).__NOLO_DESKTOP__);
+
+const isLocalServerUrl = (value?: string | null): boolean => {
+    if (!value) return false;
+    try {
+        const hostname = new URL(value).hostname.toLowerCase();
+        return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
+    } catch {
+        return false;
+    }
+};
+
+const resolveDesktopSafeServer = (value?: string | null): string => {
+    if (!getIsDesktopApp()) return value || MAIN_SERVER;
+    return isLocalServerUrl(value) ? MAIN_SERVER : value || MAIN_SERVER;
+};
+
+const selectCurrentServerFromState = (state: any): string =>
+    resolveDesktopSafeServer(state?.settings?.currentServer);
+
+const selectCurrentTokenFromState = (state: any): string | null =>
+    typeof state?.auth?.currentToken === "string" ? state.auth.currentToken : null;
+
+const selectCurrentDialogKeyFromState = (state: any): string | null =>
+    typeof state?.dialog?.currentDialogKey === "string" ? state.dialog.currentDialogKey : null;
+
+export const resolveToolBaseUrl = (currentServer?: string | null): string => {
+    const _window = (globalThis as any).window;
+    if (!_window) return (currentServer || "").replace(/\/+$/, "");
+    const fallbackLocal = _window.location.origin;
+    if (!currentServer) return fallbackLocal;
+    return currentServer.replace(/\/+$/, "");
+};
+
+const DESKTOP_LOCAL_TOOL_PATHS = new Set([
+    "/api/exec-shell",
+    "/api/check-env",
+    "/api/read-file",
+    "/api/write-file",
+    "/api/apply-edit",
+    "/api/apply-line-edits",
+    "/api/code-search",
+    "/api/search-repo",
+    "/api/desktop/files/roots",
+    "/api/desktop/files/roots/request",
+    "/api/desktop/files/list",
+    "/api/desktop/files/read",
+    "/api/desktop/files/plan",
+    "/api/desktop/files/approve",
+    "/api/desktop/files/execute",
+    "/api/desktop/files/undo",
+    "/api/desktop/files/history",
+]);
+
+const getWindowOrigin = (): string | null => {
+    const _window = (globalThis as any).window;
+    const origin = _window?.location?.origin;
+    return typeof origin === "string" && origin ? origin.replace(/\/+$/, "") : null;
+};
+
+export const resolveToolApiBaseUrl = (
+    currentServer?: string | null,
+    path?: string
+): string => {
+    if (path && DESKTOP_LOCAL_TOOL_PATHS.has(path) && getIsDesktopApp()) {
+        const localOrigin = getWindowOrigin();
+        if (localOrigin) return localOrigin;
+    }
+    return resolveToolBaseUrl(currentServer);
+};
+
+export const getRequestConfig = (thunkApi: any): RequestConfig => {
+    const state = thunkApi.getState();
+    const currentServer = selectCurrentServerFromState(state);
+    const token = selectCurrentTokenFromState(state);
+    if (!currentServer) throw new Error("无法获取当前服务器地址。");
+    return { currentServer, token };
+};
+
+export const getToolBaseUrl = (thunkApi: any): string => {
+    const { currentServer } = getRequestConfig(thunkApi);
+    const baseUrl = resolveToolBaseUrl(currentServer);
+    if (!baseUrl) throw new Error("无法获取工具服务器地址。");
+    return baseUrl;
+};
+
+export const getToolRequestContext = (thunkApi: any): ToolRequestContext => {
+    const { currentServer, token } = getRequestConfig(thunkApi);
+    const baseUrl = resolveToolBaseUrl(currentServer);
+    if (!baseUrl) throw new Error("无法获取工具服务器地址。");
+    return {
+        currentServer,
+        token,
+        baseUrl,
+    };
+};
+
+// ─────────────────────────────────────────────
+// 统一 POST 请求入口
+// ─────────────────────────────────────────────
+
+export interface CallToolApiOptions {
+    /** 是否在请求头中附带 Authorization token，默认 false */
+    withAuth?: boolean;
+    /** 生产受控 devtool 路由需要知道是哪一个 agent 在调用。 */
+    agentKey?: string | null;
+}
+
+const maybeAttachDialogId = (thunkApi: any, body: object): object => {
+    if (!body || typeof body !== "object" || Array.isArray(body)) return body;
+    if ("dialogId" in body) return body;
+
+    const state = thunkApi.getState();
+    const currentDialogKey = selectCurrentDialogKeyFromState(state);
+    const dialogId = currentDialogKey ? extractCustomId(currentDialogKey) : null;
+    if (!dialogId) return body;
+
+    return {
+        ...body,
+        dialogId,
+    };
+};
+
+export class ToolApiError extends Error {
+    status?: number;
+    code?: string;
+    details?: unknown;
+
+    constructor(message: string, options?: { status?: number; code?: string; details?: unknown }) {
+        super(message);
+        this.name = "ToolApiError";
+        this.status = options?.status;
+        this.code = options?.code;
+        this.details = options?.details;
+    }
+}
+
+export const buildToolRequestHeaders = (
+    thunkApi: any,
+    options: CallToolApiOptions = {}
+): Record<string, string> => {
+    const { withAuth = false, agentKey } = options;
+    const { token } = getRequestConfig(thunkApi);
+    const headers: Record<string, string> = { "Content-Type": "application/json" };
+    if (withAuth && token) {
+        headers["Authorization"] = `Bearer ${token}`;
+    }
+    if (agentKey && typeof agentKey === "string" && agentKey.trim()) {
+        headers["X-Nolo-Agent-Key"] = agentKey.trim();
+    }
+    if (typeof window !== "undefined" && (window as any).__NOLO_DESKTOP__) {
+        headers["X-Nolo-Desktop-Tool"] = "1";
+    }
+    return headers;
+};
+
+const buildResponsePreview = (text: string): string =>
+    text
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 240);
+
+const looksLikeHtmlResponse = (text: string, contentType: string | null): boolean => {
+    if (contentType?.toLowerCase().includes("text/html")) return true;
+    const trimmed = text.trim().toLowerCase();
+    return trimmed.startsWith("<!doctype html") || trimmed.startsWith("<html");
+};
+
+/**
+ * 向本项目后端发起 POST 请求的统一封装。
+ * - 自动从 Redux state 中读取 currentServer，构建完整 URL（兼容 Web & RN）。
+ * - 自动处理错误响应，抛出包含状态码和错误信息的 Error。
+ *
+ * @param thunkApi  Redux Thunk API
+ * @param path      API 路径，如 "/api/exa-search"
+ * @param body      请求体对象
+ * @param options   选项：{ withAuth } 是否附带 token
+ * @returns         解析后的 JSON 数据
+ */
+export async function callToolApi<T = any>(
+    thunkApi: any,
+    path: string,
+    body: object,
+    options: CallToolApiOptions = {}
+): Promise<T> {
+    const { currentServer } = getRequestConfig(thunkApi);
+
+    const baseUrl = resolveToolApiBaseUrl(currentServer, path);
+    if (!baseUrl) throw new Error("无法获取工具服务器地址。");
+    const url = `${baseUrl}${path}`;
+    const headers = buildToolRequestHeaders(thunkApi, options);
+
+    const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(maybeAttachDialogId(thunkApi, body)),
+    });
+
+    const contentType = response.headers.get("content-type");
+    const responseText = await response.text();
+
+    if (!response.ok) {
+        let errorMessage = `API 请求失败，状态码: ${response.status}`;
+        let errorCode: string | undefined;
+        let errorDetails: unknown;
+        try {
+            const errorData = JSON.parse(responseText) as Record<string, any>;
+            const err = errorData?.error;
+            if (err) {
+                errorMessage += `: ${err.message ?? JSON.stringify(err)}`;
+                errorCode = typeof err.code === "string" ? err.code : undefined;
+                errorDetails = err.details;
+            }
+        } catch {
+            errorCode = looksLikeHtmlResponse(responseText, contentType)
+                ? "HTML_ERROR_RESPONSE"
+                : "NON_JSON_ERROR_RESPONSE";
+            errorDetails = {
+                contentType,
+                responsePreview: buildResponsePreview(responseText),
+            };
+            if (typeof (errorDetails as any).responsePreview === "string" && (errorDetails as any).responsePreview) {
+                errorMessage += `: ${(errorDetails as any).responsePreview}`;
+            }
+        }
+        throw new ToolApiError(errorMessage, {
+            status: response.status,
+            code: errorCode,
+            details: errorDetails,
+        });
+    }
+
+    try {
+        return JSON.parse(responseText) as T;
+    } catch {
+        throw new ToolApiError("服务端返回了无法解析的非 JSON 响应", {
+            status: response.status,
+            code: looksLikeHtmlResponse(responseText, contentType)
+                ? "HTML_RESPONSE"
+                : "INVALID_JSON_RESPONSE",
+            details: {
+                contentType,
+                responsePreview: buildResponsePreview(responseText),
+            },
+        });
+    }
+}

package/ai/tools/toolResultError.ts

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

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

@@ -0,0 +1,53 @@
+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),
+    },
+  };
+};