@jsonstudio/llms 0.4.2

package/dist/sse/json-to-sse/sequencers/responses-sequencer.js

@@ -0,0 +1,263 @@
+/**
+ * Responses协议事件编排器
+ * 负责将Responses响应数据转换为有序的SSE事件流
+ */
+import { buildResponseStartEvents, buildResponseDoneEvent, buildOutputItemStartEvent, buildOutputItemDoneEvent, buildContentPartStartEvent, buildContentPartDeltas, buildContentPartDoneEvent, buildOutputTextDoneEvent, buildFunctionCallArgsDeltas, buildFunctionCallDoneEvent, buildReasoningStartEvent, buildReasoningDeltas, buildReasoningDoneEvent, buildRequiredActionEvent, buildResponseCompletedEvent, buildErrorEvent, DEFAULT_RESPONSES_EVENT_GENERATOR_CONFIG, createDefaultResponsesContext } from '../event-generators/responses.js';
+// 默认配置
+export const DEFAULT_RESPONSES_SEQUENCER_CONFIG = {
+    ...DEFAULT_RESPONSES_EVENT_GENERATOR_CONFIG,
+    enableValidation: true,
+    enableRecovery: true,
+    enableDelay: false,
+    maxOutputItems: 50,
+    maxContentParts: 100,
+    submittedToolOutputs: undefined
+};
+/**
+ * 验证响应格式
+ */
+function validateResponse(response, config) {
+    if (!config.enableValidation)
+        return;
+    if (!response.id || !response.model) {
+        throw new Error('Invalid response: missing required fields');
+    }
+    if (!response.output || !Array.isArray(response.output)) {
+        throw new Error('Invalid response: missing or invalid output array');
+    }
+    if (response.output.length > config.maxOutputItems) {
+        throw new Error(`Too many output items: ${response.output.length} > ${config.maxOutputItems}`);
+    }
+}
+/**
+ * 异步生成器：为事件添加延迟
+ */
+async function* withDelay(events, config) {
+    for await (const event of events) {
+        yield event;
+        if (config.enableDelay && config.chunkDelayMs > 0) {
+            await new Promise(resolve => setTimeout(resolve, config.chunkDelayMs));
+        }
+    }
+}
+/**
+ * 序列化消息输出项
+ */
+async function* sequenceMessageItem(item, context, config) {
+    // 1. 发送output_item.start事件
+    yield buildOutputItemStartEvent(item, context, config);
+    // 2. 发送content_part事件序列
+    for (let contentIndex = 0; contentIndex < item.content.length; contentIndex++) {
+        if (contentIndex >= config.maxContentParts) {
+            if (config.enableValidation) {
+                throw new Error(`Too many content parts: ${contentIndex} >= ${config.maxContentParts}`);
+            }
+            break;
+        }
+        const content = item.content[contentIndex];
+        context.contentIndexCounter.set(item.id, contentIndex);
+        // 2a. 发送content_part.start事件
+        yield buildContentPartStartEvent(item.id, contentIndex, content, context, config);
+        // 2b. 发送content_part.delta事件流（仅对文本内容）
+        const isTextContent = (content.type === 'input_text' || content.type === 'output_text') && !!content.text;
+        if (isTextContent && content.text) {
+            yield* withDelay(buildContentPartDeltas(item.id, contentIndex, content.text, context, config), config);
+            if (content.type === 'output_text') {
+                yield buildOutputTextDoneEvent(item.id, contentIndex, content.text, context, config);
+            }
+        }
+        // 2c. 发送content_part.done事件
+        yield buildContentPartDoneEvent(item.id, contentIndex, content, context, config);
+    }
+    // 3. 发送output_item.done事件
+    yield buildOutputItemDoneEvent(item, context, config);
+}
+/**
+ * 序列化函数调用输出项
+ */
+async function* sequenceFunctionCallItem(item, context, config) {
+    // 1. 发送output_item.start事件
+    yield buildOutputItemStartEvent(item, context, config);
+    // 2. 发送function_call.delta事件流（arguments）
+    if (item.arguments) {
+        yield* withDelay(buildFunctionCallArgsDeltas(item, context, config), config);
+    }
+    // 3. 发送function_call.done事件
+    yield buildFunctionCallDoneEvent(item, context, config);
+    // 4. 发送output_item.done事件
+    yield buildOutputItemDoneEvent(item, context, config);
+}
+/**
+ * 序列化函数调用输出项
+ */
+async function* sequenceFunctionCallOutputItem(item, context, config) {
+    yield buildOutputItemStartEvent(item, context, config);
+    yield buildOutputItemDoneEvent(item, context, config);
+}
+/**
+ * 序列化推理输出项
+ */
+async function* sequenceReasoningItem(item, context, config) {
+    // 1. 发送output_item.start事件
+    yield buildOutputItemStartEvent(item, context, config);
+    // 2. 发送reasoning.start事件
+    yield buildReasoningStartEvent(item, context, config);
+    // 3. 发送reasoning.delta事件流
+    yield* withDelay(buildReasoningDeltas(item, context, config), config);
+    // 4. 发送reasoning.done事件
+    yield buildReasoningDoneEvent(item, context, config);
+    // 5. 发送output_item.done事件
+    yield buildOutputItemDoneEvent(item, context, config);
+}
+/**
+ * 序列化单个输出项
+ */
+async function* sequenceOutputItem(item, context, config) {
+    try {
+        switch (item.type) {
+            case 'message':
+                yield* sequenceMessageItem(item, context, config);
+                break;
+            case 'function_call':
+                yield* sequenceFunctionCallItem(item, context, config);
+                break;
+            case 'function_call_output':
+                yield* sequenceFunctionCallOutputItem(item, context, config);
+                break;
+            case 'reasoning':
+                yield* sequenceReasoningItem(item, context, config);
+                break;
+            default:
+                if (config.enableValidation) {
+                    throw new Error(`Unknown output item type: ${item.type}`);
+                }
+        }
+    }
+    catch (error) {
+        if (config.enableRecovery) {
+            yield buildErrorEvent(error, context, config);
+        }
+        else {
+            throw error;
+        }
+    }
+}
+/**
+ * 主编排器：将Responses响应转换为有序的SSE事件流
+ */
+export async function* sequenceResponse(response, context, config = DEFAULT_RESPONSES_SEQUENCER_CONFIG) {
+    try {
+        // 1. 验证响应格式
+        validateResponse(response, config);
+        // 2. 发送response.start事件
+        yield* buildResponseStartEvents(response, context, config);
+        const submittedOutputs = Array.isArray(config.submittedToolOutputs)
+            ? config.submittedToolOutputs
+            : [];
+        for (let i = 0; i < submittedOutputs.length; i++) {
+            context.outputIndexCounter = i;
+            yield* sequenceFunctionCallOutputItem(submittedOutputs[i], context, config);
+        }
+        const outputOffset = submittedOutputs.length;
+        // 3. 序列化所有输出项
+        for (let outputIndex = 0; outputIndex < response.output.length; outputIndex++) {
+            const item = response.output[outputIndex];
+            context.outputIndexCounter = outputOffset + outputIndex;
+            yield* sequenceOutputItem(item, context, config);
+            // 输出项间添加小延迟（如果启用）
+            if (config.enableDelay && config.chunkDelayMs > 0 && outputIndex < response.output.length - 1) {
+                await new Promise(resolve => setTimeout(resolve, config.chunkDelayMs * 2));
+            }
+        }
+        // 4. 发送required_action事件（如果有）
+        if (response.required_action) {
+            yield buildRequiredActionEvent(response, response.required_action, context, config);
+        }
+        // 5. 发送response.completed + response.done事件
+        yield buildResponseCompletedEvent(response, context, config);
+        yield buildResponseDoneEvent(response, context, config);
+    }
+    catch (error) {
+        // 发送错误事件
+        yield buildErrorEvent(error, context, config);
+    }
+}
+/**
+ * 序列化Responses请求（用于请求→SSE转换）
+ */
+export async function* sequenceRequest(request, context, config = DEFAULT_RESPONSES_SEQUENCER_CONFIG) {
+    try {
+        // 验证请求格式
+        if (config.enableValidation && (!request.model || !request.input)) {
+            throw new Error('Invalid request: missing required fields');
+        }
+        // 对于请求，我们主要回显输入内容
+        yield* buildResponseStartEvents({
+            id: context.requestId,
+            object: 'response',
+            created_at: Math.floor(Date.now() / 1000),
+            status: 'in_progress',
+            model: request.model,
+            output: [],
+            usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 }
+        }, context, config);
+        // 回显输入消息作为输出项
+        if (request.input && Array.isArray(request.input)) {
+            for (let inputIndex = 0; inputIndex < request.input.length; inputIndex++) {
+                const inputItem = request.input[inputIndex];
+                context.outputIndexCounter = inputIndex;
+                // 将输入转换为输出项格式
+                const outputItem = {
+                    id: `${context.requestId}-input-${inputIndex}`,
+                    type: 'message',
+                    status: 'completed',
+                    role: inputItem.role,
+                    content: inputItem.content
+                };
+                yield* sequenceMessageItem(outputItem, context, config);
+            }
+        }
+        const syntheticResponse = {
+            id: context.requestId,
+            object: 'response',
+            created_at: Math.floor(Date.now() / 1000),
+            status: 'completed',
+            model: request.model,
+            output: [],
+            usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 }
+        };
+        yield buildResponseCompletedEvent(syntheticResponse, context, config);
+        yield buildResponseDoneEvent(syntheticResponse, context, config);
+    }
+    catch (error) {
+        yield buildErrorEvent(error, context, config);
+    }
+}
+/**
+ * 创建Responses事件序列化器工厂
+ */
+export function createResponsesSequencer(config) {
+    const finalConfig = { ...DEFAULT_RESPONSES_SEQUENCER_CONFIG, ...config };
+    return {
+        /**
+         * 序列化响应
+         */
+        async *sequenceResponse(response, requestId) {
+            const context = createDefaultResponsesContext(requestId, response.model);
+            yield* sequenceResponse(response, context, finalConfig);
+        },
+        /**
+         * 序列化请求
+         */
+        async *sequenceRequest(request, requestId) {
+            const context = createDefaultResponsesContext(requestId, request.model);
+            yield* sequenceRequest(request, context, finalConfig);
+        },
+        /**
+         * 获取当前配置
+         */
+        getConfig() {
+            return { ...finalConfig };
+        }
+    };
+}

package/dist/sse/registry/sse-codec-registry.d.ts

@@ -0,0 +1,32 @@
+import type { ResponsesFunctionCallOutputItem } from '../types/index.js';
+export type SseProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages';
+export type SseStreamLike = any;
+export type SseStreamInput = any;
+export interface JsonToSseContext {
+    requestId: string;
+    model?: string;
+    direction?: 'request' | 'response';
+    resumeToolOutputs?: ResponsesFunctionCallOutputItem[];
+}
+export interface SseToJsonContext {
+    requestId: string;
+    model?: string;
+    direction?: 'request' | 'response';
+}
+export interface NormalizeSseContext {
+    requestId: string;
+    protocol: SseProtocol;
+}
+export interface SseCodec {
+    protocol: SseProtocol;
+    convertJsonToSse(payload: unknown, context: JsonToSseContext): Promise<SseStreamLike>;
+    convertSseToJson(stream: SseStreamInput, context: SseToJsonContext): Promise<unknown>;
+    normalize?(stream: SseStreamInput, context: NormalizeSseContext): Promise<SseStreamInput>;
+}
+export declare class SseCodecRegistry {
+    private readonly codecs;
+    register(codec: SseCodec): void;
+    get(protocol: SseProtocol): SseCodec;
+    list(): SseCodec[];
+}
+export declare const defaultSseCodecRegistry: SseCodecRegistry;

package/dist/sse/registry/sse-codec-registry.js

@@ -0,0 +1,106 @@
+import { chatConverters, responsesConverters, anthropicConverters } from '../index.js';
+export class SseCodecRegistry {
+    codecs = new Map();
+    register(codec) {
+        this.codecs.set(codec.protocol, codec);
+    }
+    get(protocol) {
+        const codec = this.codecs.get(protocol);
+        if (!codec) {
+            throw new Error(`SSE codec for protocol "${protocol}" is not registered`);
+        }
+        return codec;
+    }
+    list() {
+        return Array.from(this.codecs.values());
+    }
+}
+export const defaultSseCodecRegistry = new SseCodecRegistry();
+function resolveModelId(payload, fallback) {
+    if (typeof fallback === 'string' && fallback.trim()) {
+        return fallback;
+    }
+    if (!payload || typeof payload !== 'object') {
+        return 'unknown';
+    }
+    const record = payload;
+    if (typeof record.model === 'string') {
+        return record.model;
+    }
+    if (record.response && typeof record.response === 'object') {
+        const inner = record.response;
+        if (typeof inner.model === 'string') {
+            return inner.model;
+        }
+    }
+    return 'unknown';
+}
+function createChatCodec() {
+    return {
+        protocol: 'openai-chat',
+        async convertJsonToSse(payload, context) {
+            const model = resolveModelId(payload, context.model);
+            return chatConverters.jsonToSse
+                .convertResponseToJsonToSse(payload, {
+                requestId: context.requestId,
+                model
+            });
+        },
+        async convertSseToJson(stream, context) {
+            return chatConverters.sseToJson.convertSseToJson(stream, {
+                requestId: context.requestId,
+                model: context.model ?? 'unknown'
+            });
+        },
+        async normalize(stream) {
+            return stream;
+        }
+    };
+}
+function createResponsesCodec() {
+    return {
+        protocol: 'openai-responses',
+        async convertJsonToSse(payload, context) {
+            const model = resolveModelId(payload, context.model);
+            return responsesConverters.jsonToSse
+                .convertResponseToJsonToSse(payload, {
+                requestId: context.requestId,
+                model,
+                resumeToolOutputs: context.resumeToolOutputs
+            });
+        },
+        async convertSseToJson(stream, context) {
+            return responsesConverters.sseToJson.convertSseToJson(stream, {
+                requestId: context.requestId,
+                model: context.model ?? 'unknown'
+            });
+        },
+        async normalize(stream) {
+            return stream;
+        }
+    };
+}
+function createAnthropicCodec() {
+    return {
+        protocol: 'anthropic-messages',
+        async convertJsonToSse(payload, context) {
+            const model = resolveModelId(payload, context.model);
+            return anthropicConverters.jsonToSse
+                .convertResponseToJsonToSse(payload, {
+                requestId: context.requestId,
+                model
+            });
+        },
+        async convertSseToJson(stream, context) {
+            return anthropicConverters.sseToJson.convertSseToJson(stream, {
+                requestId: context.requestId
+            });
+        },
+        async normalize(stream) {
+            return stream;
+        }
+    };
+}
+defaultSseCodecRegistry.register(createChatCodec());
+defaultSseCodecRegistry.register(createResponsesCodec());
+defaultSseCodecRegistry.register(createAnthropicCodec());

package/dist/sse/shared/chat-serializer.d.ts

@@ -0,0 +1,4 @@
+import { PassThrough, Readable } from 'node:stream';
+import { ChatSseEvent } from '../types/index.js';
+export declare function serializeChatEventToSSE(evt: ChatSseEvent): string;
+export declare function toSSETextStream(objectEventStream: Readable): PassThrough;

package/dist/sse/shared/chat-serializer.js

@@ -0,0 +1,40 @@
+import { PassThrough } from 'node:stream';
+// Serialize an internal ChatSseEvent (object-mode) to SSE wire frames
+export function serializeChatEventToSSE(evt) {
+    const lines = [];
+    // Standard SSE fields
+    if (evt.event)
+        lines.push(`event: ${evt.event}`);
+    if (typeof evt.data === 'string')
+        lines.push(`data: ${evt.data}`);
+    else
+        lines.push(`data: ${JSON.stringify(evt.data ?? {})}`);
+    return lines.join('\n') + '\n\n';
+}
+// Convert a Readable of ChatSseEvent objects into a text SSE stream
+export function toSSETextStream(objectEventStream) {
+    const out = new PassThrough();
+    (async () => {
+        try {
+            for await (const evt of objectEventStream) {
+                const frame = serializeChatEventToSSE(evt);
+                if (!out.write(frame))
+                    await new Promise(r => out.once('drain', r));
+            }
+        }
+        catch {
+            // emit minimal error frame, then close
+            try {
+                out.write('data: {"error":"chat sse serialization failed"}\n\n');
+            }
+            catch { }
+        }
+        finally {
+            try {
+                out.end();
+            }
+            catch { }
+        }
+    })();
+    return out;
+}