@jsonstudio/llms 0.4.2 → 0.4.4

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

@@ -1,566 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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 {};