langgraph-api 0.4.46__py3-none-any.whl → 0.4.48__py3-none-any.whl

langgraph_api/grpc_ops/ops.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import functools
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Sequence
 from datetime import UTC
 from http import HTTPStatus
 from typing import Any
@@ -16,6 +16,7 @@ from google.protobuf.json_format import MessageToDict
 from google.protobuf.struct_pb2 import Struct  # type: ignore[import]
 from grpc import StatusCode
 from grpc.aio import AioRpcError
+from langgraph.pregel.debug import CheckpointPayload
 from langgraph_sdk.schema import Config
 from starlette.exceptions import HTTPException
 
@@ -25,7 +26,11 @@ from langgraph_api.schema import (
     Context,
     MetadataInput,
     OnConflictBehavior,
+    Thread,
+    ThreadSelectField,
+    ThreadStatus,
 )
+from langgraph_api.serde import json_dumpb, json_loads
 
 from .client import GrpcClient
 from .generated import core_api_pb2 as pb
@@ -57,7 +62,7 @@ def map_configurable(config: Config) -> Struct:
     extra_dict = {k: v for k, v in (config or {}).items() if k not in base_keys}
 
     kwargs: dict[str, Any] = dict(
-        tags=config.get("tags"),
+        tags=pb.Tags(values=config.get("tags")),
         recursion_limit=config.get("recursion_limit"),
         configurable=(
             dict_to_struct(config.get("configurable", {}))
@@ -120,8 +125,8 @@ def _runnable_config_to_user_dict(cfg: pb.Config | None) -> dict[str, Any]:
 
     out: dict[str, Any] = {}
     # tags
-    if cfg.tags:
-        out["tags"] = list(cfg.tags)
+    if cfg.tags and cfg.tags.values:
+        out["tags"] = list(cfg.tags.values)
     # recursion_limit (preserve presence of 0 if set)
     try:
         if cfg.HasField("recursion_limit"):
@@ -138,7 +143,6 @@ def _runnable_config_to_user_dict(cfg: pb.Config | None) -> dict[str, Any]:
         extra = orjson.loads(cfg.extra)
         if isinstance(extra, dict) and extra:
             out.update(extra)
-
     return out
 
 
@@ -162,6 +166,248 @@ def proto_to_assistant(proto_assistant: pb.Assistant) -> Assistant:
     }
 
 
+THREAD_STATUS_TO_PB = {
+    "idle": pb.ThreadStatus.THREAD_STATUS_IDLE,
+    "busy": pb.ThreadStatus.THREAD_STATUS_BUSY,
+    "interrupted": pb.ThreadStatus.THREAD_STATUS_INTERRUPTED,
+    "error": pb.ThreadStatus.THREAD_STATUS_ERROR,
+}
+
+THREAD_STATUS_FROM_PB = {
+    pb.ThreadStatus.THREAD_STATUS_IDLE: "idle",
+    pb.ThreadStatus.THREAD_STATUS_BUSY: "busy",
+    pb.ThreadStatus.THREAD_STATUS_INTERRUPTED: "interrupted",
+    pb.ThreadStatus.THREAD_STATUS_ERROR: "error",
+}
+
+THREAD_SORT_BY_MAP = {
+    "thread_id": pb.ThreadsSortBy.THREADS_SORT_BY_THREAD_ID,
+    "created_at": pb.ThreadsSortBy.THREADS_SORT_BY_CREATED_AT,
+    "updated_at": pb.ThreadsSortBy.THREADS_SORT_BY_UPDATED_AT,
+    "status": pb.ThreadsSortBy.THREADS_SORT_BY_STATUS,
+}
+
+THREAD_TTL_STRATEGY_MAP = {"delete": pb.ThreadTTLStrategy.THREAD_TTL_STRATEGY_DELETE}
+
+
+def _map_thread_status(status: ThreadStatus | None) -> pb.ThreadStatus | None:
+    if status is None:
+        return None
+    return THREAD_STATUS_TO_PB.get(status)
+
+
+def _map_threads_sort_by(sort_by: str | None) -> pb.ThreadsSortBy:
+    if not sort_by:
+        return pb.ThreadsSortBy.THREADS_SORT_BY_CREATED_AT
+    return THREAD_SORT_BY_MAP.get(
+        sort_by.lower(), pb.ThreadsSortBy.THREADS_SORT_BY_CREATED_AT
+    )
+
+
+def _map_thread_ttl(ttl: dict[str, Any] | None) -> pb.ThreadTTLConfig | None:
+    if not ttl:
+        return None
+
+    config = pb.ThreadTTLConfig()
+    strategy = ttl.get("strategy")
+    if strategy:
+        mapped_strategy = THREAD_TTL_STRATEGY_MAP.get(str(strategy).lower())
+        if mapped_strategy is None:
+            raise HTTPException(
+                status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+                detail=f"Invalid thread TTL strategy: {strategy}. Expected one of ['delete']",
+            )
+        config.strategy = mapped_strategy
+
+    ttl_value = ttl.get("ttl", ttl.get("default_ttl"))
+    if ttl_value is not None:
+        config.default_ttl = float(ttl_value)
+
+    sweep_interval = ttl.get("sweep_interval_minutes")
+    if sweep_interval is not None:
+        config.sweep_interval_minutes = int(sweep_interval)
+
+    return config
+
+
+def fragment_to_value(fragment: pb.Fragment | None) -> Any:
+    if fragment is None or not fragment.value:
+        return {}
+    try:
+        return json_loads(fragment.value)
+    except orjson.JSONDecodeError:
+        logger.warning("Failed to decode fragment", fragment=fragment.value)
+        return {}
+
+
+def _proto_interrupts_to_dict(
+    interrupts_map: dict[str, pb.Interrupts],
+) -> dict[str, list[dict[str, Any]]]:
+    out: dict[str, list[dict[str, Any]]] = {}
+    for key, interrupts in interrupts_map.items():
+        entries: list[dict[str, Any]] = []
+        for interrupt in interrupts.interrupts:
+            entry: dict[str, Any] = {
+                "id": interrupt.id or None,
+                "value": json_loads(interrupt.value),
+            }
+            if interrupt.when:
+                entry["when"] = interrupt.when
+            if interrupt.resumable:
+                entry["resumable"] = interrupt.resumable
+            if interrupt.ns:
+                entry["ns"] = list(interrupt.ns)
+            entries.append(entry)
+        out[key] = entries
+    return out
+
+
+def proto_to_thread(proto_thread: pb.Thread) -> Thread:
+    """Convert protobuf Thread to API dictionary format."""
+    thread_id = (
+        UUID(proto_thread.thread_id.value)
+        if proto_thread.HasField("thread_id")
+        else None
+    )
+    if thread_id is None:
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            detail="Thread response missing thread_id",
+        )
+    created_at = (
+        proto_thread.created_at.ToDatetime(tzinfo=UTC)
+        if proto_thread.HasField("created_at")
+        else None
+    )
+    updated_at = (
+        proto_thread.updated_at.ToDatetime(tzinfo=UTC)
+        if proto_thread.HasField("updated_at")
+        else None
+    )
+    status = THREAD_STATUS_FROM_PB.get(proto_thread.status, "idle")
+
+    return {
+        "thread_id": thread_id,
+        "created_at": created_at,
+        "updated_at": updated_at,
+        "metadata": fragment_to_value(proto_thread.metadata),
+        "config": fragment_to_value(proto_thread.config),
+        "error": fragment_to_value(proto_thread.error),
+        "status": status,  # type: ignore[typeddict-item]
+        "values": fragment_to_value(proto_thread.values),
+        "interrupts": _proto_interrupts_to_dict(dict(proto_thread.interrupts)),
+    }
+
+
+def _checkpoint_metadata_to_pb(
+    metadata: dict[str, Any] | None,
+) -> pb.CheckpointMetadata | None:
+    if not metadata:
+        return None
+
+    message = pb.CheckpointMetadata()
+    source = metadata.get("source")
+    if source is not None:
+        if isinstance(source, str):
+            enum_key = f"CHECKPOINT_SOURCE_{source.upper()}"
+            try:
+                message.source = pb.CheckpointSource.Value(enum_key)
+            except ValueError:
+                logger.warning(
+                    "Unknown checkpoint source enum, defaulting to unspecified",
+                    source=source,
+                )
+        elif isinstance(source, int):
+            try:
+                message.source = pb.CheckpointSource(source)
+            except ValueError:
+                logger.warning(
+                    "Unknown checkpoint source value, defaulting to unspecified",
+                    source=source,
+                )
+    if step := metadata.get("step"):
+        message.step = int(step)
+    parents = metadata.get("parents")
+    if isinstance(parents, dict):
+        message.parents.update({str(k): str(v) for k, v in parents.items()})
+    return message
+
+
+def _checkpoint_tasks_to_pb(tasks: Sequence[dict[str, Any]]) -> list[pb.CheckpointTask]:
+    task_messages: list[pb.CheckpointTask] = []
+    for task in tasks:
+        message = pb.CheckpointTask(
+            id=task.get("id", ""),
+            name=task.get("name", ""),
+        )
+        if task.get("error"):
+            message.error = str(task["error"])
+        interrupts = task.get("interrupts") or []
+        for interrupt in interrupts:
+            message.interrupts.append(dict_to_struct(interrupt))
+        if task.get("state"):
+            message.state.CopyFrom(dict_to_struct(task["state"]))
+        task_messages.append(message)
+    return task_messages
+
+
+def checkpoint_to_pb(
+    checkpoint: CheckpointPayload | None,
+) -> pb.CheckpointPayload | None:
+    if checkpoint is None:
+        return None
+
+    message = pb.CheckpointPayload()
+
+    config = checkpoint.get("config")
+    if config:
+        message.config.CopyFrom(map_configurable(config))
+
+    metadata = _checkpoint_metadata_to_pb(checkpoint.get("metadata"))
+    if metadata:
+        message.metadata.CopyFrom(metadata)
+
+    values = checkpoint.get("values")
+    if values:
+        message.values.CopyFrom(dict_to_struct(values))
+
+    next_nodes = checkpoint.get("next")
+    if next_nodes:
+        message.next.extend([str(n) for n in next_nodes])
+
+    parent_config = checkpoint.get("parent_config")
+    if parent_config:
+        message.parent_config.CopyFrom(map_configurable(parent_config))
+
+    tasks = checkpoint.get("tasks")
+    if tasks:
+        message.tasks.extend(_checkpoint_tasks_to_pb(tasks))
+
+    return message
+
+
+def exception_to_struct(exception: BaseException | None) -> Struct | None:
+    if exception is None:
+        return None
+    try:
+        payload = orjson.loads(json_dumpb(exception))
+    except orjson.JSONDecodeError:
+        payload = {"error": type(exception).__name__, "message": str(exception)}
+    return dict_to_struct(payload)
+
+
+def _filter_thread_fields(
+    thread: Thread, select: list[ThreadSelectField] | None
+) -> dict[str, Any]:
+    if not select:
+        return thread
+    return {field: thread[field] for field in select if field in thread}
+
+
+def _normalize_uuid(value: UUID | str) -> str:
+    return str(value) if isinstance(value, UUID) else str(UUID(str(value)))
+
+
 def _map_sort_by(sort_by: str | None) -> pb.AssistantsSortBy:
     """Map string sort_by to protobuf enum."""
     if not sort_by:
@@ -608,3 +854,334 @@ class Assistants(Authenticated):
             response = await client.assistants.Count(request)
 
         return int(response.count)
+
+
+def _json_contains(container: Any, subset: dict[str, Any]) -> bool:
+    if not subset:
+        return True
+    if not isinstance(container, dict):
+        return False
+    for key, value in subset.items():
+        if key not in container:
+            return False
+        candidate = container[key]
+        if isinstance(value, dict):
+            if not _json_contains(candidate, value):
+                return False
+        else:
+            if candidate != value:
+                return False
+    return True
+
+
+@grpc_error_guard
+class Threads(Authenticated):
+    """gRPC-based threads operations."""
+
+    resource = "threads"
+
+    @staticmethod
+    async def search(
+        conn,  # Not used in gRPC implementation
+        *,
+        ids: list[str] | list[UUID] | None = None,
+        metadata: MetadataInput,
+        values: MetadataInput,
+        status: ThreadStatus | None,
+        limit: int,
+        offset: int,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+        select: list[ThreadSelectField] | None = None,
+        ctx: Any = None,
+    ) -> tuple[AsyncIterator[Thread], int | None]:  # type: ignore[return-value]
+        metadata = metadata or {}
+        values = values or {}
+
+        auth_filters = await Threads.handle_event(
+            ctx,
+            "search",
+            {
+                "metadata": metadata,
+                "values": values,
+                "status": status,
+                "limit": limit,
+                "offset": offset,
+            },
+        )
+
+        if ids:
+            normalized_ids = [_normalize_uuid(thread_id) for thread_id in ids]
+            threads: list[Thread] = []
+            async with GrpcClient() as client:
+                for thread_id in normalized_ids:
+                    request = pb.GetThreadRequest(
+                        thread_id=pb.UUID(value=_normalize_uuid(thread_id)),
+                        filters=auth_filters or {},
+                    )
+                    response = await client.threads.Get(request)
+                    thread = proto_to_thread(response)
+
+                    if status and thread["status"] != status:
+                        continue
+                    if metadata and not _json_contains(thread["metadata"], metadata):
+                        continue
+                    if values and not _json_contains(
+                        thread.get("values") or {}, values
+                    ):
+                        continue
+                    threads.append(thread)
+
+            total = len(threads)
+            paginated = threads[offset : offset + limit]
+            cursor = offset + limit if total > offset + limit else None
+
+            async def generate_results():
+                for thread in paginated:
+                    yield _filter_thread_fields(thread, select)
+
+            return generate_results(), cursor
+
+        request_kwargs: dict[str, Any] = {
+            "filters": auth_filters or {},
+            "metadata": dict_to_struct(metadata),
+            "values": dict_to_struct(values),
+            "limit": limit,
+            "offset": offset,
+            "sort_by": _map_threads_sort_by(sort_by),
+            "sort_order": _map_sort_order(sort_order),
+        }
+
+        if status:
+            mapped_status = _map_thread_status(status)
+            if mapped_status is None:
+                raise HTTPException(
+                    status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+                    detail=f"Invalid thread status: {status}",
+                )
+            request_kwargs["status"] = mapped_status
+
+        if select:
+            request_kwargs["select"] = select
+
+        async with GrpcClient() as client:
+            response = await client.threads.Search(
+                pb.SearchThreadsRequest(**request_kwargs)
+            )
+
+        threads = [proto_to_thread(thread) for thread in response.threads]
+        cursor = offset + limit if len(threads) == limit else None
+
+        async def generate_results():
+            for thread in threads:
+                yield _filter_thread_fields(thread, select)
+
+        return generate_results(), cursor
+
+    @staticmethod
+    async def count(
+        conn,  # Not used
+        *,
+        metadata: MetadataInput,
+        values: MetadataInput,
+        status: ThreadStatus | None,
+        ctx: Any = None,
+    ) -> int:  # type: ignore[override]
+        metadata = metadata or {}
+        values = values or {}
+
+        auth_filters = await Threads.handle_event(
+            ctx,
+            "search",
+            {
+                "metadata": metadata,
+                "values": values,
+                "status": status,
+            },
+        )
+
+        request_kwargs: dict[str, Any] = {
+            "filters": auth_filters or {},
+            "metadata": dict_to_struct(metadata),
+            "values": dict_to_struct(values),
+        }
+        if status:
+            mapped_status = _map_thread_status(status)
+            if mapped_status is None:
+                raise HTTPException(
+                    status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+                    detail=f"Invalid thread status: {status}",
+                )
+            request_kwargs["status"] = mapped_status
+
+        async with GrpcClient() as client:
+            response = await client.threads.Count(
+                pb.CountThreadsRequest(**request_kwargs)
+            )
+
+        return int(response.count)
+
+    @staticmethod
+    async def get(
+        conn,  # Not used
+        thread_id: UUID | str,
+        ctx: Any = None,
+    ) -> AsyncIterator[Thread]:  # type: ignore[return-value]
+        auth_filters = await Threads.handle_event(
+            ctx, "read", {"thread_id": str(thread_id)}
+        )
+
+        request = pb.GetThreadRequest(
+            thread_id=pb.UUID(value=_normalize_uuid(thread_id)),
+            filters=auth_filters or {},
+        )
+        async with GrpcClient() as client:
+            response = await client.threads.Get(request)
+
+        thread = proto_to_thread(response)
+
+        async def generate_result():
+            yield thread
+
+        return generate_result()
+
+    @staticmethod
+    async def put(
+        conn,  # Not used
+        thread_id: UUID | str,
+        *,
+        metadata: MetadataInput,
+        if_exists: OnConflictBehavior,
+        ttl: dict[str, Any] | None = None,
+        ctx: Any = None,
+    ) -> AsyncIterator[Thread]:  # type: ignore[return-value]
+        metadata = metadata or {}
+
+        auth_filters = await Threads.handle_event(
+            ctx,
+            "create",
+            {
+                "thread_id": str(thread_id),
+                "metadata": metadata,
+                "if_exists": if_exists,
+            },
+        )
+
+        request = pb.CreateThreadRequest(
+            thread_id=pb.UUID(value=_normalize_uuid(thread_id)),
+            filters=auth_filters or {},
+            if_exists=map_if_exists(if_exists),
+            metadata=dict_to_struct(metadata),
+        )
+        ttl_config = _map_thread_ttl(ttl)
+        if ttl_config is not None:
+            request.ttl.CopyFrom(ttl_config)
+
+        async with GrpcClient() as client:
+            response = await client.threads.Create(request)
+        thread = proto_to_thread(response)
+
+        async def generate_result():
+            yield thread
+
+        return generate_result()
+
+    @staticmethod
+    async def patch(
+        conn,  # Not used
+        thread_id: UUID | str,
+        *,
+        metadata: MetadataInput,
+        ttl: dict[str, Any] | None = None,
+        ctx: Any = None,
+    ) -> AsyncIterator[Thread]:  # type: ignore[return-value]
+        metadata = metadata or {}
+
+        auth_filters = await Threads.handle_event(
+            ctx,
+            "update",
+            {
+                "thread_id": str(thread_id),
+                "metadata": metadata,
+            },
+        )
+
+        request = pb.PatchThreadRequest(
+            thread_id=pb.UUID(value=_normalize_uuid(thread_id)),
+            filters=auth_filters or {},
+        )
+
+        if metadata:
+            request.metadata.CopyFrom(dict_to_struct(metadata))
+
+        ttl_config = _map_thread_ttl(ttl)
+        if ttl_config is not None:
+            request.ttl.CopyFrom(ttl_config)
+
+        async with GrpcClient() as client:
+            response = await client.threads.Patch(request)
+
+        thread = proto_to_thread(response)
+
+        async def generate_result():
+            yield thread
+
+        return generate_result()
+
+    @staticmethod
+    async def delete(
+        conn,  # Not used
+        thread_id: UUID | str,
+        ctx: Any = None,
+    ) -> AsyncIterator[UUID]:  # type: ignore[return-value]
+        auth_filters = await Threads.handle_event(
+            ctx,
+            "delete",
+            {
+                "thread_id": str(thread_id),
+            },
+        )
+
+        request = pb.DeleteThreadRequest(
+            thread_id=pb.UUID(value=_normalize_uuid(thread_id)),
+            filters=auth_filters or {},
+        )
+
+        async with GrpcClient() as client:
+            response = await client.threads.Delete(request)
+
+        deleted_id = UUID(response.value)
+
+        async def generate_result():
+            yield deleted_id
+
+        return generate_result()
+
+    @staticmethod
+    async def copy(
+        conn,  # Not used
+        thread_id: UUID | str,
+        ctx: Any = None,
+    ) -> AsyncIterator[Thread]:  # type: ignore[return-value]
+        auth_filters = await Threads.handle_event(
+            ctx,
+            "read",
+            {
+                "thread_id": str(thread_id),
+            },
+        )
+
+        request = pb.CopyThreadRequest(
+            thread_id=pb.UUID(value=_normalize_uuid(thread_id)),
+            filters=auth_filters or {},
+        )
+
+        async with GrpcClient() as client:
+            response = await client.threads.Copy(request)
+
+        thread = proto_to_thread(response)
+
+        async def generate_result():
+            yield thread
+
+        return generate_result()

langgraph_api/js/build.mts

@@ -1,7 +1,7 @@
 /// <reference types="./global.d.ts" />
 import "./src/preload.mjs";
 
-import { z } from "zod";
+import { z } from "zod/v3";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { type GraphSchema, resolveGraph } from "./src/graph.mts";

langgraph_api/js/client.http.mts

@@ -6,7 +6,7 @@ import * as path from "node:path";
 import * as url from "node:url";
 import { createLogger, format, transports } from "winston";
 import { gracefulExit } from "exit-hook";
-import { z } from "zod";
+import { z } from "zod/v3";
 
 const logger = createLogger({
   level: "debug",

langgraph_api/js/client.mts

@@ -1,6 +1,6 @@
 /// <reference types="./global.d.ts" />
 
-import { z } from "zod";
+import { z } from "zod/v3";
 import { Context, Hono } from "hono";
 import { serve } from "@hono/node-server";
 import { zValidator } from "@hono/zod-validator";

langgraph_api/js/package.json

@@ -9,16 +9,16 @@
   "dependencies": {
     "@hono/node-server": "^1.12.0",
     "@hono/zod-validator": "^0.2.2",
-    "@langchain/core": "^0.3.59",
-    "@langchain/langgraph": "^0.2.65",
-    "@langchain/langgraph-api": "~0.0.59",
-    "@langchain/langgraph-ui": "~0.0.59",
-    "@langchain/langgraph-checkpoint": "~0.0.18",
+    "@langchain/core": "^1.0.1",
+    "@langchain/langgraph": "^1.0.0",
+    "@langchain/langgraph-api": "^1.0.3",
+    "@langchain/langgraph-ui": "^1.0.3",
+    "@langchain/langgraph-checkpoint": "^1.0.0",
     "@types/json-schema": "^7.0.15",
     "@typescript/vfs": "^1.6.0",
     "dedent": "^1.5.3",
     "exit-hook": "^4.0.0",
-    "hono": "^4.9.7",
+    "hono": "^4.10.2",
     "p-queue": "^8.0.1",
     "p-retry": "^6.2.0",
     "tsx": "^4.19.3",
@@ -44,4 +44,4 @@
     "vitest": "^3.0.5"
   },
   "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
-}
+}