@jsonstudio/rcc 0.90.352 → 0.90.364

package/vendor/@jsonstudio/llms/dist/sse/index.d.ts

@@ -0,0 +1,176 @@
+/**
+ * SSE双向转换模块统一导出
+ * 支持Chat和Responses协议的JSON↔SSE双向转换
+ */
+import type { ChatCompletionResponse, ChatJsonToSseOptions, ResponsesJsonToSseOptions, ResponsesResponse, SseToChatJsonOptions, SseToResponsesJsonOptions } from './types/index.js';
+import type { AnthropicMessageResponse } from './types/anthropic-types.js';
+import type { GeminiResponse, GeminiJsonToSseOptions, SseToGeminiJsonOptions } from './types/gemini-types.js';
+import { ChatSseToJsonConverter as ChatSseToJsonConverterCtor } from './sse-to-json/index.js';
+import { ResponsesSseToJsonConverter as ResponsesSseToJsonConverterCtor } from './sse-to-json/index.js';
+import { AnthropicJsonToSseConverter as AnthropicJsonToSseConverterCtor } from './json-to-sse/anthropic-json-to-sse-converter.js';
+import { AnthropicSseToJsonConverter as AnthropicSseToJsonConverterCtor } from './sse-to-json/anthropic-sse-to-json-converter.js';
+import { GeminiJsonToSseConverter as GeminiJsonToSseConverterCtor } from './json-to-sse/gemini-json-to-sse-converter.js';
+import { GeminiSseToJsonConverter as GeminiSseToJsonConverterCtor } from './sse-to-json/gemini-sse-to-json-converter.js';
+export { ChatJsonToSseConverter } from './json-to-sse/index.js';
+export { ChatSseToJsonConverter } from './sse-to-json/index.js';
+export { ResponsesJsonToSseConverter } from './json-to-sse/index.js';
+export { ResponsesSseToJsonConverter } from './sse-to-json/index.js';
+export { GeminiJsonToSseConverter } from './json-to-sse/index.js';
+export { GeminiSseToJsonConverter } from './sse-to-json/index.js';
+export * from './shared/utils.js';
+export * from './types/index.js';
+/**
+ * 工厂函数：创建Chat协议转换器
+ */
+export declare function createChatConverters(): {
+    jsonToSse: import("./json-to-sse/chat-json-to-sse-converter.js").ChatJsonToSseConverterRefactored;
+    sseToJson: ChatSseToJsonConverterCtor;
+    /**
+     * 执行完整的回环测试
+     */
+    roundTrip(input: ChatCompletionResponse, options: ChatJsonToSseOptions & SseToChatJsonOptions): Promise<ChatCompletionResponse>;
+};
+/**
+ * 工厂函数：创建Responses协议转换器
+ */
+export declare function createResponsesConverters(): {
+    jsonToSse: import("./json-to-sse/responses-json-to-sse-converter.js").ResponsesJsonToSseConverterRefactored;
+    sseToJson: ResponsesSseToJsonConverterCtor;
+    /**
+     * 执行完整的回环测试
+     */
+    roundTrip(input: ResponsesResponse, options: ResponsesJsonToSseOptions & SseToResponsesJsonOptions): Promise<ResponsesResponse>;
+};
+/**
+ * 工厂函数：创建Anthropic协议转换器
+ */
+export declare function createAnthropicConverters(): {
+    jsonToSse: AnthropicJsonToSseConverterCtor;
+    sseToJson: AnthropicSseToJsonConverterCtor;
+    roundTrip(input: AnthropicMessageResponse, options: {
+        requestId: string;
+        model: string;
+        reasoningMode?: import("./types/chat-types.js").ChatReasoningMode;
+        reasoningTextPrefix?: string;
+    }): Promise<AnthropicMessageResponse>;
+};
+/**
+ * 工厂函数：创建Gemini协议转换器
+ */
+export declare function createGeminiConverters(): {
+    jsonToSse: GeminiJsonToSseConverterCtor;
+    sseToJson: GeminiSseToJsonConverterCtor;
+    roundTrip(input: GeminiResponse, options: GeminiJsonToSseOptions & SseToGeminiJsonOptions): Promise<GeminiResponse>;
+};
+/**
+ * 工厂函数：创建完整的双向转换器（支持Chat和Responses协议）
+ */
+export declare function createBidirectionalConverters(): {
+    chat: {
+        jsonToSse: import("./json-to-sse/chat-json-to-sse-converter.js").ChatJsonToSseConverterRefactored;
+        sseToJson: ChatSseToJsonConverterCtor;
+        /**
+         * 执行完整的回环测试
+         */
+        roundTrip(input: ChatCompletionResponse, options: ChatJsonToSseOptions & SseToChatJsonOptions): Promise<ChatCompletionResponse>;
+    };
+    responses: {
+        jsonToSse: import("./json-to-sse/responses-json-to-sse-converter.js").ResponsesJsonToSseConverterRefactored;
+        sseToJson: ResponsesSseToJsonConverterCtor;
+        /**
+         * 执行完整的回环测试
+         */
+        roundTrip(input: ResponsesResponse, options: ResponsesJsonToSseOptions & SseToResponsesJsonOptions): Promise<ResponsesResponse>;
+    };
+    anthropic: {
+        jsonToSse: AnthropicJsonToSseConverterCtor;
+        sseToJson: AnthropicSseToJsonConverterCtor;
+        roundTrip(input: AnthropicMessageResponse, options: {
+            requestId: string;
+            model: string;
+            reasoningMode?: import("./types/chat-types.js").ChatReasoningMode;
+            reasoningTextPrefix?: string;
+        }): Promise<AnthropicMessageResponse>;
+    };
+    gemini: {
+        jsonToSse: GeminiJsonToSseConverterCtor;
+        sseToJson: GeminiSseToJsonConverterCtor;
+        roundTrip(input: GeminiResponse, options: GeminiJsonToSseOptions & SseToGeminiJsonOptions): Promise<GeminiResponse>;
+    };
+    /**
+     * 自动检测协议类型并执行转换
+     */
+    autoConvert(input: any, options?: any): Promise<ChatCompletionResponse | ResponsesResponse | AnthropicMessageResponse | GeminiResponse>;
+};
+/**
+ * 默认转换器实例
+ */
+export declare const chatConverters: {
+    jsonToSse: import("./json-to-sse/chat-json-to-sse-converter.js").ChatJsonToSseConverterRefactored;
+    sseToJson: ChatSseToJsonConverterCtor;
+    /**
+     * 执行完整的回环测试
+     */
+    roundTrip(input: ChatCompletionResponse, options: ChatJsonToSseOptions & SseToChatJsonOptions): Promise<ChatCompletionResponse>;
+};
+export declare const responsesConverters: {
+    jsonToSse: import("./json-to-sse/responses-json-to-sse-converter.js").ResponsesJsonToSseConverterRefactored;
+    sseToJson: ResponsesSseToJsonConverterCtor;
+    /**
+     * 执行完整的回环测试
+     */
+    roundTrip(input: ResponsesResponse, options: ResponsesJsonToSseOptions & SseToResponsesJsonOptions): Promise<ResponsesResponse>;
+};
+export declare const bidirectionalConverters: {
+    chat: {
+        jsonToSse: import("./json-to-sse/chat-json-to-sse-converter.js").ChatJsonToSseConverterRefactored;
+        sseToJson: ChatSseToJsonConverterCtor;
+        /**
+         * 执行完整的回环测试
+         */
+        roundTrip(input: ChatCompletionResponse, options: ChatJsonToSseOptions & SseToChatJsonOptions): Promise<ChatCompletionResponse>;
+    };
+    responses: {
+        jsonToSse: import("./json-to-sse/responses-json-to-sse-converter.js").ResponsesJsonToSseConverterRefactored;
+        sseToJson: ResponsesSseToJsonConverterCtor;
+        /**
+         * 执行完整的回环测试
+         */
+        roundTrip(input: ResponsesResponse, options: ResponsesJsonToSseOptions & SseToResponsesJsonOptions): Promise<ResponsesResponse>;
+    };
+    anthropic: {
+        jsonToSse: AnthropicJsonToSseConverterCtor;
+        sseToJson: AnthropicSseToJsonConverterCtor;
+        roundTrip(input: AnthropicMessageResponse, options: {
+            requestId: string;
+            model: string;
+            reasoningMode?: import("./types/chat-types.js").ChatReasoningMode;
+            reasoningTextPrefix?: string;
+        }): Promise<AnthropicMessageResponse>;
+    };
+    gemini: {
+        jsonToSse: GeminiJsonToSseConverterCtor;
+        sseToJson: GeminiSseToJsonConverterCtor;
+        roundTrip(input: GeminiResponse, options: GeminiJsonToSseOptions & SseToGeminiJsonOptions): Promise<GeminiResponse>;
+    };
+    /**
+     * 自动检测协议类型并执行转换
+     */
+    autoConvert(input: any, options?: any): Promise<ChatCompletionResponse | ResponsesResponse | AnthropicMessageResponse | GeminiResponse>;
+};
+export declare const anthropicConverters: {
+    jsonToSse: AnthropicJsonToSseConverterCtor;
+    sseToJson: AnthropicSseToJsonConverterCtor;
+    roundTrip(input: AnthropicMessageResponse, options: {
+        requestId: string;
+        model: string;
+        reasoningMode?: import("./types/chat-types.js").ChatReasoningMode;
+        reasoningTextPrefix?: string;
+    }): Promise<AnthropicMessageResponse>;
+};
+export declare const geminiConverters: {
+    jsonToSse: GeminiJsonToSseConverterCtor;
+    sseToJson: GeminiSseToJsonConverterCtor;
+    roundTrip(input: GeminiResponse, options: GeminiJsonToSseOptions & SseToGeminiJsonOptions): Promise<GeminiResponse>;
+};
+export { defaultSseCodecRegistry, SseCodecRegistry, type SseCodec, type SseProtocol, type JsonToSseContext, type SseToJsonContext, type NormalizeSseContext } from './registry/sse-codec-registry.js';

package/vendor/@jsonstudio/llms/dist/sse/index.js

@@ -0,0 +1,142 @@
+/**
+ * SSE双向转换模块统一导出
+ * 支持Chat和Responses协议的JSON↔SSE双向转换
+ */
+import { ChatJsonToSseConverter as ChatJsonToSseConverterCtor } from './json-to-sse/index.js';
+import { ChatSseToJsonConverter as ChatSseToJsonConverterCtor } from './sse-to-json/index.js';
+import { ResponsesJsonToSseConverter as ResponsesJsonToSseConverterCtor } from './json-to-sse/index.js';
+import { ResponsesSseToJsonConverter as ResponsesSseToJsonConverterCtor } from './sse-to-json/index.js';
+import { AnthropicJsonToSseConverter as AnthropicJsonToSseConverterCtor } from './json-to-sse/anthropic-json-to-sse-converter.js';
+import { AnthropicSseToJsonConverter as AnthropicSseToJsonConverterCtor } from './sse-to-json/anthropic-sse-to-json-converter.js';
+import { GeminiJsonToSseConverter as GeminiJsonToSseConverterCtor } from './json-to-sse/gemini-json-to-sse-converter.js';
+import { GeminiSseToJsonConverter as GeminiSseToJsonConverterCtor } from './sse-to-json/gemini-sse-to-json-converter.js';
+// Chat协议转换器
+export { ChatJsonToSseConverter } from './json-to-sse/index.js';
+export { ChatSseToJsonConverter } from './sse-to-json/index.js';
+// Responses协议转换器
+export { ResponsesJsonToSseConverter } from './json-to-sse/index.js';
+export { ResponsesSseToJsonConverter } from './sse-to-json/index.js';
+// Gemini协议转换器
+export { GeminiJsonToSseConverter } from './json-to-sse/index.js';
+export { GeminiSseToJsonConverter } from './sse-to-json/index.js';
+// 共享工具导出
+export * from './shared/utils.js';
+// 序列化器暂时禁用以专注核心SSE转换功能
+// export * from './shared/serializers/index.js';
+// 类型导出
+export * from './types/index.js';
+/**
+ * 工厂函数：创建Chat协议转换器
+ */
+export function createChatConverters() {
+    const jsonToSse = new ChatJsonToSseConverterCtor();
+    const sseToJson = new ChatSseToJsonConverterCtor();
+    return {
+        jsonToSse,
+        sseToJson,
+        /**
+         * 执行完整的回环测试
+         */
+        async roundTrip(input, options) {
+            const sseStream = await jsonToSse.convertResponseToJsonToSse(input, options);
+            const result = await sseToJson.convertSseToJson(sseStream, options);
+            return result;
+        }
+    };
+}
+/**
+ * 工厂函数：创建Responses协议转换器
+ */
+export function createResponsesConverters() {
+    const jsonToSse = new ResponsesJsonToSseConverterCtor();
+    const sseToJson = new ResponsesSseToJsonConverterCtor();
+    return {
+        jsonToSse,
+        sseToJson,
+        /**
+         * 执行完整的回环测试
+         */
+        async roundTrip(input, options) {
+            const sseStream = await jsonToSse.convertResponseToJsonToSse(input, options);
+            const result = await sseToJson.convertSseToJson(sseStream, options);
+            return result;
+        }
+    };
+}
+/**
+ * 工厂函数：创建Anthropic协议转换器
+ */
+export function createAnthropicConverters() {
+    const jsonToSse = new AnthropicJsonToSseConverterCtor();
+    const sseToJson = new AnthropicSseToJsonConverterCtor();
+    return {
+        jsonToSse,
+        sseToJson,
+        async roundTrip(input, options) {
+            const sseStream = await jsonToSse.convertResponseToJsonToSse(input, options);
+            const result = await sseToJson.convertSseToJson(sseStream, options);
+            return result;
+        }
+    };
+}
+/**
+ * 工厂函数：创建Gemini协议转换器
+ */
+export function createGeminiConverters() {
+    const jsonToSse = new GeminiJsonToSseConverterCtor();
+    const sseToJson = new GeminiSseToJsonConverterCtor();
+    return {
+        jsonToSse,
+        sseToJson,
+        async roundTrip(input, options) {
+            const sseStream = await jsonToSse.convertResponseToJsonToSse(input, options);
+            const result = await sseToJson.convertSseToJson(sseStream, options);
+            return result;
+        }
+    };
+}
+/**
+ * 工厂函数：创建完整的双向转换器（支持Chat和Responses协议）
+ */
+export function createBidirectionalConverters() {
+    const chat = createChatConverters();
+    const responses = createResponsesConverters();
+    const anthropic = createAnthropicConverters();
+    const gemini = createGeminiConverters();
+    return {
+        chat,
+        responses,
+        anthropic,
+        gemini,
+        /**
+         * 自动检测协议类型并执行转换
+         */
+        async autoConvert(input, options = {}) {
+            // 根据输入数据的结构自动检测协议类型
+            if (input.object === 'chat.completion') {
+                return await chat.roundTrip(input, options);
+            }
+            else if (input.object === 'response') {
+                return await responses.roundTrip(input, options);
+            }
+            else if (input.type === 'message') {
+                return await anthropic.roundTrip(input, options);
+            }
+            else if (Array.isArray(input?.candidates)) {
+                return await gemini.roundTrip(input, options);
+            }
+            else {
+                throw new Error(`无法识别的协议类型: ${input.object}`);
+            }
+        }
+    };
+}
+/**
+ * 默认转换器实例
+ */
+export const chatConverters = createChatConverters();
+export const responsesConverters = createResponsesConverters();
+export const bidirectionalConverters = createBidirectionalConverters();
+export const anthropicConverters = createAnthropicConverters();
+export const geminiConverters = createGeminiConverters();
+export { defaultSseCodecRegistry, SseCodecRegistry } from './registry/sse-codec-registry.js';

package/vendor/@jsonstudio/llms/dist/sse/json-to-sse/anthropic-json-to-sse-converter.d.ts

@@ -0,0 +1,15 @@
+import { PassThrough } from 'node:stream';
+import { DEFAULT_ANTHROPIC_CONVERSION_CONFIG } from '../types/index.js';
+import type { AnthropicMessageResponse, AnthropicJsonToSseOptions } from '../types/index.js';
+export declare class AnthropicJsonToSseConverter {
+    private config;
+    private contexts;
+    constructor(config?: Partial<typeof DEFAULT_ANTHROPIC_CONVERSION_CONFIG>);
+    convertResponseToJsonToSse(response: AnthropicMessageResponse, options: AnthropicJsonToSseOptions): Promise<PassThrough>;
+    private createContext;
+    private processResponse;
+    private updateStats;
+    private validateResponse;
+    private handleStreamError;
+    private wrapError;
+}

package/vendor/@jsonstudio/llms/dist/sse/json-to-sse/anthropic-json-to-sse-converter.js

@@ -0,0 +1,112 @@
+import { PassThrough } from 'node:stream';
+import { DEFAULT_ANTHROPIC_CONVERSION_CONFIG } from '../types/index.js';
+import { ErrorUtils } from '../shared/utils.js';
+import { createAnthropicSequencer } from './sequencers/anthropic-sequencer.js';
+import { createAnthropicStreamWriter } from '../shared/writer.js';
+export class AnthropicJsonToSseConverter {
+    config = DEFAULT_ANTHROPIC_CONVERSION_CONFIG;
+    contexts = new Map();
+    constructor(config) {
+        if (config) {
+            this.config = { ...this.config, ...config };
+        }
+    }
+    async convertResponseToJsonToSse(response, options) {
+        const context = this.createContext(response, options);
+        this.contexts.set(options.requestId, context);
+        const stream = new PassThrough({ objectMode: true });
+        const writer = createAnthropicStreamWriter(stream, {
+            onEvent: (event) => this.updateStats(context, event),
+            onError: (error) => this.handleStreamError(context, error, stream)
+        });
+        this.processResponse(response, context, writer, stream).catch((error) => {
+            this.handleStreamError(context, error, stream);
+        });
+        return Object.assign(stream, {
+            protocol: 'anthropic-messages',
+            direction: 'json_to_sse',
+            requestId: options.requestId,
+            getStats: () => context.eventStats,
+            complete: () => writer.complete(),
+            abort: (error) => writer.abort(error)
+        });
+    }
+    createContext(response, options) {
+        const stats = {
+            totalEvents: 0,
+            contentBlocks: 0,
+            toolUseBlocks: 0,
+            thinkingBlocks: 0,
+            textBlocks: 0,
+            errors: 0,
+            startTime: Date.now()
+        };
+        return {
+            requestId: options.requestId,
+            model: options.model,
+            response,
+            options,
+            startTime: Date.now(),
+            eventStats: stats
+        };
+    }
+    async processResponse(response, context, writer, stream) {
+        try {
+            this.validateResponse(response);
+            const sequencer = createAnthropicSequencer({
+                chunkSize: context.options.chunkSize ?? this.config.defaultChunkSize,
+                chunkDelayMs: context.options.chunkDelayMs ?? this.config.defaultDelayMs,
+                enableDelay: Boolean(context.options.chunkDelayMs),
+                reasoningMode: context.options.reasoningMode ?? this.config.reasoningMode,
+                reasoningTextPrefix: context.options.reasoningTextPrefix ?? this.config.reasoningTextPrefix
+            });
+            const events = sequencer.sequenceResponse(response, context.requestId);
+            await writer.writeAnthropicEvents(events);
+            writer.complete();
+        }
+        catch (error) {
+            writer.abort(error);
+            throw this.wrapError('ANTHROPIC_JSON_TO_SSE_FAILED', error, context.requestId);
+        }
+        finally {
+            this.contexts.delete(context.requestId);
+            stream.end();
+        }
+    }
+    updateStats(context, event) {
+        context.eventStats.totalEvents += 1;
+        if (!event || typeof event !== 'object')
+            return;
+        const type = event.type;
+        if (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')
+                context.eventStats.thinkingBlocks += 1;
+            if (blockType === 'text')
+                context.eventStats.textBlocks += 1;
+        }
+    }
+    validateResponse(response) {
+        if (!response || typeof response !== 'object') {
+            throw new Error('Invalid Anthropic response payload');
+        }
+        if (!Array.isArray(response.content)) {
+            throw new Error('Anthropic response content must be an array');
+        }
+    }
+    handleStreamError(context, error, stream) {
+        context.eventStats.errors += 1;
+        try {
+            stream.destroy(error);
+        }
+        catch {
+            /* noop */
+        }
+    }
+    wrapError(code, error, requestId) {
+        return ErrorUtils.createError(error.message, code, { requestId });
+    }
+}

package/vendor/@jsonstudio/llms/dist/sse/json-to-sse/chat-json-to-sse-converter.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Chat JSON → SSE转换器（重构版本）
+ * 使用函数化架构：事件生成 + 序列化 + 写入分离
+ */
+import { DEFAULT_CHAT_CONVERSION_CONFIG } from '../types/index.js';
+import type { ChatCompletionRequest, ChatCompletionResponse, ChatJsonToSseContext, ChatJsonToSseOptions, ChatSseEventStream } from '../types/index.js';
+/**
+ * 重构后的Chat JSON到SSE转换器
+ * 采用函数化架构，专注于编排而非具体业务逻辑
+ */
+export declare class ChatJsonToSseConverterRefactored {
+    private config;
+    private contexts;
+    constructor(config?: Partial<typeof DEFAULT_CHAT_CONVERSION_CONFIG>);
+    /**
+     * 将Chat Completion请求转换为SSE流
+     */
+    convertRequestToJsonToSse(request: ChatCompletionRequest, options: ChatJsonToSseOptions): Promise<ChatSseEventStream>;
+    /**
+     * 将Chat Completion响应转换为SSE流
+     */
+    convertResponseToJsonToSse(response: ChatCompletionResponse, options: ChatJsonToSseOptions): Promise<ChatSseEventStream>;
+    /**
+     * 使用函数化架构处理请求转换
+     */
+    private processRequestToSseWithFunctions;
+    /**
+     * 使用函数化架构处理响应转换
+     */
+    private processResponseToSseWithFunctions;
+    /**
+     * 验证请求格式
+     */
+    private validateRequest;
+    /**
+     * 验证响应格式
+     */
+    private validateResponse;
+    /**
+     * 更新统计信息
+     */
+    private updateStats;
+    /**
+     * 包装错误
+     */
+    private wrapError;
+    /**
+     * 处理流错误
+     */
+    private handleStreamError;
+    /**
+     * 完成流
+     */
+    private completeStream;
+    /**
+     * 中止流
+     */
+    private abortStream;
+    /**
+     * 创建请求上下文
+     */
+    private createRequestContext;
+    /**
+     * 创建响应上下文
+     */
+    private createResponseContext;
+    /**
+     * 获取上下文
+     */
+    getContext(requestId: string): ChatJsonToSseContext | undefined;
+    /**
+     * 清理上下文
+     */
+    clearContext(requestId: string): void;
+    /**
+     * 获取所有活跃的上下文
+     */
+    getActiveContexts(): Map<string, ChatJsonToSseContext>;
+}
+export declare const ChatJsonToSseConverter: typeof ChatJsonToSseConverterRefactored;