@jsonstudio/llms 0.4.2 → 0.4.4

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

@@ -1,46 +0,0 @@
-/**
- * 输入节点决策器
- *
- * 根据端点路径自动决定输入节点类型，无需配置
- */
-/**
- * 输入节点决策器
- */
-export declare class InputNodeDecision {
-    /**
-     * 根据端点决定输入节点类型
-     */
-    static decideInputNodeType(endpoint: string): string;
-    /**
-     * 获取端点对应的输入格式
-     */
-    static getInputFormat(endpoint: string): string;
-    /**
-     * 检查是否支持该端点
-     */
-    static isEndpointSupported(endpoint: string): boolean;
-    /**
-     * 获取所有支持的端点
-     */
-    static getSupportedEndpoints(): string[];
-    /**
-     * 获取所有支持的输入节点类型
-     */
-    static getSupportedInputNodeTypes(): string[];
-    /**
-     * 规范化端点路径
-     */
-    private static normalizeEndpoint;
-    /**
-     * 注册新的端点映射
-     */
-    static registerEndpointMapping(endpoint: string, nodeType: string, format: string): void;
-    /**
-     * 批量注册端点映射
-     */
-    static registerEndpointMappings(mappings: Array<{
-        endpoint: string;
-        nodeType: string;
-        format: string;
-    }>): void;
-}

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

@@ -1,125 +0,0 @@
-/**
- * 输入节点决策器
- *
- * 根据端点路径自动决定输入节点类型，无需配置
- */
-/**
- * 端点到输入节点的映射
- */
-const ENDPOINT_TO_INPUT_NODE = new Map([
-    // OpenAI Chat 相关端点
-    ['/v1/chat/completions', 'chat-input'],
-    ['/chat/completions', 'chat-input'],
-    ['/v1/completions', 'chat-input'], // 兼容旧接口
-    // Anthropic 相关端点  
-    ['/v1/messages', 'anthropic-input'],
-    ['/messages', 'anthropic-input'],
-    // OpenAI Responses 相关端点
-    ['/v1/responses', 'responses-input'],
-    ['/responses', 'responses-input']
-]);
-/**
- * 端点格式映射
- */
-const ENDPOINT_FORMATS = new Map([
-    ['/v1/chat/completions', 'openai-chat'],
-    ['/chat/completions', 'openai-chat'],
-    ['/v1/completions', 'openai-chat'],
-    ['/v1/messages', 'anthropic-messages'],
-    ['/messages', 'anthropic-messages'],
-    ['/v1/responses', 'openai-responses'],
-    ['/responses', 'openai-responses']
-]);
-/**
- * 输入节点决策器
- */
-export class InputNodeDecision {
-    /**
-     * 根据端点决定输入节点类型
-     */
-    static decideInputNodeType(endpoint) {
-        // 规范化端点路径
-        const normalizedEndpoint = this.normalizeEndpoint(endpoint);
-        // 查找精确匹配
-        const nodeType = ENDPOINT_TO_INPUT_NODE.get(normalizedEndpoint);
-        if (nodeType) {
-            return nodeType;
-        }
-        // 查找前缀匹配
-        for (const [mappedEndpoint, nodeType] of ENDPOINT_TO_INPUT_NODE) {
-            if (normalizedEndpoint.startsWith(mappedEndpoint)) {
-                return nodeType;
-            }
-        }
-        throw new Error(`Unsupported endpoint: ${endpoint}. No input node mapping found.`);
-    }
-    /**
-     * 获取端点对应的输入格式
-     */
-    static getInputFormat(endpoint) {
-        const normalizedEndpoint = this.normalizeEndpoint(endpoint);
-        const format = ENDPOINT_FORMATS.get(normalizedEndpoint);
-        if (format) {
-            return format;
-        }
-        // 查找前缀匹配
-        for (const [mappedEndpoint, format] of ENDPOINT_FORMATS) {
-            if (normalizedEndpoint.startsWith(mappedEndpoint)) {
-                return format;
-            }
-        }
-        throw new Error(`Unsupported endpoint: ${endpoint}. No format mapping found.`);
-    }
-    /**
-     * 检查是否支持该端点
-     */
-    static isEndpointSupported(endpoint) {
-        try {
-            this.decideInputNodeType(endpoint);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * 获取所有支持的端点
-     */
-    static getSupportedEndpoints() {
-        return Array.from(ENDPOINT_TO_INPUT_NODE.keys());
-    }
-    /**
-     * 获取所有支持的输入节点类型
-     */
-    static getSupportedInputNodeTypes() {
-        return Array.from(new Set(ENDPOINT_TO_INPUT_NODE.values()));
-    }
-    /**
-     * 规范化端点路径
-     */
-    static normalizeEndpoint(endpoint) {
-        // 移除尾部斜杠
-        let normalized = endpoint.replace(/\/$/, '');
-        // 确保以 / 开头
-        if (!normalized.startsWith('/')) {
-            normalized = '/' + normalized;
-        }
-        return normalized;
-    }
-    /**
-     * 注册新的端点映射
-     */
-    static registerEndpointMapping(endpoint, nodeType, format) {
-        const normalizedEndpoint = this.normalizeEndpoint(endpoint);
-        ENDPOINT_TO_INPUT_NODE.set(normalizedEndpoint, nodeType);
-        ENDPOINT_FORMATS.set(normalizedEndpoint, format);
-    }
-    /**
-     * 批量注册端点映射
-     */
-    static registerEndpointMappings(mappings) {
-        for (const mapping of mappings) {
-            this.registerEndpointMapping(mapping.endpoint, mapping.nodeType, mapping.format);
-        }
-    }
-}

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

@@ -1,20 +0,0 @@
-/**
- * Responses 输入节点
- *
- * 统一走 Hub inbound 流水线，不再保留旧版转换逻辑。
- */
-import { BaseInputNode } from './base-input-node.js';
-import type { NodeContext, NodeConfig, NodeResult, StandardizedMessage, StandardizedTool } from '../../types/index.js';
-export declare class ResponsesInputNode 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/responses-input-node.js

@@ -1,51 +0,0 @@
-/**
- * Responses 输入节点
- *
- * 统一走 Hub inbound 流水线，不再保留旧版转换逻辑。
- */
-import { BaseInputNode } from './base-input-node.js';
-import { NodeType, ConversionError } from '../../types/index.js';
-import { runHubInboundConversion, shouldUseHub } from '../../../hub/node-support.js';
-export class ResponsesInputNode extends BaseInputNode {
-    constructor(config) {
-        super('responses-input', NodeType.INPUT, 'OpenAI Responses Input Node', config);
-    }
-    isHubEnabled() {
-        return shouldUseHub('openai-responses');
-    }
-    async runHubConversion(context, startTime) {
-        return runHubInboundConversion({
-            protocol: 'openai-responses',
-            rawRequest: context.data,
-            nodeContext: context,
-            nodeId: this.id,
-            inputFormat: this.config.inputFormat,
-            outputFormat: this.config.outputFormat,
-            startTime
-        });
-    }
-    legacyRemoved(stage) {
-        throw new ConversionError(`ResponsesInputNode 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/output/anthropic-output-node.d.ts

@@ -1,71 +0,0 @@
-/**
- * Anthropic 输出节点
- *
- * 负责将处理后的数据转换为 Anthropic Claude 格式
- */
-import { BaseOutputNode } from './base-output-node.js';
-import type { NodeContext, NodeConfig, ProcessedRequest } from '../../types/index.js';
-/**
- * Anthropic 输出节点实现
- *
- * 负责将处理后的数据转换为 Anthropic Claude 格式
- */
-export declare class AnthropicOutputNode extends BaseOutputNode {
-    constructor(config: NodeConfig);
-    /**
-     * 转换为 Anthropic 输出格式
-     */
-    protected convertToOutputFormat(processedRequest: ProcessedRequest, context: NodeContext): Promise<Record<string, unknown>>;
-    /**
-     * 生成 Anthropic 输出元数据
-     */
-    protected generateOutputMetadata(processedRequest: ProcessedRequest, context: NodeContext): Promise<Record<string, unknown>>;
-    /**
-     * 转换为 Message 格式
-     */
-    private convertToMessageFormat;
-    /**
-     * 转换为流式格式
-     */
-    private convertToStreamingFormat;
-    /**
-     * 转换消息内容为 Anthropic 格式
-     */
-    private convertMessageContentToAnthropic;
-    /**
-     * 解析工具参数
-     */
-    private parseToolArguments;
-    /**
-     * 确定停止原因
-     */
-    private determineStopReason;
-    /**
-     * 确定停止序列
-     */
-    private determineStopSequence;
-    /**
-     * 生成 Anthropic 使用情况
-     */
-    private generateAnthropicUsage;
-    /**
-     * 生成消息ID
-     */
-    private generateMessageId;
-    /**
-     * 验证 Anthropic 响应
-     */
-    private validateAnthropicResponse;
-    /**
-     * 验证流式 Anthropic 响应
-     */
-    private validateStreamingAnthropicResponse;
-    /**
-     * 计算 Anthropic token 数量
-     */
-    private calculateAnthropicTokens;
-    /**
-     * 提取工具调用信息
-     */
-    private extractToolCallInfo;
-}

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

@@ -1,320 +0,0 @@
-/**
- * Anthropic 输出节点
- *
- * 负责将处理后的数据转换为 Anthropic Claude 格式
- */
-import { BaseOutputNode } from './base-output-node.js';
-import { buildAnthropicRequestFromOpenAIChat } from '../../../codecs/anthropic-openai-codec.js';
-import { NodeType, ConversionError } from '../../types/index.js';
-import { runHubOutboundConversion, shouldUseHub } from '../../../hub/node-support.js';
-/**
- * Anthropic 输出节点实现
- *
- * 负责将处理后的数据转换为 Anthropic Claude 格式
- */
-export class AnthropicOutputNode extends BaseOutputNode {
-    constructor(config) {
-        super('anthropic-output', NodeType.OUTPUT, 'Anthropic Output Node', config);
-    }
-    /**
-     * 转换为 Anthropic 输出格式
-     */
-    async convertToOutputFormat(processedRequest, context) {
-        const direction = this.getPipelineDirection(context);
-        if (direction !== 'response') {
-            if (shouldUseHub('anthropic-messages')) {
-                return runHubOutboundConversion({
-                    protocol: 'anthropic-messages',
-                    request: processedRequest,
-                    nodeContext: context
-                });
-            }
-            const chatPayload = this.buildChatRequestPayload(processedRequest);
-            return buildAnthropicRequestFromOpenAIChat(chatPayload);
-        }
-        // 检查是否为流式响应
-        const isStreaming = processedRequest.processingMetadata?.streaming?.enabled === true;
-        if (isStreaming) {
-            return this.convertToStreamingFormat(processedRequest, context);
-        }
-        else {
-            return this.convertToMessageFormat(processedRequest, context);
-        }
-    }
-    /**
-     * 生成 Anthropic 输出元数据
-     */
-    async generateOutputMetadata(processedRequest, context) {
-        const direction = this.getPipelineDirection(context);
-        if (direction !== 'response') {
-            return {
-                outputFormat: 'anthropic-messages',
-                direction: 'request',
-                model: this.resolveRequestModel(processedRequest),
-                messageCount: processedRequest.messages.length,
-                toolCount: processedRequest.tools?.length || 0
-            };
-        }
-        const metadata = {
-            outputFormat: 'anthropic-messages',
-            model: processedRequest.model,
-            streaming: processedRequest.processingMetadata?.streaming?.enabled === true,
-            messageCount: processedRequest.messages.length,
-            toolCount: processedRequest.tools?.length || 0,
-            processingTime: Date.now() - processedRequest.processed.timestamp
-        };
-        // 添加流式特定元数据
-        if (processedRequest.processingMetadata?.streaming?.enabled) {
-            metadata.streamingInfo = {
-                format: 'sse',
-                chunkSize: processedRequest.processingMetadata.streaming.chunkCount || 0,
-                maxTokens: processedRequest.parameters.max_tokens
-            };
-        }
-        // 添加工具调用元数据
-        const toolCallInfo = this.extractToolCallInfo(processedRequest.messages);
-        if (toolCallInfo.hasToolCalls) {
-            metadata.toolCallInfo = toolCallInfo;
-        }
-        // 添加 Anthropic 特定元数据
-        metadata.anthropicInfo = {
-            apiVersion: '2023-06-01',
-            supportsStreaming: true,
-            maxTokens: processedRequest.parameters.max_tokens,
-            temperature: processedRequest.parameters.temperature
-        };
-        return metadata;
-    }
-    /**
-     * 转换为 Message 格式
-     */
-    async convertToMessageFormat(processedRequest, context) {
-        const assistantMessages = processedRequest.messages.filter(m => m.role === 'assistant');
-        if (assistantMessages.length === 0) {
-            throw new ConversionError('No assistant messages found for Anthropic message response', this.id, 'message_validation');
-        }
-        // 使用最后一个助手消息作为响应
-        const lastAssistantMessage = assistantMessages[assistantMessages.length - 1];
-        // 转换内容为 Anthropic 格式
-        const content = this.convertMessageContentToAnthropic(lastAssistantMessage);
-        const response = {
-            id: this.generateMessageId(),
-            type: 'message',
-            role: 'assistant',
-            content,
-            model: processedRequest.model,
-            stop_reason: this.determineStopReason(lastAssistantMessage),
-            stop_sequence: this.determineStopSequence(lastAssistantMessage),
-            usage: this.generateAnthropicUsage(processedRequest)
-        };
-        // 验证响应结构
-        this.validateAnthropicResponse(response);
-        return response;
-    }
-    /**
-     * 转换为流式格式
-     */
-    async convertToStreamingFormat(processedRequest, context) {
-        const assistantMessages = processedRequest.messages.filter(m => m.role === 'assistant');
-        if (assistantMessages.length === 0) {
-            throw new ConversionError('No assistant messages found for Anthropic streaming response', this.id, 'message_validation');
-        }
-        const lastAssistantMessage = assistantMessages[assistantMessages.length - 1];
-        const content = this.convertMessageContentToAnthropic(lastAssistantMessage);
-        const response = {
-            id: this.generateMessageId(),
-            type: 'message',
-            role: 'assistant',
-            content,
-            model: processedRequest.model,
-            stop_reason: undefined,
-            usage: this.generateAnthropicUsage(processedRequest)
-        };
-        this.validateStreamingAnthropicResponse(response);
-        return response;
-    }
-    /**
-     * 转换消息内容为 Anthropic 格式
-     */
-    convertMessageContentToAnthropic(message) {
-        const contentBlocks = [];
-        // 处理文本内容
-        if (message.content) {
-            contentBlocks.push({
-                type: 'text',
-                text: message.content
-            });
-        }
-        // 处理工具调用
-        if (message.tool_calls && message.tool_calls.length > 0) {
-            for (const toolCall of message.tool_calls) {
-                try {
-                    const toolUseBlock = {
-                        type: 'tool_use',
-                        id: toolCall.id,
-                        name: toolCall.function.name,
-                        input: this.parseToolArguments(toolCall.function.arguments)
-                    };
-                    contentBlocks.push(toolUseBlock);
-                }
-                catch (error) {
-                    throw new ConversionError(`Failed to convert tool call for ${toolCall.function.name}: ${error instanceof Error ? error.message : 'Unknown error'}`, this.id, 'tool_conversion', error instanceof Error ? error : undefined);
-                }
-            }
-        }
-        // 如果没有内容，创建空的文本块
-        if (contentBlocks.length === 0) {
-            contentBlocks.push({
-                type: 'text',
-                text: ''
-            });
-        }
-        return contentBlocks;
-    }
-    /**
-     * 解析工具参数
-     */
-    parseToolArguments(args) {
-        // Shape-only mapping: best-effort parse, never throw; preserve raw on failure
-        try {
-            const parsed = JSON.parse(args);
-            if (parsed && typeof parsed === 'object') {
-                return parsed;
-            }
-            return { _raw: args };
-        }
-        catch {
-            return { _raw: args };
-        }
-    }
-    /**
-     * 确定停止原因
-     */
-    determineStopReason(message) {
-        // 如果有工具调用，设置为 tool_use
-        if (message.tool_calls && message.tool_calls.length > 0) {
-            return 'tool_use';
-        }
-        // 如果内容为空或很短，可能是 end_turn
-        if (!message.content || message.content.length < 10) {
-            return 'end_turn';
-        }
-        // 简单的长度检查，实际实现应该更精确
-        if (message.content && message.content.length > 2000) {
-            return 'max_tokens';
-        }
-        return 'end_turn';
-    }
-    /**
-     * 确定停止序列
-     */
-    determineStopSequence(message) {
-        // 检查是否包含特定的停止序列
-        const stopSequences = ['\n\nHuman:', '\n\nUSER:', '\n\nAssistant:', ''];
-        if (message.content) {
-            for (const sequence of stopSequences) {
-                if (message.content.includes(sequence)) {
-                    return sequence;
-                }
-            }
-        }
-        return undefined;
-    }
-    /**
-     * 生成 Anthropic 使用情况
-     */
-    generateAnthropicUsage(processedRequest) {
-        // 简单的 token 计算逻辑
-        const inputTokens = this.calculateAnthropicTokens(processedRequest.messages.slice(0, -1));
-        const outputTokens = this.calculateAnthropicTokens(processedRequest.messages.slice(-1));
-        return {
-            input_tokens: Math.max(1, inputTokens),
-            output_tokens: Math.max(1, outputTokens)
-        };
-    }
-    /**
-     * 生成消息ID
-     */
-    generateMessageId() {
-        const timestamp = Math.floor(Date.now() / 1000);
-        const random = Math.random().toString(36).substr(2, 8);
-        return `msg_${timestamp}_${random}`;
-    }
-    /**
-     * 验证 Anthropic 响应
-     */
-    validateAnthropicResponse(response) {
-        if (!response.id) {
-            throw new ConversionError('Anthropic response must have id', this.id);
-        }
-        if (response.type !== 'message') {
-            throw new ConversionError('Anthropic response type must be message', this.id);
-        }
-        if (response.role !== 'assistant') {
-            throw new ConversionError('Anthropic response role must be assistant', this.id);
-        }
-        if (!Array.isArray(response.content) || response.content.length === 0) {
-            throw new ConversionError('Anthropic response must have non-empty content array', this.id);
-        }
-        if (!response.model) {
-            throw new ConversionError('Anthropic response must have model', this.id);
-        }
-        if (!response.usage) {
-            throw new ConversionError('Anthropic response must have usage', this.id);
-        }
-    }
-    /**
-     * 验证流式 Anthropic 响应
-     */
-    validateStreamingAnthropicResponse(response) {
-        if (!response.id) {
-            throw new ConversionError('Anthropic streaming response must have id', this.id);
-        }
-        if (response.type !== 'message') {
-            throw new ConversionError('Anthropic streaming response type must be message', this.id);
-        }
-        if (response.role !== 'assistant') {
-            throw new ConversionError('Anthropic streaming response role must be assistant', this.id);
-        }
-        if (response.content && !Array.isArray(response.content)) {
-            throw new ConversionError('Anthropic streaming response content must be array', this.id);
-        }
-        if (!response.model) {
-            throw new ConversionError('Anthropic streaming response must have model', this.id);
-        }
-    }
-    /**
-     * 计算 Anthropic token 数量
-     */
-    calculateAnthropicTokens(messages) {
-        // 简单的 token 估算（Anthropic 可能使用不同的计数方式）
-        const totalChars = messages.reduce((sum, msg) => {
-            const contentLength = (msg.content || '').length;
-            const toolCallLength = (msg.tool_calls || []).reduce((tcSum, tc) => {
-                return tcSum + tc.function.name.length + tc.function.arguments.length;
-            }, 0);
-            return sum + contentLength + toolCallLength;
-        }, 0);
-        // Anthropic 可能有不同的 token 计算，这里使用简单估算
-        return Math.ceil(totalChars / 3.5); // Claude 可能有不同的 token/char 比例
-    }
-    /**
-     * 提取工具调用信息
-     */
-    extractToolCallInfo(messages) {
-        const assistantMessages = messages.filter(m => m.role === 'assistant' && m.tool_calls);
-        if (assistantMessages.length === 0) {
-            return { hasToolCalls: false };
-        }
-        const allToolCalls = assistantMessages.flatMap(m => m.tool_calls || []);
-        return {
-            hasToolCalls: true,
-            toolCallCount: allToolCalls.length,
-            uniqueTools: new Set(allToolCalls.map(tc => tc.function.name)).size,
-            toolNames: allToolCalls.map(tc => tc.function.name),
-            // Anthropic 特定信息
-            toolUseCount: allToolCalls.length,
-            totalTools: allToolCalls.length
-        };
-    }
-}