lambda_function_alb.py

"""
AWS Lambda function entry point for Bedrock API service
"""
import json
import logging
import time
import uuid
from datetime import datetime
from typing import Dict, Any, Iterator

from services.authentication_handler import AuthenticationHandler
from services.request_parser import RequestParser
from services.image_processor import ImageProcessor
from services.bedrock_client import BedrockClient
from services.response_formatter import ResponseFormatter
from services.stream_handler import StreamHandler
from services.error_handler import ErrorHandler
from utils.logging_utils import setup_logging, StructuredLogger, MonitoringCollector
from config import Config

# 设置结构化日志记录
setup_logging(Config.LOG_LEVEL)

# 创建结构化日志记录器
logger = StructuredLogger("lambda_handler")

# 创建监控收集器（全局实例，在Lambda容器重用时保持状态）
monitoring_collector = MonitoringCollector() if Config.ENABLE_METRICS_COLLECTION else None

# Initialize service components (reuse across invocations)
auth_handler = AuthenticationHandler(
    secret_name=Config.API_KEYS_SECRET_NAME,
    region_name=Config.AWS_REGION
)
request_parser = RequestParser()
image_processor = ImageProcessor(bucket_name=Config.S3_BUCKET)
bedrock_client = BedrockClient(region=Config.BEDROCK_REGION)
response_formatter = ResponseFormatter()
stream_handler = StreamHandler()
error_handler = ErrorHandler()

def parse_event_format(event):
    """
    解析事件格式，支持ALB、API Gateway v1.0和v2.0
    """
    # API Gateway v2.0 format
    if 'requestContext' in event and 'http' in event.get('requestContext', {}):
        return {
            'http_method': event['requestContext']['http']['method'],
            'path': event.get('rawPath', ''),
            'headers': event.get('headers', {}),
            'body': event.get('body', ''),
            'is_base64_encoded': event.get('isBase64Encoded', False),
            'source_ip': event.get('requestContext', {}).get('http', {}).get('sourceIp', 'unknown'),
            'user_agent': event.get('headers', {}).get('user-agent', 'unknown')
        }
    # ALB or API Gateway v1.0 format
    else:
        return {
            'http_method': event.get('httpMethod', ''),
            'path': event.get('path', ''),
            'headers': event.get('headers', {}),
            'body': event.get('body', ''),
            'is_base64_encoded': event.get('isBase64Encoded', False),
            'source_ip': event.get('requestContext', {}).get('identity', {}).get('sourceIp', 'unknown'),
            'user_agent': event.get('headers', {}).get('User-Agent', 'unknown')
        }




def lambda_handler(event: Dict[str, Any], context: Any) -> Dict[str, Any]:
    """
    Lambda function entry point for handling HTTP requests
    
    Args:
        event: Lambda event containing HTTP request data
        context: Lambda context object
        
    Returns:
        HTTP response dictionary or streaming response
    """
    # 生成请求ID用于跟踪
    request_id = str(uuid.uuid4())
    start_time = time.time()
    
    # 解析事件格式
    parsed_event = parse_event_format(event)
    
    # 确定是否为流式请求（用于性能跟踪）
    is_streaming = False
    try:
        body = json.loads(event.get('body', '{}')) if event.get('body') else {}
        is_streaming = body.get('stream', False)
    except:
        pass
    
    # 开始请求跟踪
    metrics = logger.start_request_tracking(
        request_id=request_id,
        is_streaming=is_streaming,
        model_name=Config.BEDROCK_MODEL_ID
    )
    
    try:
        # 记录请求信息
        logger.log_request(
            event=event,
            request_id=request_id,
            enable_request_logging=Config.ENABLE_REQUEST_LOGGING
        )
        
        # 1. Handle CORS preflight requests
        if event.get('httpMethod') == 'OPTIONS':
            response = _create_cors_response()
            logger.log_response(
                status_code=response['statusCode'],
                response_size=len(response.get('body', '')),
                request_id=request_id
            )
            return response
        
        # 2. Handle health check endpoint
        # Use parsed event data
        path = parsed_event['path']
        http_method = parsed_event['http_method']
        
        # Health check endpoint for ALB and API Gateway
        if path == '/health' or path.endswith('/health'):
            return {
                'statusCode': 200,
                'headers': {
                    'Content-Type': 'application/json',
                    'Access-Control-Allow-Origin': '*',
                    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
                    'Access-Control-Allow-Headers': 'Content-Type, Authorization'
                },
                'body': json.dumps({
                    'status': 'healthy',
                    'timestamp': datetime.utcnow().isoformat() + 'Z',
                    'service': 'bedrock-api-service'
                })
            }
        
        # 3. Validate HTTP method and path for API endpoints
        if http_method != 'POST':
            error_response = error_handler.handle_validation_error("Only POST method is supported")
            logger.log_error(
                error=ValueError("Invalid HTTP method"),
                context={"method": http_method},
                request_id=request_id,
                error_phase="method_validation"
            )
            return error_response
        
        if not path.endswith('/v1/mllm/completions'):
            error_response = error_handler.handle_validation_error("Invalid endpoint. Use /v1/mllm/completions")
            logger.log_error(
                error=ValueError("Invalid endpoint"),
                context={"path": path},
                request_id=request_id,
                error_phase="path_validation"
            )
            return error_response
        
        # 3. API Key authentication
        auth_start = time.time()
        auth_header = event.get('headers', {}).get('Authorization') or event.get('headers', {}).get('authorization')
        auth_result = auth_handler.validate_api_key(auth_header)
        auth_duration = (time.time() - auth_start) * 1000
        
        logger.log_performance_phase(
            phase="auth",
            duration_ms=auth_duration,
            request_id=request_id,
            additional_info={"success": auth_result.is_valid}
        )
        
        if not auth_result.is_valid:
            logger.log_authentication(
                success=False,
                error_message=auth_result.error_message,
                request_id=request_id
            )
            error_response = error_handler.handle_authentication_error(auth_result.error_message)
            return error_response
        
        logger.log_authentication(
            success=True,
            api_key_id=auth_result.api_key_id,
            request_id=request_id
        )
        
        # 4. Parse and validate request
        parsing_start = time.time()
        try:
            parsed_request = request_parser.parse_request(event)
        except ValueError as e:
            logger.log_error(
                error=e,
                context={"body": event.get('body', '')[:500]},  # 限制日志大小
                request_id=request_id,
                error_phase="request_parsing"
            )
            return error_handler.handle_validation_error(str(e))
        
        validation_result = request_parser.validate_request(parsed_request)
        parsing_duration = (time.time() - parsing_start) * 1000
        
        logger.log_performance_phase(
            phase="parsing",
            duration_ms=parsing_duration,
            request_id=request_id,
            additional_info={
                "model": parsed_request.model,
                "stream": parsed_request.stream,
                "message_count": len(parsed_request.messages)
            }
        )
        
        if not validation_result.is_valid:
            logger.log_error(
                error=ValueError(validation_result.error_message),
                context={"validation_errors": validation_result.error_message},
                request_id=request_id,
                error_phase="request_validation"
            )
            return error_handler.handle_validation_error(validation_result.error_message)
        
        # 5. Process images in messages
        image_processing_start = time.time()
        image_count = 0
        total_image_size = 0
        
        try:
            processed_request = _process_images_in_request(parsed_request, request_id)
            
            # 统计图像信息
            for message in processed_request.messages:
                for content in message.content:
                    if content.type == 'image' and content.image_base64:
                        image_count += 1
                        # 估算base64图像大小
                        total_image_size += len(content.image_base64) * 3 // 4  # base64解码后的大小
                        
        except Exception as e:
            logger.log_error(
                error=e,
                context={"image_count": image_count},
                request_id=request_id,
                error_phase="image_processing"
            )
            return error_handler.handle_validation_error(f"Image processing failed: {str(e)}")
        
        image_processing_duration = (time.time() - image_processing_start) * 1000
        
        if image_count > 0:
            logger.log_image_processing(
                image_count=image_count,
                total_size_bytes=total_image_size,
                processing_duration_ms=image_processing_duration,
                request_id=request_id
            )
        
        logger.log_performance_phase(
            phase="image_processing",
            duration_ms=image_processing_duration,
            request_id=request_id,
            additional_info={
                "image_count": image_count,
                "total_image_size_bytes": total_image_size
            }
        )
        
        # 6. Convert to Bedrock format
        try:
            bedrock_request = bedrock_client.format_bedrock_request(processed_request)
        except Exception as e:
            logger.log_error(
                error=e,
                context={"model": parsed_request.model},
                request_id=request_id,
                error_phase="bedrock_formatting"
            )
            return error_handler.handle_internal_error(e)
        
        # 7. Route to streaming or non-streaming processing using ALB handler
        from services.alb_response_handler import ALBResponseHandler
        
        if parsed_request.stream:
            return ALBResponseHandler.handle_streaming_request(bedrock_request, parsed_request.meta, start_time, request_id)
        else:
            return ALBResponseHandler.handle_non_streaming_request(bedrock_request, parsed_request.meta, start_time, request_id)
            
    except Exception as e:
        logger.log_error(
            error=e,
            context={"event_path": event.get('path'), "event_method": event.get('httpMethod')},
            request_id=request_id,
            error_phase="lambda_handler"
        )
        return error_handler.handle_internal_error(e)
    
    finally:
        # 完成请求跟踪并收集指标
        final_metrics = logger.finish_request_tracking(request_id)
        
        if final_metrics and monitoring_collector:
            monitoring_collector.add_metrics(final_metrics)
            
            # 定期记录汇总统计
            if len(monitoring_collector.metrics) % Config.METRICS_SUMMARY_INTERVAL == 0:
                monitoring_collector.log_periodic_summary()


def _create_cors_response() -> Dict[str, Any]:
    """Create CORS preflight response"""
    return {
        'statusCode': 200,
        'headers': {
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Methods': 'POST, OPTIONS',
            'Access-Control-Allow-Headers': 'Content-Type, Authorization',
            'Access-Control-Max-Age': '86400'
        },
        'body': ''
    }


def _process_images_in_request(parsed_request, request_id: str):
    """Process images in the request messages"""
    processed_messages = []
    
    for message in parsed_request.messages:
        processed_content = []
        
        for content in message.content:
            if content.type == 'image':
                # Process image content
                try:
                    # Determine if this is a path or base64 data
                    image_data = content.image_base64
                    
                    # More robust detection using multiple heuristics
                    def is_base64_data(data):
                        """Check if data appears to be base64 encoded"""
                        if len(data) < 50:  # Base64 images are typically much longer
                            return False
                        
                        # Check for base64 characteristics
                        import re
                        # Base64 pattern: only contains A-Z, a-z, 0-9, +, /, = and proper padding
                        base64_pattern = re.compile(r'^[A-Za-z0-9+/]*={0,2}$')
                        if not base64_pattern.match(data):
                            return False
                        
                        # Check length is multiple of 4 (base64 requirement)
                        if len(data) % 4 != 0:
                            return False
                        
                        # Try to decode a small portion to verify it's valid base64
                        try:
                            import base64
                            base64.b64decode(data[:100])  # Test first 100 chars
                            return True
                        except:
                            return False
                    
                    def is_file_path(data):
                        """Check if data appears to be a file path"""
                        if len(data) > 500:  # File paths are typically short
                            return False
                        
                        # Check for path characteristics
                        path_indicators = [
                            data.startswith('/'),
                            data.startswith('./'),
                            data.startswith('../'),
                            data.startswith('~'),
                            (len(data) > 2 and data[1] == ':'),  # Windows paths
                            '.' in data and data.count('.') <= 3,  # Has extension
                        ]
                        
                        return any(path_indicators) and not is_base64_data(data)
                    
                    if is_file_path(image_data):
                        # This looks like a file path
                        logger.log_structured("image_processing", {
                            "request_id": request_id,
                            "type": "file_path",
                            "path_length": len(image_data)
                        })
                        processed_image = image_processor.process_image_content({
                            'image_path': image_data
                        })
                    else:
                        # This is base64 data
                        logger.log_structured("image_processing", {
                            "request_id": request_id,
                            "type": "base64",
                            "data_length": len(image_data)
                        })
                        processed_image = image_processor.process_image_content({
                            'image_base64': image_data
                        })
                    
                    # Update content with processed image data
                    content.image_base64 = processed_image.base64_data
                    
                    # 使用结构化日志记录图像处理详情
                    logger.log_structured("image_processed", {
                        "request_id": request_id,
                        "media_type": processed_image.media_type,
                        "size_bytes": processed_image.size_bytes,
                        "width": processed_image.width,
                        "height": processed_image.height
                    })
                    
                except Exception as e:
                    raise ValueError(f"Image processing failed: {str(e)}")
            
            processed_content.append(content)
        
        message.content = processed_content
        processed_messages.append(message)
    
    parsed_request.messages = processed_messages
    return parsed_request


def _handle_non_streaming_request(bedrock_request, meta, start_time, request_id: str) -> Dict[str, Any]:
    """
    Handle non-streaming request processing
    
    完整的非流式请求处理管道：
    1. 调用Bedrock API获取响应
    2. 格式化响应为目标API格式
    3. 计算性能指标
    4. 返回JSON响应
    5. 处理各种错误情况并返回适当的HTTP状态码
    
    Args:
        bedrock_request: 格式化后的Bedrock请求
        meta: 请求元数据
        start_time: 请求开始时间（用于性能计算）
        
    Returns:
        HTTP响应字典，包含状态码、头部和响应体
    """
    try:
        logger.log_structured("non_streaming_request_start", {
            "request_id": request_id,
            "model": getattr(bedrock_request, 'model', 'unknown')
        })
        
        # 调用Bedrock API
        bedrock_start = time.time()
        bedrock_response = bedrock_client.invoke_model(bedrock_request)
        bedrock_duration = (time.time() - bedrock_start) * 1000
        
        # 提取响应内容用于统计
        response_content = response_formatter.extract_content_from_bedrock_response(bedrock_response)
        response_tokens = len(response_content.split()) if response_content else 0
        
        # 记录Bedrock调用信息
        logger.log_bedrock_call(
            model_name=Config.BEDROCK_MODEL_ID,
            response_tokens=response_tokens,
            duration_ms=bedrock_duration,
            request_id=request_id,
            is_streaming=False
        )
        
        logger.log_performance_phase(
            phase="bedrock_call",
            duration_ms=bedrock_duration,
            request_id=request_id,
            additional_info={
                "response_length": len(response_content),
                "estimated_tokens": response_tokens
            }
        )
        
        # 格式化响应
        formatting_start = time.time()
        formatted_response = response_formatter.format_non_streaming_response(
            bedrock_response=bedrock_response,
            meta=meta,
            start_time=start_time
        )
        formatting_duration = (time.time() - formatting_start) * 1000
        
        logger.log_performance_phase(
            phase="response_formatting",
            duration_ms=formatting_duration,
            request_id=request_id
        )
        
        # 计算总处理时间
        total_time = time.time() - start_time
        
        # 准备响应
        response_body = json.dumps(formatted_response, ensure_ascii=False)
        response_size = len(response_body.encode('utf-8'))
        
        # 记录响应信息
        logger.log_response(
            status_code=200,
            response_size=response_size,
            request_id=request_id,
            is_streaming=False
        )
        
        logger.log_structured("non_streaming_request_completed", {
            "request_id": request_id,
            "total_duration_ms": round(total_time * 1000, 2),
            "response_size_bytes": response_size,
            "response_tokens": response_tokens
        })
        
        # 返回成功响应
        return {
            'statusCode': 200,
            'headers': {
                'Content-Type': 'application/json',
                'Access-Control-Allow-Origin': '*',
                'Access-Control-Allow-Methods': 'POST, OPTIONS',
                'Access-Control-Allow-Headers': 'Content-Type, Authorization',
                'Cache-Control': 'no-cache'
            },
            'body': response_body
        }
        
    except Exception as e:
        logger.log_error(
            error=e,
            context={"model": getattr(bedrock_request, 'model', 'unknown')},
            request_id=request_id,
            error_phase="non_streaming_processing"
        )
        
        # 详细的错误分类和处理
        return _handle_non_streaming_error(e, start_time, request_id)


def _handle_non_streaming_error(error: Exception, start_time: float, request_id: str) -> Dict[str, Any]:
    """
    处理非流式请求的错误情况
    
    根据错误类型返回适当的HTTP状态码和错误信息：
    - Bedrock服务错误: 502 Bad Gateway
    - 超时错误: 504 Gateway Timeout  
    - 速率限制: 429 Too Many Requests
    - 访问拒绝: 403 Forbidden
    - 其他错误: 500 Internal Server Error
    
    Args:
        error: 发生的异常
        start_time: 请求开始时间
        
    Returns:
        HTTP错误响应字典
    """
    error_str = str(error).lower()
    total_time = time.time() - start_time
    
    # 根据错误内容确定错误类型和状态码
    if any(keyword in error_str for keyword in ['bedrock', 'invoke_model', 'anthropic']):
        status_code = 502
        error_type = 'bedrock_error'
        error_message = 'Bedrock服务暂时不可用，请稍后重试'
        
    elif any(keyword in error_str for keyword in ['timeout', 'timed out', 'deadline']):
        status_code = 504
        error_type = 'timeout_error'
        error_message = '请求超时，请稍后重试'
        
    elif any(keyword in error_str for keyword in ['throttling', 'rate limit', 'too many requests']):
        status_code = 429
        error_type = 'rate_limit_error'
        error_message = '请求频率过高，请稍后重试'
        
    elif any(keyword in error_str for keyword in ['access denied', 'unauthorized', 'forbidden']):
        status_code = 403
        error_type = 'access_denied_error'
        error_message = '访问被拒绝，请检查权限配置'
        
    elif any(keyword in error_str for keyword in ['validation', 'invalid', 'bad request']):
        status_code = 400
        error_type = 'validation_error'
        error_message = f'请求验证失败: {str(error)}'
        
    else:
        status_code = 500
        error_type = 'internal_error'
        error_message = '内部服务器错误，请稍后重试'
    
    # 记录错误详情
    logger.log_structured("non_streaming_error", {
        "request_id": request_id,
        "error_type": error_type,
        "status_code": status_code,
        "processing_time_ms": round(total_time * 1000, 2),
        "error_message": str(error)
    }, level="error")
    
    # 构建错误响应
    error_response = {
        'error': {
            'type': error_type,
            'message': error_message,
            'code': status_code,
            'timestamp': int(time.time()),
            'processing_time_ms': round(total_time * 1000, 2),
            'request_id': request_id
        }
    }
    
    response_body = json.dumps(error_response, ensure_ascii=False)
    response_size = len(response_body.encode('utf-8'))
    
    # 记录错误响应
    logger.log_response(
        status_code=status_code,
        response_size=response_size,
        request_id=request_id,
        is_streaming=False
    )
    
    return {
        'statusCode': status_code,
        'headers': {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Methods': 'POST, OPTIONS',
            'Access-Control-Allow-Headers': 'Content-Type, Authorization',
            'Cache-Control': 'no-cache'
        },
        'body': response_body
    }


def _handle_streaming_request(bedrock_request, meta, start_time, request_id: str) -> Dict[str, Any]:
    """
    Handle streaming request processing
    
    完整的流式请求处理管道：
    1. 调用Bedrock API获取流式响应
    2. 集成SSE流式响应生成
    3. 处理流式响应的错误情况和中断
    4. 返回Server-Sent Events格式的流式响应
    
    Args:
        bedrock_request: 格式化后的Bedrock请求
        meta: 请求元数据
        start_time: 请求开始时间（用于性能计算）
        
    Returns:
        HTTP流式响应字典，包含状态码、头部和流式响应生成器
    """
    try:
        logger.log_structured("streaming_request_start", {
            "request_id": request_id,
            "model": getattr(bedrock_request, 'model', 'unknown')
        })
        
        # 记录流式请求详情
        logger.log_structured("streaming_generator_setup", {
            "request_id": request_id
        })
        
        # 创建流式响应生成器
        def stream_generator():
            """
            流式响应生成器
            
            生成Server-Sent Events格式的流式响应：
            1. 发送初始流开始标记
            2. 处理Bedrock流式响应块
            3. 格式化为SSE格式
            4. 处理错误和中断情况
            5. 发送流结束标记
            """
            chunk_count = 0
            total_content_length = 0
            
            try:
                logger.log_structured("streaming_generation_start", {
                    "request_id": request_id
                })
                
                # 发送流开始标记
                start_chunk = stream_handler.create_stream_start_chunk(
                    model=Config.BEDROCK_MODEL_ID,
                    meta=meta
                )
                yield start_chunk
                
                logger.log_structured("stream_start_sent", {
                    "request_id": request_id
                })
                
                # 获取Bedrock流式响应
                bedrock_stream_start = time.time()
                bedrock_stream = bedrock_client.invoke_model_stream(bedrock_request)
                
                logger.log_structured("bedrock_stream_started", {
                    "request_id": request_id,
                    "setup_duration_ms": round((time.time() - bedrock_stream_start) * 1000, 2)
                })
                
                # 创建格式化的流生成器
                formatted_stream = stream_handler.create_streaming_response_generator(
                    bedrock_stream=bedrock_stream,
                    response_formatter=response_formatter,
                    meta=meta,
                    model=Config.BEDROCK_MODEL_ID,
                    start_time=start_time
                )
                
                # 处理每个流式响应块
                for formatted_chunk in formatted_stream:
                    chunk_count += 1
                    
                    # 统计内容长度
                    if 'choices' in formatted_chunk and formatted_chunk['choices']:
                        content = formatted_chunk['choices'][0].get('delta', {}).get('content', '')
                        total_content_length += len(content)
                    
                    # 转换为SSE格式并发送
                    sse_chunk = stream_handler.format_sse_chunk(formatted_chunk)
                    yield sse_chunk
                    
                    # 定期记录进度
                    if chunk_count % 20 == 0:  # 减少日志频率
                        logger.log_structured("streaming_progress", {
                            "request_id": request_id,
                            "chunks_processed": chunk_count,
                            "content_length": total_content_length,
                            "elapsed_ms": round((time.time() - start_time) * 1000, 2)
                        })
                
                # 发送流结束标记
                yield stream_handler.create_stream_end_chunk()
                
                # 记录流式处理完成
                total_time = time.time() - start_time
                estimated_tokens = total_content_length // 4  # 粗略估算令牌数
                
                # 记录Bedrock流式调用信息
                logger.log_bedrock_call(
                    model_name=Config.BEDROCK_MODEL_ID,
                    response_tokens=estimated_tokens,
                    duration_ms=total_time * 1000,
                    request_id=request_id,
                    is_streaming=True
                )
                
                logger.log_structured("streaming_completed", {
                    "request_id": request_id,
                    "chunk_count": chunk_count,
                    "content_length": total_content_length,
                    "estimated_tokens": estimated_tokens,
                    "total_duration_ms": round(total_time * 1000, 2)
                })
                
                # 记录响应信息
                logger.log_response(
                    status_code=200,
                    response_size=total_content_length,
                    request_id=request_id,
                    is_streaming=True,
                    chunk_count=chunk_count
                )
                
            except Exception as e:
                logger.log_error(
                    error=e,
                    context={
                        "chunks_processed": chunk_count,
                        "content_length": total_content_length
                    },
                    request_id=request_id,
                    error_phase="streaming_generation"
                )
                
                # 通过流发送错误信息
                try:
                    for error_chunk in stream_handler.handle_stream_error(
                        error=e, 
                        model=Config.BEDROCK_MODEL_ID, 
                        meta=meta
                    ):
                        yield error_chunk
                        
                    # 记录错误处理完成
                    total_time = time.time() - start_time
                    logger.log_structured("streaming_error_handled", {
                        "request_id": request_id,
                        "chunks_processed": chunk_count,
                        "total_duration_ms": round(total_time * 1000, 2),
                        "error_type": type(e).__name__
                    }, level="error")
                        
                except Exception as error_handling_error:
                    logger.log_error(
                        error=error_handling_error,
                        context={"original_error": str(e)},
                        request_id=request_id,
                        error_phase="streaming_error_handling"
                    )
                    # 发送最基本的错误响应
                    yield stream_handler.create_error_sse_chunk(
                        error_message="流式响应处理失败",
                        error_code=500
                    )
                    yield stream_handler.create_stream_end_chunk()
        
        # 返回流式响应
        logger.log_structured("streaming_response_configured", {
            "request_id": request_id
        })
        
        return {
            'statusCode': 200,
            'headers': {
                'Content-Type': 'text/event-stream',
                'Cache-Control': 'no-cache',
                'Connection': 'keep-alive',
                'Access-Control-Allow-Origin': '*',
                'Access-Control-Allow-Methods': 'POST, OPTIONS',
                'Access-Control-Allow-Headers': 'Content-Type, Authorization',
                'X-Accel-Buffering': 'no'  # 禁用nginx缓冲以支持真正的流式传输
            },
            'body': _generate_pseudo_streaming_response(bedrock_request, meta, start_time, request_id),
            'isBase64Encoded': False
        }
        
    except Exception as e:
        logger.log_error(
            error=e,
            context={"model": getattr(bedrock_request, 'model', 'unknown')},
            request_id=request_id,
            error_phase="streaming_setup"
        )
        
        # 如果流式设置失败，返回标准错误响应
        return _handle_streaming_setup_error(e, start_time, request_id)


def _handle_streaming_setup_error(error: Exception, start_time: float, request_id: str) -> Dict[str, Any]:
    """
    处理流式请求设置阶段的错误
    
    当流式响应设置失败时，返回标准的JSON错误响应而不是流式响应
    
    Args:
        error: 发生的异常
        start_time: 请求开始时间
        
    Returns:
        HTTP错误响应字典
    """
    error_str = str(error).lower()
    total_time = time.time() - start_time
    
    # 根据错误内容确定错误类型和状态码
    if any(keyword in error_str for keyword in ['bedrock', 'invoke_model_stream', 'anthropic']):
        status_code = 502
        error_type = 'bedrock_streaming_error'
        error_message = 'Bedrock流式服务暂时不可用，请稍后重试'
        
    elif any(keyword in error_str for keyword in ['timeout', 'timed out', 'deadline']):
        status_code = 504
        error_type = 'streaming_timeout_error'
        error_message = '流式请求超时，请稍后重试'
        
    elif any(keyword in error_str for keyword in ['throttling', 'rate limit', 'too many requests']):
        status_code = 429
        error_type = 'streaming_rate_limit_error'
        error_message = '流式请求频率过高，请稍后重试'
        
    elif any(keyword in error_str for keyword in ['access denied', 'unauthorized', 'forbidden']):
        status_code = 403
        error_type = 'streaming_access_denied_error'
        error_message = '流式服务访问被拒绝，请检查权限配置'
        
    else:
        status_code = 500
        error_type = 'streaming_internal_error'
        error_message = '流式服务内部错误，请稍后重试'
    
    # 记录错误详情
    logger.log_structured("streaming_setup_error", {
        "request_id": request_id,
        "error_type": error_type,
        "status_code": status_code,
        "processing_time_ms": round(total_time * 1000, 2),
        "error_message": str(error)
    }, level="error")
    
    # 构建错误响应
    error_response = {
        'error': {
            'type': error_type,
            'message': error_message,
            'code': status_code,
            'timestamp': int(time.time()),
            'processing_time_ms': round(total_time * 1000, 2),
            'stream_support': False,
            'request_id': request_id
        }
    }
    
    response_body = json.dumps(error_response, ensure_ascii=False)
    response_size = len(response_body.encode('utf-8'))
    
    # 记录错误响应
    logger.log_response(
        status_code=status_code,
        response_size=response_size,
        request_id=request_id,
        is_streaming=False
    )
    
    return {
        'statusCode': status_code,
        'headers': {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Methods': 'POST, OPTIONS',
            'Access-Control-Allow-Headers': 'Content-Type, Authorization',
            'Cache-Control': 'no-cache'
        },
        'body': response_body
    }

def _generate_pseudo_streaming_response(bedrock_request, meta, start_time, request_id: str) -> str:
    """
    生成伪流式响应内容
    
    这个函数会：
    1. 调用Bedrock获取完整响应
    2. 将响应内容分解成多个块
    3. 格式化为SSE格式
    4. 模拟流式输出体验
    
    Args:
        bedrock_request: Bedrock请求对象
        meta: 请求元数据
        start_time: 请求开始时间
        request_id: 请求ID
        
    Returns:
        完整的SSE格式响应字符串
    """
    try:
        logger.log_structured("pseudo_streaming_generation_start", {
            "request_id": request_id,
            "note": "Generating pseudo-streaming response for ALB"
        })
        
        # 1. 获取Bedrock完整响应
        bedrock_response = bedrock_client.invoke_model(bedrock_request)
        
        # 2. 提取响应内容
        content = ""
        try:
            # Bedrock响应是一个特殊对象，需要正确访问
            response_body = bedrock_response.get('body')
            if response_body:
                response_data = json.loads(response_body.read())
                if 'content' in response_data:
                    for content_block in response_data['content']:
                        if content_block.get('type') == 'text':
                            content += content_block.get('text', '')
                elif 'completion' in response_data:
                    content = response_data['completion']
        except Exception as parse_error:
            logger.log_error(
                error=parse_error,
                context={"request_id": request_id},
                error_phase="bedrock_response_parsing"
            )
            content = "响应解析失败，使用默认内容进行测试。"
        
        if not content:
            content = "抱歉，无法生成响应内容。"
        
        logger.log_structured("pseudo_streaming_content_extracted", {
            "request_id": request_id,
            "content_length": len(content),
            "estimated_tokens": len(content) // 4
        })
        
        # 3. 构建SSE响应块列表
        sse_chunks = []
        
        # 添加流开始标记
        start_chunk = stream_handler.create_stream_start_chunk(
            model=Config.BEDROCK_MODEL_ID,
            meta=meta
        )
        sse_chunks.append(stream_handler.format_sse_chunk(start_chunk))
        
        # 4. 将内容分解成多个块（模拟流式输出）
        chunk_size = max(10, len(content) // 8)  # 分成大约8个块，每块至少10个字符
        content_chunks = [content[i:i+chunk_size] for i in range(0, len(content), chunk_size)]
        
        # 为每个内容块创建SSE数据
        for i, chunk_content in enumerate(content_chunks):
            chunk_data = {
                "id": f"chunk_{i}",
                "object": "understand_image",
                "created": int(time.time()),
                "model": Config.BEDROCK_MODEL_ID,
                "choices": [{
                    "index": 0,
                    "delta": {
                        "content": chunk_content
                    },
                    "finish_reason": "stream" if i < len(content_chunks) - 1 else "stop"
                }],
                "meta": meta
            }
            
            sse_chunks.append(stream_handler.format_sse_chunk(chunk_data))
        
        # 5. 添加流结束标记
        sse_chunks.append(stream_handler.create_stream_end_chunk())
        
        # 6. 合并所有SSE块
        response_body = ''.join(sse_chunks)
        
        # 记录伪流式响应完成
        total_time = time.time() - start_time
        logger.log_structured("pseudo_streaming_completed", {
            "request_id": request_id,
            "total_chunks": len(content_chunks),
            "total_content_length": len(content),
            "total_response_size": len(response_body),
            "processing_time_ms": round(total_time * 1000, 2)
        })
        
        return response_body
        
    except Exception as e:
        logger.log_error(
            error=e,
            context={"request_id": request_id},
            error_phase="pseudo_streaming_generation"
        )
        
        # 如果生成失败，返回错误的SSE响应
        error_chunks = [
            stream_handler.format_sse_chunk(stream_handler.create_stream_start_chunk(Config.BEDROCK_MODEL_ID, meta)),
            'data: {"error": {"message": "伪流式响应生成失败", "type": "pseudo_streaming_error", "code": 500}}\n\n',
            'data: [DONE]\n\n'
        ]
        return ''.join(error_chunks)