@jsonstudio/llms 0.4.2

package/dist/conversion/conversion-v3/config/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 配置统一导出
+ */
+export * from './default-configs.js';
+export * from './pipeline-config-manager.js';

package/dist/conversion/conversion-v3/config/index.js

@@ -0,0 +1,5 @@
+/**
+ * 配置统一导出
+ */
+export * from './default-configs.js';
+export * from './pipeline-config-manager.js';

package/dist/conversion/conversion-v3/config/pipeline-config-manager.d.ts

@@ -0,0 +1,49 @@
+export type PipelineStreamingMode = 'auto' | 'always' | 'never';
+export interface PipelineNodeSnapshotConfig {
+    enabled?: boolean;
+    channel?: string;
+    label?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface PipelineNodeConfig {
+    id: string;
+    kind: 'sse-input' | 'sse-output' | 'sse-passthrough' | 'input' | 'process' | 'output';
+    implementation: string;
+    inputFormat?: string;
+    outputFormat?: string;
+    timeout?: number;
+    options?: Record<string, unknown>;
+    snapshot?: PipelineNodeSnapshotConfig;
+}
+export interface PipelineRouteConfig {
+    id: string;
+    mode?: 'standard' | 'passthrough' | 'custom';
+    processMode?: string;
+    name: string;
+    stage?: 'inbound' | 'outbound';
+    description?: string;
+    entryEndpoints: string[];
+    providerProtocols?: string[];
+    streaming?: PipelineStreamingMode;
+    passthrough?: {
+        enabled?: boolean;
+        mode?: 'auto' | 'forced' | 'disabled';
+        reasons?: string[];
+    };
+    nodes: PipelineNodeConfig[];
+}
+export interface PipelineConfigDocument {
+    pipelineConfigVersion?: string;
+    generatedAt?: string;
+    pipelines: PipelineRouteConfig[];
+}
+export declare class PipelineConfigManager {
+    private static instance;
+    private config;
+    private constructor();
+    static getInstance(): PipelineConfigManager;
+    static setConfig(config: PipelineConfigDocument): void;
+    static getConfig(): PipelineConfigDocument;
+    static hasConfig(): boolean;
+    static resolvePipeline(endpoint: string, providerProtocol?: string, processMode?: string, stage?: 'inbound' | 'outbound'): PipelineRouteConfig | undefined;
+}

package/dist/conversion/conversion-v3/config/pipeline-config-manager.js

@@ -0,0 +1,65 @@
+import Ajv from 'ajv';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const schema = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), 'pipeline-config.schema.json'), 'utf-8'));
+const ajv = new Ajv({ allErrors: true, strict: false });
+const validate = ajv.compile(schema);
+export class PipelineConfigManager {
+    static instance;
+    config = null;
+    constructor() { }
+    static getInstance() {
+        if (!PipelineConfigManager.instance) {
+            PipelineConfigManager.instance = new PipelineConfigManager();
+        }
+        return PipelineConfigManager.instance;
+    }
+    static setConfig(config) {
+        if (!validate(config)) {
+            const message = ajv.errorsText(validate.errors);
+            throw new Error(`Invalid pipeline config: ${message}`);
+        }
+        const manager = PipelineConfigManager.getInstance();
+        manager.config = config;
+    }
+    static getConfig() {
+        const manager = PipelineConfigManager.getInstance();
+        if (!manager.config) {
+            throw new Error('Pipeline config has not been initialized');
+        }
+        return manager.config;
+    }
+    static hasConfig() {
+        return PipelineConfigManager.getInstance().config !== null;
+    }
+    static resolvePipeline(endpoint, providerProtocol, processMode, stage) {
+        const config = PipelineConfigManager.getConfig();
+        const normalizedEndpoint = (endpoint || '').toLowerCase();
+        const candidates = config.pipelines.filter(pipeline => {
+            if (stage && pipeline.stage && pipeline.stage !== stage)
+                return false;
+            return pipeline.entryEndpoints.some(route => route.toLowerCase() === normalizedEndpoint);
+        });
+        if (!candidates.length)
+            return undefined;
+        const normalizedProvider = (providerProtocol || '').toLowerCase();
+        const providerCandidates = normalizedProvider
+            ? candidates.filter(pipeline => Array.isArray(pipeline.providerProtocols) &&
+                pipeline.providerProtocols.some(proto => proto.toLowerCase() === normalizedProvider))
+            : [];
+        const candidatePool = providerCandidates.length ? providerCandidates : candidates;
+        if (processMode) {
+            const normalizedMode = processMode.toLowerCase();
+            const modeMatch = candidatePool.find(pipeline => typeof pipeline.processMode === 'string' &&
+                pipeline.processMode.toLowerCase() === normalizedMode);
+            if (modeMatch)
+                return modeMatch;
+        }
+        if (providerCandidates.length) {
+            return providerCandidates[0];
+        }
+        const defaultRoute = candidatePool.find(pipeline => !pipeline.providerProtocols || pipeline.providerProtocols.length === 0);
+        return defaultRoute ?? candidatePool[0];
+    }
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Conversion V3 - 节点流水线架构主入口
+ *
+ * 提供统一的转换接口和便捷方法
+ */
+export * from './types/index.js';
+export * as Standards from './standards/index.js';
+export * from './nodes/index.js';
+export * from './config/index.js';
+export * from './compatibility/index.js';
+export * from './adapters/index.js';

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

@@ -0,0 +1,17 @@
+/**
+ * Conversion V3 - 节点流水线架构主入口
+ *
+ * 提供统一的转换接口和便捷方法
+ */
+// 导出所有类型
+export * from './types/index.js';
+// 导出标准接口（命名空间形式，避免与 legacy 类型冲突）
+export * as Standards from './standards/index.js';
+// 导出所有节点
+export * from './nodes/index.js';
+// 导出配置
+export * from './config/index.js';
+// 导出兼容层能力
+export * from './compatibility/index.js';
+// 导出适配器
+export * from './adapters/index.js';

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

@@ -0,0 +1,56 @@
+/**
+ * 节点统一导出
+ */
+export { BaseInputNode } from './input/base-input-node.js';
+export { ChatInputNode } from './input/chat-input-node.js';
+export { AnthropicInputNode } from './input/anthropic-input-node.js';
+export { ResponsesInputNode } from './input/responses-input-node.js';
+export { BaseProcessNode } from './process/base-process-node.js';
+export { ChatProcessNode } from './process/chat-process-node.js';
+export { PassthroughProcessNode } from './process/passthrough-process-node.js';
+export { BaseOutputNode } from './output/base-output-node.js';
+export { OpenAIOutputNode } from './output/openai-output-node.js';
+export { AnthropicOutputNode } from './output/anthropic-output-node.js';
+export { ResponsesOutputNode } from './output/responses-output-node.js';
+export { SSEInputNode, SSEOutputNode, SSEPassthroughNode } from './sse/index.js';
+export { OpenAIResponseInputNode, AnthropicResponseInputNode, ResponsesResponseInputNode } from './response/index.js';
+import { BaseInputNode } from './input/index.js';
+import { BaseOutputNode } from './output/index.js';
+import type { NodeConfig, NodeType, PipelineNode } from '../types/index.js';
+/**
+ * 节点工厂
+ */
+export declare class NodeFactory {
+    /**
+     * 创建输入节点
+     */
+    static createInputNode(nodeType: string, config: NodeConfig): BaseInputNode;
+    /**
+     * 创建处理节点
+     */
+    static createProcessNode(nodeType: string, config: NodeConfig): PipelineNode;
+    /**
+     * 创建输出节点
+     */
+    static createOutputNode(nodeType: string, config: NodeConfig): BaseOutputNode;
+    /**
+     * 根据类型创建节点
+     */
+    static createNode(nodeType: NodeType, nodeId: string, config: NodeConfig): any;
+    /**
+     * 获取所有支持的输入节点类型
+     */
+    static getSupportedInputNodeTypes(): string[];
+    /**
+     * 获取所有支持的处理节点类型
+     */
+    static getSupportedProcessNodeTypes(): string[];
+    /**
+     * 获取所有支持的输出节点类型
+     */
+    static getSupportedOutputNodeTypes(): string[];
+    /**
+     * 获取所有支持的节点类型
+     */
+    static getAllSupportedNodeTypes(): Record<NodeType, string[]>;
+}

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

@@ -0,0 +1,149 @@
+/**
+ * 节点统一导出
+ */
+// 输入节点
+export { BaseInputNode } from './input/base-input-node.js';
+export { ChatInputNode } from './input/chat-input-node.js';
+export { AnthropicInputNode } from './input/anthropic-input-node.js';
+export { ResponsesInputNode } from './input/responses-input-node.js';
+// 处理节点
+export { BaseProcessNode } from './process/base-process-node.js';
+export { ChatProcessNode } from './process/chat-process-node.js';
+export { PassthroughProcessNode } from './process/passthrough-process-node.js';
+// 输出节点
+export { BaseOutputNode } from './output/base-output-node.js';
+export { OpenAIOutputNode } from './output/openai-output-node.js';
+export { AnthropicOutputNode } from './output/anthropic-output-node.js';
+export { ResponsesOutputNode } from './output/responses-output-node.js';
+export { SSEInputNode, SSEOutputNode, SSEPassthroughNode } from './sse/index.js';
+export { OpenAIResponseInputNode, AnthropicResponseInputNode, ResponsesResponseInputNode } from './response/index.js';
+// 节点工厂函数
+import { ChatInputNode, AnthropicInputNode, ResponsesInputNode, GeminiInputNode } from './input/index.js';
+import { ChatProcessNode, PassthroughProcessNode, ResponseProcessNode, CompatibilityProcessNode, VirtualRouterProcessNode } from './process/index.js';
+import { OpenAIOutputNode, AnthropicOutputNode, ResponsesOutputNode } from './output/index.js';
+import { SSEInputNode, SSEOutputNode, SSEPassthroughNode } from './sse/index.js';
+import { OpenAIResponseInputNode, AnthropicResponseInputNode, ResponsesResponseInputNode, ChatToResponsesResponseNode } from './response/index.js';
+/**
+ * 节点工厂
+ */
+export class NodeFactory {
+    /**
+     * 创建输入节点
+     */
+    static createInputNode(nodeType, config) {
+        const impl = config.__implementation || nodeType;
+        switch (impl) {
+            case 'sse-input':
+                return new SSEInputNode(nodeType, config);
+            case 'chat-input':
+                return new ChatInputNode(config);
+            case 'anthropic-input':
+                return new AnthropicInputNode(config);
+            case 'responses-input':
+                return new ResponsesInputNode(config);
+            case 'gemini-input':
+                return new GeminiInputNode(config);
+            case 'openai-response-input':
+                return new OpenAIResponseInputNode(nodeType, config);
+            case 'anthropic-response-input':
+                return new AnthropicResponseInputNode(nodeType, config);
+            case 'responses-response-input':
+                return new ResponsesResponseInputNode(nodeType, config);
+            case 'chat-to-responses-response-input':
+                return new ChatToResponsesResponseNode(nodeType, config);
+            default:
+                throw new Error(`Unknown input node type: ${nodeType}`);
+        }
+    }
+    /**
+     * 创建处理节点
+     */
+    static createProcessNode(nodeType, config) {
+        const impl = config.__implementation || nodeType;
+        switch (impl) {
+            case 'sse-passthrough':
+                return new SSEPassthroughNode(nodeType, config);
+            case 'chat-process':
+                return new ChatProcessNode(config);
+            case 'passthrough-process':
+                return new PassthroughProcessNode(config);
+            case 'response-process':
+                return new ResponseProcessNode(nodeType, config);
+            case 'compatibility-process':
+                return new CompatibilityProcessNode(nodeType, config);
+            case 'virtual-router-process':
+                return new VirtualRouterProcessNode(nodeType, config);
+            default:
+                throw new Error(`Unknown process node type: ${nodeType}`);
+        }
+    }
+    /**
+     * 创建输出节点
+     */
+    static createOutputNode(nodeType, config) {
+        const impl = config.__implementation || nodeType;
+        switch (impl) {
+            case 'sse-output':
+                return new SSEOutputNode(nodeType, config);
+            case 'openai-output':
+                return new OpenAIOutputNode(config);
+            case 'anthropic-output':
+                return new AnthropicOutputNode(config);
+            case 'responses-output':
+                return new ResponsesOutputNode(config);
+            default:
+                throw new Error(`Unknown output node type: ${nodeType}`);
+        }
+    }
+    /**
+     * 根据类型创建节点
+     */
+    static createNode(nodeType, nodeId, config) {
+        switch (nodeType) {
+            case 'input':
+                return this.createInputNode(nodeId, config);
+            case 'process':
+                return this.createProcessNode(nodeId, config);
+            case 'output':
+                return this.createOutputNode(nodeId, config);
+            default:
+                throw new Error(`Unknown node type: ${nodeType}`);
+        }
+    }
+    /**
+     * 获取所有支持的输入节点类型
+     */
+    static getSupportedInputNodeTypes() {
+        return [
+            'chat-input',
+            'anthropic-input',
+            'responses-input',
+            'openai-response-input',
+            'anthropic-response-input',
+            'responses-response-input',
+            'sse-input'
+        ];
+    }
+    /**
+     * 获取所有支持的处理节点类型
+     */
+    static getSupportedProcessNodeTypes() {
+        return ['chat-process', 'passthrough-process', 'response-process', 'compatibility-process', 'virtual-router-process'];
+    }
+    /**
+     * 获取所有支持的输出节点类型
+     */
+    static getSupportedOutputNodeTypes() {
+        return ['openai-output', 'anthropic-output', 'responses-output'];
+    }
+    /**
+     * 获取所有支持的节点类型
+     */
+    static getAllSupportedNodeTypes() {
+        return {
+            input: this.getSupportedInputNodeTypes(),
+            process: this.getSupportedProcessNodeTypes(),
+            output: this.getSupportedOutputNodeTypes()
+        };
+    }
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Anthropic 输入节点
+ *
+ * 基于 anthropic-converter.ts 适配为节点架构
+ */
+import { BaseInputNode } from './base-input-node.js';
+import type { NodeContext, NodeConfig, NodeResult, StandardizedMessage, StandardizedTool } from '../../types/index.js';
+/**
+ * Anthropic 输入节点实现
+ *
+ * 负责将 Anthropic 格式转换为标准化格式
+ */
+export declare class AnthropicInputNode extends BaseInputNode {
+    constructor(config: NodeConfig);
+    protected isHubEnabled(): boolean;
+    protected runHubConversion(context: NodeContext, startTime: number): Promise<NodeResult>;
+    private legacyRemoved;
+    protected preprocessInput(_payload: Record<string, unknown>, _context: NodeContext): Promise<Record<string, unknown>>;
+    protected convertMessages(_payload: Record<string, unknown>, _context: NodeContext): Promise<StandardizedMessage[]>;
+    protected convertTools(_payload: Record<string, unknown>, _context: NodeContext): Promise<StandardizedTool[]>;
+    protected extractParameters(_payload: Record<string, unknown>, _context: NodeContext): Promise<Record<string, unknown>>;
+    protected captureContext(_payload: Record<string, unknown>, _context: NodeContext): Promise<Record<string, unknown>>;
+    protected postprocessMessages(_messages: unknown[], _context: NodeContext): Promise<StandardizedMessage[]>;
+    protected postprocessTools(_tools: unknown[], _context: NodeContext): Promise<StandardizedTool[]>;
+}

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

@@ -0,0 +1,56 @@
+/**
+ * Anthropic 输入节点
+ *
+ * 基于 anthropic-converter.ts 适配为节点架构
+ */
+import { BaseInputNode } from './base-input-node.js';
+import { NodeType, ConversionError } from '../../types/index.js';
+import { runHubInboundConversion, shouldUseHub } from '../../../hub/node-support.js';
+/**
+ * Anthropic 输入节点实现
+ *
+ * 负责将 Anthropic 格式转换为标准化格式
+ */
+export class AnthropicInputNode extends BaseInputNode {
+    constructor(config) {
+        super('anthropic-input', NodeType.INPUT, 'Anthropic Input Node', config);
+    }
+    isHubEnabled() {
+        return shouldUseHub('anthropic-messages');
+    }
+    async runHubConversion(context, startTime) {
+        return runHubInboundConversion({
+            protocol: 'anthropic-messages',
+            rawRequest: context.data,
+            nodeContext: context,
+            nodeId: this.id,
+            inputFormat: this.config.inputFormat,
+            outputFormat: this.config.outputFormat,
+            startTime
+        });
+    }
+    legacyRemoved(stage) {
+        throw new ConversionError(`AnthropicInputNode legacy stage '${stage}' removed (hub-only mode)`, this.id);
+    }
+    async preprocessInput(_payload, _context) {
+        return this.legacyRemoved('preprocessInput');
+    }
+    async convertMessages(_payload, _context) {
+        return this.legacyRemoved('convertMessages');
+    }
+    async convertTools(_payload, _context) {
+        return this.legacyRemoved('convertTools');
+    }
+    async extractParameters(_payload, _context) {
+        return this.legacyRemoved('extractParameters');
+    }
+    async captureContext(_payload, _context) {
+        return this.legacyRemoved('captureContext');
+    }
+    async postprocessMessages(_messages, _context) {
+        return this.legacyRemoved('postprocessMessages');
+    }
+    async postprocessTools(_tools, _context) {
+        return this.legacyRemoved('postprocessTools');
+    }
+}

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

@@ -0,0 +1,75 @@
+/**
+ * 输入节点基类
+ *
+ * 基于现有 converter-base.ts 适配为节点架构
+ */
+import { PipelineNode, NodeContext, NodeResult, NodeConfig, NodeStatus, ValidationResult, NodeType } from '../../types/index.js';
+import type { StandardizedMessage, StandardizedTool } from '../../types/index.js';
+/**
+ * 输入节点抽象基类
+ *
+ * 提供统一的输入转换流程和接口
+ */
+export declare abstract class BaseInputNode implements PipelineNode {
+    readonly id: string;
+    readonly type: NodeType.INPUT;
+    readonly name: string;
+    config: NodeConfig;
+    status: NodeStatus;
+    constructor(id: string, type: NodeType.INPUT, name: string, config: NodeConfig);
+    /**
+     * 主执行方法 - 实现统一的转换流水线
+     */
+    execute(context: NodeContext): Promise<NodeResult>;
+    protected isHubEnabled(_context: NodeContext): boolean;
+    protected runHubConversion(_context: NodeContext, _startTime: number): Promise<NodeResult>;
+    private executeWithHub;
+    /**
+     * 验证输入数据
+     */
+    validate(data: Record<string, unknown>): ValidationResult;
+    /**
+     * 前置验证 - 确保必要字段存在
+     */
+    private validatePayload;
+    /**
+     * 输入标准化预处理
+     */
+    protected abstract preprocessInput(payload: Record<string, unknown>, context: NodeContext): Promise<Record<string, unknown>>;
+    /**
+     * 转换消息列表
+     */
+    protected abstract convertMessages(payload: Record<string, unknown>, context: NodeContext): Promise<StandardizedMessage[]>;
+    /**
+     * 转换工具列表
+     */
+    protected abstract convertTools(payload: Record<string, unknown>, context: NodeContext): Promise<StandardizedTool[]>;
+    /**
+     * 提取参数
+     */
+    protected abstract extractParameters(payload: Record<string, unknown>, context: NodeContext): Promise<Record<string, unknown>>;
+    /**
+     * 捕获上下文
+     */
+    protected abstract captureContext(payload: Record<string, unknown>, context: NodeContext): Promise<Record<string, unknown>>;
+    /**
+     * 后置处理消息
+     */
+    protected abstract postprocessMessages(messages: unknown[], context: NodeContext): Promise<any[]>;
+    /**
+     * 后置处理工具
+     */
+    protected abstract postprocessTools(tools: unknown[], context: NodeContext): Promise<any[]>;
+    /**
+     * 后置验证
+     */
+    private validateResult;
+    /**
+     * 工具方法：提取必需的字符串字段
+     */
+    protected extractRequiredString(obj: Record<string, unknown>, field: string): string;
+    /**
+     * 工具方法：安全类型转换
+     */
+    protected safeCast<T>(value: unknown, expectedType: 'string' | 'number' | 'boolean'): T | undefined;
+}