@jsonstudio/llms 0.4.2

package/dist/conversion/conversion-v3/nodes/response/openai-response-input-node.js

@@ -0,0 +1,87 @@
+import { NodeType, NodeStatus } from '../../types/index.js';
+function unwrapOpenAIResponse(payload) {
+    let current = payload;
+    const seen = new Set();
+    while (current && typeof current === 'object' && !Array.isArray(current) && !seen.has(current)) {
+        seen.add(current);
+        if ('choices' in current || 'id' in current || 'object' in current)
+            break;
+        if ('data' in current && current.data && typeof current.data === 'object') {
+            current = current.data;
+            continue;
+        }
+        break;
+    }
+    return current;
+}
+/**
+ * OpenAI provider response → canonical chat response输入节点
+ */
+export class OpenAIResponseInputNode {
+    id;
+    config;
+    type = NodeType.INPUT;
+    status = NodeStatus.IDLE;
+    name;
+    constructor(id, config) {
+        this.id = id;
+        this.config = config;
+        this.name = config.name || 'OpenAI Response Input Node';
+    }
+    async execute(context) {
+        const start = Date.now();
+        this.status = NodeStatus.RUNNING;
+        try {
+            const payload = context.data?.payload ?? context.data ?? context.request.payload;
+            const chatShape = unwrapOpenAIResponse(payload);
+            const responseContext = {
+                toolContext: {
+                    originalRequest: context.request.context?.metadata?.originalRequest,
+                    requestId: context.request.id,
+                    entryEndpoint: context.request.context?.entryEndpoint || context.request.endpoint
+                }
+            };
+            this.status = NodeStatus.COMPLETED;
+            return {
+                success: true,
+                data: {
+                    responsePayload: chatShape,
+                    responseContext
+                },
+                metadata: {
+                    node: this.id,
+                    executionTime: Date.now() - start,
+                    startTime: start,
+                    endTime: Date.now()
+                }
+            };
+        }
+        catch (error) {
+            this.status = NodeStatus.FAILED;
+            return {
+                success: false,
+                error: {
+                    code: 'OPENAI_RESPONSE_INPUT_ERROR',
+                    message: error instanceof Error ? error.message : 'Failed to normalize OpenAI response',
+                    cause: error instanceof Error ? error : undefined
+                },
+                metadata: {
+                    node: this.id,
+                    executionTime: Date.now() - start,
+                    startTime: start,
+                    endTime: Date.now()
+                }
+            };
+        }
+    }
+    validate() {
+        return {
+            valid: true,
+            errors: [],
+            warnings: []
+        };
+    }
+    async cleanup() {
+        this.status = NodeStatus.IDLE;
+    }
+}

package/dist/conversion/conversion-v3/nodes/response/response-utils.d.ts

@@ -0,0 +1 @@
+export { buildProcessedRequestFromChatResponse } from '../../../hub/response/chat-response-utils.js';

package/dist/conversion/conversion-v3/nodes/response/response-utils.js

@@ -0,0 +1 @@
+export { buildProcessedRequestFromChatResponse } from '../../../hub/response/chat-response-utils.js';

package/dist/conversion/conversion-v3/nodes/response/responses-response-input-node.d.ts

@@ -0,0 +1,12 @@
+import { NodeType, NodeStatus, type NodeConfig, type NodeContext, type NodeResult, type PipelineNode, type ValidationResult } from '../../types/index.js';
+export declare class ResponsesResponseInputNode implements PipelineNode {
+    readonly id: string;
+    readonly config: NodeConfig;
+    readonly type = NodeType.INPUT;
+    status: NodeStatus;
+    readonly name: string;
+    constructor(id: string, config: NodeConfig);
+    execute(context: NodeContext): Promise<NodeResult>;
+    validate(): ValidationResult;
+    cleanup(): Promise<void>;
+}

package/dist/conversion/conversion-v3/nodes/response/responses-response-input-node.js

@@ -0,0 +1,67 @@
+import { NodeType, NodeStatus } from '../../types/index.js';
+import { buildChatResponseFromResponses } from '../../../responses/responses-openai-bridge.js';
+export class ResponsesResponseInputNode {
+    id;
+    config;
+    type = NodeType.INPUT;
+    status = NodeStatus.IDLE;
+    name;
+    constructor(id, config) {
+        this.id = id;
+        this.config = config;
+        this.name = config.name || 'Responses Response Input Node';
+    }
+    async execute(context) {
+        const start = Date.now();
+        this.status = NodeStatus.RUNNING;
+        try {
+            const payload = context.data?.payload ?? context.data ?? context.request.payload;
+            const chatShape = buildChatResponseFromResponses(payload);
+            const responseContext = {
+                toolContext: {
+                    originalRequest: context.request.context?.metadata?.originalRequest,
+                    requestId: context.request.id,
+                    entryEndpoint: context.request.context?.entryEndpoint || context.request.endpoint
+                }
+            };
+            this.status = NodeStatus.COMPLETED;
+            return {
+                success: true,
+                data: {
+                    responsePayload: chatShape,
+                    rawResponsesPayload: payload,
+                    responseContext
+                },
+                metadata: {
+                    node: this.id,
+                    executionTime: Date.now() - start,
+                    startTime: start,
+                    endTime: Date.now()
+                }
+            };
+        }
+        catch (error) {
+            this.status = NodeStatus.FAILED;
+            return {
+                success: false,
+                error: {
+                    code: 'RESPONSES_RESPONSE_INPUT_ERROR',
+                    message: error instanceof Error ? error.message : 'Failed to normalize OpenAI Responses payload',
+                    cause: error instanceof Error ? error : undefined
+                },
+                metadata: {
+                    node: this.id,
+                    executionTime: Date.now() - start,
+                    startTime: start,
+                    endTime: Date.now()
+                }
+            };
+        }
+    }
+    validate() {
+        return { valid: true, errors: [], warnings: [] };
+    }
+    async cleanup() {
+        this.status = NodeStatus.IDLE;
+    }
+}

package/dist/conversion/conversion-v3/nodes/sse/index.d.ts

@@ -0,0 +1,3 @@
+export { SSEInputNode } from './sse-input-node.js';
+export { SSEOutputNode } from './sse-output-node.js';
+export { SSEPassthroughNode } from './sse-passthrough-node.js';

package/dist/conversion/conversion-v3/nodes/sse/index.js

@@ -0,0 +1,3 @@
+export { SSEInputNode } from './sse-input-node.js';
+export { SSEOutputNode } from './sse-output-node.js';
+export { SSEPassthroughNode } from './sse-passthrough-node.js';

package/dist/conversion/conversion-v3/nodes/sse/sse-input-node.d.ts

@@ -0,0 +1,27 @@
+import { NodeType, NodeStatus, type NodeConfig, type NodeContext, type NodeResult, type PipelineNode, type ValidationResult } from '../../types/index.js';
+/**
+ * SSE 输入节点（重构版本）
+ *
+ * 将上游 SSE 请求上下文转换为标准 JSON 载荷。
+ * 基于配置驱动的轻量级编排器，使用标准化的 codec registry。
+ */
+export declare class SSEInputNode implements PipelineNode {
+    readonly id: string;
+    readonly config: NodeConfig;
+    readonly type = NodeType.INPUT;
+    status: NodeStatus;
+    readonly name: string;
+    constructor(id: string, config: NodeConfig);
+    execute(context: NodeContext): Promise<NodeResult>;
+    private getParserConfig;
+    private resolveSseProtocol;
+    private applyCompatibilityFilters;
+    private detectInputFormat;
+    private convertSSEToJson;
+    private createSseEventStream;
+    private unwrapReadable;
+    private passThroughJson;
+    private wrapError;
+    validate(): ValidationResult;
+    cleanup(): Promise<void>;
+}

package/dist/conversion/conversion-v3/nodes/sse/sse-input-node.js

@@ -0,0 +1,165 @@
+import { Readable } from 'stream';
+import { NodeType, NodeStatus, ConversionError } from '../../types/index.js';
+import { defaultSseCodecRegistry } from '../../../../sse/index.js';
+/**
+ * SSE 输入节点（重构版本）
+ *
+ * 将上游 SSE 请求上下文转换为标准 JSON 载荷。
+ * 基于配置驱动的轻量级编排器，使用标准化的 codec registry。
+ */
+export class SSEInputNode {
+    id;
+    config;
+    type = NodeType.INPUT;
+    status = NodeStatus.IDLE;
+    name;
+    constructor(id, config) {
+        this.id = id;
+        this.config = config;
+        this.name = config.name || 'SSE Input Node';
+    }
+    async execute(context) {
+        const start = Date.now();
+        this.status = NodeStatus.RUNNING;
+        try {
+            const parserConfig = this.getParserConfig(context);
+            const filteredConfig = await this.applyCompatibilityFilters(parserConfig, context);
+            const inputFormat = this.detectInputFormat(context);
+            if (inputFormat === 'sse-stream') {
+                const result = await this.convertSSEToJson(context, filteredConfig);
+                this.status = NodeStatus.COMPLETED;
+                return {
+                    success: true,
+                    data: result,
+                    metadata: {
+                        node: this.id,
+                        executionTime: Date.now() - start,
+                        startTime: start,
+                        endTime: Date.now()
+                    }
+                };
+            }
+            return this.passThroughJson(context, start);
+        }
+        catch (error) {
+            this.status = NodeStatus.FAILED;
+            throw this.wrapError(error);
+        }
+    }
+    getParserConfig(context) {
+        const requestContext = context.request.context;
+        const nestedMetadata = requestContext?.metadata;
+        const metadataSource = nestedMetadata ?? requestContext;
+        const provider = metadataSource?.provider ?? requestContext?.provider;
+        const profile = provider?.profile;
+        const providedModel = typeof metadataSource?.model === 'string' ? metadataSource.model : undefined;
+        const providerProtocol = typeof metadataSource?.providerProtocol === 'string'
+            ? metadataSource.providerProtocol
+            : undefined;
+        const entryEndpoint = typeof metadataSource?.entryEndpoint === 'string'
+            ? metadataSource.entryEndpoint
+            : context.request.endpoint;
+        return {
+            protocol: this.resolveSseProtocol(profile, providerProtocol, entryEndpoint),
+            model: providedModel
+        };
+    }
+    resolveSseProtocol(profile, providerProtocol, entryEndpoint) {
+        const candidates = [
+            profile,
+            providerProtocol,
+            entryEndpoint
+        ].filter((value) => typeof value === 'string');
+        for (const value of candidates) {
+            const lowered = value.toLowerCase();
+            if (lowered.includes('responses')) {
+                return 'openai-responses';
+            }
+            if (lowered.includes('messages') || lowered.includes('anthropic')) {
+                return 'anthropic-messages';
+            }
+        }
+        return 'openai-chat';
+    }
+    async applyCompatibilityFilters(config, _context) {
+        return config;
+    }
+    detectInputFormat(context) {
+        const payload = context.request.payload;
+        if (payload && typeof payload === 'object' && 'readable' in payload) {
+            return 'sse-stream';
+        }
+        if (payload && typeof payload === 'object') {
+            return 'json-object';
+        }
+        return 'json-object';
+    }
+    async convertSSEToJson(context, config) {
+        const readable = this.unwrapReadable(context.request.payload);
+        const codec = defaultSseCodecRegistry.get(config.protocol);
+        try {
+            const result = await codec.convertSseToJson(this.createSseEventStream(readable), {
+                requestId: context.request.id,
+                model: config.model,
+                direction: 'request'
+            });
+            if (!result || typeof result !== 'object') {
+                throw new ConversionError('SSE converter returned empty payload', this.id);
+            }
+            return result;
+        }
+        catch (error) {
+            throw new ConversionError(`${config.protocol} SSE conversion failed: ${error.message}`, this.id);
+        }
+    }
+    createSseEventStream(sseStream) {
+        const iterator = async function* () {
+            for await (const chunk of sseStream) {
+                yield typeof chunk === 'string' ? chunk : chunk.toString();
+            }
+        };
+        return iterator();
+    }
+    unwrapReadable(payload) {
+        if (payload && typeof payload === 'object' && 'readable' in payload) {
+            const candidate = payload.readable;
+            if (candidate instanceof Readable) {
+                return candidate;
+            }
+        }
+        return payload;
+    }
+    passThroughJson(context, startTime) {
+        const payload = context.request.payload;
+        if (!payload || typeof payload !== 'object') {
+            throw new ConversionError('JSON payload must be an object', this.id);
+        }
+        this.status = NodeStatus.COMPLETED;
+        return {
+            success: true,
+            data: payload,
+            metadata: {
+                node: this.id,
+                executionTime: Date.now() - startTime,
+                startTime,
+                endTime: Date.now()
+            }
+        };
+    }
+    wrapError(error) {
+        if (error instanceof ConversionError) {
+            return error;
+        }
+        return new ConversionError(`SSE input conversion failed: ${error.message}`, this.id);
+    }
+    validate() {
+        return {
+            valid: true,
+            errors: [],
+            warnings: []
+        };
+    }
+    async cleanup() {
+        this.status = NodeStatus.IDLE;
+    }
+}

package/dist/conversion/conversion-v3/nodes/sse/sse-output-node.d.ts

@@ -0,0 +1,19 @@
+import { NodeStatus, NodeType, type NodeConfig, type NodeContext, type NodeResult, type PipelineNode, type ValidationResult } from '../../types/index.js';
+/**
+ * SSE 输出节点
+ *
+ * 将转换后的响应根据是否流式输出为 JSON 或 Readable SSE 流。
+ */
+export declare class SSEOutputNode implements PipelineNode {
+    readonly id: string;
+    readonly config: NodeConfig;
+    readonly type = NodeType.OUTPUT;
+    status: NodeStatus;
+    readonly name: string;
+    constructor(id: string, config: NodeConfig);
+    execute(context: NodeContext): Promise<NodeResult>;
+    validate(): ValidationResult;
+    cleanup(): Promise<void>;
+    private createStreamingResponse;
+    private resolveModelId;
+}

package/dist/conversion/conversion-v3/nodes/sse/sse-output-node.js

@@ -0,0 +1,267 @@
+import { PassThrough } from 'node:stream';
+import { NodeStatus, NodeType } from '../../types/index.js';
+import { defaultSseCodecRegistry } from '../../../../sse/index.js';
+function getPipelineDirection(context) {
+    const metadata = context.request.context?.metadata;
+    const direction = typeof metadata?.direction === 'string' ? metadata.direction.toLowerCase() : '';
+    return direction === 'response' ? 'response' : 'request';
+}
+function mapResumeToolOutputs(meta) {
+    if (!Array.isArray(meta))
+        return [];
+    const mapped = [];
+    meta.forEach((entry, index) => {
+        if (!entry || typeof entry !== 'object')
+            return;
+        const rec = entry;
+        const originalId = typeof rec.originalId === 'string' && rec.originalId.trim()
+            ? rec.originalId.trim()
+            : undefined;
+        const callIdRaw = typeof rec.callId === 'string' && rec.callId.trim()
+            ? rec.callId.trim()
+            : undefined;
+        const callId = callIdRaw || (originalId ? (originalId.startsWith('fc_') ? originalId : `fc_${originalId}`) : `fc_resume_${index}`);
+        const outputText = typeof rec.outputText === 'string' ? rec.outputText : '';
+        mapped.push({
+            id: callId,
+            type: 'function_call_output',
+            call_id: callId,
+            tool_call_id: originalId,
+            output: outputText
+        });
+    });
+    return mapped;
+}
+function resolveMetadata(context) {
+    const ctx = context.request.context?.metadata;
+    return (ctx && typeof ctx === 'object') ? ctx : {};
+}
+function getOriginalRequest(metadata) {
+    const original = metadata?.originalRequest;
+    return original && typeof original === 'object' ? original : undefined;
+}
+function normalizeStreamingFlag(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'string') {
+        const lowered = value.trim().toLowerCase();
+        if (['true', '1', 'yes', 'always'].includes(lowered))
+            return true;
+        if (['false', '0', 'no', 'never'].includes(lowered))
+            return false;
+    }
+    return undefined;
+}
+function metadataRequestsStreaming(meta) {
+    if (!meta)
+        return false;
+    const inboundFlag = normalizeStreamingFlag(meta.inboundStream);
+    if (inboundFlag)
+        return true;
+    const directFlag = normalizeStreamingFlag(meta.stream);
+    if (directFlag)
+        return true;
+    const clientFlag = normalizeStreamingFlag(meta.clientStream);
+    if (clientFlag)
+        return true;
+    if (typeof meta.streaming === 'string') {
+        const lowered = meta.streaming.toLowerCase();
+        if (lowered === 'always')
+            return true;
+        if (lowered === 'auto' && clientFlag)
+            return true;
+    }
+    return false;
+}
+function shouldStreamResponse(context, conversionResponse) {
+    const metadata = resolveMetadata(context);
+    if (metadataRequestsStreaming(metadata))
+        return true;
+    const orig = getOriginalRequest(metadata);
+    if (orig) {
+        const origStream = normalizeStreamingFlag(orig.stream);
+        if (origStream === true)
+            return true;
+    }
+    if (conversionResponse?.metadata && conversionResponse.metadata?.streaming === true)
+        return true;
+    return false;
+}
+function fallbackSSE(payload, requestId) {
+    const stream = new PassThrough();
+    try {
+        stream.write(`data: ${JSON.stringify({ error: payload, requestId })}\n\n`);
+    }
+    catch {
+        stream.write('data: {"error":{"message":"sse_fallback"}}\n\n');
+    }
+    stream.write('data: [DONE]\n\n');
+    stream.end();
+    return stream;
+}
+function resolveFormat(contextData) {
+    const conversionResponse = contextData?.conversionResponse;
+    const explicit = typeof conversionResponse?.format === 'string' ? conversionResponse.format : undefined;
+    if (explicit)
+        return explicit;
+    const outputFormat = contextData?.outputFormat;
+    return typeof outputFormat === 'string' ? outputFormat : '';
+}
+function normalizeFormatToProtocol(format) {
+    if (!format) {
+        return 'openai-chat';
+    }
+    const lowered = format.toLowerCase();
+    if (lowered === 'openai-chat' || lowered === 'processed-chat') {
+        return 'openai-chat';
+    }
+    if (lowered === 'openai-responses') {
+        return 'openai-responses';
+    }
+    if (lowered === 'anthropic-messages' || lowered === 'anthropic') {
+        return 'anthropic-messages';
+    }
+    return null;
+}
+function resolveResponsePayload(contextData) {
+    const conversionResponse = contextData?.conversionResponse;
+    if (conversionResponse?.data && typeof conversionResponse.data === 'object') {
+        return conversionResponse.data;
+    }
+    const outputData = contextData?.outputData;
+    if (outputData && typeof outputData === 'object') {
+        return outputData;
+    }
+    return undefined;
+}
+/**
+ * SSE 输出节点
+ *
+ * 将转换后的响应根据是否流式输出为 JSON 或 Readable SSE 流。
+ */
+export class SSEOutputNode {
+    id;
+    config;
+    type = NodeType.OUTPUT;
+    status = NodeStatus.IDLE;
+    name;
+    constructor(id, config) {
+        this.id = id;
+        this.config = config;
+        this.name = config.name || 'SSE Output Node';
+    }
+    async execute(context) {
+        const start = Date.now();
+        this.status = NodeStatus.RUNNING;
+        const direction = getPipelineDirection(context);
+        if (direction !== 'response') {
+            this.status = NodeStatus.COMPLETED;
+            return {
+                success: true,
+                data: context.data ?? {},
+                metadata: {
+                    node: this.id,
+                    executionTime: Date.now() - start,
+                    startTime: start,
+                    endTime: Date.now()
+                }
+            };
+        }
+        const data = context.data;
+        const conversionResponse = data?.conversionResponse;
+        const responsePayload = resolveResponsePayload(data ?? {});
+        const format = resolveFormat(data ?? {});
+        const wantsStream = shouldStreamResponse(context, conversionResponse);
+        const metadata = resolveMetadata(context);
+        if (wantsStream) {
+            const stream = await this.createStreamingResponse(format, responsePayload, context.request.id, metadata);
+            this.status = NodeStatus.COMPLETED;
+            return {
+                success: true,
+                data: {
+                    __sse_responses: stream,
+                    passthrough: context.pipeline.isPassthrough,
+                    format
+                },
+                metadata: {
+                    node: this.id,
+                    executionTime: Date.now() - start,
+                    startTime: start,
+                    endTime: Date.now()
+                }
+            };
+        }
+        // 非流式路径：
+        // - Responses 输出：返回标准 Responses JSON（response 节点），并保留 sseStream 供快照/调试。
+        // - 其他输出：保持原有 sseStream 形状，避免干扰 Chat / Anthropic 等路径。
+        this.status = NodeStatus.COMPLETED;
+        const responsePayloadData = conversionResponse?.data ?? responsePayload;
+        const includeResponsePayload = typeof format === 'string' && format.toLowerCase() === 'openai-responses';
+        return {
+            success: true,
+            data: {
+                ...(includeResponsePayload ? {
+                    response: responsePayloadData,
+                    responseMetadata: conversionResponse?.metadata
+                } : {}),
+                sseStream: conversionResponse ?? responsePayload,
+                passthrough: context.pipeline.isPassthrough,
+                format
+            },
+            metadata: {
+                node: this.id,
+                executionTime: Date.now() - start,
+                startTime: start,
+                endTime: Date.now()
+            }
+        };
+    }
+    validate() {
+        return {
+            valid: true,
+            errors: [],
+            warnings: []
+        };
+    }
+    async cleanup() {
+        this.status = NodeStatus.IDLE;
+    }
+    async createStreamingResponse(format, payload, requestId, metadata) {
+        if (!payload) {
+            return fallbackSSE({ message: 'sse_not_available', format }, requestId);
+        }
+        const protocol = normalizeFormatToProtocol(format);
+        if (!protocol) {
+            return fallbackSSE({ message: 'sse_protocol_unsupported', format }, requestId);
+        }
+        try {
+            const codec = defaultSseCodecRegistry.get(protocol);
+            const resumeItems = mapResumeToolOutputs(metadata?.responsesResume?.toolOutputsDetailed);
+            const stream = await codec.convertJsonToSse(payload, {
+                requestId,
+                model: this.resolveModelId(payload),
+                direction: 'response',
+                resumeToolOutputs: resumeItems.length ? resumeItems : undefined
+            });
+            return stream;
+        }
+        catch (error) {
+            console.error('[SSEOutputNode] Error creating streaming response:', error);
+            return fallbackSSE({
+                error: 'sse_conversion_failed',
+                message: error instanceof Error ? error.message : 'Unknown error',
+                format,
+                protocol
+            }, requestId);
+        }
+    }
+    resolveModelId(payload) {
+        if ('model' in payload && typeof payload.model === 'string') {
+            return payload.model;
+        }
+        if ('response' in payload && payload.response && typeof payload.response.model === 'string') {
+            return payload.response.model;
+        }
+        return 'unknown';
+    }
+}

package/dist/conversion/conversion-v3/nodes/sse/sse-passthrough-node.d.ts

@@ -0,0 +1,18 @@
+import { NodeStatus, NodeType, type NodeConfig, type NodeContext, type NodeResult, type PipelineNode, type ValidationResult } from '../../types/index.js';
+/**
+ * SSE 直通节点
+ *
+ * 在需要保持 SSE 原样透传时使用。
+ * 仅做元数据记录，不改变数据内容。
+ */
+export declare class SSEPassthroughNode implements PipelineNode {
+    readonly id: string;
+    readonly config: NodeConfig;
+    readonly type = NodeType.PROCESS;
+    status: NodeStatus;
+    readonly name: string;
+    constructor(id: string, config: NodeConfig);
+    execute(context: NodeContext): Promise<NodeResult>;
+    validate(): ValidationResult;
+    cleanup(): Promise<void>;
+}