langgraph-api 0.8.4__tar.gz → 0.8.5__tar.gz

{langgraph_api-0.8.4 → langgraph_api-0.8.5}/Makefile

@@ -16,7 +16,6 @@ start-go-server: # NOTE: core server will start with sqlite if no DATABASE_URI i
 	DATABASE_URI= \
 	REDIS_URI= \
 	./bin/core-server \
-		-service core-api \
 		-apply-db-schema &
 	@sleep 2
 

{langgraph_api-0.8.4 → langgraph_api-0.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.8.4
+Version: 0.8.5
 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

langgraph_api-0.8.5/langgraph_api/__init__.py

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

{langgraph_api-0.8.4 → langgraph_api-0.8.5}/langgraph_api/cli.py

@@ -1,5 +1,4 @@
 import argparse
-import asyncio
 import contextlib
 import inspect
 import json
@@ -194,7 +193,6 @@ def run_server(
     __redis_uri__: str | None = "fake",
     __database_uri__: str | None = ":memory:",
     __migrations_path__: str | None = "__inmem",
-    __entrypoint__: Literal["server", "python-executor"] = "server",
     **kwargs: typing.Any,
 ):
     """Run the LangGraph API server."""
@@ -371,53 +369,40 @@ For production use, please use LangSmith Deployment.
             if k in inspect.signature(uvicorn.run).parameters
         }
         server_level = server_level.upper()
-        if __entrypoint__ == "server":
-            uvicorn.run(
-                "langgraph_api.server:app",
-                host=host,
-                port=port,
-                reload=reload,
-                env_file=env_file,
-                access_log=False,
-                reload_includes=list(reload_includes) if reload_includes else None,
-                reload_excludes=list(reload_excludes) if reload_excludes else None,
-                log_config={
-                    "version": 1,
-                    "incremental": False,
-                    "disable_existing_loggers": False,
-                    "formatters": {
-                        "simple": {
-                            "class": "langgraph_api.logging.Formatter",
-                        }
-                    },
-                    "handlers": {
-                        "console": {
-                            "class": "logging.StreamHandler",
-                            "formatter": "simple",
-                            "stream": "ext://sys.stdout",
-                        }
-                    },
-                    "loggers": {
-                        "uvicorn": {"level": server_level},
-                        "uvicorn.error": {"level": server_level},
-                        "langgraph_api.server": {"level": server_level},
-                    },
-                    "root": {"handlers": ["console"]},
+        uvicorn.run(
+            "langgraph_api.server:app",
+            host=host,
+            port=port,
+            reload=reload,
+            env_file=env_file,
+            access_log=False,
+            reload_includes=list(reload_includes) if reload_includes else None,
+            reload_excludes=list(reload_excludes) if reload_excludes else None,
+            log_config={
+                "version": 1,
+                "incremental": False,
+                "disable_existing_loggers": False,
+                "formatters": {
+                    "simple": {
+                        "class": "langgraph_api.logging.Formatter",
+                    }
                 },
-                **supported_kwargs,
-            )
-        elif __entrypoint__ == "python-executor":
-            from langgraph_api.executor_entrypoint import (  # noqa: PLC0415
-                main as executor_entrypoint_main,
-            )
-
-            asyncio.run(
-                executor_entrypoint_main(
-                    grpc_port=8188,
-                )
-            )
-        else:
-            raise ValueError(f"Unknown entrypoint: {__entrypoint__}")
+                "handlers": {
+                    "console": {
+                        "class": "logging.StreamHandler",
+                        "formatter": "simple",
+                        "stream": "ext://sys.stdout",
+                    }
+                },
+                "loggers": {
+                    "uvicorn": {"level": server_level},
+                    "uvicorn.error": {"level": server_level},
+                    "langgraph_api.server": {"level": server_level},
+                },
+                "root": {"handlers": ["console"]},
+            },
+            **supported_kwargs,
+        )
 
 
 def main():
@@ -464,13 +449,6 @@ def main():
         default="inmem",
         help="Runtime edition to use",
     )
-    parser.add_argument(
-        "--entrypoint",
-        type=str,
-        default="server",
-        choices=["server", "python-executor"],
-        help="Entry point to use",
-    )
     args = parser.parse_args()
 
     with open(args.config, encoding="utf-8") as f:
@@ -487,8 +465,6 @@ def main():
         kwargs["__redis_uri__"] = os.getenv("REDIS_URI")
         kwargs["__database_uri__"] = os.getenv("DATABASE_URI")
         kwargs["__migrations_path__"] = os.getenv("MIGRATIONS_PATH")
-    if args.entrypoint == "python-executor":
-        kwargs["__entrypoint__"] = "python-executor"
     run_server(
         args.host,
         args.port,

{langgraph_api-0.8.4 → langgraph_api-0.8.5}/langgraph_api/queue_entrypoint.py

@@ -199,7 +199,6 @@ async def health_and_metrics_server():
 
 
 async def entrypoint(
-    grpc_port: int | None = None,
     entrypoint_name: str = "python-queue",
     cancel_event: asyncio.Event | None = None,
 ):
@@ -215,7 +214,6 @@ async def entrypoint(
         functools.partial(
             lifespan.lifespan,
             with_cron_scheduler=False,
-            grpc_port=grpc_port,
             taskset=tasks,
             cancel_event=cancel_event,
         ),
@@ -249,7 +247,7 @@ async def entrypoint(
             await asyncio.sleep(3600)
 
 
-async def main(grpc_port: int | None = None, entrypoint_name: str = "python-queue"):
+async def main(entrypoint_name: str = "python-queue"):
     """Run the queue entrypoint and shut down gracefully on SIGTERM/SIGINT."""
 
     loop = asyncio.get_running_loop()
@@ -270,7 +268,6 @@ async def main(grpc_port: int | None = None, entrypoint_name: str = "python-queu
     # Start the queue entrypoint
     entry_task = asyncio.create_task(
         entrypoint(
-            grpc_port=grpc_port,
             entrypoint_name=entrypoint_name,
             cancel_event=cancel_event,
         )

langgraph_api-0.8.5/langgraph_grpc_common/conversion/__init__.py

@@ -0,0 +1,15 @@
+from langgraph_grpc_common.conversion import (
+    checkpoint,
+    config,
+    durability,
+    struct,
+    value,
+)
+
+__all__ = [
+    "checkpoint",
+    "config",
+    "durability",
+    "struct",
+    "value",
+]

{langgraph_api-0.8.4 → langgraph_api-0.8.5}/langgraph_grpc_common/conversion/value.py

@@ -5,7 +5,7 @@ from langgraph.types import Command, Send
 
 from langgraph_grpc_common import serde
 from langgraph_grpc_common.conversion._compat import MISSING, TASKS
-from langgraph_grpc_common.proto import engine_api_pb2, engine_common_pb2
+from langgraph_grpc_common.proto import engine_common_pb2
 
 
 def serialized_value_from_proto(value: engine_common_pb2.SerializedValue) -> Any:
@@ -207,19 +207,3 @@ def base_value_to_proto(value: Any) -> engine_common_pb2.ChannelValue:
     )
 
     return engine_common_pb2.ChannelValue(serialized_value=serialize_value_proto)
-
-
-def input_to_proto(value: Any) -> engine_api_pb2.RunInput | None:
-    """Convert a Python value to a RunInput proto.
-
-    Returns None if value is None (for resuming execution).
-    If the value is a Command, wraps it in RunInput with command field.
-    Otherwise, serializes it and wraps in RunInput with input field.
-    """
-    if value is None:
-        return None
-    elif isinstance(value, Command):
-        return engine_api_pb2.RunInput(command=command_to_proto(value))
-    else:
-        serialize_value_proto = any_to_serialized_value(value)
-        return engine_api_pb2.RunInput(input=serialize_value_proto)

{langgraph_api-0.8.4 → langgraph_api-0.8.5}/langgraph_grpc_common/proto/__init__.py

@@ -12,10 +12,6 @@ from . import enum_thread_status_pb2
 from . import enum_thread_stream_mode_pb2
 from . import core_api_pb2
 from . import core_api_pb2_grpc
-from . import executor_api_pb2
-from . import executor_api_pb2_grpc
-from . import engine_api_pb2
-from . import engine_api_pb2_grpc
 from . import engine_common_pb2
 from . import engine_common_pb2_grpc
 from . import checkpointer_pb2
@@ -28,10 +24,6 @@ from . import errors_pb2_grpc
 __all__ = [
     "core_api_pb2",
     "core_api_pb2_grpc",
-    "executor_api_pb2",
-    "executor_api_pb2_grpc",
-    "engine_api_pb2",
-    "engine_api_pb2_grpc",
     "engine_common_pb2",
     "engine_common_pb2_grpc",
     "checkpointer_pb2",

langgraph_api-0.8.4/langgraph_api/__init__.py

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

langgraph_api-0.8.4/langgraph_api/executor_entrypoint.py

@@ -1,31 +0,0 @@
-import argparse
-import asyncio
-import json
-import logging.config
-import pathlib
-
-from langgraph_api.queue_entrypoint import main as queue_main
-
-
-async def main(grpc_port: int = 50051):
-    with open(pathlib.Path(__file__).parent.parent / "logging.json") as file:
-        loaded_config = json.load(file)
-        logging.config.dictConfig(loaded_config)
-    try:
-        import uvloop  # noqa: PLC0415
-
-        uvloop.install()
-    except ImportError:
-        pass
-    from langgraph_api import config  # noqa: PLC0415
-
-    config.IS_EXECUTOR_ENTRYPOINT = True
-    await queue_main(grpc_port=grpc_port, entrypoint_name="python-executor")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument("--grpc-port", type=int, default=50051)
-    args = parser.parse_args()
-    asyncio.run(main(grpc_port=args.grpc_port))

langgraph_api-0.8.4/langgraph_grpc_common/conversion/__init__.py

@@ -1,33 +0,0 @@
-from langgraph_grpc_common.conversion import (
-    channel,
-    checkpoint,
-    config,
-    durability,
-    exception,
-    graph,
-    interrupt,
-    messages,
-    orchestrator_response,
-    runopts,
-    stream_mode,
-    struct,
-    task,
-    value,
-)
-
-__all__ = [
-    "channel",
-    "checkpoint",
-    "config",
-    "durability",
-    "exception",
-    "graph",
-    "interrupt",
-    "messages",
-    "orchestrator_response",
-    "runopts",
-    "stream_mode",
-    "struct",
-    "task",
-    "value",
-]

langgraph_api-0.8.4/langgraph_grpc_common/conversion/channel.py

@@ -1,159 +0,0 @@
-import logging
-from collections.abc import Mapping
-from typing import Any
-
-from langgraph.channels.any_value import AnyValue
-from langgraph.channels.base import BaseChannel, EmptyChannelError
-from langgraph.channels.binop import BinaryOperatorAggregate
-from langgraph.channels.ephemeral_value import EphemeralValue
-from langgraph.channels.last_value import LastValue, LastValueAfterFinish
-from langgraph.channels.named_barrier_value import (
-    NamedBarrierValue,
-    NamedBarrierValueAfterFinish,
-)
-from langgraph.channels.topic import Topic
-from langgraph.channels.untracked_value import UntrackedValue
-from langgraph.managed.base import (
-    ManagedValue,
-    ManagedValueMapping,
-    ManagedValueSpec,
-    is_managed_value,
-)
-from langgraph.pregel import Pregel
-
-from langgraph_grpc_common.conversion._compat import MISSING
-from langgraph_grpc_common.conversion.exception import UserCodeExecutionErrorException
-from langgraph_grpc_common.conversion.value import value_from_proto, value_to_proto
-from langgraph_grpc_common.proto import engine_common_pb2, executor_api_pb2
-
-logger = logging.getLogger(__name__)
-
-
-def channel_to_proto(name: str, channel: BaseChannel) -> engine_common_pb2.Channel:
-    try:
-        get_result = channel.get()
-    except EmptyChannelError:
-        get_result = MISSING
-
-    return engine_common_pb2.Channel(
-        get_result=value_to_proto(name, get_result),
-        is_available_result=channel.is_available(),
-        checkpoint_result=value_to_proto(name, channel.checkpoint()),
-    )
-
-
-def channels_to_proto(
-    channels: Mapping[str, ManagedValueSpec | BaseChannel | type[ManagedValue]],
-) -> engine_common_pb2.Channels:
-    pb = {}
-    for name, channel in channels.items():
-        if isinstance(channel, BaseChannel):
-            pb[name] = channel_to_proto(name, channel)
-        else:
-            logger.warning(
-                "Unrecognized channel value: %s | %s", type(channel), channel
-            )
-    return engine_common_pb2.Channels(channels=pb)
-
-
-def channels_specs_to_proto(
-    channels: Mapping[str, ManagedValueSpec | BaseChannel | type[ManagedValue]],
-) -> dict[str, executor_api_pb2.ChannelSpec]:
-    """Get static channel specs (kind, params) from graph channels. ChannelSpecs is a simple message and by passing it back it lets us avoid deserializing blobs in Go runtime."""
-    specs: dict[str, executor_api_pb2.ChannelSpec] = {}
-    for name, ch in channels.items():
-        kind: executor_api_pb2.ChannelSpec.Kind.ValueType
-        params = executor_api_pb2.ChannelParams()
-
-        if is_managed_value(ch):
-            kind = executor_api_pb2.ChannelSpec.MANAGED_VALUE
-        elif isinstance(ch, LastValue):
-            kind = executor_api_pb2.ChannelSpec.LAST_VALUE
-            params.initial_value.CopyFrom(value_to_proto(name, ch.value))
-        elif isinstance(ch, AnyValue):
-            kind = executor_api_pb2.ChannelSpec.ANY_VALUE
-            params.initial_value.CopyFrom(value_to_proto(name, ch.value))
-        elif isinstance(ch, EphemeralValue):
-            kind = executor_api_pb2.ChannelSpec.EPHEMERAL_VALUE
-            params.guard = ch.guard
-            params.initial_value.CopyFrom(value_to_proto(name, ch.value))
-        elif isinstance(ch, UntrackedValue):  # special case
-            kind = executor_api_pb2.ChannelSpec.UNTRACKED_VALUE
-            params.guard = ch.guard
-            params.initial_value.CopyFrom(value_to_proto(name, ch.value))
-        elif isinstance(ch, BinaryOperatorAggregate):
-            kind = executor_api_pb2.ChannelSpec.BINARY_OPERATOR_AGGREGATE
-            params.initial_value.CopyFrom(value_to_proto(name, ch.value))
-        elif isinstance(ch, Topic):
-            kind = executor_api_pb2.ChannelSpec.TOPIC
-            params.accumulate = ch.accumulate
-            params.initial_value.CopyFrom(value_to_proto(name, ch.values))
-        elif isinstance(ch, NamedBarrierValue):
-            kind = executor_api_pb2.ChannelSpec.NAMED_BARRIER_VALUE
-            params.names.extend(list(ch.names))
-            params.initial_value.CopyFrom(value_to_proto(name, list(ch.seen)))
-        elif isinstance(ch, LastValueAfterFinish):
-            kind = executor_api_pb2.ChannelSpec.LAST_VALUE_AFTER_FINISH
-            params.initial_value.CopyFrom(value_to_proto(name, ch.value))
-        elif isinstance(ch, NamedBarrierValueAfterFinish):
-            kind = executor_api_pb2.ChannelSpec.NAMED_BARRIER_VALUE_AFTER_FINISH
-            params.names.extend(list(ch.names))
-            params.initial_value.CopyFrom(
-                value_to_proto(name, [list(ch.seen), ch.finished])
-            )
-        else:
-            kind = executor_api_pb2.ChannelSpec.UNKNOWN
-
-        spec = executor_api_pb2.ChannelSpec(kind=kind, params=params)
-        specs[name] = spec
-
-    return specs
-
-
-def channels_from_proto(
-    channels_pb: dict[str, engine_common_pb2.Channel] | Any,
-    graph: Pregel,
-    *,
-    clear_after_read: bool = False,
-) -> tuple[dict[str, BaseChannel], ManagedValueMapping]:
-    """Convert proto channels to Python channel objects.
-
-    Args:
-        channels_pb: Proto channel map from the request.
-        graph: The Pregel graph containing channel definitions.
-        clear_after_read: If True, clear each channel proto after conversion
-            to free memory incrementally. This is useful when channels contain
-            large data to avoid holding both serialized and deserialized forms
-            in memory simultaneously.
-
-    Returns:
-        Tuple of (channels dict, managed values dict).
-    """
-    channels = {}
-    managed = {}
-    for k, channel_pb in channels_pb.items():
-        if k not in graph.channels:
-            raise UserCodeExecutionErrorException(
-                ValueError(f"Channel '{k}' not found in graph definition"),
-                node_name=None,
-            )
-        v = graph.channels[k]
-        if isinstance(v, BaseChannel):
-            channels[k] = revive_channel(v, channel_pb)
-        elif is_managed_value(v):  # managed values
-            managed[k] = v
-        else:
-            raise NotImplementedError(f"Unrecognized channel value: {type(v)} | {v}")
-
-        if clear_after_read:
-            channel_pb.Clear()
-
-    return channels, managed
-
-
-def revive_channel(
-    channel: BaseChannel, channel_pb: engine_common_pb2.Channel
-) -> BaseChannel:
-    val_pb = channel_pb.checkpoint_result
-    val = MISSING if val_pb.WhichOneof("val") is None else value_from_proto(val_pb)
-    return channel.copy().from_checkpoint(val)

langgraph_api-0.8.4/langgraph_grpc_common/conversion/exception.py

@@ -1,95 +0,0 @@
-import traceback
-
-from langgraph.errors import GraphInterrupt, GraphRecursionError, ParentCommand
-from langgraph.types import Interrupt
-
-from langgraph_grpc_common import serde
-from langgraph_grpc_common.conversion.value import (
-    any_to_serialized_value,
-    command_to_proto,
-)
-from langgraph_grpc_common.proto import engine_common_pb2, errors_pb2
-
-
-class ExecutorDependencyError(Exception):
-    """Exception wrapper for executor dependency failures (e.g., RemoteCheckpointer gRPC calls).
-
-    Distinguishes dependency/infrastructure failures from user code execution errors
-    and from other executor-internal errors. Tagged as "executor_dependency_internal" in gRPC
-    trailing metadata.
-    """
-
-    def __init__(self, original_exception: Exception, context: str | None = None):
-        self.original_exception = original_exception
-        self.context = context
-        super().__init__(str(original_exception))
-
-
-class UserCodeExecutionErrorException(Exception):
-    """Exception wrapper for user code execution errors that need explicit marking.
-
-    This exception is used to explicitly mark certain errors as user code errors
-    (e.g., context schema validation errors) so they are checked and returned as
-    UserCodeExecutionError to the client via grpc, not treated as internal errors.
-
-    Note that we can't use UserCodeExecutionError which is protobuf message instead of Exception.
-    """
-
-    def __init__(self, original_exception: Exception, node_name: str | None = None):
-        self.original_exception = original_exception
-        self.node_name = node_name
-        super().__init__(str(original_exception))
-
-
-def exception_to_proto(
-    exc: Exception,
-) -> (
-    errors_pb2.UserCodeExecutionError
-    | engine_common_pb2.WrappedInterrupts
-    | engine_common_pb2.ParentCommand
-    | errors_pb2.GraphRecursionLimitError
-):
-    if isinstance(exc, GraphInterrupt):
-        if exc.args[0]:
-            # Serialize the list of Interrupts
-            encoding, ser = serde.get_serializer().dumps_typed(exc.args[0])
-            serialized_interrupts = engine_common_pb2.SerializedValue(
-                encoding=encoding, value=ser
-            )
-            interrupts = interrupts_to_proto(exc.args[0])
-            return engine_common_pb2.WrappedInterrupts(
-                interrupts=interrupts, serialized_interrupts=serialized_interrupts
-            )
-        else:
-            # Static interrupt (interrupt_before or interrupt_after)
-            return engine_common_pb2.WrappedInterrupts(
-                interrupts=[engine_common_pb2.Interrupt()]
-            )
-    elif isinstance(exc, ParentCommand):
-        cmd = exc.args[0]
-        return engine_common_pb2.ParentCommand(command=command_to_proto(cmd))
-    elif isinstance(exc, GraphRecursionError):
-        return errors_pb2.GraphRecursionLimitError()
-    elif isinstance(exc, ExecutorDependencyError):
-        # Internal executor errors (e.g., gRPC failures from RemoteCheckpointer)
-        # should be re-raised to be handled as internal errors, not user code errors
-        raise
-    else:
-        # All other exceptions (including InternalUserCodeExecutionError) are user code errors
-        return errors_pb2.UserCodeExecutionError(
-            error_type=exc.__class__.__name__,
-            error_message=str(exc),
-            traceback=traceback.format_exc(),
-        )
-
-
-def interrupts_to_proto(
-    interrupts: tuple[Interrupt],
-) -> list[engine_common_pb2.Interrupt]:
-    return [
-        engine_common_pb2.Interrupt(
-            value=any_to_serialized_value(interrupt.value),
-            id=interrupt.id,
-        )
-        for interrupt in interrupts
-    ]