jarvis-ai-assistant 0.1.206__py3-none-any.whl → 0.1.208__py3-none-any.whl

jarvis/jarvis_platform_manager/service.py

@@ -0,0 +1,432 @@
+# -*- coding: utf-8 -*-
+"""Jarvis Platform Manager Service Module.
+
+This module provides an OpenAI-compatible API service for the Jarvis platform.
+"""
+import asyncio
+import json
+import os
+import time
+import uuid
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union
+
+import uvicorn
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel, Field
+from starlette.responses import JSONResponse, Response
+
+from jarvis.jarvis_platform.registry import PlatformRegistry
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+
+
+class ChatMessage(BaseModel):
+    """Represents a chat message with role and content."""
+
+    role: str
+    content: str
+
+
+class ChatCompletionRequest(BaseModel):
+    """Request model for chat completion."""
+
+    model: str
+    messages: List[ChatMessage]
+    stream: bool = False
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+
+
+class ChatCompletionChoice(BaseModel):
+    """Represents a choice in chat completion response."""
+
+    index: int
+    message: ChatMessage
+    finish_reason: str = "stop"
+
+
+class ChatCompletionResponse(BaseModel):
+    """Response model for chat completion."""
+
+    id: str
+    object: str = "chat.completion"
+    created: int
+    model: str
+    choices: List[ChatCompletionChoice]
+    usage: Dict[str, int] = Field(
+        default_factory=lambda: {
+            "prompt_tokens": 0,
+            "completion_tokens": 0,
+            "total_tokens": 0,
+        }
+    )
+
+
+def start_service(
+    host: str,
+    port: int,
+    default_platform: Optional[str] = None,
+    default_model: Optional[str] = None,
+) -> None:
+    """Start OpenAI-compatible API server."""
+    # 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")
+
+    # Add CORS middleware
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        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)
+
+    # Platform and model cache
+    platform_instances: Dict[str, Any] = {}
+
+    # Chat history storage
+    chat_histories: Dict[str, Dict[str, Any]] = {}
+
+    def get_platform_instance(platform_name: str, model_name: str) -> Any:
+        """Get or create a platform instance."""
+        key = f"{platform_name}:{model_name}"
+        if key not in platform_instances:
+            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: str,
+        messages: List[Dict[str, str]],
+        model: str,
+        response: Optional[str] = None,
+    ) -> None:
+        """Log conversation to file in plain text format."""
+        timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+        log_file = os.path.join(
+            logs_dir, f"conversation_{conversation_id}_{timestamp}.txt"
+        )
+
+        with open(log_file, "w", encoding="utf-8", errors="ignore") as f:
+            f.write(f"Conversation ID: {conversation_id}\n")
+            f.write(f"Timestamp: {timestamp}\n")
+            f.write(f"Model: {model}\n\n")
+            f.write("Messages:\n")
+            for message in messages:
+                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() -> Dict[str, Any]:
+        """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:
+                platform = registry.create_platform(default_platform)
+                if platform:
+                    models = platform.get_model_list()
+                    if models:
+                        for model_name, _ in models:
+                            full_name = f"{default_platform}/{model_name}"
+                            model_list.append(
+                                {
+                                    "id": full_name,
+                                    "object": "model",
+                                    "created": int(time.time()),
+                                    "owned_by": default_platform,
+                                }
+                            )
+            except Exception as exc:
+                print(f"Error getting models for {default_platform}: {str(exc)}")
+
+        # Return model list
+        return {"object": "list", "data": model_list}
+
+    @app.post("/v1/chat/completions", response_model=None)
+    @app.options("/v1/chat/completions")
+    async def create_chat_completion(
+        request: ChatCompletionRequest,
+    ) -> Response:
+        """Create a chat completion in OpenAI-compatible format.
+        
+        Returns:
+            Response: Either a JSONResponse or StreamingResponse depending on the request.
+        """
+        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)
+        else:
+            # Use default platform and model if not specified
+            if default_platform and default_model:
+                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],
+            model,
+        )
+
+        if stream:
+            # Return streaming response
+            return StreamingResponse(
+                stream_chat_response(platform, message_text, model),
+                media_type="text/event-stream",
+            )
+
+        # 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"],
+                model,
+                response_text,
+            )
+
+            return JSONResponse({
+                "id": completion_id,
+                "object": "chat.completion",
+                "created": int(time.time()),
+                "model": model,
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {"role": "assistant", "content": response_text},
+                        "finish_reason": "stop",
+                    }
+                ],
+                "usage": {
+                    "prompt_tokens": len(message_text) // 4,
+                    "completion_tokens": len(response_text) // 4,
+                    "total_tokens": (len(message_text) + len(response_text)) // 4,
+                },
+            })
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=str(exc))
+
+    async def stream_chat_response(
+        platform: Any, message: str, model_name: str
+    ) -> Any:
+        """Stream chat response in OpenAI-compatible format."""
+        completion_id = f"chatcmpl-{str(uuid.uuid4())}"
+        created_time = int(time.time())
+        conversation_id = str(uuid.uuid4())
+
+        # Modify first yield statement format
+        initial_data = {
+            "id": completion_id,
+            "object": "chat.completion.chunk",
+            "created": created_time,
+            "model": model_name,
+            "choices": [
+                {"index": 0, "delta": {"role": "assistant"}, "finish_reason": None}
+            ],
+        }
+        yield f"data: {json.dumps(initial_data)}\n\n"
+
+        try:
+            # Get chat response directly
+            response = platform.chat_until_success(message)
+
+            # Record full response
+            full_response = ""
+
+            # If there is a response, send it in chunks
+            if response:
+                # Split into small chunks for better streaming experience
+                chunk_size = 4
+                for i in range(0, len(response), chunk_size):
+                    chunk = response[i : i + chunk_size]
+                    full_response += chunk
+
+                    # Create and send chunk
+                    chunk_data = {
+                        "id": completion_id,
+                        "object": "chat.completion.chunk",
+                        "created": created_time,
+                        "model": model_name,
+                        "choices": [
+                            {
+                                "index": 0,
+                                "delta": {"content": chunk},
+                                "finish_reason": None,
+                            }
+                        ],
+                    }
+
+                    yield f"data: {json.dumps(chunk_data)}\n\n"
+
+                    # Small delay to simulate streaming
+                    await asyncio.sleep(0.01)
+            else:
+                # If no output, send an empty content chunk
+                chunk_data = {
+                    "id": completion_id,
+                    "object": "chat.completion.chunk",
+                    "created": created_time,
+                    "model": model_name,
+                    "choices": [
+                        {
+                            "index": 0,
+                            "delta": {"content": "No response from model."},
+                            "finish_reason": None,
+                        }
+                    ],
+                }
+                yield f"data: {json.dumps(chunk_data)}\n\n"
+                full_response = "No response from model."
+
+            # Modify final yield statement format
+            final_data = {
+                "id": completion_id,
+                "object": "chat.completion.chunk",
+                "created": created_time,
+                "model": model_name,
+                "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}],
+            }
+            yield f"data: {json.dumps(final_data)}\n\n"
+
+            # Send [DONE] marker
+            yield "data: [DONE]\n\n"
+
+            # Log conversation to file
+            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,
+                "model": model_name,
+                "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 exc:
+            # Send error message
+            error_msg = f"Error: {str(exc)}"
+            print(f"Streaming error: {error_msg}")
+
+            res = json.dumps(
+                {
+                    "id": completion_id,
+                    "object": "chat.completion.chunk",
+                    "created": created_time,
+                    "model": model_name,
+                    "choices": [
+                        {
+                            "index": 0,
+                            "delta": {"content": error_msg},
+                            "finish_reason": "stop",
+                        }
+                    ],
+                }
+            )
+            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"
+
+            # Log error to file
+            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,
+                "model": model_name,
+                "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)

jarvis/jarvis_smart_shell/main.py

@@ -3,7 +3,7 @@
 import argparse
 import os
 import sys
-from typing import Optional
+from typing import Optional, Tuple
 
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_utils.config import get_shell_name, set_config
@@ -18,54 +18,105 @@ def execute_command(command: str, should_run: bool) -> None:
         os.system(command)
 
 
-def install_fish_completion() -> int:
-    """Install fish shell command completion with interactive choice
+def _check_fish_shell() -> bool:
+    """Check if current shell is fish
+    
+    Returns:
+        bool: True if fish shell, False otherwise
+    """
+    return get_shell_name() == "fish"
+
+def _get_config_file() -> str:
+    """Get fish config file path
+    
+    Returns:
+        str: Path to fish config file
+    """
+    return os.path.expanduser("~/.config/fish/config.fish")
+
+def _get_markers() -> Tuple[str, str]:
+    """Get start and end markers for JSS completion
+    
+    Returns:
+        Tuple[str, str]: (start_marker, end_marker)
+    """
+    return (
+        "# ===== JARVIS JSS FISH COMPLETION START =====",
+        "# ===== JARVIS JSS FISH COMPLETION END ====="
+    )
 
+def install_jss_completion() -> int:
+    """Install JSS fish shell command completion
+    
     Returns:
         int: 0 if success, 1 if failed
     """
-    if get_shell_name() != "fish":
+    if not _check_fish_shell():
         print("当前不是fish shell，无需安装")
         return 0
 
-    # 使用fish命令检查函数是否已加载
-    check_cmd = 'functions --names | grep fish_command_not_found > /dev/null && echo "defined" || echo "undefined"'
-    result = os.popen(f"fish -c '{check_cmd}'").read().strip()
+    config_file = _get_config_file()
+    start_marker, end_marker = _get_markers()
 
-    if result == "defined":
-        print("fish_command_not_found函数已加载，无需安装")
-        return 0
-
-    config_file = os.path.expanduser("~/.config/fish/config.fish")
+    if not os.path.exists(config_file):
+        print("未找到config.fish文件，将创建新文件")
+        os.makedirs(os.path.dirname(config_file), exist_ok=True)
 
-    # 检查文件内容是否已定义但未加载
-    if os.path.exists(config_file):
-        with open(config_file, "r") as config:
-            if "function fish_command_not_found" in config.read():
-                print(
-                    "fish_command_not_found函数已定义但未加载，请执行: source ~/.config/fish/config.fish"
-                )
-                return 0
+    with open(config_file, "r") as f:
+        content = f.read()
 
-    # 创建config.fish文件如果不存在
-    os.makedirs(os.path.dirname(config_file), exist_ok=True)
+    if start_marker in content:
+        print("JSS fish completion已安装，请执行: source ~/.config/fish/config.fish")
+        return 0
 
-    # 追加函数定义到config.fish
-    with open(config_file, "a") as config:
-        config.write(
-            """
+    with open(config_file, "a") as f:
+        f.write(f"""
+{start_marker}
 function fish_command_not_found
+    if test (string length "$argv") -lt 10
+        return
+    end
     commandline -r (jss request "$argv")
 end
 
 function __fish_command_not_found_handler --on-event fish_command_not_found
     fish_command_not_found "$argv"
 end
-"""
-        )
-    print(
-        "Fish shell命令补全功能已安装到config.fish，请执行: source ~/.config/fish/config.fish"
-    )
+{end_marker}
+""")
+    print("JSS fish completion已安装，请执行: source ~/.config/fish/config.fish")
+    return 0
+
+def uninstall_jss_completion() -> int:
+    """Uninstall JSS fish shell command completion
+    
+    Returns:
+        int: 0 if success, 1 if failed
+    """
+    if not _check_fish_shell():
+        print("当前不是fish shell，无需卸载")
+        return 0
+
+    config_file = _get_config_file()
+    start_marker, end_marker = _get_markers()
+
+    if not os.path.exists(config_file):
+        print("未找到JSS fish completion配置，无需卸载")
+        return 0
+
+    with open(config_file, "r") as f:
+        content = f.read()
+
+    if start_marker not in content:
+        print("未找到JSS fish completion配置，无需卸载")
+        return 0
+
+    new_content = content.split(start_marker)[0] + content.split(end_marker)[-1]
+    
+    with open(config_file, "w") as f:
+        f.write(new_content)
+    
+    print("JSS fish completion已卸载，请执行: source ~/.config/fish/config.fish")
     return 0
 
 
@@ -149,11 +200,19 @@ Example:
 
     # install子命令
     install_parser = subparsers.add_parser(
-        "install", help="安装fish shell的命令补全功能"
+        "install", help="安装JSS fish shell命令补全功能"
     )
     install_parser.add_argument(
         "--shell", choices=["fish"], default="fish", help="指定shell类型(仅支持fish)"
     )
+    
+    # 添加uninstall子命令
+    uninstall_parser = subparsers.add_parser(
+        "uninstall", help="卸载JSS fish shell命令补全功能"
+    )
+    uninstall_parser.add_argument(
+        "--shell", choices=["fish"], default="fish", help="指定shell类型(仅支持fish)"
+    )
 
     # 解析参数
     args = parser.parse_args()
@@ -165,8 +224,15 @@ Example:
         if args.shell != "fish":
             print(f"错误: 不支持的shell类型: {args.shell}, 仅支持fish")
             return 1
-        return install_fish_completion()
+        return install_jss_completion()
 
+    # 处理uninstall命令
+    if args.command == "uninstall":
+        if args.shell != "fish":
+            print(f"错误: 不支持的shell类型: {args.shell}, 仅支持fish")
+            return 1
+        return uninstall_jss_completion()
+        
     # 处理request命令
     if not args.request:
         # 检查是否在交互式终端中运行