Add files via upload

Author: TyperBody

main.py

@@ -0,0 +1,386 @@
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import json
+import time
+from datetime import datetime
+from server import MessageServer
+import uuid
+import threading
+import secrets
+import string
+import os
+import logging
+from logging.handlers import RotatingFileHandler
+
+app = Flask(__name__)
+CORS(app)
+
+# 配置日志系统
+def setup_logging():
+    """设置应用日志配置"""
+    # 创建日志目录
+    if not os.path.exists('logs'):
+        os.makedirs('logs')
+    
+    # 配置日志格式
+    log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    
+    # 配置根日志记录器
+    logging.basicConfig(
+        level=logging.INFO,
+        format=log_format,
+        handlers=[
+            # 控制台输出
+            logging.StreamHandler(),
+            # 文件输出（带轮转）
+            RotatingFileHandler(
+                'logs/simhoshino_api.log',
+                maxBytes=10*1024*1024,  # 10MB
+                backupCount=5,
+                encoding='utf-8'
+            )
+        ]
+    )
+    
+    # 设置Flask应用的日志级别
+    app.logger.setLevel(logging.INFO)
+    
+    return logging.getLogger('SimHoshino')
+
+# 初始化日志系统
+logger = setup_logging()
+
+# 初始化消息服务器实例
+message_server = MessageServer()
+
+def generate_api_key():
+    """生成安全的API密钥"""
+    # 生成32位的随机字符串，包含字母和数字
+    alphabet = string.ascii_letters + string.digits
+    api_key = 'sk-' + ''.join(secrets.choice(alphabet) for _ in range(48))
+    return api_key
+
+def load_or_create_api_key():
+    """加载已保存的API密钥，如果不存在则生成新的并保存"""
+    key_file = "api_key.txt"
+    
+    # 检查密钥文件是否存在
+    if os.path.exists(key_file):
+        try:
+            with open(key_file, 'r', encoding='utf-8') as f:
+                api_key = f.read().strip()
+            
+            # 验证密钥格式是否正确
+            if api_key.startswith('sk-') and len(api_key) == 51:
+                print(f"🔑 使用已保存的API密钥")
+                return api_key
+            else:
+                print("⚠️  已保存的API密钥格式不正确，将生成新密钥")
+        except Exception as e:
+            print(f"⚠️  读取API密钥文件失败: {e}，将生成新密钥")
+    
+    # 生成新的API密钥
+    print("🆕 生成新的API密钥...")
+    api_key = generate_api_key()
+    
+    # 保存到文件
+    try:
+        with open(key_file, 'w', encoding='utf-8') as f:
+            f.write(api_key)
+        print(f"💾 API密钥已保存到 {key_file}")
+    except Exception as e:
+        print(f"⚠️  保存API密钥失败: {e}")
+    
+    return api_key
+
+class OpenAIAPIServer:
+    def __init__(self):
+        self.model_name = "SimHoshino-agent"
+        self.conversations = {}
+        
+    def format_openai_response(self, content, model="SimHoshino-agent"):
+        """格式化为OpenAI API响应格式"""
+        return {
+            "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": model,
+            "choices": [{
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": content
+                },
+                "finish_reason": "stop"
+            }],
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": len(content.split()),
+                "total_tokens": len(content.split())
+            }
+        }
+    
+    def format_stream_response(self, content, model="SimHoshino-agent"):
+        """格式化为流式响应"""
+        chat_id = f"chatcmpl-{uuid.uuid4().hex[:8]}"
+        timestamp = int(time.time())
+        
+        # 开始响应
+        yield f"data: {json.dumps({'id': chat_id, 'object': 'chat.completion.chunk', 'created': timestamp, 'model': model, 'choices': [{'index': 0, 'delta': {'role': 'assistant'}, 'finish_reason': None}]})}\n\n"
+        
+        # 内容响应
+        yield f"data: {json.dumps({'id': chat_id, 'object': 'chat.completion.chunk', 'created': timestamp, 'model': model, 'choices': [{'index': 0, 'delta': {'content': content}, 'finish_reason': None}]})}\n\n"
+        
+        # 结束响应
+        yield f"data: {json.dumps({'id': chat_id, 'object': 'chat.completion.chunk', 'created': timestamp, 'model': model, 'choices': [{'index': 0, 'delta': {}, 'finish_reason': 'stop'}]})}\n\n"
+        yield "data: [DONE]\n\n"
+
+# 创建API服务器实例
+api_server = OpenAIAPIServer()
+
+@app.route('/v1/chat/completions', methods=['POST'])
+def chat_completions():
+    """OpenAI兼容的聊天完成API"""
+    request_id = uuid.uuid4().hex[:8]
+    client_ip = request.remote_addr
+    
+    # 记录请求开始
+    logger.info(f"[{request_id}] 新的聊天请求 - 客户端IP: {client_ip}")
+    
+    try:
+        data = request.get_json()
+        logger.debug(f"[{request_id}] 请求数据: {json.dumps(data, ensure_ascii=False)}")
+        
+        # 验证必需字段
+        if not data or 'messages' not in data:
+            error_msg = "Missing required field: messages"
+            logger.warning(f"[{request_id}] 请求验证失败: {error_msg}")
+            return jsonify({"error": {"message": error_msg, "type": "invalid_request_error"}}), 400
+        
+        messages = data['messages']
+        model = data.get('model', 'SimHoshino-agent')
+        stream = data.get('stream', False)
+        
+        logger.info(f"[{request_id}] 请求参数 - 模型: {model}, 流式: {stream}, 消息数量: {len(messages)}")
+        
+        # 获取最后一条用户消息
+        user_message = None
+        for msg in reversed(messages):
+            if msg.get('role') == 'user':
+                user_message = msg.get('content', '')
+                break
+        
+        if not user_message:
+            error_msg = "No user message found"
+            logger.warning(f"[{request_id}] 未找到用户消息")
+            return jsonify({"error": {"message": error_msg, "type": "invalid_request_error"}}), 400
+        
+        logger.info(f"[{request_id}] 收到用户消息: {user_message}")
+        print(f"📨 收到用户消息: {user_message}")
+        
+        # 发送消息到智能体
+        logger.info(f"[{request_id}] 开始发送消息到智能体")
+        success = message_server.send_message_to_chat(user_message)
+        if not success:
+            error_msg = "Failed to send message to agent"
+            logger.error(f"[{request_id}] 消息发送失败: {error_msg}")
+            logger.debug(f"[{request_id}] 发送失败详细信息 - 用户消息: {repr(user_message)}")
+            
+            # 详细调试信息已记录到日志
+            
+            # 尝试获取更多调试信息
+            try:
+                if hasattr(message_server, 'get_connection_status'):
+                    status = message_server.get_connection_status()
+                    logger.debug(f"[{request_id}] 连接状态: {status}")
+                    print(f"   - 连接状态: {status}")
+                    
+                if hasattr(message_server, 'last_error'):
+                    logger.debug(f"[{request_id}] 最后错误: {message_server.last_error}")
+                    print(f"   - 最后错误: {message_server.last_error}")
+                    
+            except Exception as debug_e:
+                logger.debug(f"[{request_id}] 获取调试信息时出错: {debug_e}")
+                
+            return jsonify({"error": {"message": error_msg, "type": "internal_server_error"}}), 500
+        
+        logger.info(f"[{request_id}] 消息发送成功，等待智能体回复...")
+        
+        # 等待一段时间让智能体处理
+        time.sleep(3)
+        
+        # 获取智能体回复
+        logger.info(f"[{request_id}] 开始获取智能体回复")
+        previous_msg, at_msg = message_server.extract_at_messages()
+        if at_msg and previous_msg:
+            agent_name = previous_msg.strip()
+            logger.info(f"[{request_id}] 检测到智能体: {agent_name}")
+            print(f"🔍 检测到智能体: {agent_name}")
+            
+            agent_response = message_server.get_agent_previous_message(agent_name)
+            if agent_response:
+                logger.info(f"[{request_id}] 获取到智能体回复 - 长度: {len(agent_response)}字符")
+                logger.debug(f"[{request_id}] 智能体回复内容: {agent_response}")
+                
+                if stream:
+                    logger.info(f"[{request_id}] 返回流式响应")
+                    return app.response_class(
+                        api_server.format_stream_response(agent_response, model),
+                        mimetype='text/plain'
+                    )
+                else:
+                    logger.info(f"[{request_id}] 返回标准响应")
+                    return jsonify(api_server.format_openai_response(agent_response, model))
+            else:
+                error_msg = f"智能体 {agent_name} 暂未回复，请稍后重试"
+                logger.warning(f"[{request_id}] 智能体未回复: {error_msg}")
+                logger.debug(f"[{request_id}] 智能体详细信息 - 名称: {agent_name}, previous_msg: {repr(previous_msg)}, at_msg: {repr(at_msg)}")
+                # 详细调试信息已记录到日志
+        else:
+            error_msg = "未检测到智能体回复"
+            logger.warning(f"[{request_id}] 未检测到智能体回复")
+            logger.debug(f"[{request_id}] extract_at_messages返回值 - previous_msg: {repr(previous_msg)}, at_msg: {repr(at_msg)}")
+            # 详细调试信息已记录到日志
+            
+            # 尝试获取更多调试信息
+            try:
+                # 检查消息服务器的状态
+                print(f"   - 消息服务器实例: {message_server}")
+                print(f"   - 消息服务器类型: {type(message_server)}")
+                
+                # 如果有其他调试方法，也可以调用
+                if hasattr(message_server, 'get_last_messages'):
+                    last_messages = message_server.get_last_messages()
+                    logger.debug(f"[{request_id}] 最近消息: {last_messages}")
+                    print(f"   - 最近消息: {last_messages}")
+                
+                if hasattr(message_server, 'get_debug_info'):
+                    debug_info = message_server.get_debug_info()
+                    logger.debug(f"[{request_id}] 调试信息: {debug_info}")
+                    
+            except Exception as debug_e:
+                logger.debug(f"[{request_id}] 获取调试信息时出错: {debug_e}")
+        
+        logger.error(f"[{request_id}] 最终错误: {error_msg}")
+        
+        if stream:
+            logger.info(f"[{request_id}] 返回错误流式响应")
+            return app.response_class(
+                api_server.format_stream_response(error_msg, model),
+                mimetype='text/plain'
+            )
+        else:
+            logger.info(f"[{request_id}] 返回错误标准响应")
+            return jsonify(api_server.format_openai_response(error_msg, model))
+        
+    except Exception as e:
+        import traceback
+        error_trace = traceback.format_exc()
+        
+        logger.error(f"[{request_id}] API异常: {str(e)}")
+        logger.error(f"[{request_id}] 异常堆栈:\n{error_trace}")
+        logger.debug(f"[{request_id}] 请求数据: {repr(request.get_json())}")
+        
+        # 详细异常信息已记录到日志
+        
+        # 导入traceback来获取完整的错误堆栈
+        print("📋 完整错误堆栈:")
+        traceback.print_exc()
+        
+        error_response = {
+            "error": {
+                "message": f"Internal server error: {str(e)}",
+                "type": "internal_server_error"
+            }
+        }
+        logger.info(f"[{request_id}] 返回异常响应")
+        return jsonify(error_response), 500
+
+@app.route('/v1/models', methods=['GET'])
+def list_models():
+    """列出可用模型"""
+    client_ip = request.remote_addr
+    logger.info(f"模型列表请求 - 客户端IP: {client_ip}")
+    
+    response = {
+        "object": "list",
+        "data": [{
+            "id": "SimHoshino-agent",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "SimHoshino"
+        }]
+    }
+    
+    logger.debug(f"返回模型列表: {response}")
+    return jsonify(response)
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    """健康检查"""
+    client_ip = request.remote_addr
+    logger.info(f"健康检查请求 - 客户端IP: {client_ip}")
+    
+    response = {
+        "status": "ok",
+        "timestamp": datetime.now().isoformat(),
+        "server": "SimHoshino OpenAI API Server"
+    }
+    
+    logger.debug(f"健康检查响应: {response}")
+    return jsonify(response)
+
+@app.route('/', methods=['GET'])
+def index():
+    """根路径信息"""
+    client_ip = request.remote_addr
+    logger.info(f"根路径访问 - 客户端IP: {client_ip}")
+    
+    response = {
+        "message": "SimHoshino OpenAI API Server",
+        "version": "1.0.0",
+        "endpoints": {
+            "chat_completions": "/v1/chat/completions",
+            "models": "/v1/models",
+            "health": "/health"
+        },
+        "documentation": "Compatible with OpenAI API format"
+    }
+    
+    logger.debug(f"根路径响应: {response}")
+    return jsonify(response)
+
+if __name__ == '__main__':
+    # 只在主进程中显示启动信息，避免调试模式重载时重复显示
+    if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
+        # ASCII艺术字
+        print(r"""
+ $$$$$$\  $$\               $$\   $$\                     $$\       $$\                     
+$$  __$$\ \__|              $$ |  $$ |                    $$ |      \__|                    
+$$ /  \__|$$\ $$$$$$\$$$$\  $$ |  $$ | $$$$$$\   $$$$$$$\ $$$$$$$\  $$\ $$$$$$$\   $$$$$$\  
+\$$$$$$\  $$ |$$  _$$  _$$\ $$$$$$$$ |$$  __$$\ $$  _____|$$  __$$\ $$ |$$  __$$\ $$  __$$\ 
+ \____$$\ $$ |$$ / $$ / $$ |$$  __$$ |$$ /  $$ |\$$$$$$\  $$ |  $$ |$$ |$$ |  $$ |$$ /  $$ |
+$$\   $$ |$$ |$$ | $$ | $$ |$$ |  $$ |$$ |  $$ | \____$$\ $$ |  $$ |$$ |$$ |  $$ |$$ |  $$ |
+\$$$$$$  |$$ |$$ | $$ | $$ |$$ |  $$ |\$$$$$$  |$$$$$$$  |$$ |  $$ |$$ |$$ |  $$ |\$$$$$$  |
+ \______/ \__|\__| \__| \__|\__|  \__| \______/ \_______/ \__|  \__|\__|\__|  \__| \______/ 
+                                                                                            
+        """)
+        
+        # 加载或生成API密钥
+        logger.info("应用程序启动开始")
+        api_key = load_or_create_api_key()
+        logger.info(f"API密钥已准备就绪: {api_key[:12]}...")
+        
+        logger.info("SimHoshino OpenAI API服务器启动中...")
+        print("🚀 启动SimHoshino OpenAI API服务器...")
+        print("📡 服务器地址: http://localhost:5000")
+        print("🔗 API端点: http://localhost:5000/v1/chat/completions")
+        print("📋 模型列表: http://localhost:5000/v1/models")
+        print("❤️  健康检查: http://localhost:5000/health")
+        print("="*60)
+        print(f"🔑 API密钥: {api_key}")
+        print("="*60)
+        
+        logger.info("服务器即将在端口5000上启动")
+    
+    app.run(host='0.0.0.0', port=5000, debug=True)