@jsonstudio/llms 0.4.2

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

@@ -0,0 +1,128 @@
+/**
+ * 端点处理器基类
+ *
+ * 为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

@@ -0,0 +1,545 @@
+/**
+ * 端点处理器基类
+ *
+ * 为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;
+        }
+    }
+}