nolo-cli 0.1.13 → 0.1.15

package/ai/chat/accumulateToolCallChunks.ts

@@ -0,0 +1,95 @@
+/**
+ * 处理流式工具调用数据块，将其累积到数组中。
+ * 关键点：
+ * - 支持按 index 拼接，也支持同一 id、无 index 的分片追加（OpenAI 风格常见）
+ * - 字符串分片追加；对象分片直接覆盖（最后一段为准）
+ * - 不再过滤特殊标记，保持原样透传
+ */
+
+export interface ToolCallChunk {
+  index?: number;
+  id?: string;
+  type?: "function";
+  function?: {
+    name?: string;
+    arguments?: string;
+  };
+}
+
+export interface AccumulatedToolCall {
+  index?: number;
+  id: string;
+  type: "function";
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export function accumulateToolCallChunks(
+  currentAccumulatedCalls: AccumulatedToolCall[],
+  toolCallChunks: ToolCallChunk[]
+): AccumulatedToolCall[] {
+  const out = [...currentAccumulatedCalls];
+
+  for (const chunk of toolCallChunks) {
+    const { index, id, type, function: fn } = chunk;
+
+    // 分块流（带 index）
+    if (index !== undefined) {
+      // 确保数组长度足够覆盖 index
+      while (out.length <= index) {
+        // 先占位，后续必须填充 id/type/function 才能成为有效的 AccumulatedToolCall
+        // 这里暂时断言为空对象，等待后续逻辑填充完整
+        out.push({} as AccumulatedToolCall);
+      }
+
+      const cur = out[index];
+
+      // 初始化或更新基础字段
+      if (id && !cur.id) cur.id = id;
+      if (type && !cur.type) cur.type = type;
+      if (!cur.function) cur.function = { name: "", arguments: "" };
+
+      if (fn) {
+        if (fn.name) cur.function.name += fn.name;
+        if (fn.arguments) cur.function.arguments += fn.arguments;
+      }
+      continue;
+    }
+
+    // 无 index，但有 fn 的分片（同 id 的后续片段会被追加）
+    // 这种模式下通常 id 在第一个 chunk 给定，后续 chunk 可能没有 id
+    if (fn?.name || fn?.arguments) {
+      let targetIndex = -1;
+
+      // 尝试通过 ID 查找现有调用
+      if (id) {
+        targetIndex = out.findIndex((c) => c.id === id);
+      } else if (out.length > 0) {
+        // 如果没有 ID，默认追加到最后一个（假设顺序性）
+        // 注意：这是兜底逻辑，OpenAI 规范通常会带 index 或 id
+        targetIndex = out.length - 1;
+      }
+
+      if (targetIndex >= 0) {
+        const target = out[targetIndex];
+        if (fn.name) target.function.name += fn.name; // 追加
+        if (fn.arguments) target.function.arguments += fn.arguments; // 追加
+      } else if (id) {
+        // 是新的调用
+        const newCall: AccumulatedToolCall = {
+          id,
+          type: type || "function",
+          function: {
+            name: fn.name || "",
+            arguments: fn.arguments || ""
+          },
+        };
+        out.push(newCall);
+      }
+    }
+  }
+
+  return out;
+}

package/ai/chat/fetchUtils.native.ts

@@ -0,0 +1,276 @@
+// 文件路径: ai/chat/fetchUtils.native.ts
+// React Native 版 fetch 工具 - 使用 react-native-sse 支持流式传输
+
+import { Agent } from "app/types";
+import { API_ENDPOINTS } from "database/config";
+import EventSource from 'react-native-sse';
+import { shouldUseServerProxy } from "./shouldUseServerProxy";
+
+interface BodyData {
+    model: string;
+    messages: any[];
+    stream: boolean;
+    tools?: any[];
+    provider?: string;
+}
+
+interface FetchParams {
+    agentConfig: Agent;
+    api: string;
+    bodyData: BodyData;
+    currentServer: string;
+    token: string;
+    signal?: AbortSignal;
+}
+
+const buildProxyPayload = (
+    bodyData: BodyData,
+    api: string,
+    agentConfig: Agent
+) => {
+    const apiSource =
+        agentConfig.apiSource === "custom" || agentConfig.apiSource === "cli"
+            ? agentConfig.apiSource
+            : undefined;
+    const provider =
+        bodyData.provider ||
+        agentConfig.provider ||
+        (apiSource === "custom" ? "custom" : undefined);
+    const apiKey = agentConfig.apiKey?.trim() || undefined;
+
+    return {
+        ...bodyData,
+        url: api,
+        provider,
+        ...(apiSource ? { apiSource } : {}),
+        KEY: apiKey,
+    };
+};
+
+interface SSEFetchParams extends FetchParams {
+    onChunk: (chunk: string) => void;
+    onError: (error: Error) => void;
+    onComplete: () => void;
+}
+
+/**
+ * React Native 版流式 SSE 请求
+ * 使用 react-native-sse 库
+ */
+export const performSSEFetchRequest = (params: SSEFetchParams): (() => void) => {
+    const {
+        agentConfig,
+        api,
+        bodyData,
+        currentServer,
+        token,
+        signal,
+        onChunk,
+        onError,
+        onComplete,
+    } = params;
+
+    // 确定请求 URL 和 headers
+    const useProxy = shouldUseServerProxy(agentConfig, bodyData.provider);
+    const url = useProxy ? `${currentServer}${API_ENDPOINTS.CHAT}` : api;
+
+    const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+        'Accept': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+    };
+
+    if (api.includes("openrouter.ai")) {
+        headers["HTTP-Referer"] = "https://nolo.chat";
+        headers["X-Title"] = "nolo";
+    }
+
+    let requestBody: any;
+
+    if (useProxy) {
+        headers['Authorization'] = `Bearer ${token}`;
+        requestBody = buildProxyPayload(bodyData, api, agentConfig);
+    } else {
+        const directApiKey = agentConfig.apiKey?.trim();
+        if (directApiKey) {
+            headers['Authorization'] = `Bearer ${directApiKey}`;
+        }
+        requestBody = bodyData;
+    }
+
+    console.log('[SSE Native] Creating EventSource for:', url);
+
+    const es = new EventSource(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(requestBody),
+        pollingInterval: 0,
+    });
+
+    let isCompleted = false;
+
+    const cleanup = () => {
+        if (!isCompleted) {
+            isCompleted = true;
+            es.close();
+        }
+    };
+
+    // 处理消息事件
+    es.addEventListener('message', (event: any) => {
+        // console.log('[SSE Native] Message event received:', event);
+        if (event.data) {
+            // console.log('[SSE Native] Chunk data:', event.data.substring(0, 100));
+            // 包装成 SSE 格式
+            onChunk(`data: ${event.data}\n\n`);
+        }
+    });
+
+    // 处理打开事件
+    es.addEventListener('open', () => {
+        console.log('[SSE Native] Connection opened');
+    });
+
+    // 处理错误
+    es.addEventListener('error', (event: any) => {
+        console.error('SSE Error event:', event);
+
+        // react-native-sse 有时会把结束信号当做 error 发送 (xhrStatus 200, but type error)
+        // 或者简单的网络错误
+
+        // 如果是正常结束（有些实现会把 close 当 error 发）
+        if (event.type === 'error' && !event.message && !event.xhrStatus) {
+            // 可能是连接关闭
+            console.log('[SSE Native] Empty error event, treating as close/complete');
+            if (!isCompleted) {
+                onComplete();
+                cleanup();
+            }
+            return;
+        }
+
+        if (!isCompleted) {
+            // 检查是否包含 [DONE] 或者 status 200 但解析失败
+            if (event.message?.includes('[DONE]')) {
+                onComplete();
+            } else {
+                onError(new Error(event.message || 'SSE connection error'));
+            }
+            cleanup();
+        }
+    });
+
+    // 处理关闭
+    es.addEventListener('close', () => {
+        console.log('[SSE Native] Connection closed');
+        if (!isCompleted) {
+            onComplete();
+            cleanup();
+        }
+    });
+
+    // 处理 abort signal
+    if (signal) {
+        signal.addEventListener('abort', () => {
+            // console.log('[SSE Native] Aborted by signal');
+            cleanup();
+            onComplete();
+        });
+    }
+
+    // 返回 cleanup 函数
+    return cleanup;
+};
+
+/**
+ * React Native 版普通 fetch 请求 (非流式)
+ * 保持与 web 版相同的接口
+ */
+const fetchDirectly = async ({
+    api,
+    agentConfig,
+    bodyData,
+    signal,
+}: Omit<FetchParams, "currentServer" | "token">): Promise<Response> => {
+    try {
+        const apiKey = agentConfig.apiKey?.trim();
+        return await fetch(api, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+                ...(api.includes("openrouter.ai") ? {
+                    "HTTP-Referer": "https://nolo.chat",
+                    "X-Title": "nolo"
+                } : {})
+            },
+            body: JSON.stringify(bodyData),
+            signal,
+        });
+    } catch (error: any) {
+        console.error("[fetchDirectly] 网络请求失败:", error);
+        throw error;
+    }
+};
+
+const fetchWithServerProxy = async ({
+    currentServer,
+    api,
+    bodyData,
+    agentConfig,
+    token,
+    signal,
+}: FetchParams): Promise<Response> => {
+    try {
+        const payload = buildProxyPayload(bodyData, api, agentConfig);
+
+        let response = await fetch(`${currentServer}${API_ENDPOINTS.CHAT}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify(payload),
+            signal,
+        });
+
+        if (response.status === 503) {
+            console.warn("[fetchWithServerProxy] 检测到503状态，重试一次...");
+            response = await fetch(`${currentServer}${API_ENDPOINTS.CHAT}`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify(payload),
+                signal,
+            });
+        }
+
+        return response;
+    } catch (error: any) {
+        console.error("[fetchWithServerProxy] 网络请求失败:", error);
+        throw error;
+    }
+};
+
+export const performFetchRequest = async (
+    params: FetchParams
+): Promise<Response> => {
+    try {
+        return shouldUseServerProxy(
+            params.agentConfig,
+            params.bodyData.provider,
+        )
+            ? await fetchWithServerProxy(params)
+            : await fetchDirectly(params);
+    } catch (error: any) {
+        console.error("[performFetchRequest] 请求过程中发生错误:", error);
+        throw new Error(`网络请求失败: ${error.message || String(error)}`);
+    }
+};
+
+/**
+ * 标识当前是 React Native 环境
+ */
+export const isNativeSSE = true;

package/ai/chat/fetchUtils.ts

@@ -0,0 +1,153 @@
+// 文件路径: ai/chat/fetchUtils.ts
+import { Agent } from "app/types";
+
+import { API_ENDPOINTS } from "database/config";
+import { shouldUseServerProxy } from "./shouldUseServerProxy";
+
+interface BodyData {
+  model: string;
+  messages: any[];
+  stream: boolean;
+  tools?: any[];
+  provider?: string;
+}
+
+interface FetchParams {
+  agentConfig: Agent;
+  api: string;
+  bodyData: BodyData;
+  currentServer: string;
+  token: string;
+  signal?: AbortSignal; // signal 是可选的
+}
+
+const buildProxyPayload = (
+  bodyData: BodyData,
+  api: string,
+  agentConfig: Agent
+) => {
+  const apiSource =
+    agentConfig.apiSource === "custom" || agentConfig.apiSource === "cli"
+      ? agentConfig.apiSource
+      : undefined;
+  const provider =
+    bodyData.provider ||
+    agentConfig.provider ||
+    (apiSource === "custom" ? "custom" : undefined);
+  const apiKey = agentConfig.apiKey?.trim() || undefined;
+
+  return {
+    ...bodyData,
+    url: api,
+    provider,
+    ...(apiSource ? { apiSource } : {}),
+    KEY: apiKey,
+  };
+};
+
+const fetchDirectly = async ({
+  api,
+  agentConfig,
+  bodyData,
+  signal,
+}: Omit<FetchParams, "currentServer" | "token">): Promise<Response> => {
+  try {
+    const apiKey = agentConfig.apiKey?.trim();
+    return await fetch(api, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+        ...(api.includes("openrouter.ai") ? {
+          "HTTP-Referer": "https://nolo.chat",
+          "X-Title": "nolo"
+        } : {})
+      },
+      body: JSON.stringify(bodyData),
+      signal, // 可选参数，直接传递
+    });
+  } catch (error: any) {
+    console.error("[fetchDirectly] 网络请求失败:", error);
+    throw error; // 抛出错误，交给上层处理
+  }
+};
+
+const fetchWithServerProxy = async ({
+  currentServer,
+  api,
+  bodyData,
+  agentConfig,
+  token,
+  signal,
+}: FetchParams): Promise<Response> => {
+  try {
+    const payload = buildProxyPayload(bodyData, api, agentConfig);
+
+    let response = await fetch(`${currentServer}${API_ENDPOINTS.CHAT}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`, // 使用 Authorization 头传递 token
+      },
+      body: JSON.stringify(payload),
+      signal, // 可选参数，直接传递
+    });
+
+    // 如果状态码是503，重试一次
+    if (response.status === 503) {
+      console.warn("[fetchWithServerProxy] 检测到503状态，重试一次...");
+      response = await fetch(`${currentServer}${API_ENDPOINTS.CHAT}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify(payload),
+        signal,
+      });
+    }
+
+    return response;
+  } catch (error: any) {
+    console.error("[fetchWithServerProxy] 网络请求失败:", error);
+    throw error; // 抛出错误，交给上层处理
+  }
+};
+export const performFetchRequest = async (
+  params: FetchParams
+): Promise<Response> => {
+  try {
+    return shouldUseServerProxy(
+      params.agentConfig,
+      params.bodyData.provider
+    )
+      ? await fetchWithServerProxy(params)
+      : await fetchDirectly(params);
+  } catch (error: any) {
+    console.error("[performFetchRequest] 请求过程中发生错误:", error);
+    // 如果是网络错误，抛出自定义错误对象，以便上层捕获
+    throw new Error(`网络请求失败: ${error.message || String(error)}`);
+  }
+};
+
+// SSE 流式请求参数（与 native 版本保持一致的接口）
+interface SSEFetchParams extends FetchParams {
+  onChunk: (chunk: string) => void;
+  onError: (error: Error) => void;
+  onComplete: () => void;
+}
+
+/**
+ * Web 版流式 SSE 请求 - 占位函数
+ * Web 版不使用此函数，而是使用 performFetchRequest + ReadableStream
+ * 此函数仅为类型兼容而存在
+ */
+export const performSSEFetchRequest = (_params: SSEFetchParams): (() => void) => {
+  throw new Error('performSSEFetchRequest should not be called on web platform');
+};
+
+/**
+ * 标识当前是否为 React Native 环境
+ * Web 版返回 false
+ */
+export const isNativeSSE = false;

package/ai/chat/inlineImageUrlsForCustomProvider.ts

@@ -0,0 +1,117 @@
+type ImageFetchResult = {
+  ok: boolean;
+  mimeType?: string;
+  bytes?: Uint8Array;
+  error?: string;
+};
+
+type InlineOptions = {
+  shouldInline: boolean;
+  fetchImage?: (url: string) => Promise<ImageFetchResult>;
+};
+
+const FILE_CONTENT_PATH = "/api/v1/db/file/content/";
+
+export const shouldInlineImageUrlsForAgent = (
+  agentConfig: { apiSource?: string | null; provider?: string | null } | null | undefined,
+) => {
+  const apiSource = agentConfig?.apiSource?.toLowerCase();
+  const provider = agentConfig?.provider?.toLowerCase();
+  return apiSource === "custom" || provider === "custom";
+};
+
+const isInlineCandidate = (url: string) =>
+  /^https?:\/\//i.test(url) && url.includes(FILE_CONTENT_PATH);
+
+const bytesToBase64 = (bytes: Uint8Array) => {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+};
+
+const defaultFetchImage = async (url: string): Promise<ImageFetchResult> => {
+  const response = await fetch(url);
+  if (!response.ok) {
+    return {
+      ok: false,
+      error: `HTTP ${response.status}`,
+    };
+  }
+
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  return {
+    ok: true,
+    mimeType: response.headers.get("content-type") ?? "application/octet-stream",
+    bytes,
+  };
+};
+
+const cloneImagePartWithDataUrl = async (
+  part: any,
+  fetchImage: (url: string) => Promise<ImageFetchResult>,
+) => {
+  const url = part?.image_url?.url;
+  if (typeof url !== "string" || !isInlineCandidate(url)) return part;
+
+  const result = await fetchImage(url);
+  if (!result.ok || !result.bytes) {
+    throw new Error(
+      `Failed to inline custom provider image URL ${url}: ${result.error ?? "unknown error"}`,
+    );
+  }
+
+  const mimeType = result.mimeType || "application/octet-stream";
+  return {
+    ...part,
+    image_url: {
+      ...part.image_url,
+      url: `data:${mimeType};base64,${bytesToBase64(result.bytes)}`,
+    },
+  };
+};
+
+export const inlineImageUrlsForCustomProvider = async <T>(
+  bodyData: T,
+  options: InlineOptions,
+): Promise<T> => {
+  if (!options.shouldInline) return bodyData;
+
+  const body: any = bodyData;
+  if (!Array.isArray(body?.messages)) return bodyData;
+
+  const fetchImage = options.fetchImage ?? defaultFetchImage;
+  let changed = false;
+  const messages = [];
+
+  for (const message of body.messages) {
+    if (!Array.isArray(message?.content)) {
+      messages.push(message);
+      continue;
+    }
+
+    const content = [];
+    let messageChanged = false;
+    for (const part of message.content) {
+      if (part?.type !== "image_url") {
+        content.push(part);
+        continue;
+      }
+      const nextPart = await cloneImagePartWithDataUrl(part, fetchImage);
+      if (nextPart !== part) {
+        changed = true;
+        messageChanged = true;
+      }
+      content.push(nextPart);
+    }
+
+    messages.push(messageChanged ? { ...message, content } : message);
+  }
+
+  if (!changed) return bodyData;
+  return {
+    ...body,
+    messages,
+  };
+};

package/ai/chat/parseApiError.ts

@@ -0,0 +1,64 @@
+// 处理失败的API响应
+export async function parseApiError(response: Response): Promise<string> {
+  const errorBody = await response.text();
+  const truncateErrorMessage = (message: string, maxChars = 320): string =>
+    message.length <= maxChars ? message : `${message.slice(0, maxChars)}…`;
+  const isContextOverflow = (message: string): boolean =>
+    /maximum context length|context length|context_length_exceeded|requested about .*tokens|too many tokens/i.test(message);
+  let defaultMessage = `状态码 ${response.status} ${response.statusText}`;
+  let errorMessage = defaultMessage;
+  let errorCode: string | null = `E${response.status}`;
+
+  try {
+    const errorJson = JSON.parse(errorBody);
+    errorMessage = errorJson?.error?.message
+      || errorJson?.message
+      || errorJson?.msg
+      || errorBody
+      || defaultMessage;
+    errorCode = errorJson?.error?.code || errorJson?.code || errorCode;
+  } catch (_e) {
+    if (errorBody) {
+      errorMessage = errorBody;
+    }
+  }
+
+  switch (response.status) {
+    case 400:
+      if (isContextOverflow(errorMessage) || isContextOverflow(errorBody) || errorCode === "UPSTREAM_400") {
+        return "上下文过长：本轮消息或工具结果太大。请缩小范围，或先读取更小片段后再继续。";
+      }
+      if (errorMessage && errorMessage !== defaultMessage) {
+        return `请求参数错误: ${truncateErrorMessage(errorMessage)}`;
+      }
+      return "请求参数错误，请检查输入";
+    case 413:
+      return "请求内容过大：请减少一次发送的消息、文件或工具结果。";
+    case 401:
+      switch (errorCode) {
+        case "AUTH_TOKEN_EXPIRED":
+          return "登录状态已过期，请先登出后重新登录";
+        case "AUTH_ACCOUNT_INVALID":
+          return "账户无效或已被停用，请联系管理员";
+        case "AUTH_NO_TOKEN":
+          return "未检测到登录状态，请先登录";
+        case "AUTH_INVALID_TOKEN":
+          return "登录凭证无效，请先登出后重新登录";
+        case "AUTH_TOKEN_NOT_ACTIVE":
+          return "令牌尚未生效，请稍后再试";
+        default:
+          // 避免把第三方 API 的 401（如 OpenRouter key 缺失）误显示为"请先登出重登"
+          return errorMessage && errorMessage !== `状态码 401 Unauthorized`
+            ? `认证错误: ${truncateErrorMessage(errorMessage)}`
+            : "身份验证失败，请先登出后重新登录";
+      }
+    case 503:
+      return errorMessage && errorMessage !== `状态码 503 Service Unavailable`
+        ? truncateErrorMessage(errorMessage)
+        : "服务暂时不可用，请稍后再试";
+    case 504:
+      return "请求超时，请稍后再试";
+    default:
+      return `API请求失败: ${truncateErrorMessage(errorMessage)}`;
+  }
+}