langgraph-api 0.7.78__tar.gz → 0.7.80__tar.gz

{langgraph_api-0.7.78 → langgraph_api-0.7.80}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.7.78
+Version: 0.7.80
 Author-email: Will Fu-Hinthorn <will@langchain.dev>, Josh Rogers <josh@langchain.dev>, Parker Rule <parker@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE
@@ -24,7 +24,7 @@ Requires-Dist: opentelemetry-sdk>=1.37.0
 Requires-Dist: orjson>=3.9.7
 Requires-Dist: protobuf<7.0.0,>=6.32.1
 Requires-Dist: pyjwt>=2.9.0
-Requires-Dist: sse-starlette<3.4.0,>=3.0.0
+Requires-Dist: sse-starlette<3.4.0,>=2.1.3
 Requires-Dist: starlette>=0.38.6
 Requires-Dist: structlog<26,>=24.1.0
 Requires-Dist: tenacity>=8.0.0

langgraph_api-0.7.80/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.7.80"

{langgraph_api-0.7.78 → langgraph_api-0.7.80}/langgraph_api/_checkpointer/_adapter.py

@@ -309,7 +309,7 @@ async def get_checkpointer(
         # Create a fresh adapter each time (not cached) - each gets own latest_iter
         if _CHECKPOINTER_CAPABILITIES is None:
             raise RuntimeError("Capabilities not initialized")
-        return _CustomCheckpointerAdapter(  # type: ignore[return-value]
+        return _CustomCheckpointerAdapter(
             inner=CHECKPOINTER_STACK.inner, capabilities=_CHECKPOINTER_CAPABILITIES
         )
 
@@ -431,7 +431,7 @@ def _load_checkpointer(checkpointer_path: str) -> Any:
                     raise ValueError(f"Could not find checkpointer file: {path_name}")
                 module = importlib.util.module_from_spec(modspec)
                 sys.modules[modname] = module
-                modspec.loader.exec_module(module)  # type: ignore[possibly-unbound-attribute]
+                modspec.loader.exec_module(module)
         else:
             path_name, function = checkpointer_path.rsplit(".", 1)
             module = importlib.import_module(path_name)

{langgraph_api-0.7.78 → langgraph_api-0.7.80}/langgraph_api/auth/custom.py

@@ -251,7 +251,7 @@ def _get_auth_instance(path: str | None = None) -> Auth | Literal["js"] | None:
         deps := _get_dependencies(auth_instance._authenticate_handler)
     ):
         auth_instance._authenticate_handler = _solve_fastapi_dependencies(
-            auth_instance._authenticate_handler,  # type: ignore[invalid-argument-type]
+            auth_instance._authenticate_handler,
             deps,
         )
     logger.info(f"Loaded auth instance from path {path}: {auth_instance}")
@@ -631,7 +631,7 @@ def _load_auth_obj(path: str) -> Auth | Literal["js"]:
                     raise ValueError(f"Could not load file: {module_name}")
                 module = importlib.util.module_from_spec(modspec)
                 sys.modules[modname] = module
-                modspec.loader.exec_module(module)  # type: ignore[possibly-unbound-attribute]
+                modspec.loader.exec_module(module)
             else:
                 # Load from Python module
                 module = importlib.import_module(module_name)

langgraph_api-0.7.80/langgraph_api/cache.py

@@ -0,0 +1,418 @@
+"""Basic distributed key/value cache for internal use."""
+
+import asyncio
+import logging
+import time
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from datetime import timedelta
+from typing import Any, Generic, Literal, TypedDict, TypeVar, cast
+
+import orjson
+
+from langgraph_api.feature_flags import IS_POSTGRES_OR_GRPC_BACKEND
+from langgraph_api.utils.cache import LRUCache
+
+MAX_CACHE_TTL = timedelta(hours=24)
+
+if IS_POSTGRES_OR_GRPC_BACKEND:
+    from langgraph_api.grpc.ops.cache import cache_get as _cache_get
+    from langgraph_api.grpc.ops.cache import cache_set as _cache_set
+else:
+    _CACHE: LRUCache[bytes] = LRUCache(ttl=MAX_CACHE_TTL.total_seconds())
+
+    async def _cache_get(key: str) -> bytes | None:
+        return await _CACHE.get(key)
+
+    async def _cache_set(key: str, value: bytes, ttl: timedelta | None = None) -> None:
+        ttl = _clamp_ttl(ttl)
+        _CACHE.set(key, value)
+
+
+logger = logging.getLogger(__name__)
+
+_SWR_KEY_PREFIX = "__lg_swr__:"
+_SWR_SCHEMA_VERSION = 1
+_DELTA_ZERO = timedelta(0)
+_UNSET: Any = object()
+
+
+JsonValue = dict[str, Any] | list[Any] | str | int | float | bool | None
+
+CacheStatus = Literal["miss", "fresh", "stale", "expired"]
+
+T = TypeVar("T")
+
+__all__ = ["CacheStatus", "JsonValue", "SWRResult", "cache_get", "cache_set", "swr"]
+
+
+class SWRResult(Generic[T]):
+    """Result wrapper returned by :func:`swr`.
+
+    Attributes:
+        value: The cached (or freshly loaded) value.
+        status: How the value was resolved: ``"miss"``, ``"fresh"``,
+            ``"stale"``, or ``"expired"``.
+    """
+
+    __slots__ = ("_cache_key", "_loader", "_max_age", "_model", "status", "value")
+
+    def __init__(
+        self,
+        value: T,
+        *,
+        cache_key: str,
+        loader: Callable[[], Awaitable[Any]],
+        max_age: timedelta,
+        status: CacheStatus,
+        model: type[T] | None = None,
+    ) -> None:
+        self.value = value
+        self._cache_key = cache_key
+        self._loader = loader
+        self._max_age = max_age
+        self._model = model
+        self.status: CacheStatus = status
+
+    async def mutate(self, value: T = _UNSET) -> T:  # ty: ignore[invalid-parameter-default]
+        """Update or revalidate the cached value.
+
+        Args:
+            value: If provided, optimistically write this value into the cache.
+                If omitted, re-run the original loader to revalidate.
+
+        Returns:
+            The new cached value.
+        """
+        if value is _UNSET:
+            raw = await _await_swr_load(self._cache_key, self._loader, self._max_age)
+            result = (
+                cast("T", self._model.model_validate(raw))
+                if self._model is not None
+                else cast("T", raw)
+            )
+        else:
+            raw = value.model_dump(mode="json") if self._model is not None else value
+            await _write_swr_value(self._cache_key, raw, self._max_age)
+            result = value
+        self.value = result
+        return result
+
+    def __repr__(self) -> str:
+        return f"SWRResult(value={self.value!r}, status={self.status!r})"
+
+
+async def cache_get(key: str) -> Any | None:
+    """Get a value from the cache."""
+    val = await _cache_get(key)
+    return orjson.loads(val) if val is not None else None
+
+
+async def cache_set(key: str, value: Any, ttl: timedelta | None = None) -> None:
+    """Set a value in the cache.
+
+    Args:
+        key: The cache key.
+        value: The value to cache (must be serializable to JSON).
+        ttl: Optional time-to-live.  Capped at MAX_CACHE_TTL (24 hours by default);
+            `None` or zero defaults to MAX_CACHE_TTL.
+    """
+    ttl = _clamp_ttl(ttl)
+    await _cache_set(key, orjson.dumps(value), ttl)
+
+
+class _SWREntry(TypedDict):
+    v: int
+    value: Any
+    stored_at_ms: int
+
+
+@dataclass(slots=True)
+class _SWRState:
+    task: asyncio.Task[Any] | None = None
+    write_epoch: int = 0
+    write_lock: asyncio.Lock = field(default_factory=asyncio.Lock)
+    users: int = 0
+
+
+_SWR_STATES: dict[str, _SWRState] = {}
+
+
+async def swr(
+    key: str,
+    loader: Callable[[], Awaitable[T]],
+    *,
+    fresh_for: timedelta = _DELTA_ZERO,
+    max_age: timedelta | None = None,
+    model: type[T] | None = None,
+) -> SWRResult[T]:
+    """Load a cached value using stale-while-revalidate semantics.
+
+    This helper is server-side only and is intended for caching internal async
+    dependencies such as auth or metadata lookups.
+
+    Args:
+        key: Cache key.
+        loader: Async callable that fetches the value on miss/revalidation.
+        fresh_for: How long a cached value is considered fresh (no revalidation).
+            Defaults to ``timedelta(0)`` so every access triggers a background
+            revalidate while still returning the cached value instantly. Values
+            above :data:`MAX_CACHE_TTL` are clamped to the backend maximum.
+        max_age: Total lifetime of a cached entry. After this, the next access
+            blocks on the loader. Defaults to :data:`MAX_CACHE_TTL` (24 h by
+            default). Values above :data:`MAX_CACHE_TTL` are clamped to the
+            backend maximum.
+        model: Optional Pydantic model class. When provided, values are
+            serialized via ``model_dump(mode="json")`` before storage and
+            deserialized via ``model.model_validate()`` on read.
+
+    Returns:
+        An :class:`SWRResult` with ``.value``, ``.status``, and an async
+        ``.mutate()`` method.
+
+    Semantics:
+    - cache miss: await ``loader()``, store the value, return it
+    - fresh hit (age < fresh_for): return the cached value
+    - stale hit (fresh_for <= age < max_age): return the cached value
+      immediately and trigger a best-effort background refresh
+    - expired (age >= max_age): await ``loader()``, store the value, return it
+    """
+    resolved_fresh_for = min(fresh_for, MAX_CACHE_TTL)
+    resolved_max_age = _resolve_swr_max_age(max_age)
+    fresh_for_ms, max_age_ms, resolved_max_age = _validate_swr_windows(
+        resolved_fresh_for, resolved_max_age
+    )
+    cache_key = _swr_cache_key(key)
+
+    # When a pydantic model is provided, wrap the loader to serialize before
+    # storage and deserialize after reads.  The internal helpers always deal
+    # with plain JSON-compatible values.
+    if model is not None and hasattr(model, "model_validate"):
+        _original_loader = loader
+
+        async def _json_loader() -> Any:
+            val = await _original_loader()
+            return val.model_dump(mode="json")
+
+        json_loader: Callable[[], Awaitable[Any]] = _json_loader
+
+        def _deserialize(raw: Any) -> T:
+            return cast("T", model.model_validate(raw))  # ty: ignore[call-non-callable]
+    else:
+        json_loader = loader
+
+        def _deserialize(raw: Any) -> T:
+            return cast("T", raw)
+
+    def _result(value: T, status: CacheStatus) -> SWRResult[T]:
+        return SWRResult(
+            value,
+            cache_key=cache_key,
+            loader=json_loader,
+            max_age=resolved_max_age,
+            status=status,
+            model=model,
+        )
+
+    entry = _parse_swr_entry(await cache_get(cache_key))
+    if entry is None:
+        raw = await _await_swr_load(cache_key, json_loader, resolved_max_age)
+        return _result(_deserialize(raw), "miss")
+
+    age_ms = max(0, _now_ms() - entry["stored_at_ms"])
+    cached_value = _deserialize(entry["value"])
+
+    if age_ms < fresh_for_ms:
+        return _result(cached_value, "fresh")
+
+    if age_ms < max_age_ms:
+        _start_swr_refresh(cache_key, json_loader, resolved_max_age)
+        return _result(cached_value, "stale")
+
+    raw = await _await_swr_load(cache_key, json_loader, resolved_max_age)
+    return _result(_deserialize(raw), "expired")
+
+
+def _clamp_ttl(ttl: timedelta | None) -> timedelta:
+    """Normalise caller-supplied TTL: None/0 -> MAX, >MAX -> MAX."""
+    if ttl is None or ttl <= timedelta(0):
+        return MAX_CACHE_TTL
+    return min(ttl, MAX_CACHE_TTL)
+
+
+def _resolve_swr_max_age(max_age: timedelta | None) -> timedelta:
+    if max_age is None:
+        return MAX_CACHE_TTL
+    if max_age <= _DELTA_ZERO:
+        return max_age
+    return min(max_age, MAX_CACHE_TTL)
+
+
+def _swr_cache_key(key: str) -> str:
+    return f"{_SWR_KEY_PREFIX}{key}"
+
+
+def _validate_swr_windows(
+    fresh_for: timedelta, max_age: timedelta
+) -> tuple[int, int, timedelta]:
+    if fresh_for < _DELTA_ZERO:
+        raise ValueError("fresh_for must be >= 0")
+    if max_age <= _DELTA_ZERO:
+        raise ValueError("max_age must be > 0")
+    if fresh_for > max_age:
+        raise ValueError("fresh_for must be <= max_age")
+
+    return (
+        int(fresh_for.total_seconds() * 1000),
+        int(max_age.total_seconds() * 1000),
+        max_age,
+    )
+
+
+def _now_ms() -> int:
+    return time.time_ns() // 1_000_000
+
+
+def _parse_swr_entry(value: Any) -> _SWREntry | None:
+    if not isinstance(value, dict):
+        return None
+
+    version = value.get("v")
+    stored_at_ms = value.get("stored_at_ms")
+    if version != _SWR_SCHEMA_VERSION or not isinstance(stored_at_ms, int):
+        return None
+    if "value" not in value:
+        return None
+
+    return {
+        "v": _SWR_SCHEMA_VERSION,
+        "value": value["value"],
+        "stored_at_ms": stored_at_ms,
+    }
+
+
+def _acquire_swr_state(cache_key: str) -> _SWRState:
+    state = _SWR_STATES.get(cache_key)
+    if state is None:
+        state = _SWRState()
+        _SWR_STATES[cache_key] = state
+    state.users += 1
+    return state
+
+
+def _release_swr_state(cache_key: str, state: _SWRState) -> None:
+    state.users -= 1
+    _maybe_cleanup_swr_state(cache_key, state)
+
+
+def _maybe_cleanup_swr_state(cache_key: str, state: _SWRState) -> None:
+    if (
+        state.users == 0
+        and state.task is None
+        and not state.write_lock.locked()
+        and _SWR_STATES.get(cache_key) is state
+    ):
+        _SWR_STATES.pop(cache_key, None)
+
+
+async def _cache_swr_entry(cache_key: str, value: Any, ttl: timedelta) -> None:
+    entry: _SWREntry = {
+        "v": _SWR_SCHEMA_VERSION,
+        "value": value,
+        "stored_at_ms": _now_ms(),
+    }
+    await cache_set(cache_key, entry, ttl=ttl)
+
+
+async def _write_swr_value(cache_key: str, value: Any, ttl: timedelta) -> None:
+    state = _acquire_swr_state(cache_key)
+    try:
+        async with state.write_lock:
+            state.write_epoch += 1
+            await _cache_swr_entry(cache_key, value, ttl)
+    finally:
+        _release_swr_state(cache_key, state)
+
+
+async def _store_loaded_swr_value(
+    cache_key: str, value: Any, ttl: timedelta, *, start_epoch: int
+) -> bool:
+    state = _acquire_swr_state(cache_key)
+    try:
+        async with state.write_lock:
+            if start_epoch != state.write_epoch:
+                return False
+            await _cache_swr_entry(cache_key, value, ttl)
+            return True
+    finally:
+        _release_swr_state(cache_key, state)
+
+
+async def _load_and_store_swr_value(
+    cache_key: str,
+    loader: Callable[[], Awaitable[T]],
+    ttl: timedelta,
+    *,
+    start_epoch: int,
+) -> T:
+    value = await loader()
+    if await _store_loaded_swr_value(cache_key, value, ttl, start_epoch=start_epoch):
+        return value
+
+    entry = _parse_swr_entry(await cache_get(cache_key))
+    if entry is not None:
+        return cast("T", entry["value"])
+    return value
+
+
+def _ensure_swr_load_task(
+    cache_key: str,
+    loader: Callable[[], Awaitable[T]],
+    ttl: timedelta,
+    *,
+    log_errors: bool,
+) -> asyncio.Task[T]:
+    state = _acquire_swr_state(cache_key)
+    try:
+        existing = state.task
+        if existing is not None and not existing.done():
+            return cast("asyncio.Task[T]", existing)
+
+        task = asyncio.create_task(
+            _load_and_store_swr_value(
+                cache_key, loader, ttl, start_epoch=state.write_epoch
+            )
+        )
+        state.task = task
+
+        def _cleanup(done: asyncio.Task[Any]) -> None:
+            cleanup_state = _SWR_STATES.get(cache_key)
+            if cleanup_state is not None and cleanup_state.task is done:
+                cleanup_state.task = None
+                _maybe_cleanup_swr_state(cache_key, cleanup_state)
+            try:
+                done.result()
+            except Exception:
+                if log_errors:
+                    logger.debug(
+                        "Background swr refresh failed for %s",
+                        cache_key,
+                        exc_info=True,
+                    )
+
+        task.add_done_callback(_cleanup)
+        return task
+    finally:
+        _release_swr_state(cache_key, state)
+
+
+async def _await_swr_load(
+    cache_key: str, loader: Callable[[], Awaitable[T]], ttl: timedelta
+) -> T:
+    return await _ensure_swr_load_task(cache_key, loader, ttl, log_errors=False)
+
+
+def _start_swr_refresh(
+    cache_key: str, loader: Callable[[], Awaitable[Any]], ttl: timedelta
+) -> None:
+    _ensure_swr_load_task(cache_key, loader, ttl, log_errors=True)

{langgraph_api-0.7.78 → langgraph_api-0.7.80}/langgraph_api/cli.py

@@ -135,7 +135,7 @@ def run_server(
         mount_prefix = os.environ.get("LANGGRAPH_MOUNT_PREFIX")
     if isinstance(env, str | pathlib.Path):
         try:
-            from dotenv.main import (  # type: ignore[unresolved-import]  # noqa: PLC0415
+            from dotenv.main import (  # noqa: PLC0415
                 DotEnv,
             )
 
@@ -149,7 +149,7 @@ def run_server(
 
     if debug_port is not None:
         try:
-            import debugpy  # type: ignore[unresolved-import]  # noqa: PLC0415
+            import debugpy  # noqa: PLC0415  # ty: ignore[unresolved-import]
         except ImportError:
             logger.warning("debugpy is not installed. Debugging will not be available.")
             logger.info("To enable debugging, install debugpy: pip install debugpy")
@@ -226,7 +226,7 @@ def run_server(
             if k in to_patch:
                 logger.debug(f"Skipping loaded env var {k}={v}")
                 continue
-            to_patch[k] = v  # type: ignore[invalid-assignment]
+            to_patch[k] = v
     with patch_environment(
         **to_patch,
     ):

{langgraph_api-0.7.78 → langgraph_api-0.7.80}/langgraph_api/command.py

@@ -21,7 +21,7 @@ def map_cmd(cmd: RunCommand) -> Command:
         update=update,
         goto=(
             [
-                it if isinstance(it, str) else Send(it["node"], it["input"])  # type: ignore[non-subscriptable]
+                it if isinstance(it, str) else Send(it["node"], it["input"])
                 for it in goto
             ]
             if goto

{langgraph_api-0.7.78 → langgraph_api-0.7.80}/langgraph_api/cron_scheduler.py

@@ -87,7 +87,7 @@ async def cron_scheduler():
                     )
 
                     if on_run_completed == "keep":
-                        run_payload.setdefault("on_completion", "keep")  # type: ignore[union-attr]
+                        run_payload.setdefault("on_completion", "keep")
 
                     run_payload["metadata"] = get_metadata_from_payload(
                         cron, run_payload

{langgraph_api-0.7.78 → langgraph_api-0.7.80}/langgraph_api/encryption/context.py

@@ -11,7 +11,7 @@ from typing import Any
 # Request-scoped encryption context
 # Set by API middleware when X-Encryption-Context header is present
 # Accessed by serializers during checkpoint encryption/decryption
-encryption_context: ContextVar[dict[str, Any] | None] = ContextVar(  # type: ignore[assignment]
+encryption_context: ContextVar[dict[str, Any] | None] = ContextVar(
     "encryption_context", default=None
 )
 

{langgraph_api-0.7.78 → langgraph_api-0.7.80}/langgraph_api/encryption/middleware.py

@@ -539,7 +539,7 @@ async def decrypt_response(
             )
             result["error"] = json_loads(error_bytes)
             return result
-        return obj  # type: ignore[return-value]
+        return obj
 
     result = dict(obj)
     await _decrypt_object(result, model_type, fields, encryption_instance)
@@ -595,9 +595,9 @@ async def decrypt_responses(
                     result["error"] = json_loads(error_bytes)
                     results.append(result)
                 else:
-                    results.append(obj)  # type: ignore[arg-type]
+                    results.append(obj)
             return results
-        return objects  # type: ignore[return-value]
+        return objects
 
     results = [dict(obj) for obj in objects]
     await asyncio.gather(
@@ -728,7 +728,7 @@ async def encrypt_request(
     """
     encryption_instance = get_encryption()
     if encryption_instance is None:
-        return data  # type: ignore[return-value]
+        return data
 
     result = dict(data)
     encrypted_fields = await asyncio.gather(

{langgraph_api-0.7.78 → langgraph_api-0.7.80}/langgraph_api/graph.py

@@ -557,7 +557,7 @@ def _graph_from_spec(spec: GraphSpec) -> GraphValue:
                     raise ValueError(f"Could not find python file for graph: {spec}")
                 module = importlib.util.module_from_spec(modspec)
                 sys.modules[modname] = module
-                modspec.loader.exec_module(module)  # type: ignore[possibly-unbound-attribute]
+                modspec.loader.exec_module(module)
             except ImportError as e:
                 e.add_note(f"Could not import python module for graph:\n{spec}")
                 if lg_api_config.API_VARIANT == "local_dev":
@@ -665,7 +665,7 @@ def _graph_from_spec(spec: GraphSpec) -> GraphValue:
 @functools.lru_cache(maxsize=1)
 def _get_init_embeddings() -> Callable[[str, ...], "Embeddings"] | None:
     try:
-        from langchain.embeddings import (  # type: ignore[unresolved-import]  # noqa: PLC0415
+        from langchain.embeddings import (  # noqa: PLC0415  # ty: ignore[unresolved-import]
             init_embeddings,
         )
 
@@ -730,7 +730,7 @@ def resolve_embeddings(index_config: dict) -> "Embeddings":
                         )
                     module = importlib.util.module_from_spec(modspec)
                     sys.modules[modname] = module
-                    modspec.loader.exec_module(module)  # type: ignore[possibly-unbound-attribute]
+                    modspec.loader.exec_module(module)
                 else:
                     # Load from Python module
                     module = importlib.import_module(module_name)

{langgraph_api-0.7.78 → langgraph_api-0.7.80}/langgraph_api/grpc/client.py

@@ -6,8 +6,8 @@ import threading
 import time
 
 import structlog
-from grpc import aio  # type: ignore[import]
-from grpc_health.v1 import health_pb2, health_pb2_grpc  # type: ignore[import]
+from grpc import aio
+from grpc_health.v1 import health_pb2, health_pb2_grpc
 from langgraph_grpc_common.proto.checkpointer_pb2_grpc import CheckpointerStub
 from langgraph_grpc_common.proto.core_api_pb2_grpc import (
     AdminStub,

{langgraph_api-0.7.78 → langgraph_api-0.7.80}/langgraph_api/grpc/ops/assistants.py

@@ -87,7 +87,7 @@ class Assistants(Authenticated):
         sort_order: str | None = None,
         select: list[AssistantSelectField] | None = None,
         ctx: Any = None,
-    ) -> tuple[AsyncIterator[Assistant], int | None]:  # type: ignore[return-value]
+    ) -> tuple[AsyncIterator[Assistant], int | None]:
         """Search assistants via gRPC."""
         # Handle auth filters
         auth_filters = await Assistants.handle_event(
@@ -139,7 +139,7 @@ class Assistants(Authenticated):
         conn,  # Not used in gRPC implementation
         assistant_id: UUID | str,
         ctx: Any = None,
-    ) -> AsyncIterator[Assistant]:  # type: ignore[return-value]
+    ) -> AsyncIterator[Assistant]:
         """Get assistant by ID via gRPC."""
         # Handle auth filters
         auth_filters = await Assistants.handle_event(
@@ -177,7 +177,7 @@ class Assistants(Authenticated):
         description: str | None = None,
         ctx: Any = None,
         system: bool = False,
-    ) -> AsyncIterator[Assistant]:  # type: ignore[return-value]
+    ) -> AsyncIterator[Assistant]:
         """Create/update assistant via gRPC."""
         metadata = metadata if metadata is not None else {}
         config = config if config is not None else Config()
@@ -240,7 +240,7 @@ class Assistants(Authenticated):
         name: str | None = None,
         description: str | None = None,
         ctx: Any = None,
-    ) -> AsyncIterator[Assistant]:  # type: ignore[return-value]
+    ) -> AsyncIterator[Assistant]:
         """Update assistant via gRPC."""
         metadata = metadata if metadata is not None else {}
         config = config if config is not None else Config()
@@ -295,7 +295,7 @@ class Assistants(Authenticated):
         ctx: Any = None,
         *,
         delete_threads: bool = False,
-    ) -> AsyncIterator[UUID]:  # type: ignore[return-value]
+    ) -> AsyncIterator[UUID]:
         """Delete assistant via gRPC."""
         # Handle auth filters
         auth_filters = await Assistants.handle_event(
@@ -324,7 +324,7 @@ class Assistants(Authenticated):
         assistant_id: UUID | str,
         version: int,
         ctx: Any = None,
-    ) -> AsyncIterator[Assistant]:  # type: ignore[return-value]
+    ) -> AsyncIterator[Assistant]:
         """Set latest version of assistant via gRPC."""
         # Handle auth filters
         auth_filters = await Assistants.handle_event(
@@ -362,7 +362,7 @@ class Assistants(Authenticated):
         limit: int,
         offset: int,
         ctx: Any = None,
-    ) -> AsyncIterator[Assistant]:  # type: ignore[return-value]
+    ) -> AsyncIterator[Assistant]:
         """Get all versions of assistant via gRPC."""
         # Handle auth filters
         auth_filters = await Assistants.handle_event(
@@ -412,7 +412,7 @@ class Assistants(Authenticated):
         name: str | None = None,
         metadata: MetadataInput = None,
         ctx: Any = None,
-    ) -> int:  # type: ignore[return-value]
+    ) -> int:
         """Count assistants via gRPC."""
         # Handle auth filters
         auth_filters = await Assistants.handle_event(