@jsonstudio/llms 0.4.2

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

@@ -0,0 +1,237 @@
+/**
+ * 输入节点基类
+ *
+ * 基于现有 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

@@ -0,0 +1,25 @@
+/**
+ * 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

@@ -0,0 +1,56 @@
+/**
+ * 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

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

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

@@ -0,0 +1,16 @@
+/**
+ * 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

@@ -0,0 +1,125 @@
+/**
+ * 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

@@ -0,0 +1,8 @@
+/**
+ * 输入节点导出
+ */
+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

@@ -0,0 +1,8 @@
+/**
+ * 输入节点导出
+ */
+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';