nolo-cli 0.1.30 → 0.1.32

package/ai/chat/sendOpenAIResponseRequest.ts

@@ -1,577 +0,0 @@
-import {
-  addActiveController,
-  removeActiveController,
-  tokenUsageLiveUpdate,
-} from "../../chat/dialog/dialogSlice";
-import {
-  messageStreaming,
-  messageStreamEnd,
-} from "../../chat/messages/messageSlice";
-import { handleToolCalls } from "../../chat/messages/toolThunks";
-import type { Message } from "../../chat/messages/types";
-import { selectRuntimeCurrentServer } from "../../app/stateViews/runtime";
-import { selectCurrentSpaceId } from "../../create/space/spaceSlice";
-import { getApiEndpoint } from "../llm/providers";
-import { createDialogMessageKeyAndId } from "../../database/keys";
-import { selectCurrentToken } from "../../auth/authSlice";
-import { extractCustomId } from "../../core/prefix";
-import type { RootState } from "../../app/store";
-import { performFetchRequest } from "./fetchUtils";
-import { createSSEParser } from "./parseMultilineSSE";
-import { parseApiError } from "./parseApiError";
-import { updateTotalUsage } from "./updateTotalUsage";
-import type { CompletionMeta } from "./sendOpenAICompletionsRequest";
-import { prepareTools } from "../tools/prepareTools";
-import {
-  extractImagePartsFromResponseOutput,
-  extractTextFromResponseOutput,
-  toResponsesTools,
-  type AssistantToolCall,
-} from "../../integrations/openai/responsesHelpers";
-import { getModelInfo } from "../llm/getModelContextWindow";
-import {
-  getPublicImageAgentDefaultProfile,
-  getPublicImageAgentMode,
-} from "../agent/utils/publicImageAgentMode";
-
-type Segment = { type: "text"; text: string };
-const seg = (txt: string): Segment[] => [{ type: "text", text: txt ?? "" }];
-
-const shouldEnableBuiltInImageGeneration = (agentConfig: any): boolean =>
-  String(agentConfig?.provider || "").toLowerCase() === "openai" &&
-  !getModelInfo(String(agentConfig?.model || ""))?.hasImageOutput &&
-  !!agentConfig?.imageConfig?.enabled;
-
-const logQuickChatPerfStage = (
-  startedAt: number | undefined,
-  stage: string,
-  details?: Record<string, unknown>
-) => {
-  if (!startedAt) return;
-  const now = typeof performance !== "undefined" ? performance.now() : Date.now();
-  console.info("[QuickChatPerf]", {
-    stage,
-    elapsedMs: now - startedAt,
-    ...(typeof performance !== "undefined" ? { atMs: now } : {}),
-    ...(details ?? {}),
-  });
-};
-
-type StreamState = {
-  content: string;
-  contentBuffer: Array<
-    { type: "text"; text: string } | { type: "image_url"; image_url: { url: string } }
-  >;
-  reasoning: string;
-  usage: any | null;
-  assistantToolCalls: AssistantToolCall[];
-  completedResponse: any | null;
-};
-
-const safeCancel = async (
-  reader?: ReadableStreamDefaultReader<Uint8Array>
-): Promise<void> => {
-  if (!reader) return;
-  try {
-    await reader.cancel();
-  } catch {
-    /* noop */
-  }
-};
-
-const ensureToolCall = (
-  state: StreamState,
-  key: string,
-  partial: Partial<AssistantToolCall>
-) => {
-  let toolCall = state.assistantToolCalls.find((call) => call.id === key);
-  if (!toolCall) {
-    toolCall = {
-      id: key,
-      type: "function",
-      function: { name: "", arguments: "" },
-    };
-    state.assistantToolCalls.push(toolCall);
-  }
-
-  if (partial.id) toolCall.id = partial.id;
-  if (partial.function?.name) toolCall.function.name = partial.function.name;
-  if (typeof partial.function?.arguments === "string") {
-    toolCall.function.arguments = partial.function.arguments;
-  }
-
-  return toolCall;
-};
-
-const extractTextFromOutputItem = (item: any): string => {
-  if (item?.type !== "message" || !Array.isArray(item.content)) return "";
-  return item.content
-    .filter(
-      (content: any) =>
-        content?.type === "output_text" && typeof content.text === "string"
-    )
-    .map((content: any) => content.text)
-    .join("");
-};
-
-const getStreamErrorMessage = (event: any): string => {
-  const directMessage =
-    typeof event?.message === "string" && event.message.trim()
-      ? event.message.trim()
-      : null;
-  if (directMessage) return directMessage;
-
-  const nestedMessage =
-    typeof event?.error?.message === "string" && event.error.message.trim()
-      ? event.error.message.trim()
-      : typeof event?.error?.msg === "string" && event.error.msg.trim()
-        ? event.error.msg.trim()
-        : null;
-  if (nestedMessage) return nestedMessage;
-
-  const nestedCode =
-    typeof event?.error?.code === "string" && event.error.code.trim()
-      ? event.error.code.trim()
-      : typeof event?.code === "string" && event.code.trim()
-        ? event.code.trim()
-        : null;
-  if (nestedCode) return nestedCode;
-
-  const nestedType =
-    typeof event?.error?.type === "string" && event.error.type.trim()
-      ? event.error.type.trim()
-      : typeof event?.type === "string" && event.type.trim() && event.type !== "error"
-        ? event.type.trim()
-        : null;
-  if (nestedType) return nestedType;
-
-  return "Unknown error";
-};
-
-export const sendOpenAIResponseRequest = async ({
-  bodyData,
-  agentConfig,
-  thunkApi,
-  dialogKey,
-  parentMessageId,
-  messageMetadata,
-  quickChatPerfStartedAt,
-}: {
-  bodyData: any;
-  agentConfig: any;
-  thunkApi: any;
-  dialogKey: string;
-  parentMessageId?: string;
-  messageMetadata?: Partial<Message>;
-  quickChatPerfStartedAt?: number;
-}): Promise<CompletionMeta> => {
-  const { dispatch, getState, signal: thunkSignal } = thunkApi;
-  const dialogId = extractCustomId(dialogKey);
-  const controller = new AbortController();
-  thunkSignal.addEventListener("abort", () => controller.abort());
-  const signal = controller.signal;
-  const streamSpaceId = selectCurrentSpaceId(getState() as RootState) || undefined;
-
-  let messageId: string;
-  let msgKey: string;
-  if (parentMessageId) {
-    messageId = parentMessageId;
-    msgKey = `msg:${dialogId}:${messageId}`;
-  } else {
-    const newIds = createDialogMessageKeyAndId(dialogId);
-    messageId = newIds.messageId;
-    msgKey = newIds.key;
-  }
-
-  dispatch(addActiveController({ messageId, controller, dialogKey }));
-
-  const state: StreamState = {
-    content: "",
-    contentBuffer: [],
-    reasoning: "",
-    usage: null,
-    assistantToolCalls: [],
-    completedResponse: null,
-  };
-
-  const buildMeta = (
-    hasPendingInteraction = false,
-    hasHandedOff = false,
-    finishReason: string | null = null
-  ): CompletionMeta => ({
-    hasToolCalls: state.assistantToolCalls.length > 0,
-    hasPendingInteraction,
-    hasHandedOff,
-    finishReason,
-    messageId,
-    usage: state.usage ?? undefined,
-  });
-
-  const flush = () =>
-    dispatch(
-      messageStreaming({
-        id: messageId,
-        dialogId,
-      dbKey: msgKey,
-      content: state.contentBuffer,
-      thinkContent: state.reasoning,
-      role: "assistant",
-      agentKey: agentConfig.dbKey,
-      cybotKey: agentConfig.dbKey,
-      ...(typeof agentConfig?.name === "string" && agentConfig.name.trim()
-        ? { agentName: agentConfig.name.trim() }
-        : {}),
-      ...(messageMetadata ?? {}),
-    })
-  );
-
-  const finalize = async () => {
-    if (!state.content) {
-      const completedText = extractTextFromResponseOutput(state.completedResponse);
-      if (completedText) {
-        state.content = completedText;
-      }
-    }
-
-    const completedImages = extractImagePartsFromResponseOutput(state.completedResponse);
-    if (state.contentBuffer.length === 0) {
-      state.contentBuffer = [
-        ...(state.content ? seg(state.content) : []),
-        ...completedImages,
-      ];
-    } else if (
-      completedImages.length > 0 &&
-      !state.contentBuffer.some((part) => part.type === "image_url")
-    ) {
-      state.contentBuffer = [...state.contentBuffer, ...completedImages];
-    }
-
-    if (state.contentBuffer.length === 0 && state.content) {
-      state.contentBuffer = seg(state.content);
-    }
-
-    flush();
-    await dispatch(
-      messageStreamEnd({
-        finalContentBuffer: state.contentBuffer,
-        totalUsage: state.usage,
-        msgKey,
-        agentConfig,
-        dialogId,
-        dialogKey,
-        messageId,
-        reasoningBuffer: state.reasoning,
-        messageMetadata,
-        toolCalls: state.assistantToolCalls,
-        spaceId: streamSpaceId,
-      })
-    );
-  };
-
-  const processToolCalls = async () => {
-    if (!state.assistantToolCalls.length) {
-      await finalize();
-      return buildMeta(false, false, null);
-    }
-
-    if (state.usage) {
-      dispatch(
-        tokenUsageLiveUpdate({
-          input_tokens: state.usage.prompt_tokens ?? state.usage.input_tokens,
-          output_tokens:
-            state.usage.completion_tokens ?? state.usage.output_tokens,
-          cost: state.usage.cost,
-          dialogKey,
-        })
-      );
-    }
-
-    const result = await dispatch(
-      handleToolCalls({
-        accumulatedCalls: state.assistantToolCalls,
-        currentContentBuffer: state.contentBuffer,
-        agentConfig,
-        messageId,
-        dialogId,
-        dialogKey,
-        parallelSessionId: messageMetadata?.parallelSessionId,
-        parallelBranchId: messageMetadata?.parallelBranchId,
-        parallelLabel: messageMetadata?.parallelLabel,
-        parallelIndex: messageMetadata?.parallelIndex,
-      })
-    ).unwrap();
-
-    state.content = Array.isArray(result.finalContentBuffer)
-      ? result.finalContentBuffer
-        .filter((part: any) => part?.type === "text")
-        .map((part: any) => part.text ?? "")
-        .join("")
-      : state.content;
-    state.contentBuffer = Array.isArray(result.finalContentBuffer)
-      ? result.finalContentBuffer
-      : state.contentBuffer;
-
-    await finalize();
-    return buildMeta(result.hasPendingInteraction, result.hasHandedOff, null);
-  };
-
-  let reader: ReadableStreamDefaultReader<Uint8Array> | undefined;
-
-  try {
-    if (!parentMessageId) {
-      dispatch(
-        messageStreaming({
-          id: messageId,
-          dialogId,
-          dbKey: msgKey,
-          content: "",
-          role: "assistant",
-          agentKey: agentConfig.dbKey,
-          cybotKey: agentConfig.dbKey,
-          ...(typeof agentConfig?.name === "string" && agentConfig.name.trim()
-            ? { agentName: agentConfig.name.trim() }
-            : {}),
-          ...(messageMetadata ?? {}),
-          isStreaming: true,
-        })
-      );
-    }
-
-    const functionTools = getModelInfo(agentConfig.model)?.hasImageOutput
-      ? []
-      : prepareTools(agentConfig.tools ?? [], { provider: agentConfig.provider });
-
-    const imageMode = getPublicImageAgentMode(agentConfig);
-    const imageProfile =
-      imageMode === "continuous"
-        ? getPublicImageAgentDefaultProfile("continuous")
-        : null;
-
-    const tools = [
-      ...(toResponsesTools(functionTools) ?? []),
-      ...(shouldEnableBuiltInImageGeneration(agentConfig)
-        ? [{ type: "image_generation" as const }]
-        : []),
-      ...(imageMode === "continuous"
-        ? [
-            {
-              type: "image_generation" as const,
-              action: "auto" as const,
-              quality: imageProfile?.quality,
-              output_format: imageProfile?.outputFormat,
-            },
-          ]
-        : []),
-    ];
-    const requestBody = {
-      ...bodyData,
-      ...(tools.length ? { tools, tool_choice: bodyData.tool_choice ?? "auto" } : {}),
-      stream: true,
-    };
-
-    const api = getApiEndpoint(agentConfig);
-    const token = selectCurrentToken(getState() as RootState);
-    logQuickChatPerfStage(quickChatPerfStartedAt, "openai-response-fetch-starting", {
-      api,
-      dialogKey,
-    });
-    const response = await performFetchRequest({
-      agentConfig,
-      api,
-      bodyData: requestBody,
-      currentServer: selectRuntimeCurrentServer(getState() as RootState),
-      signal,
-      token,
-    });
-    logQuickChatPerfStage(quickChatPerfStartedAt, "openai-response-fetch-response", {
-      ok: response.ok,
-      status: response.status,
-      dialogKey,
-    });
-
-    if (!response.ok) {
-      const errorMessage = await parseApiError(response);
-      state.content = `[错误: ${errorMessage}]`;
-      await finalize();
-      return buildMeta();
-    }
-
-    reader = response.body?.getReader();
-    if (!reader) {
-      await finalize();
-      return buildMeta();
-    }
-
-    const parseSSE = createSSEParser();
-    const decoder = new TextDecoder();
-    let finishReason: string | null = null;
-    let loggedFirstStreamChunk = false;
-    let loggedFirstParsedEvent = false;
-    let loggedFirstVisibleDelta = false;
-
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      if (!loggedFirstStreamChunk) {
-        loggedFirstStreamChunk = true;
-        logQuickChatPerfStage(
-          quickChatPerfStartedAt,
-          "openai-response-first-stream-chunk",
-          { dialogKey, byteLength: value.byteLength }
-        );
-      }
-
-      const chunk = decoder.decode(value, { stream: true });
-      const events = parseSSE(chunk);
-      if (events.length > 0 && !loggedFirstParsedEvent) {
-        loggedFirstParsedEvent = true;
-        logQuickChatPerfStage(
-          quickChatPerfStartedAt,
-          "openai-response-first-sse-event",
-          { dialogKey, eventCount: events.length }
-        );
-      }
-      const eventList = Array.isArray(events) ? events : [events];
-
-      for (const event of eventList) {
-        if (event?.usage) {
-          state.usage = updateTotalUsage(state.usage, event.usage);
-        }
-
-        if (event?.type === "error" || event?.error) {
-          state.content += `\n[Error: ${getStreamErrorMessage(event)}]`;
-          await finalize();
-          return buildMeta();
-        }
-
-        switch (event?.type) {
-          case "response.output_text.delta":
-            if (event.delta) {
-              state.content += event.delta;
-              state.contentBuffer = seg(state.content);
-              if (!loggedFirstVisibleDelta) {
-                loggedFirstVisibleDelta = true;
-                logQuickChatPerfStage(
-                  quickChatPerfStartedAt,
-                  "openai-response-first-visible-delta",
-                  { dialogKey }
-                );
-              }
-              flush();
-            }
-            break;
-          case "response.reasoning.delta":
-            if (event.delta?.text) {
-              state.reasoning += event.delta.text;
-              flush();
-            }
-            break;
-          case "response.reasoning.done":
-            if (event.text) {
-              state.reasoning += event.text;
-              flush();
-            }
-            break;
-          case "response.output_item.added":
-          case "response.output_item.done": {
-            const item = event.item;
-            if (!state.content) {
-              const itemText = extractTextFromOutputItem(item);
-              if (itemText) {
-                state.content = itemText;
-                state.contentBuffer = seg(state.content);
-                if (!loggedFirstVisibleDelta) {
-                  loggedFirstVisibleDelta = true;
-                  logQuickChatPerfStage(
-                    quickChatPerfStartedAt,
-                    "openai-response-first-visible-delta",
-                    { dialogKey }
-                  );
-                }
-                flush();
-              }
-            }
-            if (item?.type === "function_call") {
-              ensureToolCall(state, item.call_id || item.id, {
-                id: item.call_id || item.id,
-                function: {
-                  name: item.name || "",
-                  arguments:
-                    typeof item.arguments === "string" ? item.arguments : "",
-                },
-              });
-            }
-            break;
-          }
-          case "response.function_call_arguments.delta": {
-            const key = event.call_id || event.item_id || `${event.output_index ?? 0}`;
-            const toolCall = ensureToolCall(state, key, {
-              id: event.call_id || key,
-              function: { name: event.name || "", arguments: "" },
-            });
-            toolCall.function.arguments += event.delta ?? "";
-            break;
-          }
-          case "response.function_call_arguments.done": {
-            const key = event.call_id || event.item_id || `${event.output_index ?? 0}`;
-            ensureToolCall(state, key, {
-              id: event.call_id || key,
-              function: {
-                name: event.name || "",
-                arguments:
-                  typeof event.arguments === "string"
-                    ? event.arguments
-                    : typeof event.output?.arguments === "string"
-                      ? event.output.arguments
-                      : "",
-              },
-            });
-            break;
-          }
-          case "response.completed":
-            state.completedResponse = event.response ?? null;
-            finishReason =
-              event.response?.status === "completed"
-                ? "stop"
-                : event.response?.status ?? null;
-            if (event.response?.usage) {
-              state.usage = updateTotalUsage(state.usage, event.response.usage);
-            }
-            break;
-          case "response.failed":
-            state.content += `\n[API Failed: ${event.response?.error?.message || "unknown"}]`;
-            finishReason = "error";
-            await finalize();
-            return buildMeta(false, false, finishReason);
-          case "response.incomplete":
-            state.content += `\n[Incomplete: ${event.response?.incomplete_details?.reason || "unknown"}]`;
-            finishReason = "incomplete";
-            await finalize();
-            return buildMeta(false, false, finishReason);
-          default:
-            break;
-        }
-      }
-    }
-
-    const meta = await processToolCalls();
-    return {
-      ...meta,
-      finishReason: meta.finishReason ?? finishReason,
-    };
-  } catch (error: any) {
-    state.content +=
-      error?.name === "AbortError"
-        ? "[用户中断]"
-        : `[异常: ${error?.message || "unknown"}]`;
-    await finalize();
-    return buildMeta(false, false, "error");
-  } finally {
-    logQuickChatPerfStage(quickChatPerfStartedAt, "openai-response-stream-finished", {
-      dialogKey,
-    });
-    dispatch(removeActiveController({ messageId, dialogKey }));
-    await safeCancel(reader);
-  }
-};

package/ai/chat/shouldUseServerProxy.ts

@@ -1,18 +0,0 @@
-import type { Agent } from "../../app/types";
-
-export const shouldUseServerProxy = (
-  agentConfig: Pick<Agent, "provider" | "useServerProxy">,
-  requestProvider?: string
-): boolean => {
-  const effectiveProvider = (requestProvider || agentConfig.provider || "").toLowerCase();
-
-  // Google requests are forced through the server proxy for now because the
-  // native Gemini image bridge, provider fallback, and request translation live
-  // on the server. Keep this centralized so we can later add direct/custom-url
-  // opt-out for user-managed keys without having to update web/native twice.
-  if (effectiveProvider === "google") {
-    return true;
-  }
-
-  return !!agentConfig.useServerProxy;
-};

package/ai/chat/sseClient.native.ts

@@ -1,91 +0,0 @@
-// 文件路径: ai/chat/sseClient.native.ts
-// React Native 版 SSE 客户端实现 - 使用 react-native-sse
-
-import EventSource from 'react-native-sse';
-
-export interface SSEClientOptions {
-    url: string;
-    method: 'POST';
-    headers: Record<string, string>;
-    body: string;
-    signal?: AbortSignal;
-    onMessage: (data: string) => void;
-    onError: (error: Error) => void;
-    onComplete: () => void;
-}
-
-/**
- * React Native 版 SSE 客户端
- * 使用 react-native-sse 库实现
- */
-export async function createSSEClient(options: SSEClientOptions): Promise<void> {
-    const { url, method, headers, body, signal, onMessage, onError, onComplete } = options;
-
-    return new Promise<void>((resolve) => {
-        const es = new EventSource(url, {
-            method,
-            headers: {
-                ...headers,
-                'Accept': 'text/event-stream',
-            },
-            body,
-            pollingInterval: 0, // 禁用轮询，使用真正的 SSE
-        });
-
-        let isCompleted = false;
-
-        const cleanup = () => {
-            if (!isCompleted) {
-                isCompleted = true;
-                es.close();
-                resolve();
-            }
-        };
-
-        // 处理原始消息事件
-        es.addEventListener('message', (event: any) => {
-            if (event.data) {
-                // react-native-sse 返回的是已解析的单行数据
-                // 需要包装成 SSE 格式以便 parseMultilineSSE 处理
-                onMessage(`data: ${event.data}\n\n`);
-            }
-        });
-
-        // 处理打开事件
-        es.addEventListener('open', () => {
-            console.log('[SSE Native] Connection opened');
-        });
-
-        // 处理错误
-        es.addEventListener('error', (event: any) => {
-            console.error('[SSE Native] Error:', event);
-            if (!isCompleted) {
-                // 检查是否是正常结束
-                if (event.message?.includes('DONE') || event.type === 'close') {
-                    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();
-            });
-        }
-    });
-}