oagi-core 0.10.1__py3-none-any.whl

oagi/server/main.py

@@ -0,0 +1,157 @@
+# -----------------------------------------------------------------------------
+#  Copyright (c) OpenAGI Foundation
+#  All rights reserved.
+#
+#  This file is part of the official API project.
+#  Licensed under the MIT License.
+# -----------------------------------------------------------------------------
+
+import logging
+from datetime import datetime
+from typing import Any
+
+from ..exceptions import check_optional_dependency
+from .config import ServerConfig
+from .models import SessionStatusData
+from .session_store import session_store
+from .socketio_server import socket_app
+
+check_optional_dependency("fastapi", "Server features", "server")
+check_optional_dependency("uvicorn", "Server features", "server")
+
+import uvicorn  # noqa: E402
+from fastapi import FastAPI, HTTPException  # noqa: E402
+from fastapi.middleware.cors import CORSMiddleware  # noqa: E402
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+
+logger = logging.getLogger(__name__)
+
+
+def create_app(config: ServerConfig | None = None) -> FastAPI:
+    if config is None:
+        config = ServerConfig()
+
+    app = FastAPI(
+        title="OAGI Socket.IO Server",
+        description="Real-time task automation server for OAGI SDK",
+        version="0.1.0",
+    )
+
+    cors_origins = (
+        config.cors_allowed_origins.split(",")
+        if config.cors_allowed_origins != "*"
+        else ["*"]
+    )
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=cors_origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    @app.get("/")
+    async def root() -> dict[str, str]:
+        return {
+            "name": "OAGI Socket.IO Server",
+            "version": "0.1.0",
+            "status": "running",
+        }
+
+    @app.get("/health")
+    async def health_check() -> dict[str, Any]:
+        return {
+            "status": "healthy",
+            "server": {
+                "name": "OAGI Socket.IO Server",
+                "version": "0.1.0",
+            },
+            "config": {
+                "base_url": config.oagi_base_url,
+                "default_model": config.default_model,
+            },
+            "sessions": {
+                "active": len(session_store.sessions),
+                "connected": sum(
+                    1 for s in session_store.sessions.values() if s.socket_id
+                ),
+            },
+        }
+
+    @app.get("/sessions")
+    async def list_sessions() -> dict[str, Any]:
+        return {
+            "sessions": session_store.list_sessions(),
+            "total": len(session_store.sessions),
+        }
+
+    @app.get("/sessions/{session_id}")
+    async def get_session(session_id: str) -> SessionStatusData:
+        session = session_store.get_session(session_id)
+        if not session:
+            raise HTTPException(
+                status_code=404, detail=f"Session {session_id} not found"
+            )
+
+        return SessionStatusData(
+            session_id=session.session_id,
+            status=session.status,  # type: ignore
+            instruction=session.instruction,
+            created_at=session.created_at,
+            actions_executed=session.actions_executed,
+            last_activity=datetime.fromtimestamp(session.last_activity).isoformat(),
+        )
+
+    @app.delete("/sessions/{session_id}")
+    async def delete_session(session_id: str) -> dict[str, str]:
+        session = session_store.get_session(session_id)
+        if not session:
+            raise HTTPException(
+                status_code=404, detail=f"Session {session_id} not found"
+            )
+
+        if session.oagi_client:
+            try:
+                await session.oagi_client.close()
+            except Exception as e:
+                logger.warning(f"Error closing OAGI client: {e}")
+
+        deleted = session_store.delete_session(session_id)
+        if deleted:
+            return {"message": f"Session {session_id} deleted"}
+        else:
+            raise HTTPException(status_code=500, detail="Failed to delete session")
+
+    @app.post("/sessions/cleanup")
+    async def cleanup_sessions(timeout_hours: float = 1.0) -> dict[str, Any]:
+        timeout_seconds = timeout_hours * 3600
+        cleaned = session_store.cleanup_inactive_sessions(timeout_seconds)
+        return {
+            "cleaned": cleaned,
+            "remaining": len(session_store.sessions),
+        }
+
+    # Mount Socket.IO application
+    app.mount("/", socket_app)
+
+    logger.info(
+        f"Server created - will listen on {config.server_host}:{config.server_port}"
+    )
+
+    return app
+
+
+if __name__ == "__main__":
+    config = ServerConfig()
+    app = create_app(config)
+    uvicorn.run(
+        app,
+        host=config.server_host,
+        port=config.server_port,
+        log_level="info",
+    )

oagi/server/models.py

@@ -0,0 +1,98 @@
+# -----------------------------------------------------------------------------
+#  Copyright (c) OpenAGI Foundation
+#  All rights reserved.
+#
+#  This file is part of the official API project.
+#  Licensed under the MIT License.
+# -----------------------------------------------------------------------------
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+# Client-to-server events
+class InitEventData(BaseModel):
+    instruction: str = Field(...)
+    mode: str | None = Field(default="actor")
+    model: str | None = Field(default="lux-actor-1")
+    temperature: float | None = Field(default=0.1, ge=0.0, le=2.0)
+
+
+# Server-to-client events
+class BaseActionEventData(BaseModel):
+    index: int = Field(..., ge=0)
+    total: int = Field(..., ge=1)
+
+
+class ClickEventData(BaseActionEventData):
+    x: int = Field(..., ge=0, le=1000)
+    y: int = Field(..., ge=0, le=1000)
+
+
+class DragEventData(BaseActionEventData):
+    x1: int = Field(..., ge=0, le=1000)
+    y1: int = Field(..., ge=0, le=1000)
+    x2: int = Field(..., ge=0, le=1000)
+    y2: int = Field(..., ge=0, le=1000)
+
+
+class HotkeyEventData(BaseActionEventData):
+    combo: str = Field(...)
+    count: int = Field(default=1, ge=1)
+
+
+class TypeEventData(BaseActionEventData):
+    text: str = Field(...)
+
+
+class ScrollEventData(BaseActionEventData):
+    x: int = Field(..., ge=0, le=1000)
+    y: int = Field(..., ge=0, le=1000)
+    direction: Literal["up", "down"] = Field(...)
+    count: int = Field(default=1, ge=1)
+
+
+class WaitEventData(BaseActionEventData):
+    duration_ms: int = Field(default=1000, ge=0)
+
+
+class FinishEventData(BaseActionEventData):
+    pass
+
+
+# Screenshot request/response
+class ScreenshotRequestData(BaseModel):
+    presigned_url: str = Field(...)
+    uuid: str = Field(...)
+    expires_at: str = Field(...)
+
+
+class ScreenshotResponseData(BaseModel):
+    success: bool = Field(...)
+    error: str | None = Field(None)
+
+
+# Action acknowledgement
+class ActionAckData(BaseModel):
+    index: int = Field(...)
+    success: bool = Field(...)
+    error: str | None = Field(None)
+    execution_time_ms: int | None = Field(None)
+
+
+# Session status
+class SessionStatusData(BaseModel):
+    session_id: str = Field(...)
+    status: Literal["initialized", "running", "completed", "failed"] = Field(...)
+    instruction: str = Field(...)
+    created_at: str = Field(...)
+    actions_executed: int = Field(default=0)
+    last_activity: str = Field(...)
+
+
+# Error event
+class ErrorEventData(BaseModel):
+    message: str = Field(...)
+    code: str | None = Field(None)
+    details: dict | None = Field(None)

oagi/server/session_store.py

@@ -0,0 +1,116 @@
+# -----------------------------------------------------------------------------
+#  Copyright (c) OpenAGI Foundation
+#  All rights reserved.
+#
+#  This file is part of the official API project.
+#  Licensed under the MIT License.
+# -----------------------------------------------------------------------------
+
+import secrets
+from datetime import datetime
+from typing import Any
+from uuid import uuid4
+
+
+class Session:
+    def __init__(
+        self,
+        session_id: str,
+        instruction: str,
+        mode: str = "actor",
+        model: str = "lux-actor-1",
+        temperature: float = 0.0,
+    ):
+        self.session_id: str = session_id
+        self.instruction: str = instruction
+        self.mode: str = mode
+        self.model: str = model
+        self.temperature: float = temperature
+
+        # OAGI task state
+        self.task_id: str = uuid4().hex
+        self.message_history: list[dict[str, Any]] = []
+        self.current_screenshot_url: str | None = None
+
+        # Socket state
+        self.socket_id: str | None = None
+        self.namespace: str | None = None
+        self.last_activity: float = datetime.now().timestamp()
+
+        # Status tracking
+        self.status: str = "initialized"
+        self.created_at: str = datetime.now().isoformat()
+        self.actions_executed: int = 0
+
+        # OAGI client reference
+        self.oagi_client: Any | None = None
+
+
+class SessionStore:
+    def __init__(self):
+        self.sessions: dict[str, Session] = {}
+
+    def create_session(
+        self,
+        instruction: str,
+        mode: str = "actor",
+        model: str = "lux-actor-1",
+        temperature: float = 0.0,
+        session_id: str | None = None,
+    ) -> str:
+        if session_id is None:
+            session_id = f"ses_{secrets.token_urlsafe(16)}"
+
+        session = Session(session_id, instruction, mode, model, temperature)
+        self.sessions[session_id] = session
+        return session_id
+
+    def get_session(self, session_id: str) -> Session | None:
+        return self.sessions.get(session_id)
+
+    def get_session_by_socket_id(self, socket_id: str) -> Session | None:
+        for session in self.sessions.values():
+            if session.socket_id == socket_id:
+                return session
+        return None
+
+    def delete_session(self, session_id: str) -> bool:
+        if session_id in self.sessions:
+            self.sessions.pop(session_id)
+            return True
+        return False
+
+    def update_activity(self, session_id: str) -> None:
+        session = self.sessions.get(session_id)
+        if session:
+            session.last_activity = datetime.now().timestamp()
+
+    def list_sessions(self) -> list[dict[str, Any]]:
+        return [
+            {
+                "session_id": session.session_id,
+                "status": session.status,
+                "instruction": session.instruction,
+                "created_at": session.created_at,
+                "actions_executed": session.actions_executed,
+                "connected": session.socket_id is not None,
+            }
+            for session in self.sessions.values()
+        ]
+
+    def cleanup_inactive_sessions(self, timeout_seconds: float) -> int:
+        current_time = datetime.now().timestamp()
+        sessions_to_delete = []
+
+        for session_id, session in self.sessions.items():
+            if current_time - session.last_activity > timeout_seconds:
+                sessions_to_delete.append(session_id)
+
+        for session_id in sessions_to_delete:
+            self.delete_session(session_id)
+
+        return len(sessions_to_delete)
+
+
+# Global instance
+session_store = SessionStore()