union-app-chat-stream 1.1.6

package/app/asgi.py

@@ -0,0 +1,139 @@
+"""创建 Starlette ASGI 应用并组装配置、运行时与 HTTP 路由。"""
+
+from __future__ import annotations
+
+import logging
+import os
+from contextlib import asynccontextmanager
+from functools import lru_cache
+from typing import Any
+
+import httpx
+import logfire
+from dotenv import load_dotenv
+from starlette.applications import Starlette
+
+from app.agent.graph import AgentGraph, build_agent_graph
+from app.agent.runtime.execution import ExecutionCoordinator
+from app.agent.runtime.model import build_model
+from app.config.settings import AgentSettings
+from app.views.routes import RouteError, build_routes, http_error
+
+
+@lru_cache(maxsize=1)
+def _configure_observability(environment: str) -> None:
+    level = getattr(logging, os.getenv("LOG_LEVEL", "INFO").upper(), logging.INFO)
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s %(levelname)s %(name)s %(message)s",
+    )
+    logfire.configure(
+        send_to_logfire=False,
+        service_name="union-py-app",
+        environment=environment,
+        inspect_arguments=False,
+    )
+
+
+class Runtime:
+    def __init__(
+        self,
+        *,
+        settings: AgentSettings,
+        http: httpx.AsyncClient,
+        graph: AgentGraph,
+        rag_service: Any | None,
+    ) -> None:
+        self.settings = settings
+        self.http = http
+        self.graph = graph
+        self.rag_service = rag_service
+        self.executions = ExecutionCoordinator(
+            max_run_seconds=settings.max_run_seconds,
+        )
+
+
+def _rag_service(settings: AgentSettings):
+    if not settings.rag_enabled:
+        return None
+    from app.service.rag_service import RagService
+
+    return RagService(
+        {
+            "RAG_ENABLED": settings.rag_enabled,
+            "RAG_TOP_K": settings.rag_top_k,
+            "RAG_KNOWLEDGE_DIR": settings.rag_knowledge_dir,
+            "RAG_COLLECTION": settings.rag_collection,
+            "LLM_URL": settings.llm_url,
+            "LLM_KEY": settings.llm_key,
+            "RAG_EMBEDDING_MODEL": settings.rag_embedding_model,
+            "RAG_CHUNK_SIZE": settings.rag_chunk_size,
+        }
+    )
+
+
+def create_app(
+    *,
+    settings: AgentSettings | None = None,
+    model: Any | None = None,
+    http: httpx.AsyncClient | None = None,
+    rag_service: Any | None = None,
+) -> Starlette:
+    environment = os.getenv("APP_ENV", "dev")
+    if settings is None:
+        load_dotenv(
+            os.path.join(
+                os.path.dirname(__file__),
+                "config",
+                "env",
+                f".env.{environment}",
+            ),
+            override=False,
+        )
+    _configure_observability(environment)
+    configured = settings or AgentSettings.from_env()
+
+    @asynccontextmanager
+    async def lifespan(app: Starlette):
+        shared_http = http or httpx.AsyncClient(
+            limits=httpx.Limits(
+                max_connections=100,
+                max_keepalive_connections=20,
+            ),
+            follow_redirects=False,
+        )
+        agent_model = model or build_model(configured, shared_http)
+        graph = build_agent_graph(
+            agent_model,
+            configured,
+            router_model=(
+                model or build_model(configured, shared_http, thinking=False)
+            ),
+        )
+        runtime = Runtime(
+            settings=configured,
+            http=shared_http,
+            graph=graph,
+            rag_service=(
+                rag_service
+                if rag_service is not None
+                else _rag_service(configured)
+            ),
+        )
+        app.state.runtime = runtime
+        await runtime.executions.startup()
+        try:
+            yield
+        finally:
+            await runtime.executions.close()
+            if http is None:
+                await shared_http.aclose()
+
+    return Starlette(
+        lifespan=lifespan,
+        routes=build_routes(),
+        exception_handlers={RouteError: http_error},
+    )
+
+
+app = create_app()

package/app/config/__init__.py

@@ -0,0 +1 @@
+"""存放应用配置模型及环境配置文件。"""

package/app/config/settings.py

@@ -0,0 +1,67 @@
+"""读取并校验应用运行所需的环境变量配置。"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+
+def _integer(name: str, default: int) -> int:
+    try:
+        return int(os.getenv(name, str(default)))
+    except ValueError:
+        return default
+
+
+def _floating(name: str, default: float) -> float:
+    try:
+        return float(os.getenv(name, str(default)))
+    except ValueError:
+        return default
+
+
+@dataclass(frozen=True)
+class AgentSettings:
+    union_base_url: str
+    llm_url: str
+    llm_key: str
+    llm_model: str
+    llm_context_window: int
+    request_limit: int
+    tool_calls_limit: int
+    input_tokens_limit: int
+    output_tokens_limit: int
+    tool_timeout_seconds: float
+    subagent_timeout_seconds: float
+    max_run_seconds: float
+    required_permission: str
+    rag_enabled: bool
+    rag_knowledge_dir: str
+    rag_collection: str
+    rag_embedding_model: str
+    rag_top_k: int
+    rag_chunk_size: int
+
+    @classmethod
+    def from_env(cls) -> AgentSettings:
+        return cls(
+            union_base_url=os.getenv("UNION_BASE_URL", "http://127.0.0.1:8080").rstrip("/"),
+            llm_url=os.getenv("LLM_URL", "").rstrip("/"),
+            llm_key=os.getenv("LLM_KEY", ""),
+            llm_model=os.getenv("LLM_MODEL", ""),
+            llm_context_window=_integer("LLM_CONTEXT_WINDOW", 131072),
+            request_limit=_integer("AGENT_REQUEST_LIMIT", 30),
+            tool_calls_limit=_integer("AGENT_TOOL_CALLS_LIMIT", 40),
+            input_tokens_limit=_integer("AGENT_INPUT_TOKENS_LIMIT", 120000),
+            output_tokens_limit=_integer("AGENT_OUTPUT_TOKENS_LIMIT", 16000),
+            tool_timeout_seconds=_floating("AGENT_TOOL_TIMEOUT_SECONDS", 300.0),
+            subagent_timeout_seconds=_floating("SUBAGENT_TIMEOUT_SECONDS", 900.0),
+            max_run_seconds=_floating("AGENT_MAX_RUN_SECONDS", 900.0),
+            required_permission=os.getenv("PERMISSIONS", ""),
+            rag_enabled=os.getenv("RAG_ENABLED", "true").lower() in {"1", "true", "yes", "on"},
+            rag_knowledge_dir=os.getenv("RAG_KNOWLEDGE_DIR", "knowledge"),
+            rag_collection=os.getenv("RAG_COLLECTION", "ops_knowledge"),
+            rag_embedding_model=os.getenv("RAG_EMBEDDING_MODEL", "embedding-3"),
+            rag_top_k=_integer("RAG_TOP_K", 5),
+            rag_chunk_size=_integer("RAG_CHUNK_SIZE", 1200),
+        )

package/app/memory/__init__.py

@@ -0,0 +1 @@
+"""存放 Agent 个人记忆的存储适配实现。"""

package/app/memory/store.py

@@ -0,0 +1,154 @@
+"""将远端记忆接口适配为 Harness 记忆存储协议。"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic_ai_harness.memory import (
+    MemoryConflictError,
+    MemoryFile,
+    MemoryMutation,
+    MemoryOperation,
+    MemoryOperationConflictError,
+    MemorySearchMatch,
+    MemorySearchResult,
+)
+
+from app.utils.state_client import AgentStateClient, AgentStateError
+
+
+class AgentMemoryStore:
+    """HTTP adapter for the official SearchableMemoryStore protocol."""
+
+    def __init__(self, state_client: AgentStateClient) -> None:
+        self._state_client = state_client
+
+    async def _call(self, action: str, payload: dict[str, Any]) -> dict[str, Any]:
+        body = await self._state_client.post(f"/agent/memoryStore/{action}", payload)
+        code = body.get("errorCode")
+        if code == "version_conflict":
+            raise MemoryConflictError(body.get("errorMsg", "memory version conflict"))
+        if code == "operation_conflict":
+            raise MemoryOperationConflictError(body.get("errorMsg", "memory operation conflict"))
+        if body.get("success") is False:
+            raise AgentStateError(body.get("errorMsg", "memory store request failed"))
+        return body
+
+    async def read(self, path: str, *, max_chars: int) -> MemoryFile | None:
+        body = await self._call("read", {"path": path, "maxChars": max_chars})
+        item = body.get("file")
+        if item is None:
+            return None
+        return MemoryFile(
+            content=str(item["content"]),
+            version=str(item["version"]),
+            operation_id=item.get("operationId"),
+            truncated=bool(item.get("truncated", False)),
+        )
+
+    async def list_paths(self, prefix: str = "", *, limit: int) -> list[str]:
+        body = await self._call("list", {"prefix": prefix, "limit": limit})
+        return [str(path) for path in body.get("paths", [])]
+
+    async def get_operation(self, operation: MemoryOperation) -> MemoryMutation | None:
+        body = await self._call(
+            "operation",
+            {"operationId": operation.id, "fingerprint": operation.fingerprint},
+        )
+        return self._mutation(body.get("mutation"))
+
+    async def write(
+        self,
+        path: str,
+        content: str,
+        *,
+        expected_version: str | None,
+        operation: MemoryOperation | None = None,
+    ) -> MemoryMutation:
+        return self._required_mutation(
+            await self._call(
+                "write",
+                {
+                    "path": path,
+                    "content": content,
+                    "expectedVersion": expected_version,
+                    "operation": self._operation(operation),
+                },
+            )
+        )
+
+    async def delete(
+        self,
+        path: str,
+        *,
+        expected_version: str | None,
+        operation: MemoryOperation | None = None,
+    ) -> MemoryMutation:
+        return self._required_mutation(
+            await self._call(
+                "delete",
+                {
+                    "path": path,
+                    "expectedVersion": expected_version,
+                    "operation": self._operation(operation),
+                },
+            )
+        )
+
+    async def search(
+        self,
+        prefix: str,
+        query: str,
+        *,
+        limit: int,
+        max_files: int,
+        max_chars: int,
+        max_file_chars: int,
+    ) -> MemorySearchResult:
+        body = await self._call(
+            "search",
+            {
+                "prefix": prefix,
+                "query": query,
+                "limit": limit,
+                "maxFiles": max_files,
+                "maxChars": max_chars,
+                "maxFileChars": max_file_chars,
+            },
+        )
+        result = body.get("result") or {}
+        return MemorySearchResult(
+            matches=[
+                MemorySearchMatch(
+                    path=str(item["path"]),
+                    snippet=str(item["snippet"]),
+                    score=float(item["score"]),
+                )
+                for item in result.get("matches", [])
+            ],
+            scanned=int(result.get("scanned", 0)),
+            truncated=bool(result.get("truncated", False)),
+        )
+
+    @staticmethod
+    def _operation(operation: MemoryOperation | None) -> dict[str, str] | None:
+        if operation is None:
+            return None
+        return {"id": operation.id, "fingerprint": operation.fingerprint}
+
+    @staticmethod
+    def _mutation(value: Any) -> MemoryMutation | None:
+        if value is None:
+            return None
+        return MemoryMutation(
+            version=str(value["version"]) if value.get("version") is not None else None,
+            replayed=bool(value.get("replayed", False)),
+            existed=bool(value.get("existed", False)),
+        )
+
+    @classmethod
+    def _required_mutation(cls, body: dict[str, Any]) -> MemoryMutation:
+        mutation = cls._mutation(body.get("mutation"))
+        if mutation is None:
+            raise AgentStateError("state service omitted memory mutation result")
+        return mutation