api: Apply OpenAI plugins.

app.py

@@ -14,7 +14,7 @@ from fastapi import FastAPI, HTTPException
 from fastapi.responses import JSONResponse, StreamingResponse
 from gradio_client import Client
 from pydantic import BaseModel
-from typing import AsyncGenerator, Optional, Dict, List, Tuple
+from typing import AsyncGenerator, Optional, Dict, List, Tuple, Any
 
 # Default AI model name used when no model is specified by user
 MODEL = "JARVIS: 2.1.3"
@@ -49,6 +49,21 @@ class ResponseRequest(BaseModel):
     stream: Optional[bool] = False
     session_id: Optional[str] = None
 
+class OpenAIChatRequest(BaseModel):
+    """
+    Defines the OpenAI-compatible request structure for /v1/chat/completions endpoint.
+    
+    Attributes:
+    - model: Optional; specifies which AI model to use. Defaults to MODEL if not provided.
+    - messages: List of message objects containing 'role' and 'content'
+    - stream: Optional; if True, the response will be streamed incrementally.
+    - session_id: Optional; unique session identifier for maintaining conversation history
+    """
+    model: Optional[str] = None
+    messages: List[Dict[str, str]]
+    stream: Optional[bool] = False
+    session_id: Optional[str] = None
+
 def cleanup_expired_sessions():
     """
     Remove sessions that have been inactive for longer than EXPIRE.
@@ -230,7 +245,7 @@ async def event_generator(user_input: str, model: str, session_id: str) -> Async
 @app.post("/v1/responses")
 async def responses(req: ResponseRequest):
     """
-    Main API endpoint to get AI responses.
+    Original API endpoint to get AI responses.
     Supports both streaming and non-streaming modes.
     
     Workflow:
@@ -294,6 +309,131 @@ async def responses(req: ResponseRequest):
     # Return the JSON response
     return JSONResponse(response)
 
+@app.post("/v1/chat/completions")
+async def openai_chat_completions(req: OpenAIChatRequest):
+    """
+    OpenAI-compatible endpoint for chat completions.
+    Supports both streaming and non-streaming modes.
+    
+    Workflow:
+    - Validate message structure and extract conversation history
+    - Validate or create session
+    - Update session history from messages
+    - Handle streaming or full response
+    - Save new interaction to session history
+    
+    Returns:
+    - JSON response in OpenAI format with session ID extension
+    """
+    # Validate messages structure
+    if not req.messages:
+        raise HTTPException(status_code=400, detail="Messages cannot be empty")
+    
+    # Extract conversation history and current input
+    history = []
+    current_input = ""
+    
+    # Process messages to extract conversation history
+    try:
+        # Last message should be from user and used as current input
+        if req.messages[-1]["role"] != "user":
+            raise ValueError("Last message must be from user")
+        
+        current_input = req.messages[-1]["content"]
+        
+        # Process message pairs (user + assistant)
+        messages = req.messages[:-1]  # Exclude last message (current input)
+        for i in range(0, len(messages), 2):
+            if i+1 < len(messages):
+                user_msg = messages[i]
+                assistant_msg = messages[i+1]
+                
+                if user_msg["role"] != "user" or assistant_msg["role"] != "assistant":
+                    # Skip invalid pairs but continue processing
+                    continue
+                
+                history.append({
+                    "input": user_msg["content"],
+                    "response": assistant_msg["content"]
+                })
+    except (KeyError, ValueError) as e:
+        raise HTTPException(status_code=400, detail=f"Invalid message format: {str(e)}")
+
+    model = req.model or MODEL  # Use requested model or default
+    session_id = get_or_create_session(req.session_id, model)  # Get or create session
+    last_update, session_data = session_store[session_id]
+
+    # Update session history from messages
+    session_data["history"] = history
+    session_store[session_id] = (time.time(), session_data)
+
+    client = session_data["client"]
+    if client is None:
+        raise HTTPException(status_code=503, detail="AI client not available")
+
+    if req.stream:
+        # Streaming response
+        return StreamingResponse(
+            event_generator(current_input, model, session_id),
+            media_type="text/event-stream"
+        )
+
+    # Non-streaming response
+    try:
+        jarvis_response = client.submit(multi={"text": current_input}, api_name="/api")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to submit to AI: {str(e)}")
+
+    buffer = ""
+    for partial in jarvis_response:
+        text = partial[0][0][1]
+        buffer = text
+
+    # Update session history with new interaction
+    session_data["history"].append({"input": current_input, "response": buffer})
+    session_store[session_id] = (time.time(), session_data)
+
+    # Format response in OpenAI style
+    response = {
+        "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": model,
+        "choices": [
+            {
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": buffer
+                },
+                "finish_reason": "stop"
+            }
+        ],
+        "session_id": session_id  # Custom extension for session management
+    }
+
+    return JSONResponse(response)
+
+@app.get("/v1/models")
+async def list_models():
+    """
+    OpenAI-compatible endpoint to list available models.
+    Returns a fixed list containing our default model.
+    
+    This endpoint is required by many OpenAI-compatible clients.
+    """
+    return JSONResponse({
+        "object": "list",
+        "data": [
+            {
+                "id": MODEL,
+                "object": "model",
+                "created": 0,  # Timestamp not available
+                "owned_by": "J.A.R.V.I.S."
+            }
+        ]
+    })
+
 @app.get("/v1/history")
 async def get_history(session_id: Optional[str] = None):
     """