agent-os-server 0.0.4__py3-none-any.whl

agent_os_server-0.0.4.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: agent-os-server
+Version: 0.0.4
+Summary: 智能体服务
+Author-email: fubo <fb_linux@163.com>
+License: MIT
+Project-URL: Homepage, https://codeup.aliyun.com/64650c96168f0a5963451dec/agi-next/agent-server/blob/master/README.md
+Project-URL: Repository, https://codeup.aliyun.com/64650c96168f0a5963451dec/agi-next/agent-server.git
+Keywords: agent-server
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: agent-os-base>=0.1.2
+Provides-Extra: test
+Requires-Dist: pytest>=6.0; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: license-file
+
+# Agent Server
+
+一个基于 Google ADK (Agent Development Kit) 和 FastAPI 构建的智能体服务服务器，用于运行和管理 AI 代理。
+
+## 项目概述
+
+`agent-server` 提供了多种接口方式来与 AI 代理进行交互，包括 HTTP API、AGUI 接口和命令行界面。
+
+## 核心功能
+
+### 1. ADK Server
+
+基于 FastAPI 的 HTTP API 服务器，使用 Google ADK 的 Runner 来执行代理。
+
+- **功能**: 提供标准的 HTTP API 接口
+- **会话管理**: 支持会话创建和管理
+- **安全**: 包含用户白名单中间件
+- **启动命令**: `agent-server-adk`
+
+### 2. AGUI Server
+
+提供 AGUI (Agent Graphical User Interface) 接口，用于图形化交互。
+
+- **主要端点**:
+  - `POST /agui/api/v1/chat/completions` - 聊天完成接口
+  - `GET /agui/api/v1/reload` - 热重载代理配置
+  - `GET /agui/api/v1/health` - 健康检查
+- **启动命令**: `agent-server-agui`
+
+### 3. CMD Server
+
+命令行交互界面，使用 `rich` 库实现彩色输出和 Markdown 渲染。
+
+- **功能**:
+  - 任务提交和执行
+  - 会话管理（列出、删除）
+  - 实时输出代理响应
+  - 支持工具调用和函数响应展示
+- **启动命令**: `agent-server-cmd`
+
+## 技术架构
+
+### 依赖
+- **Google ADK**: Agent Development Kit，用于代理运行
+- **FastAPI**: Web 框架，提供 HTTP API
+- **Uvicorn**: ASGI 服务器
+- **Rich**: 命令行美化输出
+- **Python Dotenv**: 环境变量管理
+
+### 工具类 (utils.py)
+
+- **Utils.Service**: 提供 session 和 memory 服务的创建
+  - `memory_service()`: 创建记忆服务
+  - `session_service()`: 创建会话服务
+- **Utils.Agent**: 负责代理的加载和运行器创建
+  - `load_adk_agents()`: 从指定路径加载代理配置
+  - `create_adk_agent_agui_runner()`: 创建 AGUI 运行器
+  - `create_adk_agent_adk_runner()`: 创建 ADK 运行器
+
+## 配置说明
+
+配置文件：`.server.env`
+
+```bash
+# 代理配置路径
+AGENTS_PATH=/Users/fubo/develop/apps/agent-os/agents
+
+# 会话服务数据库 URI（留空使用内存服务）
+SESSION_SERVICE_URI=
+
+# 记忆服务 URI（留空使用内存服务）
+MEMORY_SERVICE_URI=
+
+# 用户服务 URI
+USER_SERVICE_URI=
+
+# 追踪服务 URI
+TRACE_SERVICE_URI=
+
+# 服务器监听地址
+HOST=0.0.0.0
+
+# 服务器端口
+PORT=8000
+```
+
+## 安装与使用
+
+### 安装依赖
+
+```bash
+pip install -e .
+```
+
+### 启动服务
+
+```bash
+# 启动 AGUI 服务器
+agent-server-agui
+
+# 启动命令行界面
+agent-server-cmd
+
+# 启动 ADK 服务器
+agent-server-adk
+```
+
+## 项目结构
+
+```
+agent-server/
+├── src/
+│   └── agent_server/
+│       ├── __init__.py
+│       ├── adk_server.py      # ADK HTTP 服务器
+│       ├── agui_server.py     # AGUI 服务器
+│       ├── cmd_server.py      # 命令行服务器
+│       ├── utils.py           # 工具类
+│       └── .server.env        # 配置文件
+├── tests/
+├── pyproject.toml
+├── Dockerfile
+└── README.md
+```
+
+## 开发信息
+
+- **版本**: 0.0.1
+- **作者**: fubo <fb_linux@163.com>
+- **许可证**: MIT
+- **Python 版本**: >= 3.10
+
+## 依赖项
+
+- `agent-base>=0.1.2`
+- `fastapi`
+- `uvicorn`
+- `rich`
+- `python-dotenv`
+- `google-adk`
+
+## 测试
+
+```bash
+pip install -e ".[test]"
+pytest
+```

agent_os_server-0.0.4.dist-info/RECORD

@@ -0,0 +1,11 @@
+agent_os_server-0.0.4.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_server/adk_server.py,sha256=-i1gNbVkfiiqZsZ1zwScI6nuzK0UamqbNEU_zNQm2Jc,13488
+agent_server/agui_server.py,sha256=rYcOpmrZII2v_ZrydaWY298dgpkOg3gVDjCv7VZZ9cI,2388
+agent_server/cmd_server.py,sha256=Q1yMKHIiuhgj4MaVuZwE093H4DhTWEEFwB_9mWNBjhQ,12975
+agent_server/utils.py,sha256=vbf3mGyycWzFk1XXE9GdYX_z2qzkWpHGgNqXLiquxhs,5350
+agent_os_server-0.0.4.dist-info/METADATA,sha256=25Pu88H_htUlQvddfJR-2RGMSCd0vtQauzhxBW2YLLM,4054
+agent_os_server-0.0.4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+agent_os_server-0.0.4.dist-info/entry_points.txt,sha256=SNeJ2OiWVPKWKaJIk_r4fgjeTcb7j-sJGXp1d5bZCzM,164
+agent_os_server-0.0.4.dist-info/top_level.txt,sha256=IgClwJDz-2vEwgH27kHdjOhpnyqvomdkfGgrXBV5Tc4,13
+agent_os_server-0.0.4.dist-info/RECORD,,

agent_os_server-0.0.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

agent_os_server-0.0.4.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+agent-server-adk = agent_server.adk_server:main
+agent-server-agui = agent_server.agui_server:main
+agent-server-cmd = agent_server.cmd_server:main

agent_os_server-0.0.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+agent_server

agent_server/adk_server.py

@@ -0,0 +1,372 @@
+import asyncio
+import contextlib
+import logging
+import sys
+import uvicorn
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s [%(name)s] %(message)s",
+    stream=sys.stderr
+)
+
+from collections.abc import AsyncIterable
+from dotenv import dotenv_values
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.sse import EventSourceResponse, ServerSentEvent
+from pydantic import BaseModel
+
+from google.adk.runners import Runner
+from google.adk.sessions import DatabaseSessionService
+from google.adk.artifacts import InMemoryArtifactService
+from google.genai import types
+from google.adk.apps import App
+from .utils import Utils
+
+# from agents.proxy_agent.agent import root_agent
+
+#### ===========
+# logging.basicConfig(
+#     level=logging.INFO,
+#     format="%(asctime)s %(levelname)s [%(name)s] %(message)s",
+# )
+# logger = logging.getLogger("agent_os")
+#
+#
+# app_name = "agent_os_app"
+# session_service = DatabaseSessionService(
+#     db_url="sqlite+aiosqlite:///./.resources/sqlite.db/sessions.db"
+# )
+#
+# Runner(app=App(name=, root_agent=root_agent,plugins=))
+# runner = Runner(
+#     app_name=app_name,
+#     agent=root_agent,
+#     session_service=session_service,
+#     artifact_service=InMemoryArtifactService(),
+#     auto_create_session=False,
+# )
+
+#### ===========
+
+config = dotenv_values(".server.env")
+server_config = Utils.Server.ServerConfig(
+    agents_path=config.get("AGENTS_PATH", ""),
+    session_service_uri=config.get("SESSION_SERVICE_URI", ""),
+    memory_service_uri=config.get("MEMORY_SERVICE_URI", ""),
+    user_service_uri=config.get("USER_SERVICE_URI", ""),
+    trace_service_uri=config.get("TRACE_SERVICE_URI", ""),
+    host=config.get("HOST", "0.0.0.0"),
+    port=int(config.get("PORT", "8000"))
+)
+
+class CreateSessionRequest(BaseModel):
+    user_id: str
+
+
+class ChatRequest(BaseModel):
+    user_id: str
+    session_id: str
+    message: str
+
+
+class Application:
+    global server_config
+    api = FastAPI(title=f"{Utils.Agent.agent_name} ADK Server")
+    agent_app_name = f"{Utils.Agent.agent_name} ADK APP"
+    api.add_middleware(Utils.Server.UserWhitelistMiddleware)
+    agent_adk_runner = Utils.Agent.create_adk_agent_adk_runner(
+        agents_path=server_config.agents_path,
+        session_service_uri=server_config.session_service_uri,
+        memory_service_uri=server_config.memory_service_uri
+    )
+    session_service = agent_adk_runner.session_service
+    if agent_adk_runner is None:
+        raise Exception("Agent load failed")
+
+    @staticmethod
+    def safe_jsonable(value):
+        if value is None:
+            return None
+
+        if hasattr(value, "model_dump"):
+            try:
+                return value.model_dump(mode="json")
+            except Exception:
+                pass
+
+        if hasattr(value, "dict"):
+            try:
+                return value.dict()
+            except Exception:
+                pass
+
+        if isinstance(value, (str, int, float, bool, list, dict)):
+            return value
+
+        return str(value)
+
+    @staticmethod
+    async def ensure_session(user_id: str, session_id: str | None = None):
+        if session_id:
+            session = await Application.session_service.get_session(
+                app_name=Application.agent_app_name,
+                user_id=user_id,
+                session_id=session_id,
+            )
+            if session:
+                return session
+
+            return await Application.session_service.create_session(
+                app_name=Application.agent_app_name,
+                user_id=user_id,
+                session_id=session_id,
+                state={},
+            )
+
+        return await Application.session_service.create_session(
+            app_name=Application.agent_app_name,
+            user_id=user_id,
+            state={},
+        )
+
+
+    @api.post("/session/create", tags=["ADK API"])
+    async def create_session(request: CreateSessionRequest):
+        try:
+            session = await Application.ensure_session(user_id=request.user_id)
+            return {"user_id": request.user_id, "session_id": session.id}
+        except Exception as e:
+            logging.exception("create_session failed")
+            raise HTTPException(status_code=500, detail=str(e))
+
+
+    @api.post("/chat/stream", response_class=EventSourceResponse, tags=["ADK API"])
+    async def chat_stream(request: ChatRequest, http_request: Request) -> AsyncIterable[ServerSentEvent]:
+        """
+        关键点：
+        1. 这里不要 return EventSourceResponse(...)
+        2. 路由函数本身直接 yield，符合 FastAPI 官方 SSE 用法
+        3. 没有消息时也定期发 comment，防止连接静默
+        """
+        await Application.ensure_session(user_id=request.user_id, session_id=request.session_id)
+
+        queue: asyncio.Queue[ServerSentEvent | None] = asyncio.Queue()
+
+        async def producer():
+            try:
+                content = types.Content(
+                    role="user",
+                    parts=[types.Part(text=request.message)]
+                )
+
+                logging.info(
+                    "stream start user_id=%s session_id=%s",
+                    request.user_id,
+                    request.session_id,
+                )
+
+                async for event in Application.agent_adk_runner.run_async(
+                    user_id=request.user_id,
+                    session_id=request.session_id,
+                    new_message=content,
+                ):
+                    if event.content and event.content.parts:
+                        for part in event.content.parts:
+                            if getattr(part, "text", None):
+                                await queue.put(
+                                    ServerSentEvent(
+                                        data={
+                                            "type": "thinking" if getattr(part, "thought", False) else "text",
+                                            "content": part.text,
+                                        },
+                                        event="message",
+                                    )
+                                )
+
+                            if getattr(part, "function_call", None) is not None:
+                                await queue.put(
+                                    ServerSentEvent(
+                                        data={
+                                            "type": "tool_call",
+                                            "delta": {
+                                                "tool_name": part.function_call.name,
+                                                "params": Application.safe_jsonable(part.function_call.args),
+                                            },
+                                        },
+                                        event="message",
+                                    )
+                                )
+
+                            if getattr(part, "function_response", None) is not None:
+                                await queue.put(
+                                    ServerSentEvent(
+                                        data={
+                                            "type": "tool_response",
+                                            "delta": {
+                                                "tool_name": part.function_response.name,
+                                                "response": Application.safe_jsonable(part.function_response.response),
+                                            },
+                                        },
+                                        event="message",
+                                    )
+                                )
+
+                    if event.actions and event.actions.state_delta:
+                        await queue.put(
+                            ServerSentEvent(
+                                data={
+                                    "type": "state_update",
+                                    "delta": Application.safe_jsonable(event.actions.state_delta),
+                                },
+                                event="message",
+                            )
+                        )
+
+                    if event.is_final_response():
+                        final_session = await Application.session_service.get_session(
+                            app_name=Application.agent_app_name,
+                            user_id=request.user_id,
+                            session_id=request.session_id,
+                        )
+                        await queue.put(
+                            ServerSentEvent(
+                                data={
+                                    "type": "final",
+                                    "state": Application.safe_jsonable(final_session.state if final_session else None),
+                                },
+                                event="final",
+                            )
+                        )
+
+                await queue.put(ServerSentEvent(raw_data="[DONE]", event="done"))
+                logging.info(
+                    "stream done user_id=%s session_id=%s",
+                    request.user_id,
+                    request.session_id,
+                )
+
+            except asyncio.CancelledError:
+                logging.info(
+                    "stream producer cancelled user_id=%s session_id=%s",
+                    request.user_id,
+                    request.session_id,
+                )
+                raise
+            except Exception as e:
+                logging.exception(
+                    "stream producer failed user_id=%s session_id=%s",
+                    request.user_id,
+                    request.session_id,
+                )
+                await queue.put(
+                    ServerSentEvent(
+                        data={"type": "error", "message": str(e)},
+                        event="error",
+                    )
+                )
+            finally:
+                await queue.put(None)
+
+        producer_task = asyncio.create_task(producer())
+
+        try:
+            # 首包
+            yield ServerSentEvent(comment="stream opened")
+
+            while True:
+                if await http_request.is_disconnected():
+                    producer_task.cancel()
+                    break
+
+                try:
+                    item = await asyncio.wait_for(queue.get(), timeout=10)
+                except asyncio.TimeoutError:
+                    # 空闲保活
+                    yield ServerSentEvent(comment="keep-alive")
+                    continue
+
+                if item is None:
+                    break
+
+                yield item
+
+        finally:
+            if not producer_task.done():
+                producer_task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await producer_task
+
+
+    @api.post("/chat", tags=["ADK API"])
+    async def chat(request: ChatRequest):
+        try:
+            await Application.ensure_session(user_id=request.user_id, session_id=request.session_id)
+
+            full_response = ""
+            final_state = None
+
+            content = types.Content(
+                role="user",
+                parts=[types.Part(text=request.message)]
+            )
+
+            async for event in Application.agent_adk_runner.run_async(
+                user_id=request.user_id,
+                session_id=request.session_id,
+                new_message=content,
+            ):
+                if event.content and event.content.parts:
+                    for part in event.content.parts:
+                        if getattr(part, "text", None):
+                            full_response += part.text
+
+                if event.is_final_response():
+                    final_session = await Application.session_service.get_session(
+                        app_name=Application.agent_app_name,
+                        user_id=request.user_id,
+                        session_id=request.session_id,
+                    )
+                    final_state = final_session.state if final_session else None
+
+            return {
+                "response": full_response,
+                "final_state": Application.safe_jsonable(final_state),
+            }
+
+        except Exception as e:
+            logging.exception("chat failed")
+            raise HTTPException(status_code=500, detail=str(e))
+
+
+    @api.get("/session/{user_id}/{session_id}/state", tags=["ADK API"])
+    async def get_session_state(user_id: str, session_id: str):
+        try:
+            session = await Application.session_service.get_session(
+                app_name=Application.agent_app_name,
+                user_id=user_id,
+                session_id=session_id,
+            )
+            if not session:
+                raise HTTPException(status_code=404, detail="Session not found")
+
+            return {"state": Application.safe_jsonable(session.state)}
+
+        except HTTPException:
+            raise
+        except Exception as e:
+            logging.exception("get_session_state failed")
+            raise HTTPException(status_code=500, detail=str(e))
+        
+def main():
+    global server_config
+    logging.basicConfig(
+        level=logging.INFO, format="%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s",
+        stream=sys.stderr
+    )
+    uvicorn.run(Application.api, host=server_config.host, port=server_config.port)
+
+
+if __name__ == '__main__':
+    main()

agent_server/agui_server.py

@@ -0,0 +1,69 @@
+import sys
+import logging
+# logging.basicConfig(
+#     level=logging.INFO,
+#     format="%(asctime)s %(levelname)s [%(name)s] %(message)s",
+# )
+import uvicorn
+from dotenv import dotenv_values
+from fastapi import FastAPI
+from ag_ui_adk import add_adk_fastapi_endpoint
+from .utils import Utils
+
+config = dotenv_values(".server.env")
+server_config = Utils.Server.ServerConfig(
+    agents_path=config.get("AGENTS_PATH", ""),
+    session_service_uri=config.get("SESSION_SERVICE_URI", ""),
+    memory_service_uri=config.get("MEMORY_SERVICE_URI", ""),
+    user_service_uri=config.get("USER_SERVICE_URI", ""),
+    trace_service_uri=config.get("TRACE_SERVICE_URI", ""),
+    host=config.get("HOST", "0.0.0.0"),
+    port=int(config.get("PORT", "8000"))
+)
+
+
+class Application:
+    global server_config
+    api = FastAPI(title=f"{Utils.Agent.agent_name} AGUI Server")
+    api.add_middleware(Utils.Server.UserWhitelistMiddleware)
+    agent_agui_runner = Utils.Agent.create_adk_agent_agui_runner(
+        agents_path=server_config.agents_path,
+        session_service_uri=server_config.session_service_uri,
+        memory_service_uri=server_config.memory_service_uri
+    )
+    if agent_agui_runner is None:
+        raise Exception("Agent load failed")
+
+    add_adk_fastapi_endpoint(api, agent_agui_runner, path="/agui/api/v1/chat/completions")
+
+    @staticmethod
+    @api.get("/agui/api/v1/reload")
+    async def reload():
+        Application.agent_agui_runner = Utils.Agent.create_adk_agent_agui_runner(
+            agents_path=server_config.agents_path,
+            session_service_uri=server_config.session_service_uri,
+            memory_service_uri=server_config.memory_service_uri
+        )
+        if Application.agent_agui_runner is None:
+            logging.error("Failed to load agents")
+            return {"code": 10000, "message": "Failed to load agents", "data": ""}
+
+        return {"code": 0, "message": "", "data": "OK"}
+
+    @staticmethod
+    @api.get("/agui/api/v1/health")
+    async def health_check():
+        return {"code": 0, "message": "", "data": "OK"}
+
+
+def main():
+    global server_config
+    logging.basicConfig(
+        level=logging.INFO, format="%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s",
+        stream=sys.stderr
+    )
+    uvicorn.run(Application.api, host=server_config.host, port=server_config.port)
+
+
+if __name__ == '__main__':
+    main()

agent_server/cmd_server.py

@@ -0,0 +1,340 @@
+import uuid
+import json
+import asyncio
+from dataclasses import dataclass, field
+from typing import Optional, Dict, List
+from dotenv import dotenv_values
+# import logging
+# logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+from rich.console import Console
+from rich.markdown import Markdown
+
+from google.adk.runners import Runner
+from google.adk.sessions import BaseSessionService
+from google.genai import types
+
+from .utils import Utils
+
+
+@dataclass
+class JobRecord:
+    job_id: str
+    session_id: str
+    prompt: str
+    task: Optional[asyncio.Task] = None
+    done: bool = False
+    error: Optional[str] = None
+    buffer: List[str] = field(default_factory=list)
+
+
+class AgentRunner:
+    def __init__(self) -> None:
+        self.user_id = "cmd-user"
+        self.console = Console()
+        config = dotenv_values(".server.env")
+        server_config = Utils.Server.ServerConfig(
+            agents_path=config.get("AGENTS_PATH", ""),
+            session_service_uri=config.get("SESSION_SERVICE_URI", ""),
+            memory_service_uri=config.get("MEMORY_SERVICE_URI", ""),
+            user_service_uri=config.get("USER_SERVICE_URI", ""),
+            trace_service_uri=config.get("TRACE_SERVICE_URI", ""),
+            host=config.get("HOST", "0.0.0.0"),
+            port=int(config.get("PORT", "8000"))
+        )
+        self.runner: Runner = Utils.Agent.create_adk_agent_adk_runner(
+            agents_path=server_config.agents_path,
+            session_service_uri=server_config.session_service_uri,
+            memory_service_uri=server_config.memory_service_uri,
+        )
+        self.runner.auto_create_session = True
+        self.session_service: BaseSessionService = self.runner.session_service
+
+        self.jobs: Dict[str, JobRecord] = {}
+        self.foreground_job_id: Optional[str] = None
+
+    @staticmethod
+    def print_banner():
+        banner = r"""
+         █████╗  ██████╗ ███████╗███╗   ██╗████████╗    ██████╗ ███████╗
+        ██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝   ██╔═══██╗██╔════╝
+        ███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║      ██║   ██║███████╗
+        ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║      ██║   ██║╚════██║
+        ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║      ╚██████╔╝███████║
+        ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝       ╚═════╝ ╚══════╝
+
+                              ██████╗ ███████╗
+                             ██╔═══██╗██╔════╝
+                             ██║   ██║███████╗
+                             ██║   ██║╚════██║
+                             ╚██████╔╝███████║
+                              ╚═════╝ ╚══════╝
+        """
+        print(banner)
+
+    def render_output(self, text: str):
+        self.console.print(Markdown(text), justify="left")
+
+    def format_part(self, part: types.Part) -> Optional[str]:
+        if part.text is not None and part.text != "" and part.thought is True:
+            return f"===\n* **分析**\n{part.text}"
+
+        if part.text is not None and part.text != "" and (part.thought is None or part.thought is False):
+            return f"===\n* **答案**\n{part.text}"
+
+        if part.function_call is not None:
+            try:
+                params_json = json.dumps(part.function_call.args, indent=2, ensure_ascii=False)
+            except Exception:
+                params_json = str(part.function_call.args)
+
+            return (
+                f"===\n* **工具调用**\n"
+                f"- 工具名：{part.function_call.name}\n"
+                f"- 工具参数：\n```python\n{params_json}\n```"
+            )
+
+        if part.function_response is not None:
+            try:
+                response_json = json.dumps(part.function_response.response, indent=2, ensure_ascii=False)
+            except Exception:
+                response_json = str(part.function_response.response)
+
+            return (
+                f"===\n* **工具调用返回结果**\n"
+                f"- 工具名：{part.function_response.name}\n"
+                f"- 工具返回结果：\n```json\n{response_json}\n```"
+            )
+
+        return None
+
+    def _emit_to_job(self, job: JobRecord, text: str):
+        job.buffer.append(text)
+
+        # 只有当前前台任务才实时显示
+        if self.foreground_job_id == job.job_id:
+            self.render_output(text)
+
+    async def submit_job(self, input_text: str) -> str:
+        job_id = uuid.uuid4().hex[:8]
+        session_id = uuid.uuid4().hex
+
+        job = JobRecord(
+            job_id=job_id,
+            session_id=session_id,
+            prompt=input_text,
+        )
+        self.jobs[job_id] = job
+
+        job.task = asyncio.create_task(self._run_job(job))
+        return job_id
+
+    async def _run_job(self, job: JobRecord):
+        content = types.Content(role="user", parts=[types.Part(text=job.prompt)])
+
+        try:
+            async for chunk in self.runner.run_async(
+                user_id=self.user_id,
+                session_id=job.session_id,
+                new_message=content,
+            ):
+                for part in chunk.content.parts:
+                    rendered = self.format_part(part)
+                    if rendered:
+                        self._emit_to_job(job, rendered)
+
+            job.done = True
+            if self.foreground_job_id == job.job_id:
+                self.render_output(f"===\n* **任务完成**\n- job_id：`{job.job_id}`")
+        except asyncio.CancelledError:
+            job.done = True
+            job.error = "cancelled"
+            raise
+        except Exception as e:
+            job.done = True
+            job.error = str(e)
+            err_text = f"===\n* **任务异常**\n- job_id：`{job.job_id}`\n- 错误：```text\n{type(e).__name__}: {e}\n```"
+            self._emit_to_job(job, err_text)
+
+    async def _list_sessions_raw(self):
+        resp = await self.session_service.list_sessions(
+            app_name=self.app_name,
+            user_id=self.user_id,
+        )
+        if hasattr(resp, "sessions"):
+            return resp.sessions
+        return resp or []
+
+    async def show_sessions(self):
+        sessions = await self._list_sessions_raw()
+
+        if not sessions:
+            self.render_output("当前没有 session。")
+            return
+
+        lines = ["===\n* **Session 列表**"]
+        for s in sessions:
+            sid = getattr(s, "session_id", None) or getattr(s, "id", None) or str(s)
+            uid = getattr(s, "user_id", self.user_id)
+            app = getattr(s, "app_name", self.app_name)
+            lines.append(f"- session_id=`{sid}` | user=`{uid}` | app=`{app}`")
+        self.render_output("\n".join(lines))
+
+    async def delete_session(self, session_id: str):
+        # 如果该 session 对应的 job 还在运行，先取消任务并从内存中移除
+        for job_id, job in list(self.jobs.items()):
+            if job.session_id == session_id:
+                if job.task and not job.task.done():
+                    job.task.cancel()
+                if self.foreground_job_id == job_id:
+                    self.foreground_job_id = None
+                self.jobs.pop(job_id, None)
+                break
+
+        await self.session_service.delete_session(
+            app_name=self.app_name,
+            user_id=self.user_id,
+            session_id=session_id,
+        )
+
+        self.render_output(f"===\n* **已删除 Session**\n- session_id：`{session_id}`")
+
+    async def delete_job(self, job_id: str):
+        job = self.jobs.get(job_id)
+        if not job:
+            self.render_output(f"===\n* **错误**\n未找到 job：`{job_id}`")
+            return
+
+        if job.task and not job.task.done():
+            job.task.cancel()
+
+        await self.session_service.delete_session(
+            app_name=self.app_name,
+            user_id=self.user_id,
+            session_id=job.session_id,
+        )
+
+        if self.foreground_job_id == job_id:
+            self.foreground_job_id = None
+
+        self.jobs.pop(job_id, None)
+        self.render_output(
+            f"===\n* **已删除 Job 对应 Session**\n- job_id：`{job_id}`\n- session_id：`{job.session_id}`"
+        )
+
+    async def cancel_job(self, job_id: str):
+        job = self.jobs.get(job_id)
+        if not job:
+            self.render_output(f"===\n* **错误**\n未找到 job：`{job_id}`")
+            return
+
+        if job.task and not job.task.done():
+            job.task.cancel()
+            self.render_output(f"===\n* **已取消任务**\n- job_id：`{job_id}`")
+        else:
+            self.render_output(f"===\n* **任务已结束**\n- job_id：`{job_id}`")
+
+    def show_jobs(self):
+        if not self.jobs:
+            self.render_output("当前没有任务。")
+            return
+
+        lines = ["===\n* **任务列表**"]
+        for jid, job in self.jobs.items():
+            status = "done" if job.done else "running"
+            if job.error == "cancelled":
+                status = "cancelled"
+            elif job.error:
+                status = "error"
+            fg = " ← 前台" if self.foreground_job_id == jid else ""
+            lines.append(
+                f"- `{jid}` | `{status}` | session=`{job.session_id}`{fg}"
+            )
+        self.render_output("\n".join(lines))
+
+    async def bring_to_foreground(self, job_id: str):
+        job = self.jobs.get(job_id)
+        if not job:
+            self.render_output(f"===\n* **错误**\n未找到 job：`{job_id}`")
+            return
+
+        self.foreground_job_id = job_id
+        self.render_output(f"===\n* **切换前台**\n- 当前前台 job：`{job_id}`")
+
+        # 重放历史输出
+        if job.buffer:
+            self.render_output(f"===\n* **历史输出重放**\n- job：`{job_id}`")
+            for item in job.buffer:
+                self.render_output(item)
+
+    def send_to_background(self):
+        self.foreground_job_id = None
+        self.render_output("===\n* **已切回后台模式**")
+
+
+async def run_main():
+    agent_runner = AgentRunner()
+    agent_runner.print_banner()
+    agent_runner.render_output(
+        "输入自然语言即提交一个任务；\n"
+        "`/jobs` 查看任务；`/sessions` 查看 session；\n"
+        "`/fg <job_id>` 切前台；`/bg` 回后台；\n"
+        "`/del <session_id>` 删除 session；`/deljob <job_id>` 删除 job 对应 session；\n"
+        "`/cancel <job_id>` 取消任务；`exit` `bye` `quit` 退出。"
+    )
+
+    while True:
+        try:
+            # 不阻塞事件循环：后台任务可以继续并发跑
+            input_text = await asyncio.to_thread(input, "\n> ")
+            input_text = input_text.strip()
+
+            if not input_text:
+                continue
+
+            if input_text.lower() in {"bye", "exit", "quit"}:
+                break
+
+            if input_text == "/jobs":
+                agent_runner.show_jobs()
+                continue
+
+            if input_text == "/sessions":
+                await agent_runner.show_sessions()
+                continue
+
+            if input_text.startswith("/fg "):
+                job_id = input_text.split(maxsplit=1)[1].strip()
+                await agent_runner.bring_to_foreground(job_id)
+                continue
+
+            if input_text == "/bg":
+                agent_runner.send_to_background()
+                continue
+
+            if input_text.startswith("/deljob "):
+                job_id = input_text.split(maxsplit=1)[1].strip()
+                await agent_runner.delete_job(job_id)
+                continue
+
+            if input_text.startswith("/del "):
+                session_id = input_text.split(maxsplit=1)[1].strip()
+                await agent_runner.delete_session(session_id)
+                continue
+
+            if input_text.startswith("/cancel "):
+                job_id = input_text.split(maxsplit=1)[1].strip()
+                await agent_runner.cancel_job(job_id)
+                continue
+
+            job_id = await agent_runner.submit_job(input_text)
+            agent_runner.render_output(f"===\n* **已提交任务**\n- job_id：`{job_id}`")
+        except (EOFError, KeyboardInterrupt):
+            print("\n已退出。")
+            break
+
+def main():
+    asyncio.run(run_main())
+
+if __name__ == "__main__":
+    main()

agent_server/utils.py

@@ -0,0 +1,154 @@
+import os
+import logging
+from pydantic import BaseModel
+from fastapi import Request
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import Response
+from google.adk.agents import BaseAgent
+from google.adk.memory import InMemoryMemoryService, BaseMemoryService
+from google.adk.sessions import DatabaseSessionService, InMemorySessionService, BaseSessionService
+from google.adk.runners import Runner
+from ag_ui_adk import ADKAgent
+
+
+class Utils:
+    class Service:
+        @staticmethod
+        def memory_service(db_uri: str) -> BaseMemoryService | None:
+            """
+            Memory服务
+            """
+            if db_uri is None:
+                return None
+
+            if db_uri == "":
+                return InMemoryMemoryService()
+
+            return InMemoryMemoryService()
+
+
+        @staticmethod
+        def session_service(db_url: str) -> BaseSessionService | None:
+            """Session服务"""
+            if db_url is None:
+                return None
+
+            if db_url == "":
+                return InMemorySessionService()
+
+            return DatabaseSessionService(db_url=db_url)
+
+    class Agent:
+        agent_name = "AgentOS"
+        @staticmethod
+        def load_adk_agents(agents_path: str) -> BaseAgent | None:
+            """
+            加载智能体配置
+            :param agents_path:
+            :return:
+            """
+            try:
+                import sys
+                sys.path.append(str(agents_path))
+                from agents import root_agent
+                return root_agent
+            except Exception as e:
+                logging.error(f"Failed to load agents {e}")
+                return None
+
+        @staticmethod
+        def create_adk_agent_agui_runner(
+                agents_path: str,
+                session_service_uri: str,
+                memory_service_uri: str
+        ) -> ADKAgent | None:
+            """
+            加载智能体配置
+            """
+            agent: BaseAgent = Utils.Agent.load_adk_agents(agents_path)
+            if agent is not None:
+                return ADKAgent(
+                    adk_agent=agent,
+                    app_name=f"{Utils.Agent.agent_name} AGUI APP",
+                    session_service=Utils.Service.session_service(db_url=session_service_uri),
+                    memory_service=Utils.Service.memory_service(db_uri=memory_service_uri),
+                )
+
+            return None
+
+
+        @staticmethod
+        def create_adk_agent_adk_runner(
+                agents_path: str,
+                session_service_uri: str,
+                memory_service_uri: str
+        ) -> Runner | None:
+            """
+            加载智能体配置
+            """
+            agent: BaseAgent = Utils.Agent.load_adk_agents(agents_path)
+            if agent is not None:
+                return Runner(
+                    agent=agent,
+                    app_name=f"{Utils.Agent.agent_name} ADK APP",
+                    session_service=Utils.Service.session_service(db_url=session_service_uri),
+                    memory_service=Utils.Service.memory_service(db_uri=memory_service_uri),
+                    auto_create_session=False,
+                )
+
+            return None
+
+
+    class Server:
+        class UserWhitelistMiddleware(BaseHTTPMiddleware):
+            ALLOWED_USERS = {"alice", "bob", "charlie@example.com"}
+
+            async def dispatch(self, request: Request, call_next):
+                # 1. 可选：定义路由白名单，用于跳过验证的端点
+                # 例如，一个公开的 /health 端点，无需用户验证
+                if request.url.path in [
+                    "/agui/api/v1/health",
+                    "/agui/api/v1/reload",
+                    "/agui/api/v1/chat/completions",
+                    "/adk/api/v1/health",
+                    "/adk/api/v1/reload",
+                    "/adk/api/v1/chat/completions",
+                    "/docs", "/openapi.json"
+                ]:
+                    return await call_next(request)
+
+                # 2. 提取并验证用户ID
+                user_id = request.headers.get("X-User-Id")
+                if not user_id:
+                    logging.warning(f"拒绝访问: 未提供用户ID，来自 {request.client.host}")
+                    return Response("未授权: 缺少用户身份标识", status_code=401)
+
+                if user_id not in Utils.Server.UserWhitelistMiddleware.ALLOWED_USERS:
+                    logging.warning(f"拒绝访问: 用户 '{user_id}' 不在白名单内，来自 {request.client.host}")
+                    return Response(f"禁止访问: 用户 '{user_id}' 无权限", status_code=403)
+
+                # 3. 用户在白名单内，记录日志并继续处理请求
+                logging.info(f"用户 '{user_id}' 通过白名单验证")
+                return await call_next(request)
+
+        class ServerConfig(BaseModel):
+            # 智能体配置文件夹
+            agents_path: str
+
+            # session服务URI
+            session_service_uri: str
+
+            # memory服务URI
+            memory_service_uri: str
+
+            # 用户服务URI
+            user_service_uri: str
+
+            # trace service URI
+            trace_service_uri: str
+
+            # host
+            host: str
+
+            # port
+            port: int