@jsonstudio/llms 0.4.2

package/dist/conversion/conversion-v3/types/pipeline-types.d.ts

@@ -0,0 +1,246 @@
+/**
+ * 流水线相关类型定义
+ */
+import type { NodeResult, NodeConfig, PipelineNode } from './node-types.js';
+import type { ConversionRequest, ConversionResponse } from './request-types.js';
+/**
+ * 流水线执行模式
+ */
+export declare enum PipelineMode {
+    /** 标准模式：执行所有节点 */
+    STANDARD = "standard",
+    /** Passthrough 模式：直接传递 */
+    PASSTHROUGH = "passthrough",
+    /** 自定义模式：用户定义执行逻辑 */
+    CUSTOM = "custom"
+}
+/**
+ * 流水线状态
+ */
+export declare enum PipelineStatus {
+    IDLE = "idle",
+    RUNNING = "running",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    CANCELLED = "cancelled"
+}
+/**
+ * 流水线配置
+ */
+export interface PipelineConfig {
+    /** 流水线唯一标识 */
+    id: string;
+    /** 流水线名称 */
+    name: string;
+    /** 流水线描述 */
+    description?: string;
+    /** 节点配置列表 */
+    nodes: NodeConfig[];
+    /** 执行模式 */
+    mode: PipelineMode;
+    /** 自定义运行模式（如 chat/passthrough） */
+    processMode?: string;
+    /** 超时设置（毫秒） */
+    timeout?: number;
+    /** 重试配置 */
+    retry?: RetryConfig;
+    /** 监控配置 */
+    monitoring?: MonitoringConfig;
+    /** 自定义选项 */
+    options?: Record<string, unknown>;
+}
+/**
+ * 流水线接口
+ */
+export interface ConversionPipeline {
+    /** 流水线唯一标识 */
+    readonly id: string;
+    /** 流水线名称 */
+    readonly name: string;
+    /** 流水线节点列表 */
+    readonly nodes: PipelineNode[];
+    /** 流水线配置 */
+    readonly config: PipelineConfig;
+    /**
+     * 执行流水线
+     *
+     * @param request 转换请求
+     * @returns 转换结果
+     */
+    execute(request: ConversionRequest): Promise<PipelineResult>;
+    /**
+     * 获取流水线状态
+     *
+     * @returns 流水线状态
+     */
+    getStatus(): PipelineStatus;
+    /**
+     * 取消流水线执行
+     */
+    cancel(): void;
+    /**
+     * 重置流水线
+     */
+    reset(): void;
+    /**
+     * 获取执行统计信息
+     *
+     * @returns 统计信息
+     */
+    getStats(): PipelineStats;
+}
+/**
+ * 流水线执行结果
+ */
+export interface PipelineResult {
+    /** 是否执行成功 */
+    success: boolean;
+    /** 最终输出数据 */
+    data?: Record<string, unknown>;
+    /** 转换响应 */
+    response?: ConversionResponse;
+    /** 执行错误 */
+    error?: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+        cause?: Error;
+        node?: string;
+    };
+    /** 执行元数据 */
+    metadata: {
+        /** 流水线ID */
+        pipeline: string;
+        /** 执行模式 */
+        mode: PipelineMode;
+        /** 总执行时间 */
+        executionTime: number;
+        /** 开始时间 */
+        startTime: number;
+        /** 结束时间 */
+        endTime: number;
+        /** 执行的节点列表 */
+        nodes: string[];
+        /** Passthrough 信息 */
+        passthrough?: {
+            enabled: boolean;
+            reason: string;
+            originalFormat?: string;
+        };
+        /** 当前流水线状态（补充信息） */
+        status?: PipelineStatus;
+    };
+    /** 节点执行结果 */
+    nodeResults: NodeResult[];
+    /** 性能指标 */
+    performance: {
+        /** 节点执行时间分布 */
+        nodeExecutionTimes: Record<string, number>;
+        /** 内存使用情况 */
+        memoryUsage?: {
+            peak: number;
+            average: number;
+            final: number;
+        };
+        /** 数据处理量 */
+        dataProcessed: {
+            messages: number;
+            tools: number;
+            tokens: number;
+            /** 可选：响应字节长度或字符长度 */
+            responseSize?: number;
+        };
+    };
+}
+/**
+ * 流水线统计信息
+ */
+export interface PipelineStats {
+    /** 总执行次数 */
+    totalExecutions: number;
+    /** 成功次数 */
+    successCount: number;
+    /** 失败次数 */
+    failureCount: number;
+    /** 平均执行时间 */
+    averageExecutionTime: number;
+    /** 最大执行时间 */
+    maxExecutionTime: number;
+    /** 最小执行时间 */
+    minExecutionTime: number;
+    /** Passthrough 次数 */
+    passthroughCount: number;
+    /** 最后执行时间 */
+    lastExecution?: Date;
+    /** 各节点执行次数 */
+    nodeExecutions: Record<string, number>;
+}
+/**
+ * 流水线工厂接口
+ */
+export interface PipelineFactory {
+    /**
+     * 根据请求创建流水线
+     *
+     * @param request 转换请求
+     * @returns 流水线实例
+     */
+    createPipeline(request: ConversionRequest): ConversionPipeline;
+    /**
+     * 根据配置创建流水线
+     *
+     * @param config 流水线配置
+     * @returns 流水线实例
+     */
+    createCustomPipeline(config: PipelineConfig): ConversionPipeline;
+    /**
+     * 注册节点类型
+     *
+     * @param type 节点类型
+     * @param factory 节点工厂函数
+     */
+    registerNodeType(type: string, factory: () => PipelineNode): void;
+    /**
+     * 获取支持的端点列表
+     *
+     * @returns 支持的端点列表
+     */
+    getSupportedEndpoints(): string[];
+    /**
+     * 检查是否需要 Passthrough
+     *
+     * @param request 转换请求
+     * @returns 是否需要 Passthrough
+     */
+    needsPassthrough(request: ConversionRequest): boolean;
+}
+/**
+ * 流水线编排器接口
+ */
+export interface PipelineOrchestrator {
+    /**
+     * 执行流水线
+     *
+     * @param pipeline 流水线实例
+     * @param request 转换请求
+     * @returns 执行结果
+     */
+    execute(pipeline: ConversionPipeline, request: ConversionRequest): Promise<PipelineResult>;
+    /**
+     * 并行执行多个流水线
+     *
+     * @param pipelines 流水线数组
+     * @param requests 请求数组
+     * @returns 结果数组
+     */
+    executeParallel(pipelines: ConversionPipeline[], requests: ConversionRequest[]): Promise<PipelineResult[]>;
+    /**
+     * 批量执行流水线
+     *
+     * @param pipeline 流水线实例
+     * @param requests 请求数组
+     * @returns 结果数组
+     */
+    executeBatch(pipeline: ConversionPipeline, requests: ConversionRequest[]): Promise<PipelineResult[]>;
+}
+import type { RetryConfig, MonitoringConfig } from './node-types.js';

package/dist/conversion/conversion-v3/types/pipeline-types.js

@@ -0,0 +1,26 @@
+/**
+ * 流水线相关类型定义
+ */
+/**
+ * 流水线执行模式
+ */
+export var PipelineMode;
+(function (PipelineMode) {
+    /** 标准模式：执行所有节点 */
+    PipelineMode["STANDARD"] = "standard";
+    /** Passthrough 模式：直接传递 */
+    PipelineMode["PASSTHROUGH"] = "passthrough";
+    /** 自定义模式：用户定义执行逻辑 */
+    PipelineMode["CUSTOM"] = "custom";
+})(PipelineMode || (PipelineMode = {}));
+/**
+ * 流水线状态
+ */
+export var PipelineStatus;
+(function (PipelineStatus) {
+    PipelineStatus["IDLE"] = "idle";
+    PipelineStatus["RUNNING"] = "running";
+    PipelineStatus["COMPLETED"] = "completed";
+    PipelineStatus["FAILED"] = "failed";
+    PipelineStatus["CANCELLED"] = "cancelled";
+})(PipelineStatus || (PipelineStatus = {}));

package/dist/conversion/conversion-v3/types/request-types.d.ts

@@ -0,0 +1,293 @@
+/**
+ * 请求和响应相关类型定义
+ */
+/**
+ * 转换请求
+ */
+export interface ConversionRequest {
+    /** 请求唯一标识 */
+    id: string;
+    /** 请求时间戳 */
+    timestamp: number;
+    /** 目标端点 */
+    endpoint: string;
+    /** 原始请求数据 */
+    payload: Record<string, unknown>;
+    /** 请求上下文 */
+    context: Record<string, unknown>;
+    /** 请求选项 */
+    options?: {
+        /** 上游 provider 类型（openai/anthropic/responses/...） */
+        provider?: string;
+        /** 规范化 provider 大类（openai/anthropic/responses/gemini） */
+        providerType?: string;
+        /** 首选流式传输格式 */
+        streamingFormat?: 'sse' | 'websocket' | 'polling' | string;
+        /** 指定运行模式（chat/passthrough 等） */
+        processMode?: string;
+        /** 目标阶段（inbound/outbound） */
+        stage?: 'inbound' | 'outbound';
+    };
+}
+/**
+ * 转换响应
+ */
+export interface ConversionResponse {
+    /** 响应唯一标识 */
+    id: string;
+    /** 对应的请求ID */
+    requestId: string;
+    /** 响应时间戳 */
+    timestamp: number;
+    /** 响应数据 */
+    data: Record<string, unknown>;
+    /** 响应格式 */
+    format: string;
+    /** 响应元数据 */
+    metadata: {
+        /** 转换耗时 */
+        conversionTime: number;
+        /** 是否为 Passthrough */
+        isPassthrough: boolean;
+        /** 原始格式 */
+        originalFormat?: string;
+        /** 目标格式 */
+        targetFormat?: string;
+        /** 流水线信息 */
+        pipeline?: {
+            id: string;
+            nodes: string[];
+            mode: string;
+        };
+        /** 使用的转换版本（v2/v3 等） */
+        version?: string;
+    };
+}
+/**
+ * 标准化请求格式
+ *
+ * 所有输入节点转换后的统一格式
+ */
+export interface StandardizedRequest {
+    /** 模型名称 */
+    model: string;
+    /** 标准化的 OpenAI Chat 消息列表 */
+    messages: StandardizedMessage[];
+    /** 标准化的工具定义 */
+    tools?: StandardizedTool[];
+    /** 标准化参数 */
+    parameters: {
+        /** 温度 (0-2) */
+        temperature?: number;
+        /** 最大生成token数 */
+        max_tokens?: number;
+        /** 采样策略 */
+        top_p?: number;
+        /** 频率惩罚 */
+        frequency_penalty?: number;
+        /** 存在惩罚 */
+        presence_penalty?: number;
+        /** 停止词 */
+        stop?: string | string[];
+        /** 是否流式输出 */
+        stream?: boolean;
+        /** 其他参数 */
+        [key: string]: unknown;
+    };
+    /** 元数据信息 */
+    metadata: {
+        /** 原始端点类型 */
+        originalEndpoint: string;
+        /** 捕获的端点特定上下文 */
+        capturedContext?: Record<string, unknown>;
+        /** 请求ID */
+        requestId?: string;
+        /** 是否为流式请求 */
+        stream?: boolean;
+        /** 工具选择策略 */
+        toolChoice?: ToolChoice;
+        /** 虚拟路由器提供的目标 Provider Key */
+        providerKey?: string;
+        /** 虚拟路由器提供的 Provider 类型 */
+        providerType?: string;
+        /** 虚拟路由器提供的处理模式 */
+        processMode?: 'chat' | 'passthrough';
+        /** 客户端提供的路由提示 */
+        routeHint?: string;
+        /** 原始请求携带的模型（virtual router 改写前） */
+        originalModelId?: string;
+        /** 客户端模型标识（与 originalModelId 保持一致，用于响应恢复） */
+        clientModelId?: string;
+        /** 虚拟路由器指派给上游的模型 */
+        assignedModelId?: string;
+    };
+}
+/**
+ * 处理后的请求格式
+ *
+ * 处理节点执行后的格式
+ */
+export interface ProcessedRequest extends StandardizedRequest {
+    /** 处理结果 */
+    processed: {
+        /** 处理时间 */
+        timestamp: number;
+        /** 处理逻辑应用 */
+        appliedRules: string[];
+        /** 处理状态 */
+        status: 'success' | 'partial' | 'failed';
+    };
+    /** 处理元数据 */
+    processingMetadata: {
+        /** 工具调用解析结果 */
+        toolCalls?: ToolCallResult[];
+        /** 流式处理信息 */
+        streaming?: {
+            enabled: boolean;
+            chunkCount?: number;
+            totalTokens?: number;
+        };
+        /** 上下文处理结果 */
+        context?: {
+            systemPrompt?: string;
+            conversationHistory?: string[];
+            relevantContext?: Record<string, unknown>;
+        };
+        /** Passthrough 标记（仅在直通流程中使用） */
+        passthrough?: boolean;
+    };
+}
+/**
+ * 标准化消息
+ */
+export interface StandardizedMessage {
+    /** 消息角色 */
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    /** 消息内容 */
+    content: string | null;
+    /** 工具调用（仅assistant角色） */
+    tool_calls?: ToolCall[];
+    /** 工具调用ID（仅tool角色） */
+    tool_call_id?: string;
+    /** 消息名称（可选） */
+    name?: string;
+    /** 额外元数据 */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * 标准化工具
+ */
+export interface StandardizedTool {
+    /** 工具类型（通常是 'function'） */
+    type: 'function';
+    /** 工具函数定义 */
+    function: {
+        /** 函数名称 */
+        name: string;
+        /** 函数描述 */
+        description?: string;
+        /** 函数参数模式 */
+        parameters: {
+            type: 'object';
+            properties: Record<string, any>;
+            required?: string[];
+            additionalProperties?: boolean;
+        };
+        /** 是否严格模式 */
+        strict?: boolean;
+    };
+}
+/**
+ * 工具调用
+ */
+export interface ToolCall {
+    /** 调用ID */
+    id: string;
+    /** 工具类型 */
+    type: 'function';
+    /** 函数调用 */
+    function: {
+        /** 函数名称 */
+        name: string;
+        /** 函数参数（JSON字符串） */
+        arguments: string;
+    };
+}
+/**
+ * 工具调用结果
+ */
+export interface ToolCallResult {
+    /** 工具调用ID */
+    tool_call_id: string;
+    /** 执行状态 */
+    status: 'success' | 'error' | 'timeout' | 'pending';
+    /** 执行结果 */
+    result?: any;
+    /** 错误信息 */
+    error?: string;
+    /** 执行时间 */
+    executionTime?: number;
+}
+/**
+ * 工具选择策略
+ */
+export type ToolChoice = 'none' | 'auto' | 'required' | {
+    type: 'function';
+    function: {
+        name: string;
+    };
+} | Record<string, unknown>;
+/**
+ * 端点信息
+ */
+export interface EndpointInfo {
+    /** 端点路径 */
+    path: string;
+    /** 端点类型 */
+    type: 'chat' | 'completions' | 'embeddings' | 'responses' | 'messages';
+    /** 支持的输入格式 */
+    inputFormats: string[];
+    /** 支持的输出格式 */
+    outputFormats: string[];
+    /** 是否支持流式 */
+    supportsStreaming: boolean;
+    /** 是否支持工具调用 */
+    supportsTools: boolean;
+    /** 默认流水线配置 */
+    defaultPipeline?: string;
+}
+/**
+ * 格式信息
+ */
+export interface FormatInfo {
+    /** 格式名称 */
+    name: string;
+    /** 格式版本 */
+    version: string;
+    /** 格式描述 */
+    description?: string;
+    /** 支持的功能 */
+    features: string[];
+    /** 数据模式 */
+    schema?: any;
+}
+/**
+ * 转换错误类型
+ *
+ * 用于在各个节点之间传递结构化错误信息。
+ */
+export declare class ConversionError extends Error {
+    /** 出错的节点ID */
+    readonly nodeId?: string;
+    /** 错误阶段（例如 validation / processing 等） */
+    readonly stage?: string;
+    /** 底层错误原因 */
+    readonly cause?: Error;
+    constructor(message: string, 
+    /** 出错的节点ID */
+    nodeId?: string, 
+    /** 错误阶段（例如 validation / processing 等） */
+    stage?: string, 
+    /** 底层错误原因 */
+    cause?: Error);
+}

package/dist/conversion/conversion-v3/types/request-types.js

@@ -0,0 +1,26 @@
+/**
+ * 请求和响应相关类型定义
+ */
+/**
+ * 转换错误类型
+ *
+ * 用于在各个节点之间传递结构化错误信息。
+ */
+export class ConversionError extends Error {
+    nodeId;
+    stage;
+    cause;
+    constructor(message, 
+    /** 出错的节点ID */
+    nodeId, 
+    /** 错误阶段（例如 validation / processing 等） */
+    stage, 
+    /** 底层错误原因 */
+    cause) {
+        super(message);
+        this.nodeId = nodeId;
+        this.stage = stage;
+        this.cause = cause;
+        this.name = 'ConversionError';
+    }
+}

package/dist/conversion/conversion-v3/utils/provider-payload-sanitizer.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderType } from '../nodes/output/output-decision.js';
+export interface SanitizeProviderPayloadOptions {
+    direction?: 'request' | 'response';
+}
+/**
+ * 确保存放到 provider 客户端的 payload 只包含协议字段，避免将内部元数据泄露到上游。
+ * - 默认仅在 request 方向执行净化；response 方向返回结构化拷贝。
+ * - 通过白名单 + 前缀检测删除 `providerType`、`routeHint` 等内部字段。
+ */
+export declare function sanitizeProviderPayload(providerType: ProviderType | undefined, payload: Record<string, unknown> | undefined, options?: SanitizeProviderPayloadOptions): Record<string, unknown> | undefined;

package/dist/conversion/conversion-v3/utils/provider-payload-sanitizer.js

@@ -0,0 +1,103 @@
+const INTERNAL_FIELD_NAMES = new Set([
+    'providertype',
+    'provider_type',
+    'metadata',
+    'provider',
+    'providerid',
+    'provider_id',
+    'providerkey',
+    'provider_key',
+    'providerprotocol',
+    'provider_protocol',
+    'providerprofile',
+    'provider_profile',
+    'providerfamily',
+    'routehint',
+    'entryendpoint',
+    'entry_endpoint',
+    'target',
+    'compatibilityprofile',
+    'compatibility_profile',
+    'compatprofile',
+    'contextmetadata',
+    'metadata_context',
+    'clientheaders',
+    'client_headers',
+    'serverheaders',
+    'server_headers',
+    'noderesults',
+    'node_results',
+    'processmode',
+    'stage',
+    'direction',
+    'passthrough',
+    '__raw_request_body',
+    '__raw_response_body',
+    '__routecodex_internal',
+    '__codex_internal'
+]);
+const INTERNAL_FIELD_PREFIXES = ['__rcc', '__routecodex', '__codex', '__internal', '_internal'];
+/**
+ * 确保存放到 provider 客户端的 payload 只包含协议字段，避免将内部元数据泄露到上游。
+ * - 默认仅在 request 方向执行净化；response 方向返回结构化拷贝。
+ * - 通过白名单 + 前缀检测删除 `providerType`、`routeHint` 等内部字段。
+ */
+export function sanitizeProviderPayload(providerType, payload, options = {}) {
+    if (!payload || typeof payload !== 'object') {
+        return payload;
+    }
+    const direction = options.direction ?? 'request';
+    if (direction !== 'request') {
+        return clonePayload(payload);
+    }
+    const source = payload;
+    return sanitizeObject(source);
+}
+function sanitizeObject(source) {
+    const result = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (isInternalKey(key)) {
+            continue;
+        }
+        result[key] = sanitizeValue(value);
+    }
+    return result;
+}
+function sanitizeValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(item => typeof item === 'object' && item !== null
+            ? sanitizeObject(item)
+            : item);
+    }
+    if (value && typeof value === 'object') {
+        return sanitizeObject(value);
+    }
+    return value;
+}
+function clonePayload(payload) {
+    return cloneValue(payload);
+}
+function cloneValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(item => typeof item === 'object' && item !== null ? cloneValue(item) : item);
+    }
+    if (value && typeof value === 'object') {
+        const result = {};
+        for (const [key, entry] of Object.entries(value)) {
+            result[key] = cloneValue(entry);
+        }
+        return result;
+    }
+    return value;
+}
+function isInternalKey(key) {
+    if (!key)
+        return false;
+    const normalized = key.trim().toLowerCase();
+    if (!normalized)
+        return false;
+    if (INTERNAL_FIELD_NAMES.has(normalized)) {
+        return true;
+    }
+    return INTERNAL_FIELD_PREFIXES.some(prefix => normalized.startsWith(prefix));
+}