@jsonstudio/llms 0.4.2

package/dist/endpoints/messages-endpoint-handler.js

@@ -0,0 +1,238 @@
+/**
+ * Messages端点处理器
+ *
+ * 处理/v1/messages端点的请求和响应 (Anthropic Messages API)
+ */
+import { BaseEndpointHandler } from './base-endpoint-handler.js';
+import { TokenCounter } from '../utils/token-counter.js';
+import { RequestLogicProcessor } from '../utils/request-processor.js';
+/**
+ * Messages端点处理器
+ */
+export class MessagesEndpointHandler extends BaseEndpointHandler {
+    constructor(hooksAdapter) {
+        const config = {
+            endpoint: 'messages',
+            protocol: 'anthropic-messages',
+            enabled: true,
+            sse: {
+                enabled: true,
+                accumulateMs: 500,
+                maxEvents: 100,
+                timeout: 30000
+            },
+            hooks: {
+                enabled: true,
+                stages: [
+                    'request_1_validation_pre',
+                    'request_1_validation_post',
+                    'request_2_routing_pre',
+                    'request_2_routing_post',
+                    'request_3_conversion_pre',
+                    'request_3_conversion_post',
+                    'request_4_tools_pre',
+                    'request_4_tools_post',
+                    'request_5_sse_pre',
+                    'request_5_sse_post',
+                    'request_6_snapshot_pre',
+                    'request_6_snapshot_post',
+                    'request_7_monitoring_pre',
+                    'request_7_monitoring_post',
+                    'request_8_validation_pre',
+                    'request_8_validation_post',
+                    'response_1_receive_pre',
+                    'response_1_receive_post',
+                    'response_2_conversion_pre',
+                    'response_2_conversion_post',
+                    'response_3_tools_pre',
+                    'response_3_tools_post',
+                    'response_4_sse_pre',
+                    'response_4_sse_post',
+                    'response_5_formatting_pre',
+                    'response_5_formatting_post',
+                    'response_6_snapshot_pre',
+                    'response_6_snapshot_post',
+                    'response_7_quality_pre',
+                    'response_7_quality_post',
+                    'response_8_monitoring_pre',
+                    'response_8_monitoring_post'
+                ],
+                timeout: 5000
+            },
+            conversion: {
+                autoDetect: true,
+                fallbackToOriginal: true
+            }
+        };
+        super(config, hooksAdapter);
+    }
+    /**
+     * 处理Messages端点请求预处理 - llmswitch-core只负责预处理
+     */
+    async processEndpointRequest(request, context) {
+        const startTime = Date.now();
+        try {
+            // 1. 验证请求格式
+            this.validateMessagesRequest(request);
+            // 2. 预处理请求（协议转换、工具调用规范化等）
+            const processedRequest = await this.preprocessRequest(request, context);
+            // 3. 返回预处理后的请求，传递给workflow
+            return {
+                success: true,
+                data: processedRequest, // 预处理后的请求，给workflow处理
+                executionTime: Date.now() - startTime,
+                metadata: {
+                    endpoint: 'messages',
+                    originalProtocol: this.config.protocol,
+                    targetProtocol: this.config.protocol,
+                    processingMode: context.processingMode,
+                    stage: 'messages_request_preprocessing_completed'
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error,
+                executionTime: Date.now() - startTime,
+                metadata: {
+                    endpoint: 'messages',
+                    originalProtocol: this.config.protocol,
+                    targetProtocol: this.config.protocol,
+                    processingMode: context.processingMode,
+                    stage: 'messages_request_preprocessing_failed'
+                }
+            };
+        }
+    }
+    /**
+     * 处理流式Messages请求
+     */
+    async *processStreamingEndpointRequest(request, context) {
+        try {
+            // 验证请求格式
+            this.validateMessagesRequest(request);
+            // 预处理请求
+            const processedRequest = await this.preprocessRequest(request, context);
+            // 生成流式响应
+            yield* this.generateStreamingResponse(processedRequest, context);
+        }
+        catch (error) {
+            // 发出错误事件
+            yield {
+                event: 'error',
+                data: JSON.stringify({
+                    error: {
+                        message: error.message,
+                        type: 'messages_processing_error'
+                    }
+                }),
+                timestamp: Date.now()
+            };
+        }
+    }
+    /**
+     * 验证Messages请求格式
+     */
+    validateMessagesRequest(request) {
+        // 验证请求格式（V2）
+        const validation = RequestLogicProcessor.validateRequest(request, 'messages');
+        if (!validation.valid) {
+            throw new Error(`Messages请求验证失败: ${validation.errors.join(', ')}`);
+        }
+    }
+    /**
+     * 预处理请求 - 协议转换、工具调用规范化等
+     */
+    async preprocessRequest(request, context) {
+        // 使用V2逻辑处理Messages请求规范化
+        return RequestLogicProcessor.processMessagesRequest(request);
+    }
+    /**
+     * 规范化工具调用
+     */
+    async normalizeTools(request) {
+        // 这里可以实现工具调用的规范化逻辑
+        // 例如：Anthropic工具格式转换等
+        return request;
+    }
+    /**
+     * 规范化消息
+     */
+    async normalizeMessages(request) {
+        // 这里可以实现消息的规范化逻辑
+        // 例如：内容格式转换、图片处理等
+        return request;
+    }
+    /**
+     * 处理内容项
+     */
+    async processContentItems(response) {
+        // 这里可以实现内容项的处理逻辑
+        return response;
+    }
+    /**
+     * 验证响应格式
+     */
+    validateResponse(response) {
+        if (!response.id) {
+            throw new Error('Response missing required field: id');
+        }
+        if (!response.type) {
+            throw new Error('Response missing required field: type');
+        }
+        if (!response.content || !Array.isArray(response.content) || response.content.length === 0) {
+            throw new Error('Response missing required field: content');
+        }
+    }
+    /**
+     * 生成模拟响应内容
+     */
+    generateMockResponse(request) {
+        const lastMessage = request.messages[request.messages.length - 1];
+        const content = typeof lastMessage.content === 'string'
+            ? lastMessage.content
+            : lastMessage.content?.[0]?.text || 'Hello!';
+        return `这是Messages端点的模拟响应，基于您的输入：${content.substring(0, 50)}...`;
+    }
+    /**
+     * 计算Token数量（使用精确计算）
+     */
+    async calculateTokens(text, model = 'gpt-3.5-turbo') {
+        return await TokenCounter.calculateTokens(text, model);
+    }
+    /**
+     * 计算请求的token数量（使用精确计算）
+     */
+    async calculateRequestTokens(request) {
+        // 将Messages请求转换为Chat格式进行计算
+        const chatRequest = {
+            model: request.model,
+            messages: [
+                ...(request.system ? [{ role: 'system', content: request.system }] : []),
+                ...request.messages
+            ],
+            tools: request.tools
+        };
+        const { inputTokens, toolTokens } = await TokenCounter.calculateRequestTokensExact(chatRequest, request.model);
+        return inputTokens + (toolTokens || 0);
+    }
+    /**
+     * 生成路径标识符
+     */
+    generatePathIdentifier(request) {
+        // 使用模型名和消息数量生成标识符
+        const messageCount = request.messages?.length || 0;
+        const toolCount = request.tools?.length || 0;
+        return `messages-${request.model.replace(/[^a-zA-Z0-9]/g, '-')}-${messageCount}msg-${toolCount}tools`;
+    }
+    /**
+     * 检测处理模式
+     */
+    detectProcessingMode(request) {
+        if (request.stream === true) {
+            return 'streaming';
+        }
+        return 'non-streaming';
+    }
+}

package/dist/endpoints/responses-endpoint-handler.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Responses端点处理器
+ *
+ * 处理/v1/responses端点的请求和响应
+ */
+import type { LLMSwitchHookContext, LLMSwitchProcessingResult, ProcessingMode, SSEEvent } from '../api/llmswitch-types.js';
+import { BaseEndpointHandler } from './base-endpoint-handler.js';
+import type { HooksIntegration } from '../hooks/hooks-integration.js';
+/**
+ * OpenAI Responses请求接口
+ */
+export interface ResponsesRequest {
+    input: string;
+    instructions?: string;
+    tools?: any[];
+    temperature?: number;
+    max_tokens?: number;
+    stream?: boolean;
+    previous_response_id?: string;
+    truncation_strategy?: any;
+    metadata?: any;
+}
+/**
+ * OpenAI Responses响应接口
+ */
+export interface ResponsesResponse {
+    id: string;
+    object: 'response';
+    created: number;
+    model: string;
+    output: Array<{
+        type: 'message';
+        id: string;
+        role: 'assistant';
+        content: Array<{
+            type: 'text';
+            text: string;
+        }>;
+    }>;
+    output_text: string;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    tool_calls?: any[];
+    error?: any;
+}
+/**
+ * Responses请求格式
+ */
+export interface ResponsesRequest {
+    model: string;
+    input: string;
+    instructions?: string;
+    tools?: any[];
+    temperature?: number;
+    max_tokens?: number;
+    stream?: boolean;
+    top_p?: number;
+    user?: string;
+    response_format?: any;
+    truncation?: string;
+}
+/**
+ * Responses响应格式
+ */
+export interface ResponsesResponse {
+    id: string;
+    object: 'response';
+    created: number;
+    model: string;
+    status: 'in_progress' | 'completed' | 'failed';
+    output: Array<{
+        type: 'message';
+        id: string;
+        role: 'assistant';
+        content: Array<{
+            type: 'text';
+            text: string;
+        }>;
+    }>;
+    output_text: string;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+/**
+ * Responses端点处理器
+ */
+export declare class ResponsesEndpointHandler extends BaseEndpointHandler {
+    constructor(hooksAdapter: HooksIntegration);
+    /**
+     * 处理Responses端点请求预处理 - llmswitch-core只负责预处理
+     */
+    protected processEndpointRequest(request: any, context: LLMSwitchHookContext): Promise<LLMSwitchProcessingResult>;
+    /**
+     * 处理流式Responses请求
+     */
+    protected processStreamingEndpointRequest(request: any, context: LLMSwitchHookContext): AsyncIterable<SSEEvent>;
+    /**
+     * 验证Responses请求格式
+     */
+    private validateResponsesRequest;
+    /**
+     * 预处理请求 - 协议转换、工具调用规范化等
+     */
+    protected preprocessRequest(request: any, context: LLMSwitchHookContext): Promise<any>;
+    /**
+     * 规范化工具调用
+     */
+    private normalizeTools;
+    /**
+     * 规范化输入内容
+     */
+    private normalizeInput;
+    /**
+     * 处理输出内容
+     */
+    private processOutputContent;
+    /**
+     * 验证响应格式
+     */
+    private validateResponse;
+    /**
+     * 生成模拟响应内容
+     */
+    private generateMockResponse;
+    /**
+     * 估算Token数量
+     */
+    private estimateTokens;
+    /**
+     * 计算请求的token数量
+     */
+    private calculateRequestTokens;
+    /**
+     * 生成路径标识符
+     */
+    protected generatePathIdentifier(request: any): string;
+    /**
+     * 检测处理模式
+     */
+    protected detectProcessingMode(request: any): ProcessingMode;
+}

package/dist/endpoints/responses-endpoint-handler.js

@@ -0,0 +1,233 @@
+/**
+ * Responses端点处理器
+ *
+ * 处理/v1/responses端点的请求和响应
+ */
+import { BaseEndpointHandler } from './base-endpoint-handler.js';
+import { TokenCounter } from '../utils/token-counter.js';
+import { RequestLogicProcessor } from '../utils/request-processor.js';
+/**
+ * Responses端点处理器
+ */
+export class ResponsesEndpointHandler extends BaseEndpointHandler {
+    constructor(hooksAdapter) {
+        const config = {
+            endpoint: 'responses',
+            protocol: 'openai-responses',
+            enabled: true,
+            sse: {
+                enabled: true,
+                accumulateMs: 500,
+                maxEvents: 100,
+                timeout: 30000
+            },
+            hooks: {
+                enabled: true,
+                stages: [
+                    'request_1_validation_pre',
+                    'request_1_validation_post',
+                    'request_2_routing_pre',
+                    'request_2_routing_post',
+                    'request_3_conversion_pre',
+                    'request_3_conversion_post',
+                    'request_4_tools_pre',
+                    'request_4_tools_post',
+                    'request_5_sse_pre',
+                    'request_5_sse_post',
+                    'request_6_snapshot_pre',
+                    'request_6_snapshot_post',
+                    'request_7_monitoring_pre',
+                    'request_7_monitoring_post',
+                    'request_8_validation_pre',
+                    'request_8_validation_post',
+                    'response_1_receive_pre',
+                    'response_1_receive_post',
+                    'response_2_conversion_pre',
+                    'response_2_conversion_post',
+                    'response_3_tools_pre',
+                    'response_3_tools_post',
+                    'response_4_sse_pre',
+                    'response_4_sse_post',
+                    'response_5_formatting_pre',
+                    'response_5_formatting_post',
+                    'response_6_snapshot_pre',
+                    'response_6_snapshot_post',
+                    'response_7_quality_pre',
+                    'response_7_quality_post',
+                    'response_8_monitoring_pre',
+                    'response_8_monitoring_post'
+                ],
+                timeout: 5000
+            },
+            conversion: {
+                autoDetect: true,
+                fallbackToOriginal: true
+            }
+        };
+        super(config, hooksAdapter);
+    }
+    /**
+     * 处理Responses端点请求预处理 - llmswitch-core只负责预处理
+     */
+    async processEndpointRequest(request, context) {
+        const startTime = Date.now();
+        try {
+            // 1. 验证请求格式
+            this.validateResponsesRequest(request);
+            // 2. 预处理请求（协议转换、工具调用规范化等）
+            const processedRequest = await this.preprocessRequest(request, context);
+            // 3. 返回预处理后的请求，传递给workflow
+            return {
+                success: true,
+                data: processedRequest, // 预处理后的请求，给workflow处理
+                executionTime: Date.now() - startTime,
+                metadata: {
+                    endpoint: 'responses',
+                    originalProtocol: this.config.protocol,
+                    targetProtocol: this.config.protocol,
+                    processingMode: context.processingMode,
+                    stage: 'responses_request_preprocessing_completed'
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error,
+                executionTime: Date.now() - startTime,
+                metadata: {
+                    endpoint: 'responses',
+                    originalProtocol: this.config.protocol,
+                    targetProtocol: this.config.protocol,
+                    processingMode: context.processingMode,
+                    stage: 'responses_request_preprocessing_failed'
+                }
+            };
+        }
+    }
+    /**
+     * 处理流式Responses请求
+     */
+    async *processStreamingEndpointRequest(request, context) {
+        try {
+            // 验证请求格式
+            this.validateResponsesRequest(request);
+            // 预处理请求
+            const processedRequest = await this.preprocessRequest(request, context);
+            // 生成流式响应
+            yield* this.generateStreamingResponse(processedRequest, context);
+        }
+        catch (error) {
+            // 发出错误事件
+            yield {
+                event: 'error',
+                data: JSON.stringify({
+                    error: {
+                        message: error.message,
+                        type: 'responses_processing_error'
+                    }
+                }),
+                timestamp: Date.now()
+            };
+        }
+    }
+    /**
+     * 验证Responses请求格式
+     */
+    validateResponsesRequest(request) {
+        // 验证请求格式（V2）
+        const validation = RequestLogicProcessor.validateRequest(request, 'responses');
+        if (!validation.valid) {
+            throw new Error(`Responses请求验证失败: ${validation.errors.join(', ')}`);
+        }
+    }
+    /**
+     * 预处理请求 - 协议转换、工具调用规范化等
+     */
+    async preprocessRequest(request, context) {
+        // 使用V2逻辑处理Responses请求规范化
+        return RequestLogicProcessor.processResponsesRequest(request);
+    }
+    /**
+     * 规范化工具调用
+     */
+    async normalizeTools(request) {
+        // 这里可以实现工具调用的规范化逻辑
+        return request;
+    }
+    /**
+     * 规范化输入内容
+     */
+    async normalizeInput(request) {
+        // 这里可以实现输入内容的规范化逻辑
+        return request;
+    }
+    /**
+     * 处理输出内容
+     */
+    async processOutputContent(response) {
+        // 这里可以实现输出内容的处理逻辑
+        return response;
+    }
+    /**
+     * 验证响应格式
+     */
+    validateResponse(response) {
+        if (!response.id) {
+            throw new Error('Response missing required field: id');
+        }
+        if (!response.object) {
+            throw new Error('Response missing required field: object');
+        }
+        if (!response.output || !Array.isArray(response.output) || response.output.length === 0) {
+            throw new Error('Response missing required field: output');
+        }
+    }
+    /**
+     * 生成模拟响应内容
+     */
+    generateMockResponse(request) {
+        const inputText = typeof request.input === 'string' ? request.input : JSON.stringify(request.input);
+        return `这是Responses端点的模拟响应，基于您的输入：${inputText.substring(0, 50)}...`;
+    }
+    /**
+     * 估算Token数量
+     */
+    estimateTokens(text) {
+        return TokenCounter.estimateTokens(text);
+    }
+    /**
+     * 计算请求的token数量
+     */
+    calculateRequestTokens(request) {
+        // 将Responses请求转换为Chat格式进行计算
+        const chatRequest = {
+            model: request.model,
+            messages: [
+                ...(request.instructions ? [{ role: 'system', content: request.instructions }] : []),
+                { role: 'user', content: request.input }
+            ],
+            tools: request.tools
+        };
+        const { inputTokens, toolTokens } = TokenCounter.estimateRequestTokens(chatRequest);
+        return inputTokens + (toolTokens || 0);
+    }
+    /**
+     * 生成路径标识符
+     */
+    generatePathIdentifier(request) {
+        // 使用模型名和输入长度生成标识符
+        const inputLength = typeof request.input === 'string' ? request.input.length : JSON.stringify(request.input).length;
+        const toolCount = request.tools?.length || 0;
+        return `responses-${request.model.replace(/[^a-zA-Z0-9]/g, '-')}-${inputLength}char-${toolCount}tools`;
+    }
+    /**
+     * 检测处理模式
+     */
+    detectProcessingMode(request) {
+        if (request.stream === true) {
+            return 'streaming';
+        }
+        return 'non-streaming';
+    }
+}

package/dist/filters/builtin/add-fields-filter.d.ts

@@ -0,0 +1,8 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+export declare class AddFieldsFilter implements Filter<JsonObject> {
+    readonly name = "add_fields";
+    readonly stage: any;
+    private readonly fields;
+    constructor(stage: FilterContext['stage'], fields: Record<string, unknown>);
+    apply(input: JsonObject): FilterResult<JsonObject>;
+}

package/dist/filters/builtin/add-fields-filter.js

@@ -0,0 +1,16 @@
+export class AddFieldsFilter {
+    name = 'add_fields';
+    stage;
+    fields;
+    constructor(stage, fields) {
+        this.stage = stage;
+        this.fields = fields || {};
+    }
+    apply(input) {
+        const out = JSON.parse(JSON.stringify(input || {}));
+        for (const [k, v] of Object.entries(this.fields)) {
+            out[k] = v;
+        }
+        return { ok: true, data: out };
+    }
+}

package/dist/filters/builtin/blacklist-filter.d.ts

@@ -0,0 +1,8 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+export declare class BlacklistFilter implements Filter<JsonObject> {
+    readonly name = "blacklist";
+    readonly stage: any;
+    private readonly deny;
+    constructor(stage: FilterContext['stage'], deny: string[]);
+    apply(input: JsonObject): FilterResult<JsonObject>;
+}

package/dist/filters/builtin/blacklist-filter.js

@@ -0,0 +1,19 @@
+export class BlacklistFilter {
+    name = 'blacklist';
+    stage;
+    deny;
+    constructor(stage, deny) {
+        this.stage = stage;
+        this.deny = new Set(deny || []);
+    }
+    apply(input) {
+        if (!input || typeof input !== 'object')
+            return { ok: true, data: input };
+        const out = JSON.parse(JSON.stringify(input));
+        for (const k of Object.keys(out)) {
+            if (this.deny.has(k))
+                delete out[k];
+        }
+        return { ok: true, data: out };
+    }
+}

package/dist/filters/builtin/whitelist-filter.d.ts

@@ -0,0 +1,8 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+export declare class WhitelistFilter implements Filter<JsonObject> {
+    readonly name = "whitelist";
+    readonly stage: any;
+    private readonly allow;
+    constructor(stage: FilterContext['stage'], allow: string[]);
+    apply(input: JsonObject): FilterResult<JsonObject>;
+}