edgeone 1.6.2 → 1.6.3-beta.1

package/edgeone-dist/pages/templates/agent-python/adapter.py

@@ -13,20 +13,76 @@ from typing import Any, Callable
 from urllib.parse import parse_qs
 import httpx
 
-# --- Observability bootstrap (must run before user code imports) ---
-# Reads entry names from AGENT_OBSERVABILITY_ENTRIES env var (set by main.py
-# or the dev runner). Idempotent — safe to call multiple times.
-_obs_entries_raw = os.environ.get("AGENT_OBSERVABILITY_ENTRIES", "")
-if _obs_entries_raw:
-    try:
-        from _platform._observability import setup as _obs_setup
-        _obs_setup(json.loads(_obs_entries_raw))
-    except Exception as _obs_err:
-        print(f"[observability] setup failed: {_obs_err}", file=sys.stderr, flush=True)
+# --- Observability bootstrap (deferred for fast cold start) ---
+# Moved to _ensure_observability() — called by background preload thread
+# or lazily on first request. This avoids blocking startup with OTel imports.
+_obs_initialized = False
+
+
+def _ensure_observability():
+    """Initialize observability (idempotent). Called by preload thread or first request."""
+    global _obs_initialized
+    if _obs_initialized:
+        return
+    _obs_initialized = True
+    _obs_entries_raw = os.environ.get("AGENT_OBSERVABILITY_ENTRIES", "")
+    if _obs_entries_raw:
+        try:
+            from _platform._observability import setup as _obs_setup
+            _obs_setup(json.loads(_obs_entries_raw))
+        except Exception as _obs_err:
+            print(f"[observability] setup failed: {_obs_err}", file=sys.stderr, flush=True)
 
 from .store import InMemoryStore, BlobBackedStore
 from .runtime import AgentRuntime, RouteEntry
-from .context import StreamResponse
+from .context import EoContext, StreamResponse
+
+
+# --- Geo parsing (aligns with Node agent-node.ts parseEoConnectingGeo) ---
+
+def _parse_eo(headers: dict) -> EoContext:
+    """Parse eo-connecting-geo header into structured EoContext.
+
+    Format: key=value key="quoted value"
+    Aligns with Node Agent parseEoConnectingGeo logic.
+    """
+    import urllib.parse as _up
+
+    geo_str = ""
+    if isinstance(headers, dict):
+        geo_str = _up.unquote(headers.get("eo-connecting-geo", ""))
+    if not geo_str:
+        return EoContext(geo={}, client_ip=str(headers.get("eo-connecting-ip", "")) if isinstance(headers, dict) else "")
+
+    result = {}
+    matches = __import__("re").findall(r'[a-z_]+="[^"]*"|[a-z_]+=[A-Za-z0-9.-]+', geo_str)
+    for m in matches:
+        key, val = m.split("=", 1)
+        result[key] = val.strip('"')
+
+    geo = {}
+    if "asn" in result:
+        geo["asn"] = result["asn"]
+    if "nation_name" in result:
+        geo["countryName"] = result["nation_name"]
+    if "region_code" in result:
+        geo["regionCode"] = result["region_code"]
+        geo["countryCodeAlpha2"] = result["region_code"].split("-")[0]
+    if "nation_numeric" in result:
+        geo["countryCodeNumeric"] = result["nation_numeric"]
+    if "region_name" in result:
+        geo["regionName"] = result["region_name"]
+    if "city_name" in result:
+        geo["cityName"] = result["city_name"]
+    if "latitude" in result:
+        geo["latitude"] = result["latitude"]
+    if "longitude" in result:
+        geo["longitude"] = result["longitude"]
+    if "network_operator" in result:
+        geo["cisp"] = result["network_operator"]
+
+    client_ip = str(headers.get("eo-connecting-ip", "")) if isinstance(headers, dict) else ""
+    return EoContext(geo=geo, client_ip=client_ip)
 
 
 # --- Platform response headers (align with Node agent + python-function) ---
@@ -408,22 +464,58 @@ _registry: dict[str, RouteEntry] = {}
 # 加载失败的路由：route_path → 失败原因。404 响应时回显，避免静默 404 难以排查。
 _failed_routes: dict[str, str] = {}
 
+
+# --- Lazy route loading for fast cold start ---
+# Routes are NOT imported at startup. Instead, each route module is loaded
+# on first access (or by the background preload thread). This avoids blocking
+# the health check with heavy imports (langchain, langgraph, pydantic, etc.).
+
+class _LazyRouteEntry:
+    """Lazy-loading wrapper for RouteEntry. Defers importlib.import_module() to first access."""
+
+    __slots__ = ('_module_path', '_is_index', '_handler', '_loaded', '_load_error')
+
+    def __init__(self, module_path: str, is_index: bool):
+        self._module_path = module_path
+        self._is_index = is_index
+        self._handler = None
+        self._loaded = False
+        self._load_error: str | None = None
+
+    @property
+    def handler(self):
+        if not self._loaded:
+            self._do_load()
+        if self._load_error:
+            raise ImportError(self._load_error)
+        return self._handler
+
+    @property
+    def is_index(self):
+        return self._is_index
+
+    @property
+    def module_path(self):
+        return self._module_path
+
+    def _do_load(self):
+        """Actually import the module and resolve the handler."""
+        try:
+            mod = importlib.import_module(self._module_path)
+            handler = getattr(mod, "handler", None)
+            if handler is None:
+                self._load_error = f"module '{self._module_path}' has no 'handler' function"
+            else:
+                self._handler = handler
+        except Exception as e:
+            self._load_error = f"failed to import '{self._module_path}': {e}"
+        self._loaded = True
+
+
 for route_path, info in _route_table_raw.items():
     module_path = info["module"]
     is_index = info.get("isIndex", False)
-    try:
-        mod = importlib.import_module(module_path)
-        handler = getattr(mod, "handler", None)
-        if handler is None:
-            reason = f"module '{module_path}' has no 'handler' function"
-            print(f"[agent-python] WARNING: {reason}, skipping", file=sys.stderr, flush=True)
-            _failed_routes[route_path] = reason
-            continue
-        _registry[route_path] = RouteEntry(handler=handler, is_index=is_index, module_path=module_path)
-    except Exception as e:
-        reason = f"failed to import '{module_path}': {e}"
-        print(f"[agent-python] ERROR loading {module_path}: {e}", file=sys.stderr, flush=True)
-        _failed_routes[route_path] = reason
+    _registry[route_path] = _LazyRouteEntry(module_path, is_index)
 
 _runtime = AgentRuntime(
     registry=_registry,
@@ -433,13 +525,46 @@ _runtime = AgentRuntime(
     failed_routes=_failed_routes,
 )
 
-print(f"[agent-python] Loaded {len(_registry)} routes, timeout={_timeout}s", file=sys.stderr, flush=True)
-if _failed_routes:
-    print(
-        f"[agent-python] WARNING: {len(_failed_routes)} route(s) failed to load: "
-        f"{', '.join(_failed_routes.keys())}",
-        file=sys.stderr, flush=True,
-    )
+print(f"[agent-python] Registered {len(_registry)} routes (lazy), timeout={_timeout}s", file=sys.stderr, flush=True)
+
+
+# --- Background preload thread ---
+# After uvicorn binds the port and health check passes, this thread
+# pre-imports all route modules in the background. If a request arrives
+# before preload completes, the lazy handler property will block and
+# import synchronously (no failure, just slower first request).
+
+import threading
+
+
+def _background_preload():
+    """Preload routes + observability in background after startup."""
+    import time
+    time.sleep(0.05)  # yield to let uvicorn finish port binding
+
+    # 1. Initialize observability first (lighter, needed for spans)
+    _ensure_observability()
+
+    # 2. Trigger lazy loading for all routes
+    for route_path, entry in _registry.items():
+        try:
+            _ = entry.handler
+        except Exception as e:
+            _failed_routes[route_path] = str(e)
+            print(f"[agent-python] ERROR loading {entry.module_path}: {e}", file=sys.stderr, flush=True)
+
+    loaded_count = sum(1 for e in _registry.values() if e._loaded and e._load_error is None)
+    if _failed_routes:
+        print(
+            f"[agent-python] Preload done: {loaded_count}/{len(_registry)} routes loaded, "
+            f"{len(_failed_routes)} failed: {', '.join(_failed_routes.keys())}",
+            file=sys.stderr, flush=True,
+        )
+    else:
+        print(f"[agent-python] Preload done: {loaded_count}/{len(_registry)} routes loaded", file=sys.stderr, flush=True)
+
+
+threading.Thread(target=_background_preload, daemon=True, name="agent-preload").start()
 
 
 # --- ASGI app ---
@@ -464,6 +589,11 @@ async def app(scope: dict, receive, send) -> None:
     if scope["type"] != "http":
         return
 
+    # Ensure observability is initialized before processing requests.
+    # Usually already done by background preload, but if a request arrives
+    # before preload completes, this ensures instrumentation is active.
+    _ensure_observability()
+
     # Read body
     body_parts = []
     while True:
@@ -571,7 +701,9 @@ async def app(scope: dict, receive, send) -> None:
     except (ImportError, Exception):
         pass
 
-    dispatch_task = asyncio.create_task(_runtime.handle(path, method, headers, query, body))
+    dispatch_task = asyncio.create_task(
+        _runtime.handle(path, method, headers, query, body, eo=_parse_eo(headers))
+    )
 
     # 用 Event 让 watcher 区分「流被业务自己 cancel 了」和「client 真的断开」：
     # 流式 generator 内部 await asyncio.sleep 时如果业务调了 task.cancel，

package/edgeone-dist/pages/templates/agent-python/context.py

@@ -105,12 +105,24 @@ def _resolve_sandbox_api_env(env: Mapping[str, str], configured_api_env: str = "
     return ""
 
 
+@dataclass
+class EoContext:
+    """EdgeOne 请求元数据，与 Node Agent 的 AgentEoContext 对齐。
+
+    包含从 eo-connecting-geo / eo-connecting-ip 请求头解析的地理位置信息。
+    在 adapter 层解析后传入 runtime，挂载到 ctx.eo 和 ctx.request.eo。
+    """
+    geo: dict = field(default_factory=dict)
+    client_ip: str = ""
+
+
 @dataclass
 class RequestInfo:
     body: dict
     headers: dict
     query: dict  # URL query parameters, e.g. ?foo=bar → {"foo": "bar"}
     signal: asyncio.Event  # is_set() → cancelled
+    eo: EoContext = field(default_factory=EoContext)
 
     @property
     def is_cancelled(self) -> bool:
@@ -143,6 +155,9 @@ class AgentContext:
     env: dict
     kv: Any  # Per-route KV store (BlobBackedStore or InMemoryStore)
     agents: Any  # AgentsApi (avoid circular import)
+    # EdgeOne 请求元数据，与 Node Agent ctx.eo 对齐
+    # 包含 geo（地理位置）和 client_ip（客户端 IP），从 eo-connecting-geo/ip 请求头解析
+    eo: EoContext = field(default_factory=EoContext)
     # 同 conversation 的活跃 run_id（如果有）。供业务自管并发场景使用：
     # 对齐 Node `AgentContext.active_run_id`，业务在自定义 stop / cancel handler 中
     # 可以根据这个字段判断是否需要主动 abort 旧 run；非 index 路由不会自动 409。