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

langgraph_api/{grpc_ops → grpc}/ops.py

@@ -4,10 +4,10 @@ from __future__ import annotations
 
 import asyncio
 import functools
-from collections.abc import AsyncIterator, Sequence
+from collections.abc import AsyncIterator
 from datetime import UTC
 from http import HTTPStatus
-from typing import Any
+from typing import Any, overload
 from uuid import UUID
 
 import orjson
@@ -16,10 +16,10 @@ 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
 
+from langgraph_api.grpc import config_conversion
 from langgraph_api.schema import (
     Assistant,
     AssistantSelectField,
@@ -32,7 +32,7 @@ from langgraph_api.schema import (
 )
 from langgraph_api.serde import json_dumpb, json_loads
 
-from .client import GrpcClient
+from .client import get_shared_client
 from .generated import core_api_pb2 as pb
 
 GRPC_STATUS_TO_HTTP_STATUS = {
@@ -50,30 +50,16 @@ def map_if_exists(if_exists: str) -> pb.OnConflictBehavior:
     return pb.OnConflictBehavior.RAISE
 
 
-def map_configurable(config: Config) -> Struct:
-    """Build pb.Config, placing non-standard keys into `extra` bytes.
+@overload
+def consolidate_config_and_context(
+    config: Config | None, context: None
+) -> tuple[Config, None]: ...
 
-    The `extra` field mirrors any keys that are not first-class in
-    Config (e.g., "tags", "recursion_limit", "configurable").
-    It is JSON-encoded bytes to minimize serde overhead; the server will
-    unpack and persist them as top-level keys.
-    """
-    base_keys = {"tags", "recursion_limit", "configurable"}
-    extra_dict = {k: v for k, v in (config or {}).items() if k not in base_keys}
-
-    kwargs: dict[str, Any] = dict(
-        tags=pb.Tags(values=config.get("tags")),
-        recursion_limit=config.get("recursion_limit"),
-        configurable=(
-            dict_to_struct(config.get("configurable", {}))
-            if config.get("configurable")
-            else None
-        ),
-    )
-    if extra_dict:
-        kwargs["extra"] = orjson.dumps(extra_dict)
 
-    return pb.Config(**kwargs)
+@overload
+def consolidate_config_and_context(
+    config: Config | None, context: Context
+) -> tuple[Config, Context]: ...
 
 
 def consolidate_config_and_context(
@@ -84,17 +70,20 @@ def consolidate_config_and_context(
     Does not mutate the passed-in objects. If both configurable and context
     are provided, raises 400. If only one is provided, mirrors it to the other.
     """
-    cfg: Config = dict(config or {})
+    cfg: Config = Config(config or {})
     ctx: Context | None = dict(context) if context is not None else None
+    configurable = cfg.get("configurable")
 
-    if cfg.get("configurable") and ctx:
+    if configurable and ctx:
         raise HTTPException(
             status_code=400,
-            detail="Cannot specify both configurable and context. Prefer setting context alone. Context was introduced in LangGraph 0.6.0 and is the long term planned replacement for configurable.",
+            detail="Cannot specify both configurable and context. Prefer setting context alone."
+            " Context was introduced in LangGraph 0.6.0 and "
+            "is the long term planned replacement for configurable.",
         )
 
-    if cfg.get("configurable"):
-        ctx = cfg["configurable"]
+    if configurable:
+        ctx = configurable
     elif ctx is not None:
         cfg["configurable"] = ctx
 
@@ -114,38 +103,6 @@ def struct_to_dict(struct: Struct) -> dict[str, Any]:
     return MessageToDict(struct) if struct else {}
 
 
-def _runnable_config_to_user_dict(cfg: pb.Config | None) -> dict[str, Any]:
-    """Convert pb.Config to user-visible dict, unpacking `extra`.
-
-    - Keeps top-level known keys: tags, recursion_limit, configurable.
-    - Merges keys from `extra` into the top-level dict.
-    """
-    if not cfg:
-        return {}
-
-    out: dict[str, Any] = {}
-    # 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"):
-            out["recursion_limit"] = cfg.recursion_limit
-    except ValueError:
-        # Some runtimes may not support HasField on certain builds; fallback
-        if getattr(cfg, "recursion_limit", None) is not None:
-            out["recursion_limit"] = cfg.recursion_limit
-    # configurable
-    if cfg.HasField("configurable"):
-        out["configurable"] = struct_to_dict(cfg.configurable)
-    # extra (bytes: JSON-encoded object)
-    if cfg.HasField("extra") and cfg.extra:
-        extra = orjson.loads(cfg.extra)
-        if isinstance(extra, dict) and extra:
-            out.update(extra)
-    return out
-
-
 def proto_to_assistant(proto_assistant: pb.Assistant) -> Assistant:
     """Convert protobuf Assistant to dictionary format."""
     # Preserve None for optional scalar fields by checking presence via HasField
@@ -158,7 +115,7 @@ def proto_to_assistant(proto_assistant: pb.Assistant) -> Assistant:
         "version": proto_assistant.version,
         "created_at": proto_assistant.created_at.ToDatetime(tzinfo=UTC),
         "updated_at": proto_assistant.updated_at.ToDatetime(tzinfo=UTC),
-        "config": _runnable_config_to_user_dict(proto_assistant.config),
+        "config": config_conversion.config_from_proto(proto_assistant.config),
         "context": struct_to_dict(proto_assistant.context),
         "metadata": struct_to_dict(proto_assistant.metadata),
         "name": proto_assistant.name,
@@ -299,93 +256,6 @@ def proto_to_thread(proto_thread: pb.Thread) -> Thread:
     }
 
 
-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
@@ -400,7 +270,7 @@ def _filter_thread_fields(
     thread: Thread, select: list[ThreadSelectField] | None
 ) -> dict[str, Any]:
     if not select:
-        return thread
+        return dict(thread)
     return {field: thread[field] for field in select if field in thread}
 
 
@@ -539,9 +409,8 @@ class Assistants(Authenticated):
             select=select,
         )
 
-        # Make the gRPC call
-        async with GrpcClient() as client:
-            response = await client.assistants.Search(request)
+        client = await get_shared_client()
+        response = await client.assistants.Search(request)
 
         # Convert response to expected format
         assistants = [
@@ -578,9 +447,8 @@ class Assistants(Authenticated):
             filters=auth_filters or {},
         )
 
-        # Make the gRPC call
-        async with GrpcClient() as client:
-            response = await client.assistants.Get(request)
+        client = await get_shared_client()
+        response = await client.assistants.Get(request)
 
         # Convert and yield the result
         assistant = proto_to_assistant(response)
@@ -630,16 +498,15 @@ class Assistants(Authenticated):
             graph_id=graph_id,
             filters=auth_filters or {},
             if_exists=on_conflict,
-            config=map_configurable(config),
+            config=config_conversion.config_to_proto(config),
             context=dict_to_struct(context or {}),
             name=name,
             description=description,
             metadata=dict_to_struct(metadata or {}),
         )
 
-        # Make the gRPC call
-        async with GrpcClient() as client:
-            response = await client.assistants.Create(request)
+        client = await get_shared_client()
+        response = await client.assistants.Create(request)
 
         # Convert and yield the result
         assistant = proto_to_assistant(response)
@@ -654,7 +521,7 @@ class Assistants(Authenticated):
         conn,  # Not used in gRPC implementation
         assistant_id: UUID | str,
         *,
-        config: dict | None = None,
+        config: Config | None = None,
         context: Context | None = None,
         graph_id: str | None = None,
         metadata: MetadataInput | None = None,
@@ -664,7 +531,7 @@ class Assistants(Authenticated):
     ) -> AsyncIterator[Assistant]:  # type: ignore[return-value]
         """Update assistant via gRPC."""
         metadata = metadata if metadata is not None else {}
-        config = config if config is not None else {}
+        config = config if config is not None else Config()
         # Handle auth filters
         auth_filters = await Assistants.handle_event(
             ctx,
@@ -694,15 +561,14 @@ class Assistants(Authenticated):
 
         # Add optional config if provided
         if config:
-            request.config.CopyFrom(map_configurable(config))
+            request.config.CopyFrom(config_conversion.config_to_proto(config))
 
         # Add optional context if provided
         if context:
             request.context.CopyFrom(dict_to_struct(context))
 
-        # Make the gRPC call
-        async with GrpcClient() as client:
-            response = await client.assistants.Patch(request)
+        client = await get_shared_client()
+        response = await client.assistants.Patch(request)
 
         # Convert and yield the result
         assistant = proto_to_assistant(response)
@@ -730,9 +596,8 @@ class Assistants(Authenticated):
             filters=auth_filters or {},
         )
 
-        # Make the gRPC call
-        async with GrpcClient() as client:
-            await client.assistants.Delete(request)
+        client = await get_shared_client()
+        await client.assistants.Delete(request)
 
         # Return the deleted ID
         async def generate_result():
@@ -765,9 +630,8 @@ class Assistants(Authenticated):
             filters=auth_filters or {},
         )
 
-        # Make the gRPC call
-        async with GrpcClient() as client:
-            response = await client.assistants.SetLatest(request)
+        client = await get_shared_client()
+        response = await client.assistants.SetLatest(request)
 
         # Convert and yield the result
         assistant = proto_to_assistant(response)
@@ -803,9 +667,8 @@ class Assistants(Authenticated):
             offset=offset,
         )
 
-        # Make the gRPC call
-        async with GrpcClient() as client:
-            response = await client.assistants.GetVersions(request)
+        client = await get_shared_client()
+        response = await client.assistants.GetVersions(request)
 
         # Convert and yield the results
         async def generate_results():
@@ -819,7 +682,7 @@ class Assistants(Authenticated):
                     "graph_id": version.graph_id,
                     "version": version.version,
                     "created_at": version.created_at.ToDatetime(tzinfo=UTC),
-                    "config": _runnable_config_to_user_dict(version.config),
+                    "config": config_conversion.config_from_proto(version.config),
                     "context": struct_to_dict(version.context),
                     "metadata": struct_to_dict(version.metadata),
                     "name": version.name,
@@ -849,9 +712,8 @@ class Assistants(Authenticated):
             metadata=dict_to_struct(metadata or {}),
         )
 
-        # Make the gRPC call
-        async with GrpcClient() as client:
-            response = await client.assistants.Count(request)
+        client = await get_shared_client()
+        response = await client.assistants.Count(request)
 
         return int(response.count)
 
@@ -913,24 +775,22 @@ class Threads(Authenticated):
         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)
+            client = await get_shared_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]
@@ -964,10 +824,10 @@ class Threads(Authenticated):
         if select:
             request_kwargs["select"] = select
 
-        async with GrpcClient() as client:
-            response = await client.threads.Search(
-                pb.SearchThreadsRequest(**request_kwargs)
-            )
+        client = await get_shared_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
@@ -1014,10 +874,8 @@ class Threads(Authenticated):
                 )
             request_kwargs["status"] = mapped_status
 
-        async with GrpcClient() as client:
-            response = await client.threads.Count(
-                pb.CountThreadsRequest(**request_kwargs)
-            )
+        client = await get_shared_client()
+        response = await client.threads.Count(pb.CountThreadsRequest(**request_kwargs))
 
         return int(response.count)
 
@@ -1035,8 +893,8 @@ class Threads(Authenticated):
             thread_id=pb.UUID(value=_normalize_uuid(thread_id)),
             filters=auth_filters or {},
         )
-        async with GrpcClient() as client:
-            response = await client.threads.Get(request)
+        client = await get_shared_client()
+        response = await client.threads.Get(request)
 
         thread = proto_to_thread(response)
 
@@ -1077,8 +935,8 @@ class Threads(Authenticated):
         if ttl_config is not None:
             request.ttl.CopyFrom(ttl_config)
 
-        async with GrpcClient() as client:
-            response = await client.threads.Create(request)
+        client = await get_shared_client()
+        response = await client.threads.Create(request)
         thread = proto_to_thread(response)
 
         async def generate_result():
@@ -1118,8 +976,8 @@ class Threads(Authenticated):
         if ttl_config is not None:
             request.ttl.CopyFrom(ttl_config)
 
-        async with GrpcClient() as client:
-            response = await client.threads.Patch(request)
+        client = await get_shared_client()
+        response = await client.threads.Patch(request)
 
         thread = proto_to_thread(response)
 
@@ -1147,8 +1005,8 @@ class Threads(Authenticated):
             filters=auth_filters or {},
         )
 
-        async with GrpcClient() as client:
-            response = await client.threads.Delete(request)
+        client = await get_shared_client()
+        response = await client.threads.Delete(request)
 
         deleted_id = UUID(response.value)
 
@@ -1176,8 +1034,8 @@ class Threads(Authenticated):
             filters=auth_filters or {},
         )
 
-        async with GrpcClient() as client:
-            response = await client.threads.Copy(request)
+        client = await get_shared_client()
+        response = await client.threads.Copy(request)
 
         thread = proto_to_thread(response)
 

langgraph_api/js/package.json

@@ -16,12 +16,12 @@
     "@langchain/langgraph-checkpoint": "^1.0.0",
     "@types/json-schema": "^7.0.15",
     "@typescript/vfs": "^1.6.0",
-    "dedent": "^1.5.3",
+    "dedent": "^1.7.0",
     "exit-hook": "^4.0.0",
-    "hono": "^4.10.2",
+    "hono": "^4.10.4",
     "p-queue": "^8.0.1",
     "p-retry": "^6.2.0",
-    "tsx": "^4.19.3",
+    "tsx": "^4.20.6",
     "typescript": "^5.5.4",
     "undici": "^6.21.2",
     "uuid": "^10.0.0",
@@ -40,8 +40,8 @@
     "@types/react-dom": "^19.0.3",
     "jose": "^6.0.10",
     "postgres": "^3.4.4",
-    "prettier": "^3.3.3",
-    "vitest": "^3.0.5"
+    "prettier": "^3.6.2",
+    "vitest": "^4.0.6"
   },
   "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }

langgraph_api/js/src/graph.mts

@@ -62,6 +62,17 @@ export async function resolveGraph(
     return "compile" in graph && typeof graph.compile === "function";
   };
 
+  const isCompiledGraph = (
+    graph: GraphLike,
+  ): graph is CompiledGraph<string> => {
+    if (typeof graph !== "object" || graph == null) return false;
+    return (
+      "builder" in graph &&
+      typeof graph.builder === "object" &&
+      graph.builder != null
+    );
+  };
+
   const graph: GraphUnknown = await import(sourceFile).then(
     (module) => module[exportSymbol || "default"],
   );
@@ -73,6 +84,15 @@ export async function resolveGraph(
 
       const afterResolve = (graphLike: GraphLike): CompiledGraph<string> => {
         const graph = isGraph(graphLike) ? graphLike.compile() : graphLike;
+
+        // TODO: hack, remove once LangChain 1.x createAgent is fixed
+        // LangGraph API will assign it's checkpointer by setting it
+        // via `graph.checkpointer = ...` and `graph.store = ...`, and the 1.x `createAgent`
+        // hides the underlying `StateGraph` instance, so we need to access it directly.
+        if (!isCompiledGraph(graph) && "graph" in graph) {
+          return (graph as { graph: CompiledGraph<string> }).graph;
+        }
+
         return graph;
       };