jarvis-ai-assistant 0.1.222__py3-none-any.whl → 0.7.0__py3-none-any.whl

jarvis/jarvis_platform_manager/service.py

@@ -7,9 +7,10 @@ import asyncio
 import json
 import os
 import time
+import threading
 import uuid
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 
 import uvicorn
 from fastapi import FastAPI, HTTPException
@@ -72,8 +73,16 @@ def start_service(
 ) -> 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)
+    # Prefer environment variable, then user directory, fall back to CWD
+    logs_dir = os.environ.get("JARVIS_LOG_DIR")
+    if not logs_dir:
+        logs_dir = os.path.join(os.path.expanduser("~"), ".jarvis", "logs")
+    try:
+        os.makedirs(logs_dir, exist_ok=True)
+    except Exception:
+        # As a last resort, use current working directory
+        logs_dir = os.path.join(os.getcwd(), "logs")
+        os.makedirs(logs_dir, exist_ok=True)
 
     app = FastAPI(title="Jarvis API Server")
 
@@ -81,7 +90,7 @@ def start_service(
     app.add_middleware(
         CORSMiddleware,
         allow_origins=["*"],
-        allow_credentials=True,
+        allow_credentials=False,
         allow_methods=["*"],
         allow_headers=["*"],
     )
@@ -91,7 +100,7 @@ def start_service(
     PrettyOutput.print(
         f"Starting Jarvis API server on {host}:{port}", OutputType.SUCCESS
     )
-    PrettyOutput.print("This server provides an OpenAI-compatible API", OutputType.INFO)
+    PrettyOutput.print("本服务提供与 OpenAI 兼容的 API", OutputType.INFO)
 
     if default_platform and default_model:
         PrettyOutput.print(
@@ -99,8 +108,6 @@ def start_service(
             OutputType.INFO,
         )
 
-    PrettyOutput.print("Available platforms:", OutputType.INFO)
-
     # Platform and model cache
     platform_instances: Dict[str, Any] = {}
 
@@ -144,7 +151,7 @@ def start_service(
             if response:
                 f.write(f"\nResponse:\n{response}\n")
 
-        PrettyOutput.print(f"Conversation logged to {log_file}", OutputType.INFO)
+        PrettyOutput.print(f"会话已记录到 {log_file}", OutputType.INFO)
 
     @app.get("/v1/models")
     async def list_models() -> Dict[str, Any]:
@@ -169,7 +176,10 @@ def start_service(
                                 }
                             )
             except Exception as exc:
-                print(f"Error getting models for {default_platform}: {str(exc)}")
+                PrettyOutput.print(
+                    f"Error getting models for {default_platform}: {str(exc)}",
+                    OutputType.ERROR,
+                )
 
         # Return model list
         return {"object": "list", "data": model_list}
@@ -195,11 +205,16 @@ def start_service(
         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
+            # Use default platform if not specified in the model name
+            if default_platform:
+                platform_name = default_platform
+                model_name = model
             else:
-                platform_name, model_name = "oyi", model  # Default to OYI platform
+                raise HTTPException(
+                    status_code=400,
+                    detail="Model name must be in 'platform/model_name' format "
+                    "or a default platform must be set.",
+                )
 
         # Get platform instance
         platform = get_platform_instance(platform_name, model_name)
@@ -223,23 +238,23 @@ def start_service(
             "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,
-        )
+        # Logging moved to post-response to avoid duplicates
 
         if stream:
             # Return streaming response
             return StreamingResponse(
                 stream_chat_response(platform, message_text, model),  # type: ignore
                 media_type="text/event-stream",
+                headers={"Cache-Control": "no-cache", "Connection": "keep-alive"},
             )
 
         # Get chat response
         try:
-            response_text = platform.chat_until_success(message_text)
+            # Run potentially blocking call in a thread to avoid blocking the event loop
+            loop = asyncio.get_running_loop()
+            response_text = await loop.run_in_executor(
+                None, lambda: platform.chat_until_success(message_text)
+            )
 
             # Create response in OpenAI format
             completion_id = f"chatcmpl-{str(uuid.uuid4())}"
@@ -282,11 +297,31 @@ def start_service(
             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."""
+        """Stream chat response in OpenAI-compatible format without blocking the event loop."""
         completion_id = f"chatcmpl-{str(uuid.uuid4())}"
         created_time = int(time.time())
         conversation_id = str(uuid.uuid4())
 
+        loop = asyncio.get_running_loop()
+        queue: asyncio.Queue = asyncio.Queue()
+        SENTINEL = object()
+
+        def producer() -> None:
+            try:
+                for chunk in platform.chat(message):
+                    if chunk:
+                        asyncio.run_coroutine_threadsafe(queue.put(chunk), loop)
+            except Exception as exc:
+                # Use a special dict to pass error across thread boundary
+                asyncio.run_coroutine_threadsafe(
+                    queue.put({"__error__": str(exc)}), loop
+                )
+            finally:
+                asyncio.run_coroutine_threadsafe(queue.put(SENTINEL), loop)
+
+        # Start producer thread
+        threading.Thread(target=producer, daemon=True).start()
+
         # Send the initial chunk with the role
         initial_data = {
             "id": completion_id,
@@ -299,36 +334,20 @@ def start_service(
         }
         yield f"data: {json.dumps(initial_data)}\n\n"
 
-        try:
-            # Use the streaming-capable chat method
-            response_generator = platform.chat(message)
-
-            full_response = ""
-            has_content = False
-
-            # Iterate over the generator and stream chunks
-            for chunk in response_generator:
-                if chunk:
-                    has_content = True
-                    full_response += 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"
+        full_response = ""
+        has_content = False
+
+        while True:
+            item = await queue.get()
+            if item is SENTINEL:
+                break
+
+            if isinstance(item, dict) and "__error__" in item:
+                error_msg = f"Error during streaming: {item['__error__']}"
+                PrettyOutput.print(error_msg, OutputType.ERROR)
 
-            if not has_content:
-                no_response_message = "No response from model."
-                chunk_data = {
+                # Send error information in the stream
+                error_chunk = {
                     "id": completion_id,
                     "object": "chat.completion.chunk",
                     "created": created_time,
@@ -336,41 +355,45 @@ def start_service(
                     "choices": [
                         {
                             "index": 0,
-                            "delta": {"content": no_response_message},
-                            "finish_reason": None,
+                            "delta": {"content": error_msg},
+                            "finish_reason": "stop",
                         }
                     ],
                 }
-                yield f"data: {json.dumps(chunk_data)}\n\n"
-                full_response = no_response_message
+                yield f"data: {json.dumps(error_chunk)}\n\n"
+                yield "data: [DONE]\n\n"
+
+                # Log the error
+                log_conversation(
+                    conversation_id,
+                    [{"role": "user", "content": message}],
+                    model_name,
+                    response=f"ERROR: {error_msg}",
+                )
+                return
 
-            # Send the final chunk with finish_reason
-            final_data = {
+            # Normal chunk
+            chunk = item
+            has_content = True
+            full_response += chunk
+            chunk_data = {
                 "id": completion_id,
                 "object": "chat.completion.chunk",
                 "created": created_time,
                 "model": model_name,
-                "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}],
+                "choices": [
+                    {
+                        "index": 0,
+                        "delta": {"content": chunk},
+                        "finish_reason": None,
+                    }
+                ],
             }
-            yield f"data: {json.dumps(final_data)}\n\n"
-
-            # Send the [DONE] marker
-            yield "data: [DONE]\n\n"
+            yield f"data: {json.dumps(chunk_data)}\n\n"
 
-            # Log the full conversation
-            log_conversation(
-                conversation_id,
-                [{"role": "user", "content": message}],
-                model_name,
-                full_response,
-            )
-
-        except Exception as exc:
-            error_msg = f"Error during streaming: {str(exc)}"
-            PrettyOutput.print(error_msg, OutputType.ERROR)
-
-            # Send error information in the stream
-            error_chunk = {
+        if not has_content:
+            no_response_message = "No response from model."
+            chunk_data = {
                 "id": completion_id,
                 "object": "chat.completion.chunk",
                 "created": created_time,
@@ -378,21 +401,34 @@ def start_service(
                 "choices": [
                     {
                         "index": 0,
-                        "delta": {"content": error_msg},
-                        "finish_reason": "stop",
+                        "delta": {"content": no_response_message},
+                        "finish_reason": None,
                     }
                 ],
             }
-            yield f"data: {json.dumps(error_chunk)}\n\n"
-            yield "data: [DONE]\n\n"
+            yield f"data: {json.dumps(chunk_data)}\n\n"
+            full_response = no_response_message
 
-            # Log the error
-            log_conversation(
-                conversation_id,
-                [{"role": "user", "content": message}],
-                model_name,
-                response=f"ERROR: {error_msg}",
-            )
+        # Send the final chunk with finish_reason
+        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 the [DONE] marker
+        yield "data: [DONE]\n\n"
+
+        # Log the full conversation
+        log_conversation(
+            conversation_id,
+            [{"role": "user", "content": message}],
+            model_name,
+            full_response,
+        )
 
     # Run the server
     uvicorn.run(app, host=host, port=port)