edgeone 1.6.4-beta.1 → 1.6.4-beta.2

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

@@ -13,16 +13,25 @@ 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
@@ -455,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,
@@ -480,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 ---
@@ -511,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:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edgeone",
-  "version": "1.6.4-beta.1",
+  "version": "1.6.4-beta.2",
   "description": "Command-line interface for TencentCloud Pages Functions",
   "bin": {
     "edgeone": "./edgeone-bin/edgeone.js"