agent-lab-sdk 0.1.35__py3-none-any.whl → 0.1.35.dev1__py3-none-any.whl

agent_lab_sdk/langgraph/checkpoint/agw_saver.py

@@ -1,19 +1,18 @@
 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 random import random
 from typing import Any, AsyncIterator, Dict, Iterator, Optional, Sequence, Tuple
-import logging
 
 import httpx
+import orjson
 from langchain_core.runnables import RunnableConfig
 
 from langgraph.checkpoint.base import (
-    WRITES_IDX_MAP,
     BaseCheckpointSaver,
     ChannelVersions,
     Checkpoint,
@@ -23,20 +22,27 @@ from langgraph.checkpoint.base import (
     get_checkpoint_metadata,
 )
 from langgraph.checkpoint.serde.base import SerializerProtocol
+from langgraph.checkpoint.serde.encrypted import EncryptedSerializer
+from langgraph.checkpoint.serde.types import ChannelProtocol
+from .serde import Serializer
 
 __all__ = ["AsyncAGWCheckpointSaver"]
 
 logger = logging.getLogger(__name__)
 
-# ------------------------------------------------------------------ #
-# helpers for Py < 3.10
-# ------------------------------------------------------------------ #
-try:
-    anext  # type: ignore[name-defined]
-except NameError:  # pragma: no cover
+TYPED_KEYS = ("type", "blob")
+
+
+def _to_b64(b: bytes | None) -> str | None:
+    return base64.b64encode(b).decode() if b is not None else None
+
 
-    async def anext(it):
-        return await it.__anext__()
+def _b64decode_strict(s: str) -> bytes | None:
+    """Возвращает bytes только если строка действительно корректная base64."""
+    try:
+        return base64.b64decode(s, validate=True)
+    except Exception:
+        return None
 
 
 class AsyncAGWCheckpointSaver(BaseCheckpointSaver):
@@ -53,6 +59,19 @@ class AsyncAGWCheckpointSaver(BaseCheckpointSaver):
         extra_headers: Dict[str, str] | None = None,
         verify: bool = True,
     ):
+        if not serde:
+            base_serde: SerializerProtocol = Serializer()
+            # опционально оборачиваем в AES по ENV
+            _aes_key = (
+                os.getenv("LANGGRAPH_AES_KEY")
+                or os.getenv("AGW_AES_KEY")
+                or os.getenv("AES_KEY")
+            )
+            if _aes_key:
+                base_serde = EncryptedSerializer.from_pycryptodome_aes(
+                    base_serde, key=_aes_key
+                )
+            serde = base_serde
         super().__init__(serde=serde)
         self.base_url = base_url.rstrip("/")
         self.timeout = timeout
@@ -66,13 +85,13 @@ class AsyncAGWCheckpointSaver(BaseCheckpointSaver):
             self.headers.update(extra_headers)
         if api_key:
             self.headers["Authorization"] = f"Bearer {api_key}"
-            
+
         self._client = httpx.AsyncClient(
             base_url=self.base_url,
             headers=self.headers,
             timeout=self.timeout,
             verify=verify,
-            trust_env=True
+            trust_env=True,
         )
 
     async def __aenter__(self):  # noqa: D401
@@ -81,56 +100,63 @@ class AsyncAGWCheckpointSaver(BaseCheckpointSaver):
     async def __aexit__(self, exc_type, exc, tb):  # noqa: D401
         await self._client.aclose()
 
-    # ----------------------- 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 orjson.loads(s)
-            except (UnicodeDecodeError, orjson.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(orjson.dumps(obj))
+    # ----------------------- typed (de)serialize ---------------------
+    def _encode_typed(self, value: Any) -> dict[str, Any]:
+        """value -> {"type": str, "blob": base64str | null}"""
+        t, b = self.serde.dumps_typed(value)
+        return {"type": t, "blob": _to_b64(b)}
+
+    def _decode_typed(self, obj: Any) -> Any:
+        """{type, blob} | [type, blob] | legacy -> python."""
+        # Новый формат: dict с ключами type/blob — только если blob валидная base64 или None
+        if isinstance(obj, dict) and all(k in obj for k in TYPED_KEYS):
+            t = obj.get("type")
+            b64 = obj.get("blob")
+            if b64 is None:
+                return self.serde.loads_typed((t, None))
+            if isinstance(b64, str):
+                b = _b64decode_strict(b64)
+                if b is not None:
+                    return self.serde.loads_typed((t, b))
+            # если невалидно — падаем ниже на общую обработку
+
+        # Допускаем tuple/list вида [type, base64] — только при валидной base64
+        if isinstance(obj, (list, tuple)) and len(obj) == 2 and isinstance(obj[0], str):
+            t, b64 = obj
+            if b64 is None and t == "empty":
+                return self.serde.loads_typed((t, None))
+            if isinstance(b64, str):
+                b = _b64decode_strict(b64)
+                if b is not None:
+                    return self.serde.loads_typed((t, b))
+            # иначе это не typed-пара
+
+        # Если это строка — пробуем как base64 строго, затем как JSON-строку
         if isinstance(obj, str):
-            # сначала plain JSON-строка
+            b = _b64decode_strict(obj)
+            if b is not None:
+                try:
+                    return self.serde.loads(b)
+                except Exception:
+                    pass
             try:
                 return self.serde.loads(obj.encode())
             except Exception:
-                # возможно base64
-                try:
-                    return self.serde.loads(base64.b64decode(obj))
-                except Exception:
-                    return obj
+                return obj
+
+        # dict/list -> считаем это уже JSON и грузим через serde
+        if isinstance(obj, (dict, list)):
+            try:
+                return self.serde.loads(orjson.dumps(obj))
+            except Exception:
+                return obj
+
+        # как есть пробуем через serde
         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:
@@ -148,28 +174,53 @@ class AsyncAGWCheckpointSaver(BaseCheckpointSaver):
 
     # --------------------- checkpoint (de)ser ------------------------
     def _encode_cp(self, cp: Checkpoint) -> Dict[str, Any]:
+        channel_values = {
+            k: self._encode_typed(v) for k, v in cp.get("channel_values", {}).items()
+        }
+        pending = []
+        for item in cp.get("pending_sends", []) or []:
+            try:
+                channel, value = item
+                pending.append({"channel": channel, **self._encode_typed(value)})
+            except Exception:
+                continue
         return {
             "v": cp["v"],
             "id": cp["id"],
             "ts": cp["ts"],
-            "channelValues": {k: self._safe_dump(v) for k, v in cp["channel_values"].items()},
+            "channelValues": channel_values,
             "channelVersions": cp["channel_versions"],
             "versionsSeen": cp["versions_seen"],
-            "pendingSends": cp.get("pending_sends", []),
+            "pendingSends": pending,
         }
 
     def _decode_cp(self, raw: Dict[str, Any]) -> Checkpoint:
+        cv_raw = raw.get("channelValues") or {}
+        channel_values = {k: self._decode_typed(v) for k, v in cv_raw.items()}
+        ps_raw = raw.get("pendingSends") or []
+        pending_sends = []
+        for obj in ps_raw:
+            # ожидаем {channel, type, blob}
+            if isinstance(obj, dict) and "channel" in obj:
+                ch = obj["channel"]
+                typed = {k: obj[k] for k in obj.keys() if k in TYPED_KEYS}
+                val = self._decode_typed(typed)
+                pending_sends.append((ch, val))
+            elif isinstance(obj, (list, tuple)) and len(obj) == 2:
+                ch, val = obj
+                pending_sends.append((ch, self._decode_typed(val)))
+
         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_values=channel_values,
             channel_versions=raw["channelVersions"],
             versions_seen=raw["versionsSeen"],
-            pending_sends=raw.get("pendingSends", []),
+            pending_sends=pending_sends,
         )
 
-    def _decode_config(self, raw: Dict[str, Any]) -> Optional[RunnableConfig]:
+    def _decode_config(self, raw: Dict[str, Any] | None) -> Optional[RunnableConfig]:
         if not raw:
             return None
         return RunnableConfig(
@@ -179,7 +230,7 @@ class AsyncAGWCheckpointSaver(BaseCheckpointSaver):
             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"))
+            configurable=self._decode_configurable(raw.get("configurable") or {}),
         )
 
     def _decode_configurable(self, raw: Dict[str, Any]) -> dict[str, Any]:
@@ -187,41 +238,52 @@ class AsyncAGWCheckpointSaver(BaseCheckpointSaver):
             "thread_id": raw.get("threadId"),
             "thread_ts": raw.get("threadTs"),
             "checkpoint_ns": raw.get("checkpointNs"),
-            "checkpoint_id": raw.get("checkpointId")
+            "checkpoint_id": raw.get("checkpointId"),
         }
 
-    # metadata (de)ser
+    # metadata (de)ser — передаём как есть (JSON-совместимый словарь)
     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
+        return md or {}
 
     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)
+        return md
 
     # ------------------------ HTTP wrapper ---------------------------
     async def _http(self, method: str, path: str, **kw) -> httpx.Response:
         if "json" in kw:
             payload = kw.pop("json")
             kw["data"] = orjson.dumps(payload)
-            logger.info(kw["data"].decode())
-            
+            logger.debug("AGW HTTP payload: %s", kw["data"].decode())
         return await self._client.request(method, path, **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"]]
+        pending_writes = None
+        raw_pw = node.get("pendingWrites")
+        if raw_pw:
+            decoded: list[tuple[str, str, Any]] = []
+            for w in raw_pw:
+                if isinstance(w, dict) and "first" in w and "second" in w:
+                    # ожидаем формат, который возвращает бек: first=task_id, second=channel, third=typed
+                    task_id = w["first"]
+                    channel = w["second"]
+                    tv = w.get("third")
+                    value = self._decode_typed(tv)
+                    decoded.append((task_id, channel, value))
+                elif isinstance(w, (list, tuple)):
+                    try:
+                        first, channel, tv = w
+                        decoded.append((first, channel, self._decode_typed(tv)))
+                    except Exception:  # pragma: no cover
+                        continue
+            pending_writes = decoded
+
         return CheckpointTuple(
-            config=self._decode_config(node["config"]),
+            config=self._decode_config(node.get("config")),
             checkpoint=self._decode_cp(node["checkpoint"]),
-            metadata=self._dec_meta(node["metadata"]),
+            metadata=self._dec_meta(node.get("metadata")),
             parent_config=self._decode_config(node.get("parentConfig")),
-            pending_writes=pending,
+            pending_writes=pending_writes,
         )
 
     # =================================================================
@@ -230,7 +292,7 @@ class AsyncAGWCheckpointSaver(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"]
+        tid = api_cfg.get("threadId")
 
         if cid:
             path = f"/checkpoint/{tid}/{cid}"
@@ -242,9 +304,7 @@ class AsyncAGWCheckpointSaver(BaseCheckpointSaver):
         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):
+        if not resp.text or resp.status_code in (404, 406):
             return None
         resp.raise_for_status()
         return self._to_tuple(resp.json())
@@ -279,7 +339,7 @@ class AsyncAGWCheckpointSaver(BaseCheckpointSaver):
         payload = {
             "config": self._to_api_config(cfg),
             "checkpoint": self._encode_cp(cp),
-            "metadata": self._enc_meta(get_checkpoint_metadata(cfg, metadata)),
+            "metadata": get_checkpoint_metadata(cfg, metadata),
             "newVersions": new_versions,
         }
         resp = await self._http("POST", "/checkpoint", json=payload)
@@ -294,7 +354,7 @@ class AsyncAGWCheckpointSaver(BaseCheckpointSaver):
         task_id: str,
         task_path: str = "",
     ) -> None:
-        enc = [{"first": ch, "second": self._safe_dump(v)} for ch, v in writes]
+        enc = [{"first": ch, "second": self._encode_typed(v)} for ch, v in writes]
         payload = {
             "config": self._to_api_config(cfg),
             "writes": enc,

agent_lab_sdk/langgraph/checkpoint/serde.py

@@ -0,0 +1,172 @@
+import asyncio
+import re
+import uuid
+from base64 import b64encode
+from collections import deque
+from collections.abc import Mapping
+from datetime import timedelta, timezone
+from decimal import Decimal
+from ipaddress import (
+    IPv4Address,
+    IPv4Interface,
+    IPv4Network,
+    IPv6Address,
+    IPv6Interface,
+    IPv6Network,
+)
+from pathlib import Path
+from re import Pattern
+from typing import Any, NamedTuple
+from zoneinfo import ZoneInfo
+
+import cloudpickle
+import orjson
+import logging
+from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
+
+logger = logging.getLogger(__name__)
+
+
+class Fragment(NamedTuple):
+    buf: bytes
+
+
+def decimal_encoder(dec_value: Decimal) -> int | float:
+    """
+    Encodes a Decimal as int of there's no exponent, otherwise float
+
+    This is useful when we use ConstrainedDecimal to represent Numeric(x,0)
+    where a integer (but not int typed) is used. Encoding this as a float
+    results in failed round-tripping between encode and parse.
+    Our Id type is a prime example of this.
+
+    >>> decimal_encoder(Decimal("1.0"))
+    1.0
+
+    >>> decimal_encoder(Decimal("1"))
+    1
+    """
+    if dec_value.as_tuple().exponent >= 0:
+        return int(dec_value)
+    else:
+        return float(dec_value)
+
+
+def default(obj):
+    # Only need to handle types that orjson doesn't serialize by default
+    # https://github.com/ijl/orjson#serialize
+    if isinstance(obj, Fragment):
+        return orjson.Fragment(obj.buf)
+    if (
+        hasattr(obj, "model_dump")
+        and callable(obj.model_dump)
+        and not isinstance(obj, type)
+    ):
+        return obj.model_dump()
+    elif hasattr(obj, "dict") and callable(obj.dict) and not isinstance(obj, type):
+        return obj.dict()
+    elif (
+        hasattr(obj, "_asdict") and callable(obj._asdict) and not isinstance(obj, type)
+    ):
+        return obj._asdict()
+    elif isinstance(obj, BaseException):
+        return {"error": type(obj).__name__, "message": str(obj)}
+    elif isinstance(obj, (set, frozenset, deque)):  # noqa: UP038
+        return list(obj)
+    elif isinstance(obj, (timezone, ZoneInfo)):  # noqa: UP038
+        return obj.tzname(None)
+    elif isinstance(obj, timedelta):
+        return obj.total_seconds()
+    elif isinstance(obj, Decimal):
+        return decimal_encoder(obj)
+    elif isinstance(obj, uuid.UUID):
+        return str(obj)
+    elif isinstance(  # noqa: UP038
+        obj,
+        (
+            IPv4Address,
+            IPv4Interface,
+            IPv4Network,
+            IPv6Address,
+            IPv6Interface,
+            IPv6Network,
+            Path,
+        ),
+    ):
+        return str(obj)
+    elif isinstance(obj, Pattern):
+        return obj.pattern
+    elif isinstance(obj, bytes | bytearray):
+        return b64encode(obj).decode()
+    return None
+
+
+_option = orjson.OPT_SERIALIZE_NUMPY | orjson.OPT_NON_STR_KEYS
+
+_SURROGATE_RE = re.compile(r"[\ud800-\udfff]")
+
+
+def _strip_surr(s: str) -> str:
+    return s if _SURROGATE_RE.search(s) is None else _SURROGATE_RE.sub("", s)
+
+
+def _sanitise(o: Any) -> Any:
+    if isinstance(o, str):
+        return _strip_surr(o)
+    if isinstance(o, Mapping):
+        return {_sanitise(k): _sanitise(v) for k, v in o.items()}
+    if isinstance(o, list | tuple | set):
+        ctor = list if isinstance(o, list) else type(o)
+        return ctor(_sanitise(x) for x in o)
+    return o
+
+
+def json_dumpb(obj) -> bytes:
+    try:
+        dumped = orjson.dumps(obj, default=default, option=_option)
+    except TypeError as e:
+        if "surrogates not allowed" not in str(e):
+            raise
+        dumped = orjson.dumps(_sanitise(obj), default=default, option=_option)
+    return (
+        # Unfortunately simply doing ``.replace(rb"\\u0000", b"")`` on
+        # the dumped bytes can leave an **orphaned back-slash** (e.g. ``\\q``)
+        # which makes the resulting JSON invalid.  The fix is to delete the *double*
+        # back-slash form **first**, then (optionally) the single-escapes.
+        dumped.replace(rb"\\u0000", b"").replace(rb"\u0000", b"")
+    )
+
+
+def json_loads(content: bytes | Fragment | dict) -> Any:
+    if isinstance(content, Fragment):
+        content = content.buf
+    if isinstance(content, dict):
+        return content
+    return orjson.loads(content)
+
+
+async def ajson_loads(content: bytes | Fragment) -> Any:
+    return await asyncio.to_thread(json_loads, content)
+
+
+class Serializer(JsonPlusSerializer):
+    def dumps_typed(self, obj: Any) -> tuple[str, bytes]:
+        try:
+            return super().dumps_typed(obj)
+        except TypeError:
+            return "pickle", cloudpickle.dumps(obj)
+
+    def dumps(self, obj: Any) -> bytes:
+        # See comment above (in json_dumpb)
+        return super().dumps(obj).replace(rb"\\u0000", b"").replace(rb"\u0000", b"")
+
+    def loads_typed(self, data: tuple[str, bytes]) -> Any:
+        if data[0] == "pickle":
+            try:
+                return cloudpickle.loads(data[1])
+            except Exception as e:
+                logger.warning(
+                    "Failed to unpickle object, replacing w None", exc_info=e
+                )
+                return None
+        return super().loads_typed(data)

{agent_lab_sdk-0.1.35.dist-info → agent_lab_sdk-0.1.35.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-lab-sdk
-Version: 0.1.35
+Version: 0.1.35.dev1
 Summary: SDK для работы с Agent Lab
 Author-email: Andrew Ohurtsov <andermirik@yandex.com>
 License: Proprietary and Confidential — All Rights Reserved
@@ -25,6 +25,7 @@ Requires-Dist: prometheus-client
 Requires-Dist: langchain
 Requires-Dist: httpx
 Requires-Dist: orjson
+Requires-Dist: cloudpickle
 Dynamic: license-file
 
 # Agent Lab SDK

{agent_lab_sdk-0.1.35.dist-info → agent_lab_sdk-0.1.35.dev1.dist-info}/RECORD

@@ -1,6 +1,7 @@
 agent_lab_sdk/__init__.py,sha256=1Dlmv-wuz1QuciymKtYtX7jXzr_fkeGTe7aENfEDl3E,108
 agent_lab_sdk/langgraph/checkpoint/__init__.py,sha256=DnKwR1LwbaQ3qhb124lE-tnojrUIVcCdNzHEHwgpL5M,86
-agent_lab_sdk/langgraph/checkpoint/agw_saver.py,sha256=K4ni4x6bMibkC9PphEll7RLtbKbaHCGTz0uM6ouQaV0,13763
+agent_lab_sdk/langgraph/checkpoint/agw_saver.py,sha256=QeYUAGEldw9SNXup3FRI7gNcGXYQDecKhoF1NyXa7yQ,16365
+agent_lab_sdk/langgraph/checkpoint/serde.py,sha256=UTSYbTbhBeL1CAr-XMbaH3SSIx9TeiC7ak22duXvqkw,5175
 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=nlOxHcwJovsmM4cpI4fwMrYjoSeMjelDaHTipXsrUuA,8282
@@ -13,8 +14,8 @@ agent_lab_sdk/schema/input_types.py,sha256=e75nRW7Dz_RHk5Yia8DkFfbqMafsLQsQrJPfz
 agent_lab_sdk/schema/log_message.py,sha256=nadi6lZGRuDSPmfbYs9QPpRJUT9Pfy8Y7pGCvyFF5Mw,638
 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.35.dist-info/licenses/LICENSE,sha256=_TRXHkF3S9ilWBPdZcHLI_S-PRjK0L_SeOb2pcPAdV4,417
-agent_lab_sdk-0.1.35.dist-info/METADATA,sha256=U8K4oMgtKBD5uMVi3RhDRkkdSUIjZF1y3GcLgvCzN-g,17884
-agent_lab_sdk-0.1.35.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-agent_lab_sdk-0.1.35.dist-info/top_level.txt,sha256=E1efqkJ89KNmPBWdLzdMHeVtH0dYyCo4fhnSb81_15I,14
-agent_lab_sdk-0.1.35.dist-info/RECORD,,
+agent_lab_sdk-0.1.35.dev1.dist-info/licenses/LICENSE,sha256=_TRXHkF3S9ilWBPdZcHLI_S-PRjK0L_SeOb2pcPAdV4,417
+agent_lab_sdk-0.1.35.dev1.dist-info/METADATA,sha256=MsteJ1L7FktEWd45-MkhTlgxWHevOduYeL1prnNTjJY,17916
+agent_lab_sdk-0.1.35.dev1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+agent_lab_sdk-0.1.35.dev1.dist-info/top_level.txt,sha256=E1efqkJ89KNmPBWdLzdMHeVtH0dYyCo4fhnSb81_15I,14
+agent_lab_sdk-0.1.35.dev1.dist-info/RECORD,,