@jsonstudio/rcc 0.90.323 → 0.90.364

package/vendor/@jsonstudio/llms/dist/sse/sse-to-json/builders/anthropic-response-builder.js

@@ -0,0 +1,258 @@
+import { dispatchReasoning } from '../../shared/reasoning-dispatcher.js';
+function mergeAnthropicUsage(current, incoming) {
+    if (!incoming || typeof incoming !== 'object') {
+        return current;
+    }
+    const incomingRecord = incoming;
+    const base = current && typeof current === 'object' ? { ...current } : {};
+    for (const [key, value] of Object.entries(incomingRecord)) {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const prev = base[key];
+            base[key] = {
+                ...(prev && typeof prev === 'object' && !Array.isArray(prev) ? prev : {}),
+                ...value
+            };
+            continue;
+        }
+        base[key] = value;
+    }
+    return base;
+}
+export function createAnthropicResponseBuilder(options) {
+    const state = {
+        content: [],
+        role: 'assistant',
+        completed: false
+    };
+    const inferStopReason = () => {
+        if (state.stopReason) {
+            return state.stopReason;
+        }
+        const currentKind = state.currentBlock?.kind;
+        if (currentKind === 'tool_use' || state.content.some((block) => block.type === 'tool_use')) {
+            return 'tool_use';
+        }
+        return 'end_turn';
+    };
+    const flushCurrent = () => {
+        if (!state.currentBlock)
+            return;
+        const block = state.currentBlock;
+        if (block.kind === 'text' && block.buffer) {
+            state.content.push({ type: 'text', text: block.buffer });
+        }
+        else if (block.kind === 'thinking' && block.buffer) {
+            const decision = dispatchReasoning(block.buffer, {
+                mode: options?.reasoningMode,
+                prefix: options?.reasoningTextPrefix
+            });
+            if (decision.appendToContent) {
+                state.content.push({ type: 'text', text: decision.appendToContent });
+            }
+            if (decision.channel) {
+                state.content.push({
+                    type: 'thinking',
+                    text: decision.channel,
+                    ...(typeof block.signature === 'string' && block.signature.trim().length
+                        ? { signature: block.signature.trim() }
+                        : {})
+                });
+            }
+            if (typeof block.signature === 'string' && block.signature.trim().length) {
+                state.content.push({ type: 'redacted_thinking', data: block.signature.trim() });
+            }
+        }
+        else if (block.kind === 'thinking' && typeof block.signature === 'string' && block.signature.trim().length) {
+            state.content.push({ type: 'redacted_thinking', data: block.signature.trim() });
+        }
+        else if (block.kind === 'redacted_thinking' && block.data.trim().length) {
+            state.content.push({ type: 'redacted_thinking', data: block.data.trim() });
+        }
+        else if (block.kind === 'tool_use') {
+            let input = {};
+            try {
+                input = block.buffer ? JSON.parse(block.buffer) : {};
+            }
+            catch {
+                input = { _raw: block.buffer };
+            }
+            state.content.push({
+                type: 'tool_use',
+                id: block.id,
+                name: block.name,
+                input
+            });
+        }
+        else if (block.kind === 'tool_result') {
+            state.content.push({
+                type: 'tool_result',
+                tool_use_id: block.tool_use_id,
+                content: block.content,
+                is_error: block.is_error
+            });
+        }
+        state.currentBlock = undefined;
+    };
+    return {
+        processEvent(event) {
+            switch (event.type) {
+                case 'message_start': {
+                    const payload = event.data?.message;
+                    if (payload) {
+                        state.id = payload.id || state.id;
+                        state.model = payload.model || state.model;
+                        state.role = payload.role || state.role;
+                        state.usage = mergeAnthropicUsage(state.usage, payload.usage);
+                    }
+                    break;
+                }
+                case 'content_block_start': {
+                    const payload = event.data?.content_block;
+                    const index = event.data?.index ?? 0;
+                    if (!payload)
+                        break;
+                    if (payload.type === 'text') {
+                        state.currentBlock = { kind: 'text', buffer: '', index };
+                    }
+                    else if (payload.type === 'thinking') {
+                        state.currentBlock = {
+                            kind: 'thinking',
+                            buffer: '',
+                            index,
+                            signature: typeof payload.signature === 'string' ? payload.signature : undefined
+                        };
+                    }
+                    else if (payload.type === 'redacted_thinking') {
+                        state.currentBlock = {
+                            kind: 'redacted_thinking',
+                            data: typeof payload.data === 'string' ? payload.data : '',
+                            index
+                        };
+                    }
+                    else if (payload.type === 'tool_use') {
+                        state.currentBlock = {
+                            kind: 'tool_use',
+                            id: payload.id,
+                            name: payload.name,
+                            buffer: '',
+                            index
+                        };
+                    }
+                    else if (payload.type === 'tool_result') {
+                        state.currentBlock = {
+                            kind: 'tool_result',
+                            tool_use_id: payload.tool_use_id,
+                            content: payload.content,
+                            is_error: payload.is_error,
+                            index
+                        };
+                    }
+                    break;
+                }
+                case 'content_block_delta': {
+                    if (!state.currentBlock)
+                        break;
+                    const delta = event.data?.delta;
+                    if (!delta)
+                        break;
+                    if (state.currentBlock.kind === 'text' && typeof delta.text === 'string') {
+                        state.currentBlock.buffer += delta.text;
+                    }
+                    else if (state.currentBlock.kind === 'thinking') {
+                        if (typeof delta.text === 'string') {
+                            state.currentBlock.buffer += delta.text;
+                        }
+                        if (typeof delta.thinking === 'string') {
+                            state.currentBlock.buffer += delta.thinking;
+                        }
+                        if (typeof delta.signature === 'string' && delta.signature.trim().length) {
+                            state.currentBlock.signature = delta.signature;
+                        }
+                    }
+                    else if (state.currentBlock.kind === 'tool_use' && typeof delta.partial_json === 'string') {
+                        state.currentBlock.buffer += delta.partial_json;
+                    }
+                    else if (state.currentBlock.kind === 'redacted_thinking') {
+                        if (typeof delta.signature === 'string' && delta.signature.trim().length) {
+                            state.currentBlock.data += delta.signature;
+                        }
+                        else if (typeof delta.thinking === 'string' && delta.thinking.trim().length) {
+                            state.currentBlock.data += delta.thinking;
+                        }
+                        else if (typeof delta.text === 'string' && delta.text.trim().length) {
+                            state.currentBlock.data += delta.text;
+                        }
+                    }
+                    break;
+                }
+                case 'content_block_stop': {
+                    flushCurrent();
+                    break;
+                }
+                case 'message_delta': {
+                    const data = event.data ?? {};
+                    const delta = data?.delta;
+                    if (delta?.stop_reason) {
+                        state.stopReason = delta.stop_reason;
+                    }
+                    if (typeof delta?.stop_sequence === 'string' || delta?.stop_sequence === null) {
+                        state.stopSequence = delta.stop_sequence;
+                    }
+                    // 部分实现将 usage 挂在 delta.usage，部分实现挂在顶层 event.data.usage，
+                    // 这里统一优先读取 delta.usage，缺失时回退到 data.usage。
+                    const usageNode = (delta && delta.usage) ?? data.usage;
+                    if (usageNode) {
+                        state.usage = mergeAnthropicUsage(state.usage, usageNode);
+                    }
+                    break;
+                }
+                case 'message_stop': {
+                    state.completed = true;
+                    flushCurrent();
+                    break;
+                }
+                default:
+                    break;
+            }
+            return true;
+        },
+        getResult() {
+            if (!state.completed) {
+                // 网络提前断开时可能缺失 content_block_stop/message_stop，
+                // 先尝试 flush 当前 block，尽最大努力还原已接收内容。
+                flushCurrent();
+                // 对部分实现（或网络提前关闭）导致缺失 message_stop 的 SSE 流，
+                // 只要已经累计到可用内容，就以最佳努力方式返回结果，而不是直接抛错。
+                if (state.content.length > 0) {
+                    return {
+                        success: true,
+                        response: {
+                            id: state.id || `msg_${Date.now()}`,
+                            type: 'message',
+                            role: state.role || 'assistant',
+                            model: state.model || 'unknown',
+                            content: state.content,
+                            usage: state.usage,
+                            stop_reason: inferStopReason(),
+                            stop_sequence: state.stopSequence
+                        }
+                    };
+                }
+                return { success: false, error: new Error('Anthropic SSE stream incomplete') };
+            }
+            return {
+                success: true,
+                response: {
+                    id: state.id || `msg_${Date.now()}`,
+                    type: 'message',
+                    role: state.role || 'assistant',
+                    model: state.model || 'unknown',
+                    content: state.content,
+                    usage: state.usage,
+                    stop_reason: inferStopReason(),
+                    stop_sequence: state.stopSequence
+                }
+            };
+        }
+    };
+}

package/vendor/@jsonstudio/llms/dist/sse/sse-to-json/builders/response-builder.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Responses响应构建器
+ * 负责状态机和事件聚合，从SSE事件构建完整的Responses响应对象
+ */
+import type { ResponsesSseEvent, ResponsesResponse } from '../../types/index.js';
+export type ResponseBuilderState = 'initial' | 'building' | 'completed' | 'error';
+export interface ResponseBuilderConfig {
+    enableStrictValidation: boolean;
+    enableEventRecovery: boolean;
+    maxOutputItems: number;
+    maxContentParts: number;
+    maxSequenceGaps: number;
+}
+export interface OutputItemState {
+    id: string;
+    type: string;
+    status: 'in_progress' | 'completed';
+    contentParts: any[];
+    currentContentIndex: number;
+    accumulatedContent: any[];
+    currentReasoningIndex: number;
+    summaryByIndex: Map<number, string>;
+    currentSummaryIndex: number;
+    hasContentPartAdded: boolean;
+    isTextInProgress: boolean;
+    callId?: string;
+    name?: string;
+    arguments?: string;
+    role?: string;
+    encryptedContent?: string;
+    startTime: number;
+    lastEventTime: number;
+}
+export declare const DEFAULT_RESPONSE_BUILDER_CONFIG: ResponseBuilderConfig;
+/**
+ * Responses响应构建器
+ */
+export declare class ResponsesResponseBuilder {
+    private state;
+    private response;
+    private outputItemBuilders;
+    private lastSequenceNumber;
+    private config;
+    private error?;
+    private hasExplicitReasoning;
+    constructor(config?: Partial<ResponseBuilderConfig>);
+    /**
+     * 处理SSE事件
+     */
+    processEvent(event: ResponsesSseEvent): boolean;
+    /**
+     * 验证序列号
+     */
+    private validateSequenceNumber;
+    /**
+     * 处理response.start事件
+     */
+    private handleResponseStart;
+    private handleResponseCreated;
+    private handleResponseInProgress;
+    /**
+     * 处理output_item.start事件
+     */
+    private handleOutputItemStart;
+    private mapOutputItemAdded;
+    private mapOutputItemDone;
+    /**
+     * 处理content_part.start事件
+     */
+    private handleContentPartStart;
+    private mapContentPartAdded;
+    /**
+     * 处理content_part.delta事件
+     */
+    private handleContentPartDelta;
+    private mapOutputTextDelta;
+    /**
+     * 处理content_part.done事件
+     */
+    private handleContentPartDone;
+    private mapContentPartDone;
+    /**
+     * 处理function_call.start事件
+     */
+    private handleFunctionCallStart;
+    private coerceArgumentsChunk;
+    private shouldOverrideArguments;
+    /**
+     * 处理function_call.delta事件
+     */
+    private handleFunctionCallDelta;
+    private mapFunctionCallDelta;
+    /**
+     * 处理function_call.done事件
+     */
+    private handleFunctionCallDone;
+    private mapFunctionCallDone;
+    /**
+     * 处理reasoning.start事件
+     */
+    private handleReasoningStart;
+    /**
+     * 处理reasoning.delta事件
+     */
+    private handleReasoningDelta;
+    private handleReasoningSummaryDelta;
+    private handleReasoningSummaryDone;
+    private handleReasoningSummaryPartAdded;
+    private handleReasoningSummaryPartDone;
+    private mapReasoningDelta;
+    private mapReasoningDone;
+    /**
+     * 处理reasoning.done事件
+     */
+    private handleReasoningDone;
+    /**
+     * 处理output_item.done事件
+     */
+    private handleOutputItemDone;
+    /**
+     * 处理required_action事件
+     */
+    private handleRequiredAction;
+    /**
+     * 处理response.done事件
+     */
+    private handleResponseDone;
+    /**
+     * 处理错误事件
+     */
+    private handleError;
+    private handleResponseCompleted;
+    /**
+     * 构建输出项列表
+     */
+    private buildOutputItems;
+    /**
+     * 构建消息项并根据需要拆分reasoning
+     */
+    private buildMessageItem;
+    /**
+     * 构建函数调用项
+     */
+    private buildFunctionCallItem;
+    /**
+     * 构建推理项
+     */
+    private buildReasoningItem;
+    /**
+     * 获取构建结果
+     */
+    getResult(): {
+        success: boolean;
+        response?: ResponsesResponse;
+        error?: Error;
+    };
+    /**
+     * 获取当前状态
+     */
+    getState(): ResponseBuilderState;
+    /**
+     * 重置构建器
+     */
+    reset(): void;
+    /**
+     * 获取输出项构建器
+     */
+    getOutputItemBuilders(): Map<string, OutputItemState>;
+    /**
+     * 获取最后序列号
+     */
+    getLastSequenceNumber(): number;
+}
+/**
+ * 创建响应构建器工厂
+ */
+export declare function createResponseBuilder(config?: Partial<ResponseBuilderConfig>): ResponsesResponseBuilder;