agent-lab-sdk 0.1.37__tar.gz → 0.1.39__tar.gz

{agent_lab_sdk-0.1.37 → agent_lab_sdk-0.1.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-lab-sdk
-Version: 0.1.37
+Version: 0.1.39
 Summary: SDK для работы с Agent Lab
 Author-email: Andrew Ohurtsov <andermirik@yandex.com>
 License: Proprietary and Confidential — All Rights Reserved

{agent_lab_sdk-0.1.37 → agent_lab_sdk-0.1.39}/agent_lab_sdk/langgraph/checkpoint/agw_saver.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
 
-import orjson
-from random import random
-from langgraph.checkpoint.serde.types import ChannelProtocol
 import asyncio
 import base64
 import logging
 import os
 from contextlib import asynccontextmanager
-from typing import Any, AsyncIterator, Dict, Iterator, Optional, Sequence, Tuple
+from random import random
+from typing import Any, AsyncIterator, Dict, Iterable, Iterator, Optional, Sequence, Tuple
+
+import orjson
+from langgraph.checkpoint.serde.types import ChannelProtocol
 
 import httpx
 from langchain_core.runnables import RunnableConfig
@@ -26,11 +27,32 @@ from langgraph.checkpoint.serde.base import SerializerProtocol
 from langgraph.checkpoint.serde.encrypted import EncryptedSerializer
 
 from .serde import Serializer
+from agent_lab_sdk.metrics import get_metric
 
 __all__ = ["AsyncAGWCheckpointSaver"]
 
 logger = logging.getLogger(__name__)
 
+AGW_METRIC_LABELS = ["method", "endpoint"]
+AGW_HTTP_SUCCESS = get_metric(
+    "counter",
+    "agw_http_success_total",
+    "Number of successful AGW HTTP requests",
+    labelnames=AGW_METRIC_LABELS,
+)
+AGW_HTTP_ERROR = get_metric(
+    "counter",
+    "agw_http_error_total",
+    "Number of failed AGW HTTP request attempts",
+    labelnames=AGW_METRIC_LABELS,
+)
+AGW_HTTP_FINAL_ERROR = get_metric(
+    "counter",
+    "agw_http_final_error_total",
+    "Number of AGW HTTP requests that failed after retries",
+    labelnames=AGW_METRIC_LABELS,
+)
+
 TYPED_KEYS = ("type", "blob")
 
 
@@ -82,6 +104,66 @@ class AsyncAGWCheckpointSaver(BaseCheckpointSaver):
         self.timeout = timeout
         self.loop = asyncio.get_running_loop()
 
+        raw_attempts = os.getenv("AGW_HTTP_MAX_RETRIES")
+        if raw_attempts is None:
+            self.retry_max_attempts = 3
+        else:
+            try:
+                self.retry_max_attempts = max(int(raw_attempts), 1)
+            except ValueError:
+                logger.warning(
+                    "Env %s expected int, got %r; using default %s",
+                    "AGW_HTTP_MAX_RETRIES",
+                    raw_attempts,
+                    3,
+                )
+                self.retry_max_attempts = 3
+
+        raw_backoff_base = os.getenv("AGW_HTTP_RETRY_BACKOFF_BASE")
+        if raw_backoff_base is None:
+            self.retry_backoff_base = 0.5
+        else:
+            try:
+                self.retry_backoff_base = max(float(raw_backoff_base), 0.0)
+            except ValueError:
+                logger.warning(
+                    "Env %s expected float, got %r; using default %.3f",
+                    "AGW_HTTP_RETRY_BACKOFF_BASE",
+                    raw_backoff_base,
+                    0.5,
+                )
+                self.retry_backoff_base = 0.5
+
+        raw_backoff_max = os.getenv("AGW_HTTP_RETRY_BACKOFF_MAX")
+        if raw_backoff_max is None:
+            self.retry_backoff_max = 5.0
+        else:
+            try:
+                self.retry_backoff_max = max(float(raw_backoff_max), 0.0)
+            except ValueError:
+                logger.warning(
+                    "Env %s expected float, got %r; using default %.3f",
+                    "AGW_HTTP_RETRY_BACKOFF_MAX",
+                    raw_backoff_max,
+                    5.0,
+                )
+                self.retry_backoff_max = 5.0
+
+        raw_jitter = os.getenv("AGW_HTTP_RETRY_JITTER")
+        if raw_jitter is None:
+            self.retry_jitter = 0.25
+        else:
+            try:
+                self.retry_jitter = max(float(raw_jitter), 0.0)
+            except ValueError:
+                logger.warning(
+                    "Env %s expected float, got %r; using default %.3f",
+                    "AGW_HTTP_RETRY_JITTER",
+                    raw_jitter,
+                    0.25,
+                )
+                self.retry_jitter = 0.25
+
         self.headers: Dict[str, str] = {
             "Accept": "application/json",
             "Content-Type": "application/json",
@@ -91,19 +173,51 @@ class AsyncAGWCheckpointSaver(BaseCheckpointSaver):
         if api_key:
             self.headers["Authorization"] = f"Bearer {api_key}"
 
-        self._client = httpx.AsyncClient(
+        self._verify = verify
+        self._client: httpx.AsyncClient | None = None
+
+    def _create_client(self) -> httpx.AsyncClient:
+        return httpx.AsyncClient(
             base_url=self.base_url,
             headers=self.headers,
             timeout=self.timeout,
-            verify=verify,
-            trust_env=True
+            verify=self._verify,
+            trust_env=True,
         )
 
+    def _ensure_client(self) -> httpx.AsyncClient:
+        client = self._client
+        if client is None or client.is_closed:
+            if client is not None and client.is_closed:
+                logger.debug("Recreating closed httpx.AsyncClient for AGW")
+            client = self._create_client()
+            self._client = client
+        return client
+
+    def _compute_retry_delay(self, attempt: int) -> float:
+        if attempt <= 0:
+            attempt = 1
+        if self.retry_backoff_base <= 0:
+            delay = 0.0
+        else:
+            delay = self.retry_backoff_base * (2 ** (attempt - 1))
+            if self.retry_backoff_max > 0:
+                delay = min(delay, self.retry_backoff_max)
+        if self.retry_jitter > 0:
+            delay += self.retry_jitter * random()
+        return delay
+
     async def __aenter__(self):  # noqa: D401
         return self
 
     async def __aexit__(self, exc_type, exc, tb):  # noqa: D401
-        await self._client.aclose()
+        if self._client is not None:
+            try:
+                await self._client.aclose()
+            except Exception as close_exc:  # pragma: no cover - best effort
+                logger.debug("Failed to close AGW httpx.AsyncClient: %s", close_exc)
+            finally:
+                self._client = None
 
     # ----------------------- universal dump/load ---------------------
     # def _safe_dump(self, obj: Any) -> Any:
@@ -300,13 +414,99 @@ class AsyncAGWCheckpointSaver(BaseCheckpointSaver):
         return self._safe_load(md)
 
     # ------------------------ HTTP wrapper ---------------------------
-    async def _http(self, method: str, path: str, **kw) -> httpx.Response:
+    async def _http(
+        self,
+        method: str,
+        path: str,
+        *,
+        ok_statuses: Iterable[int] | None = None,
+        **kw,
+    ) -> httpx.Response:
         if "json" in kw:
             payload = kw.pop("json")
             kw["data"] = orjson.dumps(payload)
             logger.debug("AGW HTTP payload: %s", kw["data"].decode())
-            
-        return await self._client.request(method, path, **kw)
+
+        ok_set = set(ok_statuses) if ok_statuses is not None else set()
+
+        attempt = 1
+        while True:
+            client = self._ensure_client()
+            try:
+                resp = await client.request(method, path, **kw)
+            except httpx.RequestError as exc:
+                AGW_HTTP_ERROR.labels(method, path).inc()
+                logger.warning(
+                    "AGW request %s %s failed on attempt %d/%d: %s",
+                    method,
+                    path,
+                    attempt,
+                    self.retry_max_attempts,
+                    exc,
+                )
+                if attempt >= self.retry_max_attempts:
+                    AGW_HTTP_FINAL_ERROR.labels(method, path).inc()
+                    if self._client is not None:
+                        try:
+                            await self._client.aclose()
+                        except Exception as close_exc:  # pragma: no cover
+                            logger.debug(
+                                "Failed to close AGW httpx.AsyncClient: %s",
+                                close_exc,
+                            )
+                        finally:
+                            self._client = None
+                    raise
+
+                if self._client is not None:
+                    try:
+                        await self._client.aclose()
+                    except Exception as close_exc:  # pragma: no cover
+                        logger.debug(
+                            "Failed to close AGW httpx.AsyncClient: %s",
+                            close_exc,
+                        )
+                    finally:
+                        self._client = None
+                delay = self._compute_retry_delay(attempt)
+                if delay > 0:
+                    await asyncio.sleep(delay)
+                attempt += 1
+                continue
+
+            status = resp.status_code
+            if status < 400 or status in ok_set:
+                AGW_HTTP_SUCCESS.labels(method, path).inc()
+                return resp
+
+            AGW_HTTP_ERROR.labels(method, path).inc()
+            if status in (404, 406):
+                AGW_HTTP_FINAL_ERROR.labels(method, path).inc()
+                return resp
+
+            if attempt >= self.retry_max_attempts:
+                AGW_HTTP_FINAL_ERROR.labels(method, path).inc()
+                return resp
+
+            try:
+                await resp.aclose()
+            except Exception as exc:  # pragma: no cover - best effort
+                logger.debug("Failed to close AGW httpx.Response before retry: %s", exc)
+
+            if self._client is not None:
+                try:
+                    await self._client.aclose()
+                except Exception as close_exc:  # pragma: no cover
+                    logger.debug(
+                        "Failed to close AGW httpx.AsyncClient: %s",
+                        close_exc,
+                    )
+                finally:
+                    self._client = None
+            delay = self._compute_retry_delay(attempt)
+            if delay > 0:
+                await asyncio.sleep(delay)
+            attempt += 1
 
     # -------------------- api -> CheckpointTuple ----------------------
     def _to_tuple(self, node: Dict[str, Any]) -> CheckpointTuple:
@@ -497,4 +697,10 @@ class AsyncAGWCheckpointSaver(BaseCheckpointSaver):
         try:
             yield saver
         finally:
-            await saver._client.aclose()
+            if saver._client is not None:
+                try:
+                    await saver._client.aclose()
+                except Exception as close_exc:  # pragma: no cover - best effort
+                    logger.debug("Failed to close AGW httpx.AsyncClient: %s", close_exc)
+                finally:
+                    saver._client = None

{agent_lab_sdk-0.1.37 → agent_lab_sdk-0.1.39}/agent_lab_sdk/llm/llm.py

@@ -38,4 +38,7 @@ def get_model(
         # Включаем режим авто-обновления токена в обёртках
         kwargs["manage_access_token"] = True
 
-    return _class(verify_ssl_certs=verify_ssl_certs, **kwargs)
+    if access_token:
+        kwargs["access_token"] = access_token
+
+    return _class(verify_ssl_certs=verify_ssl_certs, **kwargs)

{agent_lab_sdk-0.1.37 → agent_lab_sdk-0.1.39}/agent_lab_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-lab-sdk
-Version: 0.1.37
+Version: 0.1.39
 Summary: SDK для работы с Agent Lab
 Author-email: Andrew Ohurtsov <andermirik@yandex.com>
 License: Proprietary and Confidential — All Rights Reserved

{agent_lab_sdk-0.1.37 → agent_lab_sdk-0.1.39}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agent-lab-sdk"
-version = "0.1.37"
+version = "0.1.39"
 description = "SDK для работы с Agent Lab"
 readme = "README.md"
 license = { text = "Proprietary and Confidential — All Rights Reserved" }