jarvis-ai-assistant 0.1.134__py3-none-any.whl → 0.1.138__py3-none-any.whl

jarvis/jarvis_platform_manager/main.py

@@ -15,22 +15,22 @@ def list_platforms():
     """List all supported platforms and models"""
     registry = PlatformRegistry.get_global_platform_registry()
     platforms = registry.get_available_platforms()
-    
+
     PrettyOutput.section("Supported platforms and models", OutputType.SUCCESS)
-    
+
     for platform_name in platforms:
         # Create platform instance
         platform = registry.create_platform(platform_name)
         if not platform:
             continue
-            
+
         # Get the list of models supported by the platform
         try:
             models = platform.get_model_list()
-            
+
             # Print platform name
             PrettyOutput.section(f"{platform_name}", OutputType.SUCCESS)
-            
+
             output = ""
             # Print model list
             if models:
@@ -42,65 +42,65 @@ def list_platforms():
                 PrettyOutput.print(output, OutputType.SUCCESS, lang="markdown")
             else:
                 PrettyOutput.print("  • 没有可用的模型信息", OutputType.WARNING)
-                
+
         except Exception as e:
             PrettyOutput.print(f"获取 {platform_name} 的模型列表失败: {str(e)}", OutputType.WARNING)
 
 def chat_with_model(platform_name: str, model_name: str):
     """Chat with specified platform and model"""
     registry = PlatformRegistry.get_global_platform_registry()
-    
+
     # Create platform instance
     platform = registry.create_platform(platform_name)
     if not platform:
         PrettyOutput.print(f"创建平台 {platform_name} 失败", OutputType.WARNING)
         return
-    
+
     try:
         # Set model
         platform.set_model_name(model_name)
         platform.set_suppress_output(False)
         PrettyOutput.print(f"连接到 {platform_name} 平台 {model_name} 模型", OutputType.SUCCESS)
-        
+
         # Start conversation loop
         while True:
             # Get user input
             user_input = get_multiline_input("")
-            
+
             # Check if input is cancelled
             if user_input.strip() == "/bye":
                 PrettyOutput.print("再见!", OutputType.SUCCESS)
                 break
-                
+
             # Check if input is empty
             if not user_input.strip():
                 continue
-                
+
             # Check if it is a clear session command
             if user_input.strip() == "/clear":
                 try:
-                    platform.delete_chat()
+                    platform.reset()
                     platform.set_model_name(model_name)  # Reinitialize session
                     PrettyOutput.print("会话已清除", OutputType.SUCCESS)
                 except Exception as e:
                     PrettyOutput.print(f"清除会话失败: {str(e)}", OutputType.ERROR)
                 continue
-                
+
             try:
                 # Send to model and get reply
                 response = platform.chat_until_success(user_input)
                 if not response:
                     PrettyOutput.print("没有有效的回复", OutputType.WARNING)
-                    
+
             except Exception as e:
                 PrettyOutput.print(f"聊天失败: {str(e)}", OutputType.ERROR)
-                
+
     except Exception as e:
         PrettyOutput.print(f"初始化会话失败: {str(e)}", OutputType.ERROR)
     finally:
         # Clean up resources
         try:
-            platform.delete_chat()
+            platform.reset()
         except:
             pass
 
@@ -160,18 +160,18 @@ def service_command(args):
     import json
     import os
     from datetime import datetime
-    
+
     host = args.host
     port = args.port
     default_platform = args.platform
     default_model = args.model
-    
+
     # Create logs directory if it doesn't exist
     logs_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "logs")
     os.makedirs(logs_dir, exist_ok=True)
-    
+
     app = FastAPI(title="Jarvis API Server")
-    
+
     # 添加 CORS 中间件
     app.add_middleware(
         CORSMiddleware,
@@ -180,27 +180,27 @@ def service_command(args):
         allow_methods=["*"],  # 允许所有方法
         allow_headers=["*"],  # 允许所有头
     )
-    
+
     registry = PlatformRegistry.get_global_platform_registry()
-    
+
     PrettyOutput.print(f"Starting Jarvis API server on {host}:{port}", OutputType.SUCCESS)
     PrettyOutput.print("This server provides an OpenAI-compatible API", OutputType.INFO)
-    
+
     if default_platform and default_model:
         PrettyOutput.print(f"Default platform: {default_platform}, model: {default_model}", OutputType.INFO)
-    
+
     PrettyOutput.print("Available platforms:", OutputType.INFO)
-    
+
     # Print available platforms and models
     platforms = registry.get_available_platforms()
     list_platforms()
-    
+
     # Platform and model cache
     platform_instances = {}
-    
+
     # Chat history storage
     chat_histories = {}
-    
+
     def get_platform_instance(platform_name: str, model_name: str):
         """Get or create a platform instance"""
         key = f"{platform_name}:{model_name}"
@@ -208,12 +208,12 @@ def service_command(args):
             platform = registry.create_platform(platform_name)
             if not platform:
                 raise HTTPException(status_code=400, detail=f"Platform {platform_name} not found")
-            
+
             platform.set_model_name(model_name)
             platform_instances[key] = platform
-        
+
         return platform_instances[key]
-    
+
     def log_conversation(conversation_id, messages, model, response=None):
         """Log conversation to file in plain text format."""
         timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
@@ -228,14 +228,14 @@ def service_command(args):
                 f.write(f"{message['role']}: {message['content']}\n")
             if response:
                 f.write(f"\nResponse:\n{response}\n")
-        
+
         PrettyOutput.print(f"Conversation logged to {log_file}", OutputType.INFO)
-    
+
     @app.get("/v1/models")
     async def list_models():
         """List available models for the specified platform in OpenAI-compatible format"""
         model_list = []
-        
+
         # Only get models for the currently set platform
         if default_platform:
             try:
@@ -253,10 +253,10 @@ def service_command(args):
                             })
             except Exception as e:
                 print(f"Error getting models for {default_platform}: {str(e)}")
-        
+
         # Return model list
         return {"object": "list", "data": model_list}
-    
+
     @app.post("/v1/chat/completions")
     @app.options("/v1/chat/completions")  # 添加 OPTIONS 方法支持
     async def create_chat_completion(request: ChatCompletionRequest):
@@ -264,10 +264,10 @@ def service_command(args):
         model = request.model
         messages = request.messages
         stream = request.stream
-        
+
         # Generate a conversation ID if this is a new conversation
         conversation_id = str(uuid.uuid4())
-        
+
         # Extract platform and model name
         if "/" in model:
             platform_name, model_name = model.split("/", 1)
@@ -277,34 +277,34 @@ def service_command(args):
                 platform_name, model_name = default_platform, default_model
             else:
                 platform_name, model_name = "oyi", model  # Default to OYI platform
-        
+
         # Get platform instance
         platform = get_platform_instance(platform_name, model_name)
-        
+
         # Convert messages to text format for the platform
         message_text = ""
         for msg in messages:
             role = msg.role
             content = msg.content
-            
+
             if role == "system":
                 message_text += f"System: {content}\n\n"
             elif role == "user":
                 message_text += f"User: {content}\n\n"
             elif role == "assistant":
                 message_text += f"Assistant: {content}\n\n"
-        
+
         # Store messages in chat history
         chat_histories[conversation_id] = {
             "model": model,
             "messages": [{"role": m.role, "content": m.content} for m in messages]
         }
-        
+
         # Log the conversation
-        log_conversation(conversation_id, 
-                         [{"role": m.role, "content": m.content} for m in messages], 
+        log_conversation(conversation_id,
+                         [{"role": m.role, "content": m.content} for m in messages],
                          model)
-        
+
         if stream:
             # Return streaming response
             return StreamingResponse(
@@ -315,23 +315,23 @@ def service_command(args):
             # Get chat response
             try:
                 response_text = platform.chat_until_success(message_text)
-                
+
                 # Create response in OpenAI format
                 completion_id = f"chatcmpl-{str(uuid.uuid4())}"
-                
+
                 # Update chat history with response
                 if conversation_id in chat_histories:
                     chat_histories[conversation_id]["messages"].append({
                         "role": "assistant",
                         "content": response_text
                     })
-                
+
                 # Log the conversation with response
-                log_conversation(conversation_id, 
-                                 chat_histories[conversation_id]["messages"], 
+                log_conversation(conversation_id,
+                                 chat_histories[conversation_id]["messages"],
                                  model,
                                  response_text)
-                
+
                 return {
                     "id": completion_id,
                     "object": "chat.completion",
@@ -355,7 +355,7 @@ def service_command(args):
                 }
             except Exception as e:
                 raise HTTPException(status_code=500, detail=str(e))
-    
+
     async def stream_chat_response(platform, message, model_name):
         """Stream chat response in OpenAI-compatible format"""
         import time
@@ -363,15 +363,15 @@ def service_command(args):
         import uuid
         from datetime import datetime
         import os
-        
+
         completion_id = f"chatcmpl-{str(uuid.uuid4())}"
         created_time = int(time.time())
         conversation_id = str(uuid.uuid4())
-        
+
         # Create logs directory if it doesn't exist
         logs_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "logs")
         os.makedirs(logs_dir, exist_ok=True)
-        
+
         # 修改第一个yield语句的格式
         initial_data = {
             'id': completion_id,
@@ -386,14 +386,14 @@ def service_command(args):
         }
         res = json.dumps(initial_data)
         yield f"data: {res}\n\n"
-        
+
         try:
             # 直接获取聊天响应，而不是尝试捕获stdout
             response = platform.chat_until_success(message)
-            
+
             # 记录完整响应
             full_response = ""
-            
+
             # 如果有响应，将其分块发送
             if response:
                 # 分成小块以获得更好的流式体验
@@ -401,7 +401,7 @@ def service_command(args):
                 for i in range(0, len(response), chunk_size):
                     chunk = response[i:i+chunk_size]
                     full_response += chunk
-                    
+
                     # 创建并发送块
                     chunk_data = {
                         'id': completion_id,
@@ -414,9 +414,9 @@ def service_command(args):
                             'finish_reason': None
                         }]
                     }
-                    
+
                     yield f"data: {json.dumps(chunk_data)}\n\n"
-                    
+
                     # 小延迟以模拟流式传输
                     await asyncio.sleep(0.01)
             else:
@@ -434,7 +434,7 @@ def service_command(args):
                 }
                 yield f"data: {json.dumps(chunk_data)}\n\n"
                 full_response = "No response from model."
-            
+
             # 修改最终yield语句的格式
             final_data = {
                 'id': completion_id,
@@ -448,14 +448,14 @@ def service_command(args):
                 }]
             }
             yield f"data: {json.dumps(final_data)}\n\n"
-            
+
             # 发送[DONE]标记
             yield "data: [DONE]\n\n"
-            
+
             # 记录对话到文件
             timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
             log_file = os.path.join(logs_dir, f"stream_conversation_{conversation_id}_{timestamp}.json")
-            
+
             log_data = {
                 "conversation_id": conversation_id,
                 "timestamp": timestamp,
@@ -463,12 +463,12 @@ def service_command(args):
                 "message": message,
                 "response": full_response
             }
-            
+
             with open(log_file, "w", encoding="utf-8", errors="ignore") as f:
                 json.dump(log_data, f, ensure_ascii=False, indent=2)
-            
+
             PrettyOutput.print(f"Stream conversation logged to {log_file}", OutputType.INFO)
-            
+
         except Exception as e:
             # 发送错误消息
             error_msg = f"Error: {str(e)}"
@@ -488,11 +488,11 @@ def service_command(args):
             yield f"data: {res}\n\n"
             yield f"data: {json.dumps({'error': {'message': error_msg, 'type': 'server_error'}})}\n\n"
             yield "data: [DONE]\n\n"
-            
+
             # 记录错误到文件
             timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
             log_file = os.path.join(logs_dir, f"stream_error_{conversation_id}_{timestamp}.json")
-            
+
             log_data = {
                 "conversation_id": conversation_id,
                 "timestamp": timestamp,
@@ -500,12 +500,12 @@ def service_command(args):
                 "message": message,
                 "error": error_msg
             }
-            
+
             with open(log_file, "w", encoding="utf-8", errors="ignore") as f:
                 json.dump(log_data, f, ensure_ascii=False, indent=2)
-            
+
             PrettyOutput.print(f"Stream error logged to {log_file}", OutputType.ERROR)
-    
+
     # Run the server
     uvicorn.run(app, host=host, port=port)
 
@@ -514,27 +514,27 @@ def main():
     import argparse
 
     init_env()
-    
+
     parser = argparse.ArgumentParser(description='Jarvis AI 平台')
     subparsers = parser.add_subparsers(dest='command', help='可用子命令')
-    
+
     # info subcommand
     info_parser = subparsers.add_parser('info', help='显示支持的平台和模型信息')
-    
+
     # chat subcommand
     chat_parser = subparsers.add_parser('chat', help='与指定平台和模型聊天')
     chat_parser.add_argument('--platform', '-p', help='指定要使用的平台')
     chat_parser.add_argument('--model', '-m', help='指定要使用的模型')
-    
+
     # service subcommand
     service_parser = subparsers.add_parser('service', help='启动OpenAI兼容的API服务')
     service_parser.add_argument('--host', default='127.0.0.1', help='服务主机地址 (默认: 127.0.0.1)')
     service_parser.add_argument('--port', type=int, default=8000, help='服务端口 (默认: 8000)')
     service_parser.add_argument('--platform', '-p', help='指定默认平台，当客户端未指定平台时使用')
     service_parser.add_argument('--model', '-m', help='指定默认模型，当客户端未指定模型时使用')
-    
+
     args = parser.parse_args()
-    
+
     if args.command == 'info':
         info_command(args)
     elif args.command == 'chat':

jarvis/jarvis_platform_manager/openai_test.py

@@ -13,10 +13,10 @@ def test_chat(api_base, model, stream=False, interactive=False):
         api_key="dummy-key",  # Not actually used by our service
         base_url=f"{api_base}/v1"
     )
-    
+
     print(f"Testing chat with model: {model}, stream={stream}")
     print("=" * 50)
-    
+
     try:
         # First, list available models
         print("Available models:")
@@ -24,35 +24,35 @@ def test_chat(api_base, model, stream=False, interactive=False):
         for m in models.data:
             print(f"  - {m.id}")
         print()
-        
+
         if interactive:
             # Interactive chat mode
             messages = [
                 {"role": "system", "content": "You are a helpful assistant."}
             ]
-            
+
             print("Interactive chat mode. Type 'exit' to quit.")
             print("=" * 50)
-            
+
             while True:
                 # Get user input
                 user_input = input("You: ")
                 if user_input.lower() in ['exit', 'quit', 'bye']:
                     break
-                
+
                 # Add user message to history
                 messages.append({"role": "user", "content": user_input})
-                
+
                 # Get response
                 print("Assistant: ", end="", flush=True)
-                
+
                 if stream:
                     response = client.chat.completions.create(
                         model=model,
                         messages=messages, # type: ignore
                         stream=True
                     ) # type: ignore
-                    
+
                     # Process the streaming response
                     assistant_response = ""
                     for chunk in response:
@@ -68,14 +68,14 @@ def test_chat(api_base, model, stream=False, interactive=False):
                     )
                     assistant_response = response.choices[0].message.content
                     print(assistant_response)
-                
+
                 # Add assistant response to history
                 messages.append({"role": "assistant", "content": assistant_response}) # type: ignore
                 print()
-            
+
             print("=" * 50)
             print("Chat session ended.")
-            
+
         else:
             # Single request mode
             print("Sending chat request...")
@@ -83,17 +83,17 @@ def test_chat(api_base, model, stream=False, interactive=False):
                 {"role": "system", "content": "You are a helpful assistant."},
                 {"role": "user", "content": "Hello! Tell me a short joke."}
             ]
-            
+
             if stream:
                 print("Response (streaming):")
-                
+
                 # Use the OpenAI client for streaming
                 response = client.chat.completions.create(
                     model=model,
                     messages=messages, # type: ignore
                     stream=True
                 ) # type: ignore
-                
+
                 # Process the streaming response
                 full_content = ""
                 for chunk in response:
@@ -101,7 +101,7 @@ def test_chat(api_base, model, stream=False, interactive=False):
                         content = chunk.choices[0].delta.content
                         full_content += content
                         print(content, end="", flush=True)
-                
+
                 print("\n")
                 print(f"Full response: {full_content}")
             else:
@@ -111,16 +111,16 @@ def test_chat(api_base, model, stream=False, interactive=False):
                     messages=messages # type: ignore
                 )
                 print(response.choices[0].message.content)
-        
+
         print("=" * 50)
         print("Test completed successfully!")
-        
+
     except Exception as e:
         print(f"Error: {str(e)}")
         import traceback
         traceback.print_exc()
         return 1
-    
+
     return 0
 
 def main():
@@ -129,9 +129,9 @@ def main():
     parser.add_argument("--model", default="gpt-3.5-turbo", help="Model to test (default: gpt-3.5-turbo)")
     parser.add_argument("--stream", action="store_true", help="Test streaming mode")
     parser.add_argument("--interactive", "-i", action="store_true", help="Interactive chat mode")
-    
+
     args = parser.parse_args()
-    
+
     return test_chat(args.api_base, args.model, args.stream, args.interactive)
 
 if __name__ == "__main__":