@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/sse/shared/writer.js

@@ -0,0 +1,321 @@
+/**
+ * 统一的SSE事件流写入器
+ * 处理backpressure、超时、心跳、错误处理等通用流管理逻辑
+ */
+import { defaultResponsesEventSerializer, serializeAnthropicEventToSSE, serializeGeminiEventToSSE } from './serializers/index.js';
+import { TimeUtils } from './utils.js';
+import { serializeChatEventToSSE } from './chat-serializer.js';
+/**
+ * 统一的SSE流写入器
+ */
+export class StreamWriter {
+    stream;
+    config;
+    stats;
+    heartbeatInterval;
+    isActive = true;
+    writeQueue = [];
+    isWriting = false;
+    constructor(stream, config = {}) {
+        this.stream = stream;
+        this.config = {
+            timeoutMs: config.timeoutMs || 30000,
+            enableHeartbeat: config.enableHeartbeat ?? false,
+            heartbeatIntervalMs: config.heartbeatIntervalMs || 15000,
+            maxBufferSize: config.maxBufferSize || 1000,
+            enableBackpressure: config.enableBackpressure ?? true,
+            onEvent: config.onEvent || (() => { }),
+            onError: config.onError || (() => { }),
+            onComplete: config.onComplete || (() => { })
+        };
+        this.stats = {
+            totalEvents: 0,
+            bytesWritten: 0,
+            startTime: TimeUtils.now(),
+            lastWriteTime: 0,
+            errors: 0
+        };
+        this.setupHeartbeat();
+        this.setupErrorHandling();
+    }
+    /**
+     * 设置心跳
+     */
+    setupHeartbeat() {
+        if (!this.config.enableHeartbeat)
+            return;
+        this.heartbeatInterval = setInterval(() => {
+            if (this.isActive) {
+                this.sendHeartbeat();
+            }
+        }, this.config.heartbeatIntervalMs);
+    }
+    /**
+     * 设置错误处理
+     */
+    setupErrorHandling() {
+        this.stream.on('error', (error) => {
+            this.stats.errors++;
+            this.config.onError(error);
+        });
+        this.stream.on('close', () => {
+            this.cleanup();
+            this.config.onComplete();
+        });
+    }
+    /**
+     * 发送心跳事件
+     */
+    sendHeartbeat() {
+        const heartbeatEvent = {
+            type: 'heartbeat',
+            timestamp: TimeUtils.now(),
+            data: '',
+            sequenceNumber: -1
+        };
+        this.writeEvent(heartbeatEvent);
+    }
+    /**
+     * 写入单个事件
+     */
+    async writeEvent(event) {
+        if (!this.isActive)
+            return;
+        try {
+            // 触发事件回调
+            this.config.onEvent(event);
+            // 序列化事件 - 使用协议标识进行类型识别
+            let serialized;
+            if (event && event.protocol === 'chat') {
+                serialized = serializeChatEventToSSE(event);
+            }
+            else if (event && event.protocol === 'responses') {
+                serialized = this.serializeResponsesEvent(event);
+            }
+            else if (event && event.protocol === 'anthropic-messages') {
+                serialized = serializeAnthropicEventToSSE(event);
+            }
+            else if (event && event.protocol === 'gemini-chat') {
+                serialized = serializeGeminiEventToSSE(event);
+            }
+            else {
+                // 兜底处理：尝试通过事件字段识别
+                const eventField = event.event;
+                if (eventField === 'chat_chunk' || eventField === 'chat.done' || eventField === 'error' || eventField === 'ping') {
+                    serialized = serializeChatEventToSSE(event);
+                }
+                else if (eventField === 'message_start' || eventField === 'content_block_start') {
+                    serialized = serializeAnthropicEventToSSE(event);
+                }
+                else if (eventField === 'gemini.data' || eventField === 'gemini.done') {
+                    serialized = serializeGeminiEventToSSE(event);
+                }
+                else {
+                    serialized = this.serializeResponsesEvent(event);
+                }
+            }
+            const needsBackpressure = this.config.enableBackpressure && !this.stream.write(serialized);
+            if (needsBackpressure) {
+                await this.handleBackpressure();
+            }
+            // 更新统计
+            this.stats.totalEvents++;
+            this.stats.bytesWritten += Buffer.byteLength(serialized, 'utf8');
+            this.stats.lastWriteTime = TimeUtils.now();
+        }
+        catch (error) {
+            this.stats.errors++;
+            this.config.onError(error);
+        }
+    }
+    /**
+     * 处理背压
+     */
+    async handleBackpressure() {
+        return new Promise((resolve) => {
+            const checkDrain = () => {
+                if (this.stream.writableLength < this.config.maxBufferSize) {
+                    this.stream.removeListener('drain', checkDrain);
+                    resolve();
+                }
+            };
+            this.stream.on('drain', checkDrain);
+        });
+    }
+    /**
+     * 序列化Responses事件（临时实现，需要 ResponsesSerializer）
+     * TODO: 等Responses协议修复后，实现完整的ResponsesSerializer
+     * 当前为临时实现，仅用于避免编译错误
+     */
+    serializeResponsesEvent(event) {
+        try {
+            if (typeof event.type === 'string' && event.type.startsWith('response.')) {
+                return defaultResponsesEventSerializer.serializeToWire(event);
+            }
+        }
+        catch {
+            // ignore and fallback
+        }
+        const eventType = String(event.type ?? 'response.unknown');
+        const rawData = event.data;
+        const timestamp = typeof event.timestamp === 'number' ? event.timestamp : undefined;
+        const sequenceNumber = typeof event.sequenceNumber === 'number' ? event.sequenceNumber : undefined;
+        let wire = `event: ${eventType}\n`;
+        if (rawData === '[DONE]') {
+            wire += 'data: [DONE]\n';
+        }
+        else if (typeof rawData === 'string') {
+            wire += `data: ${rawData}\n`;
+        }
+        else {
+            const payload = rawData && typeof rawData === 'object' ? { ...rawData } : {};
+            if (!Object.prototype.hasOwnProperty.call(payload, 'type'))
+                payload.type = eventType;
+            if (sequenceNumber !== undefined && !Object.prototype.hasOwnProperty.call(payload, 'sequence_number')) {
+                payload.sequence_number = sequenceNumber;
+            }
+            wire += `data: ${JSON.stringify(payload)}\n`;
+        }
+        if (timestamp !== undefined) {
+            wire += `id: ${timestamp}\n`;
+        }
+        wire += '\n';
+        return wire;
+    }
+    /**
+     * 异步写入事件流
+     */
+    async writeEventStream(events) {
+        if (!this.isActive)
+            return;
+        try {
+            for await (const event of events) {
+                if (!this.isActive)
+                    break;
+                await this.writeEvent(event);
+            }
+        }
+        catch (error) {
+            this.stats.errors++;
+            this.config.onError(error);
+        }
+    }
+    /**
+     * 同步写入事件数组
+     */
+    async writeEvents(events) {
+        if (!this.isActive)
+            return;
+        for (const event of events) {
+            if (!this.isActive)
+                break;
+            await this.writeEvent(event);
+        }
+    }
+    /**
+     * 写入Chat事件流
+     */
+    async writeChatEvents(events) {
+        await this.writeEventStream(events);
+    }
+    /**
+     * 写入Responses事件流
+     */
+    async writeResponsesEvents(events) {
+        await this.writeEventStream(events);
+    }
+    /**
+     * 写入Anthropic事件流
+     */
+    async writeAnthropicEvents(events) {
+        await this.writeEventStream(events);
+    }
+    /**
+     * 写入Gemini事件流
+     */
+    async writeGeminiEvents(events) {
+        await this.writeEventStream(events);
+    }
+    /**
+     * 完成流写入
+     */
+    complete() {
+        if (!this.isActive)
+            return;
+        this.isActive = false;
+        // 确保所有数据都写入完成
+        if (this.stream.writable) {
+            this.stream.end();
+        }
+    }
+    /**
+     * 中止流写入
+     */
+    abort(error) {
+        if (!this.isActive)
+            return;
+        this.isActive = false;
+        if (error) {
+            this.stats.errors++;
+            this.config.onError(error);
+        }
+        if (this.stream.writable) {
+            this.stream.destroy(error);
+        }
+    }
+    /**
+     * 获取写入统计
+     */
+    getStats() {
+        return {
+            ...this.stats,
+            duration: TimeUtils.now() - this.stats.startTime
+        };
+    }
+    /**
+     * 检查流是否活跃
+     */
+    isStreamActive() {
+        return this.isActive && this.stream.writable;
+    }
+    /**
+     * 清理资源
+     */
+    cleanup() {
+        this.isActive = false;
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = undefined;
+        }
+    }
+    /**
+     * 获取底层流
+     */
+    getUnderlyingStream() {
+        return this.stream;
+    }
+}
+/**
+ * 创建Chat流写入器工厂函数
+ */
+export function createChatStreamWriter(stream, config = {}) {
+    return new StreamWriter(stream, config);
+}
+/**
+ * 创建Responses流写入器工厂函数
+ */
+export function createResponsesStreamWriter(stream, config = {}) {
+    return new StreamWriter(stream, config);
+}
+/**
+ * 创建Anthropic流写入器工厂函数
+ */
+export function createAnthropicStreamWriter(stream, config = {}) {
+    return new StreamWriter(stream, config);
+}
+/**
+ * 创建Gemini流写入器工厂函数
+ */
+export function createGeminiStreamWriter(stream, config = {}) {
+    return new StreamWriter(stream, config);
+}

package/vendor/llmswitch-core/dist/sse/sse-to-json/anthropic-sse-to-json-converter.d.ts

@@ -0,0 +1,20 @@
+import { DEFAULT_ANTHROPIC_CONVERSION_CONFIG } from '../types/index.js';
+import type { AnthropicMessageResponse, SseToAnthropicJsonOptions } from '../types/index.js';
+type AnthropicSseToJsonConverterConfig = {
+    enableEventValidation: boolean;
+    strictMode: boolean;
+} & typeof DEFAULT_ANTHROPIC_CONVERSION_CONFIG;
+export declare class AnthropicSseToJsonConverter {
+    private config;
+    private contexts;
+    constructor(config?: Partial<AnthropicSseToJsonConverterConfig>);
+    convertSseToJson(sseStream: AsyncIterable<string | Buffer>, options: SseToAnthropicJsonOptions): Promise<AnthropicMessageResponse>;
+    private isTerminatedError;
+    private createContext;
+    private chunkStrings;
+    private updateStats;
+    private attachDecodeStats;
+    private extractAnthropicErrorEventMessage;
+    private wrapError;
+}
+export {};

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

@@ -0,0 +1,204 @@
+import { DEFAULT_ANTHROPIC_CONVERSION_CONFIG } from '../types/index.js';
+import { ErrorUtils } from '../shared/utils.js';
+import { createSseParser } from './parsers/sse-parser.js';
+import { createAnthropicResponseBuilder } from './builders/anthropic-response-builder.js';
+export class AnthropicSseToJsonConverter {
+    config = {
+        enableEventValidation: true,
+        strictMode: false,
+        ...DEFAULT_ANTHROPIC_CONVERSION_CONFIG
+    };
+    contexts = new Map();
+    constructor(config) {
+        if (config) {
+            this.config = { ...this.config, ...config };
+        }
+    }
+    async convertSseToJson(sseStream, options) {
+        const context = this.createContext(options);
+        this.contexts.set(options.requestId, context);
+        const parser = createSseParser({
+            enableStrictValidation: this.config.enableEventValidation,
+            enableEventRecovery: !this.config.strictMode,
+            allowedEventTypes: new Set([
+                'message_start',
+                'content_block_start',
+                'content_block_delta',
+                'content_block_stop',
+                'message_delta',
+                'message_stop',
+                'error'
+            ])
+        });
+        const builder = createAnthropicResponseBuilder({
+            reasoningMode: options.reasoningMode ?? this.config.reasoningMode,
+            reasoningTextPrefix: options.reasoningTextPrefix ?? this.config.reasoningTextPrefix
+        });
+        try {
+            for await (const result of parser.parseStreamAsync(this.chunkStrings(sseStream, context))) {
+                if (!result.success || !result.event) {
+                    if (this.config.strictMode) {
+                        throw new Error(result.error || 'Failed to parse Anthropic SSE event');
+                    }
+                    continue;
+                }
+                context.eventStats.firstEventAtMs ??= Date.now();
+                context.eventStats.lastEventAtMs = Date.now();
+                const upstreamError = this.extractAnthropicErrorEventMessage(result.event);
+                if (upstreamError) {
+                    throw new Error(upstreamError);
+                }
+                if (result.event.protocol !== 'anthropic-messages') {
+                    continue;
+                }
+                const builderStartedAt = Date.now();
+                builder.processEvent(result.event);
+                context.eventStats.builderMs = (context.eventStats.builderMs ?? 0) + Math.max(0, Date.now() - builderStartedAt);
+                this.updateStats(context, result.event);
+            }
+            const resultStartedAt = Date.now();
+            const outcome = builder.getResult();
+            context.eventStats.builderMs = (context.eventStats.builderMs ?? 0) + Math.max(0, Date.now() - resultStartedAt);
+            if (!outcome.success || !outcome.response) {
+                throw outcome.error || new Error('Anthropic SSE conversion incomplete');
+            }
+            context.isCompleted = true;
+            context.eventStats.endTime = Date.now();
+            this.attachDecodeStats(outcome.response, context);
+            return outcome.response;
+        }
+        catch (error) {
+            context.eventStats.errors = (context.eventStats.errors ?? 0) + 1;
+            if (this.isTerminatedError(error)) {
+                try {
+                    const salvaged = builder.getResult();
+                    if (salvaged.success && salvaged.response) {
+                        context.isCompleted = true;
+                        context.eventStats.endTime = Date.now();
+                        return salvaged.response;
+                    }
+                }
+                catch {
+                    // ignore salvage failure, fall through to wrapped error
+                }
+            }
+            throw this.wrapError('ANTHROPIC_SSE_TO_JSON_FAILED', error, options.requestId);
+        }
+        finally {
+            this.contexts.delete(options.requestId);
+        }
+    }
+    isTerminatedError(error) {
+        if (!error || typeof error !== 'object') {
+            return false;
+        }
+        const message = error.message;
+        if (typeof message !== 'string') {
+            return false;
+        }
+        const normalized = message.toLowerCase();
+        return (normalized.includes('terminated') ||
+            normalized.includes('upstream_stream_idle_timeout') ||
+            normalized.includes('upstream_stream_timeout'));
+    }
+    createContext(options) {
+        return {
+            requestId: options.requestId,
+            model: options.model,
+            startTime: Date.now(),
+            eventStats: {
+                totalEvents: 0,
+                contentBlocks: 0,
+                toolUseBlocks: 0,
+                thinkingBlocks: 0,
+                textBlocks: 0,
+                errors: 0,
+                chunkCount: 0,
+                byteCount: 0,
+                parserMs: 0,
+                builderMs: 0,
+                messageStopSeen: false,
+                startTime: Date.now()
+            },
+            isCompleted: false
+        };
+    }
+    async *chunkStrings(stream, context) {
+        for await (const chunk of stream) {
+            const now = Date.now();
+            const text = typeof chunk === 'string' ? chunk : chunk.toString();
+            context.eventStats.chunkCount = (context.eventStats.chunkCount ?? 0) + 1;
+            context.eventStats.byteCount = (context.eventStats.byteCount ?? 0) + Buffer.byteLength(text);
+            context.eventStats.firstChunkAtMs ??= now;
+            context.eventStats.lastChunkAtMs = now;
+            const parserStartedAt = Date.now();
+            yield text;
+            context.eventStats.parserMs = (context.eventStats.parserMs ?? 0) + Math.max(0, Date.now() - parserStartedAt);
+        }
+    }
+    updateStats(context, event) {
+        context.eventStats.totalEvents += 1;
+        if (event.type === 'content_block_start') {
+            context.eventStats.contentBlocks += 1;
+            const blockType = event.data?.content_block?.type;
+            if (blockType === 'tool_use')
+                context.eventStats.toolUseBlocks += 1;
+            if (blockType === 'thinking' || blockType === 'redacted_thinking')
+                context.eventStats.thinkingBlocks += 1;
+            if (blockType === 'text')
+                context.eventStats.textBlocks += 1;
+        }
+        if (event.type === 'message_stop') {
+            context.eventStats.messageStopSeen = true;
+        }
+    }
+    attachDecodeStats(response, context) {
+        Object.defineProperty(response, '__rccDecodeStats', {
+            value: {
+                ...context.eventStats,
+                streamMs: context.eventStats.firstChunkAtMs !== undefined && context.eventStats.lastChunkAtMs !== undefined
+                    ? Math.max(0, context.eventStats.lastChunkAtMs - context.eventStats.firstChunkAtMs)
+                    : undefined,
+                eventSpanMs: context.eventStats.firstEventAtMs !== undefined && context.eventStats.lastEventAtMs !== undefined
+                    ? Math.max(0, context.eventStats.lastEventAtMs - context.eventStats.firstEventAtMs)
+                    : undefined
+            },
+            configurable: true,
+            enumerable: false,
+            writable: false
+        });
+    }
+    extractAnthropicErrorEventMessage(event) {
+        const node = event;
+        if (node?.type !== 'error') {
+            return null;
+        }
+        const dataNode = node.data;
+        if (typeof dataNode === 'string' && dataNode.trim()) {
+            return `Anthropic SSE error event: ${dataNode.trim()}`;
+        }
+        const nestedError = dataNode && typeof dataNode === 'object' ? dataNode.error : undefined;
+        const message = (nestedError && typeof nestedError.message === 'string' && nestedError.message.trim()) ||
+            (dataNode && typeof dataNode === 'object' && typeof dataNode.message === 'string' && dataNode.message.trim()) ||
+            'Anthropic SSE upstream returned an error event';
+        const code = (nestedError && typeof nestedError.code === 'string' && nestedError.code.trim()) ||
+            (nestedError && typeof nestedError.code === 'number' ? String(nestedError.code) : '') ||
+            (dataNode && typeof dataNode === 'object' && typeof dataNode.code === 'string' && dataNode.code.trim()) ||
+            (dataNode && typeof dataNode === 'object' && typeof dataNode.code === 'number' ? String(dataNode.code) : '');
+        const requestId = (dataNode && typeof dataNode === 'object' && typeof dataNode.request_id === 'string' && dataNode.request_id.trim()) ||
+            (dataNode && typeof dataNode === 'object' && typeof dataNode.requestId === 'string' && dataNode.requestId.trim()) ||
+            '';
+        const parts = ['Anthropic SSE error event'];
+        if (code) {
+            parts.push(`[${code}]`);
+        }
+        parts.push(message);
+        if (requestId) {
+            parts.push(`(request_id=${requestId})`);
+        }
+        return parts.join(' ');
+    }
+    wrapError(code, error, requestId) {
+        return ErrorUtils.createError(error.message, code, { requestId });
+    }
+}

package/vendor/llmswitch-core/dist/sse/sse-to-json/builders/anthropic-response-builder.d.ts

@@ -0,0 +1,16 @@
+import type { AnthropicMessageResponse, AnthropicSseEvent } from '../../types/index.js';
+import type { ChatReasoningMode } from '../../types/chat-types.js';
+interface BuilderOptions {
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
+}
+export interface AnthropicBuilderResult {
+    success: boolean;
+    response?: AnthropicMessageResponse;
+    error?: Error;
+}
+export declare function createAnthropicResponseBuilder(options?: BuilderOptions): {
+    processEvent(event: AnthropicSseEvent): boolean;
+    getResult(): AnthropicBuilderResult;
+};
+export {};