aethergraph 0.1.0a1__py3-none-any.whl → 0.1.0a2__py3-none-any.whl

aethergraph/runtime/__init__.py

@@ -1,6 +1,14 @@
 # redirect runtime service imports for clean imports
 
 from aethergraph.core.runtime.ad_hoc_context import open_session
+from aethergraph.core.runtime.run_manager import RunManager
+from aethergraph.core.runtime.run_types import (
+    RunImportance,
+    RunOrigin,
+    RunRecord,
+    RunStatus,
+    RunVisibility,
+)
 from aethergraph.core.runtime.runtime_services import (
     # logger service helpers
     current_logger_factory,
@@ -59,4 +67,11 @@ __all__ = [
     "list_mcp_clients",
     # ad-hoc context
     "open_session",
+    # run manager and types
+    "RunManager",
+    "RunRecord",
+    "RunStatus",
+    "RunOrigin",
+    "RunImportance",
+    "RunVisibility",
 ]

aethergraph/server/app_factory.py

@@ -1,16 +1,40 @@
 import asyncio
+from contextlib import asynccontextmanager, suppress
+import logging
+import os
+from pathlib import Path
 from typing import Optional
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-
+from fastapi.responses import FileResponse, PlainTextResponse
+from fastapi.staticfiles import StaticFiles
+
+from aethergraph.api.v1.agents import router as agents_router
+from aethergraph.api.v1.apps import router as apps_router
+from aethergraph.api.v1.artifacts import router as artifacts_router
+from aethergraph.api.v1.graphs import router as graphs_router
+from aethergraph.api.v1.identity import router as identity_router
+from aethergraph.api.v1.memory import router as memory_router
+from aethergraph.api.v1.misc import router as misc_router
+from aethergraph.api.v1.runs import router as runs_router
+from aethergraph.api.v1.session import router as session_router
+from aethergraph.api.v1.stats import router as stats_router
+from aethergraph.api.v1.viz import router as vis_router
+
+# include apis
 from aethergraph.config.config import AppSettings
-from aethergraph.utils.optdeps import require
+from aethergraph.core.runtime.runtime_services import install_services
 
-from ..core.runtime.runtime_services import install_services
+# import built-in agents and plugins to register them
+from aethergraph.plugins.agents.default_chat_agent import *  # noqa: F403
 
 # channel routes
-from ..services.container.default_container import build_default_container
+from aethergraph.server.loading import GraphLoader, LoadSpec
+from aethergraph.services.container.default_container import build_default_container
+from aethergraph.utils.optdeps import require
+
+logger = logging.getLogger(__name__)
 
 
 def create_app(
@@ -23,40 +47,23 @@ def create_app(
     Builds the FastAPI app, registers routers, and installs all services
     into app.state.container (and globally via install_services()).
     """
-    app = FastAPI(title="AetherGraph Sidecar", version="0.1")
-
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=["http://localhost:5173"],  # dev UI origin
-        allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
 
-    # Resolve settings early, so we can conditionally include routers
+    # Resolve settings and container up front so lifespan can capture them
     settings = cfg or AppSettings()
-    app.state.settings = settings
-
-    # --- Routers (HTTP transports) ---
-    # For now, we can just always include; or gate it with a flag like settings.slack.use_webhook.
-    # app.include_router(slack_router)     # HTTP /slack/events + /slack/interact
-    # app.include_router(console_router)
-    # app.include_router(telegram_router)
-    # app.include_router(webui_router)
-
-    # override log level in config
     settings.logging.level = log_level
 
-    # ---- Services container ----
     container = build_default_container(root=workspace, cfg=settings)
-    app.state.container = container
 
-    # install globally so run()/tools see the same services
-    install_services(container)
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        # --- Startup: attach settings/container and start external transports ---
+        app.state.settings = settings
+        app.state.container = container
+
+        slack_task = None
+        tg_task = None
 
-    # ---- External channel transports (Socket Mode, polling, etc.) ----
-    @app.on_event("startup")
-    async def start_external_transports():
+        # Slack Socket Mode
         slack_cfg = settings.slack
         if (
             slack_cfg
@@ -70,15 +77,164 @@ def create_app(
 
             runner = SlackSocketModeRunner(container=container, settings=settings)
             app.state.slack_socket_runner = runner
-            asyncio.create_task(runner.start())
+            slack_task = asyncio.create_task(runner.start())
 
-        # Telegram polling for local / dev
+        # Telegram polling
         tg_cfg = settings.telegram
         if tg_cfg and tg_cfg.enabled and tg_cfg.polling_enabled and tg_cfg.bot_token:
             from ..plugins.channel.websockets.telegram_polling import TelegramPollingRunner
 
             tg_runner = TelegramPollingRunner(container=container, settings=settings)
             app.state.telegram_polling_runner = tg_runner
-            asyncio.create_task(tg_runner.start())
+            tg_task = asyncio.create_task(tg_runner.start())
+
+        try:
+            # Hand control back to FastAPI / TestClient
+            yield
+        finally:
+            # --- Shutdown: best-effort cleanup of background tasks ---
+            for task in (slack_task, tg_task):
+                if task is not None and not task.done():
+                    task.cancel()
+                    # swallow cancellation errors
+                    with suppress(asyncio.CancelledError):
+                        await task
+
+    # Create app with lifespan
+    app = FastAPI(
+        title="AetherGraph Sidecar",
+        version="0.1",
+        lifespan=lifespan,
+    )
 
+    frontend_dir = Path(__file__).parent / "ui_static"
+    if frontend_dir.exists():
+        logger.info(f"Serving built frontend UI from {frontend_dir}")
+        logger.info("UI will be available at: http://<host>:<port>/ui")
+
+        # 1) Serve built assets under /ui/assets
+        assets_dir = frontend_dir / "assets"
+        if assets_dir.exists():
+            app.mount(
+                "/ui/assets",
+                StaticFiles(directory=str(assets_dir)),
+                name="ui_assets",
+            )
+
+        index_path = frontend_dir / "index.html"
+
+        # 2) SPA catch-all: /ui and ANY /ui/... path -> index.html
+        @app.get("/ui", include_in_schema=False)
+        @app.get("/ui/{full_path:path}", include_in_schema=False)
+        async def serve_ui(full_path: str = ""):
+            if index_path.exists():
+                return FileResponse(index_path)
+            return PlainTextResponse(
+                "UI bundle not found. Please build the frontend and copy it to ui_static.",
+                status_code=501,
+            )
+
+    else:
+        logger.warning(
+            "AetherGraph UI bundle NOT found at %s. "
+            "The /ui endpoint will return a 501 until you build and copy it.",
+            frontend_dir,
+        )
+
+        @app.get("/ui", include_in_schema=False)
+        async def ui_not_built():
+            return PlainTextResponse(
+                "UI bundle not found. Please build the frontend and copy it to ui_static.",
+                status_code=501,
+            )
+
+    # CORS
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["http://localhost:5173"],  # dev UI origin
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Routers
+    app.include_router(router=runs_router, prefix="/api/v1")
+    app.include_router(router=graphs_router, prefix="/api/v1")
+    app.include_router(router=artifacts_router, prefix="/api/v1")
+    app.include_router(router=memory_router, prefix="/api/v1")
+    app.include_router(router=stats_router, prefix="/api/v1")
+    app.include_router(router=identity_router, prefix="/api/v1")
+    app.include_router(router=misc_router, prefix="/api/v1")
+    app.include_router(router=vis_router, prefix="/api/v1")
+    app.include_router(router=session_router, prefix="/api/v1")
+    app.include_router(router=apps_router, prefix="/api/v1")
+    app.include_router(router=agents_router, prefix="/api/v1")
+
+    # Webui router
+    from aethergraph.plugins.channel.routes.webui_routes import router as webui_router
+
+    app.include_router(router=webui_router, prefix="/api/v1")
+
+    # Install services globally so run()/tools see the same container
+    install_services(container)
+
+    # Optional: keep these for immediate access before lifespan runs
+    app.state.settings = settings
+    app.state.container = container
+
+    return app
+
+
+def _load_user_graphs_from_env() -> None:
+    """
+    Called inside each uvicorn worker to import user graphs based
+    on environment variables set by the CLI.
+    """
+    modules_str = os.environ.get("AETHERGRAPH_LOAD_MODULES", "")
+    paths_str = os.environ.get("AETHERGRAPH_LOAD_PATHS", "")
+    project_root_str = os.environ.get("AETHERGRAPH_PROJECT_ROOT", ".")
+    strict_str = os.environ.get("AETHERGRAPH_STRICT_LOAD", "0")
+
+    modules = [m for m in modules_str.split(",") if m]
+    paths = [Path(p) for p in paths_str.split(os.pathsep) if p]
+
+    project_root = Path(project_root_str).resolve()
+    strict = strict_str.lower() in ("1", "true", "yes")
+
+    spec = LoadSpec(
+        modules=modules,
+        paths=paths,
+        project_root=project_root,
+        strict=strict,
+    )
+
+    loader = GraphLoader()
+    report = loader.load(spec)
+
+    # Optional: log report.loaded / report.errors here if you like
+    print("🚀 [worker] Loaded user graphs:", report.loaded)
+    if report.errors:
+        for e in report.errors:
+            print(f"⚠️ [worker load error] {e.source}: {e.error}")
+
+
+def create_app_from_env() -> FastAPI:
+    """
+    Factory for uvicorn --reload / workers mode.
+    Reads workspace + graph load config from env, imports user graphs,
+    then builds the FastAPI app.
+    """
+    workspace = os.environ.get("AETHERGRAPH_WORKSPACE", "./aethergraph_data")
+    log_level = os.environ.get("AETHERGRAPH_LOG_LEVEL", "warning")
+
+    # 1) Load user graphs in *this* process
+    _load_user_graphs_from_env()
+
+    # 2) Build the app (your existing factory)
+    # If you have a config system, wire it here
+    app = create_app(
+        workspace=workspace,
+        cfg=None,  # or AppSettings.from_env(), etc.
+        log_level=log_level,
+    )
     return app

aethergraph/server/clients/channel_client.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Iterable
+import json
+from typing import Any
+
+import httpx
+import websockets
+
+
+class ChannelClient:
+    """
+    Convenience client for talking to a running AetherGraph server from Python.
+
+    - send_* methods: external -> AG (inbound to AG via /channel/incoming)
+    - iter_events():  AG -> external (outbound from AG via /ws/channel)
+
+    This is intentionally thin; real apps can wrap it with their own abstractions.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        scheme: str = "ext",
+        channel_id: str = "default",
+        thread_id: str | None = None,
+        timeout: float = 100.0,
+        api_key: str | None = None,  # currently unused
+        http_client: httpx.AsyncClient | None = None,  # managed externally if provided
+        ws_path: str = "/ws/channel",  # currently unused
+    ):
+        self.base_url = base_url
+        self.scheme = scheme
+        self.channel_id = channel_id
+        self.thread_id = thread_id
+        self.timeout = timeout
+        self.api_key = api_key
+        self.ws_path = ws_path
+
+        self._external_client = http_client
+        self._client: httpx.AsyncClient | None = None
+        self._owns_client = http_client is None
+
+    # ------------- internal helpers -------------
+    @property
+    def client(self) -> httpx.AsyncClient:
+        if self._external_client is not None:
+            return self._external_client
+        if self._client is None:
+            headers = {}
+            if self.api_key:
+                headers["Authorization"] = f"Bearer {self.api_key}"
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                headers=headers,
+                timeout=self.timeout,
+            )
+        return self._client
+
+    async def aclose(self):
+        if self._owns_client and self._client is not None:
+            await self._client.aclose()
+            self._client = None
+
+    def _default_thread_id(self, thread_id: str | None) -> str | None:
+        return thread_id if thread_id is not None else self.thread_id
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        """Get or create an httpx.AsyncClient."""
+        if self._external_client is not None:
+            return self._external_client
+        return httpx.AsyncClient(base_url=self.base_url, timeout=self.timeout)
+
+    # --------- Inbound to AG (HTTP) ---------
+    async def send_text(self, text: str, *, meta: dict[str, Any] | None = None) -> httpx.Response:
+        """
+        Send a text message into AG via /channel/incoming.
+        """
+        url = f"{self.base_url}/channel/incoming"
+        payload = {
+            "scheme": self.scheme,
+            "channel_id": self.channel_id,
+            "thread_id": self.thread_id,
+            "text": text,
+            "meta": meta or {},
+        }
+        r = await self.client.post(url, json=payload)
+        r.raise_for_status()
+        return r.json
+
+    async def send_choice(
+        self, choice: str, *, meta: dict[str, Any] | None = None
+    ) -> httpx.Response:
+        """
+        Send a choice/approval response into AG via /channel/incoming.
+        """
+        url = f"{self.base_url}/channel/incoming"
+        payload = {
+            "scheme": self.scheme,
+            "channel_id": self.channel_id,
+            "thread_id": self.thread_id,
+            "choice": choice,
+            "meta": meta or {},
+        }
+        r = await self.client.post(url, json=payload)
+        r.raise_for_status()
+        return r.json()
+
+    async def send_text_and_files(
+        self,
+        text: str | None,
+        files: Iterable[dict[str, Any]],
+        *,
+        meta: dict[str, Any] | None = None,
+    ):
+        """
+        Send a text message with attached files into AG via /channel/incoming.
+
+        Each file is a dict with keys like:
+          - name (str): filename
+          - mimetype (str): MIME type
+          - size (int): size in bytes
+          - url (str): public URL to download the file
+        """
+        url = f"{self.base_url}/channel/incoming"
+        payload = {
+            "scheme": self.scheme,
+            "channel_id": self.channel_id,
+            "thread_id": self.thread_id,
+            "text": text,
+            "files": list(files),
+            "meta": meta or {},
+        }
+        r = await self.client.post(url, json=payload)
+        r.raise_for_status()
+        return r.json()
+
+    async def resume(
+        self,
+        run_id: str,
+        node_id: str,
+        token: str,
+        resume_key: str | None = None,
+        payload: dict[str, Any] | None = None,
+    ) -> httpx.Response:
+        """
+        Low-level manual resume via /channel/resume.
+        """
+        url = f"{self.base_url}/channel/resume"
+        body = {
+            "run_id": run_id,
+            "node_id": node_id,
+            "token": token,
+            "resume_key": resume_key,
+            "payload": payload or {},
+        }
+        r = await self.client.post(url, json=body)
+        r.raise_for_status()
+        return r.json()
+
+    # --------- Outbound from AG (WebSocket) ---------
+    async def iter_events(self) -> AsyncIterator[dict[str, Any]]:
+        """
+        Receive outbound channel events over a WebSocket.
+
+        Expected server endpoint: /ws/channel
+
+        Query params:
+          - scheme
+          - channel_id
+          - thread_id (optional)
+          - api_key (optional)
+        """
+        # Build ws URL from base_url (http/https -> ws/wss)
+        if self.base_url.startswith("https://"):
+            ws_base = "wss://" + self.base_url[len("https://") :]
+        elif self.base_url.startswith("http://"):
+            ws_base = "ws://" + self.base_url[len("http://") :]
+        else:
+            # assume ws already
+            ws_base = self.base_url
+
+        params = {
+            "scheme": self.scheme,
+            "channel_id": self.channel_id,
+        }
+        if self.thread_id:
+            params["thread_id"] = self.thread_id
+        if self.api_key:
+            params["api_key"] = self.api_key
+
+        query = "&".join(f"{k}={v}" for k, v in params.items())
+        url = f"{ws_base}{self.ws_path}?{query}"
+
+        async with websockets.connect(url) as ws:
+            async for msg in ws:
+                try:
+                    data = json.loads(msg)
+                except Exception:
+                    data = {"raw": msg}
+                yield data

aethergraph/server/http/channel_http_routes.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel
+from starlette.responses import JSONResponse
+
+from aethergraph.services.channel.ingress import ChannelIngress, IncomingFile, IncomingMessage
+
+router = APIRouter()
+
+
+# --------- Pydantic models for HTTP request/response ---------
+class HttpIncomingFile(BaseModel):
+    id: str | None = None
+    name: str | None = None
+    mimetype: str | None = None
+    size: int | None = None
+    url: str | None = None
+    uri: str | None = None
+    extra: dict[str, Any] | None = None
+
+
+class ChannelIncomingBody(BaseModel):
+    """
+    High-level resume via channel (no run_id/node_id/token exposed).
+    """
+
+    scheme: str = "ext"
+    channel_id: str
+    thread_id: str | None = None
+
+    text: str | None = None
+    files: list[HttpIncomingFile] | None = None
+    choice: str | None = None
+    meta: dict[str, Any] | None = None
+
+
+class ChannelManualResumeBody(BaseModel):
+    """
+    Low-level resume for power users: explicit run/node/token.
+    """
+
+    run_id: str
+    node_id: str
+    token: str
+    payload: dict[str, Any] | None = None
+
+
+# --------- HTTP route handlers ---------
+@router.post("/channel/incoming")
+async def channel_incoming(body: ChannelIncomingBody, request: Request):
+    """
+    Generic inbound message endpoint. Typical UI call looks like:
+
+      POST /channel/incoming
+      {
+        "scheme": "ext",
+        "channel_id": "user-123",
+        "text": "hello",
+        "meta": {"foo": "bar"}
+      }
+    """
+    try:
+        container = request.app.state.container
+        ingress: ChannelIngress = container.channel_ingress  # TODO: wire via default container
+
+        files = []
+        if body.files:
+            files = [
+                IncomingFile(
+                    id=f.id,
+                    name=f.name,
+                    mimetype=f.mimetype,
+                    size=f.size,
+                    url=f.url,
+                    uri=f.uri,
+                    extra=f.extra or {},
+                )
+                for f in body.files
+            ]
+
+        ok = await ingress.handle(
+            IncomingMessage(
+                scheme=body.scheme,
+                channel_id=body.channel_id,
+                thread_id=body.thread_id,
+                text=body.text,
+                files=files,
+                choice=body.choice,
+                meta=body.meta or {},
+            )
+        )
+        return JSONResponse({"ok": True, "resumed": ok})
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e)) from e
+
+
+@router.post("/channel/resume")
+async def channel_resume(body: ChannelManualResumeBody, request: Request):
+    """
+    Low-level resume for power users: explicit run/node/token.
+    """
+    try:
+        container = request.app.state.container
+
+        await container.resume_router.resume(
+            run_id=body.run_id,
+            node_id=body.node_id,
+            token=body.token,
+            payload=body.payload or {},
+        )
+        return JSONResponse({"ok": True})
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e)) from e

aethergraph/server/http/channel_ws_routers.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import asyncio
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+
+router = APIRouter()
+
+
+@router.websocket("/ws/channel")
+async def ws_channel(ws: WebSocket):
+    """
+    Generic outbound event stream.
+
+    Client must first send a JSON handshake:
+      {"scheme": "ext", "channel_id": "user-123"}
+
+    Then we stream any events that the queue-based ChannelAdapter
+    appends to `outbox://<scheme>:chan/<channel_id>`.
+    """
+    await ws.accept()
+
+    hello = await ws.receive_json()
+    scheme = hello.get("scheme") or "ext"
+    channel_id = hello["channel_id"]
+
+    container = ws.app.state.container
+    c = container
+
+    ch_key = f"{scheme}:chan/{channel_id}"
+    outbox_key = f"outbox://{ch_key}"
+
+    last_idx = 0
+    try:
+        while True:
+            await asyncio.sleep(0.25)
+            events = await c.kv_hot.list_get(outbox_key) or []
+            if last_idx < len(events):
+                for ev in events[last_idx:]:
+                    # ev is a dict produced by our queue-based adapter
+                    await ws.send_json(ev)
+                last_idx = len(events)
+    except WebSocketDisconnect:
+        # just drop; nothing special needed
+        return