@jsonstudio/llms 0.4.2

package/dist/conversion/conversion-v3/pipelines/super-pipeline.js

@@ -0,0 +1,566 @@
+import { Readable } from 'node:stream';
+import { NodeType } from '../types/index.js';
+import { SSEInputNode } from '../nodes/sse/sse-input-node.js';
+import { ChatInputNode } from '../nodes/input/chat-input-node.js';
+import { ResponsesInputNode } from '../nodes/input/responses-input-node.js';
+import { AnthropicInputNode } from '../nodes/input/anthropic-input-node.js';
+import { ChatProcessNode } from '../nodes/process/chat-process-node.js';
+import { VirtualRouterProcessNode } from '../nodes/process/virtual-router-process-node.js';
+import { CompatibilityProcessNode } from '../nodes/process/compatibility-process-node.js';
+import { OpenAIOutputNode } from '../nodes/output/openai-output-node.js';
+import { AnthropicOutputNode } from '../nodes/output/anthropic-output-node.js';
+import { ResponsesOutputNode } from '../nodes/output/responses-output-node.js';
+import { InputNodeDecision } from '../nodes/input/input-decision.js';
+import { OutputNodeDecision } from '../nodes/output/output-decision.js';
+import { sanitizeProviderPayload } from '../utils/provider-payload-sanitizer.js';
+import { bootstrapVirtualRouterConfig } from '../../../router/virtual-router/bootstrap.js';
+export class SuperPipeline {
+    config;
+    virtualRouterConfig;
+    providerRuntimeByTarget;
+    sseInputNode;
+    chatProcessNode;
+    virtualRouterNode;
+    compatibilityNode;
+    inputNodeCache;
+    outputNodes;
+    constructor(config) {
+        this.config = config;
+        const resolved = this.resolveVirtualRouterConfig(config.virtualRouter);
+        this.virtualRouterConfig = resolved.config;
+        this.providerRuntimeByTarget = resolved.runtimeByTarget;
+        this.config.virtualRouter = this.virtualRouterConfig;
+        this.sseInputNode = new SSEInputNode('sse-input', this.buildNodeConfig({
+            id: 'sse-input',
+            type: NodeType.INPUT,
+            name: 'SSE Input Node',
+            inputFormat: 'sse-or-json',
+            outputFormat: 'json'
+        }));
+        this.chatProcessNode = new ChatProcessNode(this.buildNodeConfig({
+            id: 'chat-process',
+            type: NodeType.PROCESS,
+            name: 'Chat Process Node',
+            inputFormat: 'standardized-request',
+            outputFormat: 'processed-request'
+        }));
+        this.virtualRouterNode = new VirtualRouterProcessNode('virtual-router', this.buildVirtualRouterNodeConfig());
+        this.compatibilityNode = config.compatibility
+            ? new CompatibilityProcessNode('compatibility', this.buildCompatibilityConfig(config.compatibility))
+            : undefined;
+        this.inputNodeCache = new Map();
+        this.outputNodes = this.buildOutputNodes(config.timeouts?.output);
+    }
+    updateVirtualRouterConfig(nextConfig) {
+        const resolved = this.resolveVirtualRouterConfig(nextConfig);
+        this.virtualRouterConfig = resolved.config;
+        this.providerRuntimeByTarget = resolved.runtimeByTarget;
+        this.virtualRouterNode.updateConfig(this.virtualRouterConfig);
+        this.config.virtualRouter = this.virtualRouterConfig;
+    }
+    getProviderRuntime(providerKey) {
+        return this.providerRuntimeByTarget[providerKey];
+    }
+    getProviderRuntimeMap() {
+        return { ...this.providerRuntimeByTarget };
+    }
+    async execute(request) {
+        const conversionRequest = this.buildConversionRequest(request);
+        const context = this.createNodeContext(conversionRequest, request.passthrough === true);
+        await this.runNode(this.sseInputNode, context);
+        const inputNode = this.resolveInputNode(conversionRequest.endpoint);
+        await this.runNode(inputNode, context);
+        await this.runNode(this.chatProcessNode, context);
+        await this.runNode(this.virtualRouterNode, context);
+        this.updatePassthroughState(context);
+        this.syncRequestPayload(context);
+        if (this.compatibilityNode) {
+            await this.runNode(this.compatibilityNode, context);
+        }
+        const resolvedOutput = this.resolveOutputNode(context);
+        const outputResult = await this.runNode(resolvedOutput.node, context);
+        return this.buildResult(context, outputResult, resolvedOutput);
+    }
+    getStatus() {
+        const metadata = this.config.virtualRouter;
+        return {
+            virtualRouter: this.virtualRouterNode.getStatus?.(),
+            config: {
+                routes: Object.keys(metadata.routing ?? {}),
+                providers: Object.keys(metadata.providers ?? {})
+            }
+        };
+    }
+    async runNode(node, context) {
+        context.nodeConfig = node.config;
+        context.pipeline.currentNode = node.id;
+        const result = await node.execute(context);
+        context.pipeline.previousResults.push(result);
+        if (!result.success) {
+            const error = result.error ?? { message: 'Pipeline node failed', code: 'PIPELINE_NODE_ERROR' };
+            throw new SuperPipelineError(`Node ${node.id} failed: ${error.message}`, { node: node.id, details: error.details, code: error.code });
+        }
+        this.mergeNodeData(context, result.data);
+        return result;
+    }
+    buildResult(context, outputResult, resolvedOutput) {
+        const metadata = this.getRequestMetadata(context);
+        const target = (metadata.target ?? null);
+        const routingDecision = (context.data.routingDecision ?? null);
+        const routingDiagnostics = (context.data.routingDiagnostics ?? null);
+        const isResponseStage = this.isResponseDirection(context, metadata);
+        const providerTypeForSanitize = target?.providerType ??
+            this.normalizeProviderType(metadata.providerType);
+        const rawProviderPayload = (outputResult.data ?? null) ?? undefined;
+        const providerPayloadBase = rawProviderPayload
+            ? sanitizeProviderPayload(providerTypeForSanitize, rawProviderPayload, {
+                direction: isResponseStage ? 'response' : 'request'
+            })
+            : undefined;
+        const passthroughPayload = !isResponseStage ? this.resolvePassthroughPayload(context, providerTypeForSanitize) : undefined;
+        const providerPayload = passthroughPayload ?? providerPayloadBase;
+        return {
+            requestId: context.request.id,
+            providerPayload,
+            outputFormat: resolvedOutput.format,
+            standardizedRequest: (context.data.standardizedRequest ?? null) ?? undefined,
+            processedRequest: (context.data.processedRequest ?? null) ?? undefined,
+            routingDecision: routingDecision ?? undefined,
+            routingDiagnostics: routingDiagnostics ?? undefined,
+            target: target ?? undefined,
+            metadata,
+            nodeResults: [...context.pipeline.previousResults]
+        };
+    }
+    resolveInputNode(endpoint) {
+        const normalizedEndpoint = normalizeEndpoint(endpoint);
+        if (this.inputNodeCache.has(normalizedEndpoint)) {
+            return this.inputNodeCache.get(normalizedEndpoint);
+        }
+        const nodeType = InputNodeDecision.decideInputNodeType(normalizedEndpoint);
+        const node = this.createInputNode(nodeType, normalizedEndpoint);
+        this.inputNodeCache.set(normalizedEndpoint, node);
+        return node;
+    }
+    resolveOutputNode(context) {
+        const metadata = this.getRequestMetadata(context);
+        const target = metadata.target;
+        const isResponseContext = this.isResponseDirection(context, metadata);
+        const originalProviderType = this.normalizeProviderType(target?.providerType || metadata.providerType) ?? 'openai';
+        const entryEndpoint = this.normalizeEntryEndpoint(typeof metadata.entryEndpoint === 'string'
+            ? metadata.entryEndpoint
+            : context.request.endpoint);
+        const selectedProvider = isResponseContext
+            ? this.inferOutputProviderFromEntry(entryEndpoint)
+            : originalProviderType;
+        const node = this.outputNodes.get(selectedProvider) ?? this.outputNodes.get('openai');
+        if (!node) {
+            throw new SuperPipelineError(`Unsupported provider type: ${selectedProvider}`);
+        }
+        const format = OutputNodeDecision.getOutputFormat(selectedProvider);
+        metadata.providerType = originalProviderType;
+        return { node, format, providerType: selectedProvider };
+    }
+    isResponseDirection(context, metadata) {
+        const dirMeta = typeof metadata.direction === 'string'
+            ? metadata.direction.toLowerCase()
+            : undefined;
+        if (dirMeta === 'response')
+            return true;
+        const ctxDir = typeof context.request.context?.metadata?.direction === 'string'
+            ? context.request.context.metadata.direction.toLowerCase()
+            : undefined;
+        if (ctxDir === 'response')
+            return true;
+        const endpoint = context.request.endpoint || '';
+        return endpoint.includes('#response');
+    }
+    normalizeEntryEndpoint(endpoint) {
+        if (!endpoint)
+            return '/v1/chat/completions';
+        const base = endpoint.split('#')[0];
+        return normalizeEndpoint(base);
+    }
+    inferOutputProviderFromEntry(entryEndpoint) {
+        if (entryEndpoint.includes('responses'))
+            return 'responses';
+        if (entryEndpoint.includes('messages'))
+            return 'anthropic';
+        return 'openai';
+    }
+    buildConversionRequest(request) {
+        const requestId = request.id ?? `req_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+        const endpoint = normalizeEndpoint(request.endpoint);
+        const entryEndpoint = normalizeEndpoint(request.metadata?.entryEndpoint ?? endpoint);
+        const providerProtocol = request.metadata?.providerProtocol ?? inferProviderProtocol(entryEndpoint);
+        const processMode = request.metadata?.processMode ?? 'chat';
+        const stage = request.metadata?.stage ?? 'inbound';
+        const direction = request.metadata?.direction ?? 'request';
+        const routeHint = request.metadata?.routeHint;
+        const metadataBase = request.metadata ?? {};
+        const inboundStream = resolveBoolean(metadataBase.inboundStream);
+        const outboundStream = resolveBoolean(metadataBase.outboundStream);
+        const streamFlag = this.resolveStreamFlag(stage, metadataBase, request.payload);
+        const metadata = {
+            ...metadataBase,
+            entryEndpoint,
+            providerProtocol,
+            processMode,
+            stage,
+            direction,
+            routeHint,
+            stream: streamFlag
+        };
+        if (typeof inboundStream === 'boolean') {
+            metadata.inboundStream = inboundStream;
+        }
+        if (typeof outboundStream === 'boolean') {
+            metadata.outboundStream = outboundStream;
+        }
+        const context = {
+            entryEndpoint,
+            metadata
+        };
+        const normalizedPayload = isReadable(request.payload)
+            ? { readable: request.payload }
+            : request.payload;
+        return {
+            id: requestId,
+            timestamp: Date.now(),
+            endpoint,
+            payload: normalizedPayload,
+            context,
+            options: {
+                ...(request.options ?? {}),
+                provider: providerProtocol,
+                processMode,
+                stage
+            }
+        };
+    }
+    resolveStreamFlag(stage, metadata, payload) {
+        const inboundMeta = resolveBoolean(metadata?.inboundStream);
+        const outboundMeta = resolveBoolean(metadata?.outboundStream);
+        if (stage === 'inbound' && typeof inboundMeta === 'boolean') {
+            return inboundMeta;
+        }
+        if (stage === 'outbound' && typeof outboundMeta === 'boolean') {
+            return outboundMeta;
+        }
+        if (typeof metadata?.stream === 'boolean') {
+            return metadata.stream;
+        }
+        return inferStreamFlag(payload);
+    }
+    createNodeContext(request, passthrough) {
+        const payload = request.payload;
+        const originalPayload = this.captureOriginalPayload(payload);
+        const initialData = payload && typeof payload === 'object' && !('readable' in payload)
+            ? { ...payload }
+            : {};
+        return {
+            request,
+            data: initialData,
+            pipeline: {
+                currentNode: 'init',
+                previousResults: [],
+                isPassthrough: passthrough,
+                startTime: Date.now(),
+                originalPayload
+            },
+            nodeConfig: this.sseInputNode.config
+        };
+    }
+    mergeNodeData(context, data) {
+        if (!data || typeof data !== 'object') {
+            return;
+        }
+        const target = context.data ?? {};
+        for (const [key, value] of Object.entries(data)) {
+            if (value === undefined)
+                continue;
+            target[key] = value;
+        }
+        context.data = target;
+    }
+    syncRequestPayload(context) {
+        if (!context.data || typeof context.data !== 'object') {
+            return;
+        }
+        const processed = context.data.processedRequest;
+        const standardized = context.data.standardizedRequest;
+        const source = (processed ?? standardized);
+        if (!source || typeof source !== 'object') {
+            return;
+        }
+        context.request.payload = source;
+        if (!context.data.standardizedRequest) {
+            context.data.standardizedRequest = source;
+        }
+    }
+    captureOriginalPayload(payload) {
+        if (!payload || typeof payload !== 'object')
+            return undefined;
+        if ('readable' in payload)
+            return undefined;
+        return payload;
+    }
+    updatePassthroughState(context) {
+        if (context.pipeline.isPassthrough) {
+            return;
+        }
+        const metadata = this.getRequestMetadata(context);
+        if (typeof metadata.processMode === 'string' && metadata.processMode === 'passthrough') {
+            context.pipeline.isPassthrough = true;
+        }
+    }
+    resolvePassthroughPayload(context, providerType) {
+        if (!context.pipeline.isPassthrough) {
+            return undefined;
+        }
+        const original = context.pipeline.originalPayload;
+        if (!original || typeof original !== 'object') {
+            return undefined;
+        }
+        return sanitizeProviderPayload(providerType, original, {
+            direction: 'request'
+        });
+    }
+    buildNodeConfig(options) {
+        return {
+            id: options.id,
+            type: options.type,
+            name: options.name,
+            description: `${options.name} (auto-generated)`,
+            inputFormat: options.inputFormat,
+            outputFormat: options.outputFormat,
+            rules: [],
+            validation: {
+                strict: false,
+                required: [],
+                optional: []
+            },
+            timeout: options.timeout ?? 60_000,
+            options: {}
+        };
+    }
+    buildVirtualRouterNodeConfig() {
+        return {
+            id: 'virtual-router',
+            type: NodeType.PROCESS,
+            name: 'Virtual Router Node',
+            description: 'Routes standardized chat requests to provider targets',
+            inputFormat: 'processed-request',
+            outputFormat: 'provider-target',
+            rules: [],
+            validation: {
+                strict: false,
+                required: ['processedRequest'],
+                optional: []
+            },
+            timeout: 10_000,
+            options: {
+                virtualRouter: this.virtualRouterConfig
+            }
+        };
+    }
+    resolveVirtualRouterConfig(source) {
+        if (this.isBootstrapResult(source)) {
+            return {
+                config: source.config,
+                runtimeByTarget: { ...(source.targetRuntime ?? {}) }
+            };
+        }
+        if (this.isVirtualRouterConfig(source)) {
+            return { config: source, runtimeByTarget: {} };
+        }
+        const artifacts = bootstrapVirtualRouterConfig(source);
+        return {
+            config: artifacts.config,
+            runtimeByTarget: artifacts.targetRuntime ?? {}
+        };
+    }
+    isVirtualRouterConfig(value) {
+        if (!value || typeof value !== 'object') {
+            return false;
+        }
+        const candidate = value;
+        if (typeof candidate.routing !== 'object' || typeof candidate.providers !== 'object') {
+            return false;
+        }
+        const providers = candidate.providers;
+        return Object.values(providers).every((entry) => {
+            return Boolean(entry && typeof entry === 'object' && 'providerKey' in entry);
+        });
+    }
+    isBootstrapResult(value) {
+        if (!value || typeof value !== 'object') {
+            return false;
+        }
+        const candidate = value;
+        return candidate.config !== undefined && candidate.runtime !== undefined;
+    }
+    buildCompatibilityConfig(options) {
+        return {
+            id: 'compatibility',
+            type: NodeType.PROCESS,
+            name: 'Compatibility Node',
+            inputFormat: 'processed-request',
+            outputFormat: 'processed-request',
+            rules: [],
+            validation: {
+                strict: false,
+                required: ['processedRequest'],
+                optional: []
+            },
+            timeout: 15_000,
+            options: {
+                compatibility: {
+                    profile: options.profile ?? 'default',
+                    direction: options.direction ?? 'request',
+                    executionMode: options.executionMode ?? 'core',
+                    providerMatch: options.providerMatch,
+                    providerTypeMatch: options.providerTypeMatch,
+                    protocolMatch: options.protocolMatch,
+                    requestStages: options.requestStages,
+                    responseStages: options.responseStages
+                }
+            }
+        };
+    }
+    createInputNode(nodeType, endpoint) {
+        const config = this.buildNodeConfig({
+            id: `${nodeType}:${endpoint}`,
+            type: NodeType.INPUT,
+            name: `Input(${nodeType})`,
+            inputFormat: endpoint,
+            outputFormat: 'standardized-request',
+            timeout: this.config.timeouts?.input ?? 45_000
+        });
+        switch (nodeType) {
+            case 'chat-input':
+                return new ChatInputNode(config);
+            case 'responses-input':
+                return new ResponsesInputNode(config);
+            case 'anthropic-input':
+                return new AnthropicInputNode(config);
+            default:
+                throw new SuperPipelineError(`Unsupported input node type: ${nodeType}`);
+        }
+    }
+    buildOutputNodes(timeout) {
+        const map = new Map();
+        map.set('openai', new OpenAIOutputNode(this.buildNodeConfig({
+            id: 'openai-output',
+            type: NodeType.OUTPUT,
+            name: 'OpenAI Output Node',
+            inputFormat: 'processed-request',
+            outputFormat: 'openai-chat',
+            timeout: timeout ?? 30_000
+        })));
+        map.set('anthropic', new AnthropicOutputNode(this.buildNodeConfig({
+            id: 'anthropic-output',
+            type: NodeType.OUTPUT,
+            name: 'Anthropic Output Node',
+            inputFormat: 'processed-request',
+            outputFormat: 'anthropic-messages',
+            timeout: timeout ?? 30_000
+        })));
+        map.set('responses', new ResponsesOutputNode(this.buildNodeConfig({
+            id: 'responses-output',
+            type: NodeType.OUTPUT,
+            name: 'Responses Output Node',
+            inputFormat: 'processed-request',
+            outputFormat: 'openai-responses',
+            timeout: timeout ?? 30_000
+        })));
+        return map;
+    }
+    getRequestMetadata(context) {
+        const ctx = context.request.context;
+        if (ctx && typeof ctx === 'object' && 'metadata' in ctx) {
+            const metadata = ctx.metadata;
+            if (metadata && typeof metadata === 'object') {
+                return metadata;
+            }
+        }
+        const fallback = {};
+        if (ctx && typeof ctx === 'object') {
+            ctx.metadata = fallback;
+        }
+        else {
+            context.request.context = { metadata: fallback };
+        }
+        return fallback;
+    }
+    normalizeProviderType(input) {
+        if (!input)
+            return undefined;
+        const normalized = input.toLowerCase();
+        if (normalized === 'openai')
+            return 'openai';
+        if (normalized === 'anthropic')
+            return 'anthropic';
+        if (normalized === 'responses')
+            return 'responses';
+        if (normalized === 'gemini')
+            return 'anthropic';
+        return undefined;
+    }
+}
+export class SuperPipelineError extends Error {
+    details;
+    constructor(message, details) {
+        super(message);
+        this.details = details;
+        this.name = 'SuperPipelineError';
+    }
+}
+function normalizeEndpoint(endpoint) {
+    if (!endpoint)
+        return '/v1/chat/completions';
+    let value = endpoint.trim();
+    if (!value.startsWith('/')) {
+        value = `/${value}`;
+    }
+    if (value.length > 1 && value.endsWith('/')) {
+        value = value.slice(0, -1);
+    }
+    return value.toLowerCase();
+}
+function inferProviderProtocol(endpoint) {
+    if (endpoint.includes('responses')) {
+        return 'openai-responses';
+    }
+    if (endpoint.includes('messages')) {
+        return 'anthropic-messages';
+    }
+    return 'openai-chat';
+}
+function inferStreamFlag(payload) {
+    if (isReadable(payload)) {
+        return true;
+    }
+    if (payload && typeof payload === 'object' && 'stream' in payload) {
+        const stream = payload.stream;
+        if (typeof stream === 'boolean') {
+            return stream;
+        }
+    }
+    return false;
+}
+function isReadable(payload) {
+    return payload instanceof Readable;
+}
+function resolveBoolean(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (['true', '1', 'yes', 'always'].includes(normalized))
+            return true;
+        if (['false', '0', 'no', 'never'].includes(normalized))
+            return false;
+    }
+    return undefined;
+}

package/dist/conversion/conversion-v3/response/provider-response-converter.d.ts

@@ -0,0 +1,28 @@
+import type { Readable } from 'node:stream';
+export type ProviderResponseType = 'openai' | 'anthropic' | 'responses';
+export type ClientResponseType = 'openai' | 'anthropic' | 'responses';
+export interface ConvertProviderResponseOptions {
+    entryEndpoint: string;
+    providerType: ProviderResponseType;
+    providerResponse: Record<string, unknown>;
+    requestId: string;
+    wantsStream: boolean;
+    originalRequest?: Record<string, unknown> | null;
+    metadata?: Record<string, unknown>;
+}
+type ProviderResponseResult = Record<string, unknown> | {
+    __sse_responses: Readable;
+};
+export declare class ProviderResponseConverter {
+    private readonly responseProcessNode;
+    private readonly sseOutputNode;
+    private readonly responseInputCache;
+    private readonly outputNodeCache;
+    constructor();
+    convert(options: ConvertProviderResponseOptions): Promise<ProviderResponseResult>;
+    private getResponseInputNode;
+    private getOutputNode;
+    private buildBaseContext;
+    private runNode;
+}
+export {};