nolo-cli 0.1.13 → 0.1.14

package/ai/chat/sendOpenAICompletionsRequest.native.ts

@@ -0,0 +1,682 @@
+// 文件路径: chat/sendOpenAICompletionsRequest.native.ts
+// React Native 版 - 使用 react-native-sse 进行流式传输
+
+
+
+import {
+    addActiveController,
+    removeActiveController,
+} from "chat/dialog/dialogSlice";
+import {
+    messageStreamEnd,
+    messageStreaming,
+} from "chat/messages/messageSlice";
+import { handleToolCalls } from "chat/messages/toolThunks";
+import { MessageContentPart, OpenAITextContent } from "chat/messages/types";
+import { selectCurrentServer } from "app/settings/settingSlice";
+import { getApiEndpoint } from "ai/llm/providers";
+import { createDialogMessageKeyAndId } from "database/keys";
+import { selectCurrentToken } from "auth/authSlice";
+import { extractCustomId } from "core/prefix";
+
+import { performSSEFetchRequest } from "./fetchUtils";
+import { createSSEParser } from "./parseMultilineSSE";
+import { parseApiError } from "./parseApiError";
+import { updateTotalUsage } from "./updateTotalUsage";
+import { accumulateToolCallChunks, AccumulatedToolCall, ToolCallChunk } from "./accumulateToolCallChunks";
+import { prepareTools } from "../tools/prepareTools";
+
+import { getModelInfo } from "ai/llm/getModelContextWindow";
+
+import type { RootState } from "app/store";
+
+/**
+ * 追加文本 chunk 到 contentBuffer（不可变更新）
+ */
+function appendTextChunk(
+    currentContentBuffer: MessageContentPart[],
+    textChunk: string
+): MessageContentPart[] {
+    if (!textChunk) return currentContentBuffer;
+
+    const updatedContentBuffer = [...currentContentBuffer];
+    const lastIndex = updatedContentBuffer.length - 1;
+
+    if (lastIndex >= 0 && updatedContentBuffer[lastIndex].type === "text") {
+        const last = updatedContentBuffer[lastIndex] as OpenAITextContent;
+        updatedContentBuffer[lastIndex] = {
+            ...last,
+            text: (last.text || "") + textChunk,
+        };
+    } else {
+        updatedContentBuffer.push({ type: "text", text: textChunk });
+    }
+
+    return updatedContentBuffer;
+}
+
+/** OpenAI 标准 tool_call 结构 */
+type AssistantToolCall = {
+    id: string;
+    type: "function";
+    function: { name: string; arguments: string };
+};
+
+/** 单次流式请求过程中的全部中间状态（显式 state） */
+type StreamState = {
+    contentBuffer: MessageContentPart[];
+    totalUsage: any | null;
+    accumulatedToolCalls: AccumulatedToolCall[];
+    reasoningBuffer: string;
+    assistantToolCalls?: AssistantToolCall[];
+    hasHandedOff: boolean;
+    hasProcessedToolCalls: boolean;
+    alreadyFinalized: boolean;
+    finishReason: string | null;
+};
+
+type FinalizeContext = {
+    dispatch: any;
+    msgKey: string;
+    dialogId: string;
+    dialogKey: string;
+    messageId: string;
+    agentConfig: any;
+};
+
+type ToolCallsContext = {
+    dispatch: any;
+    agentConfig: any;
+    dialogId: string;
+    dialogKey: string;
+    messageId: string;
+};
+
+type StreamCompletionContext = {
+    dispatch: any;
+    dialogId: string;
+    dialogKey: string;
+    messageId: string;
+    agentConfig: any;
+};
+
+/** 单轮调用后返回给 Agent Loop 的元信息 */
+export type CompletionMeta = {
+    hasToolCalls: boolean;
+    hasPendingInteraction: boolean;
+    hasHandedOff: boolean;
+    finishReason: string | null;
+    usage?: any;
+};
+
+/**
+ * 初始化流式状态
+ */
+function createInitialStreamState(): StreamState {
+    return {
+        contentBuffer: [],
+        totalUsage: null,
+        accumulatedToolCalls: [],
+        reasoningBuffer: "",
+        assistantToolCalls: undefined,
+        hasHandedOff: false,
+        hasProcessedToolCalls: false,
+        alreadyFinalized: false,
+        finishReason: null,
+    };
+}
+
+/**
+ * 根据 tools 配置生成本次请求体（不改动外部传入的 bodyData）
+ */
+function buildRequestBodyWithTools(
+    bodyData: any,
+    agentConfig: any,
+    disableToolsForThisRequest: boolean
+): any {
+    if (disableToolsForThisRequest) return bodyData;
+
+    // 如果模型拥有图像输出能力，则不组装任何 tools
+    const modelInfo = getModelInfo(agentConfig.model);
+    if (modelInfo?.hasImageOutput) {
+        return bodyData;
+    }
+
+    const rawTools = agentConfig.tools;
+    if (!Array.isArray(rawTools) || rawTools.length === 0) return bodyData;
+
+    const tools = prepareTools(rawTools, { provider: agentConfig.provider });
+    if (!tools.length) return bodyData;
+
+    return {
+        ...bodyData,
+        tools,
+        tool_choice: bodyData.tool_choice ?? "auto",
+    };
+}
+
+/**
+ * 结束当前流式消息，派发 messageStreamEnd（带幂等保护）
+ */
+async function finalizeStream(
+    state: StreamState,
+    ctx: FinalizeContext
+): Promise<StreamState> {
+    if (state.hasHandedOff || state.alreadyFinalized) return state;
+
+    await ctx.dispatch(
+        messageStreamEnd({
+            finalContentBuffer: state.contentBuffer,
+            totalUsage: state.totalUsage,
+            msgKey: ctx.msgKey,
+            agentConfig: ctx.agentConfig,
+            dialogId: ctx.dialogId,
+            dialogKey: ctx.dialogKey,
+            messageId: ctx.messageId,
+            reasoningBuffer: state.reasoningBuffer,
+            toolCalls: state.assistantToolCalls,
+        })
+    );
+
+    return {
+        ...state,
+        alreadyFinalized: true,
+    };
+}
+
+/**
+ * 累积 usage
+ */
+function applyUsage(state: StreamState, data: any): StreamState {
+    if (!data.usage) return state;
+
+    return {
+        ...state,
+        totalUsage: updateTotalUsage(state.totalUsage, data.usage),
+    };
+}
+
+/**
+ * 处理单个 delta（文本 / 推理 / tool_calls / 图片）
+ */
+function applyDelta(
+    state: StreamState,
+    delta: any
+): { state: StreamState; hasNewVisibleContent: boolean } {
+    let hasNewVisibleContent = false;
+    let next: StreamState = { ...state };
+
+    // reasoning_content 增量
+    if (delta.reasoning_content) {
+        next.reasoningBuffer =
+            (next.reasoningBuffer || "") + delta.reasoning_content;
+    }
+
+    // tool_calls 累积 + 映射为 OpenAI 标准格式
+    if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0) {
+        const accumulated = accumulateToolCallChunks(
+            next.accumulatedToolCalls,
+            delta.tool_calls
+        );
+
+        next = {
+            ...next,
+            accumulatedToolCalls: accumulated,
+            assistantToolCalls: accumulated.map((call) => ({
+                id: call.id,
+                type: "function",
+                function: {
+                    name: call.function?.name,
+                    arguments:
+                        typeof call.function?.arguments === "string"
+                            ? call.function.arguments
+                            : JSON.stringify(call.function?.arguments ?? {}),
+                },
+            })),
+        };
+    }
+
+    // 图片增量
+    const deltaAny = delta as any;
+    if (Array.isArray(deltaAny.images) && deltaAny.images.length > 0) {
+        next = {
+            ...next,
+            contentBuffer: [...next.contentBuffer, ...deltaAny.images],
+        };
+        hasNewVisibleContent = true;
+    }
+
+    // 文本增量
+    const contentChunk = delta.content || "";
+    if (contentChunk) {
+        next = {
+            ...next,
+            contentBuffer: appendTextChunk(next.contentBuffer, contentChunk),
+        };
+        hasNewVisibleContent = true;
+    }
+
+    return { state: next, hasNewVisibleContent };
+}
+
+/**
+ * 如果有新可见内容，则派发一次 messageStreaming 更新前端
+ */
+function emitStreamingUpdate(
+    hasNewVisibleContent: boolean,
+    state: StreamState,
+    ctx: {
+        dispatch: any;
+        agentConfig: any;
+        messageId: string;
+        msgKey: string;
+        dialogId: string;
+    }
+) {
+    if (!hasNewVisibleContent) return;
+
+    ctx.dispatch(
+        messageStreaming({
+            id: ctx.messageId,
+            dialogId: ctx.dialogId,
+            dbKey: ctx.msgKey,
+            content: state.contentBuffer,
+            thinkContent: state.reasoningBuffer,
+            role: "assistant",
+            cybotKey: ctx.agentConfig.dbKey,
+        })
+    );
+}
+
+/**
+ * 处理已经累积好的 tool_calls
+ */
+async function processAccumulatedToolCalls(
+    state: StreamState,
+    ctx: ToolCallsContext
+): Promise<{
+    state: StreamState;
+    hasHandedOff: boolean;
+    hasPendingInteraction: boolean;
+}> {
+    if (!state.accumulatedToolCalls.length) {
+        return {
+            state,
+            hasHandedOff: false,
+            hasPendingInteraction: false,
+        };
+    }
+
+    const result = await ctx
+        .dispatch(
+            handleToolCalls({
+                accumulatedCalls: state.accumulatedToolCalls,
+                currentContentBuffer: state.contentBuffer,
+                agentConfig: ctx.agentConfig,
+                messageId: ctx.messageId,
+                dialogId: ctx.dialogId,
+                dialogKey: ctx.dialogKey,
+            })
+        )
+        .unwrap();
+
+    const nextState: StreamState = {
+        ...state,
+        contentBuffer: result.finalContentBuffer,
+        accumulatedToolCalls: [],
+        hasProcessedToolCalls: true,
+        hasHandedOff: result.hasHandedOff,
+    };
+
+    return {
+        state: nextState,
+        hasHandedOff: result.hasHandedOff,
+        hasPendingInteraction: result.hasPendingInteraction,
+    };
+}
+
+/**
+ * 处理「流结束」场景（done === true）
+ */
+async function handleStreamCompletion(
+    state: StreamState,
+    ctx: StreamCompletionContext,
+    finalizeCtx: FinalizeContext
+): Promise<{
+    state: StreamState;
+    hasHandedOff: boolean;
+    hasPendingInteraction: boolean;
+}> {
+    let hasHandedOff = false;
+    let hasPendingInteraction = false;
+
+    if (!state.hasProcessedToolCalls && state.accumulatedToolCalls.length > 0) {
+        const toolResult = await processAccumulatedToolCalls(state, {
+            dispatch: ctx.dispatch,
+            agentConfig: ctx.agentConfig,
+            dialogId: ctx.dialogId,
+            dialogKey: ctx.dialogKey,
+            messageId: ctx.messageId,
+        });
+
+        let next = toolResult.state;
+        hasHandedOff ||= toolResult.hasHandedOff;
+        hasPendingInteraction ||= toolResult.hasPendingInteraction;
+
+        next = await finalizeStream(next, finalizeCtx);
+        return { state: next, hasHandedOff, hasPendingInteraction };
+    }
+
+    const finalized = await finalizeStream(state, finalizeCtx);
+    return { state: finalized, hasHandedOff, hasPendingInteraction };
+}
+
+/**
+ * React Native 版主流程：使用 react-native-sse 处理流式 SSE
+ */
+export const sendOpenAICompletionsRequest = async ({
+    bodyData,
+    agentConfig,
+    thunkApi,
+    dialogKey,
+    parentMessageId,
+    disableToolsForThisRequest = false,
+}: {
+    bodyData: any;
+    agentConfig: any;
+    thunkApi: any;
+    dialogKey: string;
+    parentMessageId?: string;
+    disableToolsForThisRequest?: boolean;
+}): Promise<CompletionMeta> => {
+    const getStreamErrorMessage = (data: any): string => {
+        const message =
+            typeof data?.error?.message === "string" && data.error.message.trim()
+                ? data.error.message.trim()
+                : typeof data?.error?.msg === "string" && data.error.msg.trim()
+                    ? data.error.msg.trim()
+                    : typeof data?.message === "string" && data.message.trim()
+                        ? data.message.trim()
+                        : null;
+        if (message) return message;
+
+        const code =
+            typeof data?.error?.code === "string" && data.error.code.trim()
+                ? data.error.code.trim()
+                : typeof data?.code === "string" && data.code.trim()
+                    ? data.code.trim()
+                    : null;
+        if (code) return code;
+
+        const type =
+            typeof data?.error?.type === "string" && data.error.type.trim()
+                ? data.error.type.trim()
+                : null;
+        if (type) return type;
+
+        return "Unknown error";
+    };
+
+    const { dispatch, getState, signal: thunkSignal } = thunkApi;
+
+    const dialogId = extractCustomId(dialogKey);
+    const controller = new AbortController();
+    thunkSignal.addEventListener("abort", () => controller.abort());
+    const signal = controller.signal;
+
+    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 requestBody = buildRequestBodyWithTools(
+        bodyData,
+        agentConfig,
+        disableToolsForThisRequest
+    );
+
+    let streamState: StreamState = createInitialStreamState();
+    const parseSSE = createSSEParser();
+    let cleanup: (() => void) | undefined;
+
+    const finalizeCtx: FinalizeContext = {
+        dispatch,
+        msgKey,
+        dialogId,
+        dialogKey,
+        messageId,
+        agentConfig,
+    };
+
+    let hasHandedOffOverall = false;
+    let hasPendingInteractionOverall = false;
+    let lastFinishReason: string | null = null;
+
+    const buildMeta = (): CompletionMeta => ({
+        hasToolCalls:
+            Array.isArray(streamState.assistantToolCalls) &&
+            streamState.assistantToolCalls.length > 0,
+        hasPendingInteraction: hasPendingInteractionOverall,
+        hasHandedOff: hasHandedOffOverall,
+        finishReason: lastFinishReason,
+        usage: streamState.totalUsage ?? undefined,
+    });
+
+    return new Promise<CompletionMeta>((resolve) => {
+        // 防止 finishWithMeta 被多次调用（[DONE] + close/error 事件可能重复触发）
+        let resolved = false;
+
+        const finishWithMeta = async () => {
+            if (resolved) {
+
+                return;
+            }
+            resolved = true;
+
+            dispatch(removeActiveController({ messageId, dialogKey }));
+            cleanup?.();
+            resolve(buildMeta());
+        };
+
+        try {
+            if (!parentMessageId) {
+                dispatch(
+                    messageStreaming({
+                        id: messageId,
+                        dialogId,
+                        dbKey: msgKey,
+                        content: "",
+                        role: "assistant",
+                        cybotKey: agentConfig.dbKey,
+                        isStreaming: true,
+                    })
+                );
+            }
+
+            const api = getApiEndpoint(agentConfig);
+            const token = selectCurrentToken(getState() as RootState);
+
+            const handleCompletion = async () => {
+                const completion = await handleStreamCompletion(
+                    streamState,
+                    {
+                        dispatch,
+                        dialogId,
+                        dialogKey: finalizeCtx.dialogKey,
+                        messageId,
+                        agentConfig,
+                    },
+                    finalizeCtx
+                );
+
+                streamState = completion.state;
+                hasHandedOffOverall ||= completion.hasHandedOff;
+                hasPendingInteractionOverall ||= completion.hasPendingInteraction;
+
+                await finishWithMeta();
+            };
+
+            cleanup = performSSEFetchRequest({
+                agentConfig,
+                api,
+                bodyData: requestBody,
+                currentServer: selectCurrentServer(getState() as RootState),
+                signal,
+                token,
+                onChunk: (chunk: string) => {
+                    const parsedResults = parseSSE(chunk);
+
+                    for (const parsedData of parsedResults) {
+                        const dataList = Array.isArray(parsedData) ? parsedData : [parsedData];
+
+                        for (const data of dataList) {
+                            streamState = applyUsage(streamState, data);
+
+                            if (data === "[DONE]") {
+
+                                cleanup?.();
+                                // 必须显式调用，不能指望 onComplete
+                                handleCompletion();
+                                return;
+                            }
+
+                            if (data.error) {
+                                const errorMsg = `Error: ${getStreamErrorMessage(data)}`;
+                                streamState = {
+                                    ...streamState,
+                                    contentBuffer: appendTextChunk(
+                                        streamState.contentBuffer,
+                                        `\n[API Error] ${errorMsg}`
+                                    ),
+                                };
+                                // 必须调用 finishWithMeta 来 resolve Promise 并移除 controller
+                                finalizeStream(streamState, finalizeCtx).then(() => {
+                                    finishWithMeta();
+                                });
+                                return;
+                            }
+
+                            const choice = data.choices?.[0];
+                            if (!choice) continue;
+
+                            const delta = choice.delta || {};
+
+                            const { state: updatedState, hasNewVisibleContent } = applyDelta(
+                                streamState,
+                                delta
+                            );
+                            streamState = updatedState;
+
+                            emitStreamingUpdate(hasNewVisibleContent, streamState, {
+                                dispatch,
+                                agentConfig,
+                                messageId,
+                                msgKey,
+                                dialogId,
+                            });
+
+                            const finishReason = choice.finish_reason;
+                            if (finishReason) {
+                                lastFinishReason = finishReason;
+                                streamState.finishReason = finishReason;
+
+                                if (finishReason === "tool_calls") {
+                                    // 处理 tool_calls - 异步执行
+                                    processAccumulatedToolCalls(streamState, {
+                                        dispatch,
+                                        agentConfig,
+                                        dialogId,
+                                        dialogKey,
+                                        messageId,
+                                    }).then((toolResult) => {
+                                        streamState = toolResult.state;
+                                        hasHandedOffOverall ||= toolResult.hasHandedOff;
+                                        hasPendingInteractionOverall ||= toolResult.hasPendingInteraction;
+
+                                        finalizeStream(streamState, finalizeCtx).then((finalized) => {
+                                            streamState = finalized;
+                                        });
+                                    });
+                                } else if (finishReason !== "stop") {
+                                    streamState = {
+                                        ...streamState,
+                                        contentBuffer: appendTextChunk(
+                                            streamState.contentBuffer,
+                                            `\n[流结束原因: ${finishReason}]`
+                                        ),
+                                    };
+                                }
+                            }
+                        }
+                    }
+                },
+                onError: async (error: Error) => {
+                    if (error?.message?.includes('[DONE]')) {
+                        const completion = await handleStreamCompletion(
+                            streamState,
+                            {
+                                dispatch,
+                                dialogId,
+                                dialogKey: finalizeCtx.dialogKey,
+                                messageId,
+                                agentConfig,
+                            },
+                            finalizeCtx
+                        );
+
+                        streamState = completion.state;
+                        hasHandedOffOverall ||= completion.hasHandedOff;
+                        hasPendingInteractionOverall ||= completion.hasPendingInteraction;
+
+                        await finishWithMeta();
+                        return;
+                    }
+
+                    let errorText: string;
+                    if (error?.name === "AbortError") {
+                        errorText = "\n[用户中断]";
+                    } else {
+                        errorText = `\n[错误: ${error?.message || String(error)}]`;
+                    }
+
+                    console.error("[SSE Native] sendOpenAICompletionsRequest error:", error);
+
+                    streamState = {
+                        ...streamState,
+                        contentBuffer: appendTextChunk(streamState.contentBuffer, errorText),
+                    };
+                    streamState = await finalizeStream(streamState, finalizeCtx);
+                    await finishWithMeta();
+                },
+                onComplete: handleCompletion,
+            });
+        } catch (error: any) {
+            let errorText: string;
+            if (error?.name === "AbortError") {
+                errorText = "\n[用户中断]";
+            } else {
+                errorText = `\n[错误: ${error?.message || String(error)}]`;
+            }
+
+            console.error("[SSE Native] sendOpenAICompletionsRequest error:", error);
+
+            streamState = {
+                ...streamState,
+                contentBuffer: appendTextChunk(streamState.contentBuffer, errorText),
+            };
+            finalizeStream(streamState, finalizeCtx).then(() => {
+                finishWithMeta();
+            });
+        }
+    });
+};