@jsonstudio/rcc 0.90.367 → 0.90.701

package/vendor/llmswitch-core/dist/sse/json-to-sse/sequencers/anthropic-sequencer.js

@@ -1,162 +0,0 @@
-import { dispatchReasoning } from '../../shared/reasoning-dispatcher.js';
-export const DEFAULT_ANTHROPIC_SEQUENCER_CONFIG = {
-    chunkSize: 1024,
-    chunkDelayMs: 0,
-    enableDelay: false,
-    reasoningMode: 'channel',
-    reasoningTextPrefix: undefined
-};
-function createEvent(type, data) {
-    return {
-        type,
-        event: type,
-        timestamp: Date.now(),
-        protocol: 'anthropic-messages',
-        direction: 'json_to_sse',
-        data: { type, ...data }
-    };
-}
-async function maybeDelay(config) {
-    if (!config.enableDelay || !config.chunkDelayMs)
-        return;
-    await new Promise(resolve => setTimeout(resolve, config.chunkDelayMs));
-}
-function chunkText(input, size) {
-    if (!input || size <= 0)
-        return [input];
-    const chunks = [];
-    for (let i = 0; i < input.length; i += size) {
-        chunks.push(input.slice(i, i + size));
-    }
-    return chunks.length ? chunks : [''];
-}
-function normalizeToolInput(input) {
-    if (typeof input === 'string') {
-        return input;
-    }
-    try {
-        return JSON.stringify(input ?? {});
-    }
-    catch {
-        return String(input ?? '');
-    }
-}
-export function createAnthropicSequencer(config) {
-    const finalConfig = {
-        ...DEFAULT_ANTHROPIC_SEQUENCER_CONFIG,
-        ...config
-    };
-    return {
-        async *sequenceResponse(response, requestId) {
-            yield createEvent('message_start', {
-                message: {
-                    id: response.id || `msg_${requestId}`,
-                    type: 'message',
-                    role: response.role || 'assistant',
-                    model: response.model
-                }
-            });
-            let index = 0;
-            for (const block of response.content || []) {
-                if (!block || typeof block !== 'object')
-                    continue;
-                if (block.type === 'text') {
-                    yield createEvent('content_block_start', { index, content_block: { type: 'text' } });
-                    for (const chunk of chunkText(block.text ?? '', finalConfig.chunkSize)) {
-                        if (!chunk)
-                            continue;
-                        yield createEvent('content_block_delta', {
-                            index,
-                            delta: { type: 'text_delta', text: chunk }
-                        });
-                        await maybeDelay(finalConfig);
-                    }
-                    yield createEvent('content_block_stop', { index });
-                    index += 1;
-                }
-                else if (block.type === 'thinking') {
-                    const decision = dispatchReasoning(block.text, {
-                        mode: finalConfig.reasoningMode,
-                        prefix: finalConfig.reasoningTextPrefix
-                    });
-                    if (decision.appendToContent) {
-                        yield createEvent('content_block_start', { index, content_block: { type: 'text' } });
-                        for (const chunk of chunkText(decision.appendToContent, finalConfig.chunkSize)) {
-                            if (!chunk)
-                                continue;
-                            yield createEvent('content_block_delta', {
-                                index,
-                                delta: { type: 'text_delta', text: chunk }
-                            });
-                            await maybeDelay(finalConfig);
-                        }
-                        yield createEvent('content_block_stop', { index });
-                        index += 1;
-                    }
-                    if (decision.channel) {
-                        yield createEvent('content_block_start', { index, content_block: { type: 'thinking' } });
-                        for (const chunk of chunkText(decision.channel, finalConfig.chunkSize)) {
-                            if (!chunk)
-                                continue;
-                            yield createEvent('content_block_delta', {
-                                index,
-                                delta: { type: 'thinking_delta', text: chunk }
-                            });
-                            await maybeDelay(finalConfig);
-                        }
-                        yield createEvent('content_block_stop', { index });
-                        index += 1;
-                    }
-                }
-                else if (block.type === 'redacted_thinking') {
-                    const data = typeof block.data === 'string' ? block.data : '';
-                    if (!data.trim().length) {
-                        continue;
-                    }
-                    yield createEvent('content_block_start', {
-                        index,
-                        content_block: { type: 'redacted_thinking', data }
-                    });
-                    yield createEvent('content_block_stop', { index });
-                    index += 1;
-                }
-                else if (block.type === 'tool_use') {
-                    const id = block.id || `call_${requestId}_${index}`;
-                    yield createEvent('content_block_start', {
-                        index,
-                        content_block: { type: 'tool_use', id, name: block.name, input: block.input }
-                    });
-                    const payload = normalizeToolInput(block.input ?? {});
-                    if (payload) {
-                        yield createEvent('content_block_delta', {
-                            index,
-                            delta: { type: 'input_json_delta', partial_json: payload }
-                        });
-                    }
-                    yield createEvent('content_block_stop', { index });
-                    index += 1;
-                }
-                else if (block.type === 'tool_result') {
-                    yield createEvent('content_block_start', {
-                        index,
-                        content_block: {
-                            type: 'tool_result',
-                            tool_use_id: block.tool_use_id,
-                            content: block.content,
-                            is_error: block.is_error
-                        }
-                    });
-                    yield createEvent('content_block_stop', { index });
-                    index += 1;
-                }
-            }
-            yield createEvent('message_delta', {
-                delta: {
-                    stop_reason: response.stop_reason ?? 'end_turn',
-                    usage: response.usage
-                }
-            });
-            yield createEvent('message_stop', {});
-        }
-    };
-}

package/vendor/llmswitch-core/dist/sse/json-to-sse/sequencers/chat-sequencer.d.ts

@@ -1,39 +0,0 @@
-/**
- * Chat协议事件编排器
- * 负责严格的事件时序组合：role → content OR tool_calls(name → args.delta*) → finish_reason → done
- */
-import type { ChatCompletionResponse, ChatReasoningMode, ChatSseEvent } from '../../types/index.js';
-import type { ChatEventGeneratorContext, ChatEventGeneratorConfig } from '../event-generators/chat.js';
-export interface ChatSequencerConfig extends ChatEventGeneratorConfig {
-    includeSequenceNumbers: boolean;
-    enableDelay: boolean;
-    validateOrder: boolean;
-    reasoningMode?: ChatReasoningMode;
-    reasoningTextPrefix?: string;
-}
-export declare const DEFAULT_CHAT_SEQUENCER_CONFIG: ChatSequencerConfig;
-/**
- * 主编排器：将Chat响应转换为有序的SSE事件流
- */
-export declare function sequenceChatResponse(response: ChatCompletionResponse, context: ChatEventGeneratorContext, config?: ChatSequencerConfig): AsyncGenerator<ChatSseEvent>;
-/**
- * 序列化Chat请求（用于请求→SSE转换）
- */
-export declare function sequenceChatRequest(request: any, context: ChatEventGeneratorContext, config?: ChatSequencerConfig): AsyncGenerator<ChatSseEvent>;
-/**
- * 创建Chat事件序列化器工厂
- */
-export declare function createChatSequencer(config?: Partial<ChatSequencerConfig>): {
-    /**
-     * 序列化响应
-     */
-    sequenceResponse(response: ChatCompletionResponse, model: string, requestId: string): AsyncGenerator<ChatSseEvent, void, any>;
-    /**
-     * 序列化请求
-     */
-    sequenceRequest(request: any, model: string, requestId: string): AsyncGenerator<ChatSseEvent, void, any>;
-    /**
-     * 获取当前配置
-     */
-    getConfig(): ChatSequencerConfig;
-};

package/vendor/llmswitch-core/dist/sse/json-to-sse/sequencers/chat-sequencer.js

@@ -1,264 +0,0 @@
-/**
- * Chat协议事件编排器
- * 负责严格的事件时序组合：role → content OR tool_calls(name → args.delta*) → finish_reason → done
- */
-import { buildRoleDelta, buildReasoningDeltas, buildContentDeltas, buildToolCallStart, buildToolCallArgsDeltas, buildFinishEvent, buildDoneEvent, buildErrorEvent, DEFAULT_CHAT_EVENT_GENERATOR_CONFIG, createDefaultContext } from '../event-generators/chat.js';
-import { normalizeMessageReasoningTools } from '../../../conversion/shared/reasoning-tool-normalizer.js';
-import { normalizeChatMessageContent } from '../../../conversion/shared/chat-output-normalizer.js';
-import { dispatchReasoning } from '../../shared/reasoning-dispatcher.js';
-// 默认配置
-export const DEFAULT_CHAT_SEQUENCER_CONFIG = {
-    ...DEFAULT_CHAT_EVENT_GENERATOR_CONFIG,
-    includeSequenceNumbers: true,
-    enableDelay: false,
-    validateOrder: true,
-    reasoningMode: 'channel'
-};
-/**
- * 验证消息顺序的合法性
- */
-function validateMessageSequence(message, previousMessage) {
-    // 基本字段
-    if (!message || typeof message.role !== 'string')
-        return false;
-    // 允许两种有效形态：
-    // 1) content 存在（字符串/数组/对象）
-    // 2) 仅工具调用（content 为空，但存在 tool_calls[] 且 finish_reason=tool_calls）
-    const hasContent = hasMeaningfulContent(message.content);
-    const hasToolCalls = Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
-    if (!hasContent && !hasToolCalls)
-        return false;
-    // 不允许 assistant 之后出现 user 倒序
-    if (previousMessage?.role === 'assistant' && message.role === 'user')
-        return false;
-    return true;
-}
-function hasMeaningfulContent(content) {
-    if (content == null)
-        return false;
-    if (typeof content === 'string')
-        return content.trim().length > 0;
-    if (Array.isArray(content))
-        return content.length > 0;
-    if (typeof content === 'object')
-        return Object.keys(content).length > 0;
-    return false;
-}
-function appendReasoningToContent(message, reasoningText, prefix) {
-    const trimmed = reasoningText.trim();
-    if (!trimmed) {
-        return;
-    }
-    const normalizedPrefix = typeof prefix === 'string' && prefix.length ? prefix : '';
-    const formatted = normalizedPrefix ? `${normalizedPrefix}${normalizedPrefix.endsWith(' ') || normalizedPrefix.endsWith('\n') ? '' : ' '}${trimmed}` : trimmed;
-    const current = message.content;
-    if (typeof current === 'string' || current == null) {
-        message.content = typeof current === 'string' && current.length
-            ? `${current}${current.endsWith('\n') ? '' : '\n\n'}${formatted}`
-            : formatted;
-        return;
-    }
-    if (Array.isArray(current)) {
-        current.push({ type: 'text', text: formatted });
-        return;
-    }
-    message.content = [current, { type: 'text', text: formatted }];
-}
-/**
- * 异步生成器：为事件添加序列号和延迟
- */
-async function* withSequencing(events, config, startSequence = 0) {
-    let sequenceNumber = startSequence;
-    for await (const event of events) {
-        if (config.includeSequenceNumbers)
-            event.sequenceNumber = sequenceNumber++;
-        yield event;
-        if (config.enableDelay && config.chunkDelayMs > 0) {
-            await new Promise(resolve => setTimeout(resolve, config.chunkDelayMs));
-        }
-    }
-}
-/**
- * 序列化单个消息的内容和工具调用
- */
-async function* sequenceMessageContent(message, context, config) {
-    // 1. 发送role delta
-    for (const roleEvent of buildRoleDelta(message.role, context, config)) {
-        yield roleEvent;
-    }
-    const contentNormalization = normalizeChatMessageContent(message.content);
-    if (contentNormalization.contentText !== undefined) {
-        message.content = contentNormalization.contentText;
-    }
-    const normalization = normalizeMessageReasoningTools(message, {
-        idPrefix: `chat_seq_reasoning_${context.choiceIndex + 1}`
-    });
-    const reasoningText = normalization.cleanedReasoning
-        ?? contentNormalization.reasoningText
-        ?? (typeof message?.reasoning_content === 'string'
-            ? message.reasoning_content
-            : typeof message?.reasoning === 'string'
-                ? message.reasoning
-                : undefined);
-    const reasoningDispatch = dispatchReasoning(reasoningText, {
-        mode: config.reasoningMode,
-        prefix: config.reasoningTextPrefix
-    });
-    if (reasoningDispatch.appendToContent) {
-        appendReasoningToContent(message, reasoningDispatch.appendToContent);
-    }
-    const reasoningForChannel = reasoningDispatch.channel;
-    // 2. 处理reasoning（如果有）
-    if (reasoningForChannel) {
-        yield* withSequencing(buildReasoningDeltas(reasoningForChannel, context, config), config);
-    }
-    // 3. 处理content和tool_calls
-    if (hasMeaningfulContent(message.content)) {
-        yield* withSequencing(buildContentDeltas(message.content, context, config), config);
-    }
-    if (message.tool_calls && message.tool_calls.length > 0) {
-        for (let i = 0; i < message.tool_calls.length; i++) {
-            const toolCall = message.tool_calls[i];
-            const toolCallIndex = context.toolCallIndexCounter + i;
-            yield buildToolCallStart(toolCall, toolCallIndex, context, config);
-            if (toolCall.function?.arguments) {
-                yield* withSequencing(buildToolCallArgsDeltas(toolCall.function.arguments, toolCallIndex, context, config), config);
-            }
-        }
-    }
-}
-/**
- * 主编排器：将Chat响应转换为有序的SSE事件流
- */
-export async function* sequenceChatResponse(response, context, config = DEFAULT_CHAT_SEQUENCER_CONFIG) {
-    try {
-        // 验证响应格式
-        if (!response.choices || response.choices.length === 0) {
-            throw new Error('Invalid ChatCompletionResponse: missing choices');
-        }
-        const choice = response.choices[0];
-        let message = choice?.message;
-        // 兼容上游给到的 chunk 形态（choices[0].delta）
-        if (!message && choice && typeof choice === 'object' && choice.delta) {
-            const d = choice.delta;
-            message = {
-                role: typeof d.role === 'string' ? d.role : 'assistant',
-                content: typeof d.content !== 'undefined' ? d.content : null,
-                tool_calls: Array.isArray(d.tool_calls) ? d.tool_calls : undefined
-            };
-            // 为了下游 finish 事件合理性，缺省 finish_reason：若存在工具调用则用 tool_calls，否则 stop
-            if (!('finish_reason' in choice)) {
-                choice.finish_reason = message.tool_calls ? 'tool_calls' : 'stop';
-            }
-        }
-        message = normalizeFunctionCall(message);
-        // 验证消息顺序（如果启用）
-        if (config.validateOrder) {
-            // 这里可以添加更多的顺序验证逻辑
-            if (!validateMessageSequence(message)) {
-                const roleSafe = message && typeof message.role === 'string' ? message.role : 'unknown';
-                throw new Error(`Invalid message sequence for role: ${roleSafe}`);
-            }
-        }
-        // 序列化消息内容
-        yield* sequenceMessageContent(message, context, config);
-        // 发送finish_reason事件（若未提供则根据消息推断）
-        yield buildFinishEvent(choice.finish_reason || (message?.tool_calls ? 'tool_calls' : 'stop'), context, config);
-        // 发送done事件
-        yield buildDoneEvent(context, config);
-    }
-    catch (error) {
-        // 发送错误事件
-        yield buildErrorEvent(error, context, config);
-    }
-}
-function normalizeFunctionCall(message) {
-    if (!message || typeof message !== 'object')
-        return message;
-    if ((message.tool_calls && message.tool_calls.length) || !message.function_call) {
-        return message;
-    }
-    const fc = message.function_call;
-    const name = typeof fc?.name === 'string' ? fc.name : 'function';
-    let args = '';
-    if (typeof fc?.arguments === 'string') {
-        args = fc.arguments;
-    }
-    else {
-        try {
-            args = JSON.stringify(fc?.arguments ?? {});
-        }
-        catch {
-            args = '{}';
-        }
-    }
-    message.tool_calls = [
-        {
-            id: typeof fc?.id === 'string' ? fc.id : `call_${Math.random().toString(36).slice(2, 10)}`,
-            type: 'function',
-            function: { name, arguments: args }
-        }
-    ];
-    return message;
-}
-/**
- * 序列化Chat请求（用于请求→SSE转换）
- */
-export async function* sequenceChatRequest(request, context, config = DEFAULT_CHAT_SEQUENCER_CONFIG) {
-    try {
-        // 验证请求格式
-        if (!request.messages || !Array.isArray(request.messages)) {
-            throw new Error('Invalid ChatCompletionRequest: missing messages');
-        }
-        // 为每个消息生成事件（主要用于流式回显）
-        for (let messageIndex = 0; messageIndex < request.messages.length; messageIndex++) {
-            const message = request.messages[messageIndex];
-            // 为每条消息创建新的上下文
-            const messageContext = {
-                ...context,
-                choiceIndex: messageIndex,
-                toolCallIndexCounter: 0,
-                contentIndexCounter: new Map()
-            };
-            // 序列化消息
-            yield* sequenceMessageContent(message, messageContext, config);
-            // 消息间添加小延迟（如果启用）
-            if (config.enableDelay && config.chunkDelayMs > 0 && messageIndex < request.messages.length - 1) {
-                await new Promise(resolve => setTimeout(resolve, config.chunkDelayMs * 2));
-            }
-        }
-        // 请求结束时发送done事件
-        yield buildDoneEvent(context, config);
-    }
-    catch (error) {
-        yield buildErrorEvent(error, context, config);
-    }
-}
-/**
- * 创建Chat事件序列化器工厂
- */
-export function createChatSequencer(config) {
-    const finalConfig = { ...DEFAULT_CHAT_SEQUENCER_CONFIG, ...config };
-    return {
-        /**
-         * 序列化响应
-         */
-        async *sequenceResponse(response, model, requestId) {
-            const context = createDefaultContext(model, requestId);
-            yield* sequenceChatResponse(response, context, finalConfig);
-        },
-        /**
-         * 序列化请求
-         */
-        async *sequenceRequest(request, model, requestId) {
-            const context = createDefaultContext(model, requestId);
-            yield* sequenceChatRequest(request, context, finalConfig);
-        },
-        /**
-         * 获取当前配置
-         */
-        getConfig() {
-            return { ...finalConfig };
-        }
-    };
-}

package/vendor/llmswitch-core/dist/sse/json-to-sse/sequencers/gemini-sequencer.d.ts

@@ -1,10 +0,0 @@
-import type { GeminiResponse, GeminiSseEvent } from '../../types/index.js';
-import type { ChatReasoningMode } from '../../types/chat-types.js';
-export interface GeminiSequencerConfig {
-    chunkDelayMs: number;
-    reasoningMode?: ChatReasoningMode;
-    reasoningTextPrefix?: string;
-}
-export declare function createGeminiSequencer(config?: Partial<GeminiSequencerConfig>): {
-    sequenceResponse(response: GeminiResponse): AsyncGenerator<GeminiSseEvent>;
-};

package/vendor/llmswitch-core/dist/sse/json-to-sse/sequencers/gemini-sequencer.js

@@ -1,95 +0,0 @@
-import { dispatchReasoning } from '../../shared/reasoning-dispatcher.js';
-const DEFAULT_CONFIG = {
-    chunkDelayMs: 0,
-    reasoningMode: 'channel',
-    reasoningTextPrefix: undefined
-};
-function createEvent(type, data) {
-    return {
-        type,
-        event: type,
-        protocol: 'gemini-chat',
-        direction: 'json_to_sse',
-        timestamp: Date.now(),
-        data,
-        sequenceNumber: 0
-    };
-}
-async function maybeDelay(config) {
-    if (!config.chunkDelayMs)
-        return;
-    await new Promise((resolve) => setTimeout(resolve, config.chunkDelayMs));
-}
-function getCandidateRole(candidate, fallback = 'model') {
-    const role = candidate?.content?.role;
-    if (typeof role === 'string' && role.trim().length) {
-        return role;
-    }
-    return fallback;
-}
-function getCandidateParts(candidate) {
-    const parts = candidate?.content?.parts;
-    if (Array.isArray(parts)) {
-        return parts.filter((part) => Boolean(part));
-    }
-    return [];
-}
-export function createGeminiSequencer(config) {
-    const finalConfig = { ...DEFAULT_CONFIG, ...config };
-    return {
-        async *sequenceResponse(response) {
-            const candidates = Array.isArray(response.candidates) ? response.candidates : [];
-            for (let candidateIndex = 0; candidateIndex < candidates.length; candidateIndex += 1) {
-                const candidate = candidates[candidateIndex] || {};
-                const role = getCandidateRole(candidate);
-                const parts = getCandidateParts(candidate);
-                for (let partIndex = 0; partIndex < parts.length; partIndex += 1) {
-                    const normalizedParts = normalizeReasoningPart(parts[partIndex], finalConfig);
-                    for (const normalizedPart of normalizedParts) {
-                        yield createEvent('gemini.data', {
-                            kind: 'part',
-                            candidateIndex,
-                            partIndex,
-                            role,
-                            part: normalizedPart
-                        });
-                        await maybeDelay(finalConfig);
-                    }
-                }
-            }
-            const doneData = {
-                kind: 'done',
-                usageMetadata: response.usageMetadata,
-                promptFeedback: response.promptFeedback,
-                modelVersion: response.modelVersion,
-                candidates: candidates.map((candidate, index) => ({
-                    index,
-                    finishReason: candidate?.finishReason,
-                    safetyRatings: candidate?.safetyRatings
-                }))
-            };
-            yield createEvent('gemini.done', doneData);
-        }
-    };
-}
-function normalizeReasoningPart(part, config) {
-    if (!part || typeof part !== 'object') {
-        return [part];
-    }
-    const reasoning = typeof part.reasoning === 'string' ? part.reasoning : undefined;
-    if (!reasoning) {
-        return [part];
-    }
-    const decision = dispatchReasoning(reasoning, {
-        mode: config.reasoningMode,
-        prefix: config.reasoningTextPrefix
-    });
-    const normalized = [];
-    if (decision.appendToContent) {
-        normalized.push({ text: decision.appendToContent });
-    }
-    if (decision.channel) {
-        normalized.push({ reasoning: decision.channel });
-    }
-    return normalized;
-}

package/vendor/llmswitch-core/dist/sse/json-to-sse/sequencers/responses-sequencer.d.ts

@@ -1,40 +0,0 @@
-/**
- * Responses协议事件编排器
- * 负责将Responses响应数据转换为有序的SSE事件流
- */
-import type { ResponsesResponse, ResponsesFunctionCallOutputItem, ResponsesSseEvent } from '../../types/index.js';
-import type { ResponsesEventGeneratorContext, ResponsesEventGeneratorConfig } from '../event-generators/responses.js';
-export interface ResponsesSequencerConfig extends ResponsesEventGeneratorConfig {
-    enableValidation: boolean;
-    enableRecovery: boolean;
-    enableDelay: boolean;
-    maxOutputItems: number;
-    maxContentParts: number;
-    submittedToolOutputs?: ResponsesFunctionCallOutputItem[];
-}
-export declare const DEFAULT_RESPONSES_SEQUENCER_CONFIG: ResponsesSequencerConfig;
-/**
- * 主编排器：将Responses响应转换为有序的SSE事件流
- */
-export declare function sequenceResponse(response: ResponsesResponse, context: ResponsesEventGeneratorContext, config?: ResponsesSequencerConfig): AsyncGenerator<ResponsesSseEvent>;
-/**
- * 序列化Responses请求（用于请求→SSE转换）
- */
-export declare function sequenceRequest(request: any, context: ResponsesEventGeneratorContext, config?: ResponsesSequencerConfig): AsyncGenerator<ResponsesSseEvent>;
-/**
- * 创建Responses事件序列化器工厂
- */
-export declare function createResponsesSequencer(config?: Partial<ResponsesSequencerConfig>): {
-    /**
-     * 序列化响应
-     */
-    sequenceResponse(response: ResponsesResponse, requestId: string): AsyncGenerator<ResponsesSseEvent, void, any>;
-    /**
-     * 序列化请求
-     */
-    sequenceRequest(request: any, requestId: string): AsyncGenerator<ResponsesSseEvent, void, any>;
-    /**
-     * 获取当前配置
-     */
-    getConfig(): ResponsesSequencerConfig;
-};