agent-lab-sdk 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

agent_lab_sdk/__init__.py

@@ -0,0 +1,3 @@
+from . import storage, metrics, llm
+
+__all__ = ["storage", "metrics", "llm", "langgraph"]

agent_lab_sdk/langgraph/checkpoint/__init__.py

@@ -0,0 +1,3 @@
+from .agw_saver import AsyncAGWCheckpointSaver
+
+__all__ = ["AsyncAGWCheckpointSaver"]

agent_lab_sdk/langgraph/checkpoint/agw_saver.py

@@ -0,0 +1,381 @@
+from __future__ import annotations
+
+import json
+from random import random
+from langgraph.checkpoint.serde.types import ChannelProtocol
+import asyncio
+import base64
+from contextlib import asynccontextmanager
+from typing import Any, AsyncIterator, Dict, Iterator, Optional, Sequence, Tuple
+import logging
+
+import requests
+from langchain_core.runnables import RunnableConfig
+
+from langgraph.checkpoint.base import (
+    WRITES_IDX_MAP,
+    BaseCheckpointSaver,
+    ChannelVersions,
+    Checkpoint,
+    CheckpointMetadata,
+    CheckpointTuple,
+    get_checkpoint_id,
+    get_checkpoint_metadata,
+)
+from langgraph.checkpoint.serde.base import SerializerProtocol
+
+__all__ = ["AsyncAGWCheckpointSaver"]
+
+logger = logging.getLogger(__name__)
+
+# ------------------------------------------------------------------ #
+# helpers for Py < 3.10
+# ------------------------------------------------------------------ #
+try:
+    anext  # type: ignore[name-defined]
+except NameError:  # pragma: no cover
+
+    async def anext(it):
+        return await it.__anext__()
+
+
+class AsyncAGWCheckpointSaver(BaseCheckpointSaver):
+    """Persist checkpoints in Agent-Gateway с помощью `requests` + threads."""
+
+    # ---------------------------- init / ctx -------------------------
+    def __init__(
+        self,
+        base_url: str = "http://localhost",
+        *,
+        serde: SerializerProtocol | None = None,
+        timeout: int | float = 10,
+        api_key: str | None = None,
+        extra_headers: Dict[str, str] | None = None,
+    ):
+        super().__init__(serde=serde)
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._session = requests.Session()
+        self.loop = asyncio.get_running_loop()
+
+        self.headers: Dict[str, str] = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+        if extra_headers:
+            self.headers.update(extra_headers)
+        if api_key:
+            self.headers["Authorization"] = f"Bearer {api_key}"
+
+    async def __aenter__(self):  # noqa: D401
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):  # noqa: D401
+        await asyncio.to_thread(self._session.close)
+
+    # ----------------------- universal dump/load ---------------------
+    # def _safe_dump(self, obj: Any) -> Any:
+    #     """self.serde.dump → гарантированная JSON-строка."""
+    #     dumped = self.serde.dumps(obj)
+    #     if isinstance(dumped, (bytes, bytearray)):
+    #         return base64.b64encode(dumped).decode()  # str
+    #     return dumped  # уже json-совместимо
+
+    def _safe_dump(self, obj: Any) -> Any:
+        """bytes → python-object; fallback base64 для реально бинарных данных."""
+        dumped = self.serde.dumps(obj)
+        if isinstance(dumped, (bytes, bytearray)):
+            try:
+                # 1) bytes → str
+                s = dumped.decode()
+                # 2) str JSON → python (list/dict/scalar)
+                return json.loads(s)
+            except (UnicodeDecodeError, json.JSONDecodeError):
+                # не UTF-8 или не JSON → base64
+                return base64.b64encode(dumped).decode()
+        return dumped
+
+    def _safe_load(self, obj: Any) -> Any:
+        if isinstance(obj, (dict, list)):          # уже распакованный JSON
+            return self.serde.loads(json.dumps(obj, ensure_ascii=False).encode())
+        if isinstance(obj, str):
+            # сначала plain JSON-строка
+            try:
+                return self.serde.loads(obj.encode())
+            except Exception:
+                # возможно base64
+                try:
+                    return self.serde.loads(base64.b64decode(obj))
+                except Exception:
+                    return obj
+        try:
+            return self.serde.loads(obj)
+        except Exception:
+            return obj
+
+    # def _safe_load(self, obj: Any) -> Any:
+    #     """Обратная операция к _safe_dump."""
+    #     if isinstance(obj, str):
+    #         try:
+    #             return self.serde.load(base64.b64decode(obj))
+    #         except Exception:
+    #             # не base64 — обычная строка
+    #             return self.serde.load(obj)
+    #     return self.serde.load(obj)
+
+    # ----------------------- config <-> api --------------------------
+    def _to_api_config(self, cfg: RunnableConfig | None) -> Dict[str, Any]:
+        if not cfg:
+            return {}
+        c = cfg.get("configurable", {})
+        res: Dict[str, Any] = {
+            "threadId": c.get("thread_id", ""),
+            "checkpointNs": c.get("checkpoint_ns", ""),
+        }
+        if cid := c.get("checkpoint_id"):
+            res["checkpointId"] = cid
+        if ts := c.get("thread_ts"):
+            res["threadTs"] = ts
+        return res
+
+    # --------------------- checkpoint (de)ser ------------------------
+    def _encode_cp(self, cp: Checkpoint) -> Dict[str, Any]:
+        return {
+            "v": cp["v"],
+            "id": cp["id"],
+            "ts": cp["ts"],
+            "channelValues": {k: self._safe_dump(v) for k, v in cp["channel_values"].items()},
+            "channelVersions": cp["channel_versions"],
+            "versionsSeen": cp["versions_seen"],
+            "pendingSends": cp.get("pending_sends", []),
+        }
+
+    def _decode_cp(self, raw: Dict[str, Any]) -> Checkpoint:
+        return Checkpoint(
+            v=raw["v"],
+            id=raw["id"],
+            ts=raw["ts"],
+            channel_values={k: self._safe_load(v) for k, v in raw["channelValues"].items()},
+            channel_versions=raw["channelVersions"],
+            versions_seen=raw["versionsSeen"],
+            pending_sends=raw.get("pendingSends", []),
+        )
+
+    def _decode_config(self, raw: Dict[str, Any]) -> Optional[RunnableConfig]:
+        if not raw:
+            return None
+        return RunnableConfig(
+            tags=raw.get("tags"),
+            metadata=raw.get("metadata"),
+            callbacks=raw.get("callbacks"),
+            run_name=raw.get("run_name"),
+            max_concurrency=raw.get("max_concurrency"),
+            recursion_limit=raw.get("recursion_limit"),
+            configurable=self._decode_configurable(raw.get("configurable"))
+        )
+
+    def _decode_configurable(self, raw: Dict[str, Any]) -> dict[str, Any]:
+        return {
+            "thread_id": raw.get("threadId"),
+            "thread_ts": raw.get("threadTs"),
+            "checkpoint_ns": raw.get("checkpointNs"),
+            "checkpoint_id": raw.get("checkpointId")
+        }
+
+    # metadata (de)ser
+    def _enc_meta(self, md: CheckpointMetadata) -> CheckpointMetadata:
+        out: CheckpointMetadata = {}
+        for k, v in md.items():
+            out[k] = self._enc_meta(v) if isinstance(v, dict) else self._safe_dump(v)  # type: ignore[assignment]
+        return out
+
+    def _dec_meta(self, md: Any) -> Any:
+        if isinstance(md, dict):
+            return {k: self._dec_meta(v) for k, v in md.items()}
+        return self._safe_load(md)
+
+    # ------------------------ HTTP wrapper ---------------------------
+    async def _http(self, m: str, path: str, **kw) -> requests.Response:
+        url = f"{self.base_url}{path}"
+        hdr = {**self.headers, **kw.pop("headers", {})}
+
+        if "json" in kw:
+            payload = kw.pop("json")
+            kw["data"] = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
+            logger.info(kw["data"])
+
+        return await asyncio.to_thread(
+            self._session.request, m, url, headers=hdr, timeout=self.timeout, **kw
+        )
+
+    # -------------------- api -> CheckpointTuple ----------------------
+    def _to_tuple(self, node: Dict[str, Any]) -> CheckpointTuple:
+        pending = None
+        if node.get("pendingWrites"):
+            pending = [(w["first"], w["second"], self._safe_load(w["third"])) for w in node["pendingWrites"]]
+        return CheckpointTuple(
+            config=self._decode_config(node["config"]),
+            checkpoint=self._decode_cp(node["checkpoint"]),
+            metadata=self._dec_meta(node["metadata"]),
+            parent_config=self._decode_config(node.get("parentConfig")),
+            pending_writes=pending,
+        )
+
+    # =================================================================
+    # async-методы BaseCheckpointSaver
+    # =================================================================
+    async def aget_tuple(self, cfg: RunnableConfig) -> CheckpointTuple | None:
+        cid = get_checkpoint_id(cfg)
+        api_cfg = self._to_api_config(cfg)
+        tid = api_cfg["threadId"]
+
+        if cid:
+            path = f"/checkpoint/{tid}/{cid}"
+            params = {"checkpointNs": api_cfg.get("checkpointNs", "")}
+        else:
+            path = f"/checkpoint/{tid}"
+            params = None
+
+        resp = await self._http("GET", path, params=params)
+        logger.debug("AGW aget_tuple response: %s", resp.text)
+
+        if not resp.text:
+            return None
+        if resp.status_code in (404, 406):
+            return None
+        resp.raise_for_status()
+        return self._to_tuple(resp.json())
+
+    async def alist(
+        self,
+        cfg: RunnableConfig | None,
+        *,
+        filter: Dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
+    ) -> AsyncIterator[CheckpointTuple]:
+        payload = {
+            "config": self._to_api_config(cfg) if cfg else None,
+            "filter": filter,
+            "before": self._to_api_config(before) if before else None,
+            "limit": limit,
+        }
+        resp = await self._http("POST", "/checkpoint/list", json=payload)
+        logger.debug("AGW alist response: %s", resp.text)
+        resp.raise_for_status()
+        for item in resp.json():
+            yield self._to_tuple(item)
+
+    async def aput(
+        self,
+        cfg: RunnableConfig,
+        cp: Checkpoint,
+        metadata: CheckpointMetadata,
+        new_versions: ChannelVersions,
+    ) -> RunnableConfig:
+        payload = {
+            "config": self._to_api_config(cfg),
+            "checkpoint": self._encode_cp(cp),
+            "metadata": self._enc_meta(get_checkpoint_metadata(cfg, metadata)),
+            "newVersions": new_versions,
+        }
+        resp = await self._http("POST", "/checkpoint", json=payload)
+        logger.debug("AGW aput response: %s", resp.text)
+        resp.raise_for_status()
+        return resp.json()["config"]
+
+    async def aput_writes(
+        self,
+        cfg: RunnableConfig,
+        writes: Sequence[Tuple[str, Any]],
+        task_id: str,
+        task_path: str = "",
+    ) -> None:
+        enc = [{"first": ch, "second": self._safe_dump(v)} for ch, v in writes]
+        payload = {
+            "config": self._to_api_config(cfg),
+            "writes": enc,
+            "taskId": task_id,
+            "taskPath": task_path,
+        }
+        resp = await self._http("POST", "/checkpoint/writes", json=payload)
+        logger.debug("AGW aput_writes response: %s", resp.text)
+        resp.raise_for_status()
+
+    async def adelete_thread(self, thread_id: str) -> None:
+        resp = await self._http("DELETE", f"/checkpoint/{thread_id}")
+        resp.raise_for_status()
+
+    # =================================================================
+    # sync-обёртки
+    # =================================================================
+    def _run(self, coro):
+        return asyncio.run_coroutine_threadsafe(coro, self.loop).result()
+
+    def list(
+        self,
+        cfg: RunnableConfig | None,
+        *,
+        filter: Dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
+    ) -> Iterator[CheckpointTuple]:
+        aiter_ = self.alist(cfg, filter=filter, before=before, limit=limit)
+        while True:
+            try:
+                yield self._run(anext(aiter_))
+            except StopAsyncIteration:
+                break
+
+    def get_tuple(self, cfg: RunnableConfig) -> CheckpointTuple | None:
+        return self._run(self.aget_tuple(cfg))
+
+    def put(
+        self,
+        cfg: RunnableConfig,
+        cp: Checkpoint,
+        metadata: CheckpointMetadata,
+        new_versions: ChannelVersions,
+    ) -> RunnableConfig:
+        return self._run(self.aput(cfg, cp, metadata, new_versions))
+
+    def put_writes(
+        self,
+        cfg: RunnableConfig,
+        writes: Sequence[Tuple[str, Any]],
+        task_id: str,
+        task_path: str = "",
+    ) -> None:
+        self._run(self.aput_writes(cfg, writes, task_id, task_path))
+
+    def delete_thread(self, thread_id: str) -> None:
+        self._run(self.adelete_thread(thread_id))
+
+    def get_next_version(self, current: Optional[str], channel: ChannelProtocol) -> str:
+        if current is None:
+            current_v = 0
+        elif isinstance(current, int):
+            current_v = current
+        else:
+            current_v = int(current.split(".")[0])
+        next_v = current_v + 1
+        next_h = random()
+        return f"{next_v:032}.{next_h:016}"
+
+    # ------------------------------------------------------------------ #
+    # Convenience factory                                                #
+    # ------------------------------------------------------------------ #
+    @classmethod
+    @asynccontextmanager
+    async def from_base_url(
+        cls,
+        base_url: str,
+        *,
+        api_key: str | None = None,
+        **kwargs: Any,
+    ) -> AsyncIterator["AsyncAGWCheckpointSaver"]:
+        saver = cls(base_url, api_key=api_key, **kwargs)
+        try:
+            yield saver
+        finally:
+            await asyncio.to_thread(saver._session.close)

agent_lab_sdk/llm/__init__.py

@@ -0,0 +1,14 @@
+# agent_lab_sdk/llm/__init__.py
+
+from .llm import get_model
+from .gigachat_token_manager import GigaChatTokenManager
+from .agw_token_manager import AgwTokenManager
+from .throttled import ThrottledGigaChat, ThrottledGigaChatEmbeddings
+
+__all__ = [
+    "get_model",
+    "GigaChatTokenManager",
+    "AgwTokenManager",
+    "ThrottledGigaChat",
+    "ThrottledGigaChatEmbeddings",
+]

agent_lab_sdk/llm/agw_token_manager.py

@@ -0,0 +1,97 @@
+from typing import Optional
+
+import requests
+import logging
+import os
+import threading
+import urllib.parse
+import json
+import random
+import time
+from datetime import datetime, timedelta, timezone
+
+logger = logging.getLogger(__name__)
+
+# Путь к файлу токена (можно переопределить через ENV)
+TOKEN_PROVIDER_AGW_URL = os.environ.get("TOKEN_PROVIDER_AGW_URL", "https://agent-gateway.apps.advosd.sberdevices.ru")
+# Максимальное число попыток получения токена (по умолчанию 3, можно переопределить через ENV)
+TOKEN_PROVIDER_AGW_DEFAULT_MAX_RETRIES = int(os.environ.get("TOKEN_PROVIDER_AGW_DEFAULT_MAX_RETRIES", 3))
+# Таймаут ожидания ответа agw в секундах
+TOKEN_PROVIDER_AGW_TIMEOUT_SEC = int(os.environ.get("TOKEN_PROVIDER_AGW_TIMEOUT_SEC", 5))
+# Случайная задержка между повторными попытками: от 1 до 5 секунд
+BACKOFF_MIN = 1
+BACKOFF_MAX = 5
+# Случайный порог обновления токена: от 0 до 300 секунд (5 минут)
+REFRESH_WINDOW_MAX = 300
+
+class AgwTokenManager:
+    # Лок для синхронизации между потоками в одном процессе
+    _thread_lock = threading.Lock()
+    _tokens: dict[str, any] = {}
+
+    @staticmethod
+    def _get_new_token(provider: str, token_type: Optional[str] = None) -> dict[str, any]:
+        req_url = urllib.parse.urljoin(TOKEN_PROVIDER_AGW_URL, "/tokens")
+        params = {"provider": provider}
+        if token_type:
+            params["type"] = token_type
+        
+        max_retries = TOKEN_PROVIDER_AGW_DEFAULT_MAX_RETRIES
+        for attempt in range(1, max_retries + 1):
+            try:
+                logger.info(f"Попытка получения токена из AGW ({attempt}/{max_retries})...")
+                resp = requests.post(req_url, params=params, data={}, verify=False, timeout=TOKEN_PROVIDER_AGW_TIMEOUT_SEC)
+                resp.raise_for_status()
+                result = resp.json()
+
+                token = result.get("token")
+                expires_in = result.get("expiresIn")
+
+                if not token or not expires_in:
+                    raise ValueError(f"Неверный ответ API: {resp.text}")
+
+                expiry_time = datetime.fromtimestamp(expires_in, tz=timezone.utc) - timedelta(seconds=60)
+                logger.info("Успешно получили токен, действует до %s", expiry_time.isoformat())
+                return {
+                    "token": token,
+                    "expiry_ts": expires_in
+                }
+
+            except (Exception, requests.RequestException, ValueError, json.JSONDecodeError) as e:
+                logger.error("Ошибка при попытке %d: %s", attempt, e)
+                if attempt < max_retries:
+                    delay = random.uniform(BACKOFF_MIN, BACKOFF_MAX)
+                    logger.info("Повтор через %.2f сек...", delay)
+                    time.sleep(delay)
+                else:
+                    logger.error("Все %d попыток получения токена провалены.", max_retries)
+                    raise
+
+    @classmethod
+    def get_token(cls, provider: str, token_type: Optional[str] = None) -> str:
+        """
+        Возвращает валидный токен, обновляя его при необходимости.
+        """
+        key = "{}_{}".format(provider, token_type if token_type is not None else "default")
+        # Лок между потоками
+        with cls._thread_lock:
+            by_provider = cls._tokens.get(key)
+            if by_provider:
+                token = by_provider.get("token")
+                expiry_ts = by_provider.get("expiry_ts")
+                now = datetime.now(timezone.utc)
+
+                if token and expiry_ts:
+                    expiry_time = datetime.fromtimestamp(expiry_ts, tz=timezone.utc)
+                    refresh_window = timedelta(seconds=random.uniform(0, REFRESH_WINDOW_MAX))
+                    time_left = expiry_time - now
+                    logger.debug("Осталось времени: %s, порог обновления: %s", time_left, refresh_window)
+                    if time_left > refresh_window:
+                        logger.debug("Используем кэшированный токен; истекает %s", expiry_time.isoformat())
+                        return token
+
+
+            # Иначе — запрашиваем новый токен
+            new_token = cls._get_new_token(provider, token_type)
+            cls._tokens[key] = new_token
+            return new_token.get("token")

agent_lab_sdk/llm/gigachat_token_manager.py

@@ -0,0 +1,156 @@
+import os
+import json
+import logging
+import logging
+import uuid
+import requests
+import fcntl
+import random
+import time
+import threading
+from datetime import datetime, timedelta, timezone
+from .agw_token_manager import AgwTokenManager
+import urllib3
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+# Путь к файлу токена (можно переопределить через ENV)
+TOKEN_FILE_PATH = os.environ.get("GIGACHAT_TOKEN_PATH", "/tmp/gigachat_token.json")
+USE_TOKEN_PROVIDER_AGW = os.environ.get("USE_TOKEN_PROVIDER_AGW", 'False').lower() in ('true', '1', 't')
+
+# Максимальное число попыток получения токена (по умолчанию 3, можно переопределить через ENV)
+DEFAULT_MAX_RETRIES = int(os.environ.get("GIGACHAT_TOKEN_FETCH_RETRIES", 3))
+# Случайная задержка между повторными попытками: от 1 до 5 секунд
+BACKOFF_MIN = 1
+BACKOFF_MAX = 5
+# Случайный порог обновления токена: от 0 до 300 секунд (5 минут)
+REFRESH_WINDOW_MAX = 300
+
+class GigaChatTokenManager:
+    # Лок для синхронизации между потоками в одном процессе
+    _thread_lock = threading.Lock()
+
+    @staticmethod
+    def _get_new_token():
+        """Запрашивает новый токен у GigaChat API с retry и случайной задержкой."""
+        if os.getenv("USE_GIGACHAT_ADVANCED", 'False').lower() in ('true', '1', 't'):
+            url = os.environ.get("GIGACHAT_BASE_URL") + "token"
+            data = None
+        else:
+            gigachat_scope = os.environ.get("GIGACHAT_SCOPE", "GIGACHAT_API_PERS")
+
+            url = "https://ngw.devices.sberbank.ru:9443/api/v2/oauth"
+            data = {"scope": gigachat_scope}
+
+        print(url)
+        gigachat_credentials = os.environ.get("GIGACHAT_CREDENTIALS")
+        if not gigachat_credentials:
+            raise ValueError("Переменная окружения GIGACHAT_CREDENTIALS не установлена.")
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Accept": "application/json",
+            "User-Agent": "agent-toolkit",
+            "RqUID": str(uuid.uuid4()),  # Уникальный идентификатор запроса
+            "Authorization": f"Basic {gigachat_credentials}"
+        }
+
+        max_retries = DEFAULT_MAX_RETRIES
+        for attempt in range(1, max_retries + 1):
+            try:
+                logger.info(f"Попытка получения токена GigaChat ({attempt}/{max_retries})...")
+                resp = requests.post(url, headers=headers, data=data, verify=False)
+                resp.raise_for_status()
+                result = resp.json()
+
+                token = result.get("access_token")
+                if not token:
+                    token = result.get("tok")
+                expires_at = result.get("expires_at")
+                if not expires_at:
+                    expires_at = result.get("exp") * 1000
+                if not token or not expires_at:
+                    raise ValueError(f"Неверный ответ API: {resp.text}")
+
+                # expires_at в миллисекундах
+                expiry_time = datetime.fromtimestamp(expires_at / 1000, tz=timezone.utc) - timedelta(seconds=60)
+                logger.info("Успешно получили токен, действует до %s", expiry_time.isoformat())
+                return token, expiry_time
+
+            except (Exception, requests.RequestException, ValueError, json.JSONDecodeError) as e:
+                logger.error("Ошибка при попытке %d: %s", attempt, e)
+                if attempt < max_retries:
+                    delay = random.uniform(BACKOFF_MIN, BACKOFF_MAX)
+                    logger.info("Повтор через %.2f сек...", delay)
+                    time.sleep(delay)
+                else:
+                    logger.error("Все %d попыток получения токена провалены.", max_retries)
+                    raise
+
+    @classmethod
+    def get_token(cls) -> str:
+        """
+        Возвращает валидный токен, обновляя его при необходимости.
+        Использует межпроцессную блокировку (fcntl.flock) и лок для потоков,
+        чтобы избежать дублирующих запросов.
+        """
+        if USE_TOKEN_PROVIDER_AGW:
+            provider = "GIGACHAT-ADVANCED" if os.getenv("USE_GIGACHAT_ADVANCED", 'False').lower() in ('true', '1', 't') else "GIGACHAT"
+            return AgwTokenManager.get_token(provider=provider)
+        
+        # Лок между потоками
+        with cls._thread_lock:
+            # Гарантируем существование директории под файл токена
+            dirpath = os.path.dirname(TOKEN_FILE_PATH)
+            if dirpath and not os.path.exists(dirpath):
+                os.makedirs(dirpath, exist_ok=True)
+
+            # Открываем (или создаем) файл токена
+            with open(TOKEN_FILE_PATH, "a+", encoding="utf-8") as f:
+                # Межпроцессная блокировка файла
+                fcntl.flock(f, fcntl.LOCK_EX)
+                try:
+                    # Читаем существующие данные
+                    f.seek(0)
+                    try:
+                        data = json.load(f)
+                    except (json.JSONDecodeError, IOError):
+                        data = {}
+
+                    token = data.get("token")
+                    expiry_ts = data.get("expiry_timestamp")
+                    now = datetime.now(timezone.utc)
+
+                    # Если токен есть и не истекает раньше случайного порога — возвращаем его
+                    if token and expiry_ts:
+                        expiry_time = datetime.fromtimestamp(expiry_ts, tz=timezone.utc)
+                        # генерируем случайный порог в секундах до истечения (0–300)
+                        refresh_window = timedelta(seconds=random.uniform(0, REFRESH_WINDOW_MAX))
+                        time_left = expiry_time - now
+                        logger.debug("Осталось времени: %s, порог обновления: %s", time_left, refresh_window)
+                        if time_left > refresh_window:
+                            logger.debug("Используем кэшированный токен; истекает %s", expiry_time.isoformat())
+                            return token
+
+                    # Иначе — запрашиваем новый токен
+                    new_token, new_expiry = cls._get_new_token()
+
+                    # Сохраняем новый токен
+                    f.seek(0)
+                    f.truncate()
+                    json.dump({
+                        "token": new_token,
+                        "expiry_timestamp": new_expiry.timestamp()
+                    }, f)
+                    f.flush()
+                    logger.debug("Новый токен сохранен в %s", TOKEN_FILE_PATH)
+                    return new_token
+
+                finally:
+                    # Снимаем межпроцессную блокировку
+                    fcntl.flock(f, fcntl.LOCK_UN)
+
+# Примечание: fcntl.flock обеспечивает межпроцессную блокировку,
+# а threading.Lock — синхронизацию между потоками в одном процессе.

agent_lab_sdk/llm/llm.py

@@ -0,0 +1,28 @@
+from langchain_gigachat.chat_models import GigaChat
+from agent_lab_sdk.llm.gigachat_token_manager import GigaChatTokenManager
+import os
+
+def get_model(**kwargs) -> GigaChat:
+    access_token = kwargs.pop("access_token", None)
+    if not access_token:
+        access_token = GigaChatTokenManager.get_token()
+    timeout = kwargs.pop("timeout", None)
+    if not timeout:
+        timeout=int(os.getenv("GLOBAL_GIGACHAT_TIMEOUT", "120"))
+        
+    scope = kwargs.pop("scope", None)
+    if not scope:
+        scope = os.getenv("GIGACHAT_SCOPE")
+
+    verify_ssl_certs = kwargs.pop("verify_ssl_certs", False)
+
+    if not scope:
+        raise ValueError("GIGACHAT_SCOPE environment variable is not set.")
+
+    return GigaChat(
+        access_token=access_token,
+        verify_ssl_certs=verify_ssl_certs,
+        scope=scope,
+        timeout=timeout,
+        **kwargs
+        )

agent_lab_sdk/llm/throttled.py

@@ -0,0 +1,177 @@
+import os
+import asyncio
+import threading
+import time
+from langchain_gigachat.chat_models import GigaChat
+from langchain_gigachat import GigaChatEmbeddings
+import langchain_gigachat.embeddings.gigachat
+
+langchain_gigachat.embeddings.gigachat.MAX_BATCH_SIZE_PARTS=int(os.getenv("EMBEDDINGS_MAX_BATCH_SIZE_PARTS", "90"))
+
+MAX_CHAT_CONCURRENCY = int(os.getenv("MAX_CHAT_CONCURRENCY", "100000"))
+MAX_EMBED_CONCURRENCY = int(os.getenv("MAX_EMBED_CONCURRENCY", "100000"))
+
+
+from agent_lab_sdk.metrics import get_metric
+
+def create_metrics(prefix: str):
+    in_use = get_metric(
+        metric_type = "gauge", name = f"{prefix}_slots_in_use",
+        documentation = f"Number of {prefix} slots currently in use"
+    )
+    waiting = get_metric(
+        metric_type = "gauge", name = f"{prefix}_waiting_tasks",
+        documentation = f"Number of tasks waiting for {prefix}"
+    )
+    wait_time = get_metric(
+        metric_type = "histogram", name = f"{prefix}_wait_time_seconds",
+        documentation = f"Time tasks wait for {prefix}",
+        buckets = [3, 5, 10, 15, 30, 60, 120, 240, 480, 960, 1920, float("inf")]
+    )
+
+    return in_use, waiting, wait_time
+
+chat_in_use, chat_waiting, chat_wait_hist = create_metrics("chat")
+embed_in_use, embed_waiting, embed_wait_hist = create_metrics("embed")
+
+class UnifiedSemaphore:
+    """Threading-based семафор + sync/async API + metrics + контекстники."""
+    def __init__(self, limit, in_use, waiting, wait_hist):
+        self._sem       = threading.Semaphore(limit)
+        self._limit     = limit
+        self._in_use    = in_use
+        self._waiting   = waiting
+        self._wait_hist = wait_hist
+        self._current   = 0
+
+        self._in_use.set(0)
+        self._waiting.set(0)
+
+    # ——— синхронный API ———
+    def acquire(self):
+        self._waiting.inc()
+        start = time.time()
+
+        self._sem.acquire()
+        elapsed = time.time() - start
+        self._wait_hist.observe(elapsed)
+        self._waiting.dec()
+
+        self._current += 1
+        self._in_use.set(self._current)
+
+    def release(self):
+        self._sem.release()
+        self._current -= 1
+        self._in_use.set(self._current)
+
+    # контекстник для sync
+    def __enter__(self):
+        self.acquire()
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        self.release()
+
+    # ——— асинхронный API ———
+    async def acquire_async(self):
+        self._waiting.inc()
+        start = time.time()
+        loop = asyncio.get_running_loop()
+        await loop.run_in_executor(None, self._sem.acquire)
+        elapsed = time.time() - start
+        self._wait_hist.observe(elapsed)
+        self._waiting.dec()
+
+        self._current += 1
+        self._in_use.set(self._current)
+
+    async def release_async(self):
+        # release очень быстрый
+        self._sem.release()
+        self._current -= 1
+        self._in_use.set(self._current)
+
+    # контекстник для async
+    async def __aenter__(self):
+        await self.acquire_async()
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        await self.release_async()
+
+# Semaphores for chat and embeddings
+_semaphores = {
+    "chat": UnifiedSemaphore(MAX_CHAT_CONCURRENCY, chat_in_use, chat_waiting, chat_wait_hist),
+    "embed": UnifiedSemaphore(MAX_EMBED_CONCURRENCY, embed_in_use, embed_waiting, embed_wait_hist),
+}
+
+class ThrottledGigaChatEmbeddings(GigaChatEmbeddings):
+    def embed_documents(self, *args, **kwargs):
+        with _semaphores["embed"]:
+            return super().embed_documents(*args, **kwargs)
+
+    def embed_query(self, *args, **kwargs):
+        # здесь семафор не нужен, под капотом вызвается embed_documents, семафор уже там
+        return super().embed_query(*args, **kwargs)
+
+    async def aembed_documents(self, *args, **kwargs):
+        async with _semaphores["embed"]:
+            return await super().aembed_documents(*args, **kwargs)
+
+    async def aembed_query(self, *args, **kwargs):
+        # здесь семафор не нужен, под капотом вызвается aembed_documents, семафор уже там
+        return await super().aembed_query(*args, **kwargs)
+
+# по хорошему бы переопределять клиент гигачата или манкипатчить его, но это не так просто
+class ThrottledGigaChat(GigaChat):
+    def invoke(self, *args, **kwargs):
+        with _semaphores["chat"]:
+            return super().invoke(*args, **kwargs)
+
+    async def ainvoke(self, *args, **kwargs):
+        async with _semaphores["chat"]:
+            return await super().ainvoke(*args, **kwargs)
+
+    def stream(self, *args, **kwargs):
+        if super()._should_stream(async_api=False, **{**kwargs, "stream": True}):
+            with _semaphores["chat"]:
+                for chunk in super().stream(*args, **kwargs):
+                    yield chunk
+        else:
+            # здесь есть проблема когда внутри stream вызывается invoke, поэтому без семафора
+            for chunk in super().stream(*args, **kwargs):
+                    yield chunk
+
+    async def astream(self, *args, **kwargs):
+        if super()._should_stream(async_api=True, **{**kwargs, "stream": True}):
+            async with _semaphores["chat"]:
+                async for chunk in super().astream(*args, **kwargs):
+                    yield chunk
+        else:
+            # здесь есть проблема когда внутри stream вызывается ainvoke, поэтому без семафора
+            async for chunk in super().astream(*args, **kwargs):
+                yield chunk
+
+    async def astream_events(self, *args, **kwargs):
+        async with _semaphores["chat"]:
+            async for ev in super().astream_events(*args, **kwargs):
+                yield ev
+
+    def batch(self, *args, **kwargs):
+        # здесь семафор не нужен, под капотом вызывается invoke, семафор уже там
+        return super().batch(*args, **kwargs)
+
+    async def abatch(self, *args, **kwargs):
+        # здесь семафор не нужен, под капотом вызывается ainvoke, семафор уже там
+        return await super().abatch(*args, **kwargs)
+
+    def batch_as_completed(self, *args, **kwargs):
+        # здесь семафор не нужен, под капотом вызывается invoke, семафор уже там
+        for item in super().batch_as_completed(*args, **kwargs):
+            yield item
+
+    async def abatch_as_completed(self, *args, **kwargs):
+        # здесь семафор не нужен, под капотом вызывается ainvoke, семафор уже там
+        async for item in super().abatch_as_completed(*args, **kwargs):
+            yield item

agent_lab_sdk/metrics/__init__.py

@@ -0,0 +1,2 @@
+from .metrics import get_metric
+__all__ = ["get_metric"]

agent_lab_sdk/metrics/metrics.py

@@ -0,0 +1,104 @@
+import logging
+from typing import Any, Dict, List, Optional, Tuple, Type, Union
+
+from prometheus_client import Counter, Gauge, Summary, Histogram, Info, Enum
+
+logger = logging.getLogger(__name__)
+
+_metrics: Dict[str, Any] = {}
+
+MetricType = Union[
+    Type[Counter],
+    Type[Gauge],
+    Type[Summary],
+    Type[Histogram],
+    Type[Info],
+    Type[Enum],
+]
+
+_CONSTRUCTORS: Dict[str, MetricType] = {
+    "counter": Counter,
+    "gauge": Gauge,
+    "summary": Summary,
+    "histogram": Histogram,
+    "info": Info,
+    "enum": Enum,
+}
+
+def get_metric(
+    metric_type: str,
+    name: str,
+    documentation: str,
+    *,
+    labelnames: Optional[List[str]] = None,
+    buckets: Optional[List[float]] = None,
+    states: Optional[List[str]] = None,
+    **kwargs
+) -> Any:
+    """
+    Возвращает метрику по name, создаёт её при первом запросе.
+    
+    metric_type  — один из ключей _CONSTRUCTORS ('counter', 'gauge', 'summary', 'histogram', 'info', 'enum').
+    labelnames   — список имён лейблов (для Counter, Gauge, Summary, Histogram).
+    buckets      — для histogram.
+    states       — для enum.
+    kwargs       — остальные параметры конструктору.
+    """
+    if name in _metrics:
+        return _metrics[name]
+
+    ctor = _CONSTRUCTORS.get(metric_type)
+    if ctor is None:
+        raise ValueError(f"Unknown metric type: {metric_type!r}")
+
+    try:
+        # Собираем позиционные и именованные аргументы в зависимости от типа
+        args: Tuple = ()
+        if metric_type == "histogram" and buckets is not None:
+            # Histogram(name, doc, labelnames?, buckets=buckets, **kwargs)
+            args = (name, documentation)
+            if labelnames:
+                args += (labelnames,)
+            _metrics[name] = ctor(*args, buckets=buckets, **kwargs)
+        elif metric_type == "enum" and states is not None:
+            # Enum(name, doc, labelnames?, states=states, **kwargs)
+            args = (name, documentation)
+            if labelnames:
+                args += (labelnames,)
+            _metrics[name] = ctor(*args, states=states, **kwargs)
+        else:
+            # Counter, Gauge, Summary, Info
+            args = (name, documentation)
+            if labelnames:
+                args += (labelnames,)
+            _metrics[name] = ctor(*args, **kwargs)
+
+    except Exception as e:
+        logger.error("Failed to create %s metric '%s': %s", metric_type, name, e)
+        return None
+
+    return _metrics[name]
+
+
+if __name__ == "__main__":
+
+    # получение счётчика
+    reqs = get_metric("http_reqs", "counter", "http_requests_total",
+                    "Всего HTTP-запросов", labelnames=["method", "endpoint"])
+
+    # увеличение
+    if reqs:
+        reqs.labels("GET", "/api").inc()
+
+    # получение гистограммы
+    lat = get_metric("http_latency", "histogram", "http_request_latency_seconds",
+                    "Длительность HTTP-запроса", buckets=[0.1, 0.5, 1.0, 5.0])
+
+    # замер времени через контекст
+    if lat:
+        with lat.time():
+            import time
+            time.sleep(0.5) # имитируем длительный запрос
+            
+    print(reqs.collect())
+    print(lat.collect())

agent_lab_sdk/storage/__init__.py

@@ -0,0 +1,3 @@
+from .storage import store_file_in_sd_asset
+
+__all__ = ["store_file_in_sd_asset"]

agent_lab_sdk/storage/storage.py

@@ -0,0 +1,64 @@
+import base64
+import os
+import mimetypes
+from typing import Optional
+from io import BytesIO
+import requests
+
+def store_file_in_sd_asset(filename: str, file_base64: str, folder: str = "giga-agents") -> Optional[str]:
+    """
+    Загружает файл в формате base64 в SD Asset API и возвращает URL загруженного файла.
+    
+    Args:
+        file_base64: файл в формате base64
+        folder: Название папки для загрузки
+        
+    Returns:
+        URL загруженного файла или None в случае ошибки
+    """
+    # Декодируем base64 в бинарные данные
+    try:
+        file_data = base64.b64decode(file_base64.split(",")[-1])
+    except Exception as e:
+        print(f"Ошибка декодирования base64: {e}")
+        return None
+    
+    # URL API
+    url = "https://asset.tools.sberdevices.ru/api/file/upload"
+    
+    api_key = os.getenv("SD_ASSET_API_KEY")
+    if not api_key:
+        raise ValueError("SD_ASSET_API_KEY is missing")
+    
+    # Заголовки запроса
+    headers = {
+        "X-Api-Key": api_key
+    }
+
+    mimetype, _ = mimetypes.guess_type(filename)
+
+    # Параметры формы
+    files = {
+        "files": (f"{filename}", BytesIO(file_data), mimetype)
+    }
+    
+    # Дополнительные параметры
+    data = {
+        "folder": folder,
+        "uniqueNames": "false",
+        "removable": "true"
+    }
+    
+    try:
+        # Отправляем POST-запрос
+        response = requests.post(url, headers=headers, data=data, files=files)
+        response.raise_for_status()
+        
+        # Получаем URL загруженного файла
+        if response.status_code == 200 and response.json():
+            return response.json()[0].replace('cdn-app.sberdevices.ru', 'cdn-app.giga.chat')
+        
+    except requests.exceptions.RequestException as e:
+        print(f"Ошибка при загрузке файла: {e}")
+    
+    return None

{agent_lab_sdk-0.1.3.dist-info → agent_lab_sdk-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-lab-sdk
-Version: 0.1.3
+Version: 0.1.4
 Summary: SDK для работы с Agent Lab
 Author-email: Andrew Ohurtsov <andermirik@yandex.com>
 License: Proprietary and Confidential — All Rights Reserved
@@ -16,4 +16,8 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: langgraph~=0.4.1
+Requires-Dist: langchain_gigachat
+Requires-Dist: prometheus-client
 Dynamic: license-file

agent_lab_sdk-0.1.4.dist-info/RECORD

@@ -0,0 +1,17 @@
+agent_lab_sdk/__init__.py,sha256=rggZCMNBJ3Vd5rZkC6kepxILIGCCAmFTPHZ-ORv97nY,90
+agent_lab_sdk/langgraph/checkpoint/__init__.py,sha256=DnKwR1LwbaQ3qhb124lE-tnojrUIVcCdNzHEHwgpL5M,86
+agent_lab_sdk/langgraph/checkpoint/agw_saver.py,sha256=ALhZW-7XUIVsbZVjCRVhZcMmcYj_f9k3UU-owaq5vxM,13797
+agent_lab_sdk/llm/__init__.py,sha256=Yo9MbYdHS1iX05A9XiJGwWN1Hm4IARGav9mNFPrtDeA,376
+agent_lab_sdk/llm/agw_token_manager.py,sha256=_bPPI8muaEa6H01P8hHQOJHiiivaLd8N_d3OT9UT_80,4787
+agent_lab_sdk/llm/gigachat_token_manager.py,sha256=TPA8cb0ypdWtRTI5C7GItL9jbLt93vR-Ijf2yMrOytQ,7921
+agent_lab_sdk/llm/llm.py,sha256=NOEH9TOH66EIJXGevxPm6w6px7Z0cZl9DJ-9A7jOnd0,873
+agent_lab_sdk/llm/throttled.py,sha256=9_nm1i3Uuep0VEWsY1KNCllZA-vM202XVdlgXhgC8BA,7005
+agent_lab_sdk/metrics/__init__.py,sha256=G4VSlzKwupPMM4c6vZaF1rnd0KusKarezDMjli9pVFw,57
+agent_lab_sdk/metrics/metrics.py,sha256=2e0c7BanThUNtCxpS6BUlAIDoLSidQsuaaBP5EB48Yo,3432
+agent_lab_sdk/storage/__init__.py,sha256=ik1_v1DMTwehvcAEXIYxuvLuCjJCa3y5qAuJqoQpuSA,81
+agent_lab_sdk/storage/storage.py,sha256=ELpt7GRwFD-aWa6ctinfA_QwcvzWLvKS0Wz8FlxVqAs,2075
+agent_lab_sdk-0.1.4.dist-info/licenses/LICENSE,sha256=_TRXHkF3S9ilWBPdZcHLI_S-PRjK0L_SeOb2pcPAdV4,417
+agent_lab_sdk-0.1.4.dist-info/METADATA,sha256=cfGy-8cVIcRC7IhJKxUCb27nPC5vnOBuSwTpTKmetcA,884
+agent_lab_sdk-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+agent_lab_sdk-0.1.4.dist-info/top_level.txt,sha256=E1efqkJ89KNmPBWdLzdMHeVtH0dYyCo4fhnSb81_15I,14
+agent_lab_sdk-0.1.4.dist-info/RECORD,,

agent_lab_sdk-0.1.3.dist-info/RECORD

@@ -1,6 +0,0 @@
-agent_lab_sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-agent_lab_sdk-0.1.3.dist-info/licenses/LICENSE,sha256=_TRXHkF3S9ilWBPdZcHLI_S-PRjK0L_SeOb2pcPAdV4,417
-agent_lab_sdk-0.1.3.dist-info/METADATA,sha256=yvcBFQxv8NoD7Gqe3mthMUkwgfJrd_pnTfafa8bZT5M,761
-agent_lab_sdk-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-agent_lab_sdk-0.1.3.dist-info/top_level.txt,sha256=E1efqkJ89KNmPBWdLzdMHeVtH0dYyCo4fhnSb81_15I,14
-agent_lab_sdk-0.1.3.dist-info/RECORD,,