server.py

import json
import os
import uvicorn
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from contextlib import asynccontextmanager
from dotenv import load_dotenv

load_dotenv()

from adapter import MiniMaxAdapter

adapter = None


@asynccontextmanager
async def lifespan(app: FastAPI):
    global adapter
    adapter = MiniMaxAdapter()
    try:
        await adapter.ensure_session()
        print(f"[OK] Session created: {adapter._session_id}")
    except Exception as e:
        print(f"[WARN] Session init: {e}")
    yield
    if adapter:
        await adapter.close()


app = FastAPI(title="MiniMax Agent Web2API", version="1.0.0", lifespan=lifespan)
app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])


class ChatMessage(BaseModel):
    role: str
    content: str | list | None = None


class FunctionDef(BaseModel):
    name: str
    description: str = ""
    parameters: dict = {}


class ToolDef(BaseModel):
    type: str = "function"
    function: FunctionDef


class ChatRequest(BaseModel):
    model: str | None = "MiniMax-M3"
    messages: list[ChatMessage]
    stream: bool | None = False
    temperature: float | None = None
    max_tokens: int | None = None
    top_p: float | None = None
    tools: list[ToolDef] | None = None
    tool_choice: str | None = None


class ModelInfo(BaseModel):
    id: str
    object: str = "model"
    created: int
    owned_by: str = "minimax"


@app.get("/v1/models")
async def list_models():
    return {
        "object": "list",
        "data": [
            ModelInfo(id="MiniMax-M3", created=1700000000),
        ],
    }


@app.get("/health")
async def health():
    return {"status": "ok", "session_id": adapter._session_id if adapter else None}


@app.post("/v1/chat/completions")
async def chat_completions(request: ChatRequest):
    global adapter
    if adapter is None:
        adapter = MiniMaxAdapter()

    try:
        await adapter.ensure_session()
    except Exception as e:
        if request.stream:
            from fastapi.responses import StreamingResponse
            async def err():
                yield f"data: {json.dumps({'choices': [{'delta': {'content': f'[SESSION ERROR] {e}'}, 'index': 0}]})}\n\n"
                yield f"data: {json.dumps({'choices': [{'delta': {}, 'finish_reason': 'stop', 'index': 0}]})}\n\n"
                yield "data: [DONE]\n\n"
            return StreamingResponse(err(), media_type="text/event-stream")
        raise HTTPException(status_code=500, detail=str(e))

    messages_dict = [m.model_dump() for m in request.messages]
    tools_dict = None
    if request.tools:
        tools_dict = [t.model_dump() for t in request.tools]

    if request.stream:
        return await _stream_response(messages_dict, tools_dict, request.tool_choice)
    else:
        return await _non_stream_response(messages_dict, tools_dict, request.tool_choice)


async def _stream_response(messages: list, tools: list | None = None, tool_choice: str | None = None):
    from fastapi.responses import StreamingResponse

    async def generate():
        yield f"data: {json.dumps({'choices': [{'delta': {'role': 'assistant'}, 'index': 0}]})}\n\n"
        try:
            async for chunk in adapter.stream_chat(messages, tools=tools, tool_choice=tool_choice):
                yield f"data: {json.dumps(chunk)}\n\n"
        except Exception as e:
            yield f"data: {json.dumps({'choices': [{'delta': {'content': f'[ERROR] {str(e)}'}, 'index': 0}]})}\n\n"
        yield "data: [DONE]\n\n"

    return StreamingResponse(generate(), media_type="text/event-stream")


async def _non_stream_response(messages: list, tools: list | None = None, tool_choice: str | None = None):
    try:
        result = await adapter.non_stream_chat(messages, tools=tools, tool_choice=tool_choice)
        return result
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


if __name__ == "__main__":
    port = int(os.getenv("PORT", "8000"))
    host = os.getenv("HOST", "0.0.0.0")
    uvicorn.run("server:app", host=host, port=port, reload=False)