@jsonstudio/llms 0.4.2 → 0.4.4

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

@@ -1,128 +0,0 @@
-/**
- * 端点处理器基类
- *
- * 为Chat、Responses、Messages端点提供统一的处理基础
- */
-import type { LLMSwitchHookContext, LLMSwitchHookStage, LLMSwitchProcessingResult, EndpointType, ProtocolType, ProcessingMode, SSEEvent } from '../api/llmswitch-types.js';
-import type { HooksIntegration } from '../hooks/hooks-integration.js';
-/**
- * 端点处理配置
- */
-export interface EndpointHandlerConfig {
-    endpoint: EndpointType;
-    protocol: ProtocolType;
-    enabled: boolean;
-    sse: {
-        enabled: boolean;
-        accumulateMs: number;
-        maxEvents: number;
-        timeout: number;
-    };
-    hooks: {
-        enabled: boolean;
-        stages: string[];
-        timeout: number;
-    };
-    conversion: {
-        autoDetect: boolean;
-        fallbackToOriginal: boolean;
-    };
-}
-/**
- * 端点处理器基类
- */
-export declare abstract class BaseEndpointHandler {
-    protected config: EndpointHandlerConfig;
-    protected hooksAdapter: HooksIntegration;
-    constructor(config: EndpointHandlerConfig, hooksAdapter: HooksIntegration);
-    /**
-     * 处理请求 - llmswitch-core只负责请求预处理
-     */
-    protected preprocessRequest(request: any, context?: Partial<LLMSwitchHookContext>): Promise<LLMSwitchProcessingResult>;
-    /**
-     * 处理流式请求预处理 - llmswitch-core只负责请求预处理
-     */
-    preprocessStreamingRequest(request: any, context?: Partial<LLMSwitchHookContext>): Promise<AsyncIterable<SSEEvent>>;
-    /**
-     * 响应后处理 - 从workflow接收响应进行处理
-     */
-    postprocessResponse(response: any, originalEndpoint: EndpointType, context: LLMSwitchHookContext): Promise<LLMSwitchProcessingResult>;
-    /**
-     * 流式响应后处理 - 从workflow接收流式响应进行处理
-     */
-    postprocessStreamingResponse(events: AsyncIterable<SSEEvent>, originalEndpoint: EndpointType, context: LLMSwitchHookContext): Promise<AsyncIterable<SSEEvent>>;
-    /**
-     * 公共请求处理方法 - 供路由器调用
-     */
-    processRequest(request: any, context?: Partial<LLMSwitchHookContext>): Promise<LLMSwitchProcessingResult>;
-    /**
-     * 执行请求预处理流水线 - 为workflow准备
-     */
-    protected executeRequestPreprocessingPipeline(request: any, context: LLMSwitchHookContext): Promise<LLMSwitchProcessingResult>;
-    /**
-     * 执行响应后处理流水线 - 从workflow接收响应
-     */
-    protected executeResponsePostprocessingPipeline(response: any, context: LLMSwitchHookContext): Promise<LLMSwitchProcessingResult>;
-    /**
-     * 执行流式请求预处理流水线 - 为workflow准备
-     */
-    protected executeStreamingPreprocessingPipeline(request: any, context: LLMSwitchHookContext): AsyncIterable<SSEEvent>;
-    /**
-     * 执行流式响应后处理流水线 - 从workflow接收响应
-     */
-    protected executeStreamingResponsePostprocessingPipeline(events: AsyncIterable<SSEEvent>, context: LLMSwitchHookContext): AsyncIterable<SSEEvent>;
-    /**
-     * 在流式请求中应用Hooks
-     */
-    protected processStreamWithHooks(streamGenerator: AsyncIterable<SSEEvent>, context: LLMSwitchHookContext): AsyncIterable<SSEEvent>;
-    /**
-     * 在流式响应中应用Hooks
-     */
-    protected processStreamWithResponseHooks(events: AsyncIterable<SSEEvent>, context: LLMSwitchHookContext): AsyncIterable<SSEEvent>;
-    /**
-     * 生成流式响应 - 默认实现
-     */
-    protected generateStreamingResponse(request: any, context: LLMSwitchHookContext): AsyncIterable<SSEEvent>;
-    /**
-     * 执行Hook阶段
-     */
-    protected executeHookStage(stages: string[], context: LLMSwitchHookContext, data: any): Promise<LLMSwitchProcessingResult>;
-    /**
-     * 抽象方法：处理端点具体请求预处理逻辑
-     * llmswitch-core只负责请求预处理，不执行实际调用
-     */
-    protected abstract processEndpointRequest(request: any, context: LLMSwitchHookContext): Promise<LLMSwitchProcessingResult>;
-    /**
-     * 抽象方法：处理流式端点请求预处理
-     * llmswitch-core只负责请求预处理，不执行实际调用
-     */
-    protected abstract processStreamingEndpointRequest(request: any, context: LLMSwitchHookContext): AsyncIterable<SSEEvent>;
-    /**
-     * 构建Hook上下文
-     */
-    protected buildHookContext(stage: LLMSwitchHookStage, pathIdentifier: string, processingMode: ProcessingMode, additionalContext?: Partial<LLMSwitchHookContext>): LLMSwitchHookContext;
-    /**
-     * 生成路径标识符
-     */
-    protected generatePathIdentifier(request: any): string;
-    /**
-     * 检测处理模式
-     */
-    protected detectProcessingMode(request: any): ProcessingMode;
-    /**
-     * 生成执行ID
-     */
-    protected generateExecutionId(): string;
-    /**
-     * 获取端点信息
-     */
-    getEndpointInfo(): EndpointHandlerConfig;
-    /**
-     * 更新配置
-     */
-    updateConfig(updates: Partial<EndpointHandlerConfig>): void;
-    /**
-     * 健康检查
-     */
-    healthCheck(): Promise<boolean>;
-}

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

@@ -1,545 +0,0 @@
-/**
- * 端点处理器基类
- *
- * 为Chat、Responses、Messages端点提供统一的处理基础
- */
-/**
- * 端点处理器基类
- */
-export class BaseEndpointHandler {
-    config;
-    hooksAdapter;
-    constructor(config, hooksAdapter) {
-        this.config = config;
-        this.hooksAdapter = hooksAdapter;
-    }
-    /**
-     * 处理请求 - llmswitch-core只负责请求预处理
-     */
-    async preprocessRequest(request, context) {
-        if (!this.config.enabled) {
-            return {
-                success: false,
-                error: new Error(`Endpoint ${this.config.endpoint} is disabled`),
-                executionTime: 0,
-                metadata: {
-                    endpoint: this.config.endpoint,
-                    originalProtocol: this.config.protocol,
-                    targetProtocol: this.config.protocol,
-                    processingMode: 'non-streaming',
-                    stage: 'disabled'
-                }
-            };
-        }
-        const pathIdentifier = this.generatePathIdentifier(request);
-        const processingMode = this.detectProcessingMode(request);
-        // 构建Hook上下文
-        const hookContext = this.buildHookContext('REQUEST_1_VALIDATION_PRE', pathIdentifier, processingMode, context);
-        return this.executeRequestPreprocessingPipeline(request, hookContext);
-    }
-    /**
-     * 处理流式请求预处理 - llmswitch-core只负责请求预处理
-     */
-    async preprocessStreamingRequest(request, context) {
-        if (!this.config.enabled) {
-            throw new Error(`Endpoint ${this.config.endpoint} is disabled`);
-        }
-        const pathIdentifier = this.generatePathIdentifier(request);
-        const processingMode = 'streaming';
-        // 构建Hook上下文
-        const hookContext = this.buildHookContext('REQUEST_1_VALIDATION_PRE', pathIdentifier, processingMode, context);
-        return this.executeStreamingPreprocessingPipeline(request, hookContext);
-    }
-    /**
-     * 响应后处理 - 从workflow接收响应进行处理
-     */
-    async postprocessResponse(response, originalEndpoint, context) {
-        return this.executeResponsePostprocessingPipeline(response, context);
-    }
-    /**
-     * 流式响应后处理 - 从workflow接收流式响应进行处理
-     */
-    async postprocessStreamingResponse(events, originalEndpoint, context) {
-        return this.executeStreamingResponsePostprocessingPipeline(events, context);
-    }
-    /**
-     * 公共请求处理方法 - 供路由器调用
-     */
-    async processRequest(request, context) {
-        return this.preprocessRequest(request, context);
-    }
-    /**
-     * 执行请求预处理流水线 - 为workflow准备
-     */
-    async executeRequestPreprocessingPipeline(request, context) {
-        const startTime = Date.now();
-        let currentRequest = request;
-        let hookResults = [];
-        try {
-            // 1. 请求验证和预处理 (REQUEST_1_*)
-            const validationResult = await this.executeHookStage(['REQUEST_1_VALIDATION_PRE', 'REQUEST_1_VALIDATION_POST'], { ...context, hookSequence: 1 }, currentRequest);
-            if (!validationResult.success) {
-                throw validationResult.error;
-            }
-            currentRequest = validationResult.data;
-            hookResults.push(...validationResult.metadata?.hookResults || []);
-            // 2. 端点路由处理 (REQUEST_2_*)
-            const routingResult = await this.executeHookStage(['REQUEST_2_ROUTING_PRE', 'REQUEST_2_ROUTING_POST'], { ...context, hookSequence: 2 }, currentRequest);
-            if (!routingResult.success) {
-                throw routingResult.error;
-            }
-            currentRequest = routingResult.data;
-            hookResults.push(...routingResult.metadata?.hookResults || []);
-            // 3. 协议转换（请求方向）(REQUEST_3_*)
-            const conversionResult = await this.executeHookStage(['REQUEST_3_CONVERSION_PRE', 'REQUEST_3_CONVERSION_POST'], { ...context, hookSequence: 3 }, currentRequest);
-            if (!conversionResult.success) {
-                throw conversionResult.error;
-            }
-            currentRequest = conversionResult.data;
-            hookResults.push(...conversionResult.metadata?.hookResults || []);
-            // 4. 工具处理（请求方向）(REQUEST_4_*)
-            const toolsResult = await this.executeHookStage(['REQUEST_4_TOOLS_PRE', 'REQUEST_4_TOOLS_POST'], { ...context, hookSequence: 4 }, currentRequest);
-            if (!toolsResult.success) {
-                throw toolsResult.error;
-            }
-            currentRequest = toolsResult.data;
-            hookResults.push(...toolsResult.metadata?.hookResults || []);
-            // 5. SSE处理（流式请求）(REQUEST_5_*)
-            const sseResult = await this.executeHookStage(['REQUEST_5_SSE_PRE', 'REQUEST_5_SSE_POST'], { ...context, hookSequence: 5 }, currentRequest);
-            if (!sseResult.success) {
-                throw sseResult.error;
-            }
-            currentRequest = sseResult.data;
-            hookResults.push(...sseResult.metadata?.hookResults || []);
-            // 6. 快照捕获（请求前）(REQUEST_6_*)
-            const snapshotResult = await this.executeHookStage(['REQUEST_6_SNAPSHOT_PRE', 'REQUEST_6_SNAPSHOT_POST'], { ...context, hookSequence: 6 }, currentRequest);
-            if (!snapshotResult.success) {
-                throw snapshotResult.error;
-            }
-            currentRequest = snapshotResult.data;
-            hookResults.push(...snapshotResult.metadata?.hookResults || []);
-            // 7. 监控指标收集（请求）(REQUEST_7_*)
-            const monitoringResult = await this.executeHookStage(['REQUEST_7_MONITORING_PRE', 'REQUEST_7_MONITORING_POST'], { ...context, hookSequence: 7 }, currentRequest);
-            if (!monitoringResult.success) {
-                throw monitoringResult.error;
-            }
-            currentRequest = monitoringResult.data;
-            hookResults.push(...monitoringResult.metadata?.hookResults || []);
-            // 8. 最终请求验证 (REQUEST_8_*)
-            const finalValidationResult = await this.executeHookStage(['REQUEST_8_VALIDATION_PRE', 'REQUEST_8_VALIDATION_POST'], { ...context, hookSequence: 8 }, currentRequest);
-            if (!finalValidationResult.success) {
-                throw finalValidationResult.error;
-            }
-            // 完成请求预处理，返回处理后的请求给workflow
-            return {
-                success: true,
-                data: finalValidationResult.data, // 处理后的请求，传递给workflow
-                executionTime: Date.now() - startTime,
-                metadata: {
-                    endpoint: this.config.endpoint,
-                    originalProtocol: this.config.protocol,
-                    targetProtocol: this.config.protocol,
-                    processingMode: context.processingMode,
-                    stage: 'request_preprocessing_completed',
-                    hookResults
-                }
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error,
-                executionTime: Date.now() - startTime,
-                metadata: {
-                    endpoint: this.config.endpoint,
-                    originalProtocol: this.config.protocol,
-                    targetProtocol: this.config.protocol,
-                    processingMode: context.processingMode,
-                    stage: 'request_preprocessing_failed',
-                    hookResults
-                }
-            };
-        }
-    }
-    /**
-     * 执行响应后处理流水线 - 从workflow接收响应
-     */
-    async executeResponsePostprocessingPipeline(response, context) {
-        const startTime = Date.now();
-        let currentResponse = response;
-        let hookResults = [];
-        try {
-            // 1. 响应接收和初始处理 (RESPONSE_1_*)
-            const receiveResult = await this.executeHookStage(['RESPONSE_1_RECEIVE_PRE', 'RESPONSE_1_RECEIVE_POST'], { ...context, hookSequence: 1 }, currentResponse);
-            if (!receiveResult.success) {
-                throw receiveResult.error;
-            }
-            currentResponse = receiveResult.data;
-            hookResults.push(...receiveResult.metadata?.hookResults || []);
-            // 2. 协议转换（响应方向）(RESPONSE_2_*)
-            const conversionResult = await this.executeHookStage(['RESPONSE_2_CONVERSION_PRE', 'RESPONSE_2_CONVERSION_POST'], { ...context, hookSequence: 2 }, currentResponse);
-            if (!conversionResult.success) {
-                throw conversionResult.error;
-            }
-            currentResponse = conversionResult.data;
-            hookResults.push(...conversionResult.metadata?.hookResults || []);
-            // 3. 工具结果处理 (RESPONSE_3_*)
-            const toolsResult = await this.executeHookStage(['RESPONSE_3_TOOLS_PRE', 'RESPONSE_3_TOOLS_POST'], { ...context, hookSequence: 3 }, currentResponse);
-            if (!toolsResult.success) {
-                throw toolsResult.error;
-            }
-            currentResponse = toolsResult.data;
-            hookResults.push(...toolsResult.metadata?.hookResults || []);
-            // 4. SSE处理（流式响应）(RESPONSE_4_*)
-            const sseResult = await this.executeHookStage(['RESPONSE_4_SSE_PRE', 'RESPONSE_4_SSE_POST'], { ...context, hookSequence: 4 }, currentResponse);
-            if (!sseResult.success) {
-                throw sseResult.error;
-            }
-            currentResponse = sseResult.data;
-            hookResults.push(...sseResult.metadata?.hookResults || []);
-            // 5. 响应格式化和清理 (RESPONSE_5_*)
-            const formattingResult = await this.executeHookStage(['RESPONSE_5_FORMATTING_PRE', 'RESPONSE_5_FORMATTING_POST'], { ...context, hookSequence: 5 }, currentResponse);
-            if (!formattingResult.success) {
-                throw formattingResult.error;
-            }
-            currentResponse = formattingResult.data;
-            hookResults.push(...formattingResult.metadata?.hookResults || []);
-            // 6. 快照存储（响应后）(RESPONSE_6_*)
-            const snapshotResult = await this.executeHookStage(['RESPONSE_6_SNAPSHOT_PRE', 'RESPONSE_6_SNAPSHOT_POST'], { ...context, hookSequence: 6 }, currentResponse);
-            if (!snapshotResult.success) {
-                throw snapshotResult.error;
-            }
-            currentResponse = snapshotResult.data;
-            hookResults.push(...snapshotResult.metadata?.hookResults || []);
-            // 7. 响应质量检查 (RESPONSE_7_*)
-            const qualityResult = await this.executeHookStage(['RESPONSE_7_QUALITY_PRE', 'RESPONSE_7_QUALITY_POST'], { ...context, hookSequence: 7 }, currentResponse);
-            if (!qualityResult.success) {
-                throw qualityResult.error;
-            }
-            currentResponse = qualityResult.data;
-            hookResults.push(...qualityResult.metadata?.hookResults || []);
-            // 8. 监控报告和指标更新 (RESPONSE_8_*)
-            const finalMonitoringResult = await this.executeHookStage(['RESPONSE_8_MONITORING_PRE', 'RESPONSE_8_MONITORING_POST'], { ...context, hookSequence: 8 }, currentResponse);
-            if (!finalMonitoringResult.success) {
-                throw finalMonitoringResult.error;
-            }
-            // 完成响应后处理，返回最终响应
-            return {
-                success: true,
-                data: finalMonitoringResult.data, // 最终处理后的响应
-                executionTime: Date.now() - startTime,
-                metadata: {
-                    endpoint: this.config.endpoint,
-                    originalProtocol: this.config.protocol,
-                    targetProtocol: this.config.protocol,
-                    processingMode: context.processingMode,
-                    stage: 'response_postprocessing_completed',
-                    hookResults
-                }
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error,
-                executionTime: Date.now() - startTime,
-                metadata: {
-                    endpoint: this.config.endpoint,
-                    originalProtocol: this.config.protocol,
-                    targetProtocol: this.config.protocol,
-                    processingMode: context.processingMode,
-                    stage: 'response_postprocessing_failed',
-                    hookResults
-                }
-            };
-        }
-    }
-    /**
-     * 执行流式请求预处理流水线 - 为workflow准备
-     */
-    async *executeStreamingPreprocessingPipeline(request, context) {
-        // 执行请求预处理Hooks
-        const preResult = await this.executeHookStage(['REQUEST_1_VALIDATION_PRE', 'REQUEST_1_VALIDATION_POST'], context, request);
-        if (!preResult.success) {
-            throw preResult.error;
-        }
-        // 执行流式请求预处理（由子类实现）
-        const streamGenerator = this.processStreamingEndpointRequest(preResult.data, context);
-        yield* this.processStreamWithHooks(streamGenerator, context);
-    }
-    /**
-     * 执行流式响应后处理流水线 - 从workflow接收响应
-     */
-    async *executeStreamingResponsePostprocessingPipeline(events, context) {
-        // 在流上应用响应后处理Hooks
-        yield* this.processStreamWithResponseHooks(events, context);
-    }
-    /**
-     * 在流式请求中应用Hooks
-     */
-    async *processStreamWithHooks(streamGenerator, context) {
-        const sseEvents = [];
-        let accumulatedTime = 0;
-        try {
-            for await (const event of streamGenerator) {
-                sseEvents.push(event);
-                // 累积事件
-                accumulatedTime += Date.now() - (event.timestamp || Date.now());
-                // 如果达到累积时间或事件数量限制，触发Hooks
-                if (accumulatedTime >= this.config.sse.accumulateMs ||
-                    sseEvents.length >= this.config.sse.maxEvents) {
-                    // 执行SSE处理Hooks
-                    const hookResult = await this.executeHookStage(['REQUEST_5_SSE_PRE', 'REQUEST_5_SSE_POST'], { ...context, hookSequence: 5 }, sseEvents);
-                    if (hookResult.success) {
-                        yield* hookResult.data;
-                    }
-                    else {
-                        throw hookResult.error;
-                    }
-                    // 重置累积
-                    sseEvents.length = 0;
-                    accumulatedTime = 0;
-                }
-                else {
-                    yield event;
-                }
-            }
-            // 处理剩余事件
-            if (sseEvents.length > 0) {
-                yield* sseEvents;
-            }
-        }
-        catch (error) {
-            // 发出错误事件
-            yield {
-                event: 'error',
-                data: JSON.stringify({ error: error.message }),
-                timestamp: Date.now()
-            };
-        }
-    }
-    /**
-     * 在流式响应中应用Hooks
-     */
-    async *processStreamWithResponseHooks(events, context) {
-        const sseEvents = [];
-        let accumulatedTime = 0;
-        try {
-            for await (const event of events) {
-                sseEvents.push(event);
-                // 累积事件
-                accumulatedTime += Date.now() - (event.timestamp || Date.now());
-                // 如果达到累积时间或事件数量限制，触发Hooks
-                if (accumulatedTime >= this.config.sse.accumulateMs ||
-                    sseEvents.length >= this.config.sse.maxEvents) {
-                    // 执行响应SSE处理Hooks
-                    const hookResult = await this.executeHookStage(['RESPONSE_4_SSE_PRE', 'RESPONSE_4_SSE_POST'], { ...context, hookSequence: 4 }, sseEvents);
-                    if (hookResult.success) {
-                        yield* hookResult.data;
-                    }
-                    else {
-                        throw hookResult.error;
-                    }
-                    // 重置累积
-                    sseEvents.length = 0;
-                    accumulatedTime = 0;
-                }
-                else {
-                    yield event;
-                }
-            }
-            // 处理剩余事件并应用最终Hooks
-            if (sseEvents.length > 0) {
-                const hookResult = await this.executeHookStage(['RESPONSE_5_FORMATTING_PRE', 'RESPONSE_5_FORMATTING_POST'], { ...context, hookSequence: 5 }, sseEvents);
-                if (hookResult.success) {
-                    yield* hookResult.data;
-                }
-                else {
-                    throw hookResult.error;
-                }
-            }
-        }
-        catch (error) {
-            // 发出错误事件
-            yield {
-                event: 'error',
-                data: JSON.stringify({ error: error.message }),
-                timestamp: Date.now()
-            };
-        }
-    }
-    /**
-     * 生成流式响应 - 默认实现
-     */
-    async *generateStreamingResponse(request, context) {
-        // 默认流式响应实现
-        yield {
-            event: 'message',
-            data: JSON.stringify({
-                id: `msg_${Date.now()}`,
-                object: 'chat.completion.chunk',
-                created: Math.floor(Date.now() / 1000),
-                model: request.model || 'default',
-                choices: [{
-                        index: 0,
-                        delta: { content: 'This is a default streaming response from llmswitch-core.' },
-                        finish_reason: null
-                    }]
-            }),
-            timestamp: Date.now()
-        };
-        // 结束事件
-        yield {
-            event: 'done',
-            data: JSON.stringify({ finished: true }),
-            timestamp: Date.now()
-        };
-    }
-    /**
-     * 执行Hook阶段
-     */
-    async executeHookStage(stages, context, data) {
-        if (!this.config.hooks.enabled) {
-            return {
-                success: true,
-                data,
-                executionTime: 0,
-                metadata: {
-                    endpoint: this.config.endpoint,
-                    originalProtocol: this.config.protocol,
-                    targetProtocol: this.config.protocol,
-                    processingMode: context.processingMode,
-                    stage: stages[0],
-                    hookResults: []
-                }
-            };
-        }
-        const startTime = Date.now();
-        let currentData = data;
-        const results = [];
-        for (let i = 0; i < stages.length; i++) {
-            const stage = stages[i];
-            const hookContext = {
-                ...context,
-                stage: stage,
-                hookSequence: context.hookSequence + i
-            };
-            try {
-                const result = await this.hooksAdapter.executeHook(stage, hookContext, currentData);
-                if (!result.success) {
-                    return {
-                        success: false,
-                        error: result.error,
-                        executionTime: Date.now() - startTime,
-                        metadata: {
-                            endpoint: this.config.endpoint,
-                            originalProtocol: this.config.protocol,
-                            targetProtocol: this.config.protocol,
-                            processingMode: context.processingMode,
-                            stage,
-                            hookResults: results
-                        }
-                    };
-                }
-                currentData = result.data;
-                results.push(result.metadata?.hookResults || []);
-            }
-            catch (error) {
-                return {
-                    success: false,
-                    error: error,
-                    executionTime: Date.now() - startTime,
-                    metadata: {
-                        endpoint: this.config.endpoint,
-                        originalProtocol: this.config.protocol,
-                        targetProtocol: this.config.protocol,
-                        processingMode: context.processingMode,
-                        stage,
-                        hookResults: results
-                    }
-                };
-            }
-        }
-        return {
-            success: true,
-            data: currentData,
-            executionTime: Date.now() - startTime,
-            metadata: {
-                endpoint: this.config.endpoint,
-                originalProtocol: this.config.protocol,
-                targetProtocol: this.config.protocol,
-                processingMode: context.processingMode,
-                stage: stages[stages.length - 1],
-                hookResults: results.flat()
-            }
-        };
-    }
-    /**
-     * 构建Hook上下文
-     */
-    buildHookContext(stage, pathIdentifier, processingMode, additionalContext) {
-        return {
-            executionId: this.generateExecutionId(),
-            stage,
-            startTime: Date.now(),
-            requestId: additionalContext?.requestId,
-            moduleId: `endpoint-${this.config.endpoint}`,
-            metadata: additionalContext?.metadata,
-            endpoint: this.config.endpoint,
-            originalProtocol: this.config.protocol,
-            targetProtocol: this.config.protocol,
-            pathIdentifier,
-            processingMode,
-            hookSequence: 1,
-            totalHooks: 16
-        };
-    }
-    /**
-     * 生成路径标识符
-     */
-    generatePathIdentifier(request) {
-        // 默认使用请求ID或生成唯一标识
-        return request.id || `${this.config.endpoint}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-    /**
-     * 检测处理模式
-     */
-    detectProcessingMode(request) {
-        // 检查是否为流式请求
-        if (request.stream === true || request.stream === 'true') {
-            return 'streaming';
-        }
-        // 自动检测模式
-        return 'auto';
-    }
-    /**
-     * 生成执行ID
-     */
-    generateExecutionId() {
-        return `exec-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-    /**
-     * 获取端点信息
-     */
-    getEndpointInfo() {
-        return { ...this.config };
-    }
-    /**
-     * 更新配置
-     */
-    updateConfig(updates) {
-        this.config = { ...this.config, ...updates };
-    }
-    /**
-     * 健康检查
-     */
-    async healthCheck() {
-        try {
-            // 基本健康检查逻辑
-            return this.config.enabled;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-}