{
  "type": 10000, // 10000 indicates real-time subtitles are delivered.
  "sender": "user_a", // userid of the speaker.
  "receiver": [], // List of receiver userid. The message is actually broadcast within the room.
  "payload": {
     "text":"", // Text recognized by ASR.
     "start_time":"00:00:01", // Start time of a sentence.
     "end_time":"00:00:02", // End time of a sentence.
     "roundid": "xxxxx", // Unique identifier of a conversation round.
     "end": true // If the value is true, the sentence is a complete sentence.
  }
}

{
  "type": 10001, // Chatbot status.
  "sender": "user_a", // userid of the sender, which is the chatbot ID in this case.
  "receiver": [], // List of receiver userid. The message is actually broadcast within the room.
  "payload": {
    "roundid": "xxx", // Unique identifier of a conversation round.
    "timestamp": 123,
    "state": 1,    //   1: Listening; 2: Thinking; 3: Speaking; 4: Interrupted; 5: Finished speaking.
  }
}


import time
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from typing import List, Optional
from langchain_core.messages import HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI

app = FastAPI(debug=True)

# Add CORS middleware.
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

class Message(BaseModel):
    role: str
    content: str

class ChatRequest(BaseModel):
    model: str
    messages: List[Message]
    temperature: Optional[float] = 0.7

class ChatResponse(BaseModel):
    id: str
    object: str
    created: int
    model: str
    choices: List[dict]
    usage: dict

@app.post("/v1/chat/completions")
async def chat_completions(request: ChatRequest):
    try:
        # Convert the request message to the LangChain message format.
        langchain_messages = []
        for msg in request.messages:
            if msg.role == "system":
                langchain_messages.append(SystemMessage(content=msg.content))
            elif msg.role == "user":
                langchain_messages.append(HumanMessage(content=msg.content))

        # add more historys 
        # Use the ChatOpenAI model from LangChain.
        chat = ChatOpenAI(temperature=request.temperature,
                          model_name=request.model)
        response = chat(langchain_messages)
        print(response)

        # Construct a response that conforms to the OpenAI API format.
        return ChatResponse(
            id="chatcmpl-" + "".join([str(ord(c))
                                     for c in response.content[:8]]),
            object="chat.completion",
            created=int(time.time()),
            model=request.model,
            choices=[{
                "index": 0,
                "message": {
                    "role": "assistant",
                    "content": response.content
                },
                "finish_reason": "stop"
            }],
            usage={
                "prompt_tokens": -1,  # LangChain does not provide this information. Thus, we use a placeholder value.
                "completion_tokens": -1,
                "total_tokens": -1
            }
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

{
  "type": 20000, // Custom text message sent by the client.
  "sender": "user_a", // Sender userid. The server will check whether the userid is valid.
  "receiver": ["user_bot"], // List of receiver userid. Fill in the chatbot userid. The server will check whether the userid is valid.
  "payload": {
    "id": "uuid", // Message ID. You can use a UUID. The ID is used for troubleshooting.
    "message": "xxx", // Message content.
    "timestamp": 123 // Timestamp. The timestamp is used for troubleshooting.
  }
}