@jsonstudio/llms 0.4.3 → 0.4.5

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

@@ -1,237 +0,0 @@
-/**
- * 输入节点基类
- *
- * 基于现有 converter-base.ts 适配为节点架构
- */
-import { NodeStatus, ConversionError } from '../../types/index.js';
-/**
- * 输入节点抽象基类
- *
- * 提供统一的输入转换流程和接口
- */
-export class BaseInputNode {
-    id;
-    type;
-    name;
-    config;
-    status = NodeStatus.IDLE;
-    constructor(id, type, name, config) {
-        this.id = id;
-        this.type = type;
-        this.name = name;
-        this.config = config;
-    }
-    /**
-     * 主执行方法 - 实现统一的转换流水线
-     */
-    async execute(context) {
-        const startTime = Date.now();
-        if (this.isHubEnabled(context)) {
-            return this.executeWithHub(context, startTime);
-        }
-        try {
-            this.status = NodeStatus.RUNNING;
-            // 1. 验证输入数据
-            const validation = this.validate(context.data);
-            if (!validation.valid) {
-                throw new ConversionError(`Input validation failed: ${validation.errors.map(e => e.message).join(', ')}`, this.id, 'validation', new Error(validation.errors[0]?.message));
-            }
-            // 2. 前置验证 - Fail Fast
-            this.validatePayload(context.data);
-            // 3. 输入标准化预处理
-            const normalized = await this.preprocessInput(context.data, context);
-            // 4. 并行执行各项转换
-            const [messages, tools, parameters, capturedContext] = await Promise.all([
-                this.convertMessages(normalized, context),
-                this.convertTools(normalized, context),
-                this.extractParameters(normalized, context),
-                this.captureContext(normalized, context)
-            ]);
-            // 5. 后置验证
-            const model = this.extractRequiredString(parameters, 'model');
-            this.validateResult({
-                model,
-                messages,
-                tools,
-                parameters,
-                metadata: { originalEndpoint: this.config.inputFormat }
-            });
-            // 6. 构建标准化请求
-            const standardizedRequest = {
-                model,
-                messages: await this.postprocessMessages(messages, context),
-                tools: tools.length > 0 ? await this.postprocessTools(tools, context) : undefined,
-                parameters,
-                metadata: {
-                    originalEndpoint: this.config.inputFormat,
-                    capturedContext,
-                    requestId: this.safeCast(context.request.id, 'string'),
-                    stream: typeof parameters.stream === 'boolean'
-                        ? parameters.stream
-                        : undefined
-                }
-            };
-            this.status = NodeStatus.COMPLETED;
-            return {
-                success: true,
-                data: {
-                    standardizedRequest,
-                    originalFormat: this.config.inputFormat,
-                    targetFormat: this.config.outputFormat
-                },
-                metadata: {
-                    node: this.id,
-                    executionTime: Date.now() - startTime,
-                    startTime,
-                    endTime: Date.now(),
-                    dataProcessed: {
-                        messages: messages.length,
-                        tools: tools.length
-                    }
-                }
-            };
-        }
-        catch (error) {
-            this.status = NodeStatus.FAILED;
-            return {
-                success: false,
-                error: {
-                    code: 'INPUT_CONVERSION_ERROR',
-                    message: error instanceof Error ? error.message : 'Unknown error during input conversion',
-                    details: {
-                        node: this.id,
-                        inputFormat: this.config.inputFormat,
-                        outputFormat: this.config.outputFormat
-                    },
-                    cause: error instanceof Error ? error : undefined
-                },
-                metadata: {
-                    node: this.id,
-                    executionTime: Date.now() - startTime,
-                    startTime,
-                    endTime: Date.now()
-                }
-            };
-        }
-    }
-    isHubEnabled(_context) {
-        return false;
-    }
-    async runHubConversion(_context, _startTime) {
-        throw new ConversionError('Hub conversion not implemented for this node', this.id);
-    }
-    async executeWithHub(context, startTime) {
-        try {
-            this.status = NodeStatus.RUNNING;
-            const result = await this.runHubConversion(context, startTime);
-            this.status = NodeStatus.COMPLETED;
-            return result;
-        }
-        catch (error) {
-            this.status = NodeStatus.FAILED;
-            return {
-                success: false,
-                error: {
-                    code: 'INPUT_CONVERSION_ERROR',
-                    message: error instanceof Error ? error.message : 'Unknown error during input conversion',
-                    details: {
-                        node: this.id,
-                        inputFormat: this.config.inputFormat,
-                        outputFormat: this.config.outputFormat
-                    },
-                    cause: error instanceof Error ? error : undefined
-                },
-                metadata: {
-                    node: this.id,
-                    executionTime: Date.now() - startTime,
-                    startTime,
-                    endTime: Date.now()
-                }
-            };
-        }
-    }
-    /**
-     * 验证输入数据
-     */
-    validate(data) {
-        const errors = [];
-        // 验证必要字段
-        if (this.config.validation.required) {
-            for (const field of this.config.validation.required) {
-                if (!(field in data) || data[field] === undefined || data[field] === null) {
-                    errors.push({
-                        field,
-                        message: `Required field '${field}' is missing`,
-                        code: 'MISSING_REQUIRED_FIELD',
-                        value: data[field]
-                    });
-                }
-            }
-        }
-        return {
-            valid: errors.length === 0,
-            errors,
-            warnings: []
-        };
-    }
-    /**
-     * 前置验证 - 确保必要字段存在
-     */
-    validatePayload(payload) {
-        if (!payload || typeof payload !== 'object') {
-            throw new ConversionError('Payload must be a non-null object', this.id);
-        }
-        if (!('model' in payload)) {
-            throw new ConversionError('Model is required in payload', this.id);
-        }
-        const model = payload.model;
-        if (typeof model !== 'string' || !model.trim()) {
-            throw new ConversionError('Model must be a non-empty string', this.id);
-        }
-    }
-    /**
-     * 后置验证
-     */
-    validateResult(result) {
-        if (!result.model) {
-            throw new ConversionError('Model is required in conversion result', this.id);
-        }
-        if (!result.messages || !Array.isArray(result.messages)) {
-            throw new ConversionError('Messages must be a valid array', this.id);
-        }
-        if (result.messages.length === 0) {
-            throw new ConversionError('Messages array cannot be empty', this.id);
-        }
-    }
-    /**
-     * 工具方法：提取必需的字符串字段
-     */
-    extractRequiredString(obj, field) {
-        if (!(field in obj)) {
-            throw new ConversionError(`Required field '${field}' is missing`, this.id);
-        }
-        const value = obj[field];
-        if (typeof value !== 'string') {
-            throw new ConversionError(`Field '${field}' must be a string`, this.id);
-        }
-        if (!value.trim()) {
-            throw new ConversionError(`Field '${field}' cannot be empty`, this.id);
-        }
-        return value.trim();
-    }
-    /**
-     * 工具方法：安全类型转换
-     */
-    safeCast(value, expectedType) {
-        switch (expectedType) {
-            case 'string':
-                return typeof value === 'string' ? value : undefined;
-            case 'number':
-                return typeof value === 'number' ? value : undefined;
-            case 'boolean':
-                return typeof value === 'boolean' ? value : undefined;
-            default:
-                return undefined;
-        }
-    }
-}

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

@@ -1,25 +0,0 @@
-/**
- * Chat 输入节点
- *
- * 基于 chat-converter.ts 适配为节点架构
- */
-import { BaseInputNode } from './base-input-node.js';
-import type { NodeContext, NodeConfig, NodeResult, StandardizedMessage, StandardizedTool } from '../../types/index.js';
-/**
- * Chat 输入节点实现
- *
- * 负责将 OpenAI Chat 格式转换为标准化格式
- */
-export declare class ChatInputNode 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/chat-input-node.js

@@ -1,56 +0,0 @@
-/**
- * Chat 输入节点
- *
- * 基于 chat-converter.ts 适配为节点架构
- */
-import { BaseInputNode } from './base-input-node.js';
-import { NodeType, ConversionError } from '../../types/index.js';
-import { runHubInboundConversion, shouldUseHub } from '../../../hub/node-support.js';
-/**
- * Chat 输入节点实现
- *
- * 负责将 OpenAI Chat 格式转换为标准化格式
- */
-export class ChatInputNode extends BaseInputNode {
-    constructor(config) {
-        super('chat-input', NodeType.INPUT, 'OpenAI Chat Input Node', config);
-    }
-    isHubEnabled() {
-        return shouldUseHub('openai-chat');
-    }
-    async runHubConversion(context, startTime) {
-        return runHubInboundConversion({
-            protocol: 'openai-chat',
-            rawRequest: context.data,
-            nodeContext: context,
-            nodeId: this.id,
-            inputFormat: this.config.inputFormat,
-            outputFormat: this.config.outputFormat,
-            startTime
-        });
-    }
-    legacyRemoved(stage) {
-        throw new ConversionError(`ChatInputNode 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/chat-shape-helpers.d.ts

@@ -1,4 +0,0 @@
-import type { StandardizedMessage, StandardizedTool } from '../../types/index.js';
-export declare function convertChatMessagesFromPayload(chatPayload: Record<string, unknown>, nodeId: string): StandardizedMessage[];
-export declare function convertChatToolsFromPayload(chatPayload: Record<string, unknown>, nodeId: string): StandardizedTool[];
-export declare function extractChatParametersFromPayload(payload: Record<string, unknown>, nodeId: string): Record<string, unknown>;

package/dist/conversion/conversion-v3/nodes/input/chat-shape-helpers.js

@@ -1,197 +0,0 @@
-import { ConversionError } from '../../types/index.js';
-const CHAT_ROLES = new Set(['system', 'user', 'assistant', 'tool']);
-const STANDARD_PARAMETERS = [
-    'temperature',
-    'max_tokens',
-    'top_p',
-    'frequency_penalty',
-    'presence_penalty',
-    'stop',
-    'stream',
-    'n',
-    'seed'
-];
-export function convertChatMessagesFromPayload(chatPayload, nodeId) {
-    const messages = [];
-    const chatMessages = ensureArrayField(chatPayload, 'messages', nodeId);
-    for (const msg of chatMessages) {
-        if (!msg || typeof msg !== 'object') {
-            throw new ConversionError(`Invalid chat message format: ${JSON.stringify(msg)}`, nodeId);
-        }
-        const messageObj = msg;
-        const role = ensureStringField(messageObj, 'role', nodeId);
-        if (!CHAT_ROLES.has(role)) {
-            throw new ConversionError(`Invalid role: ${role}. Must be 'system', 'user', 'assistant', or 'tool'`, nodeId);
-        }
-        messages.push(convertChatSingleMessage(messageObj, role, nodeId));
-    }
-    return messages;
-}
-export function convertChatToolsFromPayload(chatPayload, nodeId) {
-    const tools = [];
-    const toolsArray = ensureOptionalArrayField(chatPayload, 'tools', nodeId);
-    if (!toolsArray)
-        return tools;
-    for (const tool of toolsArray) {
-        if (!tool || typeof tool !== 'object') {
-            throw new ConversionError(`Invalid tool format: ${JSON.stringify(tool)}`, nodeId);
-        }
-        tools.push(convertChatSingleTool(tool, nodeId));
-    }
-    return tools;
-}
-export function extractChatParametersFromPayload(payload, nodeId) {
-    const parameters = {};
-    for (const param of STANDARD_PARAMETERS) {
-        if (param in payload) {
-            const value = payload[param];
-            if (value !== undefined && value !== null) {
-                parameters[param] = value;
-            }
-        }
-    }
-    parameters.model = ensureStringField(payload, 'model', nodeId);
-    if ('tool_choice' in payload) {
-        parameters.tool_choice = payload['tool_choice'];
-    }
-    return parameters;
-}
-function convertChatSingleMessage(msgObj, role, nodeId) {
-    const standardizedMessage = {
-        role,
-        content: null
-    };
-    const content = msgObj.content;
-    if (content !== null && content !== undefined) {
-        if (typeof content === 'string') {
-            standardizedMessage.content = content;
-        }
-        else if (Array.isArray(content)) {
-            const textParts = [];
-            for (const part of content) {
-                if (typeof part === 'object' && part !== null) {
-                    const partObj = part;
-                    if (partObj.type === 'text' && typeof partObj.text === 'string') {
-                        textParts.push(partObj.text);
-                    }
-                }
-                else if (typeof part === 'string') {
-                    textParts.push(part);
-                }
-            }
-            standardizedMessage.content = textParts.join('\n') || null;
-        }
-        else {
-            try {
-                standardizedMessage.content = String(content);
-            }
-            catch {
-                standardizedMessage.content = null;
-            }
-        }
-    }
-    if (role === 'assistant' && 'tool_calls' in msgObj) {
-        const toolCalls = msgObj.tool_calls;
-        if (Array.isArray(toolCalls)) {
-            standardizedMessage.tool_calls = toolCalls.map(tc => {
-                if (!tc || typeof tc !== 'object') {
-                    throw new ConversionError(`Invalid tool_call format: ${JSON.stringify(tc)}`, nodeId);
-                }
-                const tcObj = tc;
-                const funcObj = tcObj.function && typeof tcObj.function === 'object'
-                    ? tcObj.function
-                    : {};
-                return {
-                    id: ensureStringField(tcObj, 'id', nodeId),
-                    type: 'function',
-                    function: {
-                        name: ensureStringField(funcObj, 'name', nodeId),
-                        arguments: ensureStringField(funcObj, 'arguments', nodeId)
-                    }
-                };
-            });
-        }
-    }
-    if (role === 'tool' && 'tool_call_id' in msgObj) {
-        standardizedMessage.tool_call_id = ensureStringField(msgObj, 'tool_call_id', nodeId);
-    }
-    if ('name' in msgObj && msgObj.name) {
-        const name = msgObj.name;
-        if (typeof name === 'string') {
-            standardizedMessage.name = name;
-        }
-    }
-    return standardizedMessage;
-}
-function convertChatSingleTool(toolObj, nodeId) {
-    const rawType = ensureStringField(toolObj, 'type', nodeId);
-    const type = rawType === 'custom' ? 'function' : rawType;
-    if (type !== 'function') {
-        throw new ConversionError(`Only 'function' type tools are supported, got: ${rawType}`, nodeId);
-    }
-    const functionObj = toolObj.function;
-    if (!functionObj || typeof functionObj !== 'object') {
-        throw new ConversionError('Tool function definition is required', nodeId);
-    }
-    const funcObj = functionObj;
-    return {
-        type: 'function',
-        function: {
-            name: ensureStringField(funcObj, 'name', nodeId),
-            description: 'description' in funcObj ? ensureStringField(funcObj, 'description', nodeId) : undefined,
-            parameters: convertChatToolParameters(funcObj.parameters),
-            strict: funcObj.strict === true
-        }
-    };
-}
-function convertChatToolParameters(parameters) {
-    if (!parameters || typeof parameters !== 'object') {
-        return {
-            type: 'object',
-            properties: {},
-            required: [],
-            additionalProperties: true
-        };
-    }
-    const paramsObj = parameters;
-    return {
-        type: 'object',
-        properties: paramsObj.properties || {},
-        required: Array.isArray(paramsObj.required) ? paramsObj.required : [],
-        additionalProperties: paramsObj.additionalProperties !== undefined
-            ? Boolean(paramsObj.additionalProperties)
-            : true
-    };
-}
-function ensureArrayField(obj, field, nodeId) {
-    if (!(field in obj)) {
-        throw new ConversionError(`Required field '${field}' is missing`, nodeId);
-    }
-    const value = obj[field];
-    if (!Array.isArray(value)) {
-        throw new ConversionError(`Field '${field}' must be an array`, nodeId);
-    }
-    return value;
-}
-function ensureOptionalArrayField(obj, field, nodeId) {
-    if (!(field in obj))
-        return null;
-    const value = obj[field];
-    if (!Array.isArray(value)) {
-        throw new ConversionError(`Field '${field}' must be an array if present`, nodeId);
-    }
-    return value;
-}
-function ensureStringField(obj, field, nodeId) {
-    if (!(field in obj)) {
-        throw new ConversionError(`Required field '${field}' is missing`, nodeId);
-    }
-    const value = obj[field];
-    if (typeof value !== 'string') {
-        throw new ConversionError(`Field '${field}' must be a string`, nodeId);
-    }
-    if (!value.trim()) {
-        throw new ConversionError(`Field '${field}' cannot be empty`, nodeId);
-    }
-    return value;
-}

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

@@ -1,16 +0,0 @@
-/**
- * Gemini 输入节点（请求侧）
- * 仅做字段/形状映射：Gemini generateContent → 标准 Chat 请求
- */
-import { BaseInputNode } from './base-input-node.js';
-import type { NodeContext, NodeConfig, StandardizedMessage, StandardizedTool } from '../../types/index.js';
-export declare class GeminiInputNode extends BaseInputNode {
-    constructor(config: NodeConfig);
-    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/gemini-input-node.js

@@ -1,125 +0,0 @@
-/**
- * Gemini 输入节点（请求侧）
- * 仅做字段/形状映射：Gemini generateContent → 标准 Chat 请求
- */
-import { BaseInputNode } from './base-input-node.js';
-import { NodeType, ConversionError } from '../../types/index.js';
-function isObj(v) { return !!v && typeof v === 'object' && !Array.isArray(v); }
-function collectTextFromParts(parts) {
-    if (!Array.isArray(parts))
-        return '';
-    const texts = [];
-    for (const p of parts) {
-        if (isObj(p) && typeof p.text === 'string')
-            texts.push(String(p.text));
-    }
-    return texts.join('');
-}
-function mapGeminiContentsToChatMessages(contents) {
-    const out = [];
-    for (const c of (Array.isArray(contents) ? contents : [])) {
-        if (!isObj(c))
-            continue;
-        const roleRaw = String((c.role ?? 'user')).toLowerCase();
-        const role = roleRaw === 'model' ? 'assistant' : (roleRaw === 'user' ? 'user' : 'user');
-        const text = collectTextFromParts(c.parts);
-        out.push({ role, content: text });
-    }
-    return out;
-}
-function mapGeminiToolsToOpenAITools(tools) {
-    // Gemini: { tools: { functionDeclarations: [{ name, description, parameters }]} }
-    if (!isObj(tools))
-        return undefined;
-    const fns = (tools.functionDeclarations && Array.isArray(tools.functionDeclarations)) ? tools.functionDeclarations : [];
-    const mapped = [];
-    for (const fn of fns) {
-        const name = typeof fn.name === 'string' ? fn.name : undefined;
-        if (!name)
-            continue;
-        const description = typeof fn.description === 'string' ? fn.description : undefined;
-        const parameters = (isObj(fn.parameters) || typeof fn.parameters === 'object') ? fn.parameters : undefined;
-        const tool = { type: 'function', function: { name } };
-        if (description)
-            tool.function.description = description;
-        if (parameters !== undefined)
-            tool.function.parameters = parameters;
-        mapped.push(tool);
-    }
-    return mapped.length ? mapped : undefined;
-}
-export class GeminiInputNode extends BaseInputNode {
-    constructor(config) {
-        super('gemini-input', NodeType.INPUT, 'Gemini Input Node', config);
-    }
-    async preprocessInput(payload, context) {
-        if (!Array.isArray(payload.contents)) {
-            throw new ConversionError('Gemini request must include contents array', this.id);
-        }
-        if (typeof payload.model !== 'string') {
-            throw new ConversionError('Gemini request must include model', this.id);
-        }
-        const entryEndpoint = context.request.context?.entryEndpoint || context.request.endpoint || '/v1beta/models:generateContent';
-        const metadata = isObj(context.request.context?.metadata) ? context.request.context.metadata : {};
-        const toolsField = payload['tools'];
-        const chatPayload = {
-            model: payload.model,
-            messages: mapGeminiContentsToChatMessages(payload.contents),
-            tools: mapGeminiToolsToOpenAITools(toolsField)
-        };
-        const generationConfig = payload.generationConfig;
-        if (generationConfig && isObj(generationConfig)) {
-            chatPayload.temperature = generationConfig.temperature;
-            chatPayload.max_tokens = generationConfig.maxOutputTokens;
-            chatPayload.top_p = generationConfig.topP;
-            chatPayload.stop = generationConfig.stopSequences;
-        }
-        return {
-            ...payload,
-            __chatPayload: chatPayload,
-            __shape: { entryEndpoint, metadata }
-        };
-    }
-    async convertMessages(payload, context) {
-        const chat = payload.__chatPayload;
-        if (!isObj(chat) || !Array.isArray(chat.messages))
-            throw new ConversionError('Gemini input missing canonical chat payload', this.id);
-        return chat.messages.map(m => ({ role: m.role, content: String(m.content ?? '') }));
-    }
-    async convertTools(payload, context) {
-        const chat = payload.__chatPayload;
-        const tools = Array.isArray(chat?.tools) ? chat.tools : [];
-        return tools;
-    }
-    async extractParameters(payload, context) {
-        const chat = payload.__chatPayload;
-        const params = {};
-        if (typeof chat?.temperature === 'number')
-            params.temperature = chat.temperature;
-        if (typeof chat?.max_tokens === 'number')
-            params.max_tokens = chat.max_tokens;
-        if (typeof chat?.top_p === 'number')
-            params.top_p = chat.top_p;
-        if (chat?.stop)
-            params.stop = chat.stop;
-        params.model = typeof chat?.model === 'string' ? chat.model : (String(payload.model || 'gemini/unknown'));
-        params.stream = Boolean(payload.stream);
-        return params;
-    }
-    async captureContext(payload, context) {
-        const shape = payload.__shape;
-        const captured = { originalEndpoint: shape?.entryEndpoint || '/v1beta/models:generateContent', nodeType: 'gemini-input', timestamp: Date.now() };
-        // pass-through some gemini-specific fields for debugging
-        if (isObj(payload.safetySettings))
-            captured.safetySettings = payload.safetySettings;
-        if (isObj(payload.toolConfig))
-            captured.toolConfig = payload.toolConfig;
-        return captured;
-    }
-    async postprocessMessages(messages, context) {
-        return messages;
-    }
-    async postprocessTools(tools, context) {
-        return tools;
-    }
-}

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

@@ -1,8 +0,0 @@
-/**
- * 输入节点导出
- */
-export { BaseInputNode } from './base-input-node.js';
-export { ChatInputNode } from './chat-input-node.js';
-export { AnthropicInputNode } from './anthropic-input-node.js';
-export { ResponsesInputNode } from './responses-input-node.js';
-export { GeminiInputNode } from './gemini-input-node.js';

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

@@ -1,8 +0,0 @@
-/**
- * 输入节点导出
- */
-export { BaseInputNode } from './base-input-node.js';
-export { ChatInputNode } from './chat-input-node.js';
-export { AnthropicInputNode } from './anthropic-input-node.js';
-export { ResponsesInputNode } from './responses-input-node.js';
-export { GeminiInputNode } from './gemini-input-node.js';